@bananapus/nana-sdk-core 2.35.0 → 2.36.0

package/dist/esm/review/tabState.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Where this tab's shared write state lives on `globalThis`, by symbol, so
+ * every copy of the SDK loaded in the tab shares it, and the test-only entry
+ * (`@bananapus/nana-sdk-core/testing`) can reset it without a production
+ * export. Not part of the public surface.
+ */
+export declare const TAB: {
+    /** Held writes kept in memory where storage is refused. */
+    readonly memory: symbol;
+    /** Without Web Locks, one queue per action. */
+    readonly queues: symbol;
+    /** What each tab memory last saw in durable storage. */
+    readonly seen: symbol;
+    /** The stop of every write hold controller with a follower or listener running. */
+    readonly holds: symbol;
+    /** The stop of every running Safe Relayr watch. */
+    readonly watches: symbol;
+    /** Safe Relayr reviews remembered this session. */
+    readonly reviews: symbol;
+};
+/** The tab's shared `T` at `key`, made by `make` the first time. */
+export declare function tabShared<T>(key: symbol, make: () => T): T;
+//# sourceMappingURL=tabState.d.ts.map

package/dist/esm/review/tabState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabState.d.ts","sourceRoot":"","sources":["../../../src/review/tabState.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,GAAG;IACd,2DAA2D;;IAE3D,+CAA+C;;IAE/C,wDAAwD;;IAExD,mFAAmF;;IAEnF,mDAAmD;;IAEnD,mDAAmD;;CAE3C,CAAC;AAEX,oEAAoE;AACpE,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAG1D"}

package/dist/esm/review/tabState.js

@@ -0,0 +1,26 @@
+/**
+ * Where this tab's shared write state lives on `globalThis`, by symbol, so
+ * every copy of the SDK loaded in the tab shares it, and the test-only entry
+ * (`@bananapus/nana-sdk-core/testing`) can reset it without a production
+ * export. Not part of the public surface.
+ */
+export const TAB = {
+    /** Held writes kept in memory where storage is refused. */
+    memory: Symbol.for("nana-sdk:held-writes"),
+    /** Without Web Locks, one queue per action. */
+    queues: Symbol.for("nana-sdk:write-lock-queues"),
+    /** What each tab memory last saw in durable storage. */
+    seen: Symbol.for("nana-sdk:held-writes-seen"),
+    /** The stop of every write hold controller with a follower or listener running. */
+    holds: Symbol.for("nana-sdk:write-hold-stops"),
+    /** The stop of every running Safe Relayr watch. */
+    watches: Symbol.for("nana-sdk:safe-relayr-watches"),
+    /** Safe Relayr reviews remembered this session. */
+    reviews: Symbol.for("nana-sdk:safe-relayr-reviews"),
+};
+/** The tab's shared `T` at `key`, made by `make` the first time. */
+export function tabShared(key, make) {
+    const tab = globalThis;
+    return (tab[key] ??= make());
+}
+//# sourceMappingURL=tabState.js.map

package/dist/esm/review/tabState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabState.js","sourceRoot":"","sources":["../../../src/review/tabState.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG;IACjB,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,sBAAsB,CAAC;IAC1C,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,4BAA4B,CAAC;IAChD,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,2BAA2B,CAAC;IAC7C,mFAAmF;IACnF,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,2BAA2B,CAAC;IAC9C,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,8BAA8B,CAAC;IACnD,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,8BAA8B,CAAC;CAC3C,CAAC;AAEX,oEAAoE;AACpE,MAAM,UAAU,SAAS,CAAI,GAAW,EAAE,IAAa;IACrD,MAAM,GAAG,GAAG,UAAqC,CAAC;IAClD,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAM,CAAC;AACpC,CAAC"}

package/dist/esm/review/writeHold.d.ts

@@ -1,4 +1,4 @@
-import { type Hex, type PublicClient, type TransactionReceipt } from "viem";
+import { type Address, type Hex, type PublicClient, type TransactionReceipt } from "viem";
 import { type SafeQueuedTransaction, type SafeServiceOptions } from "../safeService.js";
 import { type HeldWriteStorage, type ReviewedWriteRecoveryInput, type ReviewedWriteRecoveryRecord } from "./writeRecovery.js";
 /** The reads a write hold makes on the call's chain; a viem PublicClient satisfies it. */
@@ -41,9 +41,9 @@ type Held<S extends string, Extra> = {
  *   actually sent at (`sentNonce`, from its authenticated transaction; the
  *   nonce read before the wallet opened only locates the call). The exit is
  *   offered;
- * - `held-unchecked`: a saved hash the node doesn't know, on a record saved
- *   with no nonce to check, or 30 minutes after the wallet returned it (or,
- *   for a record saved before that time was kept, after it was first read). The
+ * - `held-unchecked`: a saved hash the node doesn't know 30 minutes after
+ *   the wallet returned it (or, for a record saved before that time was
+ *   kept or adopted without it, after it was first read). The
  *   exit is offered, with a line that says so; a hash that shows up later is
  *   followed as usual. A hash seen with its sent nonce that the node has not
  *   known for 30 minutes, with that nonce unused at a canonical finalized
@@ -72,6 +72,13 @@ export type WriteHoldState = WriteHoldStateOf & {
      * so an observer can ignore a newer reservation it didn't start.
      */
     reservation?: string;
+    /**
+     * On a result of state() or exit(): true when the gate read the chain
+     * under the call's lock; false when the lock was busy and this is only the
+     * saved record (its exit hidden). Never let a false one hide an exit
+     * already shown.
+     */
+    checked?: boolean;
 };
 type WriteHoldStateOf = {
     status: "clear";
@@ -185,6 +192,11 @@ export declare function createWriteHold(options?: {
     open: (call: ReviewedWriteRecoveryInput, { legacy, }?: {
         legacy?: (string | {
             call: ReviewedWriteRecoveryInput["call"];
+        } | {
+            match: {
+                to: Address;
+                selector: Hex;
+            };
         })[];
     }) => {
         peek: () => WriteHoldState;
@@ -205,6 +217,20 @@ export declare function createWriteHold(options?: {
         onUnproven: (client: WriteHoldClient, proposalHash?: `0x${string}` | undefined) => Promise<WriteHoldState>;
         onExecuted: (client: WriteHoldClient, executionHash?: `0x${string}` | undefined) => Promise<WriteHoldState>;
         attachHash: (client: WriteHoldClient, hash: `0x${string}`) => Promise<WriteHoldState>;
+        attachSafeNonce: (client: WriteHoldClient, args_1: {
+            safeTxHash: Hex;
+            nonce: number;
+        }) => Promise<WriteHoldState>;
+        adopt: (snapshot: WriteHoldState, evidence?: {
+            nonce?: number | bigint;
+            sentNonce?: number | bigint;
+            fromBlock?: bigint;
+            submittedAt?: number;
+            hash?: Hex;
+            safe?: {
+                safeTxHash: Hex;
+            };
+        } | undefined, client?: WriteHoldClient | undefined) => Promise<WriteHoldState>;
         /**
          * Every state this controller reads or makes for the call, and other
          * tabs' changes. The latest one, if any, is replayed at once.
@@ -216,7 +242,7 @@ export declare function createWriteHold(options?: {
     /** The review's line while holds last only in this tab, or null. */
     reviewLine: () => "This browser can't remember pending transactions. Check your wallet before repeating one." | null;
     /** Stop every settle poll and the tab listener (tests, teardown). */
-    dispose(): void;
+    dispose: () => void;
 };
 export type WriteHold = ReturnType<typeof createWriteHold>;
 export type WriteHoldHandle = ReturnType<WriteHold["open"]>;

package/dist/esm/review/writeHold.d.ts.map

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

package/dist/esm/review/writeHold.js

@@ -1,9 +1,21 @@
 import { isAddress, toEventSelector, } from "viem";
 import { canonicalSafeTxHash, lookAtSafeProposalEnd, provenSafeProposalEnd, readSafeTransaction, SAFE_PROPOSAL_AWAITING, safeTransactionMessage, } from "../safeService.js";
 import { SAFE_PROPOSAL_EXECUTED_LINE, WRITE_HOLD_HASHED_EXIT_LINE, WRITE_HOLD_IN_TAB_LINE, WRITE_HOLD_LOOKS_DONE_LINE, WRITE_HOLD_MINED_LINE, WRITE_HOLD_NONCE_LINE, WRITE_HOLD_PENDING_LINE, WRITE_HOLD_UNCHECKED_LINE, WRITE_HOLD_REVERTED_LINE, WRITE_HOLD_SAFE_REPLACED_LINE, WRITE_HOLD_SAFE_UNPROVEN_LINE, WRITE_HOLD_STALE_REVIEW_LINE, writeHeldMessage, } from "./messages.js";
-import { createBrowserWriteRecovery, createHeldWriteStorage, findTransactionAtNonce, readReviewedWriteNonce, SubmittedWritePersistenceError, verifyReviewedWriteExpiry, verifyReviewedWriteReceipt, } from "./writeRecovery.js";
+import { createBrowserWriteRecovery, createHeldWriteStorage, findReviewedWrites, heldSafeProposal, findTransactionAtNonce, readReviewedWriteNonce, safeProposalIsHeldCall, SubmittedWritePersistenceError, verifyReviewedWriteExpiry, verifyReviewedWriteReceipt, } from "./writeRecovery.js";
 import { isBytes32 } from "../untrusted.js";
 import { atCanonicalFinalizedBlock } from "./relayr.js";
+import { TAB, tabShared } from "./tabState.js";
+/** `sent` is the transaction at `hash`, exactly `record`'s call, from its account, on its chain. */
+function sentIsCall(sent, hash, record) {
+    return (sent.hash?.toLowerCase() === hash.toLowerCase() &&
+        sent.from?.toLowerCase() === record.account &&
+        (sent.chainId === undefined || sent.chainId === record.chainId) &&
+        sent.to?.toLowerCase() === record.call.to &&
+        sent.input?.toLowerCase() === record.call.data &&
+        BigInt(sent.value) === BigInt(record.call.value));
+}
+/** The stop of every controller with a follower or tab listener running, for the test-only reset. */
+const liveHolds = tabShared(TAB.holds, () => new Set());
 /**
  * A state read without the chain (peek, a replay, another tab's change, a
  * send's progress): its status and line, never the exit. Only the gate in
@@ -59,6 +71,8 @@ const SAFE_EXECUTION_TOPICS = [
 ];
 /** A hash the network still hasn't seen this long after the wallet returned it was almost certainly never broadcast. */
 const UNSEEN_HASH_MS = 30 * 60_000;
+/** The longest one request to Safe's service may take inside the hold. */
+const SAFE_SERVICE_READ_MS = 8_000;
 /** The 30 minutes have passed since the wallet returned the hash, or since it was first read. A clock that couldn't be saved (NaN) never runs out. */
 function unseenTooLong(record) {
     return (Date.now() - Number(record.submittedAt ?? record.firstSeenAt) >=
@@ -175,6 +189,30 @@ function classify(record) {
  */
 export function createWriteHold(options = {}) {
     const storage = options.storage ?? createHeldWriteStorage();
+    /**
+     * Safe's service, every request and its body bounded together to
+     * {@link SAFE_SERVICE_READ_MS} whatever its fetch does with the signal: a read that times out is
+     * unknown, which never releases or settles, so a hung service can't hold
+     * a send or the call's lock.
+     */
+    const service = {
+        ...options.safeService,
+        fetch: (url, init) => {
+            const request = options.safeService?.fetch ?? globalThis.fetch;
+            let timer;
+            return Promise.race([
+                // The whole read, its body included, under the one deadline.
+                request(url, init).then(async (response) => new Response(await response.arrayBuffer(), {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: response.headers,
+                })),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error("Safe's service did not answer in time.")), SAFE_SERVICE_READ_MS);
+                }),
+            ]).finally(() => clearTimeout(timer));
+        },
+    };
     const interval = options.settle?.intervalMs ?? SETTLE_POLL_MS;
     const attempts = options.settle?.attempts ?? SETTLE_POLL_ATTEMPTS;
     const listeners = new Map();
@@ -218,11 +256,25 @@ export function createWriteHold(options = {}) {
             }
         };
         globalThis.addEventListener("storage", onStorage);
+        liveHolds.add(dispose);
+    }
+    /** Stop every settle poll and the tab listener. */
+    function dispose() {
+        for (const timer of timers.values())
+            clearTimeout(timer);
+        timers.clear();
+        if (onStorage)
+            globalThis.removeEventListener?.("storage", onStorage);
+        onStorage = undefined;
+        liveHolds.delete(dispose);
     }
-    function openOne(call, hooks = {}) {
+    function openOne(call, hooks = {}, 
+    /** The key a found write was saved under, when it isn't its call's own. */
+    at) {
         const recovery = createBrowserWriteRecovery(call, {
             storage,
             locks: options.locks,
+            at,
         });
         // The canonical recovery scope: a namespace and an exact call never share it.
         const key = recovery.scopeKey;
@@ -279,6 +331,7 @@ export function createWriteHold(options = {}) {
         function follow(client, id, left = attempts) {
             if (timers.has(id) || left <= 0)
                 return;
+            liveHolds.add(dispose);
             timers.set(id, setTimeout(() => {
                 void state(client)
                     .catch(() => null)
@@ -320,10 +373,37 @@ export function createWriteHold(options = {}) {
                 follow(client, record.id);
             return classify(recovery.read());
         }
+        /**
+         * Whether a previous deploy's `hash` may be this call's: a valid hash
+         * read on the call's chain that isn't shown to be another write. A
+         * transaction must be the exact call from the account; a Safe proposal,
+         * exactly this call. One that can't be read is unknown, not refused.
+         */
+        async function adoptable(hash, client) {
+            if (!isBytes32(hash) ||
+                !client ||
+                (await client.getChainId().catch(() => null)) !== call.chainId)
+                return false;
+            const reviewed = {
+                account: call.account.toLowerCase(),
+                chainId: call.chainId,
+                call: {
+                    to: call.call.to.toLowerCase(),
+                    data: call.call.data.toLowerCase(),
+                    value: String(call.call.value ?? 0),
+                },
+            };
+            if (call.safe) {
+                const proposal = await readSafeTransaction(call.chainId, call.account, hash, service).catch(() => null);
+                return !proposal || safeProposalIsHeldCall(proposal, call);
+            }
+            const sent = await client.getTransaction({ hash }).catch(() => null);
+            return !sent || sentIsCall(sent, hash, reviewed);
+        }
         /** The authenticated nonce of a Safe proposal, from Safe's service. */
         async function proposalNonceOf(record) {
             try {
-                const proposal = await readSafeTransaction(record.chainId, record.account, record.hash, options.safeService);
+                const proposal = await readSafeTransaction(record.chainId, record.account, record.hash, service);
                 return safeTransactionMessage(proposal).nonce;
             }
             catch {
@@ -528,13 +608,13 @@ export function createWriteHold(options = {}) {
             }
             const end = (record.safeNonce !== undefined &&
                 (await provenSafeProposalEnd(client, record.account, hash, BigInt(record.safeNonce)))) ||
-                (await lookAtSafeProposalEnd(client, record.chainId, record.account, hash, options.safeService));
+                (await lookAtSafeProposalEnd(client, record.chainId, record.account, hash, service));
             // Another Safe transaction took its nonce, even after a saved execution
             // was reorganized away. It may have run the call too: the exit, never a release.
             if (end.look === "replaced")
                 return safeReplaced(recovery.replacedOnChain(record));
             if (end.look === "expired" && !record.executed) {
-                const expired = await verifyReviewedWriteExpiry(client, record, options.safeService).catch(() => false);
+                const expired = await verifyReviewedWriteExpiry(client, record, service).catch(() => false);
                 if (expired && release(record))
                     return clear({ result: "expired" }, record.id);
             }
@@ -665,9 +745,7 @@ export function createWriteHold(options = {}) {
             }
             if (record.hash &&
                 record.sentNonce === undefined &&
-                (record.nonce === undefined ||
-                    record.fromBlock === undefined ||
-                    unseenTooLong(record)) &&
+                unseenTooLong(record) &&
                 (await client.getTransaction({ hash: record.hash }).then(() => false, (error) => error?.name === "TransactionNotFoundError")))
                 return unchecked(record);
             return classify(record);
@@ -679,7 +757,7 @@ export function createWriteHold(options = {}) {
         async function state(client, checks = {}) {
             lastEffect = checks.effect;
             const result = await locked(() => inspect(client, checks.effect), false);
-            return shown(result ? result.value : peek());
+            return { ...shown(result ? result.value : peek()), checked: !!result };
         }
         return {
             state,
@@ -865,7 +943,10 @@ export function createWriteHold(options = {}) {
                     // what the saved record says, with no exit.
                 }, false);
                 const ended = result?.value ?? { released: false, state: peek() };
-                return { ...ended, state: shown(ended.state) };
+                return {
+                    ...ended,
+                    state: { ...shown(ended.state), checked: !!result },
+                };
             },
             /**
              * A receipt for the held write: an ordinary write's own hash, or a Safe
@@ -909,6 +990,94 @@ export function createWriteHold(options = {}) {
              * one lock, without releasing it. The hold then follows that hash: no
              * exit while it is pending, and its receipt settles it.
              */
+            /**
+             * Move a write a previous deploy kept (outside these holds) into this
+             * hold. `snapshot` is the state the app read before deciding. Under
+             * the call's lock, it reserves a held record with `evidence` (the
+             * account's next nonce, or the nonce it was sent at, with the block it
+             * was read at; when it was sent; and its `hash`, or for a Safe write
+             * `safe.safeTxHash`) only while nothing is held and no reservation
+             * came since `snapshot`: another tab's hold or settlement wins, and
+             * the current state is returned unchanged. A hash is checked first
+             * with `client`: a transaction that is another call, from another
+             * account or on another chain (or a Safe proposal of another call) is
+             * refused, adopting nothing. One the chain can't show is held, with
+             * the warned exit 30 minutes after it was sent (or adopted). Then the
+             * gate reads it: a mined one settles on its verified receipt. It never
+             * sends or releases; adopting twice holds once.
+             */
+            async adopt(snapshot, evidence = {}, client) {
+                const nonce = evidence.nonce ?? evidence.sentNonce;
+                const hash = (call.safe ? evidence.safe?.safeTxHash : evidence.hash)?.toLowerCase();
+                /** Nothing held, and no reservation since the app's read. */
+                const free = () => snapshot.status === "clear" &&
+                    !recovery.read() &&
+                    recovery.latestReservation() === snapshot.reservation;
+                const reserve = () => recovery.reserve(undefined, nonce !== undefined && evidence.fromBlock !== undefined
+                    ? { nonce, blockNumber: evidence.fromBlock }
+                    : undefined, {
+                    hash,
+                    submittedAt: evidence.submittedAt === undefined
+                        ? undefined
+                        : String(evidence.submittedAt),
+                });
+                if (hooks.across) {
+                    // Under an intent: the same atomic reserve as a send, under every
+                    // legacy key's lock, mirrored at each so older versions see it.
+                    if (!free() ||
+                        (hash !== undefined && !(await adoptable(hash, client))))
+                        return shown(peek());
+                    let adopted = false;
+                    try {
+                        const { released } = await hooks.across((work) => recovery.withLock(work), () => {
+                            if (!free())
+                                throw new Error("Held since the app's read.");
+                            reserve();
+                            adopted = true;
+                        }, recovery.rejected, Promise.resolve(), hooks.generations());
+                        await released;
+                    }
+                    catch {
+                        /* Held elsewhere, busy, or no longer free: nothing adopted. */
+                    }
+                    // A mined hash settles on its verified receipt, through the gate.
+                    return adopted && hash && client ? state(client) : shown(peek());
+                }
+                const result = await locked(async () => {
+                    if (!free())
+                        return peek();
+                    if (hash !== undefined && !(await adoptable(hash, client)))
+                        return peek();
+                    reserve();
+                    return hash && client ? inspect(client) : peek();
+                }, true);
+                return shown(result?.value ?? peek());
+            },
+            /**
+             * Save the Safe nonce of a held Safe proposal adopted before it was
+             * known, so a replacement can be proven later. Under the call's lock,
+             * only while the held proposal is `safeTxHash` with no nonce yet, and
+             * only when the call's proposal at `nonce` hashes to it: the hash is
+             * the proof. Then the gate reads it. Never sends or releases.
+             */
+            async attachSafeNonce(client, { safeTxHash, nonce }) {
+                const result = await locked(async () => {
+                    const record = recovery.read();
+                    if (record?.safe &&
+                        !record.mirrorOf &&
+                        record.safeNonce === undefined &&
+                        record.hash === safeTxHash.toLowerCase())
+                        try {
+                            canonicalSafeTxHash(call.chainId, call.account, heldSafeProposal(call, nonce), safeTxHash);
+                            recovery.proposalNonce(record, BigInt(nonce));
+                        }
+                        catch {
+                            /* Not this proposal at that nonce: nothing saved. */
+                        }
+                    return inspect(client);
+                }, true);
+                return shown(result?.value ?? peek());
+            },
             async attachHash(client, hash) {
                 const result = await locked(async () => {
                     const record = recovery.read();
@@ -921,12 +1090,8 @@ export function createWriteHold(options = {}) {
                         const sent = await client
                             .getTransaction({ hash })
                             .catch(() => null);
-                        if (sent?.hash?.toLowerCase() === hash.toLowerCase() &&
-                            sent.from?.toLowerCase() === record.account &&
-                            (sent.chainId === undefined || sent.chainId === record.chainId) &&
-                            sent.to?.toLowerCase() === record.call.to &&
-                            sent.input?.toLowerCase() === record.call.data &&
-                            BigInt(sent.value) === BigInt(record.call.value) &&
+                        if (sent &&
+                            sentIsCall(sent, hash, record) &&
                             // This attempt, not an earlier identical call: never below the
                             // account's next nonce or mined before it was reserved.
                             // With no such evidence, an identical earlier call can't be
@@ -982,7 +1147,13 @@ export function createWriteHold(options = {}) {
     /**
      * `legacy`: for a write held under an intent namespace, the keys an earlier
      * version held it under (an old namespace, or `{ call }` for an exact
-     * call); the current exact call is always checked. While any of them holds
+     * call); the current exact call is always checked. `{ match: { to,
+     * selector } }` finds them instead: every exact-call write this account
+     * saved on this chain to `to` with that 4-byte selector, for a hold saved
+     * before the intent key existed under calldata the retry can't rebuild (an
+     * old minimum, expiration or deadline). Pass one only for a write whose
+     * calldata is volatile: it holds every such call. It is found when the
+     * handle opens, and again right before a send reserves. While any of them holds
      * an unresolved write, the intent handle *is* that hold: its state, its
      * refusal and its own exit, in place. Each is checked alone, under its own
      * lock only, never two at once. Only when all are clear does the intent's
@@ -992,6 +1163,9 @@ export function createWriteHold(options = {}) {
     function open(call, { legacy = [], } = {}) {
         if (call.namespace === undefined)
             return openExact(call);
+        const matches = legacy.flatMap((source) => typeof source === "object" && "match" in source ? [source.match] : []);
+        /** Every exact-call write the matches find in storage now. */
+        const matched = () => matches.flatMap((match) => findReviewedWrites({ chainId: call.chainId, account: call.account, ...match }, { storage }));
         const namespace = call.namespace;
         const own = openOne(call, {
             across: reserveAcross,
@@ -1003,19 +1177,54 @@ export function createWriteHold(options = {}) {
         const { namespace: _, ...exact } = call;
         const scopeOf = (input) => createBrowserWriteRecovery(input, { storage }).scopeKey;
         const scopes = new Set([scopeOf(call)]);
-        const inputs = [{ call: call.call }, ...legacy]
-            .map((source) => typeof source === "string"
-            ? { ...call, namespace: source }
-            : { ...exact, call: source.call })
-            .filter((input) => {
-            const scope = scopeOf(input);
-            return !scopes.has(scope) && !!scopes.add(scope);
-        })
-            // One canonical order, by scope, for every writer's locks.
-            .sort((a, b) => Number(scopeOf(a) > scopeOf(b)) - Number(scopeOf(a) < scopeOf(b)));
         // Mirror-aware: evidence and exits always act on the source attempt.
-        const delegates = inputs.map((input) => openExact(input));
-        const journals = inputs.map((input) => createBrowserWriteRecovery(input, { storage, locks: options.locks }));
+        const delegates = [];
+        const journals = [];
+        /** Hold `inputs` too, each once, in one canonical order by scope for every writer's locks. */
+        function include(inputs) {
+            const added = inputs.filter(({ input, at }) => {
+                const scope = at ?? scopeOf(input);
+                return !scopes.has(scope) && !!scopes.add(scope);
+            });
+            if (!added.length)
+                return;
+            const keyed = [
+                ...delegates.map((delegate, index) => ({
+                    delegate,
+                    journal: journals[index],
+                })),
+                ...added.map(({ input, at }) => ({
+                    delegate: openExact(input, at),
+                    journal: createBrowserWriteRecovery(input, {
+                        storage,
+                        locks: options.locks,
+                        at,
+                    }),
+                })),
+            ].sort((a, b) => Number(a.journal.scopeKey > b.journal.scopeKey) -
+                Number(a.journal.scopeKey < b.journal.scopeKey));
+            delegates.splice(0, delegates.length, ...keyed.map((k) => k.delegate));
+            journals.splice(0, journals.length, ...keyed.map((k) => k.journal));
+        }
+        /**
+         * Look for matching writes again (on every state(), send() and exit());
+         * those found since are held too, each at the exact key it was found
+         * under, with its own Safe flag. Returns the ones that are new.
+         */
+        function rescan() {
+            const found = matched().filter(({ key }) => !scopes.has(key));
+            include(found.map(({ key, record }) => ({
+                input: { ...exact, safe: record.safe, call: record.call },
+                at: key,
+            })));
+            return found.map(({ record }) => record);
+        }
+        include([{ call: call.call }, ...legacy].flatMap((source) => typeof source === "string"
+            ? [{ input: { ...call, namespace: source } }]
+            : "call" in source
+                ? [{ input: { ...exact, call: source.call } }]
+                : []));
+        rescan();
         /** A legacy key holding anything but this intent's own mirror. */
         const foreign = (index) => journals[index].read()?.mirrorOf !== namespace &&
             delegates[index].peek().status !== "clear";
@@ -1023,6 +1232,7 @@ export function createWriteHold(options = {}) {
         const active = () => delegates.find((_, index) => foreign(index));
         /** The first legacy key holding an unresolved write, through its own gate. */
         async function delegated(client) {
+            rescan();
             for (const [index, handle] of delegates.entries()) {
                 if (!foreign(index))
                     continue;
@@ -1058,14 +1268,20 @@ export function createWriteHold(options = {}) {
                             entered += 1;
                             return acquire(index + 1);
                         });
+                    const refuse = (held) => new WriteHeldError(noticed({
+                        ...ungated(classify(held)),
+                        reservation: held.id,
+                    }));
                     for (const journal of journals) {
                         const held = journal.read();
                         if (held && held.mirrorOf !== namespace)
-                            throw new WriteHeldError(noticed({
-                                ...ungated(classify(held)),
-                                reservation: held.id,
-                            }));
+                            throw refuse(held);
                     }
+                    // A matching write saved since the last look holds it too, and
+                    // its own state() and exit() are reached from now on.
+                    const [late] = rescan();
+                    if (late)
+                        throw refuse(late);
                     // Another attempt since this review opened: review it again.
                     if (generations() !== reviewed)
                         throw new WriteHoldStaleReviewError(ownJournal.settled());
@@ -1153,6 +1369,7 @@ export function createWriteHold(options = {}) {
                 return own.send(client, run);
             },
             async exit(snapshot, acknowledgement, client) {
+                rescan();
                 const owner = snapshot.status === "clear"
                     ? undefined
                     : delegates.find((handle, index) => {
@@ -1174,6 +1391,10 @@ export function createWriteHold(options = {}) {
             onUnproven: async (...args) => active()?.onUnproven(...args) ?? after(await own.onUnproven(...args)),
             onExecuted: async (...args) => active()?.onExecuted(...args) ?? after(await own.onExecuted(...args)),
             attachHash: async (...args) => active()?.attachHash(...args) ?? after(await own.attachHash(...args)),
+            attachSafeNonce: async (...args) => active()?.attachSafeNonce(...args) ??
+                after(await own.attachSafeNonce(...args)),
+            // A legacy hold already holds it: nothing is adopted.
+            adopt: async (...args) => active()?.peek() ?? after(await own.adopt(...args)),
         };
     }
     /**
@@ -1181,11 +1402,12 @@ export function createWriteHold(options = {}) {
      * it is that intent's hold: it never sends or releases on its own, and its
      * exit is the intent's. A mirror left after the intent ended is removed.
      */
-    function openExact(call) {
-        const own = openOne(call);
+    function openExact(call, at) {
+        const own = openOne(call, {}, at);
         const journal = createBrowserWriteRecovery(call, {
             storage,
             locks: options.locks,
+            at,
         });
         /** The intent this key mirrors, from storage alone. */
         const mirrored = () => {
@@ -1249,6 +1471,9 @@ export function createWriteHold(options = {}) {
             onUnproven: (...args) => (route() ?? own).onUnproven(...args),
             onExecuted: (...args) => (route() ?? own).onExecuted(...args),
             attachHash: (...args) => (route() ?? own).attachHash(...args),
+            attachSafeNonce: (...args) => (route() ?? own).attachSafeNonce(...args),
+            // An intent's mirror already holds it: nothing is adopted.
+            adopt: async (...args) => route()?.peek() ?? own.adopt(...args),
         };
     }
     return {
@@ -1258,14 +1483,7 @@ export function createWriteHold(options = {}) {
         /** The review's line while holds last only in this tab, or null. */
         reviewLine: () => (storage.durable() ? null : WRITE_HOLD_IN_TAB_LINE),
         /** Stop every settle poll and the tab listener (tests, teardown). */
-        dispose() {
-            for (const timer of timers.values())
-                clearTimeout(timer);
-            timers.clear();
-            if (onStorage)
-                globalThis.removeEventListener?.("storage", onStorage);
-            onStorage = undefined;
-        },
+        dispose,
     };
 }
 //# sourceMappingURL=writeHold.js.map