language-reader/reading.qx

fragment {
  import "events.qx";




  import interface ApplicationEntry;
  import interface ReadingServices;
  import interface ReadingOwner; import interface LanguageReader; import interface ReadingReader; import interface ReadingDocument; import interface ReadingFeature; import interface ReadingJob; import interface ReadingRequest; import interface ReadingWord; import interface AgentDocumentation;
  import interface ReadingVocabulary;
  atom ReadingVocabularyObject id "atom:reading:vocabulary";
  import package LanguageReaderRuntime; import package LanguageReaderPresentation;
  atom ReadingReaderObject id "atom:reading:reader"; atom ReadingLibrary id "atom:reading:library"; atom ReadingDocumentObject id "atom:reading:document"; atom ReadingFeatureObject id "atom:reading:feature"; atom ReadingJobObject id "atom:reading:job"; atom ReadingWordObject id "atom:reading:word"; atom ReadingSubscription id "atom:reading:subscription";
  conform ReadingSubscription as EventSubscriptionRecord<AgentCompletion,unit> id "reading:completion-subscription" {}
  conform ReadingReaderObject as ReadingReader id "reading:reader" {
    private edge ReaderVocabulary id "reading:reader:vocabulary:edge" {atom Self projection vocabulary id "reading:reader:vocabulary:target" optional-one on-delete "detach" public-traversal;interface ReadingVocabulary projection readers id "reading:vocabulary:readers" many-unique on-delete "detach";}
    bind vocabulary.resolve to edge ReaderVocabulary.vocabulary.resolve;
    bind vocabulary.connect to package LanguageReaderRuntime.attachVocabulary with {library to edge ReaderLibrary.library;vocabulary to edge ReaderVocabulary.vocabulary;target to interface ReadingVocabulary from input;};
    bind remove.call to lifecycle.delete;
    private state ReaderPalette id "reading:state:ReaderPalette" on Self : record {text:string;accent:string;} policy register default {"text":"#252923","accent":"#39745b"};
    bind palette.get to state ReaderPalette.read;bind palette.set to state ReaderPalette.write;
    private state ReaderData id "reading:state:ReaderData" on Self : record {name:string;size:uint32;width:uint32;font:string;background:string;configRevision:uint32;} policy register;
    private edge ReaderLibrary id "reading:edge:ReaderLibrary" {atom Self projection library id "reading:projection:ReaderLibrary:library" exactly-one on-delete "detach" public-traversal; interface LanguageReader projection readers id "reading:projection:ReaderLibrary:readers" many-unique on-delete "detach" public-traversal;}
    initialize {palette to state ReaderPalette;data to state ReaderData;library to edge ReaderLibrary.library;};bind data.get to state ReaderData.read;bind library.resolve to edge ReaderLibrary.library.resolve;bind features.resolve to edge FeatureReader.features.resolve;
    bind configure.call to package LanguageReaderRuntime.configureReader with {data to state ReaderData;};
    bind documents.resolve to edge DocumentReader.documents.resolve;
  }
  conform ReadingReaderObject as AgentContextSubject id "reading:reader:context" {}
  conform ReadingReaderObject as AgentDocumentation id "reading:reader:guide" {bind guide.get to package LanguageReaderRuntime.guide with {};}
  conform ReadingLibrary as LanguageReader id "reading:library" {
    private edge DefaultVocabulary id "reading:library:default-vocabulary:edge" {atom Self projection vocabulary id "reading:library:default-vocabulary:target" optional-one on-delete "detach" public-traversal;interface ReadingVocabulary projection defaults id "reading:vocabulary:defaults" many-unique on-delete "detach";}
    bind defaultVocabulary.resolve to edge DefaultVocabulary.vocabulary.resolve;bind vocabularies.resolve to edge VocabularyLibrary.vocabularies.resolve;
    bind addVocabulary.call to package LanguageReaderRuntime.addVocabulary with {vocabulary to creation ReadingVocabularyObject with {ReadingVocabulary from input;};};
    bind ensureVocabulary.call to package LanguageReaderRuntime.ensureVocabulary with {default_vocabulary to edge DefaultVocabulary.vocabulary;vocabulary to creation ReadingVocabularyObject with {ReadingVocabulary from input;};home to interface LanguageReader from input;word to interface ReadingWord from input;};
    private edge DefaultReader id "reading:edge:DefaultReader" {atom Self projection defaultReader id "reading:projection:DefaultReader:reader" optional-one on-delete "detach" public-traversal; interface ReadingReader projection defaults id "reading:projection:DefaultReader:defaults" many-unique on-delete "detach" public-traversal;}
    bind readers.resolve to edge ReaderLibrary.readers.resolve;bind defaultReader.resolve to edge DefaultReader.defaultReader.resolve;
    bind ensureReaders.call to package LanguageReaderRuntime.ensureReaders with {default_reader to edge DefaultReader.defaultReader;home to interface LanguageReader from input;feature to interface ReadingFeature from input;document to interface ReadingDocument from input;reader to creation ReadingReaderObject with {ReadingReader from input;};};
    bind addFrenchReader.call to package LanguageReaderRuntime.addFrenchReader with {reader to creation ReadingReaderObject with {ReadingReader from input;};feature to creation ReadingFeatureObject with {ReadingFeature from input;};document to creation ReadingDocumentObject with {ReadingDocument from input;};};
    bind generateDocument.call to package LanguageReaderRuntime.generateDocument with {inference to edge ReaderInference.inference;target_reader to interface ReadingReader from input;agent to interface Agent from input;job to creation ReadingJobObject with {ReadingJob from input;};job_api to interface ReadingJob from input;};
    bind addReader.call to package LanguageReaderRuntime.addReader with {source to interface ReadingReader from input;reader_api to interface ReadingReader from input;feature to interface ReadingFeature from input;reader to creation ReadingReaderObject with {ReadingReader from input;};feature_copy to creation ReadingFeatureObject with {ReadingFeature from input;};};
    private state InferenceProfile id "reading:state:InferenceProfile" on Self : string policy register default "quick-fast";
    bind inferenceProfile.get to state InferenceProfile.read;
    bind inferenceProfile.set to package LanguageReaderRuntime.setInferenceProfile with {profile to state InferenceProfile;};
    private state ArchivedTypes id "reading:state:ArchivedTypes" on Self : list<string> policy register default [];
    bind archivedTypes.get to state ArchivedTypes.read;
    bind archiveType.call to package LanguageReaderRuntime.archiveType with {archives to state ArchivedTypes;};
    bind catalog.call to package LanguageReaderRuntime.catalog with {};
    private edge ReaderCanvas id "reading:edge:ReaderCanvas" { atom Self projection canvas id "reading:projection:ReaderCanvas:canvas" exactly-one on-delete "detach" public-traversal ; atom Canvas projection readers id "reading:projection:ReaderCanvas:readers" many-unique on-delete "detach" public-traversal; }
    private state LibraryName id "reading:state:LibraryName" on Self : string policy register;

    private edge ReaderDirectory id "reading:edge:ReaderDirectory" { atom Self projection directory id "reading:projection:ReaderDirectory:directory" optional-one on-delete "detach" public-traversal ; atom AgentDirectoryObject projection readers id "reading:projection:ReaderDirectory:readers" many-unique on-delete "detach" public-traversal; }
    private edge ReaderInference id "reading:edge:ReaderInference" { atom Self projection inference id "reading:projection:ReaderInference:inference" optional-one on-delete "detach" public-traversal ; atom AgentObject projection readingInferences id "reading:projection:ReaderInference:readingInferences" many-unique on-delete "detach" public-traversal; }
    private edge ReaderAuthor id "reading:edge:ReaderAuthor" { atom Self projection author id "reading:projection:ReaderAuthor:author" optional-one on-delete "detach" public-traversal ; atom AgentObject projection readingAuthors id "reading:projection:ReaderAuthor:readingAuthors" many-unique on-delete "detach" public-traversal; }
    private edge ReaderSubscriptions id "reading:edge:ReaderSubscriptions" { atom Self projection subscriptions id "reading:projection:ReaderSubscriptions:subscriptions" many-unique on-delete "detach" public-traversal ; interface EventSubscription<AgentCompletion,unit> projection readers id "reading:projection:ReaderSubscriptions:readers" many-unique on-delete "detach" public-traversal; }
    initialize {name to state LibraryName;canvas to edge ReaderCanvas.canvas;directory to edge ReaderDirectory.directory;};
    bind name.get to state LibraryName.read;bind inference.resolve to edge ReaderInference.inference.resolve;bind author.resolve to edge ReaderAuthor.author.resolve;
    bind documents.resolve to edge DocumentLibrary.documents.resolve;bind features.resolve to edge FeatureLibrary.features.resolve;bind vocabulary.resolve to edge WordLibrary.vocabulary.resolve;bind tasks.resolve to edge JobLibrary.tasks.resolve;
    bind installWorkspace.call to package LanguageReaderRuntime.workspaceInstall with {canvas to edge ReaderCanvas.canvas;agent_workspace to interface AgentWorkspace from input;};
    bind root.call to package LanguageReaderRuntime.createRoot with {canvas to creation Canvas with {WebStudioCanvas from input;};agent_workspace to interface AgentWorkspace from input;library to creation ReadingLibrary with {LanguageReader from input;};reader to interface LanguageReader from input;};
    bind install.call to package LanguageReaderRuntime.install with {directory to edge ReaderDirectory.directory;inference to edge ReaderInference.inference;author to edge ReaderAuthor.author;subscriptions to edge ReaderSubscriptions.subscriptions;agents to interface AgentDirectory from input;agent to interface Agent from input;subscription to creation ReadingSubscription with {};delivery to interface EventSubscription<AgentCompletion,unit> from input;feature to creation ReadingFeatureObject with {ReadingFeature from input;};document to creation ReadingDocumentObject with {ReadingDocument from input;};home to interface LanguageReader from input;};
    bind addDocument.call to package LanguageReaderRuntime.addDocument with {home to interface LanguageReader from input;document to creation ReadingDocumentObject with {ReadingDocument from input;};};
    bind addFeature.call to package LanguageReaderRuntime.addFeature with {authoring to interface ReadingJob from input;home to interface LanguageReader from input;reader to interface ReadingReader from input;feature to creation ReadingFeatureObject with {ReadingFeature from input;};};
    bind remember.call to package LanguageReaderRuntime.remember with {home to interface LanguageReader from input;vocabulary to interface ReadingVocabulary from input;};
    bind customize.call to package LanguageReaderRuntime.customize with {feature to interface ReadingFeature from input;reader to interface ReadingReader from input;author to edge ReaderAuthor.author;agent to interface Agent from input;job to creation ReadingJobObject with {ReadingJob from input;};job_api to interface ReadingJob from input;};
  }
  conform ReadingLibrary as AgentWorkspace id "reading:workspace-agent" {bind agents.resolve to edge ReaderDirectory.directory.resolve; bind install.call to interface LanguageReader.installWorkspace.call;}
  conform ReadingLibrary as EventHandler<AgentCompletion,unit> id "reading:completion-handler" {bind handle.call to package LanguageReaderRuntime.completion with {request to interface ReadingRequest from input;job to interface ReadingJob from input;};}
  conform ReadingDocumentObject as ReadingDocument id "reading:document" {
    private edge DocumentResults id "reading:edge:DocumentResults" {atom Self projection results id "reading:projection:DocumentResults:results" many on-delete "detach" keyed "string" public-traversal;interface ReadingJob projection cachedBy id "reading:projection:DocumentResults:owners" many on-delete "detach";}
    private edge DocumentAttempts id "reading:edge:DocumentAttempts" {atom Self projection attempts id "reading:projection:DocumentAttempts:attempts" many on-delete "detach" keyed "string";interface ReadingJob projection attemptedBy id "reading:projection:DocumentAttempts:owners" many on-delete "detach";}
    bind results.resolve to edge DocumentResults.results.resolve;
    bind recordResult.call to package LanguageReaderRuntime.recordResult with {data to state DocumentData;results to edge DocumentResults.results;job to interface ReadingJob from input;};
    private state Archived id "reading:state:DocumentArchived" on Self : bool policy register default false;
    bind archived.get to state Archived.read;bind archived.set to state Archived.write;
    private state Variant id "reading:state:Variant" on Self : string policy register default "{}";
    private edge DocumentReader id "reading:edge:DocumentReader" {atom Self projection reader id "reading:projection:DocumentReader:reader" optional-one on-delete "detach" public-traversal;interface ReadingReader projection documents id "reading:projection:DocumentReader:documents" many-unique on-delete "detach" public-traversal;}
    private edge DocumentCanonical id "reading:edge:DocumentCanonical" {atom Self projection canonical id "reading:projection:DocumentCanonical:canonical" optional-one on-delete "detach" public-traversal;interface ReadingDocument projection variants id "reading:projection:DocumentCanonical:variants" many-unique on-delete "detach" public-traversal;}
    bind reader.resolve to edge DocumentReader.reader.resolve;bind reader.connect to package LanguageReaderRuntime.attachReader with {library to edge DocumentLibrary.library;reader to edge DocumentReader.reader;target_reader to interface ReadingReader from input;};bind canonical.resolve to edge DocumentCanonical.canonical.resolve;bind adaptation.get to state Variant.read;
    bind prepareVariant.call to package LanguageReaderRuntime.prepareVariant with {data to state DocumentData;adaptation to state Variant;library to edge DocumentLibrary.library;home to interface LanguageReader from input;agent to interface Agent from input;jobs to interface ReadingDocument from input;old to interface ReadingJob from input;job to creation ReadingJobObject with {ReadingJob from input;};job_api to interface ReadingJob from input;};
    bind applyVariant.call to package LanguageReaderRuntime.applyVariant with {data to state DocumentData;adaptation to state Variant;};
    private state DocumentData id "reading:state:DocumentData" on Self : record {title:string;text:string;sourceRevision:string;source:string;url:string;attribution:string;} policy register;
    private edge DocumentLibrary id "reading:edge:DocumentLibrary" { atom Self projection library id "reading:projection:DocumentLibrary:library" exactly-one on-delete "detach" public-traversal ; interface LanguageReader projection documents id "reading:projection:DocumentLibrary:documents" many-unique on-delete "detach" public-traversal; }
    initialize {reader to edge DocumentReader.reader;canonical to edge DocumentCanonical.canonical;adaptation to state Variant;data to state DocumentData;library to edge DocumentLibrary.library;};bind data.get to state DocumentData.read;bind library.resolve to edge DocumentLibrary.library.resolve;bind jobs.resolve to edge JobDocument.jobs.resolve;bind remove.call to lifecycle.delete;
    bind plan.call to package LanguageReaderRuntime.plan with {data to state DocumentData;library to edge DocumentLibrary.library;feature to interface ReadingFeature from input;};
    bind generate.call to package LanguageReaderRuntime.generate with {results to edge DocumentResults.results;attempts to edge DocumentAttempts.attempts;data to state DocumentData;library to edge DocumentLibrary.library;jobs to interface ReadingDocument from input;feature to interface ReadingFeature from input;home to interface LanguageReader from input;agent to interface Agent from input;old to interface ReadingJob from input;job to creation ReadingJobObject with {ReadingJob from input;};job_api to interface ReadingJob from input;};
    bind rewrite.call to package LanguageReaderRuntime.rewrite with {data to state DocumentData;library to edge DocumentLibrary.library;reader to edge DocumentReader.reader;document_result to creation ReadingDocumentObject with {ReadingDocument from input;};};
  }
  conform ReadingFeatureObject as ReadingFeature id "reading:feature" {
    private edge FeatureAuthoring id "reading:edge:FeatureAuthoring" {atom Self projection authoring id "reading:projection:FeatureAuthoring:authoring" optional-one on-delete "detach" public-traversal;atom ReadingJobObject projection createdFeatures id "reading:projection:FeatureAuthoring:features" many-unique on-delete "detach" public-traversal;}
    bind authoring.resolve to edge FeatureAuthoring.authoring.resolve;bind authoring.connect to package LanguageReaderRuntime.attachAuthoring with {authoring to edge FeatureAuthoring.authoring;library to edge FeatureLibrary.library;reader to edge FeatureReader.reader;job to interface ReadingJob from input;};
    bind setEnabled.call to package LanguageReaderRuntime.setEnabled with {data to state FeatureData;};
    private edge FeatureReader id "reading:edge:FeatureReader" {atom Self projection reader id "reading:projection:FeatureReader:reader" optional-one on-delete "detach" public-traversal;interface ReadingReader projection features id "reading:projection:FeatureReader:features" many-unique on-delete "detach" public-traversal;}
    bind reader.resolve to edge FeatureReader.reader.resolve;bind reader.connect to edge FeatureReader.reader.connect;
    private state FeatureData id "reading:state:FeatureData" on Self : record {name:string;processor:string;style:string;reveal:string;generation:string;scope:string;color:string;enabled:bool;configRevision:uint32;} policy register;
    private edge FeatureLibrary id "reading:edge:FeatureLibrary" { atom Self projection library id "reading:projection:FeatureLibrary:library" exactly-one on-delete "detach" public-traversal ; interface LanguageReader projection features id "reading:projection:FeatureLibrary:features" many-unique on-delete "detach" public-traversal; }
    initialize {authoring to edge FeatureAuthoring.authoring;reader to edge FeatureReader.reader;data to state FeatureData;library to edge FeatureLibrary.library;options to state Options;};bind data.get to state FeatureData.read;bind library.resolve to edge FeatureLibrary.library.resolve;bind remove.call to lifecycle.delete;
    private state Options id "reading:state:FeatureOptions" on Self : string policy register default "{}";
    bind options.get to state Options.read;
    bind configureOptions.call to package LanguageReaderRuntime.configureOptions with {data to state FeatureData;options to state Options;};
    bind processorRevision.get to package LanguageReaderRuntime.processorRevision with {data to state FeatureData;};
    bind configure.call to package LanguageReaderRuntime.configure with {data to state FeatureData;};
  }
  conform ReadingVocabularyObject as ReadingVocabulary id "reading:vocabulary" {
    private state VocabularyDraft id "reading:vocabulary:draft" on Self : record {word:string;} policy crdt(record {word:string;}) default {"word":""};
    bind draft.get to state VocabularyDraft.read;bind draft.edit to state VocabularyDraft.edit;
    private state VocabularyName id "reading:vocabulary:name" on Self : string policy register;
    private edge VocabularyLibrary id "reading:vocabulary:library:edge" {atom Self projection library id "reading:vocabulary:library:target" exactly-one on-delete "detach" public-traversal;interface LanguageReader projection vocabularies id "reading:library:vocabularies" many-unique on-delete "detach" public-traversal;}
    initialize {name to state VocabularyName;library to edge VocabularyLibrary.library;};bind name.get to state VocabularyName.read;
    bind name.set to package LanguageReaderRuntime.renameVocabulary with {name to state VocabularyName;};bind library.resolve to edge VocabularyLibrary.library.resolve;
    bind words.resolve to edge WordVocabulary.words.resolve;
    bind remember.call to package LanguageReaderRuntime.vocabularyRemember with {library to edge VocabularyLibrary.library;words to interface ReadingVocabulary from input;word_api to interface ReadingWord from input;word to creation ReadingWordObject with {ReadingWord from input;};};
  }
  conform ReadingVocabularyObject as AgentDocumentation id "reading:vocabulary:guide" {bind guide.get to package LanguageReaderRuntime.guide with {};}
  conform ReadingVocabularyObject as StandaloneView<interface ReadingVocabulary> id "reading:vocabulary:view" {bind render to LanguageReaderPresentation.Vocabulary;}
  conform ReadingWordObject as ReadingWord id "reading:word" {
    private edge WordVocabulary id "reading:word:vocabulary:edge" {atom Self projection vocabulary id "reading:word:vocabulary:target" optional-one on-delete "detach" public-traversal;interface ReadingVocabulary projection words id "reading:vocabulary:words" many-unique on-delete "detach" public-traversal;}
    bind vocabulary.resolve to edge WordVocabulary.vocabulary.resolve;
    bind vocabulary.connect to package LanguageReaderRuntime.attachVocabulary with {library to edge WordLibrary.library;vocabulary to edge WordVocabulary.vocabulary;target to interface ReadingVocabulary from input;};
    private edge WordLibrary id "reading:edge:WordLibrary" { atom Self projection library id "reading:projection:WordLibrary:library" exactly-one on-delete "detach" public-traversal ; interface LanguageReader projection vocabulary id "reading:projection:WordLibrary:vocabulary" many-unique on-delete "detach" public-traversal; }
    private state WordText id "reading:state:WordText" on Self : string policy register;

    initialize {text to state WordText;library to edge WordLibrary.library;};bind text.get to state WordText.read;bind forget.call to lifecycle.delete;
  }
  conform ReadingJobObject as ReadingJob id "reading:job" {
    private state Configuration id "reading:state:Configuration" on Self : string policy register default "";
    private edge JobReader id "reading:edge:JobReader" {atom Self projection reader id "reading:projection:JobReader:reader" optional-one on-delete "detach" public-traversal;interface ReadingReader projection tasks id "reading:projection:JobReader:tasks" many-unique on-delete "detach" public-traversal;}
    bind library.resolve to edge JobLibrary.library.resolve;bind reader.resolve to edge JobReader.reader.resolve;bind configuration.get to state Configuration.read;
    private edge JobDocument id "reading:edge:JobDocument" { atom Self projection document id "reading:projection:JobDocument:document" optional-one on-delete "detach" public-traversal ; interface ReadingDocument projection jobs id "reading:projection:JobDocument:jobs" many-unique on-delete "detach" public-traversal; }
    private state JobData id "reading:state:JobData" on Self : record {key:string;kind:string;featureRevision:uint32;sourceRevision:string;start:uint32;end:uint32;status:string;output:string;error:string;createdAt:string;} policy register;
    private edge JobLibrary id "reading:edge:JobLibrary" { atom Self projection library id "reading:projection:JobLibrary:library" exactly-one on-delete "detach" public-traversal ; interface LanguageReader projection tasks id "reading:projection:JobLibrary:tasks" many-unique on-delete "detach" public-traversal; }

    private edge JobFeature id "reading:edge:JobFeature" { atom Self projection feature id "reading:projection:JobFeature:feature" optional-one on-delete "detach" public-traversal ; interface ReadingFeature projection jobs id "reading:projection:JobFeature:jobs" many-unique on-delete "detach" public-traversal; }
    private edge JobRequest id "reading:edge:JobRequest" { atom Self projection request id "reading:projection:JobRequest:request" optional-one on-delete "detach" public-traversal ; atom AgentRequestObject projection readingJob id "reading:projection:JobRequest:readingJob" optional-one on-delete "detach" public-traversal; }
    private edge JobThread id "reading:edge:JobThread" { atom Self projection thread id "reading:projection:JobThread:thread" optional-one on-delete "detach" public-traversal ; atom AgentThreadObject projection readingJobs id "reading:projection:JobThread:readingJobs" many-unique on-delete "detach" public-traversal; }
    initialize {reader to edge JobReader.reader;configuration to state Configuration;data to state JobData;library to edge JobLibrary.library;document to edge JobDocument.document;feature to edge JobFeature.feature;};bind data.get to state JobData.read;bind document.resolve to edge JobDocument.document.resolve;bind feature.resolve to edge JobFeature.feature.resolve;bind request.resolve to edge JobRequest.request.resolve;bind thread.resolve to edge JobThread.thread.resolve;
    bind admitted.call to package LanguageReaderRuntime.admitted with {data to state JobData;request to edge JobRequest.request;thread to edge JobThread.thread;};
    bind complete.call to package LanguageReaderRuntime.complete with {configuration to state Configuration;reader to edge JobReader.reader;data to state JobData;request to edge JobRequest.request;document to edge JobDocument.document;feature to edge JobFeature.feature;library to edge JobLibrary.library;request_api to interface AgentRequest from input;document_api to interface ReadingDocument from input;feature_api to interface ReadingFeature from input;home to interface LanguageReader from input;document_result to creation ReadingDocumentObject with {ReadingDocument from input;};};
  }
  conform AgentRequestObject as ReadingRequest id "reading:request-job" {bind job.resolve to edge JobRequest.readingJob.resolve;}
  conform ReadingLibrary as AgentContextSubject id "reading:library:context" {}
  conform ReadingDocumentObject as AgentContextSubject id "reading:document:context" {}
  conform ReadingFeatureObject as AgentContextSubject id "reading:feature:context" {}
  conform ReadingLibrary as AgentDocumentation id "reading:library:guide" {bind guide.get to package LanguageReaderRuntime.guide with {};}
  conform ReadingDocumentObject as AgentDocumentation id "reading:document:guide" {bind guide.get to package LanguageReaderRuntime.guide with {};}
  conform ReadingFeatureObject as AgentDocumentation id "reading:feature:guide" {bind guide.get to package LanguageReaderRuntime.guide with {};}
  conform ReadingLibrary as ReadingOwner id "reading:owner" {}
  conform ReadingLibrary as ApplicationEntry id "reading:application" {}
  conform ReadingLibrary as ReadingServices id "reading:services" {
    private state SpeechSettings id "reading:speech:settings" on Self : record {key:string;voice:string;} policy register default {"key":"","voice":"JBFqnCBsd6RMkjVDRZzb"};
    bind speechStatus.call to package LanguageReaderRuntime.speechStatus with {settings to state SpeechSettings;};
    bind configureSpeech.call to package LanguageReaderRuntime.configureSpeech with {settings to state SpeechSettings;};
    bind speak.call to package LanguageReaderRuntime.speak with {settings to state SpeechSettings;};
    bind searchWikipedia.call to package LanguageReaderRuntime.searchWikipedia with {};
    bind readWikipedia.call to package LanguageReaderRuntime.readWikipedia with {};
  }
  conform ReadingLibrary as WebStudioPlaceable id "reading:placeable" {
    bind canPresent.call to package WebStudioCanvasRuntime.canPresent<atom ReadingLibrary> with {catalog to workspace reflection [presentations];};
    bind placements.resolve to edge PlacementSubject.placements.resolve;
  }
  conform ReadingLibrary as WebStudioPresentable id "reading:presentable" {bind canPresent.call to interface WebStudioPlaceable.canPresent.call;}
  conform ReadingLibrary as ReactComponent<interface LanguageReader,interface ReadingNavigation> id "reading:view" {bind render to LanguageReaderPresentation.Reader;}
  presentation Reading id "presentation:reading:library" for LanguageReader using LanguageReaderPresentation.Reader;
}