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 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 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 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 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 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;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 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 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 id "reading:view" {bind render to LanguageReaderPresentation.Reader;} presentation Reading id "presentation:reading:library" for LanguageReader using LanguageReaderPresentation.Reader; }