201 lines
25 KiB
Plaintext
201 lines
25 KiB
Plaintext
import interface ReadingVocabulary;
|
|
external atom ReadingVocabularyObject id "atom:reading:vocabulary";
|
|
symbol JavaScript id "target:org.quixos.execution.javascript@1";
|
|
import interface AgentContextSubject;
|
|
import interface AgentDocumentation;
|
|
import interface AgentWorkspace;
|
|
import interface AgentDirectory;
|
|
import interface Agent;
|
|
import interface AgentRequest;
|
|
import interface EventStream;
|
|
import interface EventHandler;
|
|
import interface EventSubscription;
|
|
import interface WebStudioCanvas;
|
|
import interface WebStudioCanvasPlacement;
|
|
import interface WebStudioPlaceable;
|
|
import interface LanguageReader;
|
|
import interface ReadingReader;
|
|
import interface ReadingDocument;
|
|
import interface ReadingFeature;
|
|
import interface ReadingJob;
|
|
import interface ReadingRequest;
|
|
import interface ReadingWord;
|
|
import interface ReadingNavigation;
|
|
import interface ReadingServices;
|
|
import interface PresentationState;
|
|
import interface PresentationMount;
|
|
external atom WebStudioCanvas id "atom:org.quixos.web-studio:canvas";
|
|
external atom AgentDirectoryObject id "atom:org.quixos.agent:directory";
|
|
external atom AgentObject id "atom:org.quixos.agent:agent";
|
|
external atom AgentRequestObject id "atom:org.quixos.agent:request";
|
|
external atom AgentThreadObject id "atom:org.quixos.agent:thread";
|
|
external atom ReadingReaderObject id "atom:reading:reader";
|
|
external atom ReadingLibrary id "atom:reading:library";
|
|
external atom ReadingDocumentObject id "atom:reading:document";
|
|
external atom ReadingFeatureObject id "atom:reading:feature";
|
|
external atom ReadingJobObject id "atom:reading:job";
|
|
external atom ReadingWordObject id "atom:reading:word";
|
|
external atom ReadingSubscription id "atom:reading:subscription";
|
|
external atom ReadingNavigationObject id "atom:reading:navigation";
|
|
type DocumentData = record {title:string;text:string;sourceRevision:string;source:string;url:string;attribution:string;};
|
|
type FeatureData = record {name:string;processor:string;style:string;reveal:string;generation:string;scope:string;color:string;enabled:bool;configRevision:uint32;};
|
|
type JobData = record {key:string;kind:string;featureRevision:uint32;sourceRevision:string;start:uint32;end:uint32;status:string;output:string;error:string;createdAt:string;};
|
|
type ReaderData = record {name:string;size:uint32;width:uint32;font:string;background:string;configRevision:uint32;};
|
|
type ReaderSeed = record {palette:record {text:string;accent:string;};data:ReaderData;library:interface-ref<LanguageReader>;};
|
|
type DocumentSeed = record {reader:optional<interface-ref<ReadingReader>>;canonical:optional<interface-ref<ReadingDocument>>;adaptation:string;data:DocumentData;library:interface-ref<LanguageReader>;};
|
|
type FeatureSeed = record {authoring:optional<atom-ref<ReadingJobObject>>;reader:optional<interface-ref<ReadingReader>>;data:FeatureData;library:interface-ref<LanguageReader>;options:string;};
|
|
type JobSeed = record {reader:optional<interface-ref<ReadingReader>>;configuration:string;data:JobData;library:interface-ref<LanguageReader>;document:optional<interface-ref<ReadingDocument>>;feature:optional<interface-ref<ReadingFeature>>;};
|
|
type AgentCompletion = record {request:atom-ref<AgentRequestObject>;thread:atom-ref<AgentThreadObject>;status:string;};
|
|
type AgentAdmission = record {accepted:bool;reason:optional<string>;thread:optional<atom-ref<AgentThreadObject>>;request:optional<atom-ref<AgentRequestObject>>;};
|
|
package LanguageReaderRuntime id "package:reading:runtime" revision "package:reading:runtime@1" {
|
|
operation attachReader id "reading:runtime:attach-reader" : interface-ref<ReadingReader> -> unit mode call execution transaction targets [server,JavaScript] receiver atom ReadingDocumentObject requires {edge library id "library" : exactly-one interface LanguageReader [resolve];edge reader id "reader" : optional-one interface ReadingReader [resolve,connect,disconnect];interface target_reader id "target_reader" : ReadingReader using [library.resolve] from input;};
|
|
operation configureReader id "reading:runtime:configure-reader" : record {expectedRevision:uint32;name:string;size:uint32;width:uint32;font:string;background:string;} -> unit mode call execution transaction targets [server] receiver atom ReadingReaderObject requires {state data id "data" : ReaderData [read,write];};
|
|
operation ensureReaders id "reading:runtime:ensure-readers" : unit -> atom-ref<ReadingReaderObject> mode call execution transaction targets [server] receiver atom ReadingLibrary requires {
|
|
edge default_reader id "default_reader" : optional-one interface ReadingReader [resolve,connect];
|
|
interface home id "home" : LanguageReader using [features.resolve,documents.resolve] from input;
|
|
interface feature id "feature" : ReadingFeature using [reader.resolve,reader.connect] from input;
|
|
interface document id "document" : ReadingDocument using [reader.resolve,reader.connect] from input;
|
|
creation reader id "reader" : ReadingReaderObject input ReaderSeed;
|
|
};
|
|
operation addFrenchReader id "reading:runtime:add-french-reader" : unit -> atom-ref<ReadingReaderObject> mode call execution transaction targets [server] receiver atom ReadingLibrary requires {creation reader id "reader" : ReadingReaderObject input ReaderSeed;creation feature id "feature" : ReadingFeatureObject input FeatureSeed;creation document id "document" : ReadingDocumentObject input DocumentSeed;};
|
|
operation generateDocument id "reading:runtime:generate-document" : record {prompt:string;reader:atom-ref<ReadingReaderObject>;createdAt:string;} -> atom-ref<ReadingJobObject> mode call execution transaction targets [server] receiver atom ReadingLibrary requires {edge inference id "inference" : optional-one atom AgentObject [resolve];interface target_reader id "target_reader" : ReadingReader using [library.resolve] from input;interface agent id "agent" : Agent using [request.call] from input;creation job id "job" : ReadingJobObject input JobSeed;interface job_api id "job_api" : ReadingJob using [admitted.call] from input;};
|
|
operation addReader id "reading:runtime:add-reader" : record {name:string;copy:optional<atom-ref<ReadingReaderObject>>;} -> atom-ref<ReadingReaderObject> mode call execution transaction targets [server] receiver atom ReadingLibrary requires {
|
|
interface source id "source" : ReadingReader using [palette.get,data.get,features.resolve,library.resolve,vocabulary.resolve] from input;
|
|
interface feature id "feature" : ReadingFeature using [data.get,options.get] from input;
|
|
interface reader_api id "reader_api" : ReadingReader using [vocabulary.connect] from input;
|
|
creation reader id "reader" : ReadingReaderObject input ReaderSeed;creation feature_copy id "feature_copy" : ReadingFeatureObject input FeatureSeed;
|
|
};
|
|
operation speechStatus id "reading:runtime:speech-status" : unit -> record {configured:bool;voice:string;} mode call execution snapshot targets [server] receiver atom ReadingLibrary requires {state settings id "settings" : record {key:string;voice:string;} [read];};
|
|
operation configureSpeech id "reading:runtime:configure-speech" : record {key:optional<string>;voice:string;} -> unit mode call execution transaction targets [server] receiver atom ReadingLibrary requires {state settings id "settings" : record {key:string;voice:string;} [read,write];};
|
|
operation speak id "reading:runtime:speak" : string -> bytes mode call execution remote receiver atom ReadingLibrary requires {state settings id "settings" : record {key:string;voice:string;} [read];};
|
|
operation searchWikipedia id "reading:runtime:wiki-search" : string -> list<record {title:string;description:string;}> mode call execution remote receiver atom ReadingLibrary;
|
|
operation readWikipedia id "reading:runtime:wiki-read" : string -> record {title:string;text:string;source:string;url:string;attribution:string;} mode call execution remote receiver atom ReadingLibrary;
|
|
operation setInferenceProfile id "reading:runtime:inference-profile" : string -> unit mode call execution transaction targets [server] receiver atom ReadingLibrary requires {state profile id "profile" : string [write];};
|
|
operation configureOptions id "reading:runtime:configure-options" : record {expectedRevision:uint32;options:string;} -> unit mode call execution transaction targets [server] receiver atom ReadingFeatureObject requires {state data id "data" : FeatureData [read,write];state options id "options" : string [write];};
|
|
operation archiveType id "reading:runtime:archive-type" : record {processor:string;archived:bool;} -> unit mode call execution transaction targets [server,JavaScript] receiver atom ReadingLibrary requires {state archives id "archives" : list<string> [read,write];};
|
|
operation catalog id "reading:runtime:catalog" : unit -> list<record {key:string;label:string;strategy:string;scope:string;processorRevision:string;config:string;}> mode call execution snapshot targets [server] receiver any;
|
|
operation createNavigation id "reading:runtime:create-navigation" : record {occurrence:string;} -> interface-ref<ReadingNavigation> mode call execution transaction targets [server] receiver atom ReadingLibrary requires {
|
|
creation navigation id "navigation" : ReadingNavigationObject input record {occurrence:string;source:atom-ref<ReadingLibrary>;};
|
|
};
|
|
operation setReadingView id "reading:runtime:set-reading" : record {displayMode:string;position:uint32;} -> unit mode call execution transaction targets [server,JavaScript] receiver atom ReadingNavigationObject requires {state reading id "reading" : record {displayMode:string;position:uint32;} [write];};
|
|
operation reportViewport id "reading:runtime:report-viewport" : record {client:string;width:uint32;height:uint32;} -> unit mode call execution transaction targets [server] receiver atom ReadingNavigationObject requires {state viewports id "viewports" : list<record {client:string;width:uint32;height:uint32;expiresAt:double;}> [read,write];};
|
|
operation selectSettings id "reading:runtime:select-settings" : record {reader:optional<interface-ref<ReadingReader>>;feature:optional<interface-ref<ReadingFeature>>;section:string;open:bool;document:optional<interface-ref<ReadingDocument>>;} -> unit mode call execution transaction targets [server,JavaScript] receiver atom ReadingNavigationObject requires {
|
|
state ui id "ui" : record {page:string;panel:string;section:string;sourceTab:string;} [read,write];
|
|
edge reader id "reader" : optional-one interface ReadingReader [resolve,connect,disconnect];
|
|
edge feature id "feature" : optional-one interface ReadingFeature [resolve,connect,disconnect];
|
|
interface document id "document" : ReadingDocument using [reader.connect] from input;
|
|
};
|
|
operation openDocument id "reading:runtime:open-document" : optional<interface-ref<ReadingDocument>> -> unit mode call execution transaction targets [server,JavaScript] receiver atom ReadingNavigationObject requires {
|
|
state target id "target" : optional<record {start:uint32;end:uint32;}> [write];
|
|
edge document id "document" : optional-one interface ReadingDocument [resolve,connect,disconnect];
|
|
state cursor id "cursor" : record {anchor:uint32;focus:uint32;size:uint32;} [read,write];
|
|
state reading id "reading" : record {displayMode:string;position:uint32;} [read,write];
|
|
};
|
|
operation copyNavigation id "reading:runtime:copy-navigation" : record {target:interface-ref<PresentationState>;mapping:list<record {source:interface-ref<PresentationState>;target:interface-ref<PresentationState>;}>;} -> unit mode call execution transaction targets [server] receiver any requires {
|
|
interface source id "source" : ReadingNavigation using [document.resolve,cursor.get,reading.get,ui.get,builder.get,settingsReader.resolve,settingsFeature.resolve];
|
|
interface target id "target" : ReadingNavigation using [open.call,cursor.set,reading.set,ui.set,builder.set,settingsReader.connect,settingsFeature.connect] from input;
|
|
};
|
|
operation workspaceInstall id "reading:runtime:workspace-install" : record {instructions:string;settings:string;} -> atom-ref<AgentDirectoryObject> mode call execution transaction targets [server] receiver atom ReadingLibrary requires {
|
|
edge canvas id "canvas" : exactly-one atom WebStudioCanvas [resolve];
|
|
interface agent_workspace id "agent_workspace" : AgentWorkspace using [install.call] from input;
|
|
};
|
|
function createRoot id "reading:runtime:root" : unit -> atom-ref<ReadingLibrary> execution transaction targets [server] requires {
|
|
creation canvas id "canvas" : WebStudioCanvas input record {name:string;};
|
|
interface agent_workspace id "workspace" : AgentWorkspace using [install.call,agents.resolve] from input;
|
|
creation library id "library" : ReadingLibrary input record {name:string;canvas:atom-ref<WebStudioCanvas>;directory:optional<atom-ref<AgentDirectoryObject>>;};
|
|
interface reader id "reader" : LanguageReader using [install.call] from input;
|
|
};
|
|
operation install id "reading:runtime:install" : unit -> unit mode call execution transaction targets [server] receiver atom ReadingLibrary requires {
|
|
edge directory id "directory" : optional-one atom AgentDirectoryObject [resolve];
|
|
edge inference id "inference" : optional-one atom AgentObject [resolve,connect];
|
|
edge author id "author" : optional-one atom AgentObject [resolve,connect];
|
|
edge subscriptions id "subscriptions" : many-unique interface EventSubscription<AgentCompletion,unit> [connect];
|
|
interface agents id "agents" : AgentDirectory using [createAgent.call] from input;
|
|
interface agent id "agent" : Agent using [completions.resolve] from input;
|
|
creation subscription id "subscription" : ReadingSubscription input unit;
|
|
interface delivery id "delivery" : EventSubscription<AgentCompletion,unit> using [attach.call] from input;
|
|
creation feature id "feature" : ReadingFeatureObject input FeatureSeed;
|
|
creation document id "document" : ReadingDocumentObject input DocumentSeed;
|
|
interface home id "home" : LanguageReader using [ensureReaders.call] from input;
|
|
};
|
|
operation addDocument id "reading:runtime:add-document" : record {title:string;text:string;source:string;url:string;attribution:string;} -> atom-ref<ReadingDocumentObject> mode call execution transaction targets [server] receiver atom ReadingLibrary requires {creation document id "document" : ReadingDocumentObject input DocumentSeed;interface home id "home" : LanguageReader using [defaultReader.resolve] from input;};
|
|
operation attachAuthoring id "reading:runtime:attach-authoring" : atom-ref<ReadingJobObject> -> unit mode call execution transaction targets [server] receiver atom ReadingFeatureObject requires {edge authoring id "authoring" : optional-one atom ReadingJobObject [resolve,connect,disconnect];edge library id "library" : exactly-one interface LanguageReader [resolve];edge reader id "reader" : optional-one interface ReadingReader [resolve];interface job id "job" : ReadingJob using [library.resolve,reader.resolve] from input;};
|
|
operation setEnabled id "reading:runtime:set-enabled" : bool -> unit mode call execution transaction targets [server,JavaScript] receiver atom ReadingFeatureObject requires {state data id "data" : FeatureData [read,write];};
|
|
operation addFeature id "reading:runtime:add-feature" : record {authoring:optional<atom-ref<ReadingJobObject>>;reader:optional<atom-ref<ReadingReaderObject>>;name:string;processor:string;style:string;reveal:string;generation:string;scope:string;color:string;options:string;} -> atom-ref<ReadingFeatureObject> mode call execution transaction targets [server] receiver atom ReadingLibrary requires {interface authoring id "authoring" : ReadingJob using [library.resolve,reader.resolve] from input;creation feature id "feature" : ReadingFeatureObject input FeatureSeed;interface home id "home" : LanguageReader using [defaultReader.resolve] from input;interface reader id "reader" : ReadingReader using [library.resolve] from input;};
|
|
operation processorRevision id "reading:runtime:processor-revision" : unit -> string mode call execution snapshot targets [server] receiver atom ReadingFeatureObject requires {state data id "data" : FeatureData [read];};
|
|
operation configure id "reading:runtime:configure" : record {expectedRevision:uint32;name:string;style:string;reveal:string;generation:string;scope:string;color:string;enabled:bool;} -> unit mode call execution transaction targets [server] receiver atom ReadingFeatureObject requires {state data id "data" : FeatureData [read,write];};
|
|
operation remember id "reading:runtime:remember" : string -> unit mode call execution transaction targets [server] receiver atom ReadingLibrary requires {
|
|
interface home id "home" : LanguageReader using [ensureVocabulary.call] from input;
|
|
interface vocabulary id "vocabulary" : ReadingVocabulary using [remember.call] from input;
|
|
};
|
|
operation addVocabulary id "reading:runtime:add-vocabulary" : string -> atom-ref<ReadingVocabularyObject> mode call execution transaction targets [server] receiver atom ReadingLibrary requires {creation vocabulary id "vocabulary" : ReadingVocabularyObject input record {name:string;library:interface-ref<LanguageReader>;};};
|
|
operation ensureVocabulary id "reading:runtime:ensure-vocabulary" : unit -> atom-ref<ReadingVocabularyObject> mode call execution transaction targets [server] receiver atom ReadingLibrary requires {
|
|
edge default_vocabulary id "default_vocabulary" : optional-one interface ReadingVocabulary [resolve,connect];
|
|
creation vocabulary id "vocabulary" : ReadingVocabularyObject input record {name:string;library:interface-ref<LanguageReader>;};
|
|
interface home id "home" : LanguageReader using [vocabulary.resolve] from input;
|
|
interface word id "word" : ReadingWord using [vocabulary.resolve,vocabulary.connect] from input;
|
|
};
|
|
operation vocabularyRemember id "reading:runtime:vocabulary-remember" : string -> unit mode call execution transaction targets [server] receiver atom ReadingVocabularyObject requires {
|
|
edge library id "library" : exactly-one interface LanguageReader [resolve];
|
|
interface words id "words" : ReadingVocabulary using [words.resolve] from input;
|
|
interface word_api id "word_api" : ReadingWord using [text.get,vocabulary.connect] from input;
|
|
creation word id "word" : ReadingWordObject input record {text:string;library:interface-ref<LanguageReader>;};
|
|
};
|
|
operation attachVocabulary id "reading:runtime:attach-vocabulary" : interface-ref<ReadingVocabulary> -> unit mode call execution transaction targets [server] receiver any requires {
|
|
edge library id "library" : exactly-one interface LanguageReader [resolve];edge vocabulary id "vocabulary" : optional-one interface ReadingVocabulary [resolve,connect,disconnect];
|
|
interface target id "target" : ReadingVocabulary using [library.resolve] from input;
|
|
};
|
|
operation renameVocabulary id "reading:runtime:rename-vocabulary" : string -> unit mode call execution transaction targets [server] receiver atom ReadingVocabularyObject requires {state name id "name" : string [write];};
|
|
operation plan id "reading:runtime:plan" : record {feature:atom-ref<ReadingFeatureObject>;start:uint32;end:uint32;visibleStart:uint32;visibleEnd:uint32;kind:string;} -> list<record {start:uint32;end:uint32;}> mode call execution snapshot targets [server,JavaScript] receiver atom ReadingDocumentObject requires {
|
|
state data id "data" : DocumentData [read];edge library id "library" : exactly-one interface LanguageReader [resolve];
|
|
interface feature id "feature" : ReadingFeature using [data.get,options.get,library.resolve] from input;
|
|
};
|
|
operation generate id "reading:runtime:generate" : record {feature:atom-ref<ReadingFeatureObject>;start:uint32;end:uint32;createdAt:string;retry:bool;} -> atom-ref<ReadingJobObject> mode call execution transaction targets [server] receiver atom ReadingDocumentObject requires {
|
|
state data id "data" : DocumentData [read];
|
|
edge results id "results" : many interface ReadingJob keyed "string" [resolve,connect,disconnect];
|
|
edge attempts id "attempts" : many interface ReadingJob keyed "string" [resolve,connect,disconnect];
|
|
edge library id "library" : exactly-one interface LanguageReader [resolve];
|
|
interface jobs id "jobs" : ReadingDocument using [jobs.resolve] from input;
|
|
interface feature id "feature" : ReadingFeature using [data.get,options.get,library.resolve] from input;
|
|
interface home id "home" : LanguageReader using [inference.resolve,inferenceProfile.get] from input;
|
|
interface agent id "agent" : Agent using [tryRequest.call] from input;
|
|
interface old id "old" : ReadingJob using [data.get,configuration.get] from input;
|
|
creation job id "job" : ReadingJobObject input JobSeed;
|
|
interface job_api id "job_api" : ReadingJob using [admitted.call] from input;
|
|
};
|
|
operation rewrite id "reading:runtime:rewrite" : record {difficulty:string;createdAt:string;} -> atom-ref<ReadingDocumentObject> mode call execution transaction targets [server] receiver atom ReadingDocumentObject requires {state data id "data" : DocumentData [read];edge library id "library" : exactly-one interface LanguageReader [resolve];edge reader id "reader" : optional-one interface ReadingReader [resolve];creation document_result id "document_result" : ReadingDocumentObject input DocumentSeed;};
|
|
operation prepareVariant id "reading:runtime:prepare-adaptation" : record {createdAt:string;retry:bool;} -> optional<atom-ref<ReadingJobObject>> mode call execution transaction targets [server] receiver atom ReadingDocumentObject requires {state data id "data" : DocumentData [read];state adaptation id "adaptation" : string [read];edge library id "library" : exactly-one interface LanguageReader [resolve];
|
|
interface home id "home" : LanguageReader using [inference.resolve,inferenceProfile.get] from input;
|
|
interface agent id "agent" : Agent using [tryRequest.call] from input;
|
|
interface jobs id "jobs" : ReadingDocument using [jobs.resolve] from input;interface old id "old" : ReadingJob using [data.get] from input;
|
|
creation job id "job" : ReadingJobObject input JobSeed;interface job_api id "job_api" : ReadingJob using [admitted.call] from input;};
|
|
operation applyVariant id "reading:runtime:apply-adaptation" : record {sourceRevision:string;start:uint32;end:uint32;text:string;} -> unit mode call execution transaction targets [server] receiver atom ReadingDocumentObject requires {state data id "data" : DocumentData [read,write];state adaptation id "adaptation" : string [read,write];};
|
|
operation customize id "reading:runtime:customize" : record {feature:optional<atom-ref<ReadingFeatureObject>>;reader:atom-ref<ReadingReaderObject>;configuration:string;text:string;createdAt:string;} -> atom-ref<ReadingJobObject> mode call execution transaction targets [server] receiver atom ReadingLibrary requires {
|
|
edge author id "author" : optional-one atom AgentObject [resolve];
|
|
interface reader id "reader" : ReadingReader using [library.resolve,data.get] from input;
|
|
interface agent id "agent" : Agent using [request.call] from input;
|
|
creation job id "job" : ReadingJobObject input JobSeed;interface job_api id "job_api" : ReadingJob using [admitted.call] from input;
|
|
interface feature id "feature" : ReadingFeature using [library.resolve,reader.resolve,authoring.connect] from input;
|
|
};
|
|
operation admitted id "reading:runtime:admitted" : AgentAdmission -> unit mode call execution transaction targets [server] receiver atom ReadingJobObject requires {
|
|
state data id "data" : JobData [read,write];edge request id "request" : optional-one atom AgentRequestObject [connect];edge thread id "thread" : optional-one atom AgentThreadObject [connect];
|
|
};
|
|
operation completion id "reading:runtime:completion" : record {event:AgentCompletion;parameters:unit;} -> unit mode call execution transaction targets [server] receiver atom ReadingLibrary requires {
|
|
interface request id "request" : ReadingRequest using [job.resolve] from input;interface job id "job" : ReadingJob using [complete.call] from input;
|
|
};
|
|
operation recordResult id "reading:runtime:record-result" : interface-ref<ReadingJob> -> unit mode call execution transaction targets [server] receiver atom ReadingDocumentObject requires {
|
|
state data id "data" : DocumentData [read];
|
|
edge results id "results" : many interface ReadingJob keyed "string" [resolve,connect,disconnect];
|
|
interface job id "job" : ReadingJob using [data.get,document.resolve] from input;
|
|
};
|
|
operation complete id "reading:runtime:complete" : unit -> unit mode call execution transaction targets [server] receiver atom ReadingJobObject requires {
|
|
state data id "data" : JobData [read,write];state configuration id "configuration" : string [read];edge request id "request" : optional-one atom AgentRequestObject [resolve,connect,disconnect];edge document id "document" : optional-one interface ReadingDocument [resolve,connect];edge reader id "reader" : optional-one interface ReadingReader [resolve];edge feature id "feature" : optional-one interface ReadingFeature [resolve];edge library id "library" : exactly-one interface LanguageReader [resolve];
|
|
interface request_api id "request_api" : AgentRequest using [progress.get,correct.call] from input;
|
|
interface document_api id "document_api" : ReadingDocument using [data.get,applyVariant.call,recordResult.call] from input;
|
|
interface feature_api id "feature_api" : ReadingFeature using [data.get,options.get] from input;
|
|
interface home id "home" : LanguageReader using [inferenceProfile.get] from input;
|
|
creation document_result id "document_result" : ReadingDocumentObject input DocumentSeed;
|
|
};
|
|
operation guide id "reading:runtime:guide" : unit -> record {title:string;resource:string;paths:list<string>;markdown:string;} mode call execution snapshot targets [server] receiver any;
|
|
}
|