@agentshouse/mdruntime-families 0.1.0-cb4fa0f3f8f25 → 0.1.0-cb5bf9bcc7bae

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.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,11 +299,10 @@ 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 = {
@@ -310,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';
@@ -386,7 +394,7 @@ export type HistoryAuthor = {
     kind: 'user';
     id: string;
 } | {
-    kind: 'site' | 'inbox';
+    kind: 'site' | 'inbox' | 'app';
     id: string;
     name: string;
 };
@@ -469,52 +477,44 @@ 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>;

package/dist/mdruntime/client.d.ts

@@ -1,6 +1,6 @@
 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 { AttachAnswer, BinaryAnswer, CallResult, DownloadAnswer, HistoryAnswer, Offline, QueueEntry, Resolution } from './outcome.js';
 import type { DocumentQuery, DocumentResult, GroupQuery, GroupResult, PendingResult } from './query.js';
@@ -35,10 +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>;
-        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: {

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>>;
@@ -25,6 +23,5 @@ export declare function selected(composition: Composition, path: string): boolea
 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

@@ -145,9 +145,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,8 +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 { 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'>;
@@ -10,7 +9,7 @@ export type ConversationEntry = {
     conversation: string;
     agent: {
         identity: string;
-        name: string | null;
+        name: string;
     };
     name: string;
     created: string;
@@ -51,6 +50,7 @@ export type ConversationView = {
     commands: readonly ProcessCommand[];
     options: readonly SessionOption[];
     starting: string | null;
+    subagents: readonly RunningSubagent[];
     link: {
         connected: boolean;
     } | null;
@@ -64,26 +64,27 @@ 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>;
-    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;
     online(): boolean;
-    listed(): boolean;
     full(): boolean;
     closed(): boolean;
     unanswered(): void;
@@ -92,15 +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;
     learned(): void;
-    declared(): void;
-    reconnected(): 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

@@ -1,5 +1,5 @@
 import type { MdRuntimeClient } from './client.js';
-import type { ShownAnswer } from './outcome.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;

package/dist/mdruntime/model.d.ts

@@ -59,5 +59,4 @@ 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/outcome.d.ts

@@ -80,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

@@ -235,7 +235,7 @@ export type GroupShape = {
 export type PlanArea = {
     room: string;
     path: string;
-    types: readonly string[];
+    open: readonly string[];
 };
 export type PlanReach = {
     rooms: readonly string[];

package/dist/mdruntime/reach.d.ts

@@ -9,7 +9,7 @@ export type ReachedDocument = {
 export type ReachedArea = {
     readonly room: string;
     readonly path: string;
-    readonly types: readonly string[];
+    readonly open: readonly string[];
 };
 export type PortReach = {
     readonly rooms: readonly string[];

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

@@ -15,7 +15,7 @@ export type ReplicaRecord = {
     readonly providerOwnedPaths: readonly string[];
     readonly roomVersion: string;
     readonly transfer: string;
-    readonly inventory: BootstrapInventory | null;
+    readonly inventory: BootstrapInventory;
     readonly key: number;
 };
 export type HeldReplica = {
@@ -34,7 +34,6 @@ export type Slice = Layer & {
     readonly held: ReadonlySet<string>;
 };
 export declare function compositionOf(record: Pick<ReplicaRecord, 'model' | 'typedSelection'>, builtIn: ModelState): Composition;
-export declare function sameMembership(record: Pick<ReplicaRecord, 'typedSelection'>, other: Pick<ReplicaRecord, 'typedSelection'>): boolean;
 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/status.d.ts

@@ -1,13 +1,9 @@
 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;
-} | {
-    room: string;
-    refusal: ProviderRefusal;
 };
 export type UnsentChange = {
     room: string;

package/dist/mdruntime/store.d.ts

@@ -1,13 +1,13 @@
-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 { 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, type StoredModel } from './model.js';
+import type { ModelState, StoredModel } from './model.js';
 import type { SearchWindow } from './search.js';
-import type { CommittedWrite, ConversationWrite, CountedRoom, HeldConversation, HeldEntry, KeptPart, 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 TransferRecord = {
     readonly locator: string;
@@ -15,8 +15,6 @@ export type TransferRecord = {
     readonly selection: string;
     readonly from: string;
     readonly last: string;
-    readonly pageToken: string | null;
-    readonly inventory: BootstrapInventory | null;
     readonly done: BootstrapInventory;
     readonly models: {
         readonly collection: ModelState;
@@ -26,17 +24,11 @@ export type TransferRecord = {
 export type StoredReplica = Omit<ReplicaRecord, 'model'> & {
     readonly model: StoredModel;
 };
-export type StoredTransfer = Omit<TransferRecord, 'models'> & {
-    readonly models: {
-        readonly collection: 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;
@@ -76,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[];
@@ -91,8 +79,6 @@ export type RefreshedPage = StagedPage & {
 };
 export type Opened = {
     readonly rooms: ReadonlyMap<string, StoredReplica>;
-    readonly transfers: ReadonlyMap<string, StoredTransfer>;
-    readonly kept: ReadonlyMap<string, ReadonlyMap<string, number>>;
     readonly unindexed: ReadonlySet<number>;
     readonly overlaid: ReadonlyMap<number, ReadonlySet<string>>;
     readonly erasing: boolean;
@@ -103,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[];
@@ -119,7 +107,6 @@ 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;
@@ -127,15 +114,13 @@ export type RuntimeStore = {
     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>;
-    keepParts(parts: readonly KeptPart[]): 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, composition: Composition, bytes: number, ms: number, floor: number): Promise<{
         readonly done: boolean;
@@ -162,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

@@ -42,16 +42,6 @@ export type ReplicaOpened = {
         readonly key: number;
         readonly record: string;
     }[];
-    readonly transfers: readonly {
-        readonly locator: string;
-        readonly key: number;
-        readonly record: string;
-    }[];
-    readonly kept: readonly {
-        readonly locator: string;
-        readonly token: string;
-        readonly bytes: number;
-    }[];
     readonly keys: readonly HeldKey[];
     readonly facts: Readonly<Record<string, string>>;
     readonly presentation: readonly {
@@ -96,20 +86,14 @@ export type CountedRoom = {
     readonly key: number;
     readonly roots: readonly string[];
 };
-export type Walked = {
-    readonly entries: readonly HeldEntry[];
-    readonly next: string | null;
-};
 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 fingerprint: string;
     readonly entries: readonly StoredEntry[];
     readonly folders: readonly string[];
-    readonly written?: string;
 }): number;
 export declare function refreshing(connection: Connection, request: {
     readonly key: number;
@@ -123,7 +107,7 @@ 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;
@@ -135,19 +119,11 @@ export declare function rederive(connection: Connection, key: number, composed:
 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 type KeptPart = {
-    readonly locator: string;
-    readonly token: string;
-    readonly part: Uint8Array;
-};
-export declare function keepParts(connection: Connection, parts: readonly KeptPart[]): 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 { 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 KeptPart, type ReplicaOpened, type Referrer, type RoomCommit, type StoredEntry, type TypedEntry, type View, type Walked } from './stored.js';
-export type { Committed, CountedRoom, HeldEntry, KeptPart, 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;
@@ -212,28 +201,14 @@ 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 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.keepParts': Asked<{
-        readonly parts: readonly KeptPart[];
-    }, null>;
     readonly 'replica.refresh': Asked<{
         readonly key: number;
         readonly composed: Composed;
@@ -260,8 +235,7 @@ export interface RuntimeRequests {
     }>;
     readonly 'replica.abandon': Asked<{
         readonly locator: string;
-        readonly kept: boolean;
-    }, number | null>;
+    }, null>;
     readonly 'replica.release': Asked<{
         readonly key: number;
     }, null>;
@@ -283,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

@@ -150,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';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/mdruntime-families",
-  "version": "0.1.0-cb4fa0f3f8f25",
+  "version": "0.1.0-cb5bf9bcc7bae",
   "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-c9952fa046c11"
+    "@agentshouse/mdmodel": "0.1.0-cf528e67c49a9"
   },
   "peerDependencies": {
     "@refinedev/core": ">=5",

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;