@agentshouse/mdruntime-families 0.1.0-c8ac97acea69a → 0.1.0-c8d38a26efb97

package/dist/mdruntime/actions.d.ts

@@ -0,0 +1,19 @@
+import type { ConversationHistoryRequest } from './adapter.js';
+import { type CallResult, type HistoryAnswer, type Resolution } from './outcome.js';
+import type { Attempted } from './recovery.js';
+import type { Runtime } from './runtime.js';
+export type HistoryQuery = {
+    revision?: string;
+    pageToken?: string;
+};
+export declare function readHistory(runtime: Runtime, locator: string, path: string, query?: HistoryQuery): Promise<HistoryAnswer>;
+export declare function located(runtime: Runtime, room: string, path: string, destination: string): Promise<{
+    room: string;
+    path: string;
+} | null>;
+export declare function resolveReference(runtime: Runtime, room: string, path: string, destination: string): Promise<Resolution>;
+export declare function invokeAction(runtime: Runtime, name: string, input: unknown, dispatching?: () => Promise<void>): Promise<CallResult>;
+export declare function readConversationHistory(runtime: Runtime, request: ConversationHistoryRequest): Promise<CallResult>;
+export declare function called(runtime: Runtime, name: string, input: unknown): Promise<CallResult>;
+export declare function resendCalls(runtime: Runtime, signal: AbortSignal): Promise<Attempted>;
+export declare function resendLater(runtime: Runtime): void;

package/dist/mdruntime/adapter.d.ts

@@ -13,7 +13,7 @@ export type TypedSelection = {
 };
 export type OperationScopes = {
     write: readonly string[];
-    delete: readonly string[];
+    erase: readonly string[];
 };
 export type ReplicaAdmission = {
     selection: string;
@@ -285,25 +285,17 @@ export type BinaryFile = {
     mediaType: string;
     sha256: string;
 };
-export type HeldFile = {
-    readonly path: string;
-    readonly revision: string;
-};
-export type HeldContent = {
-    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;
     selection: string;
     pageToken?: PageToken;
-    held?: HeldContent;
     arriving?: (bytes: number) => void;
     signal?: AbortSignal;
 };
+export type BootstrapPart = {
+    readonly id: string;
+    readonly bytes: number;
+};
 export type BootstrapInventory = {
     readonly bytes: number;
 };
@@ -318,15 +310,20 @@ export type BootstrapPage = {
     facts: Readonly<Record<string, SavedFacts>>;
     revisions: Readonly<Record<string, string>>;
     fileIds?: Readonly<Record<string, string>>;
+    created?: Readonly<Record<string, string>>;
     changes: Readonly<Record<string, HeadChange>>;
     binaryFiles: Readonly<Record<string, BinaryFile>>;
     folders?: readonly string[];
     pageToken?: PageToken;
+    parts?: readonly BootstrapPart[];
     bytes?: number;
 };
+export type NotReady = {
+    kind: 'not-ready';
+};
 export type BootstrapResult = BootstrapPage | {
     kind: 'beyond-horizon';
-} | AdapterFailure;
+} | NotReady | AdapterFailure;
 export type RefreshRequest = {
     locator: string;
     selection: string;
@@ -341,6 +338,7 @@ export type RefreshPage = {
     facts: Readonly<Record<string, SavedFacts>>;
     revisions: Readonly<Record<string, string>>;
     fileIds?: Readonly<Record<string, string>>;
+    created?: Readonly<Record<string, string>>;
     changes: Readonly<Record<string, HeadChange>>;
     binaryFiles: Readonly<Record<string, BinaryFile>>;
     removals: readonly string[];
@@ -489,12 +487,12 @@ export type SearchAnswer = {
 }) | AdapterFailure;
 export type HeldRoom = {
     locator: string;
-    roomVersion: string;
+    roomVersion: string | null;
 };
 export type RoomChange = {
     kind: 'room-change';
     locator: string;
-    from: string;
+    from: string | null;
     roomVersion: string;
     read(): Promise<RefreshPage>;
 };
@@ -527,6 +525,8 @@ export type Adapter = {
     readonly roomTypes?: string;
     readonly nameableRoomTypes?: readonly string[];
     readonly typedPaths?: readonly TypedPath[];
+    readonly unkeptReads?: readonly string[];
+    readonly leadingReads?: readonly string[];
     authorize(): Promise<Authorization>;
     discover?(authorization: Authorization): Promise<DiscoverResult>;
     bootstrap(authorization: Authorization, request: BootstrapRequest): Promise<BootstrapResult>;

package/dist/mdruntime/attached-model.d.ts

@@ -0,0 +1,7 @@
+import { type VerifiedModel } from '@agentshouse/mdmodel';
+import type { ModelResult, ModelState } from './model.js';
+export declare const NO_ROOM_TYPES: VerifiedModel;
+export declare function roomTypesOf(schema: string | undefined, nameable?: readonly string[]): VerifiedModel;
+export declare function builtInModel(roomTypes: VerifiedModel): ModelState;
+export declare function schemaTypes(schema: string | null, roomTypes: VerifiedModel): VerifiedModel['types'];
+export declare function attachedModel(answer: ModelResult, roomTypes: VerifiedModel): ModelState;

package/dist/mdruntime/bootstrap.d.ts

@@ -0,0 +1,43 @@
+import type { ModelState } from './model.js';
+import type { Adapter, TypedPath, AdapterFailure, Authorization, BootstrapPart, DiscoveredRoom, NotReady, RetryableRefusal, RoomModels } from './adapter.js';
+import type { Composition } from './collection.js';
+import type { InstallationStep } from './readiness.js';
+import { type Refreshing } from './refresh.js';
+import type { ReplicaRecord } from './replica.js';
+import type { StagedPage, TransferRecord } from './store.js';
+import { type Unconfirmed } from './transfer.js';
+export type Bootstrapped = {
+    kind: 'staged';
+    record: ReplicaRecord;
+    refreshed: boolean;
+};
+export type BootstrapOutcome = Bootstrapped | Unconfirmed | NotReady | RetryableRefusal | AdapterFailure;
+export type HeldModels = {
+    collection: ModelState;
+};
+export type Remodel = (models: RoomModels | undefined, held: HeldModels) => HeldModels;
+export type Reads = Pick<Adapter, 'bootstrap' | 'refresh' | 'reached'>;
+export type Arriving = {
+    at(bytes: number): void;
+    end(): void;
+};
+export type Resumed = {
+    readonly record: TransferRecord | null;
+    readonly staged: ReadonlySet<string>;
+};
+export type Staging = {
+    held(locator: string): TransferRecord | null;
+    turn(locator: string, step: InstallationStep): Promise<() => void>;
+    unqueued(): Promise<void>;
+    queued(text: number): () => void;
+    arriving(locator: string): Arriving;
+    readonly streamed: boolean;
+    stage(record: TransferRecord, page: StagedPage, composition: Composition): Promise<TransferRecord | null>;
+    resume(record: TransferRecord, parts: readonly BootstrapPart[], composition: Composition): Promise<Resumed | null>;
+    derive(locator: string, key: number, composition: Composition): Promise<boolean>;
+    refreshing(locator: string, key: number, composition: Composition): Promise<Refreshing>;
+    abandon(locator: string): Promise<void>;
+    setAside(locator: string): Promise<void>;
+    release(key: number): Promise<void>;
+};
+export declare function bootstrapRoom(adapter: Reads, authorization: Authorization, room: DiscoveredRoom, held: HeldModels, builtIn: ModelState, typedPaths: readonly TypedPath[], remodel: Remodel, continuing: () => boolean, staging: Staging): Promise<BootstrapOutcome>;

package/dist/mdruntime/cell.d.ts

@@ -0,0 +1,5 @@
+export type Cell<T> = {
+    now(): T;
+    set(change: Partial<T>): void;
+};
+export declare function createCell<T extends object>(first: T): Cell<T>;

package/dist/mdruntime/change.d.ts

@@ -50,6 +50,7 @@ type Arriving = {
     readonly path: string;
     readonly revision?: string;
     readonly fileId?: string;
+    readonly created?: string;
     readonly change?: HeadChange;
 };
 export type RoomMove = {

package/dist/mdruntime/client.d.ts

@@ -1,14 +1,21 @@
 import type { DocumentQuery, GroupQuery } from '@agentshouse/mdmodel';
-import type { AppRoom, ConnectionRefusal, HistoryQuery, RoomSchemas, SavedParts, SavedRoomDraft, SaveResult } from './connection.js';
+import type { HistoryQuery } from './actions.js';
+import type { AppRoom } from './listing.js';
+import type { ConnectionRefusal } from './socket.js';
+import type { RoomSchemas } from './surface.js';
+import type { SavedParts, SavedRoomDraft, SaveResult } from './saves.js';
 import type { Member, ServiceMode } from './adapter.js';
 import type { UnsentWork } from './durability.js';
 import type { ChatDraft, ConversationAgent, ConversationAnswer, ConversationEntry, ConversationOptions, ConversationRead, 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 { FiguresResult } from './figures.js';
+import type { Holdings } from './holdings.js';
 import type { DocumentResult, 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 { ObservedRead } from './reads.js';
 import type { SyncStatus } from './status.js';
 import { type RuntimePort } from './wire.js';
 export type MdRuntimeClient = {
@@ -62,6 +69,7 @@ export type MdRuntimeClient = {
     cleanUp(): Promise<number>;
     unsent(): Promise<readonly UnsentWork[]>;
     reset(): Promise<void>;
+    readAgain(): Promise<void>;
     observe: {
         (topic: 'deployment-facts'): Promise<Observation<unknown>>;
         (topic: 'rooms'): Promise<Observation<readonly AppRoom[]>>;
@@ -80,6 +88,9 @@ export type MdRuntimeClient = {
         (topic: 'conversation', conversation: string, options: ConversationOptions): Promise<Observation<ConversationView>>;
         (topic: 'conversations'): Promise<Observation<readonly ConversationEntry[]>>;
         (topic: 'agents'): Promise<Observation<readonly ConversationAgent[]>>;
+        (topic: 'figures'): Promise<Observation<FiguresResult>>;
+        (topic: 'holdings'): Promise<Observation<Holdings>>;
+        (topic: 'read', name: string, input: unknown): Promise<Observation<ObservedRead>>;
     };
     reauthorize(): Promise<void>;
     settled(): Promise<void>;

package/dist/mdruntime/compile.d.ts

@@ -1,10 +1,15 @@
+import { sql } from '@agentshouse/mdmodel';
 import type { Plan, QueryRows } from './query.js';
 import type { Connection } from './tables.js';
 export type QueryRoom = {
     readonly locator: string;
     readonly key: number;
 };
+type Fragment = sql.Fragment;
+export declare const VISIBLE: (alias: string) => string;
+export declare function within(alias: string, path: string): Fragment;
 export type QueryAnswer = QueryRows & {
     readonly more?: string;
 };
 export declare function answerQuery(connection: Connection, plan: Plan, rooms: readonly QueryRoom[], budget?: number | null): QueryAnswer;
+export {};

package/dist/mdruntime/conversation-row.d.ts

@@ -0,0 +1,32 @@
+import type { HeldRow } from './messages.js';
+import { type HouseSource } from './source.js';
+export type ConversationLast = {
+    readonly text: string;
+    readonly by: 'owner' | 'agent' | 'house';
+    readonly at: string;
+};
+export type ConversationStart = Extract<HouseSource, {
+    readonly kind: 'request' | 'trigger';
+}>;
+export type ConversationAsk = {
+    readonly who: string;
+    readonly agent: string | null;
+    readonly room: {
+        readonly ref: string;
+        readonly name: string;
+    };
+    readonly prompt: string;
+    readonly at: string;
+    readonly request: string;
+    readonly message?: string;
+};
+export type ConversationHeld = {
+    readonly last: ConversationLast | null;
+    readonly failure: string | null;
+    readonly startedBy: ConversationStart | null;
+    readonly asks: ConversationAsk | null;
+};
+export declare function heldFacts(held: HeldRow | undefined, listed: {
+    readonly outcome: string | null;
+    readonly waiting: boolean;
+}): ConversationHeld;

package/dist/mdruntime/conversation.d.ts

@@ -1,15 +1,18 @@
-import type { ConversationAction, ConversationEvent, ConversationHistoryRequest, ConversationMessage, ConversationStream, ListedConversation, ProcessCommand, RunningSubagent, SessionOption, TurnContext } from './adapter.js';
+import type { ConversationAction, ConversationEvent, ConversationHistoryRequest, ConversationMessage, ConversationStream, ProcessCommand, RunningSubagent, SessionOption, TurnContext } from './adapter.js';
 import { type ChangeSet } from './change-set.js';
+import { type ConversationHeld } from './conversation-row.js';
+import type { OpenJob } from './job.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';
+import type { RuntimeStore } from './store.js';
 export type ConversationState = Open<'working' | 'asking' | 'idle'>;
-export type ConversationEntry = {
+export type ConversationEntry = ConversationHeld & {
     conversation: string;
     agent: {
         identity: string;
         name: string;
+        retired: boolean;
     };
     name: string;
     created: string;
@@ -18,6 +21,8 @@ export type ConversationEntry = {
     waiting: boolean;
     state: ConversationState;
     started: string | null;
+    line: string | null;
+    question: string | null;
 };
 export type ConversationAgent = {
     identity: string;
@@ -62,6 +67,7 @@ export type ConversationView = {
     chatDraft: (ChatDraft & {
         readonly revision: string;
     }) | null;
+    jobs: readonly OpenJob[];
 };
 export type ConversationSurface = {
     list(): Promise<readonly ConversationEntry[]>;
@@ -86,6 +92,9 @@ export type ConversationDependencies = {
     call(name: ConversationAction, input: unknown): Promise<CallResult>;
     history(request: ConversationHistoryRequest): Promise<CallResult>;
     durably<T>(work: (local: RuntimeStore) => Promise<T>): Promise<T>;
+    local(): Promise<RuntimeStore>;
+    again(): void;
+    settled(): void;
     stream(): ConversationStream | undefined;
     publish(set: ChangeSet): void;
     online(): boolean;
@@ -96,7 +105,7 @@ export type ConversationDependencies = {
 export type ConversationStore = {
     surface: ConversationSurface;
     chatDraft: ChatDraftSurface;
-    hydrate(held: readonly HeldConversation[], drafts: readonly ChatDraftRecord[], list: readonly ListedConversation[] | null, cursor: string | null): void;
+    opened(local: RuntimeStore): Promise<void>;
     reconcile(): Promise<void>;
     catchUp(progress: CycleProgress): Promise<void>;
     resend(progress: CycleProgress): Promise<void>;
@@ -109,7 +118,7 @@ export type ConversationStore = {
     watchList(deliver: (entries: readonly ConversationEntry[]) => void): () => void;
     watchAgents(deliver: (agents: readonly ConversationAgent[]) => void): () => void;
     changed(set: ChangeSet): void;
-    receive(event: ConversationEvent): boolean;
+    receive(event: ConversationEvent): void;
     close(): void;
 };
 export declare function unheldView(conversation: string): ConversationView;

package/dist/mdruntime/durability.d.ts

@@ -4,12 +4,21 @@ export type UnsentWork = {
     readonly kind: UnsentKind;
     readonly count: number;
 };
+export type AppCode = {
+    readonly running: number;
+    readonly older: number;
+};
+export type HeldCode = {
+    readonly house: number | null;
+    readonly apps: readonly string[];
+};
 export type RuntimeShell = {
     persistence: Persistence;
     generation: string | null;
     keepGeneration(value: string): void | Promise<void>;
     dropGeneration(): void | Promise<void>;
     cleanUp?(): Promise<number>;
+    measure?(measured: (app: string, code: AppCode | null) => void): Promise<HeldCode>;
     reset(): Promise<void>;
 };
 export declare function refusedForSpace(error: unknown): boolean;

package/dist/mdruntime/figures.d.ts

@@ -0,0 +1,47 @@
+import type { ChangeSet } from './change-set.js';
+import type { GroupTotal, PendingResult } from './query.js';
+import type { Deliver, Fail } from './reach.js';
+import type { ConversationTally, RoomTally } from './tallies.js';
+import type { QueryRoom } from './tables.js';
+export declare const HOUSE_DIRECTORY = "house";
+export declare const ROOM_TOTALS: {
+    readonly outside: readonly ["house"];
+    readonly groupBy: readonly ["room"];
+    readonly select: {
+        readonly size: true;
+    };
+};
+export type DayFigures = {
+    readonly created: number;
+    readonly changed: number;
+    readonly chats: number;
+    readonly messages: number;
+};
+export type RoomFigures = {
+    readonly room: string;
+    readonly day: DayFigures;
+    readonly total: {
+        readonly documents: GroupTotal;
+        readonly files: GroupTotal;
+    };
+};
+export type Figures = {
+    readonly rooms: readonly RoomFigures[];
+    readonly agentMessages: number;
+};
+export type FiguresResult = Figures | PendingResult;
+export type FiguresCover = PendingResult | {
+    readonly rooms: readonly QueryRoom[];
+};
+export type FiguresSources = {
+    cover(): Promise<FiguresCover>;
+    rooms(rooms: readonly QueryRoom[], since: string): Promise<readonly RoomTally[]>;
+    conversations(conversations: readonly string[] | null, since: string): Promise<readonly ConversationTally[]>;
+};
+export type FiguresRead = {
+    watch(deliver: Deliver, fail: Fail): () => void;
+    touched(set: ChangeSet): void;
+    recover(): void;
+    close(): void;
+};
+export declare function createFigures(sources: FiguresSources): FiguresRead;

package/dist/mdruntime/holdings.d.ts

@@ -0,0 +1,28 @@
+import type { AppCode } from './durability.js';
+import type { GroupTotal, PendingResult } from './query.js';
+import type { Deliver, Fail } from './reach.js';
+import type { Runtime } from './runtime.js';
+import type { OpenedRoom } from './tables.js';
+export type RoomDocuments = {
+    readonly room: string;
+    readonly documents: GroupTotal;
+};
+export type HeldApp = ({
+    readonly app: string;
+    readonly state: 'measured';
+} & AppCode) | {
+    readonly app: string;
+    readonly state: 'asking' | 'unknown';
+};
+export type Holdings = {
+    readonly rooms: readonly RoomDocuments[] | PendingResult;
+    readonly opened: GroupTotal & {
+        readonly rooms: readonly OpenedRoom[];
+    };
+    readonly apps: readonly HeldApp[];
+    readonly house: number | null;
+    readonly total: number | null;
+    readonly cleanUp: number | null;
+};
+export declare const CLEANED_TOPIC = "cleaned";
+export declare function watchHoldings({ store, figures, shell }: Runtime, deliver: Deliver, fail: Fail): () => void;

package/dist/mdruntime/install.d.ts

@@ -0,0 +1,55 @@
+import type { AdapterFailure, Authorization, DiscoveredRoom, NotReady, RetryableRefusal } from './adapter.js';
+import { type Reads } from './bootstrap.js';
+import type { Installation, RoomCoverage } from './readiness.js';
+import { advancement, type Refresher } from './refresh.js';
+import type { ReplicaRecord } from './replica.js';
+import type { Runtime } from './runtime.js';
+import type { Live } from './socket.js';
+import { type CoveredRoom, type InstallHold, type RuntimeStore, type Store } from './store.js';
+import { type Unconfirmed } from './transfer.js';
+type Standing = {
+    readonly key: number | null;
+    readonly confirmed: number;
+};
+export type Unheld = {
+    readonly staged: boolean;
+};
+export type Withheld = AdapterFailure | RetryableRefusal | NotReady | Unconfirmed;
+type Landing = {
+    readonly kind: 'refreshed';
+    readonly from: Standing;
+    readonly remodelled: boolean;
+} | {
+    readonly kind: 'bootstrapped';
+    readonly refreshed: boolean;
+    readonly from: Standing;
+};
+type Refreshed = {
+    kind: 'advanced';
+    record: ReplicaRecord;
+    from: Standing;
+    remodelled: boolean;
+} | Exclude<Awaited<ReturnType<typeof advancement>>, {
+    kind: 'advanced';
+}>;
+export declare const ERASE_BATCH = 512;
+export declare function installationOf(store: Store, coverage: readonly RoomCoverage[], held: ReadonlyMap<string, CoveredRoom>): Installation;
+export declare function roomInFlight(store: Store, locator: string): boolean;
+export declare function sweep({ store, socket, journal }: Runtime): void;
+export declare function forgetInstall(store: Store, locator: string): void;
+export declare function caughtUpTo(runtime: Runtime, locator: string): void;
+export declare function catching(store: Store, locator: string): void;
+export declare function confirmedAgain(store: Store, locator: string): void;
+export declare function standingAt(store: Store, locator: string, held: Pick<ReplicaRecord, 'key'> | undefined): Standing;
+export declare function showing(system: Runtime, locator: string, roomVersion: string, held: string | undefined): void;
+export declare function olderThan(system: Runtime, locator: string, roomVersion: string, held: string | undefined): boolean;
+export declare function replaced(store: Store, locators: readonly string[]): void;
+export declare function reachedBy({ store, socket }: Runtime, locator: string, roomVersion: string): Promise<boolean>;
+export declare function behind({ store, socket }: Runtime, room: DiscoveredRoom): Promise<boolean>;
+export declare function writtenAfter({ store, socket }: Runtime, locator: string, roomVersion: string, path: string): Promise<boolean>;
+export declare function pullRefresh(runtime: Runtime, authorized: Authorization, record: ReplicaRecord, liveness: Live, hold: InstallHold, refresh: Refresher): Promise<Refreshed>;
+export declare function pullBootstrap(runtime: Runtime, authorized: Authorization, room: DiscoveredRoom, local: RuntimeStore, liveness: Live, prior: ReplicaRecord | undefined, from?: Reads, unheld?: Unheld): Promise<import("./bootstrap.js").Bootstrapped | NotReady | import("./adapter.js").RevokedAuthorization | import("./adapter.js").RoomNotReadable | Unconfirmed | {
+    readonly kind: 'transport-uncertainty';
+} | RetryableRefusal | import("./adapter.js").ScopedRefusal>;
+export declare function publish(runtime: Runtime, local: RuntimeStore, room: DiscoveredRoom, reached: ReplicaRecord, landing: Landing, live: Live): Promise<boolean>;
+export {};

package/dist/mdruntime/job.d.ts

@@ -0,0 +1,32 @@
+type Job = {
+    readonly label: string;
+    readonly kind: 'started' | 'scheduled' | 'ended';
+    readonly state: string;
+    readonly next: string | null;
+};
+export type RunningJob = {
+    readonly name: string;
+    readonly running_since: string;
+};
+export type JobMarker = {
+    readonly said: string;
+    readonly at: string;
+};
+export type OpenJob<At = string | null> = {
+    readonly name: string;
+    readonly started: At;
+};
+export declare function jobOf(said: string): Job;
+export declare function closeLast(open: {
+    readonly key: string;
+}[], key: string): void;
+export declare function markerMoved<Kept extends {
+    readonly key: string;
+}>(open: Kept[], said: string, opened: (job: Job, key: string) => Kept | null): void;
+export declare function openJobs<At>(markers: readonly {
+    readonly said: string;
+    readonly at: At;
+}[]): readonly OpenJob<At>[];
+export declare function jobsRunning(jobs: readonly RunningJob[], now: number): string[];
+export declare function sessionEnded(jobs: readonly RunningJob[], now: number): string;
+export {};

package/dist/mdruntime/listing.d.ts

@@ -0,0 +1,52 @@
+import type { HeldRooms } from '@agentshouse/mdmodel';
+import type { DiscoveredRoom, HeldRoom, OperationScopes, ProviderRefusal, ReplicaAdmission } from './adapter.js';
+import type { Composition } from './collection.js';
+import { type ModelState, type TypesResult } from './model.js';
+import { type PortReach } from './reach.js';
+import type { ReplicaRecord } from './replica.js';
+import type { Runtime } from './runtime.js';
+import type { RoomDeclaration } from './socket.js';
+import type { Stored } from './store.js';
+export type AppTypedSelection = {
+    roots: readonly string[];
+    model: TypesResult;
+};
+export type AppRoom = {
+    name: string;
+    locator: string;
+    handle: string;
+    operations: OperationScopes;
+    replica: ReplicaAdmission;
+    model: TypesResult;
+    typedSelection: AppTypedSelection | null;
+    providerOwnedPaths: readonly string[];
+    roomVersion: string | null;
+    documents: number;
+    synchronizationAvailable: boolean;
+    refusal: ProviderRefusal | null;
+    locked: boolean;
+};
+type ListedRoom = Omit<AppRoom, 'documents' | 'locked'>;
+type ListedEntry = ListedRoom & {
+    readonly documents: number;
+};
+export type Listing = ReadonlyMap<string, ListedEntry>;
+export declare function modelIn({ socket }: Runtime, locator: string, stored: Stored | undefined): ModelState;
+export declare function compositionFor(runtime: Runtime, record: ReplicaRecord): Composition;
+export declare function declarationOf({ socket }: Runtime, locator: string, stored: Stored | undefined): {
+    readonly room: RoomDeclaration;
+    readonly available: boolean;
+} | undefined;
+export declare function listedLocators({ store, socket }: Runtime, held: ReadonlyMap<string, unknown>): string[];
+export declare function patchedListing(runtime: Runtime, changed: ReadonlySet<string>): Promise<Listing | null>;
+export declare function listingNow(runtime: Runtime): Promise<Listing>;
+export declare function shownRooms(runtime: Runtime, listing: Listing): readonly AppRoom[];
+export declare function roomFacts(runtime: Runtime, reach?: PortReach | null): Promise<HeldRooms>;
+export declare function list({ store, socket }: Runtime, room: RoomDeclaration, synchronizationAvailable: boolean): void;
+export declare function listHeld({ store, socket }: Runtime, locator: string): void;
+export declare function admitted({ socket }: Runtime, room: RoomDeclaration): boolean;
+export declare function readable(runtime: Runtime, room: DiscoveredRoom): void;
+export declare function usable(runtime: Runtime, room: DiscoveredRoom): void;
+export declare function heldRooms({ store }: Runtime, listed: readonly DiscoveredRoom[]): Promise<HeldRoom[]>;
+export declare function name(runtime: Runtime, locator: string): Promise<void>;
+export {};

package/dist/mdruntime/live.d.ts

@@ -0,0 +1,22 @@
+import type { ChangeSet } from './change-set.js';
+import { type KeyedResult, type QueryMessage } from './observation.js';
+import type { PendingResult, Plan, QueryCoverage } from './query.js';
+import type { Fail } from './reach.js';
+import type { QueryRoom } from './tables.js';
+export type Cover = {
+    coverage: QueryCoverage;
+    rooms: readonly QueryRoom[];
+} | PendingResult;
+export type Ran = KeyedResult & {
+    readonly current: () => boolean;
+};
+export type Run = (plan: Plan, cover: () => Promise<Cover>) => Promise<Ran>;
+type Listener = (message: QueryMessage) => void;
+export type LiveQueries<H> = {
+    touched(set: ChangeSet): void;
+    recover(): void;
+    watch(plan: Plan, identity: string, cover: (held: H) => Cover, deliver: Listener, failed: Fail): () => void;
+    close(): void;
+};
+export declare function createLiveQueries<H>(run: Run, holding: () => Promise<H>): LiveQueries<H>;
+export {};

package/dist/mdruntime/log.d.ts

@@ -0,0 +1,5 @@
+export declare function createLog(): {
+    record(event: string): void;
+    export(): string;
+};
+export type Log = ReturnType<typeof createLog>;