@agentshouse/app-bridge 0.1.0-ccf413b4e709d → 0.1.0-cd2d3edbf9805

package/dist/mdruntime/change.d.ts

@@ -0,0 +1,118 @@
+import type { BinaryFile, HeadChange } from './adapter.js';
+export type Change = {
+    readonly kind: 'field';
+    readonly path: string;
+    readonly name: string;
+    readonly value: unknown;
+} | {
+    readonly kind: 'section';
+    readonly path: string;
+    readonly name: string;
+    readonly value: string;
+} | {
+    readonly kind: 'preamble';
+    readonly path: string;
+    readonly value: string;
+} | {
+    readonly kind: 'create';
+    readonly path: string;
+    readonly fields: Readonly<Record<string, unknown>>;
+    readonly sections: Readonly<Record<string, string>>;
+} | {
+    readonly kind: 'create';
+    readonly path: string;
+    readonly content: string;
+} | {
+    readonly kind: 'replace';
+    readonly path: string;
+    readonly content: string;
+} | {
+    readonly kind: 'binary';
+    readonly path: string;
+    readonly localId: string;
+    readonly byteLength: number;
+    readonly mediaType: string;
+    readonly sha256: string;
+} | {
+    readonly kind: 'move';
+    readonly path: string;
+    readonly to: string;
+} | {
+    readonly kind: 'remove';
+    readonly path: string;
+} | (Arriving & {
+    readonly content: string;
+}) | (Arriving & {
+    readonly binary: BinaryFile;
+});
+type Arriving = {
+    readonly kind: 'arrival';
+    readonly path: string;
+    readonly revision?: string;
+    readonly fileId?: string;
+    readonly change?: HeadChange;
+};
+export type RoomMove = {
+    readonly source: {
+        readonly room: string;
+        readonly baseRoomVersion: string;
+    };
+    readonly destination: {
+        readonly room: string;
+        readonly baseRoomVersion: string;
+        readonly handle: string;
+    };
+    readonly moves: readonly {
+        readonly path: string;
+        readonly to: string;
+    }[];
+};
+export type Precondition = {
+    readonly kind: 'field';
+    readonly path: string;
+    readonly name: string;
+    readonly value: unknown;
+} | {
+    readonly kind: 'section';
+    readonly path: string;
+    readonly name: string;
+    readonly value: string;
+} | {
+    readonly kind: 'preamble';
+    readonly path: string;
+    readonly value: string;
+} | {
+    readonly kind: 'revision';
+    readonly path: string;
+    readonly revision: string;
+} | {
+    readonly kind: 'content';
+    readonly path: string;
+    readonly content: string;
+} | {
+    readonly kind: 'present';
+    readonly path: string;
+} | {
+    readonly kind: 'absent';
+    readonly path: string;
+};
+export type WrittenBy = {
+    readonly app: string;
+    readonly release: string;
+};
+export type ChangeBatch = {
+    validation?: import('./model.js').ValidationReceipt;
+    readonly id: string;
+    readonly baseRoomVersion: string;
+    readonly changes: readonly Change[];
+    readonly preconditions: readonly Precondition[];
+    readonly writtenBy?: WrittenBy;
+    readonly between?: RoomMove;
+};
+export declare function immutable(batch: ChangeBatch): ChangeBatch;
+export declare function partnerOf(batch: ChangeBatch, locator: string): string | null;
+export declare function leaving(batch: ChangeBatch, locator: string): boolean;
+export declare function landing(changes: readonly Change[], index: number, path: string): string | null;
+export declare function departure(changes: readonly Change[], index: number): string;
+export declare function queuedFile(batch: ChangeBatch, path: string, localId: string): number;
+export {};

package/dist/mdruntime/client.d.ts

@@ -0,0 +1,90 @@
+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 { AttachAnswer, BinaryAnswer, CallResult, DownloadAnswer, HistoryAnswer, Offline, QueueEntry, Resolution } 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, next?: string): 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>;
+    resolve(room: string, path: string, destination: string): Promise<Resolution>;
+    binaryFile: {
+        read(room: string, path: string, revision?: string): Promise<BinaryAnswer>;
+        attach(room: string, file: File): Promise<AttachAnswer>;
+        download(room: string, path: string, revision?: string): Promise<DownloadAnswer>;
+    };
+    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>;
+    cleanUp(): Promise<number>;
+    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 { chainedWindows, type WindowAnswer, type WindowChain } from './chain.js';
+export { roomDraftRevision } from './identity.js';
+export { defineRoomMedia, ROOM_MEDIA } from './media.js';
+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,27 @@
+import { type Document } from '../mdmodel/index.js';
+import type { ModelState } from './model.js';
+import type { MdModelIdentity } from './adapter.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 type Composed = {
+    readonly composition: Composition;
+    readonly fingerprint: string;
+};
+export declare function composedOf(composition: Composition): Composed;
+export declare function selected(composition: Composition, path: string): boolean;
+export declare function governing(composition: Composition, path: string): ModelState;
+export declare function collectionOf(text: Readonly<Record<string, string>>, composition: Composition): Collection;
+export declare function documentsOf(collection: Collection): Generator<number, Iterable<readonly [string, Document]>, void>;
+export declare function validRoot(root: unknown): root is string;
+export declare function available(composition: Composition): boolean;

package/dist/mdruntime/compile.d.ts

@@ -0,0 +1,15 @@
+import type { Plan, QueryRows } from './query.js';
+import type { Connection, Value } from './tables.js';
+export type QueryRoom = {
+    readonly locator: string;
+    readonly key: number;
+};
+export type Fragment = {
+    readonly sql: string;
+    readonly bind: readonly Value[];
+};
+export type QueryAnswer = QueryRows & {
+    readonly more?: string;
+};
+export declare function selected(connection: Connection, plan: Plan, rooms: readonly QueryRoom[]): Fragment;
+export declare function answerQuery(connection: Connection, plan: Plan, rooms: readonly QueryRoom[], budget?: number | null): QueryAnswer;

package/dist/mdruntime/connection.d.ts

@@ -0,0 +1,152 @@
+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 AttachAnswer, type BinaryLinkAnswer, type CallResult, type HeldBinaryAnswer, type HeldShownAnswer, type HistoryAnswer, type QueueEntry, type Resolution } 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 CodeAvailability, type Persistence, type Readiness, type SearchObligation, type Space } from './readiness.js';
+import type { RuntimeDatabase } from './tables.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;
+    locked: boolean;
+};
+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;
+    database: RuntimeDatabase;
+    authorization?: Authorization;
+    signal?: AbortSignal;
+    recovery?: Recovery;
+    usableWhenHeld?: readonly string[];
+};
+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): Promise<RoomDraft | null>;
+    write(room: string, path: string, revision: string | null, parts: unknown, next?: string): 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<HeldBinaryAnswer>;
+    link(room: string, path: string, revision?: string): Promise<BinaryLinkAnswer>;
+    show(room: string, path: string, revision?: string): Promise<HeldShownAnswer>;
+    attach(room: string, file: File): Promise<AttachAnswer>;
+    part(file: string, part: number): Promise<Uint8Array | null>;
+};
+export type HistoryQuery = {
+    revision?: string;
+    pageToken?: string;
+};
+export type MdRuntime = {
+    loaded(): Promise<void>;
+    rooms(): Promise<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>;
+    resolve(room: string, path: string, destination: string): Promise<Resolution>;
+    binaryFile: BinaryFileSurface;
+    call(name: string, input: unknown): Promise<CallResult>;
+    reached(locator: string, roomVersion: string, path?: string): Promise<boolean>;
+    log(): string;
+    persistence(): boolean;
+    retry(): Promise<void>;
+    cleanUp(): Promise<number>;
+    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 space: Space | null;
+    readonly search: SearchObligation;
+};
+export type ComposedRuntime = RuntimeView & {
+    seed(entry: EntrySeed): void;
+    stop(): 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,113 @@
+import type { ConversationAction, ConversationEvent, ConversationMessage, ConversationStream, ListedConversation, ProcessCommand, SessionOption, TurnContext } from './adapter.js';
+import { type ChangeSet } from './change-set.js';
+import type { Open } from './open.js';
+import { type CallResult, type Offline } from './outcome.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;
+    };
+    name: string;
+    created: string;
+    finished: string | null;
+    outcome: string | null;
+    waiting: boolean;
+    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;
+};
+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[];
+    starting: string | null;
+    link: {
+        connected: boolean;
+    } | null;
+    deliveryUnknown: readonly string[];
+    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 = {
+    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;
+    full(): boolean;
+    closed(): boolean;
+    unanswered(): void;
+    expired(operation: string): boolean;
+};
+export type ConversationStore = {
+    surface: ConversationSurface;
+    chatDraft: ChatDraftSurface;
+    hydrate(held: readonly HeldConversation[], drafts: readonly ChatDraftRecord[], list: readonly ListedConversation[] | null): void;
+    reconcile(): Promise<void>;
+    catchUp(progress: CycleProgress): Promise<void>;
+    resend(progress: CycleProgress): Promise<void>;
+    current(): boolean;
+    known(): boolean;
+    learned(): 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 const HISTORY_CONVERSATIONS = 64;
+export declare function newChat(agent: string): string;
+export declare function createConversationStore(deps: ConversationDependencies): ConversationStore;

package/dist/mdruntime/durability.d.ts

@@ -0,0 +1,11 @@
+import type { Persistence } from './readiness.js';
+export type RuntimeShell = {
+    persistence: Persistence;
+    generation: string | null;
+    keepGeneration(value: string): void | Promise<void>;
+    dropGeneration(): void | Promise<void>;
+    cleanUp?(): Promise<number>;
+};
+export declare function refusedForSpace(error: unknown): boolean;
+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/fulltext.d.ts

@@ -0,0 +1,26 @@
+import { type QueryRoom } from './compile.js';
+import type { Plan } from './query.js';
+import type { HitCursor, SearchWindow } from './search.js';
+import type { Connection } from './tables.js';
+export declare const SEARCH_TABLES: readonly string[];
+export type SearchAsk = {
+    readonly text: string;
+    readonly limit: number;
+    readonly after: readonly [HitCursor, HitCursor] | null;
+    readonly total: boolean;
+    readonly documents: {
+        readonly plan: Plan;
+        readonly rooms: readonly QueryRoom[];
+        readonly beneath: readonly {
+            readonly key: number;
+            readonly roots: readonly string[];
+        }[];
+    } | null;
+    readonly conversations: readonly string[];
+};
+export declare function indexDocument(connection: Connection, id: number, path: string, content: string): void;
+export declare function indexMessage(connection: Connection, id: number, text: string): void;
+export declare function unindexDocuments(connection: Connection, ids: Iterable<number>): void;
+export declare function unindexMessages(connection: Connection, ids: Iterable<number>): void;
+export declare function unindexAll(connection: Connection): void;
+export declare function searched(connection: Connection, ask: SearchAsk): SearchWindow;

package/dist/mdruntime/identity.d.ts

@@ -0,0 +1,6 @@
+export declare function changeBatchIdentity(at?: number): string;
+export declare function identityTime(identity: string): number;
+export declare function roomDraftRevision(): string;
+export declare function chatDraftRevision(): string;
+export declare function transferIdentity(): string;
+export declare function binaryLocalId(): string;

package/dist/mdruntime/media.d.ts

@@ -0,0 +1,7 @@
+import type { MdRuntimeClient } from './client.js';
+import { type ShownAnswer } from './outcome.js';
+export declare const ROOM_MEDIA = "room-media";
+type Show = (room: string, path: string, revision?: string) => Promise<ShownAnswer>;
+export declare function shownBy(show: Show, client: MdRuntimeClient): MdRuntimeClient;
+export declare function defineRoomMedia(client: Promise<MdRuntimeClient> | MdRuntimeClient, registry?: CustomElementRegistry): void;
+export {};

package/dist/mdruntime/messages.d.ts

@@ -0,0 +1,27 @@
+import type { AcceptedMessage } from './adapter.js';
+import type { Connection } from './tables.js';
+export declare const MESSAGE_TABLES: readonly string[];
+export type HeldConversation = {
+    readonly conversation: string;
+    readonly read: string | null | undefined;
+    readonly partial: boolean;
+};
+export type MessageWindow = {
+    readonly messages: AcceptedMessage[];
+    readonly more: boolean;
+};
+export type ConversationWrite = {
+    readonly conversation: string;
+    readonly messages: readonly AcceptedMessage[];
+    readonly read?: {
+        readonly at: string | null;
+        readonly partial: boolean;
+    };
+};
+export declare function heldConversations(connection: Connection): HeldConversation[];
+export declare function keptMessages(connection: Connection, { conversation, messages, read }: ConversationWrite): null;
+export declare function messageWindow(connection: Connection, conversation: string, limit: number, before: readonly [string, string] | null): MessageWindow;
+export declare function messageCount(connection: Connection, conversation: string): number;
+export declare function turnArrived(connection: Connection, conversation: string, turn: string): boolean;
+export declare function droppedMessages(connection: Connection, conversations: readonly string[]): void;
+export declare function forgottenMessages(connection: Connection): void;