@agentshouse/app-bridge 0.1.0-c1b72582712c7 → 0.1.0-c1bc683ed8f4e

package/dist/calls.d.ts

@@ -53,7 +53,7 @@ export interface HouseCalls {
             readonly name: string;
             readonly width?: number;
         }[];
-        readonly operation_id?: string;
+        readonly operation_id: string;
         readonly text?: string;
     };
     readonly 'conversation.setOption': {

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-import type { MdRuntimeClient } from './mdruntime/client.js';
+import type { MdRuntimeClient, Open } from './mdruntime/client.js';
 import type { HouseCalls } from './calls.js';
 export type { HouseCalls } from './calls.js';
-type Open<Value extends string> = Value | (string & {});
 export type HouseCallInput<Name extends string> = Name extends keyof HouseCalls ? HouseCalls[Name] : unknown;
 export interface HouseRuntime extends Omit<MdRuntimeClient, 'call'> {
     call<Name extends Open<keyof HouseCalls>>(name: Name, input: HouseCallInput<Name>): ReturnType<MdRuntimeClient['call']>;
@@ -110,6 +109,20 @@ export interface HouseBrowserRefused extends Error {
     readonly code: string;
     readonly retryable: boolean;
 }
+export interface HouseTrialWithheld {
+    readonly code: Open<'house_trial_withheld'>;
+    readonly retryable: true;
+}
+export type HouseTask = unknown;
+export type HouseActivation = Open<'committed' | 'abandoned'>;
+export interface HouseCooperation {
+    checkpoint(): Promise<void> | void;
+    persist(): Promise<void> | void;
+    capture(): Promise<HouseTask> | HouseTask;
+    restore(task: HouseTask | null): Promise<void> | void;
+    ready(): Promise<boolean> | boolean;
+    settle(activation: HouseActivation): void;
+}
 export interface HouseBridge {
     readonly runtime: Promise<HouseRuntime>;
     address(): string | null;
@@ -130,6 +143,7 @@ export interface HouseBridge {
     onStatus(listener: (status: HouseStatus) => void): () => void;
     messages(listener: (message: HouseAppMessage) => void): () => void;
     analyticsConsent(choice: HouseAnalyticsChoice): void;
+    cooperate(cooperation: HouseCooperation): () => void;
 }
 export interface HouseHeld {
     readonly houseBridge: HouseBridge;

package/dist/mdmodel/document.d.ts

@@ -1,6 +1,7 @@
 import { type Definition } from './definition.js';
-import type { ApplyResult, BodyResult, Change, Document, Link, LinkOccurrence, ParseResult } from './types.js';
+import type { ApplyResult, BodyResult, FrontmatterResult, Change, Document, Link, LinkOccurrence, ParseResult } from './types.js';
 import { type YamlMap } from './yaml.js';
+export declare function parseFrontmatter(content: string, file?: string): FrontmatterResult;
 export declare function parse(content: string, file?: string): ParseResult;
 export declare function relativize(document: Document, file: string, handle: string, definition?: Definition): ApplyResult;
 export declare function relativizeBody(body: string, file: string, handle: string): BodyResult;

package/dist/mdmodel/index.d.ts

@@ -3,7 +3,7 @@ export type { Actor, Condition, ConditionScope, ConditionTest, ConditionValue, C
 export { headingLines } from './blocks.js';
 export type { HeadingLine } from './blocks.js';
 export { divide } from './divide.js';
-export { apply, bodyLinks, fieldStart, linkOccurrences, links, parse, relativize, relativizeBody, relinkBody, serialize, } from './document.js';
+export { apply, bodyLinks, fieldStart, linkOccurrences, links, parse, parseFrontmatter, relativize, relativizeBody, relinkBody, serialize, } from './document.js';
 export { HOUSE_FIELDS, MEMBER_FIELD, RECEIVED_FIELD, SITE_FIELD, TYPE_FIELD } from './fields.js';
 export { relative, retarget, target } from './paths.js';
 export { MARKDOWN_SYNTAX_PROFILE } from './profile.js';
@@ -11,8 +11,8 @@ export { project } from './project.js';
 export { references } from './references.js';
 export { ARRAY_INDEX, ATTACHMENT, crossedFacts, escapePointer, itemFacts, memberFacts, pointerFacts, pointerSegments, } from './definition.js';
 export type { Definition, JsonType, PatternFacts, PointerFacts, SectionSpec, Shape, ValueFacts, } from './definition.js';
-export type { ApplyResult, BodyResult, Change, Division, DivisionContext, Document, Library, ModelVerification, Link, LinkOccurrence, ParseResult, Projection, ProjectionContext, Reference, Refusal, Span, Validation, ValidationContext, VerifiedModel, } from './types.js';
-export { validate, verify } from './validate.js';
+export type { ApplyResult, BodyResult, Change, Division, DivisionContext, Document, DocumentCheck, Frontmatter, FrontmatterResult, Library, ModelVerification, Link, LinkOccurrence, ParseResult, Projection, ProjectionContext, Reached, Reference, Refusal, Span, Validation, ValidationContext, VerifiedModel, } from './types.js';
+export { checkDocument, resolves, sectionReferences, validate, verify } from './validate.js';
 export { VERSION } from './version.js';
 export { equalValue, frontmatterValue } from './yaml.js';
 export type { FrontmatterValue } from './yaml.js';

package/dist/mdmodel/references.d.ts

@@ -1,3 +1,3 @@
 import { type Definition } from './definition.js';
-import type { Document, Reference } from './types.js';
-export declare function references(document: Document, definition: Definition): readonly Reference[];
+import type { Frontmatter, Reference } from './types.js';
+export declare function references(document: Pick<Frontmatter, 'fields'>, definition: Definition): readonly Reference[];

package/dist/mdmodel/types.d.ts

@@ -28,10 +28,12 @@ export type Extent = {
 export type Span = Extent & {
     readonly text: string;
 };
-export type Document = {
+export type Frontmatter = {
     readonly content: string;
     readonly type: string | undefined;
     readonly fields: Readonly<Record<string, unknown>>;
+};
+export type Document = Frontmatter & {
     readonly preamble: string;
     readonly sections: Readonly<Record<string, string>>;
 };
@@ -41,6 +43,18 @@ export type Refusal = {
     readonly location?: string;
     readonly referrers?: readonly string[];
 };
+export type Reached = {
+    readonly target: string | null;
+    readonly to: readonly string[];
+};
+export type DocumentCheck = {
+    readonly ok: false;
+} | {
+    readonly ok: true;
+    readonly type: string;
+    readonly typed: boolean;
+    readonly references: readonly Reached[];
+};
 export type Validation = {
     readonly verdict: 'accept';
 } | ({
@@ -60,6 +74,13 @@ export type Division = {
     readonly ok: false;
     readonly refusal: Refusal;
 };
+export type FrontmatterResult = {
+    readonly ok: true;
+    readonly frontmatter: Frontmatter;
+} | {
+    readonly ok: false;
+    readonly refusal: Refusal;
+};
 export type ParseResult = {
     readonly ok: true;
     readonly document: Document;

package/dist/mdmodel/validate.d.ts

@@ -1,3 +1,7 @@
-import type { Library, ModelVerification, Validation, ValidationContext, VerifiedModel } from './types.js';
+import { type Definition } from './definition.js';
+import type { DocumentCheck, Library, ModelVerification, Reached, Validation, ValidationContext, VerifiedModel } from './types.js';
+export declare function resolves(reference: Reached, typeOf: (path: string) => string | undefined, binary: (path: string) => boolean): boolean;
 export declare function verify(schema: string): ModelVerification;
+export declare function checkDocument(file: string, content: string, model: VerifiedModel): DocumentCheck;
+export declare function sectionReferences(file: string, content: string, definition: Definition): readonly Reached[];
 export declare function validate(library: Library, context?: ValidationContext, model?: VerifiedModel): Validation;

package/dist/mdruntime/acquisition.d.ts

@@ -0,0 +1,13 @@
+export type RuntimeDemand = {
+    readonly whole: boolean;
+    readonly rooms: readonly string[];
+    readonly handles: readonly string[];
+    readonly conversations: boolean;
+};
+export declare const WHOLE_DEMAND: RuntimeDemand;
+export declare function demanded(demand: RuntimeDemand, room: {
+    readonly locator: string;
+    readonly handle: string;
+}): boolean;
+export declare function wider(next: RuntimeDemand, current: RuntimeDemand): boolean;
+export declare function narrower(next: RuntimeDemand, current: RuntimeDemand): boolean;

package/dist/mdruntime/adapter.d.ts

@@ -238,17 +238,15 @@ export type ContractUnavailable = ProviderRefusal & {
 export type DiscoverResult = Discovery | TransportUncertainty | RevokedAuthorization | ContractUnavailable;
 export type PageToken = string;
 export type ChangeAuthor = {
-    kind: 'user';
+    kind: Open<'user' | 'site'>;
     id: string;
     name: string;
-} | {
-    kind: 'site';
+};
+export type Member = {
+    kind: Open<'user'>;
     id: string;
     name: string;
 };
-export type Member = Extract<ChangeAuthor, {
-    kind: 'user';
-}>;
 export type HeadChange = {
     author: ChangeAuthor | null;
     time: string;
@@ -259,10 +257,15 @@ export type BinaryFile = {
     mediaType: string;
     sha256: string;
 };
+export type HeldContent = {
+    documents: Readonly<Record<string, string>>;
+    revisions: Readonly<Record<string, string>>;
+};
 export type BootstrapRequest = {
     locator: string;
     selection: string;
     pageToken?: PageToken;
+    held?: HeldContent;
 };
 export type RoomModels = {
     collection?: ModelResult;
@@ -278,7 +281,9 @@ export type BootstrapPage = {
     binaryFiles: Readonly<Record<string, BinaryFile>>;
     pageToken?: PageToken;
 };
-export type BootstrapResult = BootstrapPage | AdapterFailure;
+export type BootstrapResult = BootstrapPage | {
+    kind: 'beyond-horizon';
+} | AdapterFailure;
 export type RefreshRequest = {
     locator: string;
     selection: string;
@@ -335,6 +340,7 @@ export type MutationResult = {
     kind: 'write-halted';
 } | {
     kind: 'expired';
+    restored?: true;
 } | AdapterFailure;
 export type HistoryAuthor = {
     kind: 'user';
@@ -425,10 +431,28 @@ export type RoomStreamEvent = {
     locator: string;
     roomVersion: string;
 };
+export type KeptReceipt = {
+    key: string;
+    head: unknown;
+};
+export type StreamReceipts = {
+    heads(): Promise<readonly KeptReceipt[]>;
+    parts(key: string, count: number): Promise<readonly unknown[]>;
+    keep(key: string, head: unknown, part?: {
+        index: number;
+        value: unknown;
+    }): Promise<void>;
+    drop(keys: readonly string[]): Promise<void>;
+};
+export type AcquiredDemand = {
+    rooms: readonly string[];
+    conversations: boolean;
+};
 export type RoomStream = {
-    hold(rooms: readonly HeldRoom[]): void;
+    hold(rooms: readonly HeldRoom[], demand: AcquiredDemand | null): void;
     reopen(): void;
-    observe(notify: (event: RoomStreamEvent) => void): () => void;
+    published(locator: string, roomVersion: string): void;
+    observe(notify: (event: RoomStreamEvent) => void, receipts: StreamReceipts): () => void;
 };
 export type Adapter = {
     readonly localSaves?: true;

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

@@ -9,6 +9,7 @@ export type DocumentChange = {
 export type MessageChange = {
     conversation: string;
     identity: string;
+    text: string | null;
 };
 export type ChangeSet = {
     documents: readonly DocumentChange[];
@@ -28,5 +29,6 @@ export declare function changeSet(locator: string, before: Replica | null, after
     queue?: boolean;
     presentation?: string;
 }): ChangeSet;
+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 mergeChangeSets(sets: readonly ChangeSet[]): ChangeSet;

package/dist/mdruntime/client.d.ts

@@ -4,16 +4,17 @@ import type { ChatDraft, ConversationAgent, ConversationEntry, ConversationOptio
 import { type Observation } from './observation.js';
 import type { BinaryReference } from './binary.js';
 import type { BinaryAnswer, CallResult, HistoryAnswer, Offline, QueueEntry } from './outcome.js';
-import type { DocumentQuery, DocumentResult, GroupQuery, GroupResult } from './query.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>;
-        (query: GroupQuery): Promise<GroupResult>;
+        (query: DocumentQuery): Promise<DocumentResult | PendingResult>;
+        (query: GroupQuery): Promise<GroupResult | PendingResult>;
     };
     search(request: SearchRequest): Promise<SearchResult>;
     types(locator: string): Promise<RoomSchemas>;
@@ -52,16 +53,18 @@ export type MdRuntimeClient = {
     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>>;
-        (topic: 'query', query: GroupQuery): Promise<Observation<GroupResult>>;
+        (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>>;
@@ -75,4 +78,5 @@ export type MdRuntimeClient = {
 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 { RuntimePort } from './wire.js';
+export type { Open } from './open.js';
+export { unanswered, type RuntimePort, type WireMember } from './wire.js';

package/dist/mdruntime/collection.d.ts

@@ -1,7 +1,9 @@
-import { type Document, type Validation } from '../mdmodel/index.js';
-import type { ModelState } from './model.js';
+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>>;
@@ -17,8 +19,20 @@ export type Composition = {
 };
 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 passingDocument(collection: Collection, path: string): Document | undefined;
+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>>): Refused | null;
 export declare function validRoot(root: unknown): root is string;
 export declare function validateCollection(text: Readonly<Record<string, string>>, binaryTargets: readonly string[], composition: Composition): Validation;
+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): boolean;
+export {};

package/dist/mdruntime/connection.d.ts

@@ -1,6 +1,6 @@
 import { type TypesResult } from './model.js';
 import { type Observation } from './observation.js';
-import { type DocumentQuery, type DocumentResult, type GroupQuery, type GroupResult } from './query.js';
+import { type DocumentQuery, type DocumentResult, type GroupQuery, type GroupResult, type PendingResult } from './query.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';
@@ -8,10 +8,13 @@ import { type WrittenBy } from './change.js';
 import type { Open } from './open.js';
 import { type BinaryReference } from './binary.js';
 import { type BinaryAnswer, 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 RoomDraftWrite } from './room-draft.js';
 import { type SyncStatus } from './status.js';
 import { type RuntimeShell } from './durability.js';
+import { type RuntimeDemand } from './acquisition.js';
+import { type CapacityCause, type CodeAvailability, type Persistence, type Readiness } from './readiness.js';
 import { type NarrowedView, type PortReach, type RuntimeView } from './reach.js';
 export type AppTypedSelection = {
     roots: readonly string[];
@@ -48,6 +51,7 @@ export type MdRuntimeOptions = {
     shell: RuntimeShell;
     authorization?: Authorization;
     signal?: AbortSignal;
+    recovery?: Recovery;
 };
 export type SaveResult = {
     outcome: 'saved';
@@ -81,8 +85,8 @@ export type MdRuntime = {
     loaded(): Promise<void>;
     rooms(): readonly AppRoom[];
     query: {
-        (query: DocumentQuery): Promise<DocumentResult>;
-        (query: GroupQuery): Promise<GroupResult>;
+        (query: DocumentQuery): Promise<DocumentResult | PendingResult>;
+        (query: GroupQuery): Promise<GroupResult | PendingResult>;
     };
     search(request: SearchRequest): Promise<SearchResult>;
     types(locator: string): RoomSchemas;
@@ -97,15 +101,17 @@ export type MdRuntime = {
     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>>;
-        (topic: 'query', query: GroupQuery): Promise<Observation<GroupResult>>;
+        (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>>;
@@ -115,11 +121,18 @@ export type MdRuntime = {
     };
     reauthorize(): Promise<void>;
 };
-export type RuntimeTopic = 'rooms' | 'connection-refusal' | 'storage-loss' | 'sync-status' | 'service-mode' | 'member' | 'query' | 'queue' | 'room-drafts' | 'presentation' | 'conversation' | 'conversations' | 'agents';
+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;
+};
 export type ComposedRuntime = RuntimeView & {
     stop(): Promise<void>;
     lose(locators: readonly string[]): Promise<void>;
-    within(reach: PortReach | null): NarrowedView;
+    acquire(demand: RuntimeDemand): 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

@@ -3,8 +3,7 @@ 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 } from './query.js';
-import type { SearchedMessage } from './search.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'>;
@@ -69,13 +68,15 @@ export type ChatDraftSurface = {
 };
 export type ConversationDependencies = {
     agents(): ConversationAgents | undefined;
-    documents(locator: string): Promise<DocumentResult>;
+    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;
@@ -85,15 +86,18 @@ export type ConversationStore = {
     catchUp(progress: CycleProgress): Promise<void>;
     resend(progress: CycleProgress): Promise<void>;
     current(): boolean;
+    known(): boolean;
     reconnected(): void;
+    reopened(): 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;
-    messages(): readonly SearchedMessage[];
-    message(conversation: string, identity: string): SearchedMessage | null;
+    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 createConversationStore(deps: ConversationDependencies): ConversationStore;

package/dist/mdruntime/durability.d.ts

@@ -1,8 +1,14 @@
+import type { Persistence } from './readiness.js';
+export type StorageEstimate = {
+    readonly usage: number;
+    readonly quota: number;
+};
 export type RuntimeShell = {
-    persistentStorage: boolean;
+    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/model.d.ts

@@ -29,12 +29,13 @@ export type ModelState = {
     types: VerifiedModel['types'];
 };
 export type TypesResult = {
-    status: 'unavailable';
+    status: Open<'unavailable'>;
     reason: ModelUnavailableReason;
+    types: null;
     schema?: string | null;
     revision?: string | null;
 } | {
-    status: 'current' | 'cached';
+    status: Open<'current' | 'cached'>;
     identity: string;
     version: string;
     verifiedWith: ModelIdentity;
@@ -52,4 +53,5 @@ export declare function definitionOf(state: ModelState, type: string | 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

@@ -1,4 +1,4 @@
-import type { QueryDocument, QueryGroup, QueryResult } from './query.js';
+import type { QueryCoverage, QueryDocument, QueryGroup, QueryResult } from './query.js';
 export type Observation<T> = {
     current(): T;
     subscribe(listener: (value: T) => void): () => void;
@@ -13,14 +13,17 @@ export type QueryChange = {
     changed: readonly (readonly [RowKey, QueryDocument | QueryGroup])[];
     removed: readonly RowKey[];
     order: readonly RowKey[] | null;
+    coverage?: QueryCoverage;
 };
+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 applied(keyed: KeyedResult, change: QueryChange): KeyedResult;
+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/overlay.d.ts

@@ -22,4 +22,5 @@ export declare function sameBinary(left: HeldBinary | undefined, right: HeldBina
 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 changedPaths(left: Layer, right: Layer): ReadonlySet<string>;
 export declare function overlayChanged(base: Layer, queue: readonly ChangeBatch[], previousBase: Layer, previousQueue: readonly ChangeBatch[], previousVisible: Layer): Layer;

package/dist/mdruntime/query.d.ts

@@ -1,6 +1,7 @@
 import { type Definition } from '../mdmodel/index.js';
 import type { HeadChange } from './adapter.js';
 import type { BinaryFileRecord } from './binary.js';
+import type { Open } from './open.js';
 export type Value = string | number | boolean | null;
 export type Predicate = Value | {
     $eq: Value;
@@ -100,13 +101,38 @@ export type QueryGroup = {
     key: readonly unknown[];
     count: number;
 };
-export type DocumentResult = {
+export type CoveredRoom = {
+    room: string;
+    generation: string;
+    current: boolean;
+};
+export type QueryCoverage = {
+    rooms: readonly CoveredRoom[];
+    indexes: readonly string[];
+    overlay: readonly string[];
+};
+export type Awaits = Open<'acquisition' | 'preparation' | 'index'>;
+export type PendingRoom = {
+    room: string;
+    awaits: Awaits;
+};
+export type PendingResult = {
+    pending: readonly PendingRoom[];
+};
+export type DocumentRows = {
     documents: readonly QueryDocument[];
 };
-export type GroupResult = {
+export type GroupRows = {
     groups: readonly QueryGroup[];
 };
-export type QueryResult = DocumentResult | GroupResult;
+export type QueryRows = DocumentRows | GroupRows;
+export type DocumentResult = DocumentRows & {
+    coverage: QueryCoverage;
+};
+export type GroupResult = GroupRows & {
+    coverage: QueryCoverage;
+};
+export type QueryResult = DocumentResult | GroupResult | PendingResult;
 export type QueryErrorCode = 'invalid-query' | 'unknown-type' | 'unknown-field' | 'wrong-kind';
 export type RoomFacts = {
     locator: string;

package/dist/mdruntime/reach.d.ts

@@ -1,6 +1,7 @@
 import type { ReferrerScope } from './adapter.js';
-import type { MdRuntime, RuntimeTopic } from './connection.js';
+import type { MdRuntime, ReadinessPort, RuntimeTopic } from './connection.js';
 import type { Plan, PlanReach, QueryResult } from './query.js';
+import type { Readiness } from './readiness.js';
 import type { SearchResult } from './search.js';
 export type ReachedDocument = {
     readonly room: string;
@@ -19,12 +20,15 @@ export type RuntimeView = {
 };
 export type NarrowedView = RuntimeView & {
     narrow(reach: PortReach | null): void;
+    facts(port: ReadinessPort): void;
 };
 export type Reachable = RuntimeView & {
     plan(input: unknown, reach: PortReach | null): Plan;
     query(plan: Plan): Promise<QueryResult>;
     watchPlan(plan: Plan, deliver: (message: unknown) => void): () => void;
     search(input: unknown, reach: PortReach | null): Promise<SearchResult>;
+    searching(target: string): void;
+    watchReadiness(port: ReadinessPort, reach: PortReach | null, deliver: (readiness: Readiness) => void): () => void;
     referrerScope(referrer: unknown): ReferrerScope | null;
 };
 export declare function holds(reach: PortReach | null, room: string): boolean;
@@ -38,4 +42,4 @@ export declare function governs(reach: PortReach | null, room: {
     readonly selection: boolean;
 };
 export declare function planReach(reach: PortReach | null): PlanReach | null;
-export declare function narrowed(runtime: Reachable, given: PortReach | null): NarrowedView;
+export declare function narrowed(runtime: Reachable, given: PortReach | null, told: ReadinessPort): NarrowedView;