@agentshouse/mdruntime 0.1.0-c75a43bf2460f → 0.1.0-c7921ed1eb9d6

package/README.md

@@ -12,15 +12,14 @@ npm install @agentshouse/mdruntime
 
 ## Entries
 
-| Entry                           | For                                                                                 |
-| ------------------------------- | ----------------------------------------------------------------------------------- |
-| `@agentshouse/mdruntime/client` | The host's client: `connectMdRuntime(port)`                                         |
-| `@agentshouse/mdruntime/host`   | The host that serves a Runtime: `serveMdRuntime`                                    |
-| `@agentshouse/mdruntime`        | Shared types                                                                        |
-| `@agentshouse/mdruntime/memory` | Tests: `createMemoryAdapter`, an in-memory Adapter                                  |
-| `@agentshouse/mdruntime/tables` | The host's database: the Authored store's and opened files' tables, `answerRuntime` |
-| `@agentshouse/mdruntime/react`  | React over the client: `useObserve`, `useSave`                                      |
-| `@agentshouse/mdruntime/chat`   | The Chat: `Chat`, `mountChat`, its parts and `ChatProvider`                         |
+| Entry                           | For                                                                                            |
+| ------------------------------- | ---------------------------------------------------------------------------------------------- |
+| `@agentshouse/mdruntime/client` | The host's client: `connectMdRuntime(port)`                                                    |
+| `@agentshouse/mdruntime/host`   | The host that serves a Runtime: `serveMdRuntime`                                               |
+| `@agentshouse/mdruntime`        | Shared types                                                                                   |
+| `@agentshouse/mdruntime/memory` | Tests: `createMemoryAdapter`, an in-memory Adapter                                             |
+| `@agentshouse/mdruntime/tables` | The host's database: the Authored store's and opened files' tables, `answerRuntime`            |
+| `@agentshouse/mdruntime/react`  | React over the client: `useObserve`, `useSave`; `useReading`, a reader of an expectation store |
 
 ## Usage
 
@@ -38,17 +37,20 @@ const notes = await runtime.query({ types: ['note'], select: 'all', limit: 20 })
 `storage-loss` when unsynchronized Room Drafts and Pending Changes were lost.
 The host supplies the user-facing wording.
 
-Place the ready chat, themed by CSS custom properties, docked at a third of the
-window; outside React, `mountChat(element, { client: runtime })` places the same:
+In House the bridge object the page holds as `window.houseBridge` places the Chat, which
+House serves with the page: install and bundle nothing for it. Mount it in an element,
+themed by CSS custom properties on that element, docked at a third of the window:
 
-```tsx
-import { Chat } from '@agentshouse/mdruntime/chat';
-
-<Chat client={runtime} width="1/3" showChats style={{ '--chat-accent': '#2a6cf0' }} />;
+```ts
+const chat = await window.houseBridge.chat.mount(element, { width: '1/3', showChats: true });
+element.style.setProperty('--chat-accent', '#2a6cf0');
+chat.update({ width: 'full', showChats: true });
+chat.unmount();
 ```
 
-The rules an App's agent follows, including Local Query, Local Search, Room
-Draft, Save and the Chat, are in [`AGENTS.md`](AGENTS.md).
+The rules an App's agent follows, including Local Query, search, Room
+Draft, Save and the Chat, are the `apps/` pages of House's Guide, which House's
+`guide/open` opens.
 
 ## License
 

package/dist/acceptance.d.ts

@@ -0,0 +1,3 @@
+import type { Runtime } from './runtime.js';
+export declare function submitLater(runtime: Runtime, locator: string): void;
+//# sourceMappingURL=acceptance.d.ts.map

package/dist/acceptance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptance.d.ts","sourceRoot":"","sources":["../src/acceptance.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAiX5C,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,QAK5D"}

package/dist/acceptance.js

@@ -0,0 +1,308 @@
+import { changeSet } from './change-set.js';
+import { declared } from './declaration.js';
+import { leaving as leavingIn, partnerOf } from './change.js';
+import { olderThan, showing } from './install.js';
+import { scoped } from './models.js';
+import { answered, settle } from './queue.js';
+import { refuse } from './refusal.js';
+import { returnedPaths, returning, slicing } from './replica.js';
+import { batchFile } from './saves.js';
+import { rest, roomUnreadable, statusShown } from './shown.js';
+import { advanced, withhold } from './sync.js';
+import { unconfirmed } from './transfer.js';
+import { stepped } from './turn.js';
+async function mark(runtime, local, locator, batch, submission, lost) {
+    const { store, socket, presence } = runtime;
+    const partner = partnerOf(batch, locator);
+    for (const held of partner === null ? [locator] : [locator, partner]) {
+        const { state, room } = await local.pending(held, batch.id);
+        if (!socket.continuing() ||
+            state === undefined ||
+            (JSON.stringify(state.submission) === JSON.stringify(submission) && state.lost === lost)) {
+            continue;
+        }
+        await local.submit(held, batch.id, submission, lost);
+        if (presence.lost(held))
+            continue;
+        if (room)
+            store.changed(changeSet(held, { queue: true }));
+    }
+    statusShown(runtime);
+}
+async function keepUpload({ socket, presence }, local, locator, identifier, upload) {
+    if (!socket.continuing())
+        throw new Error();
+    await local.keepUpload(locator, identifier, upload);
+    if (presence.lost(locator))
+        throw new Error();
+    if (!socket.continuing())
+        throw new Error();
+}
+function logAccepted({ journal }, locator, submitted, accepted) {
+    journal.record(`outcome ${locator} ${submitted.id} accepted ${accepted.roomVersion}` +
+        (accepted.author === undefined ? '' : ` author ${accepted.author}`) +
+        (accepted.time === undefined ? '' : ` time ${accepted.time}`));
+}
+function restands(adoptions) {
+    return adoptions.flatMap((one) => (one === null || !('record' in one) ? [] : [one]));
+}
+async function adoption(runtime, room, current, local, submitted, accepted) {
+    const { store, socket } = runtime;
+    if (!socket.continuing())
+        return unconfirmed;
+    if (current === undefined || !current.queue.some((batch) => batch.id === submitted.id)) {
+        return null;
+    }
+    const held = current.record.roomVersion;
+    logAccepted(runtime, room.locator, submitted, accepted);
+    let record = current.record;
+    let adopted;
+    if (!socket.reads.reached(room.locator, held, accepted.roomVersion) &&
+        !olderThan(runtime, room.locator, accepted.roomVersion, held)) {
+        const paths = [...returnedPaths(submitted, accepted)];
+        const confirmedLayer = await stepped(slicing(await local.entries(record.key, 'confirmed', paths), paths));
+        adopted = await stepped(returning(confirmedLayer, submitted, accepted, accepted.roomVersion, store.composed(record)));
+        record = {
+            ...record,
+            roomVersion: socket.follows(room.locator, held, accepted.roomVersion)
+                ? accepted.roomVersion
+                : held,
+        };
+    }
+    const reached = record.roomVersion;
+    return {
+        locator: room.locator,
+        record,
+        accepted: submitted.id,
+        ...(adopted === undefined ? {} : { adopted }),
+        after() {
+            showing(runtime, room.locator, accepted.roomVersion, reached);
+            runtime.presence.readable(room.locator);
+        },
+    };
+}
+async function adopted(runtime, room, local, submitted, accepted) {
+    let kept = true;
+    await settle(runtime, [room.locator], async (held) => {
+        const adopting = await adoption(runtime, room, held.get(room.locator)?.replica, local, submitted, accepted);
+        kept = adopting !== unconfirmed;
+        return restands([adopting]);
+    });
+    return kept;
+}
+async function adoptedMove(runtime, room, partner, local, submitted, accepted) {
+    const other = runtime.presence.room(partner);
+    let kept = true;
+    await settle(runtime, [room.locator, partner], async (held) => {
+        const left = await adoption(runtime, room, held.get(room.locator)?.replica, local, submitted, accepted);
+        const there = held.get(partner)?.replica;
+        const arriving = there?.queue.find((batch) => batch.id === submitted.id);
+        const arrived = other === undefined || arriving === undefined || accepted.destination === undefined
+            ? null
+            : await adoption(runtime, other, there, local, arriving, {
+                kind: 'accepted',
+                ...accepted.destination,
+            });
+        kept = left !== unconfirmed;
+        return restands([left, arrived]);
+    });
+    submitLater(runtime, partner);
+    return kept;
+}
+async function behindIn({ store }, locator, batch) {
+    const local = await store.open();
+    const [order, { room }] = await Promise.all([
+        local.order(locator),
+        local.pending(locator, batch.id),
+    ]);
+    return room ? order.indexOf(batch.id) > 0 : order.length > 0;
+}
+async function submitRoom(runtime, room, local, authorized, progress, signal) {
+    const { store, socket, presence, journal } = runtime;
+    while (socket.continuing() &&
+        socket.session.now().authorization !== undefined &&
+        !signal.aborted) {
+        const headId = (await local.order(room.locator)).find((id) => store.landed.of(room.locator, id) === undefined);
+        if (headId === undefined)
+            return 'done';
+        const [head, pending] = await Promise.all([
+            local.batch(room.locator, headId),
+            local.pending(room.locator, headId),
+        ]);
+        if (head === null || !pending.room)
+            return 'done';
+        const { state } = pending;
+        const partner = partnerOf(head, room.locator);
+        if (partner !== null && !leavingIn(head, room.locator)) {
+            submitLater(runtime, partner);
+            return 'done';
+        }
+        if (partner !== null && (await behindIn(runtime, partner, head))) {
+            progress.complete = false;
+            return 'done';
+        }
+        const { submission, lost: earlier } = state ?? {
+            submission: { state: 'waiting' },
+            lost: false,
+        };
+        if (submission.state === 'reset' && Date.now() < Date.parse(submission.reset)) {
+            progress.complete = false;
+            return { at: Date.parse(submission.reset) };
+        }
+        if (socket.writesHeld()) {
+            progress.complete = false;
+            journal.record(`submission ${room.locator} ${head.id} held`);
+            return 'done';
+        }
+        const lost = earlier || submission.state === 'submitted';
+        let result;
+        journal.record(`submission ${room.locator} ${head.id}`);
+        await store.exclusive(() => mark(runtime, local, room.locator, head, { state: 'submitted' }, lost));
+        if (socket.session.now().paused || presence.lost(room.locator))
+            return 'done';
+        if (signal.aborted || socket.writesHeld()) {
+            await store.exclusive(() => mark(runtime, local, room.locator, head, submission, earlier));
+            if (signal.aborted)
+                return 'done';
+            progress.complete = false;
+            journal.record(`submission ${room.locator} ${head.id} held`);
+            return 'done';
+        }
+        const opensBefore = socket.session.now().openSignals;
+        const answeredHere = socket.awaitingAnswer(room.locator);
+        const answeredThere = partner === null ? () => { } : socket.awaitingAnswer(partner);
+        const heard = () => {
+            answeredHere();
+            answeredThere();
+        };
+        try {
+            result = await socket.mutate(authorized, {
+                locator: room.locator,
+                changeBatch: head,
+                file: batchFile(store, head),
+                ...(state?.upload === undefined ? {} : { upload: state.upload }),
+            }, (upload) => store.exclusive(() => keepUpload(runtime, local, room.locator, head.id, upload)));
+        }
+        catch {
+            heard();
+            progress.complete = false;
+            if (socket.continuing())
+                progress.reachable = false;
+            return 'again';
+        }
+        if (signal.aborted) {
+            heard();
+            return 'done';
+        }
+        if (result.kind !== 'accepted' || !socket.continuing())
+            heard();
+        if (!socket.continuing())
+            return 'done';
+        if (result.kind === 'transport-uncertainty') {
+            progress.complete = false;
+            progress.reachable = false;
+            return 'again';
+        }
+        if (result.kind === 'room-not-readable') {
+            progress.complete = false;
+            roomUnreadable(runtime, (presence.room(result.locator) ?? room).locator);
+            return 'done';
+        }
+        if (result.kind === 'revoked-authorization') {
+            await refuse(runtime, 'revoked-authorization');
+            return 'done';
+        }
+        if (result.kind === 'scoped-refusal') {
+            await scoped(runtime, result, room.locator, declared(room));
+            progress.complete = false;
+            return 'done';
+        }
+        if (result.kind === 'write-halted') {
+            journal.record(`outcome ${room.locator} ${head.id} write-halted`);
+            await store.exclusive(() => mark(runtime, local, room.locator, head, { state: 'waiting' }, lost));
+            if (!socket.haltedSince(opensBefore))
+                continue;
+            progress.complete = false;
+            return 'done';
+        }
+        const other = partner === null ? undefined : presence.room(partner);
+        if (result.kind === 'conflicted' ||
+            result.kind === 'rejected' ||
+            result.kind === 'retryable-refusal') {
+            journal.record(`outcome ${room.locator} ${head.id} ${result.kind}` +
+                (result.kind === 'conflicted' && result.roomVersion !== undefined
+                    ? ` ${result.roomVersion}`
+                    : ''));
+            journal.record(`refusal ${result.kind} ${result.code}`);
+        }
+        if (result.kind === 'retryable-refusal') {
+            const reset = result.reset;
+            progress.complete = false;
+            await store.exclusive(() => mark(runtime, local, room.locator, head, reset === undefined ? { state: 'waiting' } : { state: 'reset', reset }, lost));
+            return reset === undefined ? 'again' : { at: Date.parse(reset) };
+        }
+        if (result.kind === 'conflicted' || result.kind === 'rejected') {
+            const refreshed = async () => ({
+                there: other === undefined ? null : await advanced(runtime, other, local, authorized),
+                here: await advanced(runtime, room, local, authorized),
+            });
+            const judged = result.kind === 'conflicted' && other !== undefined ? await refreshed() : null;
+            if (judged !== null && (judged.there !== null || judged.here !== null)) {
+                await store.exclusive(() => mark(runtime, local, room.locator, head, { state: 'waiting' }, lost));
+                if (other !== undefined && judged.there !== null) {
+                    await withhold(runtime, judged.there, other, local, progress);
+                }
+                if (judged.here !== null)
+                    await withhold(runtime, judged.here, room, local, progress);
+                return 'done';
+            }
+            await answered(runtime, room.locator, head, result);
+            const { there, here } = judged ?? (await refreshed());
+            if (other !== undefined && there !== null) {
+                await withhold(runtime, there, other, local, progress);
+            }
+            if (here !== null) {
+                await withhold(runtime, here, room, local, progress);
+                return 'done';
+            }
+            continue;
+        }
+        const kept = await (partner === null
+            ? adopted(runtime, room, local, head, result)
+            : adoptedMove(runtime, room, partner, local, head, result)).finally(heard);
+        if (!kept) {
+            progress.complete = false;
+            return 'done';
+        }
+    }
+    return 'done';
+}
+export function submitLater(runtime, locator) {
+    if (runtime.localSaves)
+        return;
+    void runtime.recovery.attempt(`submit ${locator}`, (signal) => submitPass(runtime, locator, signal));
+}
+async function submitPass(runtime, locator, signal) {
+    const { store, socket, presence } = runtime;
+    const room = presence.room(locator);
+    if (!socket.continuing() || socket.stopping() || room === undefined) {
+        return 'done';
+    }
+    const progress = { complete: true, reachable: true };
+    let next;
+    try {
+        await socket.authorize();
+        const { authorization } = socket.session.now();
+        if (authorization === undefined)
+            return 'done';
+        next = await submitRoom(runtime, room, await store.open(), authorization, progress, signal);
+    }
+    catch {
+        progress.reachable = false;
+        next = 'again';
+    }
+    if (signal.aborted)
+        return 'done';
+    await rest(runtime, progress);
+    return next === 'again' && !socket.isOpen() ? 'done' : next;
+}

package/dist/actions.d.ts

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

package/dist/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAK/D,OAAO,EAUL,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAG5C,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAOF,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,YAAiB,GACvB,OAAO,CAAC,aAAa,CAAC,CAqCxB;AAED,wBAAsB,OAAO,CAC3B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAShD;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,CAAC,CAuBrB;AAwBD,wBAAsB,YAAY,CAChC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAChC,OAAO,CAAC,UAAU,CAAC,CA6BrB;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,UAAU,CAAC,CAiBrB;AAuCD,wBAAsB,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,CAKhG;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAiB3F;AAiBD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,QAG3C"}

package/dist/actions.js

@@ -0,0 +1,251 @@
+import { roomTarget, target } from '@agentshouse/mdmodel';
+import { resendConversations } from './conversation.js';
+import { listingNow } from './listing.js';
+import { locked, lockedRooms } from './locks.js';
+import { scoped } from './models.js';
+import { ABSENT_TARGET, calledResult, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, undeclared, UNCERTAIN, UNREADABLE, } from './outcome.js';
+import { refuse } from './refusal.js';
+function operationOf(input) {
+    const operation = input?.operation_id;
+    return typeof operation === 'string' ? operation : null;
+}
+export async function readHistory(runtime, locator, path, query = {}) {
+    const { store, socket, presence, journal } = runtime;
+    const { session } = socket;
+    if (socket.closed() || session.now().refusal !== null)
+        return UNCERTAIN;
+    await socket.firstDiscovery;
+    if (!session.now().roomsNamed)
+        return UNCERTAIN;
+    try {
+        await socket.authorize();
+    }
+    catch {
+        return UNCERTAIN;
+    }
+    const { closed, authorization, refusal } = session.now();
+    if (closed || authorization === undefined || refusal !== null)
+        return UNCERTAIN;
+    const since = presence.losses();
+    const transfer = ['transfer', 'history', locator, path];
+    if (query.revision !== undefined)
+        transfer.push(query.revision);
+    if (query.pageToken !== undefined)
+        transfer.push(query.pageToken);
+    journal.record(transfer.join(' '));
+    try {
+        const result = await socket.history(authorization, {
+            locator,
+            path,
+            ...(query.revision === undefined ? {} : { revision: query.revision }),
+            ...(query.pageToken === undefined ? {} : { pageToken: query.pageToken }),
+        });
+        journal.record(`outcome history ${result.kind}`);
+        if (presence.lostSince(locator, since))
+            return failure({ kind: 'room-not-readable', locator });
+        if (result.kind === 'scoped-refusal') {
+            const room = await store.record(result.locator);
+            if (room !== undefined)
+                await scoped(runtime, result, room.locator, room.declaration);
+        }
+        if (result.kind === 'revoked-authorization')
+            await refuse(runtime, 'revoked-authorization');
+        return historyAnswer(result);
+    }
+    catch {
+        journal.record('outcome history transport-uncertainty');
+        return UNCERTAIN;
+    }
+}
+export async function located(runtime, room, path, destination) {
+    const crossing = roomTarget(destination);
+    const listing = await listingNow(runtime);
+    if (crossing === null) {
+        const named = target(path, destination);
+        return named === null || !listing.has(room) ? null : { room, path: named };
+    }
+    const held = [...listing.values()].find((listed) => listed.handle === crossing.handle);
+    return held === undefined ? null : { room: held.locator, path: crossing.path };
+}
+export async function resolveReference(runtime, room, path, destination) {
+    const { store } = runtime;
+    if (roomTarget(destination) === null && target(path, destination) === null) {
+        return ABSENT_TARGET;
+    }
+    const at = await located(runtime, room, path, destination);
+    if (at === null)
+        return UNREADABLE;
+    if (await locked(runtime, at.room))
+        return LOCKED_UNREADABLE;
+    const held = await store.record(at.room);
+    if (held !== undefined &&
+        (await (await store.open()).entries(held.key, 'visible', [at.path])).length > 0) {
+        return { kind: 'document', ...at };
+    }
+    const history = await readHistory(runtime, at.room, at.path);
+    if (history.kind === 'no-history' || history.kind === 'revision')
+        return ABSENT_TARGET;
+    if (history.kind !== 'history')
+        return history;
+    const [last] = history.revisions;
+    if (last === undefined)
+        return ABSENT_TARGET;
+    return history.deleted === true
+        ? { kind: 'deleted', ...at, revision: last }
+        : { kind: 'document', ...at };
+}
+async function declaredAction({ store }, name) {
+    for (const capability of (await (await store.open()).facts()).capabilities) {
+        for (const action of capability.actions ?? []) {
+            if (action.name === name)
+                return action;
+        }
+    }
+    return undefined;
+}
+async function calledRooms(runtime, name, input) {
+    const member = (await declaredAction(runtime, name))?.room;
+    if (member === undefined || input === null || typeof input !== 'object')
+        return [];
+    const named = input[member];
+    return (Array.isArray(named) ? named : [named]).filter((room) => typeof room === 'string');
+}
+export async function invokeAction(runtime, name, input, dispatching) {
+    const { store, socket, journal } = runtime;
+    const { session } = socket;
+    await socket.ready;
+    if (socket.closed() || session.now().refusal !== null)
+        return UNCERTAIN;
+    if ((await declaredAction(runtime, name)) === undefined)
+        return undeclared(name);
+    try {
+        await socket.authorize();
+    }
+    catch {
+        return UNCERTAIN;
+    }
+    const { closed, authorization, refusal } = session.now();
+    if (closed || authorization === undefined || refusal !== null)
+        return UNCERTAIN;
+    await dispatching?.();
+    journal.record(`transfer action ${name}`);
+    try {
+        const result = await socket.action(authorization, { name, input });
+        if (result.kind === 'scoped-refusal') {
+            const room = await store.record(result.locator);
+            if (room !== undefined)
+                await scoped(runtime, result, room.locator, room.declaration);
+        }
+        if (result.kind === 'revoked-authorization')
+            await refuse(runtime, 'revoked-authorization');
+        journal.record(`outcome action ${result.kind}`);
+        if (result.kind === 'rejected')
+            journal.record(`refusal rejected ${result.code}`);
+        return calledResult(result);
+    }
+    catch {
+        journal.record('outcome action transport-uncertainty');
+        return UNCERTAIN;
+    }
+}
+export async function readConversationHistory(runtime, request) {
+    const { socket, journal } = runtime;
+    await socket.ready;
+    const stream = socket.conversations();
+    if (socket.closed() || socket.session.now().refusal !== null || stream?.history === undefined) {
+        return UNCERTAIN;
+    }
+    journal.record('transfer conversation history');
+    try {
+        const result = await stream.history(request);
+        if (result.kind === 'revoked-authorization')
+            await refuse(runtime, 'revoked-authorization');
+        journal.record(`outcome conversation history ${result.kind}`);
+        return calledResult(result);
+    }
+    catch {
+        journal.record('outcome conversation history transport-uncertainty');
+        return UNCERTAIN;
+    }
+}
+function unsettled(result) {
+    if (result.kind === 'action')
+        return false;
+    return result.retryable && (result.kind !== 'rejected' || result.reset === undefined);
+}
+async function recoveredAction(runtime, name, input) {
+    const { store, socket, recovery } = runtime;
+    const { lanes } = socket;
+    const operation = operationOf(input);
+    if (operation === null)
+        return invokeAction(runtime, name, input);
+    const kept = async () => (await store.open()).keepCall({ operation, name, input });
+    lanes.call(operation);
+    try {
+        let result = await invokeAction(runtime, name, input, kept);
+        if (unsettled(result)) {
+            await recovery.attempt(`action ${operation}`, async () => {
+                if (socket.closed() || socket.session.now().refusal !== null)
+                    return 'done';
+                if (!socket.isOpen())
+                    return 'again';
+                result = await invokeAction(runtime, name, input, kept);
+                return unsettled(result) ? 'again' : 'done';
+            }, { again: true });
+        }
+        if (!unsettled(result))
+            await (await store.open()).dropCall(operation);
+        return result;
+    }
+    finally {
+        lanes.called(operation);
+    }
+}
+export async function called(runtime, name, input) {
+    await runtime.socket.ready;
+    const lockedNow = await lockedRooms(runtime);
+    const room = (await calledRooms(runtime, name, input)).find((one) => lockedNow.includes(one));
+    return room === undefined ? recoveredAction(runtime, name, input) : lockedRoom(room);
+}
+export async function resendCalls(runtime, signal) {
+    const { store, socket } = runtime;
+    const { lanes } = socket;
+    if (!socket.isOpen() || socket.closed() || socket.stopping())
+        return 'done';
+    const local = await store.open();
+    for (const held of await local.calls()) {
+        if (lanes.calling(held.operation))
+            continue;
+        if (socket.closed() || signal.aborted)
+            return 'done';
+        lanes.call(held.operation);
+        try {
+            if (unsettled(await invokeAction(runtime, held.name, held.input)))
+                return 'again';
+            await local.dropCall(held.operation);
+        }
+        finally {
+            lanes.called(held.operation);
+        }
+    }
+    return 'done';
+}
+async function resendPass({ socket, conversations }, signal) {
+    if (!socket.continuing() || !socket.isOpen() || socket.stopping())
+        return 'done';
+    const reading = { complete: true, reachable: true };
+    try {
+        await resendConversations(conversations, reading);
+    }
+    catch {
+        reading.reachable = false;
+    }
+    if (signal.aborted)
+        return 'done';
+    return reading.reachable && reading.complete ? 'done' : 'again';
+}
+export function resendLater(runtime) {
+    if (!runtime.socket.isOpen())
+        return;
+    void runtime.recovery.attempt('resend', (signal) => resendPass(runtime, signal), { again: true });
+}