@agentshouse/app-bridge 0.1.0-c58a055eeaa71 → 0.1.0-c599cdbcc172a

package/dist/mdruntime/client.d.ts

@@ -0,0 +1,86 @@
+import type { AppRoom, ConnectionRefusal, HistoryQuery, RoomSchemas, SavedParts, SavedRoomDraft, SaveResult } from './connection.js';
+import type { Member, ServiceMode } from './adapter.js';
+import type { ChatDraft, ConversationAgent, ConversationEntry, ConversationOptions, ConversationView } from './conversation.js';
+import { type Observation } from './observation.js';
+import type { BinaryReference } from './binary.js';
+import type { BinaryAnswer, BinaryLinkAnswer, CallResult, HistoryAnswer, Offline, QueueEntry } from './outcome.js';
+import type { DocumentQuery, DocumentResult, GroupQuery, GroupResult, PendingResult } from './query.js';
+import type { RoomDraft, RoomDraftParts, RoomDraftWrite } from './room-draft.js';
+import type { SearchRequest, SearchResult } from './search.js';
+import type { Readiness } from './readiness.js';
+import type { SyncStatus } from './status.js';
+import { type RuntimePort } from './wire.js';
+export type MdRuntimeClient = {
+    rooms(): Promise<readonly AppRoom[]>;
+    query: {
+        (query: DocumentQuery): Promise<DocumentResult | PendingResult>;
+        (query: GroupQuery): Promise<GroupResult | PendingResult>;
+    };
+    search(request: SearchRequest): Promise<SearchResult>;
+    types(locator: string): Promise<RoomSchemas>;
+    roomDraft: {
+        list(): Promise<readonly RoomDraft[]>;
+        read(room: string, path: string): Promise<RoomDraft | null>;
+        write(room: string, path: string, revision: string | null, parts: RoomDraftParts): Promise<RoomDraftWrite>;
+        discard(room: string, path: string, revision: string): Promise<RoomDraftWrite>;
+    };
+    save(room: string, roomDrafts: readonly SavedRoomDraft[]): Promise<SaveResult>;
+    saveParts(room: string, parts: readonly SavedParts[]): Promise<SaveResult>;
+    presentation: {
+        read(): Promise<unknown>;
+        write(value: unknown): Promise<void>;
+        edit(members: Readonly<Record<string, unknown>>): Promise<void>;
+    };
+    conversation: {
+        list(): Promise<readonly ConversationEntry[]>;
+        read(conversation: string, options?: ConversationOptions): Promise<ConversationView>;
+        create(input: unknown): Promise<CallResult>;
+        send(conversation: string, operation?: string, draft?: ChatDraft): Promise<CallResult | Offline>;
+        answer(conversation: string, answer: unknown): Promise<CallResult>;
+        interrupt(conversation: string): Promise<CallResult>;
+        kill(conversation: string): Promise<CallResult>;
+        cancel(conversation: string, turn: string): Promise<CallResult>;
+        delete(conversation: string): Promise<CallResult>;
+    };
+    chatDraft: {
+        write(conversation: string, draft: ChatDraft, revision?: string): Promise<void>;
+        prepend(conversation: string, draft: ChatDraft): Promise<void>;
+        discard(conversation: string): Promise<void>;
+    };
+    history(locator: string, path: string, query?: HistoryQuery): Promise<HistoryAnswer>;
+    binaryFile: {
+        read(room: string, path: string, revision?: string): Promise<BinaryAnswer>;
+        link(room: string, path: string, revision?: string): Promise<BinaryLinkAnswer>;
+        readReference(reference: BinaryReference): Promise<BinaryAnswer>;
+    };
+    call(name: string, input: unknown): Promise<CallResult>;
+    reached(locator: string, roomVersion: string, path?: string): Promise<boolean>;
+    log(): Promise<string>;
+    persistence(): Promise<boolean>;
+    retry(): Promise<void>;
+    observe: {
+        (topic: 'deployment-facts'): Promise<Observation<unknown>>;
+        (topic: 'rooms'): Promise<Observation<readonly AppRoom[]>>;
+        (topic: 'readiness'): Promise<Observation<Readiness>>;
+        (topic: 'connection-refusal'): Promise<Observation<ConnectionRefusal | null>>;
+        (topic: 'storage-loss'): Promise<Observation<string | null>>;
+        (topic: 'sync-status'): Promise<Observation<SyncStatus>>;
+        (topic: 'service-mode'): Promise<Observation<ServiceMode>>;
+        (topic: 'member'): Promise<Observation<Member | null>>;
+        (topic: 'query', query: DocumentQuery): Promise<Observation<DocumentResult | PendingResult>>;
+        (topic: 'query', query: GroupQuery): Promise<Observation<GroupResult | PendingResult>>;
+        (topic: 'queue', locator: string): Promise<Observation<readonly QueueEntry[]>>;
+        (topic: 'room-drafts'): Promise<Observation<readonly RoomDraft[]>>;
+        (topic: 'presentation'): Promise<Observation<unknown>>;
+        (topic: 'conversation', conversation: string, options: ConversationOptions): Promise<Observation<ConversationView>>;
+        (topic: 'conversations'): Promise<Observation<readonly ConversationEntry[]>>;
+        (topic: 'agents'): Promise<Observation<readonly ConversationAgent[]>>;
+    };
+    reauthorize(): Promise<void>;
+    settled(): Promise<void>;
+};
+export declare function connectMdRuntime(port: RuntimePort): MdRuntimeClient;
+export declare function inTurn(client: MdRuntimeClient, work: () => Promise<void>): Promise<void>;
+export type { Observation } from './observation.js';
+export type { Open } from './open.js';
+export { unanswered, type RuntimePort, type WireMember } from './wire.js';

package/dist/mdruntime/collection.d.ts

@@ -0,0 +1,39 @@
+import { type Document, type Frontmatter, type Validation } from '../mdmodel/index.js';
+import { type ModelState } from './model.js';
+import type { MdModelIdentity } from './adapter.js';
+import { type Paths } from './shared.js';
+import type { Refused } from './transfer.js';
+import { type Later } from './turn.js';
+export declare const MD_MODEL: MdModelIdentity;
+export type Collection = {
+    text: Readonly<Record<string, string>>;
+    composition: Composition;
+    document(path: string): Document | undefined;
+};
+export type Composition = {
+    model: ModelState;
+    selection: {
+        roots: readonly string[];
+        model: ModelState;
+    } | null;
+};
+export declare function governing(composition: Composition, path: string): ModelState;
+export declare function collectionOf(text: Readonly<Record<string, string>>, composition: Composition, previous?: Collection): Collection;
+export declare function collecting(text: Readonly<Record<string, string>>, composition: Composition, previous?: Collection): Generator<number, Collection, void>;
+export declare function passingFrontmatter(collection: Collection, path: string): Frontmatter | undefined;
+export declare function documentsOf(collection: Collection): Generator<readonly [string, Document]>;
+export declare function unreadable(text: Readonly<Record<string, string>>, previous?: Readonly<Record<string, string>>): Generator<number, Refused | null, void>;
+export declare function validRoot(root: unknown): root is string;
+export declare function validateCollection(text: Readonly<Record<string, string>>, binaryTargets: readonly string[], composition: Composition): Generator<number, Validation, void>;
+type Held = {
+    text: Paths<string>;
+    binaries: Paths<unknown>;
+};
+export declare function indexReferrers(held: Held, composition: Composition): Later<void>;
+export declare function referencesIndexed(held: Held, composition: Composition): boolean;
+export declare function referring(held: Held, composition: Composition, targets: Iterable<string>): ReadonlySet<string> | null;
+export declare function available(composition: Composition): boolean;
+export declare function changedCleanly(next: Held, previous: Held & {
+    composition: Composition;
+}, composition: Composition): Generator<number, boolean, void>;
+export {};

package/dist/mdruntime/connection.d.ts

@@ -0,0 +1,146 @@
+import { type TypesResult } from './model.js';
+import { type Observation } from './observation.js';
+import { type DocumentQuery, type DocumentResult, type GroupQuery, type GroupResult, type PendingResult } from './query.js';
+import { type EntrySeed } from './seed.js';
+import { type SearchRequest, type SearchResult } from './search.js';
+import { type Adapter, type Authorization, type Member, type ProviderRefusal, type ServiceMode } from './adapter.js';
+import { type ChatDraftSurface, type ConversationAgent, type ConversationEntry, type ConversationOptions, type ConversationSurface, type ConversationView } from './conversation.js';
+import { type WrittenBy } from './change.js';
+import type { Open } from './open.js';
+import { type BinaryReference } from './binary.js';
+import { type BinaryAnswer, type BinaryLinkAnswer, type CallResult, type HistoryAnswer, type QueueEntry } from './outcome.js';
+import { type Recovery } from './recovery.js';
+import { type SaveRefusal } from './save.js';
+import { type RoomDraft, type RoomDraftParts, type RoomDraftWrite } from './room-draft.js';
+import { type SyncStatus } from './status.js';
+import { type RuntimeShell } from './durability.js';
+import { type CapacityCause, type CodeAvailability, type Persistence, type Readiness, type SearchObligation } from './readiness.js';
+import { type NarrowedView, type PortReach, type RuntimeView } from './reach.js';
+export type AppTypedSelection = {
+    roots: readonly string[];
+    model: TypesResult;
+};
+export type AppRoom = {
+    name: string;
+    locator: string;
+    handle: string;
+    operations: import('./adapter.js').OperationScopes;
+    replica: import('./adapter.js').ReplicaAdmission;
+    model: TypesResult;
+    typedSelection: AppTypedSelection | null;
+    providerOwnedPaths: readonly string[];
+    roomVersion: string | null;
+    documents: number;
+    synchronizationAvailable: boolean;
+    refusal: ProviderRefusal | null;
+};
+export type RoomSchemas = {
+    collection: TypesResult;
+    typedSelection: TypesResult | null;
+};
+type RefusalReason = 'missing-required-guarantee' | 'revoked-authorization';
+export type ConnectionRefusalCode = Open<RefusalReason>;
+export type ConnectionRefusal = {
+    code: ConnectionRefusalCode;
+    retryable: boolean;
+    reauthorizationOffered: boolean;
+    refusal: ProviderRefusal | null;
+};
+export type MdRuntimeOptions = {
+    adapter: Adapter;
+    shell: RuntimeShell;
+    authorization?: Authorization;
+    signal?: AbortSignal;
+    recovery?: Recovery;
+};
+export type SaveResult = {
+    outcome: 'saved';
+    identifier: string;
+} | ({
+    outcome: 'refused';
+} & SaveRefusal);
+export type SavedRoomDraft = {
+    readonly path: string;
+    readonly revision: string;
+};
+export type SavedParts = {
+    readonly path: string;
+    readonly parts: RoomDraftParts;
+};
+export type RoomDraftSurface = {
+    list(): Promise<readonly RoomDraft[]>;
+    read(room: string, path: string): RoomDraft | null;
+    write(room: string, path: string, revision: string | null, parts: unknown): Promise<RoomDraftWrite>;
+    discard(room: string, path: string, revision: string): Promise<RoomDraftWrite>;
+};
+export type PresentationSurface = {
+    read(app: string): Promise<unknown>;
+    write(app: string, value: unknown): Promise<void>;
+    edit(app: string, members: Readonly<Record<string, unknown>>): Promise<void>;
+};
+export type BinaryFileSurface = {
+    read(room: string, path: string, revision?: string): Promise<BinaryAnswer>;
+    link(room: string, path: string, revision?: string): Promise<BinaryLinkAnswer>;
+    readReference(reference: BinaryReference): Promise<BinaryAnswer>;
+};
+export type HistoryQuery = {
+    revision?: string;
+    pageToken?: string;
+};
+export type MdRuntime = {
+    loaded(): Promise<void>;
+    rooms(): readonly AppRoom[];
+    query: {
+        (query: DocumentQuery): Promise<DocumentResult | PendingResult>;
+        (query: GroupQuery): Promise<GroupResult | PendingResult>;
+    };
+    search(request: SearchRequest): Promise<SearchResult>;
+    types(locator: string): RoomSchemas;
+    roomDraft: RoomDraftSurface;
+    conversation: ConversationSurface;
+    chatDraft: ChatDraftSurface;
+    presentation: PresentationSurface;
+    save(room: string, roomDrafts: readonly SavedRoomDraft[], writtenBy?: WrittenBy): Promise<SaveResult>;
+    saveParts(room: string, parts: readonly SavedParts[], writtenBy?: WrittenBy): Promise<SaveResult>;
+    history(locator: string, path: string, query?: HistoryQuery): Promise<HistoryAnswer>;
+    binaryFile: BinaryFileSurface;
+    call(name: string, input: unknown): Promise<CallResult>;
+    reached(locator: string, roomVersion: string, path?: string): boolean;
+    log(): string;
+    persistence(): boolean;
+    retry(): Promise<void>;
+    observe: {
+        (topic: 'rooms'): Promise<Observation<readonly AppRoom[]>>;
+        (topic: 'readiness'): Promise<Observation<Readiness>>;
+        (topic: 'connection-refusal'): Promise<Observation<ConnectionRefusal | null>>;
+        (topic: 'storage-loss'): Promise<Observation<string | null>>;
+        (topic: 'sync-status'): Promise<Observation<SyncStatus>>;
+        (topic: 'service-mode'): Promise<Observation<ServiceMode>>;
+        (topic: 'member'): Promise<Observation<Member | null>>;
+        (topic: 'query', query: DocumentQuery): Promise<Observation<DocumentResult | PendingResult>>;
+        (topic: 'query', query: GroupQuery): Promise<Observation<GroupResult | PendingResult>>;
+        (topic: 'queue', locator: string): Promise<Observation<readonly QueueEntry[]>>;
+        (topic: 'room-drafts'): Promise<Observation<readonly RoomDraft[]>>;
+        (topic: 'presentation', app: string): Promise<Observation<unknown>>;
+        (topic: 'conversation', conversation: string, options: ConversationOptions): Promise<Observation<ConversationView>>;
+        (topic: 'conversations'): Promise<Observation<readonly ConversationEntry[]>>;
+        (topic: 'agents'): Promise<Observation<readonly ConversationAgent[]>>;
+    };
+    reauthorize(): Promise<void>;
+};
+export type RuntimeTopic = 'rooms' | 'readiness' | 'connection-refusal' | 'storage-loss' | 'sync-status' | 'service-mode' | 'member' | 'query' | 'queue' | 'room-drafts' | 'presentation' | 'conversation' | 'conversations' | 'agents';
+export type ReadinessPort = {
+    readonly target: string;
+    readonly code: CodeAvailability;
+    readonly capacity: CapacityCause | null;
+    readonly search: SearchObligation;
+};
+export type ComposedRuntime = RuntimeView & {
+    seed(entry: EntrySeed): void;
+    stop(): Promise<void>;
+    lose(locators: readonly string[]): Promise<void>;
+    persisted(answer: Persistence): void;
+    within(reach: PortReach | null, port: ReadinessPort): NarrowedView;
+};
+export declare function composeRuntime(options: MdRuntimeOptions): ComposedRuntime;
+export {};

package/dist/mdruntime/conversation.d.ts

@@ -0,0 +1,110 @@
+import type { ConversationAction, ConversationAgents, ConversationEvent, ConversationMessage, ConversationStream, ProcessCommand, SessionOption, TurnContext } from './adapter.js';
+import { type ChangeSet } from './change-set.js';
+import { type ChatDraftFile } from './file.js';
+import type { Open } from './open.js';
+import { type CallResult, type Offline } from './outcome.js';
+import type { DocumentResult, PendingResult } from './query.js';
+import type { CycleProgress } from './status.js';
+import type { ChatDraftRecord, HeldConversation, RuntimeStore } from './store.js';
+export type ConversationState = Open<'working' | 'asking' | 'idle'>;
+export type ConversationEntry = {
+    conversation: string;
+    agent: {
+        identity: string;
+        name: string | null;
+    };
+    name: string;
+    created: string;
+    finished: string | null;
+    outcome: string | null;
+    state: ConversationState;
+    started: string | null;
+};
+export type ConversationAgent = {
+    identity: string;
+    name: string;
+};
+export type RunningTurn = {
+    turn: string;
+    started: string | null;
+    parts: readonly unknown[];
+    context: TurnContext | null;
+};
+export type ChatDraft = {
+    text: string;
+    files: readonly ChatDraftFile[];
+};
+export type ConversationOptions = {
+    limit?: number;
+    after?: string;
+    total?: true;
+};
+export type ConversationView = {
+    conversation: string;
+    messages: readonly ConversationMessage[];
+    next?: string;
+    total?: number;
+    turn: RunningTurn | null;
+    questions: readonly unknown[];
+    process: {
+        running: boolean;
+    } | null;
+    commands: readonly ProcessCommand[];
+    options: readonly SessionOption[];
+    chatDraft: (ChatDraft & {
+        readonly revision: string;
+    }) | null;
+};
+export type ConversationSurface = {
+    list(): Promise<readonly ConversationEntry[]>;
+    read(conversation: string, options?: ConversationOptions): Promise<ConversationView>;
+    create(input: unknown): Promise<CallResult>;
+    send(conversation: string, operation?: string, draft?: ChatDraft): Promise<CallResult | Offline>;
+    answer(conversation: string, answer: unknown): Promise<CallResult>;
+    interrupt(conversation: string): Promise<CallResult>;
+    kill(conversation: string): Promise<CallResult>;
+    cancel(conversation: string, turn: string): Promise<CallResult>;
+    delete(conversation: string): Promise<CallResult>;
+};
+export type ChatDraftSurface = {
+    write(conversation: string, draft: ChatDraft, revision?: string): Promise<void>;
+    prepend(conversation: string, draft: ChatDraft): Promise<void>;
+    discard(conversation: string): Promise<void>;
+};
+export type ConversationDependencies = {
+    agents(): ConversationAgents | undefined;
+    documents(agents: ConversationAgents): Promise<DocumentResult | PendingResult>;
+    call(name: ConversationAction, input: unknown): Promise<CallResult>;
+    durably<T>(work: (local: RuntimeStore) => Promise<T>): Promise<T>;
+    stream(): ConversationStream | undefined;
+    publish(set: ChangeSet): void;
+    online(): boolean;
+    closed(): boolean;
+    unanswered(): void;
+    expired(operation: string): boolean;
+};
+export type ConversationStore = {
+    surface: ConversationSurface;
+    chatDraft: ChatDraftSurface;
+    hydrate(held: readonly HeldConversation[], drafts: readonly ChatDraftRecord[]): void;
+    reconcile(): Promise<void>;
+    catchUp(progress: CycleProgress): Promise<void>;
+    resend(progress: CycleProgress): Promise<void>;
+    current(): boolean;
+    known(): boolean;
+    reconnected(): void;
+    reopened(): void;
+    lost(): void;
+    watch(conversation: string, options: ConversationOptions, deliver: (view: ConversationView) => void): () => void;
+    watchList(deliver: (entries: readonly ConversationEntry[]) => void): () => void;
+    watchAgents(deliver: (agents: readonly ConversationAgent[]) => void): () => void;
+    changed(set: ChangeSet): void;
+    receive(event: ConversationEvent): boolean;
+    searchable(): readonly string[];
+    acquired(conversation: string): boolean;
+    close(): void;
+};
+export declare function unheldView(conversation: string): ConversationView;
+export declare const SESSION_STARTED = "Session started";
+export declare function newChat(agent: string): string;
+export declare function createConversationStore(deps: ConversationDependencies): ConversationStore;

package/dist/mdruntime/durability.d.ts

@@ -0,0 +1,14 @@
+import type { Persistence } from './readiness.js';
+export type StorageEstimate = {
+    readonly usage: number;
+    readonly quota: number;
+};
+export type RuntimeShell = {
+    persistence: Persistence;
+    generation: string | null;
+    keepGeneration(value: string): void | Promise<void>;
+    dropGeneration(): void | Promise<void>;
+    estimate?(): Promise<StorageEstimate | null>;
+};
+export declare function detectStorageLoss(stored: string | null, reported: string | null): string | null;
+export declare function nextGeneration(stored: string | null, reported: string | null): string;

package/dist/mdruntime/failure.d.ts

@@ -0,0 +1,12 @@
+export type RuntimeError = Error & {
+    readonly code: string;
+    readonly retryable: boolean;
+};
+export type Described = {
+    message: string;
+    code: string;
+    retryable: boolean;
+};
+export declare function runtimeError(code: string, message?: string, retryable?: boolean): RuntimeError;
+export declare function failed(error: unknown): RuntimeError;
+export declare function described(error: unknown): Described;

package/dist/mdruntime/file.d.ts

@@ -0,0 +1,19 @@
+export type ChatDraftFile = {
+    name: string;
+    blob: Blob;
+};
+export type FileDeclaration = {
+    name: string;
+    mediaType: string;
+    byteLength: number;
+    contentHash: string;
+    width?: number;
+    height?: number;
+};
+export type Extent = {
+    width: number;
+    height: number;
+};
+export declare function extentOf(bytes: Uint8Array): Extent | null;
+export declare function hexDigest(digest: ArrayBuffer): string;
+export declare function declaredFile(file: ChatDraftFile): Promise<FileDeclaration>;

package/dist/mdruntime/model.d.ts

@@ -0,0 +1,57 @@
+import type { Definition, ValueFacts, VerifiedModel } from '../mdmodel/index.js';
+import type { Open } from './open.js';
+export type ModelIdentity = {
+    identity: string;
+    version: string;
+};
+export type ModelSnapshot = ModelIdentity & {
+    schema: string | null;
+    revision: string | null;
+};
+export type ModelUnavailableReason = Open<'not-readable' | 'revoked' | 'not-acquired' | 'invalid'>;
+export type ModelResult = {
+    kind: 'model';
+    snapshot: ModelSnapshot;
+} | {
+    kind: 'model-unavailable';
+    reason: ModelUnavailableReason;
+};
+export type MdType = Definition;
+export type ModelState = {
+    status: 'unavailable';
+    reason: ModelUnavailableReason;
+    schema?: string | null;
+    revision?: string | null;
+} | {
+    status: 'current' | 'cached';
+    snapshot: ModelSnapshot;
+    verifiedWith: ModelIdentity;
+    types: VerifiedModel['types'];
+};
+export type TypesResult = {
+    status: Open<'unavailable'>;
+    reason: ModelUnavailableReason;
+    types: null;
+    schema?: string | null;
+    revision?: string | null;
+} | {
+    status: Open<'current' | 'cached'>;
+    identity: string;
+    version: string;
+    verifiedWith: ModelIdentity;
+    types: readonly MdType[];
+    schema: string | null;
+    revision: string | null;
+};
+export type ValidationReceipt = {
+    identity: string;
+    version: string;
+    source: Open<'current' | 'cached'>;
+};
+export declare const NO_MODEL: ModelState;
+export declare function definitionOf(state: ModelState, type: string | undefined): Definition | undefined;
+export declare function modelTypes(state: ModelState): TypesResult;
+export declare function cached(state: ModelState): ModelState;
+export declare function sameModel(left: ModelIdentity, right: ModelIdentity): boolean;
+export declare function sameTyping(left: ModelState, right: ModelState): boolean;
+export declare function referenceField(facts: ValueFacts | undefined): boolean;

package/dist/mdruntime/observation.d.ts

@@ -0,0 +1,31 @@
+import type { QueryCoverage, QueryDocument, QueryGroup, QueryResult } from './query.js';
+export type Observation<T> = {
+    current(): T;
+    subscribe(listener: (value: T) => void): () => void;
+    close(): void;
+};
+export type RowKey = string | number;
+export type KeyedResult = {
+    result: QueryResult;
+    keys: readonly RowKey[];
+};
+export type QueryChange = {
+    changed: readonly (readonly [RowKey, QueryDocument | QueryGroup])[];
+    removed: readonly RowKey[];
+    order: readonly RowKey[] | null;
+    coverage?: QueryCoverage;
+    next?: string | null;
+    total?: number;
+};
+export type QueryMessage = KeyedResult | QueryChange;
+export type Observed = {
+    observation: Observation<unknown>;
+    receive(message: unknown): void;
+    end(): void;
+};
+export declare function rowsOf(result: QueryResult): readonly (QueryDocument | QueryGroup)[];
+export declare function whole(message: QueryMessage): message is KeyedResult;
+export declare function applied(keyed: KeyedResult, message: QueryMessage): KeyedResult;
+export declare function observed(first: unknown, stop: () => void, keyed: boolean): Observed;
+export declare function opened(watch: (deliver: (message: unknown) => void) => () => void, keyed: boolean): Promise<Observation<unknown>>;
+export declare function observing<Topic extends string>(watch: (topic: Topic, input: readonly unknown[], deliver: (message: unknown) => void) => () => void): (topic: Topic, ...input: unknown[]) => Promise<Observation<unknown>>;

package/dist/mdruntime/open.d.ts

@@ -0,0 +1 @@
+export type Open<Value extends string> = Value | (string & {});

package/dist/mdruntime/outcome.d.ts

@@ -0,0 +1,52 @@
+import type { ActionResult, AdapterFailure, BinaryLinkResult, BinaryResult, HistoryResult, ProviderRefusal, RoomVersionAt, ScopedRefusal } from './adapter.js';
+import type { ChangeBatch } from './change.js';
+type Refused<Kind extends string> = ProviderRefusal & {
+    kind: Kind;
+};
+export type Failure = Refused<'transport-uncertainty'> | Refused<'revoked-authorization'> | (Refused<'room-not-readable'> & {
+    locator: string;
+}) | ScopedRefusal;
+export type CallResult = {
+    kind: 'action';
+    result: unknown;
+    at?: RoomVersionAt;
+} | Refused<'rejected'> | Refused<'undeclared'> | Failure;
+export type HistoryAnswer = Exclude<HistoryResult, {
+    kind: Failure['kind'];
+}> | Failure;
+export type BinaryAnswer = {
+    kind: 'binary';
+    blob: Blob;
+} | Refused<'rejected'> | Refused<'absent'> | Failure;
+export type BinaryLinkAnswer = {
+    kind: 'link';
+    url: string;
+    name: string;
+} | Refused<'rejected'> | Refused<'absent'> | Failure;
+export declare function absentBinary(path: string): Refused<'absent'>;
+export declare function binaryAnswer(result: BinaryResult): BinaryAnswer;
+export declare function binaryLinkAnswer(result: BinaryLinkResult): BinaryLinkAnswer;
+export type Offline = {
+    readonly kind: 'offline';
+};
+export declare const OFFLINE: Offline;
+export declare const UNCERTAIN: Failure;
+export declare function undeclared(name: string): CallResult;
+export declare function failure(result: AdapterFailure): Failure;
+export declare function calledResult(result: ActionResult): CallResult;
+export declare function historyAnswer(result: HistoryResult): HistoryAnswer;
+export type Submission = {
+    readonly state: 'waiting' | 'submitted';
+} | {
+    readonly state: 'reset';
+    readonly reset: string;
+};
+export type QueueEntry = {
+    readonly batch: ChangeBatch;
+} & (Submission | {
+    readonly state: 'local';
+} | {
+    readonly state: 'accepted';
+    readonly roomVersion: string;
+});
+export {};

package/dist/mdruntime/overlay.d.ts

@@ -0,0 +1,28 @@
+import type { BinaryFile, HeadChange } from './adapter.js';
+import type { ChangeBatch } from './change.js';
+export type Heads = {
+    revisions: Readonly<Record<string, string>>;
+    fileIds: Readonly<Record<string, string>>;
+    changes: Readonly<Record<string, HeadChange>>;
+};
+export type HeldBinary = ({
+    readonly state: 'accepted';
+} & BinaryFile) | {
+    readonly state: 'pending';
+    readonly localId: string;
+    readonly byteLength: number;
+    readonly mediaType: string;
+    readonly sha256: string;
+};
+export type Layer = Heads & {
+    documents: Readonly<Record<string, string>>;
+    binaries: Readonly<Record<string, HeldBinary>>;
+};
+export declare function acceptedBinaries(files: Readonly<Record<string, BinaryFile>>): Record<string, HeldBinary>;
+export declare function sameBinary(left: HeldBinary | undefined, right: HeldBinary | undefined): boolean;
+export declare function sameChange(left: HeadChange | undefined, right: HeadChange | undefined): boolean;
+export declare function overlay(base: Layer, queue: readonly ChangeBatch[], unapplied?: () => void): Layer;
+export declare function sameLayerText(left: Layer, right: Layer): boolean;
+export declare function sameText(left: Layer, right: Layer): Generator<number, boolean, void>;
+export declare function changedPaths(left: Layer, right: Layer): ReadonlySet<string>;
+export declare function overlayChanged(base: Layer, queue: readonly ChangeBatch[], previousBase: Layer, previousQueue: readonly ChangeBatch[], previousVisible: Layer): Layer;