@agentshouse/mdruntime-families 0.1.0-c686d19f36a21 → 0.1.0-c68df10f5cb2e

package/dist/mdruntime/adapter.d.ts

@@ -32,25 +32,20 @@ export type Capability = {
     name: string;
     limits?: readonly ProviderLimit[];
     actions?: readonly ActionDeclaration[];
-    conversationAgents?: ConversationAgents;
-};
-export type ConversationAgents = {
-    locator: string;
-    type: string;
-    identity: string;
-    name: string;
-    retired?: string;
 };
 export type ListedConversation = {
     conversation: string;
     agent: string;
+    agentName: string;
+    agentRetired: boolean;
     name: string;
     created: string;
     finished: string | null;
     outcome: string | null;
     waiting: boolean;
+    newest: string | null;
 };
-export type ConversationAction = 'conversation.create' | 'conversation.send' | 'conversation.attach' | 'conversation.answer' | 'conversation.interrupt' | 'conversation.kill' | 'conversation.cancel' | 'conversation.delete' | 'conversation.history';
+export type ConversationAction = 'conversations/create' | 'conversations/send' | 'conversations/interaction/answer' | 'conversations/interrupt' | 'conversations/kill' | 'conversations/delete';
 export type ConversationMessage = {
     identity: string;
     turn: string;
@@ -141,6 +136,10 @@ export type SessionOption = (SessionOptionNaming & {
     type: 'boolean';
     currentValue: boolean;
 });
+export type RunningSubagent = {
+    description: string;
+    activity: string | null;
+};
 export type ConversationEvent = {
     kind: 'turn';
     conversation: string;
@@ -166,6 +165,10 @@ export type ConversationEvent = {
     kind: 'starting';
     conversation: string;
     step: string | null;
+} | {
+    kind: 'subagents';
+    conversation: string;
+    subagents: readonly RunningSubagent[];
 } | {
     kind: 'link';
     conversation: string;
@@ -184,6 +187,9 @@ export type ConversationEvent = {
 } | {
     kind: 'list';
     entries: readonly ListedConversation[];
+    whole: boolean;
+    more: boolean;
+    cursor: string | null;
 } | {
     kind: 'listed';
     entry: ListedConversation;
@@ -191,9 +197,17 @@ export type ConversationEvent = {
     kind: 'unlisted';
     conversation: string;
 };
+export type ListedAgent = {
+    agent: string;
+    name: string;
+    retired: boolean;
+};
 export type ConversationStream = {
     replicate(conversations: readonly string[]): void;
+    hold(cursor: string | null): void;
     observe(notify: (event: ConversationEvent) => void): () => void;
+    agents?(): Promise<readonly ListedAgent[] | null>;
+    history?(request: ConversationHistoryRequest): Promise<ActionResult>;
 };
 export type ActionDeclaration = {
     name: string;
@@ -223,10 +237,6 @@ export type Discovery = {
     providerLimits: readonly ProviderLimit[];
     retention: Retention;
     member?: Member;
-    covered?: readonly string[];
-};
-export type DiscoveryScope = {
-    readonly authorities: readonly string[];
 };
 export type TransportUncertainty = {
     kind: 'transport-uncertainty';
@@ -255,7 +265,7 @@ export type ContractUnavailable = ProviderRefusal & {
 export type DiscoverResult = Discovery | TransportUncertainty | RevokedAuthorization | ContractUnavailable;
 export type PageToken = string;
 export type ChangeAuthor = {
-    kind: Open<'user' | 'site' | 'inbox'>;
+    kind: Open<'user' | 'site' | 'inbox' | 'app'>;
     id: string;
     name: string;
 };
@@ -289,16 +299,14 @@ export type BootstrapRequest = {
     selection: string;
     pageToken?: PageToken;
     held?: HeldContent;
-    received?: Uint8Array;
     arriving?: (bytes: number) => void;
+    signal?: AbortSignal;
 };
 export type BootstrapInventory = {
-    readonly parts: number;
     readonly bytes: number;
 };
 export type RoomModels = {
     collection?: ModelResult;
-    selection?: ModelResult;
 };
 export type BootstrapPage = {
     kind: 'bootstrap';
@@ -311,8 +319,7 @@ export type BootstrapPage = {
     binaryFiles: Readonly<Record<string, BinaryFile>>;
     folders?: readonly string[];
     pageToken?: PageToken;
-    inventory?: BootstrapInventory;
-    received?: Uint8Array;
+    bytes?: number;
 };
 export type BootstrapResult = BootstrapPage | {
     kind: 'beyond-horizon';
@@ -387,7 +394,7 @@ export type HistoryAuthor = {
     kind: 'user';
     id: string;
 } | {
-    kind: 'site' | 'inbox';
+    kind: 'site' | 'inbox' | 'app';
     id: string;
     name: string;
 };
@@ -432,6 +439,22 @@ export type BinaryLinkResult = {
     kind: 'link';
     url: string;
     name: string;
+    mediaType?: string;
+} | (ProviderRefusal & {
+    kind: 'rejected';
+}) | AdapterFailure;
+export type AttachRequest = {
+    locator: string;
+    name: string;
+    mediaType: string;
+    byteLength: number;
+    sha256: string;
+    blob: Blob;
+};
+export type AttachResult = {
+    kind: 'attached';
+    path: string;
+    revision: string;
 } | (ProviderRefusal & {
     kind: 'rejected';
 }) | AdapterFailure;
@@ -454,55 +477,49 @@ export type HeldRoom = {
     locator: string;
     roomVersion: string;
 };
-export type HeldRevisions = (locator: string, paths: readonly string[]) => Promise<ReadonlyMap<string, string>>;
+export type RoomChange = {
+    kind: 'room-change';
+    locator: string;
+    from: string;
+    roomVersion: string;
+    read(): Promise<RefreshPage>;
+};
+export type AuthorityChange = {
+    kind: 'authority-changed';
+    rooms: readonly DiscoveredRoom[];
+    left: readonly string[];
+    member?: Member;
+};
 export type RoomStreamEvent = {
     kind: 'opened';
+} | {
+    kind: 'discovered';
+    discovery: Discovery;
 } | {
     kind: 'closed';
     revoked: boolean;
     lost: boolean;
 } | {
-    kind: 'opening';
+    kind: 'caught-up';
     expired: readonly string[];
-} | {
-    kind: 'authority-changed';
-    scope?: DiscoveryScope;
-} | {
-    kind: 'room-version';
-    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>;
-};
+} | AuthorityChange | RoomChange;
 export type RoomStream = {
     hold(rooms: readonly HeldRoom[]): void;
-    reopen(): void;
-    published(locator: string, roomVersion: string): void;
-    observe(notify: (event: RoomStreamEvent) => void, receipts: StreamReceipts, revisions: HeldRevisions): () => void;
+    observe(notify: (event: RoomStreamEvent) => void): () => void;
 };
 export type Adapter = {
     readonly localSaves?: true;
-    readonly exhaustiveDiscovery?: true;
     readonly roomTypes?: string;
+    readonly nameableRoomTypes?: readonly string[];
     authorize(): Promise<Authorization>;
-    discover(authorization: Authorization, scope?: DiscoveryScope): Promise<DiscoverResult>;
+    discover?(authorization: Authorization): Promise<DiscoverResult>;
     bootstrap(authorization: Authorization, request: BootstrapRequest): Promise<BootstrapResult>;
-    refresh(authorization: Authorization, request: RefreshRequest): Promise<RefreshResult>;
+    refresh?(authorization: Authorization, request: RefreshRequest): Promise<RefreshResult>;
     mutate(authorization: Authorization, request: MutationRequest, keep: (upload: unknown) => Promise<void>): Promise<MutationResult>;
     history(authorization: Authorization, request: HistoryRequest): Promise<HistoryResult>;
     binary(authorization: Authorization, request: BinaryRequest): Promise<BinaryResult>;
     link(authorization: Authorization, request: BinaryRequest): Promise<BinaryLinkResult>;
+    attach(authorization: Authorization, request: AttachRequest): Promise<AttachResult>;
     action(authorization: Authorization, request: ActionRequest): Promise<ActionResult>;
     reached(locator: string, roomVersion: string, target: string): boolean;
     follows(locator: string, roomVersion: string, next: string): boolean;

package/dist/mdruntime/client.d.ts

@@ -1,9 +1,8 @@
 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 { ChatDraft, ConversationAgent, ConversationAnswer, ConversationEntry, ConversationOptions, ConversationView } from './conversation.js';
 import { type Observation } from './observation.js';
-import type { ChosenFile } from './file.js';
-import type { BinaryAnswer, BinaryLinkAnswer, CallResult, HistoryAnswer, Offline, QueueEntry, Resolution } from './outcome.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';
@@ -36,11 +35,9 @@ 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>;
+        answer(conversation: string, answer: ConversationAnswer): 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: {
@@ -52,7 +49,8 @@ export type MdRuntimeClient = {
     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>;
+        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>;
@@ -69,6 +67,7 @@ export type MdRuntimeClient = {
         (topic: 'sync-status'): Promise<Observation<SyncStatus>>;
         (topic: 'service-mode'): Promise<Observation<ServiceMode>>;
         (topic: 'member'): Promise<Observation<Member | null>>;
+        (topic: 'authority-changes'): Promise<Observation<number>>;
         (topic: 'query', query: DocumentQuery): Promise<Observation<DocumentResult | PendingResult>>;
         (topic: 'query', query: GroupQuery): Promise<Observation<GroupResult | PendingResult>>;
         (topic: 'queue', locator: string): Promise<Observation<readonly QueueEntry[]>>;
@@ -85,6 +84,7 @@ 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

@@ -1,8 +1,6 @@
 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';
 export declare const MD_MODEL: MdModelIdentity;
 export type Collection = {
     text: Readonly<Record<string, string>>;
@@ -16,10 +14,14 @@ export type Composition = {
         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 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 available(composition: Composition): boolean;

package/dist/mdruntime/connection.d.ts

@@ -7,7 +7,7 @@ import { type Adapter, type Authorization, type Member, type ProviderRefusal, ty
 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 BinaryLinkAnswer, type CallResult, type HeldBinaryAnswer, type HistoryAnswer, type QueueEntry, type Resolution } from './outcome.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';
@@ -54,6 +54,7 @@ export type MdRuntimeOptions = {
     authorization?: Authorization;
     signal?: AbortSignal;
     recovery?: Recovery;
+    usableWhenHeld?: readonly string[];
 };
 export type SaveResult = {
     outcome: 'saved';
@@ -83,6 +84,8 @@ export type PresentationSurface = {
 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 = {
@@ -91,7 +94,7 @@ export type HistoryQuery = {
 };
 export type MdRuntime = {
     loaded(): Promise<void>;
-    rooms(): readonly AppRoom[];
+    rooms(): Promise<readonly AppRoom[]>;
     query: {
         (query: DocumentQuery): Promise<DocumentResult | PendingResult>;
         (query: GroupQuery): Promise<GroupResult | PendingResult>;
@@ -121,6 +124,7 @@ export type MdRuntime = {
         (topic: 'sync-status'): Promise<Observation<SyncStatus>>;
         (topic: 'service-mode'): Promise<Observation<ServiceMode>>;
         (topic: 'member'): Promise<Observation<Member | null>>;
+        (topic: 'authority-changes'): Promise<Observation<number>>;
         (topic: 'query', query: DocumentQuery): Promise<Observation<DocumentResult | PendingResult>>;
         (topic: 'query', query: GroupQuery): Promise<Observation<GroupResult | PendingResult>>;
         (topic: 'queue', locator: string): Promise<Observation<readonly QueueEntry[]>>;
@@ -132,7 +136,7 @@ export type MdRuntime = {
     };
     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 RuntimeTopic = 'rooms' | 'readiness' | 'connection-refusal' | 'storage-loss' | 'sync-status' | 'service-mode' | 'member' | 'authority-changes' | 'query' | 'queue' | 'room-drafts' | 'presentation' | 'conversation' | 'conversations' | 'agents';
 export type ReadinessPort = {
     readonly target: string;
     readonly code: CodeAvailability;
@@ -142,9 +146,7 @@ export type ReadinessPort = {
 export type ComposedRuntime = RuntimeView & {
     seed(entry: EntrySeed): void;
     stop(): Promise<void>;
-    lose(locators: readonly string[]): Promise<void>;
     persisted(answer: Persistence): void;
-    shown(onScreen: boolean): void;
     within(reach: PortReach | null, port: ReadinessPort): NarrowedView;
 };
 export declare function composeRuntime(options: MdRuntimeOptions): ComposedRuntime;

package/dist/mdruntime/conversation.d.ts

@@ -1,9 +1,7 @@
-import type { ConversationAction, ConversationAgents, ConversationEvent, ConversationMessage, ConversationStream, ProcessCommand, SessionOption, TurnContext } from './adapter.js';
+import type { ConversationAction, ConversationEvent, ConversationHistoryRequest, ConversationMessage, ConversationStream, ListedConversation, ProcessCommand, RunningSubagent, SessionOption, TurnContext } from './adapter.js';
 import { type ChangeSet } from './change-set.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';
 import type { CycleProgress } from './status.js';
 import type { ChatDraftRecord, HeldConversation, RuntimeStore } from './store.js';
 export type ConversationState = Open<'working' | 'asking' | 'idle'>;
@@ -11,7 +9,7 @@ export type ConversationEntry = {
     conversation: string;
     agent: {
         identity: string;
-        name: string | null;
+        name: string;
     };
     name: string;
     created: string;
@@ -52,6 +50,7 @@ export type ConversationView = {
     commands: readonly ProcessCommand[];
     options: readonly SessionOption[];
     starting: string | null;
+    subagents: readonly RunningSubagent[];
     link: {
         connected: boolean;
     } | null;
@@ -65,22 +64,23 @@ 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>;
+    answer(conversation: string, answer: ConversationAnswer): 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 ConversationAnswer = {
+    interaction_id: string;
+    response: unknown;
+};
 export type ChatDraftSurface = {
     write(conversation: string, draft: ChatDraft, revision?: string): Promise<void>;
     prepend(conversation: string, draft: ChatDraft): Promise<void>;
     discard(conversation: string): Promise<void>;
 };
 export type ConversationDependencies = {
-    agents(): ConversationAgents | undefined;
-    documents(agents: ConversationAgents, after: string | undefined): Promise<DocumentResult | PendingResult>;
     call(name: ConversationAction, input: unknown): Promise<CallResult>;
+    history(request: ConversationHistoryRequest): Promise<CallResult>;
     durably<T>(work: (local: RuntimeStore) => Promise<T>): Promise<T>;
     stream(): ConversationStream | undefined;
     publish(set: ChangeSet): void;
@@ -93,13 +93,13 @@ export type ConversationDependencies = {
 export type ConversationStore = {
     surface: ConversationSurface;
     chatDraft: ChatDraftSurface;
-    hydrate(held: readonly HeldConversation[], drafts: readonly ChatDraftRecord[]): void;
+    hydrate(held: readonly HeldConversation[], drafts: readonly ChatDraftRecord[], list: readonly ListedConversation[] | null, cursor: string | null): void;
     reconcile(): Promise<void>;
     catchUp(progress: CycleProgress): Promise<void>;
     resend(progress: CycleProgress): Promise<void>;
     current(): boolean;
     known(): boolean;
-    reconnected(): void;
+    learned(): void;
     reopened(): void;
     lost(): void;
     watch(conversation: string, options: ConversationOptions, deliver: (view: ConversationView) => void): () => void;

package/dist/mdruntime/durability.d.ts

@@ -2,7 +2,6 @@ import type { Persistence } from './readiness.js';
 export type RuntimeShell = {
     persistence: Persistence;
     generation: string | null;
-    onScreen: boolean;
     keepGeneration(value: string): void | Promise<void>;
     dropGeneration(): void | Promise<void>;
     cleanUp?(): Promise<number>;

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/model.d.ts

@@ -28,6 +28,11 @@ export type ModelState = {
     verifiedWith: ModelIdentity;
     types: VerifiedModel['types'];
 };
+export type StoredModel = Extract<ModelState, {
+    status: 'unavailable';
+}> | Omit<Extract<ModelState, {
+    status: 'current' | 'cached';
+}>, 'types'>;
 export type TypesResult = {
     status: Open<'unavailable'>;
     reason: ModelUnavailableReason;
@@ -51,7 +56,7 @@ export type ValidationReceipt = {
 export declare const NO_MODEL: ModelState;
 export declare function definitionOf(state: ModelState, type: string | undefined): Definition | undefined;
 export declare function modelTypes(state: ModelState): TypesResult;
+export declare function storedModel(state: ModelState): StoredModel;
 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

@@ -38,6 +38,7 @@ export type Digest = {
     readonly next: string | undefined;
     readonly total: number | undefined;
 };
+export declare function hashed(text: string): number;
 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/outcome.d.ts

@@ -1,4 +1,4 @@
-import type { ActionResult, AdapterFailure, BinaryLinkResult, HistoryResult, HistoryRevision, ProviderRefusal, RoomVersionAt, ScopedRefusal } from './adapter.js';
+import type { ActionResult, AdapterFailure, AttachResult, BinaryLinkResult, HistoryResult, HistoryRevision, ProviderRefusal, RoomVersionAt, ScopedRefusal } from './adapter.js';
 import type { ChangeBatch } from './change.js';
 import type { KeptBinary, KeptResult } from './opened.js';
 type Refused<Kind extends string> = ProviderRefusal & {
@@ -29,7 +29,17 @@ export type BinaryLinkAnswer = {
     kind: 'link';
     url: string;
     name: string;
+    mediaType: string;
 } | Refused<'rejected'> | Refused<'absent'> | Failure;
+export type HeldShownAnswer = KeptBinary | BinaryLinkAnswer;
+export type ShownAnswer = BinaryAnswer | BinaryLinkAnswer;
+export type AttachAnswer = {
+    kind: 'attached';
+    path: string;
+} | Offline | Refused<'rejected'> | Failure;
+export type DownloadAnswer = {
+    kind: 'started';
+} | Refused<'rejected'> | Refused<'absent'> | Refused<'blocked'> | Failure;
 export type Resolution = {
     readonly kind: 'document';
     readonly room: string;
@@ -45,7 +55,8 @@ export declare const LOCKED_UNREADABLE: Refused<'unreadable'>;
 export declare const ABSENT_TARGET: Refused<'absent'>;
 export declare function absentBinary(path: string): Refused<'absent'>;
 export declare function binaryAnswer(result: KeptResult): HeldBinaryAnswer;
-export declare function binaryLinkAnswer(result: BinaryLinkResult): BinaryLinkAnswer;
+export declare function binaryLinkAnswer(result: BinaryLinkResult, held?: string): BinaryLinkAnswer;
+export declare function attachAnswer(result: AttachResult): AttachAnswer;
 export declare const ROOM_LOCKED = "room-locked";
 export declare function lockedRoom(locator: string): Refused<'room-locked'> & {
     locator: string;
@@ -69,8 +80,5 @@ export type QueueEntry = {
     readonly batch: ChangeBatch;
 } & (Submission | {
     readonly state: 'local';
-} | {
-    readonly state: 'accepted';
-    readonly roomVersion: string;
 });
 export {};

package/dist/mdruntime/query.d.ts

@@ -232,9 +232,15 @@ export type GroupShape = {
         direction: Direction;
     }[];
 };
+export type PlanArea = {
+    room: string;
+    path: string;
+    open: readonly string[];
+};
 export type PlanReach = {
     rooms: readonly string[];
     documents: readonly string[];
+    areas: readonly PlanArea[];
 };
 export type Continuation = {
     text: string;

package/dist/mdruntime/reach.d.ts

@@ -1,4 +1,4 @@
-import type { MdRuntime, ReadinessPort, RuntimeTopic } from './connection.js';
+import type { AppRoom, 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';
@@ -6,9 +6,15 @@ export type ReachedDocument = {
     readonly room: string;
     readonly path: string;
 };
+export type ReachedArea = {
+    readonly room: string;
+    readonly path: string;
+    readonly open: readonly string[];
+};
 export type PortReach = {
     readonly rooms: readonly string[];
     readonly documents: readonly ReachedDocument[];
+    readonly areas?: readonly ReachedArea[];
     readonly conversations: boolean;
 };
 export type Deliver = (message: unknown) => void;
@@ -31,6 +37,7 @@ export type Reachable = RuntimeView & {
     lockedRooms(): readonly string[];
     watchLocks(notify: () => void): () => void;
     located(room: string, path: string, destination: string): ReachedDocument | null;
+    room(locator: string): AppRoom | undefined;
 };
 export declare function holds(reach: PortReach | null, room: string): boolean;
 export declare function governs(reach: PortReach | null, room: {

package/dist/mdruntime/readiness.d.ts

@@ -1,6 +1,6 @@
 import type { Open } from './open.js';
 export type CodeAvailability = Open<'stored' | 'absent'>;
-export type RoomPreparation = Open<'complete' | 'acquiring' | 'preparing' | 'refused' | 'unadmitted'>;
+export type RoomPreparation = Open<'complete' | 'acquiring' | 'preparing' | 'unadmitted'>;
 export type RoomCoverage = {
     readonly room: string;
     readonly state: RoomPreparation;
@@ -19,28 +19,17 @@ export type Durability = Open<'persistent' | 'best-effort'>;
 export type ConnectionAvailability = Open<'connected' | 'connecting' | 'unreachable'>;
 export type HouseOutcome = Open<'open' | 'write-halted' | 'refused'>;
 export type Space = Open<'full'>;
-export type RefusedRoom = {
-    readonly room: string;
-    readonly name: string;
-    readonly file: string;
-    readonly rule: string;
-    readonly location: string | null;
-};
-export type InstallationStep = Open<'listing' | 'downloading' | 'writing' | 'replaying'>;
-export type InstallationPause = Open<'hidden'>;
+export type InstallationStep = Open<'downloading' | 'writing' | 'replaying'>;
 export type InstallationAmount = {
     readonly done: number;
     readonly total: number;
 };
 export type Installation = {
     readonly step: InstallationStep | null;
-    readonly paused: InstallationPause | null;
     readonly rooms: InstallationAmount;
-    readonly parts: InstallationAmount;
     readonly bytes: InstallationAmount;
-    readonly received: InstallationAmount;
 };
-export type ReadinessStatus = Open<'preparing' | 'paused' | 'refused' | 'ready' | 'lost'>;
+export type ReadinessStatus = Open<'preparing' | 'paused' | 'ready' | 'lost'>;
 export type Readiness = {
     readonly status: ReadinessStatus;
     readonly ready: boolean;
@@ -53,7 +42,6 @@ export type Readiness = {
     readonly house: HouseOutcome;
     readonly space: Space | null;
     readonly installation: Installation;
-    readonly refused: readonly RefusedRoom[];
     readonly lost: boolean;
 };
 export type ReadinessFacts = Omit<Readiness, 'status' | 'ready' | 'usable' | 'durability' | 'coverage'> & {

package/dist/mdruntime/recovery.d.ts

@@ -21,4 +21,5 @@ export type Recovery = {
     retire(): Promise<void>;
 };
 export declare function retryDelay(tries: number, firstMs?: number, maxMs?: number): number;
+export declare function untilAnswered<T>(ask: () => Promise<T>, signal: AbortSignal, answered?: (answer: T) => boolean): Promise<T>;
 export declare function createRecovery(options?: RecoveryOptions): Recovery;

package/dist/mdruntime/replica.d.ts

@@ -1,7 +1,7 @@
 import type { BootstrapInventory, MutationResult, OperationScopes, ReplicaAdmission, TypedSelection } from './adapter.js';
 import { type ChangeBatch, type Precondition } from './change.js';
 import { type Collection, type Composition } from './collection.js';
-import type { ModelState } from './model.js';
+import { type ModelState } from './model.js';
 import { type Layer } from './overlay.js';
 import type { HeldEntry, OverlayEntry, StoredEntry } from './tables.js';
 export type ReplicaRecord = {
@@ -12,11 +12,10 @@ export type ReplicaRecord = {
     readonly replica: ReplicaAdmission;
     readonly model: ModelState;
     readonly typedSelection: TypedSelection | null;
-    readonly selectionModel: ModelState;
     readonly providerOwnedPaths: readonly string[];
     readonly roomVersion: string;
     readonly transfer: string;
-    readonly inventory: BootstrapInventory | null;
+    readonly inventory: BootstrapInventory;
     readonly key: number;
 };
 export type HeldReplica = {
@@ -34,8 +33,7 @@ export type Slice = Layer & {
     readonly written: Readonly<Record<string, string>>;
     readonly held: ReadonlySet<string>;
 };
-export declare function compositionOf(record: Pick<ReplicaRecord, 'model' | 'typedSelection' | 'selectionModel'>): Composition;
-export declare function sameMembership(record: Pick<ReplicaRecord, 'typedSelection'>, other: Pick<ReplicaRecord, 'typedSelection'>): boolean;
+export declare function compositionOf(record: Pick<ReplicaRecord, 'model' | 'typedSelection'>, builtIn: ModelState): Composition;
 export declare function storedRecord(record: ReplicaRecord): string;
 export declare function slicing(entries: readonly HeldEntry[], paths: Iterable<string>): Generator<number, Slice, void>;
 export declare function entryAt(layer: Layer & {

package/dist/mdruntime/room-draft.d.ts

@@ -40,6 +40,7 @@ export type RoomDraftParts = {
     };
     readonly file?: {
         readonly blob: Blob;
+        readonly base?: string | null;
     };
 };
 export type HeldFile = {
@@ -112,7 +113,7 @@ export type RoomDraftWrite = {
 export declare function staleWrite(current: RoomDraft | null): RoomDraftWrite;
 export type ChangedPart = {
     readonly path: string;
-    readonly part: Open<'field' | 'section' | 'preamble' | 'markdown' | 'creation' | 'move' | 'removal' | 'file'>;
+    readonly part: Open<'field' | 'section' | 'preamble' | 'markdown' | 'move' | 'removal' | 'file'>;
     readonly name?: string;
 };
 export type RoomDraftRecord = {
@@ -132,7 +133,7 @@ export declare function held(current: HeldParts | undefined, parts: RoomDraftPar
 export declare function underneath(parts: HeldParts, path: string, visible: VisibleLayer | undefined): ChangedUnderneath;
 export declare function heldFile(blob: Blob, base: string | null): Promise<HeldFile>;
 export declare function binaryBase(visible: VisibleLayer | undefined, path: string): string | null;
-export declare function changedParts(path: string, report: ChangedUnderneath): readonly ChangedPart[];
+export declare function changedParts(path: string, parts: HeldParts, visible: VisibleLayer | undefined): readonly ChangedPart[];
 export type TextParts = {
     readonly fields?: Readonly<Record<string, {
         readonly value: unknown;
@@ -149,6 +150,20 @@ export declare function returnedInto(existing: HeldParts | undefined, returned:
 export declare function moveTarget(move: {
     readonly to: string;
 }): string;
+export declare function readSavedParts(named: readonly {
+    readonly path: string;
+    readonly parts: unknown;
+}[]): readonly {
+    readonly path: string;
+    readonly parts: RoomDraftParts;
+}[];
+export declare function partsChanges(named: readonly {
+    readonly path: string;
+    readonly parts: unknown;
+}[]): {
+    readonly changes: readonly Change[];
+    readonly preconditions: readonly Precondition[];
+};
 export declare function changesOf(path: string, parts: HeldParts): {
     changes: readonly Change[];
     bases: readonly Precondition[];

package/dist/mdruntime/save.d.ts

@@ -21,6 +21,7 @@ export type SaveInput = {
     providerOwnedPaths: readonly string[];
     providerLimits: readonly ProviderLimit[];
     visible: VisibleLayer;
+    folders: ReadonlySet<string>;
     handle: string;
     changes: readonly Change[];
     bases: readonly Precondition[];
@@ -75,6 +76,7 @@ export type MoveSide = {
     operations: OperationScopes;
     providerOwnedPaths: readonly string[];
     visible: VisibleLayer;
+    folders: ReadonlySet<string>;
     queued: ReadonlySet<string>;
     unmodeled: boolean;
     validate: Validator;

package/dist/mdruntime/status.d.ts

@@ -1,19 +1,20 @@
 import type { Open } from './open.js';
-import type { ProviderRefusal } from './adapter.js';
 import type { ReturnReason } from './room-draft.js';
 export type AttentionEntry = {
     room: string;
     path: string;
     returned: ReturnReason;
-} | {
+};
+export type UnsentChange = {
     room: string;
-    refusal: ProviderRefusal;
+    path: string;
 };
 export type SyncStatus = {
     state: Open<'pending' | 'syncing' | 'synced'>;
     lastCompleted: string | null;
     providerUnreachable: boolean;
     attentionRequired: readonly AttentionEntry[];
+    unsent: readonly UnsentChange[];
     reset: string | null;
 };
 export type CycleProgress = {

package/dist/mdruntime/store.d.ts

@@ -1,40 +1,34 @@
-import type { BootstrapInventory, Capability, KeptReceipt, Member, ProviderLimit } from './adapter.js';
+import type { BootstrapInventory, Capability, ListedConversation, Member, ProviderLimit } from './adapter.js';
 import type { ChangeBatch } from './change.js';
-import type { Composition } from './collection.js';
+import { type Composition } from './collection.js';
 import type { Plan } from './query.js';
 import type { ReplicaRecord } from './replica.js';
 import type { Submission } from './outcome.js';
 import type { RoomDraftRecord, SavedDraft } from './room-draft.js';
-import type { ModelState } from './model.js';
+import type { ModelState, StoredModel } from './model.js';
 import type { SearchWindow } from './search.js';
-import type { CommittedWrite, ConversationWrite, CountedRoom, HeldConversation, HeldEntry, MessageWindow, QueryAnswer, QueryRoom, Referrer, RoomCommit, RuntimeDatabase, SearchAsk, StoredEntry, StoredFile, TypedEntry, View, Walked } from './tables.js';
+import type { CommittedWrite, ConversationWrite, CountedRoom, HeldConversation, HeldEntry, MessageWindow, QueryAnswer, QueryRoom, Referrer, RoomCommit, RuntimeDatabase, SearchAsk, StoredEntry, StoredFile, TypedEntry, View } from './tables.js';
 export type { ConversationWrite, HeldConversation, MessageWindow } from './tables.js';
-export type TransferWriting = {
-    readonly token: string | null;
-    readonly written: number;
-};
 export type TransferRecord = {
     readonly locator: string;
     readonly transfer: string;
     readonly selection: string;
     readonly from: string;
     readonly last: string;
-    readonly pageToken: string | null;
-    readonly writing: TransferWriting | null;
-    readonly inventory: BootstrapInventory | null;
     readonly done: BootstrapInventory;
     readonly models: {
         readonly collection: ModelState;
-        readonly selection: ModelState;
     };
     readonly key: number | null;
 };
+export type StoredReplica = Omit<ReplicaRecord, 'model'> & {
+    readonly model: StoredModel;
+};
 export type PendingState = {
     readonly drafts: readonly SavedDraft[];
     readonly submission: Submission;
     readonly lost: boolean;
     readonly upload?: unknown;
-    readonly accepted?: string;
 };
 export type TargetRecord = {
     established: boolean;
@@ -74,10 +68,6 @@ export type AuthoredWrite = {
     saved?: ReadonlyMap<string, readonly SavedDraft[]>;
     roomDrafts?: readonly RoomDraftRecord[];
     consumedRoomDrafts?: readonly string[];
-    accepted?: readonly {
-        readonly id: string;
-        readonly roomVersion: string;
-    }[];
 };
 export type StagedPage = {
     readonly entries: readonly StoredEntry[];
@@ -88,8 +78,7 @@ export type RefreshedPage = StagedPage & {
     readonly folderRemovals: readonly string[];
 };
 export type Opened = {
-    readonly rooms: ReadonlyMap<string, ReplicaRecord>;
-    readonly transfers: ReadonlyMap<string, TransferRecord>;
+    readonly rooms: ReadonlyMap<string, StoredReplica>;
     readonly unindexed: ReadonlySet<number>;
     readonly overlaid: ReadonlyMap<number, ReadonlySet<string>>;
     readonly erasing: boolean;
@@ -100,6 +89,8 @@ export type Opened = {
     readonly member: Member | null;
     readonly targets: Readonly<Record<string, TargetRecord>>;
     readonly presentation: readonly PresentationRecord[];
+    readonly conversationList: readonly ListedConversation[] | null;
+    readonly conversationCursor: string | null;
 };
 export type Commit = {
     readonly rooms: readonly RoomCommit[];
@@ -116,24 +107,25 @@ export type RuntimeStore = {
     entries(key: number, view: View, paths: readonly string[]): Promise<readonly HeldEntry[]>;
     typed(key: number, view: View, paths: readonly string[]): Promise<readonly TypedEntry[]>;
     referrers(key: number, view: View, targets: readonly string[], kinds: readonly string[]): Promise<readonly Referrer[]>;
-    walk(key: number, view: View, after: string | null, bytes: number): Promise<Walked>;
     files(key: number, view: View, after: string | null, limit: number): Promise<readonly {
         readonly path: string;
         readonly revision: string;
     }[]>;
+    folders(key: number, view: View, paths: readonly string[]): Promise<readonly string[]>;
     typedWithin(key: number, view: View, roots: readonly string[], within: boolean): Promise<boolean>;
     search(ask: SearchAsk): Promise<SearchWindow>;
-    stage(record: TransferRecord, composition: Composition, page: StagedPage, written?: string): Promise<number | null>;
-    transferPart(locator: string, token: string): Promise<Uint8Array | null>;
-    keepPart(locator: string, token: string, part: Uint8Array): Promise<void>;
-    refresh(key: number, page: RefreshedPage): Promise<void>;
+    stage(record: TransferRecord, composition: Composition, page: StagedPage): Promise<number | null>;
+    refresh(key: number, composition: Composition, page: RefreshedPage): Promise<void>;
     unrefresh(key: number): Promise<void>;
     commit(commit: Commit): Promise<CommittedWrite>;
     fence(locators: readonly string[]): Promise<void>;
     erase(locator: string | null, limit: number): Promise<boolean>;
-    abandon(locator: string, kept?: boolean): Promise<number | null>;
+    abandon(locator: string): Promise<void>;
     release(key: number): Promise<void>;
-    rederive(key: number, limit: number): Promise<boolean>;
+    rederive(key: number, composition: Composition, bytes: number, ms: number, floor: number): Promise<{
+        readonly done: boolean;
+        readonly text: number;
+    }>;
     fact(name: string, value: unknown): Promise<void>;
     queues(): Promise<readonly QueueRecord[]>;
     submit(locator: string, id: string, submission: Submission, lost: boolean): Promise<void>;
@@ -155,13 +147,6 @@ export type RuntimeStore = {
     keepRoomDraft(record: RoomDraftRecord, files: readonly StoredFile[]): Promise<void>;
     discardRoomDraft(locator: string, path: string): Promise<void>;
     fences(): Promise<readonly string[]>;
-    receivedHeads(): Promise<readonly KeptReceipt[]>;
-    receivedParts(key: string, count: number): Promise<readonly unknown[]>;
-    keepReceived(key: string, head: unknown, part?: {
-        index: number;
-        value: unknown;
-    }): Promise<void>;
-    dropReceived(keys: readonly string[]): Promise<void>;
     generation(): Promise<string | null>;
     rememberGeneration(value: string): Promise<void>;
     file(key: string, type: string): Promise<Blob>;

package/dist/mdruntime/stored.d.ts

@@ -1,5 +1,5 @@
 import type { HeadChange } from './adapter.js';
-import type { Composition } from './collection.js';
+import { type Composed, type Composition } from './collection.js';
 import type { HeldBinary } from './overlay.js';
 import type { Connection } from './tables.js';
 export declare const REPLICA_TABLES: readonly string[];
@@ -34,6 +34,7 @@ export type HeldKey = {
     readonly locator: string;
     readonly transfer: string;
     readonly rederiving: number | null;
+    readonly searching: number | null;
 };
 export type ReplicaOpened = {
     readonly rooms: readonly {
@@ -41,11 +42,6 @@ export type ReplicaOpened = {
         readonly key: number;
         readonly record: string;
     }[];
-    readonly transfers: readonly {
-        readonly locator: string;
-        readonly key: number;
-        readonly record: string;
-    }[];
     readonly keys: readonly HeldKey[];
     readonly facts: Readonly<Record<string, string>>;
     readonly presentation: readonly {
@@ -71,7 +67,7 @@ export type RoomCommit = {
         readonly from: number | null;
     };
     readonly refreshed?: true;
-    readonly composition?: Composition;
+    readonly composed: Composed;
     readonly confirmed?: {
         readonly set: readonly StoredEntry[];
         readonly removed: readonly string[];
@@ -90,24 +86,18 @@ export type CountedRoom = {
     readonly key: number;
     readonly roots: readonly string[];
 };
-export type Walked = {
-    readonly entries: readonly HeldEntry[];
-    readonly next: string | null;
-};
-export declare function fingerprint(composition: Composition): string;
 export declare function entered(connection: Connection, locator: string, composition: Composition, rows: readonly StoredEntry[]): number;
 export declare function stage(connection: Connection, request: {
     readonly locator: string;
     readonly transfer: string;
-    readonly record: string;
     readonly key: number | null;
-    readonly composition: Composition;
+    readonly fingerprint: string;
     readonly entries: readonly StoredEntry[];
     readonly folders: readonly string[];
-    readonly written?: string;
 }): number;
 export declare function refreshing(connection: Connection, request: {
     readonly key: number;
+    readonly composed: Composed;
     readonly entries: readonly StoredEntry[];
     readonly removals: readonly string[];
     readonly folders: readonly string[];
@@ -117,28 +107,23 @@ export declare function unrefresh(connection: Connection, key: number): null;
 export declare function counts(connection: Connection, rooms: readonly CountedRoom[]): number[];
 export declare function commit(connection: Connection, rooms: readonly RoomCommit[]): Committed;
 export declare function fenceRooms(connection: Connection, locators: readonly string[]): null;
-export declare function abandon(connection: Connection, locator: string, kept: boolean): number | null;
+export declare function abandon(connection: Connection, locator: string): null;
 export declare function release(connection: Connection, key: number): null;
 export declare function erase(connection: Connection, locator: string | null, limit: number): {
     readonly remaining: boolean;
 };
-export declare function rederive(connection: Connection, key: number, limit: number): {
+export declare function rederive(connection: Connection, key: number, composed: Composed, bytes: number, ms: number, floor: number): {
     readonly done: boolean;
+    readonly text: number;
 };
 export declare function entries(connection: Connection, key: number, view: View, list: readonly string[]): HeldEntry[];
 export declare function typed(connection: Connection, key: number, view: View, list: readonly string[]): TypedEntry[];
 export declare function referrers(connection: Connection, key: number, view: View, targets: readonly string[], kinds: readonly string[]): Referrer[];
-export declare function walk(connection: Connection, key: number, view: View, after: string | null, bytes: number): Walked;
 export declare function files(connection: Connection, key: number, view: View, after: string | null, limit: number): {
     readonly path: string;
     readonly revision: string;
 }[];
+export declare function folders(connection: Connection, key: number, view: View, list: readonly string[]): string[];
 export declare function typedWithin(connection: Connection, key: number, view: View, roots: readonly string[], within: boolean): boolean;
-export declare function transferPart(connection: Connection, locator: string, token: string): Uint8Array | null;
-export declare function keepPart(connection: Connection, request: {
-    readonly locator: string;
-    readonly token: string;
-    readonly part: Uint8Array;
-}): null;
 export declare function opened(connection: Connection): ReplicaOpened;
 export declare function ended(connection: Connection): void;

package/dist/mdruntime/tables.d.ts

@@ -1,12 +1,11 @@
 import { type QueryAnswer, type QueryRoom } from './compile.js';
-import type { KeptReceipt } from './adapter.js';
-import type { Composition } from './collection.js';
+import type { Composed } from './collection.js';
 import { type SearchAsk } from './fulltext.js';
 import { type ConversationWrite, type HeldConversation, type MessageWindow } from './messages.js';
 import type { Plan } from './query.js';
 import type { SearchWindow } from './search.js';
-import { type Committed, type CountedRoom, type HeldEntry, type ReplicaOpened, type Referrer, type RoomCommit, type StoredEntry, type TypedEntry, type View, type Walked } from './stored.js';
-export type { Committed, CountedRoom, HeldEntry, OverlayEntry, ReplicaOpened, Referrer, RoomCommit, StoredEntry, TypedEntry, View, Walked, } from './stored.js';
+import { type Committed, type CountedRoom, type HeldEntry, type ReplicaOpened, type Referrer, type RoomCommit, type StoredEntry, type TypedEntry, type View } from './stored.js';
+export type { Committed, CountedRoom, HeldEntry, OverlayEntry, ReplicaOpened, Referrer, RoomCommit, StoredEntry, TypedEntry, View, } from './stored.js';
 export type { QueryAnswer, QueryRoom } from './compile.js';
 export type { SearchAsk } from './fulltext.js';
 export type { ConversationWrite, HeldConversation, MessageWindow } from './messages.js';
@@ -78,10 +77,6 @@ export type AuthoredRows = {
         readonly path: string;
     })[];
     readonly consumedRoomDrafts?: readonly string[];
-    readonly amendments?: readonly {
-        readonly id: string;
-        readonly amendment: string;
-    }[];
 };
 export type HeldQueues = {
     readonly queues: readonly {
@@ -182,12 +177,6 @@ export interface RuntimeRequests {
         readonly targets: readonly string[];
         readonly kinds: readonly string[];
     }, readonly Referrer[]>;
-    readonly 'replica.walk': Asked<{
-        readonly key: number;
-        readonly view: View;
-        readonly after: string | null;
-        readonly bytes: number;
-    }, Walked>;
     readonly 'replica.files': Asked<{
         readonly key: number;
         readonly view: View;
@@ -197,6 +186,11 @@ export interface RuntimeRequests {
         readonly path: string;
         readonly revision: string;
     }[]>;
+    readonly 'replica.folders': Asked<{
+        readonly key: number;
+        readonly view: View;
+        readonly paths: readonly string[];
+    }, readonly string[]>;
     readonly 'replica.typedWithin': Asked<{
         readonly key: number;
         readonly view: View;
@@ -207,32 +201,17 @@ export interface RuntimeRequests {
         readonly rooms: readonly CountedRoom[];
     }, readonly number[]>;
     readonly 'replica.search': Asked<SearchAsk, SearchWindow>;
-    readonly 'replica.received': Asked<Nothing, readonly KeptReceipt[]>;
-    readonly 'replica.receivedParts': Asked<{
-        readonly key: string;
-        readonly count: number;
-    }, readonly unknown[]>;
     readonly 'replica.stage': Asked<{
         readonly locator: string;
         readonly transfer: string;
-        readonly record: string;
         readonly key: number | null;
-        readonly composition: Composition;
+        readonly fingerprint: string;
         readonly entries: readonly StoredEntry[];
         readonly folders: readonly string[];
-        readonly written?: string;
     }, number | null>;
-    readonly 'replica.transferPart': Asked<{
-        readonly locator: string;
-        readonly token: string;
-    }, Uint8Array | null>;
-    readonly 'replica.keepPart': Asked<{
-        readonly locator: string;
-        readonly token: string;
-        readonly part: Uint8Array;
-    }, null>;
     readonly 'replica.refresh': Asked<{
         readonly key: number;
+        readonly composed: Composed;
         readonly entries: readonly StoredEntry[];
         readonly removals: readonly string[];
         readonly folders: readonly string[];
@@ -256,16 +235,19 @@ export interface RuntimeRequests {
     }>;
     readonly 'replica.abandon': Asked<{
         readonly locator: string;
-        readonly kept: boolean;
-    }, number | null>;
+    }, null>;
     readonly 'replica.release': Asked<{
         readonly key: number;
     }, null>;
     readonly 'replica.rederive': Asked<{
         readonly key: number;
-        readonly limit: number;
+        readonly composed: Composed;
+        readonly bytes: number;
+        readonly ms: number;
+        readonly floor: number;
     }, {
         readonly done: boolean;
+        readonly text: number;
     }>;
     readonly 'replica.fact': Asked<{
         readonly name: string;
@@ -275,17 +257,6 @@ export interface RuntimeRequests {
         readonly app: string;
         readonly value: string;
     }, null>;
-    readonly 'replica.receive': Asked<{
-        readonly key: string;
-        readonly head: string;
-        readonly part?: {
-            readonly index: number;
-            readonly value: string;
-        };
-    }, null>;
-    readonly 'replica.unreceive': Asked<{
-        readonly keys: readonly string[];
-    }, null>;
     readonly 'opened.find': Asked<{
         readonly locator: string;
         readonly path: string;

package/dist/mdruntime/wire.d.ts

@@ -54,6 +54,14 @@ declare const MEMBERS: {
         readonly reach: 'within';
         readonly effect: 'read';
     };
+    readonly 'binaryFile.show': {
+        readonly reach: 'within';
+        readonly effect: 'read';
+    };
+    readonly 'binaryFile.attach': {
+        readonly reach: 'within';
+        readonly effect: 'action';
+    };
     readonly 'binaryFile.part': {
         readonly reach: 'within';
         readonly effect: 'read';
@@ -130,10 +138,6 @@ declare const MEMBERS: {
         readonly reach: 'within';
         readonly effect: 'action';
     };
-    readonly 'conversation.attach': {
-        readonly reach: 'within';
-        readonly effect: 'action';
-    };
     readonly 'conversation.answer': {
         readonly reach: 'within';
         readonly effect: 'action';
@@ -146,10 +150,6 @@ declare const MEMBERS: {
         readonly reach: 'within';
         readonly effect: 'action';
     };
-    readonly 'conversation.cancel': {
-        readonly reach: 'within';
-        readonly effect: 'action';
-    };
     readonly 'conversation.delete': {
         readonly reach: 'within';
         readonly effect: 'action';
@@ -176,6 +176,7 @@ declare const TOPICS: {
     readonly 'sync-status': 'within';
     readonly 'service-mode': 'runtime';
     readonly member: 'runtime';
+    readonly 'authority-changes': 'runtime';
     readonly query: 'within';
     readonly queue: 'within';
     readonly 'room-drafts': 'within';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/mdruntime-families",
-  "version": "0.1.0-c686d19f36a21",
+  "version": "0.1.0-c68df10f5cb2e",
   "description": "react-admin and Refine data providers over the MD Runtime client",
   "license": "MIT",
   "type": "module",
@@ -28,7 +28,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@agentshouse/mdmodel": "0.1.0-c2522b181299a"
+    "@agentshouse/mdmodel": "0.1.0-ca34cd330fc15"
   },
   "peerDependencies": {
     "@refinedev/core": ">=5",
@@ -42,5 +42,10 @@
     "ra-core": {
       "optional": true
     }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentshouse/core.git",
+    "directory": "mdruntime/packages/mdruntime-families"
   }
 }

package/dist/mdruntime/file.d.ts

@@ -1,11 +0,0 @@
-export type ChosenFile = {
-    name: string;
-    blob: Blob;
-};
-export type FileDeclaration = {
-    name: string;
-    mediaType: string;
-    byteLength: number;
-    contentHash: string;
-};
-export declare function declaredFile(file: ChosenFile): Promise<FileDeclaration>;

package/dist/mdruntime/shared.d.ts

@@ -1,15 +0,0 @@
-export type Paths<V> = Readonly<Record<string, V>>;
-export declare function entriesIn<V>(map: Paths<V>): Generator<readonly [string, V]>;
-export declare function keysIn(...maps: readonly Paths<unknown>[]): Generator<number, Set<string>, void>;
-export declare function sortedKeys(map: Paths<unknown>): Generator<number, readonly string[], void>;
-export declare function sorting(keys: Iterable<string>): Generator<number, readonly string[], void>;
-export declare function sharing<V>(map: Paths<V>): Generator<number, Paths<V>, void>;
-export declare function shared<V>(map: Paths<V>): Paths<V>;
-export declare function patched<V>(base: Paths<V>, set: Iterable<readonly [string, V]>, removed?: Iterable<string>): Paths<V>;
-export declare function patching<V>(base: Paths<V>, set: Iterable<readonly [string, V]>, removed?: Iterable<string>): Generator<number, Paths<V>, void>;
-export declare function sizeOf<V>(map: Paths<V>): number;
-export declare function differences<V>(left: Paths<V>, right: Paths<V>, same?: (left: V, right: V) => boolean): Generator<number, ReadonlySet<string>, void>;
-export declare function differing<V>(left: Paths<V>, right: Paths<V>, same?: (left: V, right: V) => boolean): ReadonlySet<string>;
-export declare function drafted<V>(base: Paths<V>): Record<string, V>;
-export declare function settled<V>(draft: Record<string, V>): Paths<V>;
-export declare function settling<V>(draft: Record<string, V>): Generator<number, Paths<V>, void>;

package/dist/mdruntime/transfer.d.ts

@@ -1,9 +0,0 @@
-import type { Refusal } from '@agentshouse/mdmodel';
-export type Unconfirmed = {
-    kind: 'unconfirmed';
-};
-export type Refused = {
-    kind: 'refused';
-    refusal: Refusal;
-};
-export declare const unconfirmed: Unconfirmed;