@bananapus/nana-sdk-core 6.2.0 → 6.3.1

package/dist/esm/review/react/useReviewedRun.js

@@ -1,8 +1,10 @@
 import { ReviewLineError } from "../lineError.js";
+import { ConfirmationQueuedError, LockLostError, lockWorkRunning, } from "../locks.js";
 import { tell } from "../receipt.js";
-import { createHeldWriteView, discardReviewedSequence, errorLine, findReviewedSequence, followHeldWrite, isDefiniteWalletRejection, listReviewedWrites, openStepHold, RECEIPT_RETRY_MS, REVIEWED_ACCOUNT_CHANGED_LINE, REVIEWED_ENGINE_LOAD_LINE, ReviewedReceiptUnverifiedError, reviewedRunStatus, safeBatchCall, settledLine, TransactionReviewCancelledError, walletReady, } from "../index.js";
+import { createHeldWriteView, discardReviewedSequence, errorLine, findReviewedSequence, followHeldWrite, HELD_AWAY_SUCCESS_LINE, HELD_SEND_AGAIN_LABEL, isDefiniteWalletRejection, listReviewedWrites, openStepHold, RECEIPT_RETRY_MS, REVIEWED_ACCOUNT_CHANGED_LINE, REVIEWED_ENGINE_LOAD_LINE, ReviewedReceiptUnverifiedError, reviewedRunStatus, safeBatchCall, settledLine, TransactionReviewCancelledError, walletReady, WriteHeldError, WriteHoldUnacknowledgedSuccessError, } from "../index.js";
 import { useEffect, useMemo, useRef, useState, useSyncExternalStore, } from "react";
 import { actionsOf, idle, keyOf, none, } from "./heldView.js";
+import { mergeOwn } from "./ownership.js";
 const IDLE = {
     cancelled: false,
     stopped: false,
@@ -18,6 +20,7 @@ const IDLE = {
     receipt: null,
     settled: null,
     acknowledge: null,
+    away: null,
 };
 /** The bytes a call sends, for comparing two actions. */
 const sent = ({ chainId, to, data, value, gas }) => [
@@ -27,6 +30,28 @@ const sent = ({ chainId, to, data, value, gas }) => [
     value ?? 0n,
     gas ?? null,
 ];
+/** This form's earlier write of the same calls succeeded: the run closes on it, sending nothing. */
+/**
+ * The holds `action`'s steps are held in, each with its step: a resumed
+ * sequence's sending step; a Safe app's batch as its one MultiSend
+ * proposal, its last step; or each call. The one home for that mapping.
+ */
+function heldSteps(account, safe, action, saved) {
+    if (saved?.sending)
+        return [
+            { call: saved.calls[saved.sending.step], step: saved.sending.step },
+        ];
+    const total = saved?.calls.length ?? action.calls.length;
+    return !saved && action.batch && safe && action.calls.length > 1
+        ? [{ call: safeBatchCall(account, action.calls), step: total - 1 }]
+        : action.calls.map((call, step) => ({ call, step }));
+}
+class OwnSucceeded extends Error {
+    constructor(found) {
+        super("succeeded");
+        this.found = found;
+    }
+}
 export const REVIEWED_RUN_SCOPE_LINE = "This action has more than one step and no scope to resume it by. Nothing was sent.";
 export const REVIEWED_RUN_BUSY_LINE = "This action is still running. Wait for it to finish, then try again.";
 /**
@@ -42,16 +67,29 @@ export function useReviewedRun(deps) {
         if (cancelling)
             void tell(cancelling.told);
     }, [cancelling]);
-    /** The last shown success's acknowledgement: the next run waits for it. */
+    /** Every shown success's acknowledgement: the next run waits for all. */
     const acknowledged = useRef(Promise.resolve());
     // A success is acknowledged only once its done rendered: a reset after
-    // that hides nothing, and one before it leaves the success warning.
+    // that hides nothing, and one before it leaves the success warning. A
+    // later one never drops an earlier one still running from the wait.
     useEffect(() => {
         if (state.acknowledge)
-            acknowledged.current = state.acknowledge();
+            acknowledged.current = Promise.all([
+                acknowledged.current,
+                state.acknowledge(),
+            ]).then(() => undefined);
     }, [state.acknowledge]);
     /** The hold followed after a run, and its chain's client: its view is `held`. */
-    const [watched, setWatched] = useState(null);
+    const [watched, setWatchedState] = useState(null);
+    /**
+     * `watched` as last set, for a handler that resets and runs from one
+     * render's handle (a "Try again"): never that render's stale copy.
+     */
+    const watchedNow = useRef(null);
+    const setWatched = (next) => {
+        watchedNow.current = next;
+        setWatchedState(next);
+    };
     /** The latest run: an earlier one's late answers change nothing. */
     const latest = useRef(0);
     /** The sent step whose hold the latest run's `ended()` awaits. */
@@ -72,6 +110,101 @@ export function useReviewedRun(deps) {
      * hold keeps the sent step.
      */
     const leave = useRef(() => { });
+    /** Every reservation this runner's runs followed: its own, whatever its calls now. */
+    const mine = useRef(new Set());
+    /**
+     * The reservations `calls`' holds hold now (a held write, or a success
+     * nothing showed), each with its hold.
+     */
+    const holdsOf = (account, calls) => calls.flatMap((call) => {
+        if (!deps || !account)
+            return [];
+        try {
+            // A hold's key is its call's, whatever the Safe mode.
+            const handle = openStepHold(deps.hold, account, false, call);
+            const held = handle.peek();
+            const reservation = held.status !== "clear"
+                ? held.reservation
+                : handle.unacknowledgedSuccess()?.reservation;
+            return reservation ? [{ handle, reservation }] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+    /**
+     * The reservations this form's last run left unshown, or the last step
+     * `dismiss` closed while it was followed (`run`, whose later showing the
+     * user closed, never counts as seen), and the account that sent them.
+     * Their success, whoever acknowledged it, closes a later run under the
+     * same hold (its intent's, though the calls were refreshed) from the same
+     * account. Still pending, the hold refuses that run, which follows it again.
+     * One entry per account and reservation: keeping or showing one never
+     * touches another's.
+     */
+    const own = useRef(new Map());
+    /**
+     * Every change to a form's write, under the account that sent it, goes
+     * through {@link mergeOwn}: forward only. A showing (`shown`) changes
+     * the reservation's entry whichever account it is under.
+     */
+    const changeOwn = (account, reservations, change) => {
+        for (const reservation of reservations) {
+            if (!reservation)
+                continue;
+            const keys = [...own.current]
+                .filter(([, entry]) => change.kind === "shown" && entry.reservation === reservation)
+                .map(([key]) => key);
+            const mine = `${account.toLowerCase()}:${reservation}`;
+            for (const key of keys.length ? keys : [mine]) {
+                const entry = own.current.get(key);
+                own.current.set(key, mergeOwn(entry, entry?.account ?? account, reservation, change));
+            }
+        }
+    };
+    const ownSuccess = (action) => {
+        if (!deps?.account ||
+            (action.account &&
+                action.account.toLowerCase() !== deps.account.toLowerCase()))
+            return undefined;
+        const kept = [...own.current.values()]
+            .filter((entry) => entry.state === "owned" &&
+            entry.account.toLowerCase() === deps.account.toLowerCase())
+            .map((entry) => entry.reservation);
+        if (!kept.length)
+            return undefined;
+        // Only the action's last step's hold, as `follow` maps it: a success
+        // of an earlier step never completes the action. Its Safe mode may not
+        // be known yet; a reservation is only ever in its own mode's hold.
+        const account = deps.account;
+        const lasts = [false, true].map((safe) => {
+            const steps = heldSteps(account, safe, action);
+            return steps[steps.length - 1];
+        });
+        for (const { call, step } of lasts) {
+            try {
+                // A reservation is read only through its own hold: another hold
+                // (another intent, or another exact call) never answers for it.
+                const handle = openStepHold(deps.hold, deps.account, false, call);
+                for (const reservation of kept) {
+                    const settled = handle.settlementOf(reservation);
+                    if (settled?.result === "success")
+                        return {
+                            settled: settled,
+                            handle,
+                            account,
+                            call: call,
+                            step,
+                            reservation,
+                        };
+                }
+            }
+            catch {
+                /* A call the hold can't open holds nothing of this form's. */
+            }
+        }
+        return undefined;
+    };
     const replaced = () => {
         latest.current += 1;
         life.current.abort();
@@ -90,9 +223,12 @@ export function useReviewedRun(deps) {
         };
     }, []);
     /** How a followed step ended, as the run that followed it shows it. */
-    const showSettled = (run, step, total, settled, receipt, acknowledge) => {
+    const showSettled = (run, step, total, settled, receipt, acknowledge, account, reservation) => {
         if (latest.current !== run)
             return;
+        // Shown: its own entry is released, unless `dismiss` closed it while
+        // this run followed it (its showing the user closed never counts).
+        changeOwn(account, [reservation], { kind: "shown", run });
         const finished = step === total - 1;
         setState((now) => settled.result !== "success"
             ? {
@@ -170,8 +306,18 @@ export function useReviewedRun(deps) {
         shown.phase === "settled"
         ? null
         : shown;
-    const { cancelled: _cancelled, stopped: _stopped, acknowledge: _acknowledge, ...shownState } = state;
-    const status = reviewedRunStatus({ ...state, held });
+    const { cancelled: _cancelled, stopped: _stopped, acknowledge: _acknowledge, away, ...shownState } = state;
+    const awayShown = away && !held
+        ? {
+            phase: "succeeded",
+            state: null,
+            line: HELD_AWAY_SUCCESS_LINE,
+            exit: false,
+            settled: { result: "success", hash: away.hash },
+            adopting: false,
+        }
+        : null;
+    const status = reviewedRunStatus({ ...state, held: held ?? awayShown });
     const reset = () => {
         replaced();
         setState(IDLE);
@@ -191,16 +337,43 @@ export function useReviewedRun(deps) {
         ...shownState,
         ...status,
         busy: status.busy && !state.following,
-        held,
+        held: held ?? awayShown,
         ...actionsOf(shown, held ? view : undefined),
+        ...(awayShown && {
+            sendAgainAction: {
+                label: HELD_SEND_AGAIN_LABEL,
+                run: async () => {
+                    await away.handle.acknowledge({
+                        result: "success",
+                        hash: away.hash,
+                    });
+                    setState((now) => (now.away === away ? { ...now, away: null } : now));
+                },
+            },
+        }),
         reset,
         dismiss: () => {
             const waiting = awaiting.current;
             if (open.current && !waiting)
                 return false;
+            /**
+             * The followed last step this closes, under the account that sent it,
+             * and the run that followed it: a retry of it never sends it again.
+             */
+            const last = waiting
+                ? waiting.last && { ...waiting.owner, run: waiting.run }
+                : watched?.step === watched?.total - 1 && watched;
+            const closing = () => {
+                if (last)
+                    changeOwn(last.account, [last.reservation], {
+                        kind: "dismiss",
+                        run: last.run,
+                    });
+            };
             if (waiting?.last) {
                 awaiting.current = null;
                 waiting.end();
+                closing();
                 return true;
             }
             detach(waiting
@@ -209,9 +382,13 @@ export function useReviewedRun(deps) {
                     handle: watched.handle,
                     client: watched.client,
                     call: watched.call,
+                    account: watched.account,
                     reservation: watched.reservation,
                 });
+            // Closing the view keeps what this form sent: a reset forgets no
+            // entry, so a later dismiss of the idle view never forgets one.
             reset();
+            closing();
             return true;
         },
         preload,
@@ -231,6 +408,102 @@ export function useReviewedRun(deps) {
             setWatched(null);
         },
         run: async ({ onCancelled, onStopped, ...action }) => {
+            /**
+             * The account this run sends from, read once: every continuation of
+             * it uses this one, whatever account the app's deps hold by then.
+             */
+            const runAccount = deps?.account;
+            /**
+             * The wallet's Safe mode, only while it still speaks for the run's
+             * account: another account's mode never names this run's holds.
+             */
+            const runSafe = () => deps && deps.account?.toLowerCase() === runAccount?.toLowerCase()
+                ? deps.adapter.isSafe()
+                : undefined;
+            /** This form's unshown write of these calls succeeded: the form closes on it. */
+            const close = async (found) => {
+                const { settled, handle } = found;
+                // Every exit holds the run open, and this form's ownership stays
+                // until its success is shown and acknowledged: until then a dismiss
+                // is refused and a later run closes on the same success again.
+                open.current += 1;
+                try {
+                    // Completed as its run would have, under this run's locks: told to
+                    // onConfirmed once (unless another completion did), and done only
+                    // once delivered.
+                    let failure;
+                    const told = await load(deps.engine)
+                        .then((engine) => engine.completeReviewedStep({
+                        step: found.step,
+                        held: { call: found.call, reservation: found.reservation },
+                    }, {
+                        account: found.account,
+                        scope: action.scope,
+                        onConfirmed: action.onConfirmed,
+                        locks: action.locks,
+                        attemptScoped: action.attemptScoped,
+                    }, deps, null, alive, false))
+                        .catch((error) => {
+                        failure = error;
+                        return null;
+                    });
+                    if (!told || told.undelivered) {
+                        failure ??= new LockLostError(action.locks?.[0]?.name ?? "site");
+                        const error = errorLine(failure);
+                        update({ ...IDLE, error, failure });
+                        return { status: "failed", error, failure };
+                    }
+                    const step = action.calls.length - 1;
+                    update({
+                        ...IDLE,
+                        // Shown now: acknowledged once rendered, so it blocks no new send.
+                        // Rendered: the form's own is released, and a later run waits
+                        // for this acknowledgement before it sends.
+                        acknowledge: async () => {
+                            if (alive.aborted)
+                                return;
+                            changeOwn(found.account, [found.reservation], {
+                                kind: "shown",
+                            });
+                            await handle.acknowledge(settled).catch(() => undefined);
+                        },
+                        phase: "done",
+                        step,
+                        total: action.calls.length,
+                        hash: settled.hash,
+                        settled: { step, finished: true },
+                    });
+                    return {
+                        status: "done",
+                        hashes: told.hashes,
+                        receipts: [],
+                        ...(told.signatures ? { signatures: told.signatures } : {}),
+                    };
+                }
+                finally {
+                    open.current -= 1;
+                }
+            };
+            // This form's own write is still followed: a retry of it is refused
+            // with the hold's line, and the run following it goes on.
+            const now = watchedNow.current;
+            // Identity, never bytes: the followed reservation is one of these
+            // calls' holds'. A scoped sequence's journal answers for its own.
+            const followed = now?.reservation &&
+                runAccount &&
+                (action.scope === undefined || action.calls.length === 1)
+                ? now
+                : null;
+            const ownState = followed?.handle.peek();
+            if (followed &&
+                ownState?.status !== "clear" &&
+                ownState?.reservation === followed.reservation &&
+                holdsOf(runAccount, action.calls).some(({ reservation }) => reservation === followed.reservation)) {
+                const failure = new WriteHeldError(ownState);
+                const error = errorLine(failure);
+                setState((now) => ({ ...now, error, failure }));
+                return { status: "failed", error, failure };
+            }
             replaced();
             const id = latest.current;
             const { signal: alive } = life.current;
@@ -244,6 +517,21 @@ export function useReviewedRun(deps) {
                     setState((now) => ({ ...now, ...next }));
             };
             setState({ ...IDLE, phase: "review", total: action.calls.length });
+            const succeeded = ownSuccess(action);
+            if (succeeded) {
+                setWatched(null);
+                // close holds the run open itself, from here until it ends.
+                open.current -= 1;
+                return close(succeeded);
+            }
+            /**
+             * Reservations the action's holds had before this run: another run's
+             * (another form's, sharing a hold). This run never follows one.
+             */
+            const holds = () => holdsOf(runAccount, runAccount && action.batch && action.calls.length > 1
+                ? [...action.calls, safeBatchCall(runAccount, action.calls)]
+                : action.calls);
+            const before = new Set(holds().map(({ reservation }) => reservation));
             let loaded;
             /** A step of the action was sent before this run, or by it: never a cancel. */
             let sentAny = false;
@@ -272,9 +560,11 @@ export function useReviewedRun(deps) {
                 let completed = Promise.resolve(null);
                 let shown = false;
                 const action$ = {
-                    account: deps.account,
+                    account: runAccount,
                     scope: action.scope,
                     onConfirmed: action.onConfirmed,
+                    locks: action.locks,
+                    attemptScoped: action.attemptScoped,
                 };
                 const finish = (seen, receipt = null) => {
                     if (shown || alive.aborted)
@@ -288,11 +578,30 @@ export function useReviewedRun(deps) {
                             return null;
                         }));
                     void completed.then((ended) => {
+                        // Its notice undelivered: the form's own, whichever run shows
+                        // now (a retry that replaced this one included), so a later
+                        // run closes on it, telling it then.
+                        if (ended?.undelivered && target.step === total - 1)
+                            changeOwn(action$.account, [target.held?.reservation], {
+                                kind: "keep",
+                            });
                         if (shown || alive.aborted)
                             return;
-                        // Nothing advanced (its receipt unread, or its hold not settled
-                        // for this send yet): it is tried again.
-                        if (unread || (!ended && seen)) {
+                        // Nothing advanced (its receipt unread, its hold not settled
+                        // for this send yet, or its onConfirmed not delivered): it is
+                        // tried again, still followed and acknowledged by nothing.
+                        // ponytail: retried at the receipt's pace while mounted.
+                        if (unread || (!ended && seen) || ended?.undelivered) {
+                            if (ended?.undelivered) {
+                                completed = Promise.resolve(null);
+                                // While the site's work under its locks runs, its notice may
+                                // wait for it (kept for a lock this run lost, or another
+                                // completion's claim queued behind one it holds): the wait
+                                // ends now, retryable, and is never what holds that work up.
+                                // Once that work ended, nothing of the caller's is in its way.
+                                if (action.locks?.some(lockWorkRunning))
+                                    end?.("queued");
+                            }
                             if (mounted.current)
                                 setTimeout(() => finish(seen, receipt), RECEIPT_RETRY_MS);
                             return;
@@ -302,8 +611,8 @@ export function useReviewedRun(deps) {
                         shown = true;
                         // Shown with the receipt completion checked, a failure's too.
                         showSettled(id, target.step, total, ended.settled, ended.receipt, ended.settled.result === "success" && target.step === total - 1
-                            ? acknowledging(openStepHold(deps.hold, deps.account, false, target.held.call), ended.settled)
-                            : null);
+                            ? acknowledging(openStepHold(deps.hold, action$.account, false, target.held.call), ended.settled)
+                            : null, action$.account, target.held?.reservation);
                         setWatched(null);
                         end?.(ended);
                     });
@@ -315,9 +624,10 @@ export function useReviewedRun(deps) {
              * found one, or null when the wallet could not say (its Safe mode unknown).
              */
             const follow = async (finish, released) => {
-                if (latest.current !== id || !deps?.account)
+                if (latest.current !== id || !deps || !runAccount)
                     return false;
-                const { account, adapter, hold, storage } = deps;
+                const { adapter, hold, storage } = deps;
+                const account = runAccount;
                 // Its Safe mode is read only once the wallet says it is known.
                 try {
                     await walletReady(adapter);
@@ -328,36 +638,55 @@ export function useReviewedRun(deps) {
                 try {
                     if (latest.current !== id)
                         return false;
-                    const safe = adapter.isSafe();
+                    const safe = runSafe();
+                    if (safe === undefined)
+                        return null;
                     const saved = !action.scope
                         ? null
                         : findReviewedSequence(action.scope, account, { storage });
                     const total = saved?.calls.length ?? action.calls.length;
-                    // A Safe app's batch is held as its one MultiSend proposal, its last step.
-                    const steps = saved?.sending
-                        ? [
-                            {
-                                call: saved.calls[saved.sending.step],
-                                step: saved.sending.step,
-                            },
-                        ]
-                        : !saved && action.batch && safe && action.calls.length > 1
-                            ? [
-                                {
-                                    call: safeBatchCall(account, action.calls),
-                                    step: total - 1,
-                                },
-                            ]
-                            : action.calls.map((call, step) => ({ call, step }));
-                    // A held step, or the last step's success nothing showed.
+                    const steps = heldSteps(account, safe, action, saved);
+                    // A held step, or the last step's success nothing showed, of this
+                    // run (or of the saved sequence it resumes), never another run's.
+                    let away = null;
                     const found = steps
                         .map(({ call, step }) => ({
                         call,
                         step,
                         handle: openStepHold(hold, account, safe, call),
                     }))
-                        .find(({ handle, step }) => handle.peek().status !== "clear" ||
-                        (step === total - 1 && handle.unacknowledgedSuccess()));
+                        .find(({ handle, step, call }) => {
+                        const held = handle.peek();
+                        const success = step === total - 1 ? handle.unacknowledgedSuccess() : undefined;
+                        if (held.status === "clear" && !success)
+                            return false;
+                        const reservation = held.status !== "clear"
+                            ? held.reservation
+                            : success?.reservation;
+                        // A write held before this run, under an intent other forms
+                        // share, is followed only when this runner followed it before,
+                        // or it is this exact call (or this saved sequence's): another
+                        // form's write is never adopted.
+                        if (!reservation ||
+                            !before.has(reservation) ||
+                            mine.current.has(reservation) ||
+                            reservation === saved?.sending?.reservation ||
+                            !call.intent)
+                            return true;
+                        // A success another runner left settled while away, of this
+                        // call or another form's: only shown, with "Send it again", so
+                        // the refused form is never stuck. Never followed, so no
+                        // dismissal makes it this form's to close a changed call on.
+                        if (held.status === "clear") {
+                            away = { handle, hash: success.hash };
+                            return false;
+                        }
+                        const record = listReviewedWrites({ chainId: call.chainId, account }, { storage }).find(({ record }) => record.id === reservation)?.record;
+                        return (!!record &&
+                            record.call.to.toLowerCase() === call.to.toLowerCase() &&
+                            record.call.data.toLowerCase() === call.data.toLowerCase() &&
+                            record.call.value === String(call.value ?? 0n));
+                    });
                     // Its settlement completes it as a send's would: a proposal too.
                     const reservation = found?.handle.peek().reservation ??
                         found?.handle.unacknowledgedSuccess()?.reservation;
@@ -366,6 +695,7 @@ export function useReviewedRun(deps) {
                             handle: found.handle,
                             client: deps.clientFor(found.call.chainId),
                             run: id,
+                            account,
                             call: found.call,
                             reservation,
                             step: found.step,
@@ -379,8 +709,9 @@ export function useReviewedRun(deps) {
                         }
                         : null);
                     // Only its hold is followed now: the confirm can close.
-                    if (found)
-                        update({ following: true });
+                    if (reservation)
+                        mine.current.add(reservation);
+                    update(found ? { following: true, away: null } : { away });
                     return !!found;
                 }
                 catch {
@@ -390,13 +721,17 @@ export function useReviewedRun(deps) {
             };
             const heldStep = (target) => {
                 const call = target.held?.call ?? action.calls[target.step];
-                if (!deps?.account || !call)
+                if (!deps || !runAccount || !call)
                     return null;
                 try {
+                    const safe = runSafe();
+                    if (safe === undefined)
+                        return null;
                     return {
-                        handle: openStepHold(deps.hold, deps.account, deps.adapter.isSafe(), call),
+                        handle: openStepHold(deps.hold, runAccount, safe, call),
                         client: deps.clientFor(call.chainId),
                         call,
+                        account: runAccount,
                         reservation: target.held?.reservation,
                     };
                 }
@@ -405,10 +740,10 @@ export function useReviewedRun(deps) {
                 }
             };
             try {
-                if (!deps?.account)
+                if (!deps || !runAccount)
                     throw new ReviewLineError("Connect a wallet first.");
                 if (action.account &&
-                    action.account.toLowerCase() !== deps.account.toLowerCase())
+                    action.account.toLowerCase() !== runAccount.toLowerCase())
                     throw new ReviewLineError(REVIEWED_ACCOUNT_CHANGED_LINE);
                 if (action.calls.length > 1 && action.scope === undefined)
                     throw new ReviewLineError(REVIEWED_RUN_SCOPE_LINE);
@@ -429,7 +764,14 @@ export function useReviewedRun(deps) {
                 const { resumeReviewed, sendReviewed } = loaded;
                 // A success already shown is acknowledged before this run checks it.
                 await acknowledged.current;
-                const { account, guard } = deps;
+                const settledOwn = () => {
+                    const settled = ownSuccess(action);
+                    if (settled)
+                        throw new OwnSucceeded(settled);
+                };
+                settledOwn();
+                const { guard } = deps;
+                const account = runAccount;
                 const tracked = {
                     ...deps,
                     onProgress: (progress) => {
@@ -486,9 +828,20 @@ export function useReviewedRun(deps) {
                         tell(action.follow?.onConfirming, step);
                     },
                 };
+                const assertWriteState = () => {
+                    settledOwn();
+                    action.assertWriteState?.();
+                };
+                const gated = {
+                    ...action,
+                    guard,
+                    follow: inPlace,
+                    onSubmitted,
+                    assertWriteState,
+                };
                 const result = saved
-                    ? await resumeReviewed(saved, { ...action, guard, follow: inPlace, onSubmitted }, tracked)
-                    : await sendReviewed({ ...action, account, guard, follow: inPlace, onSubmitted }, tracked);
+                    ? await resumeReviewed(saved, gated, tracked)
+                    : await sendReviewed({ ...gated, account }, tracked);
                 // A wallet that reviews on its own page reports no progress: the
                 // result is the run's last word.
                 const calls = saved?.calls ?? action.calls;
@@ -513,6 +866,8 @@ export function useReviewedRun(deps) {
                 return result;
             }
             catch (error) {
+                if (error instanceof OwnSucceeded)
+                    return close(error.found);
                 if (error instanceof ReviewedReceiptUnverifiedError) {
                     // Still confirming: followed until its hold settles it.
                     update({
@@ -541,7 +896,12 @@ export function useReviewedRun(deps) {
                         leave.current = abandon;
                         cancelled?.addEventListener("abort", abandon, { once: true });
                         awaiting.current = {
+                            run: id,
                             last: error.step === action.calls.length - 1,
+                            owner: {
+                                account: runAccount,
+                                reservation: error.held?.reservation,
+                            },
                             detached: heldStep(error),
                             end: abandon,
                         };
@@ -549,7 +909,6 @@ export function useReviewedRun(deps) {
                     const finish = completing(error, action.calls.length, end);
                     // Followed for a later settlement; one already there is read once it attaches.
                     void follow(finish, () => end(null)).then(() => finish());
-                    const before = error.held?.hashes ?? [];
                     return {
                         status: "receipt",
                         step: error.step,
@@ -560,6 +919,11 @@ export function useReviewedRun(deps) {
                         ended: () => outcome.then(async (ran) => {
                             if (!ran)
                                 return null;
+                            if (ran === "queued") {
+                                const failure = new ConfirmationQueuedError(error.step);
+                                const line = errorLine(failure);
+                                return { status: "failed", error: line, failure };
+                            }
                             const { settled, receipt } = ran;
                             if (settled.result !== "success") {
                                 const line = settledLine(settled);
@@ -569,7 +933,8 @@ export function useReviewedRun(deps) {
                                     failure: new ReviewLineError(line),
                                 };
                             }
-                            const signatures = error.held?.signatures;
+                            // The run's own, as its hold saved them with the step.
+                            const { signatures } = ran;
                             if (error.step < action.calls.length - 1) {
                                 const started = await runLatest.current({
                                     ...action,
@@ -587,7 +952,7 @@ export function useReviewedRun(deps) {
                             }
                             return {
                                 status: "done",
-                                hashes: [...before, settled.hash],
+                                hashes: ran.hashes,
                                 receipts: receipt ? [receipt] : [],
                                 ...(signatures ? { signatures } : {}),
                             };
@@ -596,9 +961,9 @@ export function useReviewedRun(deps) {
                 }
                 // A resume can complete a step the wallet sent before the reload.
                 try {
-                    const after = action.scope === undefined || !deps?.account
+                    const after = action.scope === undefined || !runAccount
                         ? null
-                        : findReviewedSequence(action.scope, deps.account, {
+                        : findReviewedSequence(action.scope, runAccount, {
                             storage: deps.storage,
                         });
                     if (after?.completed.length &&
@@ -610,6 +975,19 @@ export function useReviewedRun(deps) {
                 catch {
                     /* An unreadable sequence adds nothing to what this run saw. */
                 }
+                // Refused by a write already held (another form's, sharing the
+                // hold): this run follows it only as its own exact call.
+                const refused = error instanceof WriteHeldError
+                    ? error.state.reservation
+                    : error instanceof WriteHoldUnacknowledgedSuccessError
+                        ? error.success.reservation
+                        : undefined;
+                if (refused)
+                    before.add(refused);
+                // ponytail: one call only; a sequence's journal keeps its steps.
+                const left = holds().filter(({ reservation }) => !before.has(reservation));
+                if (action.calls.length === 1 && left.length && runAccount)
+                    changeOwn(runAccount, left.map(({ reservation }) => reservation), { kind: "keep" });
                 const cancelled = error instanceof TransactionReviewCancelledError ||
                     isDefiniteWalletRejection(error);
                 const line = cancelled ? null : errorLine(error);