@agentshouse/mdruntime 0.1.0-cd3486bd400ed → 0.1.0-cd35ccee27a19

package/dist/react.js

@@ -1,5 +1,5 @@
-import { useCallback, useLayoutEffect, useRef, useState } from 'react';
-import { failed, runtimeError } from './failure.js';
+import { useCallback, useEffect, useId, useLayoutEffect, useRef, useState } from 'react';
+import { failed } from './failure.js';
 const LOADING = { state: 'loading' };
 export function useObserve(client, topic, ...input) {
     const key = JSON.stringify([topic, ...input]);
@@ -32,25 +32,22 @@ export function useObserve(client, topic, ...input) {
     }, [client, key]);
     return held !== null && held.client === client && held.key === key ? held.observed : LOADING;
 }
-const IDLE = { busy: false, outcome: null, failure: null };
-export async function saveRoomDrafts(client, room, roomDrafts) {
-    const kept = [];
-    for (const [path, parts] of roomDrafts) {
-        const prior = await client.roomDraft.read(room, path);
-        const write = await client.roomDraft.write(room, path, prior?.revision ?? null, parts);
-        if (write.outcome !== 'written' || write.roomDraft === null) {
-            throw runtimeError(write.outcome === 'stale' ? write.code : 'room-draft-unwritten', `the Room Draft at ${path} was not written`);
-        }
-        kept.push({ path, revision: write.roomDraft.revision });
-    }
-    return client.save(room, kept);
+export function useReading(store, asks, shown) {
+    const reader = useId();
+    useLayoutEffect(() => store.reads(reader, asks), [store, reader, asks]);
+    useLayoutEffect(() => () => store.left(reader), [store, reader]);
+    useEffect(() => {
+        if (shown !== null)
+            store.heard(reader, shown);
+    }, [store, reader, shown]);
 }
+const IDLE = { busy: false, outcome: null, failure: null };
 export function useSave(client) {
     const [state, setState] = useState(IDLE);
-    const save = useCallback(async (room, roomDrafts) => {
+    const settled = useCallback(async (saving) => {
         setState({ busy: true, outcome: null, failure: null });
         try {
-            const outcome = await saveRoomDrafts(client, room, roomDrafts);
+            const outcome = await saving();
             setState({ busy: false, outcome, failure: null });
             return outcome;
         }
@@ -59,6 +56,8 @@ export function useSave(client) {
             setState({ busy: false, outcome: null, failure });
             throw failure;
         }
-    }, [client]);
-    return { ...state, save };
+    }, []);
+    const save = useCallback((room, parts) => settled(() => client.saveParts(room, [...parts].map(([path, one]) => ({ path, parts: one })))), [client, settled]);
+    const saveWritten = useCallback((room, roomDrafts) => settled(() => client.save(room, roomDrafts)), [client, settled]);
+    return { ...state, save, saveWritten };
 }

package/dist/{chat/read.d.ts → read.d.ts}

@@ -1,4 +1,6 @@
 export type Fields = Readonly<Record<string, unknown>>;
+export declare const EXCERPT = 512;
+export declare function excerpt(said: string): string;
 export declare function record(entry: unknown): Fields;
 export declare function text(fields: Fields, name: string): string | null;
 export declare function list(fields: Fields, name: string): readonly unknown[];

package/dist/read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../src/read.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEvD,eAAO,MAAM,OAAO,MAAM,CAAC;AAE3B,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAI7C;AAED,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGhE;AAED,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,OAAO,EAAE,CAGrE"}

package/dist/{chat/read.js → read.js}

@@ -1,3 +1,7 @@
+export const EXCERPT = 512;
+export function excerpt(said) {
+    return [...said.slice(0, EXCERPT * 2)].slice(0, EXCERPT).join('');
+}
 export function record(entry) {
     return typeof entry === 'object' && entry !== null && !Array.isArray(entry)
         ? entry

package/dist/readiness.d.ts

@@ -0,0 +1,49 @@
+import type { Open } from './open.js';
+export type CodeAvailability = Open<'stored' | 'absent'>;
+export type RoomPreparation = Open<'complete' | 'acquiring' | 'preparing' | 'unadmitted'>;
+export type RoomCoverage = {
+    readonly room: string;
+    readonly state: RoomPreparation;
+};
+export type ConversationCoverage = Open<'complete' | 'acquiring' | 'undeclared'>;
+export type TargetCoverage = {
+    readonly complete: boolean;
+    readonly listed: boolean;
+    readonly rooms: readonly RoomCoverage[];
+    readonly conversations: ConversationCoverage;
+};
+export type Persistence = Open<'granted' | 'denied' | 'unavailable'>;
+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 InstallationStep = Open<'downloading' | 'writing' | 'replaying'>;
+export type InstallationAmount = {
+    readonly done: number;
+    readonly total: number;
+};
+export type Installation = {
+    readonly step: InstallationStep | null;
+    readonly bytes: InstallationAmount;
+};
+export type ReadinessStatus = Open<'preparing' | 'paused' | 'ready' | 'lost'>;
+export type Readiness = {
+    readonly status: ReadinessStatus;
+    readonly ready: boolean;
+    readonly usable: boolean;
+    readonly code: CodeAvailability;
+    readonly coverage: TargetCoverage;
+    readonly durability: Durability;
+    readonly persistence: Persistence;
+    readonly connection: ConnectionAvailability;
+    readonly house: HouseOutcome;
+    readonly space: Space | null;
+    readonly installation: Installation;
+    readonly lost: boolean;
+};
+export type ReadinessFacts = Omit<Readiness, 'status' | 'ready' | 'usable' | 'durability' | 'coverage'> & {
+    readonly coverage: Omit<TargetCoverage, 'complete'>;
+    readonly established: boolean;
+};
+export declare function readinessOf(facts: ReadinessFacts): Readiness;
+//# sourceMappingURL=readiness.d.ts.map

package/dist/readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.d.ts","sourceRoot":"","sources":["../src/readiness.ts"],"names":[],"mappings":"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"}

package/dist/readiness.js

@@ -0,0 +1,27 @@
+const COMPLETE_ROOMS = new Set(['complete', 'unadmitted']);
+export function readinessOf(facts) {
+    const { established, coverage: held, ...reported } = facts;
+    const settledConversations = held.conversations === 'complete' || held.conversations === 'undeclared';
+    const complete = held.listed &&
+        settledConversations &&
+        held.rooms.every((room) => COMPLETE_ROOMS.has(room.state));
+    const coverage = { ...held, complete };
+    const stored = facts.code === 'stored';
+    const ready = stored && complete;
+    const usable = stored && (ready || established);
+    const status = ready
+        ? 'ready'
+        : facts.space !== null
+            ? 'paused'
+            : facts.lost && !established
+                ? 'lost'
+                : 'preparing';
+    return {
+        ...reported,
+        coverage,
+        status,
+        ready,
+        usable,
+        durability: facts.persistence === 'granted' ? 'persistent' : 'best-effort',
+    };
+}

package/dist/reads.d.ts

@@ -0,0 +1,37 @@
+import { type CallResult } from './outcome.js';
+import type { Recovery } from './recovery.js';
+import type { Connection, RuntimeDatabase } from './tables.js';
+export declare const READ_TABLES: readonly string[];
+export type ReadAt = {
+    readonly name: string;
+    readonly input: string;
+    readonly build: string;
+};
+export type ObservedRead = {
+    readonly answer: unknown;
+    readonly failure: CallResult | null;
+    readonly kept: boolean;
+};
+export type ReadAnswers = {
+    watch(name: string, input: unknown, deliver: (read: ObservedRead) => void): () => void;
+    again(): void;
+    reopened(): void;
+};
+export type ReadAnswersOptions = {
+    readonly database: RuntimeDatabase;
+    readonly build: string;
+    readonly unkept: readonly string[];
+    readonly leading: readonly string[];
+    readonly recovery: Recovery;
+    call(name: string, input: unknown): Promise<CallResult>;
+    online(): boolean;
+    streaming(): boolean;
+    closed(): boolean;
+    full(): boolean;
+    filled(): void;
+};
+export declare function storedRead(connection: Connection, { name, input, build }: ReadAt): string | null;
+export declare function keptRead(connection: Connection, { name, input, build }: ReadAt, answer: string): null;
+export declare function readsOfOtherBuildsForgotten(connection: Connection, build: string): null;
+export declare function readAnswers(options: ReadAnswersOptions): ReadAnswers;
+//# sourceMappingURL=reads.d.ts.map

package/dist/reads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reads.d.ts","sourceRoot":"","sources":["../src/reads.ts"],"names":[],"mappings":"AAEA,OAAO,EAA6B,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE/D,eAAO,MAAM,WAAW,EAAE,SAAS,MAAM,EAExC,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACvF,KAAK,IAAI,IAAI,CAAC;IACd,QAAQ,IAAI,IAAI,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACxD,MAAM,IAAI,OAAO,CAAC;IAClB,SAAS,IAAI,OAAO,CAAC;IACrB,MAAM,IAAI,OAAO,CAAC;IAClB,IAAI,IAAI,OAAO,CAAC;IAChB,MAAM,IAAI,IAAI,CAAC;CAChB,CAAC;AAeF,wBAAgB,UAAU,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMhG;AAED,wBAAgB,QAAQ,CACtB,UAAU,EAAE,UAAU,EACtB,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,MAAM,EAC9B,MAAM,EAAE,MAAM,GACb,IAAI,CAMN;AAED,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAGvF;AAMD,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAoJpE"}

package/dist/reads.js

@@ -0,0 +1,174 @@
+import { refusedForSpace } from './durability.js';
+import { uncaught } from './failure.js';
+import { answeredResult, UNCERTAIN } from './outcome.js';
+export const READ_TABLES = [
+    'CREATE TABLE read_answers (name TEXT NOT NULL, input TEXT NOT NULL, build TEXT NOT NULL, answer TEXT NOT NULL, PRIMARY KEY (name, input)) WITHOUT ROWID',
+];
+export function storedRead(connection, { name, input, build }) {
+    const [held] = connection.rows('SELECT answer FROM read_answers WHERE name = ? AND input = ? AND build = ?', [name, input, build]);
+    return held === undefined ? null : String(held.answer);
+}
+export function keptRead(connection, { name, input, build }, answer) {
+    connection.run('INSERT OR REPLACE INTO read_answers (name, input, build, answer) VALUES (?, ?, ?, ?)', [name, input, build, answer]);
+    return null;
+}
+export function readsOfOtherBuildsForgotten(connection, build) {
+    connection.run('DELETE FROM read_answers WHERE build <> ?', [build]);
+    return null;
+}
+function answered(result) {
+    return result.kind === 'action' && answeredResult(result.result);
+}
+export function readAnswers(options) {
+    const { database, build, recovery } = options;
+    const unkept = new Set(options.unkept);
+    const leading = new Set(options.leading);
+    const reads = new Map();
+    function leads(read) {
+        return leading.has(read.at.name);
+    }
+    function show(read, shown) {
+        read.shown = shown;
+        for (const deliver of read.observers)
+            deliver(shown);
+    }
+    async function kept(read, answer) {
+        if (!read.shown.kept || options.full())
+            return;
+        await database.ask({ kind: 'read.keep', ...read.at, answer }).catch((error) => {
+            if (refusedForSpace(error))
+                options.filled();
+            else
+                uncaught(error);
+        });
+    }
+    async function asked(read, led) {
+        if (!options.online()) {
+            read.owed = true;
+            return;
+        }
+        const result = await options.call(read.at.name, read.asked).catch(() => UNCERTAIN);
+        if (options.closed())
+            return;
+        read.owed = !answered(result);
+        if (read.owed) {
+            show(read, { ...read.shown, failure: result });
+            return;
+        }
+        const answer = result.result;
+        const text = JSON.stringify(answer);
+        if (text === read.text && read.shown.failure === null)
+            return;
+        read.text = text;
+        await kept(read, text);
+        await led;
+        if (!options.closed())
+            show(read, { ...read.shown, answer, failure: null });
+    }
+    function lost(read) {
+        return read.owed && read.shown.failure?.kind === 'transport-uncertainty' && options.streaming();
+    }
+    function retrying(read) {
+        return `${read.key} again`;
+    }
+    function askedLater(read) {
+        void recovery.attempt(retrying(read), async () => {
+            if (options.closed() || read.observers.size === 0 || !lost(read))
+                return 'done';
+            await attempted(read);
+            return lost(read) ? 'again' : 'done';
+        }, { again: true });
+    }
+    function forgotten(read) {
+        read.text = null;
+        read.shown = { ...read.shown, answer: null, failure: null };
+    }
+    function attempted(read, led) {
+        read.asking = true;
+        return recovery
+            .attempt(read.key, async () => {
+            await asked(read, led);
+            return 'done';
+        })
+            .finally(() => {
+            const unanswered = read.joined && read.owed;
+            read.asking = false;
+            read.joined = false;
+            if (unanswered)
+                void ask(read);
+        });
+    }
+    function ask(read, led) {
+        return attempted(read, led).finally(() => {
+            if (lost(read))
+                askedLater(read);
+        });
+    }
+    function opened(name, input, key) {
+        const held = !unkept.has(name);
+        const read = {
+            key,
+            at: { name, input: JSON.stringify(input ?? null), build },
+            asked: input,
+            observers: new Set(),
+            stored: Promise.resolve(),
+            text: null,
+            shown: { answer: null, failure: null, kept: held },
+            owed: false,
+            asking: false,
+            joined: false,
+        };
+        if (held) {
+            read.stored = database.ask({ kind: 'read.stored', ...read.at }).then((text) => {
+                if (text === null || read.text !== null)
+                    return;
+                read.text = text;
+                read.shown = { ...read.shown, answer: JSON.parse(text) };
+            }, uncaught);
+        }
+        reads.set(key, read);
+        return read;
+    }
+    return {
+        watch(name, input, deliver) {
+            const key = JSON.stringify([name, input ?? null]);
+            const read = reads.get(key) ?? opened(name, input, key);
+            read.observers.add(deliver);
+            void read.stored.then(() => {
+                if (!read.observers.has(deliver))
+                    return;
+                if (!read.shown.kept)
+                    forgotten(read);
+                deliver(read.shown);
+                if (read.asking)
+                    read.joined = true;
+                else
+                    void ask(read);
+            });
+            return () => {
+                read.observers.delete(deliver);
+                if (read.observers.size === 0 && reads.get(key) === read)
+                    reads.delete(key);
+            };
+        },
+        again() {
+            const all = [...reads.values()];
+            const led = Promise.all(all.filter(leads).map((read) => ask(read)));
+            for (const read of all)
+                if (!leads(read))
+                    void ask(read, led);
+        },
+        reopened() {
+            for (const read of reads.values()) {
+                recovery.cancel(retrying(read));
+                if (read.text === null) {
+                    if (read.owed)
+                        void ask(read);
+                }
+                else if (read.shown.failure?.kind === 'transport-uncertainty') {
+                    show(read, { ...read.shown, failure: null });
+                }
+            }
+        },
+    };
+}

package/dist/recovery.d.ts

@@ -0,0 +1,26 @@
+export type Attempted = 'done' | 'again' | {
+    readonly at: number;
+};
+export type Attempt = (signal: AbortSignal) => Promise<Attempted>;
+export type AttemptOptions = {
+    readonly at?: number;
+    readonly again?: boolean;
+};
+export type RecoveryOptions = {
+    readonly firstMs?: number;
+    readonly maxMs?: number;
+    readonly attempts?: number;
+    readonly inFlight?: number;
+};
+export type Recovery = {
+    attempt(intent: string, run: Attempt, options?: AttemptOptions): Promise<boolean>;
+    pending(intent: string): boolean;
+    resume(): void;
+    cancel(intent: string): void;
+    scope(inFlight?: number): 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;
+//# sourceMappingURL=recovery.d.ts.map

package/dist/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;AAElE,MAAM,MAAM,cAAc,GAAG;IAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEhF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAClF,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IACjC,MAAM,IAAI,IAAI,CAAC;IACf,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IACnC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB,CAAC;AAsBF,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAW,EAAE,KAAK,SAAS,GAAG,MAAM,CAGpF;AAED,wBAAsB,aAAa,CAAC,CAAC,EACnC,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACrB,MAAM,EAAE,WAAW,EACnB,QAAQ,GAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAoB,GAC5C,OAAO,CAAC,CAAC,CAAC,CAsBZ;AA8KD,wBAAgB,cAAc,CAAC,OAAO,GAAE,eAAoB,GAAG,QAAQ,CAStE"}

package/dist/recovery.js

@@ -0,0 +1,232 @@
+// A first retry waits about a second, so a passing failure clears before the next attempt.
+const FIRST_MS = 1_000;
+// Waits stop doubling at half a minute, so work resumes soon after a long failure ends.
+const MAX_MS = 30_000;
+const ATTEMPTS = 8;
+export function retryDelay(tries, firstMs = FIRST_MS, maxMs = MAX_MS) {
+    const longest = Math.min(maxMs, firstMs * 2 ** tries);
+    return longest / 2 + (Math.random() * longest) / 2;
+}
+export async function untilAnswered(ask, signal, answered = () => true) {
+    for (let tries = 0;; tries += 1) {
+        try {
+            const answer = await ask();
+            if (answered(answer) || signal.aborted)
+                return answer;
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+        }
+        await new Promise((resume) => {
+            const stop = () => {
+                clearTimeout(again);
+                resume();
+            };
+            // A read that failed is asked again on the doubling backoff, so its asker is answered once the failure clears.
+            const again = setTimeout(() => {
+                signal.removeEventListener('abort', stop);
+                resume();
+            }, retryDelay(tries));
+            signal.addEventListener('abort', stop, { once: true });
+        });
+        signal.throwIfAborted();
+    }
+}
+function owner(backoff, inFlight, release = () => { }) {
+    const intents = new Map();
+    const children = new Set();
+    const running = new Set();
+    const queued = [];
+    let free = inFlight;
+    let retired = false;
+    function finish(key, intent, done) {
+        if (intents.get(key) === intent)
+            intents.delete(key);
+        if (intent.timer !== null)
+            clearTimeout(intent.timer);
+        intent.timer = null;
+        intent.end(done);
+    }
+    function wait(key, intent, at, guided) {
+        if (intent.timer !== null)
+            clearTimeout(intent.timer);
+        intent.due = at;
+        intent.guided = guided;
+        intent.timer = setTimeout(() => {
+            intent.timer = null;
+            launch(key, intent);
+        }, Math.max(0, at - Date.now()));
+    }
+    function launch(key, intent) {
+        intent.due = null;
+        intent.guided = false;
+        const controller = new AbortController();
+        intent.controller = controller;
+        const run = start(key, intent, controller);
+        running.add(run);
+        void run.finally(() => running.delete(run));
+    }
+    async function start(key, intent, controller) {
+        while (free === 0)
+            await new Promise((admit) => queued.push(admit));
+        if (controller.signal.aborted) {
+            queued.shift()?.();
+            return;
+        }
+        free -= 1;
+        const abandoned = new Promise((resolve) => {
+            controller.signal.addEventListener('abort', () => resolve(null), { once: true });
+        });
+        let result;
+        try {
+            result = await Promise.race([intent.run(controller.signal), abandoned]);
+        }
+        catch {
+            result = 'again';
+        }
+        finally {
+            free += 1;
+            queued.shift()?.();
+        }
+        if (result === null || controller.signal.aborted || intents.get(key) !== intent)
+            return;
+        intent.controller = null;
+        const again = intent.again;
+        intent.again = null;
+        if (result === 'done') {
+            intent.tries = 0;
+            if (again === null)
+                finish(key, intent, true);
+            else if (again === 'now')
+                launch(key, intent);
+            else
+                wait(key, intent, again, true);
+            return;
+        }
+        intent.tries += 1;
+        if (intent.tries >= backoff.attempts) {
+            if (again === null) {
+                finish(key, intent, false);
+                return;
+            }
+            intent.tries = 0;
+            if (again === 'now')
+                launch(key, intent);
+            else
+                wait(key, intent, again, true);
+            return;
+        }
+        if (result === 'again') {
+            // The next attempt waits the doubling backoff, up to its maximum.
+            const delay = retryDelay(intent.tries - 1, backoff.firstMs, backoff.maxMs);
+            wait(key, intent, Date.now() + delay, false);
+        }
+        else
+            wait(key, intent, result.at, true);
+    }
+    const recovery = {
+        attempt(key, run, options = {}) {
+            if (retired)
+                return Promise.resolve(false);
+            const held = intents.get(key);
+            if (held !== undefined) {
+                held.run = run;
+                if (held.controller !== null) {
+                    const at = options.at;
+                    held.again =
+                        at === undefined || held.again === 'now'
+                            ? 'now'
+                            : Math.min(at, held.again ?? Number.POSITIVE_INFINITY);
+                }
+                else if (held.due !== null && held.due <= Date.now()) {
+                    if (held.timer !== null)
+                        clearTimeout(held.timer);
+                    held.timer = null;
+                    launch(key, held);
+                }
+                else if (options.at !== undefined && (held.due === null || options.at < held.due)) {
+                    wait(key, held, options.at, true);
+                }
+                return held.ended;
+            }
+            let end = () => { };
+            const ended = new Promise((resolve) => {
+                end = resolve;
+            });
+            const intent = {
+                run,
+                tries: 0,
+                timer: null,
+                due: null,
+                guided: false,
+                controller: null,
+                again: null,
+                ended,
+                end,
+            };
+            intents.set(key, intent);
+            if (options.at !== undefined)
+                wait(key, intent, options.at, true);
+            else if (options.again === true) {
+                intent.tries = 1;
+                wait(key, intent, Date.now() + retryDelay(0, backoff.firstMs, backoff.maxMs), false);
+            }
+            else
+                launch(key, intent);
+            return ended;
+        },
+        pending(key) {
+            const intent = intents.get(key);
+            return intent !== undefined && intent.controller === null;
+        },
+        resume() {
+            if (retired)
+                return;
+            for (const [key, intent] of [...intents]) {
+                if (intent.guided && intent.due !== null && intent.due > Date.now())
+                    continue;
+                if (intent.timer !== null)
+                    clearTimeout(intent.timer);
+                intent.timer = null;
+                intent.controller?.abort();
+                intent.again = null;
+                intent.tries = 0;
+                launch(key, intent);
+            }
+        },
+        cancel(key) {
+            const intent = intents.get(key);
+            if (intent === undefined)
+                return;
+            intent.controller?.abort();
+            finish(key, intent, false);
+        },
+        scope(bound = Infinity) {
+            const child = owner(backoff, bound, () => children.delete(child));
+            if (retired)
+                void child.retire();
+            else
+                children.add(child);
+            return child;
+        },
+        async retire() {
+            retired = true;
+            release();
+            for (const [key, intent] of [...intents]) {
+                intent.controller?.abort();
+                finish(key, intent, false);
+            }
+            await Promise.all([...children].map((child) => child.retire()));
+            await Promise.all(running);
+        },
+    };
+    return recovery;
+}
+export function createRecovery(options = {}) {
+    return owner({
+        firstMs: options.firstMs ?? FIRST_MS,
+        maxMs: options.maxMs ?? MAX_MS,
+        attempts: options.attempts ?? ATTEMPTS,
+    }, options.inFlight ?? Infinity);
+}