@bananapus/nana-sdk-core 6.1.0 → 6.3.0

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

@@ -1,10 +1,14 @@
 import { ReviewLineError } from "../lineError.js";
+import { ConfirmationQueuedError, LockLostError, lockWorkRunning, } from "../locks.js";
 import { tell } from "../receipt.js";
-import { createHeldWriteView, discardReviewedSequence, errorLine, findReviewedSequence, 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, 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,
+    following: false,
     lastSubmittedStep: null,
     phase: "idle",
     step: 0,
@@ -15,6 +19,7 @@ const IDLE = {
     safeTxHash: null,
     receipt: null,
     settled: null,
+    acknowledge: null,
 };
 /** The bytes a call sends, for comparing two actions. */
 const sent = ({ chainId, to, data, value, gas }) => [
@@ -24,6 +29,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.";
 /**
@@ -33,18 +60,46 @@ export const REVIEWED_RUN_BUSY_LINE = "This action is still running. Wait for it
  */
 export function useReviewedRun(deps) {
     const [state, setState] = useState(IDLE);
-    /** A cancel to tell once the cancelled run has rendered. */
+    /** A cancel or stop to tell once rendered. */
     const [cancelling, setCancelling] = useState(null);
     useEffect(() => {
         if (cancelling)
-            void tell(cancelling.onCancelled);
+            void tell(cancelling.told);
     }, [cancelling]);
+    /** 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. A
+    // later one never drops an earlier one still running from the wait.
+    useEffect(() => {
+        if (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. */
+    const awaiting = useRef(null);
     /** How many runs are open: a discard waits for none. */
     const open = useRef(0);
+    /**
+     * The latest run's life: aborted when it is replaced, reset, dismissed or
+     * unmounted, so its completion acknowledges nothing it can no longer show.
+     */
+    const life = useRef(new AbortController());
     const mounted = useRef(false);
     /** This render's `run`: a run's end that continues the action runs it. */
     const runLatest = useRef(async () => null);
@@ -54,8 +109,106 @@ 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();
+        life.current = new AbortController();
+        awaiting.current = null;
         const left = leave.current;
         leave.current = () => { };
         left();
@@ -69,9 +222,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) => {
+    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"
             ? {
@@ -83,12 +239,14 @@ export function useReviewedRun(deps) {
             : finished
                 ? {
                     ...now,
+                    following: false,
                     phase: "done",
                     hash: settled.hash,
                     receipt,
                     error: null,
                     failure: null,
                     settled: { step, finished },
+                    acknowledge,
                 }
                 : {
                     ...IDLE,
@@ -109,6 +267,11 @@ export function useReviewedRun(deps) {
             // never stays proposed, and never shows done unverified.
             onSettled: (settled, receipt) => watched.finish(settled, receipt),
             onReleased: () => {
+                // A later reservation's release (another tab's) never ends a
+                // write that settled: its settlement completes it.
+                if (watched.reservation &&
+                    watched.handle.settlementOf(watched.reservation))
+                    return;
                 watched.released?.();
                 if (latest.current === watched.run)
                     setState((now) => ({
@@ -142,16 +305,68 @@ export function useReviewedRun(deps) {
         shown.phase === "settled"
         ? null
         : shown;
-    const { cancelled: _cancelled, ...shownState } = state;
+    const { cancelled: _cancelled, stopped: _stopped, acknowledge: _acknowledge, ...shownState } = state;
+    const status = reviewedRunStatus({ ...state, held });
+    const reset = () => {
+        replaced();
+        setState(IDLE);
+        setWatched(null);
+    };
+    const detach = (target) => {
+        // ponytail: unbounded; it ends once the hold is clear.
+        if (target)
+            void followHeldWrite(target.handle, target.client, {
+                signal: new AbortController().signal,
+                ...(target.reservation ? { reservation: target.reservation } : {}),
+            }).then((end) => end?.status === "clear" &&
+                end.settled?.result === "success" &&
+                tell(deps?.onDismissedSettled, target.call), () => undefined);
+    };
     const api = {
         ...shownState,
-        ...reviewedRunStatus({ ...state, held }),
+        ...status,
+        busy: status.busy && !state.following,
         held,
         ...actionsOf(shown, held ? view : undefined),
-        reset: () => {
-            replaced();
-            setState(IDLE);
-            setWatched(null);
+        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
+                ? waiting.detached
+                : watched && {
+                    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,
         discard: async (scope, account = deps?.account) => {
@@ -169,9 +384,106 @@ export function useReviewedRun(deps) {
             setState(IDLE);
             setWatched(null);
         },
-        run: async ({ onCancelled, ...action }) => {
+        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;
             // A step still confirming is followed in place, in the same review,
             // until a reset or a later run ends it.
             const following = new AbortController();
@@ -182,6 +494,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;
@@ -193,36 +520,65 @@ export function useReviewedRun(deps) {
                 update({ lastSubmittedStep: step });
             };
             setWatched(null);
+            /** Acknowledges a success this run showed, unless the run is gone. */
+            const acknowledging = (handle, settled) => async () => {
+                if (!alive.aborted)
+                    await handle.acknowledge(settled).catch(() => undefined);
+            };
             /**
              * Completes a sent step once its hold settled it, as the run would
              * have (`completeReviewedStep`: the journal, `onConfirmed` once with
-             * the receipt its hold verified, the acknowledgement), then shows how
-             * it ended, once. Until it can (the receipt unread, or the hold not yet
+             * the receipt its hold verified), then shows how it ended, once. A
+             * last step's success is acknowledged once that rendered; an earlier
+             * step's at once, its sequence's journal keeping it from sending again. Until it can (the receipt unread, or the hold not yet
              * settled for this send), it is tried again, never shown.
              */
             const completing = (target, total, end) => {
                 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)
+                        return;
                     let unread = false;
                     completed = completed.then((prior) => prior ??
                         (loaded ? Promise.resolve(loaded) : load(deps.engine))
-                            .then((engine) => engine.completeReviewedStep(target, action$, deps, receipt))
+                            .then((engine) => engine.completeReviewedStep(target, action$, deps, receipt, alive, target.step < total - 1))
                             .catch(() => {
                             unread = true;
                             return null;
                         }));
                     void completed.then((ended) => {
-                        if (shown || latest.current !== id)
+                        // 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;
@@ -231,7 +587,9 @@ export function useReviewedRun(deps) {
                             return;
                         shown = true;
                         // Shown with the receipt completion checked, a failure's too.
-                        showSettled(id, target.step, total, ended.settled, ended.receipt);
+                        showSettled(id, target.step, total, ended.settled, ended.receipt, ended.settled.result === "success" && target.step === total - 1
+                            ? acknowledging(openStepHold(deps.hold, action$.account, false, target.held.call), ended.settled)
+                            : null, action$.account, target.held?.reservation);
                         setWatched(null);
                         end?.(ended);
                     });
@@ -243,9 +601,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);
@@ -256,36 +615,48 @@ 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.
                     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;
+                        if (held.status === "clear")
+                            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;
@@ -294,6 +665,9 @@ export function useReviewedRun(deps) {
                             handle: found.handle,
                             client: deps.clientFor(found.call.chainId),
                             run: id,
+                            account,
+                            call: found.call,
+                            reservation,
                             step: found.step,
                             total,
                             finish: finish ??
@@ -304,6 +678,11 @@ export function useReviewedRun(deps) {
                             ...(released ? { released } : {}),
                         }
                         : null);
+                    // Only its hold is followed now: the confirm can close.
+                    if (reservation)
+                        mine.current.add(reservation);
+                    if (found)
+                        update({ following: true });
                     return !!found;
                 }
                 catch {
@@ -311,11 +690,31 @@ export function useReviewedRun(deps) {
                     return false;
                 }
             };
+            const heldStep = (target) => {
+                const call = target.held?.call ?? action.calls[target.step];
+                if (!deps || !runAccount || !call)
+                    return null;
+                try {
+                    const safe = runSafe();
+                    if (safe === undefined)
+                        return null;
+                    return {
+                        handle: openStepHold(deps.hold, runAccount, safe, call),
+                        client: deps.clientFor(call.chainId),
+                        call,
+                        account: runAccount,
+                        reservation: target.held?.reservation,
+                    };
+                }
+                catch {
+                    return null;
+                }
+            };
             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);
@@ -334,7 +733,16 @@ export function useReviewedRun(deps) {
                     }),
                 ]).finally(() => signal?.removeEventListener("abort", withdraw));
                 const { resumeReviewed, sendReviewed } = loaded;
-                const { account, guard } = deps;
+                // A success already shown is acknowledged before this run checks it.
+                await acknowledged.current;
+                const settledOwn = () => {
+                    const settled = ownSuccess(action);
+                    if (settled)
+                        throw new OwnSucceeded(settled);
+                };
+                settledOwn();
+                const { guard } = deps;
+                const account = runAccount;
                 const tracked = {
                     ...deps,
                     onProgress: (progress) => {
@@ -391,30 +799,46 @@ 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.
-                update({ phase: result.status });
+                const calls = saved?.calls ?? action.calls;
+                const last = result.status === "done"
+                    ? openStepHold(deps.hold, account, false, calls[calls.length - 1])
+                    : null;
+                const success = last?.unacknowledgedSuccess();
+                update({
+                    phase: result.status,
+                    // Shown, its success blocks no later run.
+                    acknowledge: last &&
+                        success &&
+                        result.status === "done" &&
+                        result.hashes.some((h) => h.toLowerCase() === success.hash)
+                        ? acknowledging(last, success)
+                        : null,
+                });
                 // Every step of a done run has its hash, a resumed one's too.
-                submit(result.status === "done"
-                    ? (saved?.calls ?? action.calls).length - 1
-                    : result.step);
+                submit(result.status === "done" ? calls.length - 1 : result.step);
                 if (result.status === "proposed")
                     void follow();
-                else if (mounted.current && latest.current === id) {
-                    // Shown: its success blocks no later run.
-                    const calls = saved?.calls ?? action.calls;
-                    const handle = openStepHold(deps.hold, account, false, calls[calls.length - 1]);
-                    const success = handle.unacknowledgedSuccess();
-                    if (success &&
-                        result.hashes.some((h) => h.toLowerCase() === success.hash))
-                        await handle.acknowledge(success).catch(() => undefined);
-                }
                 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({
@@ -423,12 +847,15 @@ export function useReviewedRun(deps) {
                         hash: error.hash,
                         error: null,
                         failure: null,
+                        following: true,
                     });
                     let end;
                     const cancelled = action.follow?.signal;
                     const abandon = () => end(null);
                     const outcome = new Promise((resolve) => (end = (ran) => {
                         cancelled?.removeEventListener("abort", abandon);
+                        if (awaiting.current?.end === abandon)
+                            awaiting.current = null;
                         resolve(ran);
                     }));
                     // Replaced, or the caller's follow ended (a cancel, unlike its
@@ -439,11 +866,20 @@ export function useReviewedRun(deps) {
                     else {
                         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,
+                        };
                     }
                     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,
@@ -454,6 +890,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);
@@ -463,11 +904,13 @@ 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,
                                     ...(onCancelled ? { onCancelled } : {}),
+                                    ...(onStopped ? { onStopped } : {}),
                                 });
                                 const next = started?.status === "receipt"
                                     ? await started.ended()
@@ -480,7 +923,7 @@ export function useReviewedRun(deps) {
                             }
                             return {
                                 status: "done",
-                                hashes: [...before, settled.hash],
+                                hashes: ran.hashes,
                                 receipts: receipt ? [receipt] : [],
                                 ...(signatures ? { signatures } : {}),
                             };
@@ -489,9 +932,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 &&
@@ -503,6 +946,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);
@@ -519,9 +975,13 @@ export function useReviewedRun(deps) {
                         return;
                     if (found === null)
                         setTimeout(settle, RECEIPT_RETRY_MS);
-                    else if (cancelled && !sentAny && !found) {
-                        update({ cancelled: true });
-                        setCancelling(onCancelled ? { onCancelled } : null);
+                    else if (cancelled && !found) {
+                        const step = submitted ?? 0;
+                        update(sentAny ? { stopped: true } : { cancelled: true });
+                        const told = sentAny
+                            ? onStopped && (() => onStopped(step))
+                            : onCancelled;
+                        setCancelling(told ? { told } : null);
                     }
                 });
                 settle();