@agentshouse/mdruntime-families 0.1.0-cf63e048166bf → 0.1.0-cff4656bdc271

package/README.md

@@ -45,10 +45,12 @@ the Room; a list asked for without a page reads every record, window by
 window. react-admin's `update` writes the fields
 that differ from `previousData`, based on it, so the Save of a field another
 writer changed meanwhile is refused; Refine's `update` and either `updateMany`
-compare with the stored record. A list stays current: react-admin's queries of
-a resource are invalidated, and Refine's live mode refetches, when a record a
-page or a read shows changes, a record a filter names starts or stops matching
-it, or a page's total changes.
+compare with the stored record. A Room the Runtime holds locked is left out of
+every list, and a read or a write of a record in it rejects with the code
+`room-locked`. A list stays current: react-admin's queries of a resource are
+invalidated, and Refine's live mode refetches, when a record a page or a read
+shows changes, a record a filter names starts or stops matching it, a page's
+total changes, or a Room the list left out as locked unlocks.
 
 ## License
 

package/dist/mdruntime/adapter.d.ts

@@ -16,6 +16,7 @@ export type OperationScopes = {
 export type ReplicaAdmission = {
     selection: string;
     admission: Open<'admitted' | 'unavailable'>;
+    offline: Open<'locked' | 'open'>;
 };
 export type DiscoveredRoom = {
     name: string;
@@ -49,7 +50,7 @@ export type ListedConversation = {
     outcome: string | null;
     waiting: boolean;
 };
-export type ConversationAction = 'conversation.create' | 'conversation.send' | 'conversation.answer' | 'conversation.interrupt' | 'conversation.kill' | 'conversation.cancel' | 'conversation.delete' | 'conversation.history';
+export type ConversationAction = 'conversation.create' | 'conversation.send' | 'conversation.attach' | 'conversation.answer' | 'conversation.interrupt' | 'conversation.kill' | 'conversation.cancel' | 'conversation.delete' | 'conversation.history';
 export type ConversationMessage = {
     identity: string;
     turn: string;
@@ -198,6 +199,7 @@ export type ActionDeclaration = {
     name: string;
     inputShape: unknown;
     resultKind: unknown;
+    room?: string;
 };
 export type ProviderLimit = {
     name: string;
@@ -253,7 +255,7 @@ export type ContractUnavailable = ProviderRefusal & {
 export type DiscoverResult = Discovery | TransportUncertainty | RevokedAuthorization | ContractUnavailable;
 export type PageToken = string;
 export type ChangeAuthor = {
-    kind: Open<'user' | 'site'>;
+    kind: Open<'user' | 'site' | 'inbox'>;
     id: string;
     name: string;
 };
@@ -272,9 +274,16 @@ export type BinaryFile = {
     mediaType: string;
     sha256: string;
 };
+export type HeldFile = {
+    readonly path: string;
+    readonly revision: string;
+};
 export type HeldContent = {
-    documents: Readonly<Record<string, string>>;
-    revisions: Readonly<Record<string, string>>;
+    files(after: string | null, limit: number): Promise<readonly HeldFile[]>;
+    contents(paths: readonly string[]): Promise<ReadonlyMap<string, {
+        readonly content: string;
+        readonly revision: string;
+    }>>;
 };
 export type BootstrapRequest = {
     locator: string;
@@ -295,6 +304,7 @@ export type BootstrapPage = {
     fileIds?: Readonly<Record<string, string>>;
     changes: Readonly<Record<string, HeadChange>>;
     binaryFiles: Readonly<Record<string, BinaryFile>>;
+    folders?: readonly string[];
     pageToken?: PageToken;
 };
 export type BootstrapResult = BootstrapPage | {
@@ -316,6 +326,8 @@ export type RefreshPage = {
     changes: Readonly<Record<string, HeadChange>>;
     binaryFiles: Readonly<Record<string, BinaryFile>>;
     removals: readonly string[];
+    folders?: readonly string[];
+    folderRemovals?: readonly string[];
     pageToken?: PageToken;
 };
 export type RefreshResult = {
@@ -326,6 +338,7 @@ export type RefreshResult = {
 export type MutationRequest = {
     locator: string;
     changeBatch: ChangeBatch;
+    file(localId: string): Promise<Blob>;
     upload?: unknown;
 };
 export type RetryableRefusal = ProviderRefusal & {
@@ -336,8 +349,7 @@ export type ServiceMode = Open<'open' | 'write-halted'>;
 export type ServiceModeSignal = {
     observe(notify: (mode: ServiceMode) => void): () => void;
 };
-export type MutationResult = {
-    kind: 'accepted';
+export type AcceptedRoom = {
     roomVersion: string;
     documents: Readonly<Record<string, string>>;
     revisions: Readonly<Record<string, string>>;
@@ -345,9 +357,13 @@ export type MutationResult = {
     changes: Readonly<Record<string, HeadChange>>;
     removals: readonly string[];
     binaryFiles?: Readonly<Record<string, BinaryFile>>;
+};
+export type MutationResult = (AcceptedRoom & {
+    kind: 'accepted';
     author?: string;
     time?: string;
-} | (ProviderRefusal & {
+    destination?: AcceptedRoom;
+}) | (ProviderRefusal & {
     kind: 'conflicted';
     roomVersion?: string;
     affected: Readonly<Record<string, string>>;
@@ -364,7 +380,7 @@ export type HistoryAuthor = {
     kind: 'user';
     id: string;
 } | {
-    kind: 'site';
+    kind: 'site' | 'inbox';
     id: string;
     name: string;
 };
@@ -403,15 +419,14 @@ export type BinaryRequest = {
     referrer: unknown;
 };
 export type ReferrerScope = {
-    kind: 'room';
     locator: string;
     path?: string;
-} | {
-    kind: 'conversations';
 };
 export type BinaryResult = {
     kind: 'binary';
-    blob: Blob;
+    body: ReadableStream<Uint8Array>;
+    mediaType: string;
+    sha256?: string;
 } | (ProviderRefusal & {
     kind: 'rejected';
 }) | AdapterFailure;
@@ -440,9 +455,8 @@ export type ActionResult = {
 export type HeldRoom = {
     locator: string;
     roomVersion: string;
-    documents: Readonly<Record<string, string>>;
-    revisions: Readonly<Record<string, string>>;
 };
+export type HeldRevisions = (locator: string, paths: readonly string[]) => Promise<ReadonlyMap<string, string>>;
 export type RoomStreamEvent = {
     kind: 'opened';
 } | {
@@ -477,11 +491,12 @@ export type RoomStream = {
     hold(rooms: readonly HeldRoom[]): void;
     reopen(): void;
     published(locator: string, roomVersion: string): void;
-    observe(notify: (event: RoomStreamEvent) => void, receipts: StreamReceipts): () => void;
+    observe(notify: (event: RoomStreamEvent) => void, receipts: StreamReceipts, revisions: HeldRevisions): () => void;
 };
 export type Adapter = {
     readonly localSaves?: true;
     readonly exhaustiveDiscovery?: true;
+    readonly roomTypes?: string;
     authorize(): Promise<Authorization>;
     discover(authorization: Authorization, scope?: DiscoveryScope): Promise<DiscoverResult>;
     bootstrap(authorization: Authorization, request: BootstrapRequest): Promise<BootstrapResult>;

package/dist/mdruntime/chain.d.ts

@@ -0,0 +1,10 @@
+import type { MdRuntimeClient } from './client.js';
+import type { DocumentQuery, DocumentResult, GroupQuery, GroupResult, PendingResult } from './query.js';
+type Rows = DocumentResult | GroupResult;
+export type WindowAnswer = Rows | PendingResult;
+export type WindowChain = {
+    want(count: number): void;
+    close(): void;
+};
+export declare function chainedWindows(runtime: MdRuntimeClient, query: DocumentQuery | GroupQuery, count: number, publish: (answers: readonly (WindowAnswer | null)[], settled: boolean) => void): WindowChain;
+export {};

package/dist/mdruntime/change-set.d.ts

@@ -1,15 +1,6 @@
-import { type Replica } from './replica.js';
-import { type Row } from './rows.js';
 export type DocumentChange = {
-    locator: string;
-    path: string;
-    before: readonly Row[];
-    after: readonly Row[];
-};
-export type MessageChange = {
-    conversation: string;
-    identity: string;
-    text: string | null;
+    readonly locator: string;
+    readonly path: string | null;
 };
 export type ChangeSet = {
     documents: readonly DocumentChange[];
@@ -20,18 +11,17 @@ export type ChangeSet = {
     rooms: readonly string[];
     queues: readonly string[];
     presentations: readonly string[];
-    messages: readonly MessageChange[];
     conversations: readonly string[];
 };
 type Changed = {
+    documents?: readonly string[] | null;
     drafts?: readonly string[];
     room?: boolean;
     queue?: boolean;
     presentation?: string;
 };
-export declare function changeSet(locator: string, before: Replica | null, after: Replica | null, changed?: Changed): ChangeSet;
-export declare function changing(locator: string, before: Replica | null, after: Replica | null, changed?: Changed): Generator<number, ChangeSet, void>;
-export declare function entering(locator: string, replica: Replica, paths: readonly string[]): ChangeSet;
-export declare function conversationChangeSet(messages: readonly MessageChange[], conversations: readonly string[]): ChangeSet;
+export declare function changeSet(locator: string, changed?: Changed): ChangeSet;
+export declare function conversationChangeSet(conversations: readonly string[]): ChangeSet;
 export declare function mergeChangeSets(sets: readonly ChangeSet[]): ChangeSet;
+export declare function touches(set: ChangeSet, locator: string, path: string): boolean;
 export {};

package/dist/mdruntime/change.d.ts

@@ -1,3 +1,4 @@
+import type { BinaryFile, HeadChange } from './adapter.js';
 export type Change = {
     readonly kind: 'field';
     readonly path: string;
@@ -29,7 +30,6 @@ export type Change = {
     readonly kind: 'binary';
     readonly path: string;
     readonly localId: string;
-    readonly blob: Blob;
     readonly byteLength: number;
     readonly mediaType: string;
     readonly sha256: string;
@@ -40,6 +40,32 @@ export type Change = {
 } | {
     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';
@@ -81,8 +107,12 @@ export type ChangeBatch = {
     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

@@ -3,7 +3,8 @@ 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 { ChosenFile } from './file.js';
+import type { BinaryAnswer, BinaryLinkAnswer, CallResult, 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';
@@ -36,6 +37,7 @@ export type MdRuntimeClient = {
         read(conversation: string, options?: ConversationOptions): Promise<ConversationView>;
         create(input: unknown): Promise<CallResult>;
         send(conversation: string, operation?: string, draft?: ChatDraft): Promise<CallResult | Offline>;
+        attach(room: string, file: ChosenFile): Promise<CallResult | Offline>;
         answer(conversation: string, answer: unknown): Promise<CallResult>;
         interrupt(conversation: string): Promise<CallResult>;
         kill(conversation: string): Promise<CallResult>;
@@ -48,6 +50,7 @@ export type MdRuntimeClient = {
         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>;
         link(room: string, path: string, revision?: string): Promise<BinaryLinkAnswer>;
@@ -58,6 +61,7 @@ export type MdRuntimeClient = {
     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[]>>;
@@ -81,6 +85,7 @@ export type MdRuntimeClient = {
 };
 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 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

@@ -1,9 +1,8 @@
-import { type Document, type Frontmatter, type Validation } from '@agentshouse/mdmodel';
-import { type ModelState } from './model.js';
+import { type Document } from '@agentshouse/mdmodel';
+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>>;
@@ -17,23 +16,10 @@ export type Composition = {
         model: ModelState;
     } | null;
 };
+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, 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 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 unreadable(text: Paths<string>, paths?: Iterable<string> | null): 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/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

@@ -8,13 +8,14 @@ import { type ChatDraftSurface, type ConversationAgent, type ConversationEntry,
 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 BinaryLinkAnswer, type CallResult, type HeldBinaryAnswer, 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 CapacityCause, type CodeAvailability, type Persistence, type Readiness, type SearchObligation } 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[];
@@ -33,6 +34,7 @@ export type AppRoom = {
     documents: number;
     synchronizationAvailable: boolean;
     refusal: ProviderRefusal | null;
+    locked: boolean;
 };
 export type RoomSchemas = {
     collection: TypesResult;
@@ -49,6 +51,7 @@ export type ConnectionRefusal = {
 export type MdRuntimeOptions = {
     adapter: Adapter;
     shell: RuntimeShell;
+    database: RuntimeDatabase;
     authorization?: Authorization;
     signal?: AbortSignal;
     recovery?: Recovery;
@@ -69,7 +72,7 @@ export type SavedParts = {
 };
 export type RoomDraftSurface = {
     list(): Promise<readonly RoomDraft[]>;
-    read(room: string, path: string): RoomDraft | null;
+    read(room: string, path: string): Promise<RoomDraft | null>;
     write(room: string, path: string, revision: string | null, parts: unknown): Promise<RoomDraftWrite>;
     discard(room: string, path: string, revision: string): Promise<RoomDraftWrite>;
 };
@@ -79,9 +82,10 @@ export type PresentationSurface = {
     edit(app: string, members: Readonly<Record<string, unknown>>): Promise<void>;
 };
 export type BinaryFileSurface = {
-    read(room: string, path: string, revision?: string): Promise<BinaryAnswer>;
+    read(room: string, path: string, revision?: string): Promise<HeldBinaryAnswer>;
     link(room: string, path: string, revision?: string): Promise<BinaryLinkAnswer>;
-    readReference(reference: BinaryReference): Promise<BinaryAnswer>;
+    readReference(reference: BinaryReference): Promise<HeldBinaryAnswer>;
+    part(file: string, part: number): Promise<Uint8Array | null>;
 };
 export type HistoryQuery = {
     revision?: string;
@@ -103,12 +107,14 @@ export type MdRuntime = {
     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): boolean;
+    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>>;

package/dist/mdruntime/conversation.d.ts

@@ -1,6 +1,6 @@
 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 ChosenFile } from './file.js';
 import type { Open } from './open.js';
 import { type CallResult, type Offline } from './outcome.js';
 import type { DocumentResult, PendingResult } from './query.js';
@@ -33,7 +33,6 @@ export type RunningTurn = {
 };
 export type ChatDraft = {
     text: string;
-    files: readonly ChatDraftFile[];
 };
 export type ConversationOptions = {
     limit?: number;
@@ -66,6 +65,7 @@ export type ConversationSurface = {
     read(conversation: string, options?: ConversationOptions): Promise<ConversationView>;
     create(input: unknown): Promise<CallResult>;
     send(conversation: string, operation?: string, draft?: ChatDraft): Promise<CallResult | Offline>;
+    attach(room: string, file: ChosenFile): Promise<CallResult | Offline>;
     answer(conversation: string, answer: unknown): Promise<CallResult>;
     interrupt(conversation: string): Promise<CallResult>;
     kill(conversation: string): Promise<CallResult>;
@@ -79,7 +79,7 @@ export type ChatDraftSurface = {
 };
 export type ConversationDependencies = {
     agents(): ConversationAgents | undefined;
-    documents(agents: ConversationAgents): Promise<DocumentResult | PendingResult>;
+    documents(agents: ConversationAgents, after: string | undefined): Promise<DocumentResult | PendingResult>;
     call(name: ConversationAction, input: unknown): Promise<CallResult>;
     durably<T>(work: (local: RuntimeStore) => Promise<T>): Promise<T>;
     stream(): ConversationStream | undefined;

package/dist/mdruntime/durability.d.ts

@@ -1,7 +1,7 @@
 import type { Persistence } from './readiness.js';
 export type StorageEstimate = {
     readonly usage: number;
-    readonly quota: number;
+    readonly total: number;
 };
 export type RuntimeShell = {
     persistence: Persistence;
@@ -9,6 +9,7 @@ export type RuntimeShell = {
     keepGeneration(value: string): void | Promise<void>;
     dropGeneration(): void | Promise<void>;
     estimate?(): Promise<StorageEstimate | null>;
+    cleanUp?(): Promise<number>;
 };
 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/file.d.ts

@@ -1,4 +1,4 @@
-export type ChatDraftFile = {
+export type ChosenFile = {
     name: string;
     blob: Blob;
 };
@@ -7,13 +7,5 @@ export type FileDeclaration = {
     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>;
+export declare function declaredFile(file: ChosenFile): Promise<FileDeclaration>;

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/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;

package/dist/mdruntime/observation.d.ts

@@ -29,3 +29,15 @@ export declare function applied(keyed: KeyedResult, message: QueryMessage): Keye
 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>>;
+export type Digest = {
+    readonly pending: string;
+} | {
+    readonly keys: readonly RowKey[];
+    readonly rows: ReadonlyMap<RowKey, number>;
+    readonly coverage: string;
+    readonly next: string | undefined;
+    readonly total: number | undefined;
+};
+export declare function digestOf({ result, keys }: KeyedResult): Digest;
+export declare function digestApplied(digest: Digest, message: QueryMessage): Digest;
+export declare function changeOf(previous: Digest, next: KeyedResult): QueryMessage | null;

package/dist/mdruntime/opened.d.ts

@@ -0,0 +1,21 @@
+import type { BinaryResult } from './adapter.js';
+import { type RuntimeDatabase } from './tables.js';
+export type OpenedName = {
+    readonly locator: string;
+    readonly path: string;
+    readonly revision: string;
+};
+export type KeptBinary = {
+    readonly kind: 'binary';
+    readonly file: string;
+    readonly byteLength: number;
+    readonly mediaType: string;
+};
+export type KeptResult = KeptBinary | Exclude<BinaryResult, {
+    kind: 'binary';
+}>;
+export type OpenedFiles = {
+    find(name: OpenedName): Promise<KeptBinary | null>;
+    fetch(name: OpenedName, read: () => Promise<BinaryResult>): Promise<KeptResult>;
+};
+export declare function openedFiles(database: RuntimeDatabase, fenced: (locator: string) => boolean): OpenedFiles;