@agentshouse/mdruntime 0.1.0-cd26b960b7262 → 0.1.0-cd30853a1b15e

package/dist/act-lanes.js

@@ -0,0 +1,225 @@
+import { expectedList } from './expectation.js';
+import { changeBatchIdentity } from './identity.js';
+const IDLE = { busy: false, drawn: false, ended: null };
+export function acting(rules) {
+    const { store, uncertain, ending, settles } = rules;
+    const mint = rules.mint ?? (() => changeBatchIdentity());
+    const identities = new Map();
+    const waiting = new Map();
+    const settling = new Map();
+    const blobs = new WeakMap();
+    let counted = 0;
+    let touches = 0;
+    const requestOf = (name, input) => {
+        const carried = [];
+        const json = JSON.stringify(input, (_key, value) => {
+            if (!(value instanceof Blob))
+                return value;
+            let one = blobs.get(value);
+            if (one === undefined) {
+                counted += 1;
+                one = counted;
+                blobs.set(value, one);
+            }
+            carried.push(one);
+            return null;
+        });
+        return `${name}\u0000${json}\u0000${carried.join(',')}`;
+    };
+    const identityOf = (request) => {
+        const held = identities.get(request);
+        if (held !== undefined)
+            return held;
+        const fresh = { operation: mint(), touched: 0, flying: 0 };
+        identities.set(request, fresh);
+        return fresh;
+    };
+    const settled = (act, ended, calls) => {
+        const released = new Map();
+        for (const { request, identity, ended: answered } of calls) {
+            const heard = answered === 'accepted' || answered === 'refused';
+            if (ended === 'accepted' && heard)
+                released.set(request, identity.touched);
+            else {
+                touches += 1;
+                identity.touched = touches;
+                identities.set(request, identity);
+            }
+        }
+        if (ended === 'refused' || ended === 'unsent')
+            store.drop(act);
+        for (const { request, ended: answered } of calls) {
+            const earlier = waiting.get(request);
+            if (answered === 'unsent' && earlier !== undefined)
+                continue;
+            if (earlier !== undefined && earlier !== act)
+                store.drop(earlier);
+            if (ended === 'unanswered')
+                waiting.set(request, act);
+            else
+                waiting.delete(request);
+        }
+        if (ended === 'accepted' || calls.some((one) => one.ended === 'accepted'))
+            rules.acted?.();
+        return released;
+    };
+    const release = (released) => {
+        for (const [request, touched] of released) {
+            const held = identities.get(request);
+            if (held !== undefined && held.touched === touched && held.flying === 0) {
+                identities.delete(request);
+            }
+        }
+    };
+    return {
+        open() {
+            const listeners = new Set();
+            const releasing = new Map();
+            let tail = Promise.resolve();
+            let pressed = 0;
+            let drawing = 0;
+            let ended = null;
+            let held = null;
+            let presses = 0;
+            let shown = IDLE;
+            const show = () => {
+                const busy = pressed > 0;
+                const drawn = drawing > 0;
+                if (shown.busy === busy && shown.drawn === drawn && shown.ended === ended)
+                    return;
+                shown = { busy, drawn, ended };
+                for (const listener of listeners)
+                    listener();
+            };
+            const awaiting = (outcome, operations, heard, again) => new Promise((resolve) => {
+                const forgotten = () => {
+                    for (const operation of operations)
+                        if (settling.get(operation) === record)
+                            settling.delete(operation);
+                };
+                const record = {
+                    supersede() {
+                        if (held !== record)
+                            return;
+                        held = null;
+                        forgotten();
+                        resolve(outcome);
+                    },
+                };
+                held = record;
+                for (const operation of operations)
+                    settling.set(operation, record);
+                const answers = operations.map((operation) => heard(operation).then((answered) => {
+                    if (!answered)
+                        record.supersede();
+                    return answered;
+                }));
+                void Promise.all(answers).then(() => {
+                    if (held !== record)
+                        return;
+                    held = null;
+                    forgotten();
+                    resolve(again());
+                }, () => record.supersede());
+            });
+            const attempt = (steps, expected, press) => {
+                const act = store.begin();
+                let drew = false;
+                const expect = (more) => {
+                    if (expectedList(more).length === 0)
+                        return;
+                    store.expect(act, more);
+                    if (drew)
+                        return;
+                    drew = true;
+                    drawing += 1;
+                    show();
+                };
+                pressed += 1;
+                expect(expected);
+                show();
+                const calls = [];
+                const send = Object.assign(async (name, input, sending) => {
+                    const request = requestOf(name, input);
+                    const identity = identityOf(request);
+                    settling.get(identity.operation)?.supersede();
+                    const called = { request, identity, ended: null };
+                    calls.push(called);
+                    touches += 1;
+                    identity.touched = touches;
+                    identity.flying += 1;
+                    let outcome;
+                    try {
+                        outcome = await sending(identity.operation);
+                    }
+                    catch {
+                        outcome = uncertain;
+                    }
+                    finally {
+                        identity.flying -= 1;
+                    }
+                    called.ended = ending(outcome);
+                    return outcome;
+                }, { expect });
+                const end = (outcome, how) => {
+                    for (const [request, touched] of settled(act, how, calls))
+                        releasing.set(request, touched);
+                    pressed -= 1;
+                    if (drew)
+                        drawing -= 1;
+                    ended = outcome;
+                    if (pressed === 0) {
+                        release(releasing);
+                        releasing.clear();
+                    }
+                    show();
+                };
+                const turn = tail.then(async () => {
+                    ended = null;
+                    show();
+                    let outcome;
+                    try {
+                        outcome = await steps(send);
+                    }
+                    catch (error) {
+                        end(uncertain, 'unanswered');
+                        throw error;
+                    }
+                    const how = ending(outcome);
+                    end(outcome, how);
+                    return { outcome, how };
+                });
+                tail = turn.catch(() => undefined);
+                return turn.then(({ outcome, how }) => {
+                    const lost = calls.flatMap(({ identity, ended: answered }) => answered === 'unanswered' ? [identity.operation] : []);
+                    if (how !== 'unanswered' || lost.length === 0 || settles === undefined)
+                        return outcome;
+                    if (press !== presses)
+                        return outcome;
+                    return awaiting(outcome, lost, settles, () => attempt(steps, expected, press));
+                });
+            };
+            const run = (steps, expected = null) => {
+                held?.supersede();
+                presses += 1;
+                return attempt(steps, expected, presses);
+            };
+            return {
+                run,
+                shown: () => shown,
+                subscribe(listener) {
+                    listeners.add(listener);
+                    return () => {
+                        listeners.delete(listener);
+                    };
+                },
+                forget() {
+                    if (pressed > 0 || ended === null)
+                        return;
+                    ended = null;
+                    show();
+                },
+            };
+        },
+    };
+}

package/dist/actions.d.ts

@@ -1,6 +1,7 @@
 import type { ConversationHistoryRequest } from './adapter.js';
 import { type CallResult, type HistoryAnswer, type Resolution } from './outcome.js';
 import type { Attempted } from './recovery.js';
+import type { Attempt } from './retried.js';
 import type { Runtime } from './runtime.js';
 export type HistoryQuery = {
     revision?: string;
@@ -12,9 +13,14 @@ export declare function located(runtime: Runtime, room: string, path: string, de
     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 type Invoked = {
+    readonly dispatching?: () => Promise<void>;
+    readonly attempt?: Attempt;
+};
+export declare function invokeAction(runtime: Runtime, name: string, input: unknown, { dispatching, attempt }?: Invoked): 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 called(runtime: Runtime, name: string, input: unknown, attempt?: Attempt): Promise<CallResult>;
+export declare function answeredCall(runtime: Runtime, operation: string): Promise<boolean>;
 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

@@ -1 +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"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAM/D,OAAO,EAWL,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;AAC5C,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,CA+BxB;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,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,wBAAsB,YAAY,CAChC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,EAAE,WAAW,EAAE,OAAO,EAAE,GAAE,OAAY,GACrC,OAAO,CAAC,UAAU,CAAC,CA6BrB;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,UAAU,CAAC,CAerB;AA4GD,wBAAsB,MAAM,CAC1B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,UAAU,CAAC,CAKrB;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAaxF;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAe3F;AAiBD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,QAG3C"}

package/dist/actions.js

@@ -1,16 +1,16 @@
 import { roomTarget, target } from '@agentshouse/mdmodel';
-import { resendConversations } from './conversation.js';
+import { CATCHING_UP, holdsSubmission, 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 { ABSENT_TARGET, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, handedOutcome, UNANSWERED, 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, journal } = runtime;
+    const { store, socket, presence } = runtime;
     const { session } = socket;
     if (socket.closed() || session.now().refusal !== null)
         return UNCERTAIN;
@@ -26,13 +26,7 @@ export async function readHistory(runtime, locator, path, query = {}) {
     const { closed, authorization, refusal } = session.now();
     if (closed || authorization === undefined || refusal !== null)
         return UNCERTAIN;
-    const since = store.fences.count();
-    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(' '));
+    const since = presence.losses();
     try {
         const result = await socket.history(authorization, {
             locator,
@@ -40,20 +34,18 @@ export async function readHistory(runtime, locator, path, query = {}) {
             ...(query.revision === undefined ? {} : { revision: query.revision }),
             ...(query.pageToken === undefined ? {} : { pageToken: query.pageToken }),
         });
-        journal.record(`outcome history ${result.kind}`);
-        if (store.fences.since(locator, since))
+        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, await store.open());
+                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;
     }
 }
@@ -110,62 +102,57 @@ async function calledRooms(runtime, name, input) {
     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;
+export async function invokeAction(runtime, name, input, { dispatching, attempt } = {}) {
+    const { store, socket, retries } = runtime;
     const { session } = socket;
     await socket.ready;
-    if (socket.closed() || session.now().refusal !== null)
-        return UNCERTAIN;
+    if (socket.closed() || session.now().refusal !== null) {
+        return handedOutcome(retries, attempt, UNANSWERED);
+    }
     if ((await declaredAction(runtime, name)) === undefined)
         return undeclared(name);
     try {
         await socket.authorize();
     }
     catch {
-        return UNCERTAIN;
+        return handedOutcome(retries, attempt, UNANSWERED);
     }
     const { closed, authorization, refusal } = session.now();
-    if (closed || authorization === undefined || refusal !== null)
-        return UNCERTAIN;
+    if (closed || authorization === undefined || refusal !== null) {
+        return handedOutcome(retries, attempt, UNANSWERED);
+    }
     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, await store.open());
+                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);
+        return handedOutcome(retries, attempt, result);
     }
-    catch {
-        journal.record('outcome action transport-uncertainty');
-        return UNCERTAIN;
+    catch (error) {
+        return handedOutcome(retries, attempt, { kind: 'transport-uncertainty', failure: error });
     }
 }
 export async function readConversationHistory(runtime, request) {
-    const { socket, journal } = runtime;
+    const { socket, retries } = runtime;
+    const caught = { step: 'conversations', instance: CATCHING_UP };
     await socket.ready;
     const stream = socket.conversations();
     if (socket.closed() || socket.session.now().refusal !== null || stream?.history === undefined) {
-        return UNCERTAIN;
+        return handedOutcome(retries, caught, UNANSWERED);
     }
-    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);
+        return handedOutcome(retries, caught, result);
     }
-    catch {
-        journal.record('outcome conversation history transport-uncertainty');
-        return UNCERTAIN;
+    catch (error) {
+        return handedOutcome(retries, caught, { kind: 'transport-uncertainty', failure: error });
     }
 }
 function unsettled(result) {
@@ -173,59 +160,123 @@ function unsettled(result) {
         return false;
     return result.retryable && (result.kind !== 'rejected' || result.reset === undefined);
 }
-async function recoveredAction(runtime, name, input) {
-    const { store, socket, recovery } = runtime;
+function numberedCall(runtime, name, input, operation, dispatching) {
+    return invokeAction(runtime, name, input, {
+        dispatching,
+        attempt: { step: 'sending', instance: `action ${operation}` },
+    });
+}
+function keptSender(runtime, name, input, operation, resent = false) {
+    const { store, socket } = runtime;
     const { lanes } = socket;
+    const dispatching = async () => (await store.open()).keepCall({ operation, name, input });
+    let waiting = [];
+    let last = UNCERTAIN;
+    let lost = resent;
+    const tell = (result) => {
+        last = result;
+        const told = waiting;
+        waiting = [];
+        for (const answer of told)
+            answer(result);
+    };
+    const sender = {
+        next: () => new Promise((answer) => waiting.push(answer)),
+        async send() {
+            let result;
+            try {
+                result = await numberedCall(runtime, name, input, operation, dispatching);
+            }
+            catch (error) {
+                tell(last);
+                throw error;
+            }
+            if (unsettled(result))
+                lost = true;
+            else {
+                await (await store.open()).dropCall(operation);
+                lanes.settle(operation, lost);
+            }
+            tell(result);
+            return result;
+        },
+        release() {
+            lanes.sent(operation, sender);
+            tell(last);
+        },
+    };
+    lanes.sending(operation, sender);
+    return sender;
+}
+async function recoveredAction(runtime, name, input, attempt) {
+    const { socket, recovery } = runtime;
     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);
+        return invokeAction(runtime, name, input, { attempt });
+    const held = socket.lanes.sender(operation);
+    if (held !== undefined)
+        return held.next();
+    const sender = keptSender(runtime, name, input, operation);
+    let first;
     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;
+        first = await sender.send();
+    }
+    catch (error) {
+        sender.release();
+        throw error;
     }
-    finally {
-        lanes.called(operation);
+    if (!unsettled(first)) {
+        sender.release();
+        return first;
     }
+    void recovery
+        .attempt(`action ${operation}`, async () => {
+        if (socket.closed() || socket.session.now().refusal !== null)
+            return 'done';
+        if (!socket.isOpen())
+            return 'again';
+        return unsettled(await sender.send()) ? 'again' : 'done';
+    }, { again: true })
+        .finally(() => sender.release());
+    return first;
 }
-export async function called(runtime, name, input) {
+export async function called(runtime, name, input, attempt) {
     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);
+    return room === undefined ? recoveredAction(runtime, name, input, attempt) : lockedRoom(room);
 }
-export async function resendCalls(runtime, signal) {
+export async function answeredCall(runtime, operation) {
     const { store, socket } = runtime;
     const { lanes } = socket;
+    const held = () => lanes.sender(operation) !== undefined || lanes.unclaimed(operation);
+    if (!held()) {
+        const calls = await (await store.open()).calls();
+        const kept = calls.some((one) => one.operation === operation) ||
+            (await holdsSubmission(runtime.conversations, operation));
+        if (!held() && !kept)
+            return false;
+    }
+    await lanes.settled(operation);
+    return true;
+}
+export async function resendCalls(runtime, signal) {
+    const { store, socket } = runtime;
     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))
+        if (socket.lanes.sender(held.operation) !== undefined)
             continue;
         if (socket.closed() || signal.aborted)
             return 'done';
-        lanes.call(held.operation);
+        const sender = keptSender(runtime, held.name, held.input, held.operation, true);
         try {
-            if (unsettled(await invokeAction(runtime, held.name, held.input)))
+            if (unsettled(await sender.send()))
                 return 'again';
-            await local.dropCall(held.operation);
         }
         finally {
-            lanes.called(held.operation);
+            sender.release();
         }
     }
     return 'done';