shinjuku-shielded 0.3.68 → 0.3.70

package/manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "carbon-shielded-wallet/bundle-manifest/v1",
   "file": "shinjuku-wallet.mjs",
-  "sha256": "3d64f9b47b1139c42d3a2ff22642951710beeb669bf633b934b31419e94cc843",
-  "bytes": 12187129,
-  "sourceCommit": "8fd3e9152a6ef43a73769ded07e2cfa23c03615b",
+  "sha256": "ae568c800e9c2e6ccaf4cad6958cf133aa07469a93428827e679d3a1be89505f",
+  "bytes": 12197454,
+  "sourceCommit": "dc07c3b2f68a0358fc8137b8ba3773c533856117",
   "sourceDirty": false,
   "installRecordMatchesLockfile": true,
   "releaseRule": "valid only when two fresh npm ci --ignore-scripts builds on different OSes give the same sha256; installRecordMatchesLockfile true means every entry npm installed equals its package-lock.json entry and every entry not marked optional, devOptional included, is installed: an optional entry (a package for another platform) may be absent",
@@ -1282,5 +1282,5 @@
       "version": "1.8.0"
     }
   ],
-  "publishedAt": "2026-10-22T13:57:14.597Z"
+  "publishedAt": "2026-10-22T15:46:57.559Z"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "shinjuku-shielded",
-  "version": "0.3.68",
+  "version": "0.3.70",
   "mcpName": "io.github.ShinjukuStaition/shinjuku-mcp",
   "description": "Shinjuku Shielded, the private x402 facilitator on Solana: the self-custody wallet CLI and its MCP server. Shield, pay, and unshield USDC from any MCP agent, under caps you set.",
-  "shinjukuRelease": "3d64f9b4",
-  "shinjukuSha256": "3d64f9b47b1139c42d3a2ff22642951710beeb669bf633b934b31419e94cc843",
+  "shinjukuRelease": "ae568c80",
+  "shinjukuSha256": "ae568c800e9c2e6ccaf4cad6958cf133aa07469a93428827e679d3a1be89505f",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Shinjuku Shielded",
   "homepage": "https://github.com/ShinjukuStaition/shinjuku-mcp#readme",

package/shinjuku-wallet.mjs

@@ -13144,8 +13144,8 @@ var require_utils4 = __commonJS({
     module.exports.wrapperForImpl = function(impl) {
       return impl[module.exports.wrapperSymbol];
     };
-    module.exports.implForWrapper = function(wrapper) {
-      return wrapper[module.exports.implSymbol];
+    module.exports.implForWrapper = function(wrapper2) {
+      return wrapper2[module.exports.implSymbol];
     };
   }
 });
@@ -18026,9 +18026,9 @@ var require_event_target = __commonJS({
             return;
           }
         }
-        let wrapper;
+        let wrapper2;
         if (type === "message") {
-          wrapper = function onMessage(data, isBinary) {
+          wrapper2 = function onMessage(data, isBinary) {
             const event = new MessageEvent("message", {
               data: isBinary ? data : data.toString()
             });
@@ -18036,7 +18036,7 @@ var require_event_target = __commonJS({
             callListener(handler, this, event);
           };
         } else if (type === "close") {
-          wrapper = function onClose(code2, message) {
+          wrapper2 = function onClose(code2, message) {
             const event = new CloseEvent("close", {
               code: code2,
               reason: message.toString(),
@@ -18046,7 +18046,7 @@ var require_event_target = __commonJS({
             callListener(handler, this, event);
           };
         } else if (type === "error") {
-          wrapper = function onError(error) {
+          wrapper2 = function onError(error) {
             const event = new ErrorEvent("error", {
               error,
               message: error.message
@@ -18055,7 +18055,7 @@ var require_event_target = __commonJS({
             callListener(handler, this, event);
           };
         } else if (type === "open") {
-          wrapper = function onOpen() {
+          wrapper2 = function onOpen() {
             const event = new Event("open");
             event[kTarget] = this;
             callListener(handler, this, event);
@@ -18063,12 +18063,12 @@ var require_event_target = __commonJS({
         } else {
           return;
         }
-        wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
-        wrapper[kListener] = handler;
+        wrapper2[kForOnEventAttribute] = !!options[kForOnEventAttribute];
+        wrapper2[kListener] = handler;
         if (options.once) {
-          this.once(type, wrapper);
+          this.once(type, wrapper2);
         } else {
-          this.on(type, wrapper);
+          this.on(type, wrapper2);
         }
       },
       /**
@@ -42800,7 +42800,10 @@ async function routeFacilitatorsOverOnion(argv2, {
         onNone?.();
       }
     });
+    const first = firstRaces.has(group.label) ? void 0 : { startedAt: Date.now() };
+    if (first) firstRaces.set(group.label, first);
     group.pending = raced.winner.then((onion) => {
+      if (first) Object.assign(first, { endedAt: Date.now(), answered: !unanswered2 });
       group.winner = onion;
       group.pending = void 0;
       if (!unanswered2 && !raced.stopped) err(`tor: the onion ${hostOf(onion)} of ${group.label} answered first; it serves this run's requests to it
@@ -42901,7 +42904,7 @@ async function routeFacilitatorsOverOnion(argv2, {
     }
   };
 }
-var SITE_ONIONS, SITE_SPARE_ONIONS, PINNED_FACILITATOR_ONIONS, PINNED_SPARE_ONIONS, HISTORY_ONIONS, PINNED_HISTORY_ONIONS, HISTORY_PROBE_PATH, FACILITATOR_FLAGS, V3_ONION, DISCOVERY_TIMEOUT_MS, WARM_TIMEOUT_MS, RACE_TIMEOUT_MS, ROUTE_WAIT_MS, SPARE_AFTER_MS, SPARE_CAUSE, routedGroups, liveOnions, hostOf, noAnswer, routedOnions, routedOrigins, onionsOfOrigin, routesOverOnion, GLOBAL_DISPATCHER, onionDispatchers;
+var SITE_ONIONS, SITE_SPARE_ONIONS, PINNED_FACILITATOR_ONIONS, PINNED_SPARE_ONIONS, HISTORY_ONIONS, PINNED_HISTORY_ONIONS, HISTORY_PROBE_PATH, FACILITATOR_FLAGS, V3_ONION, DISCOVERY_TIMEOUT_MS, WARM_TIMEOUT_MS, RACE_TIMEOUT_MS, ROUTE_WAIT_MS, SPARE_AFTER_MS, SPARE_CAUSE, routedGroups, liveOnions, hostOf, noAnswer, routedOnions, routedOrigins, onionsOfOrigin, routesOverOnion, firstRaces, firstOnionRace, GLOBAL_DISPATCHER, onionDispatchers;
 var init_facilitatorOnion = __esm({
   "wallet/src/net/facilitatorOnion.mjs"() {
     "use strict";
@@ -42951,6 +42954,11 @@ var init_facilitatorOnion = __esm({
     routedOrigins = /* @__PURE__ */ new Map();
     onionsOfOrigin = (origin) => routedOrigins.get(origin) ?? PINNED_FACILITATOR_ONIONS[origin] ?? [];
     routesOverOnion = (origin) => routedOrigins.has(origin);
+    firstRaces = /* @__PURE__ */ new Map();
+    firstOnionRace = (origin) => {
+      const race = firstRaces.get(origin);
+      return race === void 0 ? void 0 : { ...race };
+    };
     GLOBAL_DISPATCHER = /* @__PURE__ */ Symbol.for("undici.globalDispatcher.1");
     onionDispatchers = /* @__PURE__ */ new Map();
   }
@@ -53654,6 +53662,11 @@ function finalizedPoolStateOf(report, { programId, pool: pool2 }) {
   if (entry === void 0 || entry.programId !== String(programId) || entry.pool !== String(pool2)) return void 0;
   return entry.state;
 }
+function poolReadAtOf(report) {
+  if (!report || !AUTHENTICATED_HISTORY_REPORTS.has(report)) return void 0;
+  const readAt = REPORT_POOL_STATES.get(report)?.readAt;
+  return Number.isFinite(readAt) ? readAt : void 0;
+}
 function p03SettlementConsumesBuffer(tag2) {
   return P03_SETTLEMENT_TAGS.includes(tag2) && !P03_INLINE_SETTLEMENT_TAGS.includes(tag2);
 }
@@ -53835,13 +53848,34 @@ async function refreshFinalizedP03HistorySnapshot({
   history,
   paymentSettler
 }) {
+  const { authenticated, program, poolKey } = refreshBinding(history, programId, pool2);
+  const snapshot = await readFinalizedPoolForRefresh(connection, program, poolKey);
+  return refreshedFromSnapshot({ connection, program, poolKey, authenticated, snapshot, paymentSettler });
+}
+async function refreshFinalizedP03HistoryFromSliced({ connection, programId, pool: pool2, history, snapshot }) {
+  const { authenticated, program, poolKey } = refreshBinding(history, programId, pool2);
+  if (snapshot === null || typeof snapshot !== "object" || snapshot.programDataReuse === void 0) return void 0;
+  let view2 = snapshot;
+  if (snapshot.replayStore === REPLAY_STORE_INDEXED) {
+    const slices = snapshot.e1TreeSlices;
+    if (!slices || slices.slot !== snapshot.slot || !(slices.header instanceof Uint8Array)) return void 0;
+    view2 = withPoolStateOf(snapshot, Object.freeze({
+      ...snapshot,
+      e1TreeHeader: Object.freeze({ address: slices.address, ownerProgramId: slices.ownerProgramId, data: Buffer.from(slices.header) })
+    }));
+  }
+  return refreshedFromSnapshot({ connection, program, poolKey, authenticated, snapshot: view2, reuseAnswer: snapshot.programDataReuse });
+}
+function refreshBinding(history, programId, pool2) {
   const authenticated = assertAuthenticatedFinalizedP03History(history);
   const program = canonicalKey(programId, "program_id");
   const poolKey = canonicalKey(pool2, "pool");
   if (authenticated.programId !== b58(program) || authenticated.pool !== poolKey.toBase58()) {
     throw new Error("p03_history_refresh_binding_invalid");
   }
-  const snapshot = await readFinalizedPoolForRefresh(connection, program, poolKey);
+  return { authenticated, program, poolKey };
+}
+async function refreshedFromSnapshot({ connection, program, poolKey, authenticated, snapshot, paymentSettler, reuseAnswer }) {
   if (snapshot.terminal !== authenticated.finalizedPoolSnapshot.terminal || snapshot.currentIndex !== authenticated.finalizedPoolSnapshot.currentIndex || snapshot.currentRoot !== authenticated.finalizedPoolSnapshot.currentRoot || !sameP03PoolPolicy(snapshot, authenticated.finalizedPoolSnapshot.policy) || !sameE1TreeHeader(snapshot, authenticated.finalizedPoolSnapshot.e1Tree, program, poolKey) || paymentSettler !== void 0 && snapshot.paymentSettler?.toBase58() !== paymentSettler) {
     throw Object.assign(
       new Error("p03_history_refresh_transition_detected"),
@@ -53861,7 +53895,8 @@ async function refreshFinalizedP03HistorySnapshot({
       programDataSha256: priorCoverage.programDataSha256,
       ...priorCoverage.programHistory ? { programHistory: priorCoverage.programHistory } : {}
     },
-    prior: HISTORY_ATTESTATIONS.get(authenticated)
+    prior: HISTORY_ATTESTATIONS.get(authenticated),
+    ...reuseAnswer !== void 0 ? { reuseAnswer } : {}
   });
   const deploymentCoverage = refreshedCoverage.coverage;
   if (!hasExecutableEvidence(deploymentCoverage)) throw new Error("p03_history_executable_evidence_required");
@@ -54154,7 +54189,8 @@ function parseFinalizedPool(response, program, pool2) {
     SNAPSHOT_POOL_STATES.set(snapshot, Object.freeze({
       programId: b58(program),
       pool: pool2.toBase58(),
-      state: Object.freeze({ ...state, owner })
+      state: Object.freeze({ ...state, owner }),
+      readAt: Date.now()
     }));
   }
   return snapshot;
@@ -57444,8 +57480,15 @@ async function readPages(history, pool2, needed, first, { wakeSlot } = {}) {
   }
   return { records: records.slice(0, needed), imports, initialization, syncedSlot };
 }
-async function readCompactPoolSnapshot({ connection, programId, pool: pool2 }) {
-  return readFinalizedPool(withBoundedOwnReads(connection), new import_web397.PublicKey(programId), new import_web397.PublicKey(pool2), { treeSlices: true });
+function startCompactPoolSnapshot({ connection, programId, pool: pool2 }) {
+  const own = withBoundedOwnReads(connection);
+  const program = new import_web397.PublicKey(programId);
+  const poolKey = new import_web397.PublicKey(pool2);
+  const sliced = readFinalizedPoolSliced(own, program, poolKey).catch(() => void 0);
+  const full = sliced.then((snapshot) => snapshot ?? readFinalizedPool(own, program, poolKey));
+  full.catch(() => {
+  });
+  return { sliced, full };
 }
 function requestCompactFirstPage({ history, pool: pool2 }) {
   try {
@@ -58471,7 +58514,8 @@ async function loadOrExtendFinalizedP03History({
     fallbacks += 1;
   }
   let laggingRetries = 0;
-  for (let laggingTry = 0; cached; laggingTry += 1) {
+  let cursorRetry;
+  for (let attempt = 0; cached; attempt += 1) {
     try {
       const extended = await extendFromCache({
         connection,
@@ -58484,11 +58528,12 @@ async function loadOrExtendFinalizedP03History({
         historySource,
         forceRead,
         // A retry reads the pool again: the first read may be the one that lagged (stamp review).
-        liveRead: laggingTry === 0 ? liveRead : void 0
+        liveRead: attempt === 0 ? liveRead : void 0
       });
       await beforePersist?.(extended);
       await persistCache(cache, extended, programIdBase58, poolBase58);
       remember(extended);
+      if (cursorRetry === "running") markPhase("extension-retry-ok");
       return {
         report: extended.report,
         mode: extended.mode,
@@ -58498,11 +58543,22 @@ async function loadOrExtendFinalizedP03History({
         ...extended.window ? { window: extended.window } : {}
       };
     } catch (error) {
+      if (cursorRetry === void 0 && /^p03_history_cursor_exhausted/.test(String(error?.message))) {
+        cursorRetry = "running";
+        onEvent("extension_retry", error);
+        markPhase("extension-retry-start");
+        await new Promise((resolve38) => setTimeout(resolve38, EXTENSION_CURSOR_RETRY_MS));
+        continue;
+      }
+      if (cursorRetry === "running") {
+        cursorRetry = "done";
+        markPhase("extension-retry-failed");
+      }
       onEvent("extension_failed", error);
       if (isProgramDataIdentityError(error)) throw error;
-      if (isLaggingNodeRpcError(error) && laggingTry < EXTENSION_LAGGING_RETRY_MS.length) {
+      if (isLaggingNodeRpcError(error) && laggingRetries < EXTENSION_LAGGING_RETRY_MS.length) {
         laggingRetries += 1;
-        await new Promise((resolve38) => setTimeout(resolve38, EXTENSION_LAGGING_RETRY_MS[laggingTry]));
+        await new Promise((resolve38) => setTimeout(resolve38, EXTENSION_LAGGING_RETRY_MS[laggingRetries - 1]));
         continue;
       }
       fallbacks += 1;
@@ -58888,7 +58944,7 @@ async function persistCache(cache, { report, entries: walked, attestation, marks
     ...attestation ? { attestation } : {}
   });
 }
-var import_web398, EXTENSION_LAGGING_RETRY_MS, PAGE_SIZE2, LAST_REPORTS, sameMark, HISTORY_ROUND_BUCKET, HISTORY_WARM_FRESH_MS, runBufferLists;
+var import_web398, EXTENSION_LAGGING_RETRY_MS, EXTENSION_CURSOR_RETRY_MS, PAGE_SIZE2, LAST_REPORTS, sameMark, HISTORY_ROUND_BUCKET, HISTORY_WARM_FRESH_MS, runBufferLists;
 var init_incremental = __esm({
   "wallet/src/history/incremental.mjs"() {
     "use strict";
@@ -58897,6 +58953,7 @@ var init_incremental = __esm({
     init_walk();
     init_phaseTiming();
     EXTENSION_LAGGING_RETRY_MS = [1e3, 2e3];
+    EXTENSION_CURSOR_RETRY_MS = 2e3;
     PAGE_SIZE2 = 1e3;
     LAST_REPORTS = /* @__PURE__ */ new WeakMap();
     sameMark = (cached, live) => cached === void 0 || cached === live;
@@ -58966,7 +59023,7 @@ async function loadWalletP03History(args) {
   }
   if (runKey !== void 0 && recentScope.getStore() !== void 0 && strictScope.getStore() !== true && args.forceRead !== true) {
     const recent = recentLoads.get(runKey);
-    if (recent !== void 0 && Date.now() - recent.startedAt <= HISTORY_PREWARM_JOIN_MS) {
+    if (recent !== void 0 && Date.now() - recentAgeStart(recent) <= HISTORY_PREWARM_JOIN_MS) {
       PREWARMED_REPORTS.add(recent.report);
       PAYMENT_TAKEN_REPORTS.add(recent.report);
       markPhase("walk-recent");
@@ -59000,7 +59057,7 @@ function recentBeforePrewarm(runKey, prewarm) {
   const accept = recentScope.getStore()?.accept;
   if (typeof accept !== "function" || prewarm.settled) return void 0;
   const recent = recentLoads.get(runKey);
-  if (recent === void 0 || Date.now() - recent.startedAt > HISTORY_PREWARM_JOIN_MS) return void 0;
+  if (recent === void 0 || Date.now() - recentAgeStart(recent) > HISTORY_PREWARM_JOIN_MS) return void 0;
   let accepted = false;
   try {
     accepted = accept(recent.report) === true;
@@ -59145,11 +59202,11 @@ async function walkWalletP03HistoryNow({ store, connection: given, programId, po
     if (typeof index === "bigint") movedIndex = index + SUBTREE_LEAVES4;
   } else if (earlier !== void 0) {
     markPhase("refresh-start");
-    const refreshing = refreshFinalizedP03HistorySnapshot({ connection, programId, pool: pool2, history: earlier });
+    let slicedPreRead;
     if (compactNext) {
-      poolPreRead = readCompactPoolSnapshot({ connection, programId, pool: pool2 });
-      poolPreRead.catch(() => {
-      });
+      const started = startCompactPoolSnapshot({ connection, programId, pool: pool2 });
+      slicedPreRead = started.sliced;
+      poolPreRead = started.full;
       markPhase("compact-pool-prestarted");
       if (!inTorRun() && Date.now() - remembered.at > PAGE0_PREREAD_AFTER_MS) {
         firstPreRead = requestCompactFirstPage({ history: connection.historyRpcSource, pool: pool2 });
@@ -59162,11 +59219,24 @@ async function walkWalletP03HistoryNow({ store, connection: given, programId, po
       } catch {
       }
     }
+    let fromSliced = false;
+    const refreshing = (async () => {
+      if (slicedPreRead !== void 0) {
+        const decided = await refreshFinalizedP03HistoryFromSliced({ connection, programId, pool: pool2, history: earlier, snapshot: await slicedPreRead });
+        if (decided !== void 0) {
+          fromSliced = true;
+          markPhase("refresh-from-sliced");
+          return decided;
+        }
+        markPhase("refresh-sliced-undecided");
+      }
+      return refreshFinalizedP03HistorySnapshot({ connection, programId, pool: pool2, history: earlier });
+    })();
     try {
       const refreshed = await refreshing;
       markPhase("walk-refreshed");
       rememberRunReport(runKey, refreshed);
-      writeStderr("history: the pool made no transition since this run's last walk; that history was moved to the current pool account (your own RPC read the pool account and the program's deployment account; the history source answered one signature read)\n");
+      writeStderr("history: the pool made no transition since this run's last walk; that history was moved to the current pool account " + (fromSliced ? "(your own RPC read the pool account and the program's deployment account in one request)\n" : "(your own RPC read the pool account and the program's deployment account; the history source answered one signature read)\n"));
       return refreshed;
     } catch (error) {
       markPhase("refresh-missed");
@@ -59389,7 +59459,7 @@ function reportHistoryRpc(split5, source, result, crossChecked) {
   writeStderr(`history: ${who} answered ${list(split5.history)}; your own RPC answered ${list(split5.own)} (the pool account the history must match, and the cross-check)${window2}${integrity}
 `);
 }
-var prepareReport, strictScope, withStrictHistorySource, recentScope, withRecentWalletHistory, recentLoads, forgetRecentWalletHistory, proofBuiltAt, historyCacheKey, latestPrewarm, HOME_MARKS_SETTLED_MS, HISTORY_PREWARM_JOIN_MS, SHARED_WALK_WAIT_MS, PAGE0_PREREAD_AFTER_MS, SUBTREE_LEAVES4, prewarmedWalks, sharedWalks, PREWARMED_REPORTS, PAYMENT_TAKEN_REPORTS, isPrewarmedWalletHistory, REPORT_STARTED_AT, walkStartedAtOf, COMPACT_BEHIND_POLL_MS, COMPACT_BEHIND_READ_MS, COMPACT_BEHIND_TOR_READ_MS, COMPACT_BEHIND_REFUSAL_MAX_BYTES, COMPACT_BEHIND_PAGE_BODY_MS, COMPACT_BEHIND_RETRY_MS, lastRunReports, writeStderr, announcedSources;
+var prepareReport, strictScope, withStrictHistorySource, recentScope, withRecentWalletHistory, recentLoads, recentAgeStart, forgetRecentWalletHistory, proofBuiltAt, historyCacheKey, latestPrewarm, HOME_MARKS_SETTLED_MS, HISTORY_PREWARM_JOIN_MS, SHARED_WALK_WAIT_MS, PAGE0_PREREAD_AFTER_MS, SUBTREE_LEAVES4, prewarmedWalks, sharedWalks, PREWARMED_REPORTS, PAYMENT_TAKEN_REPORTS, isPrewarmedWalletHistory, REPORT_STARTED_AT, walkStartedAtOf, COMPACT_BEHIND_POLL_MS, COMPACT_BEHIND_READ_MS, COMPACT_BEHIND_TOR_READ_MS, COMPACT_BEHIND_REFUSAL_MAX_BYTES, COMPACT_BEHIND_PAGE_BODY_MS, COMPACT_BEHIND_RETRY_MS, lastRunReports, writeStderr, announcedSources;
 var init_walletHistory = __esm({
   "wallet/src/history/walletHistory.mjs"() {
     "use strict";
@@ -59411,6 +59481,7 @@ var init_walletHistory = __esm({
     recentScope = new AsyncLocalStorage2();
     withRecentWalletHistory = (fn, { accept } = {}) => recentScope.run({ accept }, fn);
     recentLoads = /* @__PURE__ */ new Map();
+    recentAgeStart = (recent) => poolReadAtOf(recent.report) ?? recent.startedAt;
     forgetRecentWalletHistory = () => {
       recentLoads.clear();
       proofBuiltAt = Date.now();
@@ -64273,6 +64344,7 @@ var init_errorCodes = __esm({
       "exit_policy_values_invalid",
       "exit_proof_tools_invalid",
       "extension_failed",
+      "extension_retry",
       "max_delay_invalid",
       "max_delay_minutes",
       "no_anchor",
@@ -95977,7 +96049,7 @@ function withSellerResource(xPayment, record) {
   return patched;
 }
 function floatFetch(base, seen) {
-  const wrapper = async (target, init = {}) => {
+  const wrapper2 = async (target, init = {}) => {
     const response = await base(target, floatInit(init));
     const paid = Object.keys(init.headers ?? {}).some((name) => name.toLowerCase() === "payment-signature");
     if (paid || response.status === 402 || response.status < 400) return response;
@@ -95999,7 +96071,7 @@ function floatFetch(base, seen) {
     };
     return new Response(null, { status: 400 });
   };
-  return Object.defineProperty(wrapper, "baseFetch", { value: base });
+  return Object.defineProperty(wrapper2, "baseFetch", { value: base });
 }
 function floatRefusalError(refusal3, record) {
   const extra = {
@@ -105384,7 +105456,8 @@ async function downloadSet({ fetchImpl, base, entries, budget, onFile, onBytes =
 } }) {
   const stop3 = new AbortController();
   const files = entries.map((entry) => ({ entry, url: new URL(entry.path, base).href, label: `the proof-tool file ${entry.path}`, buffer: void 0, left: 0 }));
-  const queue = files.map((file) => ({ file, start: 0, end: RANGE_BYTES - 1, head: true, attempts: 0 })).sort((x, y) => Number(y.file.entry.path.endsWith(".params")) - Number(x.file.entry.path.endsWith(".params")));
+  const rank = (file) => file.entry.path === "proof-tools.json" ? 2 : file.entry.path.endsWith(".params") ? 1 : 0;
+  const queue = files.map((file) => ({ file, start: 0, end: RANGE_BYTES - 1, head: true, attempts: 0 })).sort((x, y) => rank(y.file) - rank(x.file));
   const inFlight = /* @__PURE__ */ new Set();
   let firstError;
   let filesLeft = files.length;
@@ -105581,12 +105654,17 @@ async function installProofTools({
   onProgress = () => {
   },
   progressLine = (text3) => process.stderr.write(text3),
-  progressEveryMs = PROGRESS_EVERY_MS
+  progressEveryMs = PROGRESS_EVERY_MS,
+  onFileWritten = () => {
+  },
+  mark = () => {
+  }
 }) {
   const { dir, sumsSha256 } = expected;
   if (!HEX643.test(String(sumsSha256)) || dir !== sumsSha256.slice(0, 8)) throw fail26("setup_release_invalid", "the expected proof-tool set is not a 64-hex list hash");
   const folder = join21(toolsRoot, dir);
   if (existsSync(folder) && verifyToolsFolder(folder, sumsSha256)) {
+    mark("present");
     return Object.freeze({ dir, sumsSha256, folder, downloaded: 0, ...toolPaths(folder) });
   }
   const base = new URL(`/proof-tools/${dir}/`, facilitator);
@@ -105594,6 +105672,7 @@ async function installProofTools({
   if (sha2569(sums) !== sumsSha256) {
     throw fail26("setup_sums_mismatch", "the downloaded SHA256SUMS does not have the pinned SHA-256, so no proof tool was downloaded");
   }
+  mark("sums");
   const entries = parseSums(sums.toString("utf8"));
   const partial = `${folder}.partial`;
   for (const entry of entries) {
@@ -105627,14 +105706,22 @@ async function installProofTools({
   let bytesDone = 0;
   let downloaded = 0;
   const budget = { left: LIMITS.total };
+  let hashMs = 0;
   const write = (entry, bytes2) => {
     const target = localPath(partial, entry.path);
-    if (sha2569(bytes2) !== entry.sha256) {
+    const hashStart = Date.now();
+    const hash12 = sha2569(bytes2);
+    hashMs += Date.now() - hashStart;
+    if (hash12 !== entry.sha256) {
       throw fail26("setup_file_hash_mismatch", `the proof-tool file ${entry.path} does not have the SHA-256 that SHA256SUMS lists, so it was not kept; rerun setup`);
     }
     mkdirSync(dirname20(target), { recursive: true, mode: 448 });
     writeFileSync(target, bytes2, { flag: "wx", mode: 384 });
     if (executable(entry.path)) chmodSync(target, 493);
+    try {
+      onFileWritten({ path: entry.path, file: target });
+    } catch {
+    }
   };
   for (const { entry, bytes: bytes2 } of kept) {
     write(entry, bytes2);
@@ -105668,20 +105755,35 @@ async function installProofTools({
     }, progressEveryMs);
     ticker.unref?.();
   }
+  let quarter = 0;
+  const markQuarters = () => {
+    const share = totalBytes !== void 0 && totalBytes > 0 ? (keptBytes + arrived) / totalBytes : (kept.length + downloaded) / entries.length;
+    while (quarter < 4 && share >= (quarter + 1) / 4) {
+      quarter += 1;
+      mark(`download-${quarter * 25}`);
+    }
+  };
+  mark("download-start", `f${missing.length}_of_${entries.length}`);
   try {
     await downloadSet({ fetchImpl, base, entries: missing, budget, onBytes: (count2) => {
       arrived += count2;
+      markQuarters();
     }, onFile: (entry, bytes2) => {
       write(entry, bytes2);
       bytesDone += bytes2.length;
       downloaded += 1;
+      mark("file", `f${kept.length + downloaded}_of_${entries.length}`);
       onProgress({ filesDone: kept.length + downloaded, filesTotal: entries.length, bytesDone });
     } });
   } finally {
     clearInterval(ticker);
   }
+  if (quarter < 4) mark("download-100");
+  mark("file-hashes", `ms${hashMs}`);
   writeFileSync(join21(partial, "SHA256SUMS"), sums, { flag: "wx", mode: 384 });
+  mark("hash-check-start");
   if (!verifyToolsFolder(partial, sumsSha256)) throw fail26("setup_file_hash_mismatch", "the downloaded proof-tools folder did not check out on disk; rerun setup");
+  mark("hash-check-end");
   if (existsSync(folder)) rmSync(folder, { recursive: true, force: true });
   renameSync(partial, folder);
   return Object.freeze({ dir, sumsSha256, folder, downloaded, ...toolPaths(folder) });
@@ -106231,6 +106333,18 @@ function facilitatorAnchor(origin, fetchImpl = fetch) {
     fail29(`anchor_refused_${response.status}`);
   };
 }
+function markedAnchorRequest(requestAnchor) {
+  return async () => {
+    markPhase("anchor-request-start");
+    try {
+      await requestAnchor();
+      markPhase("anchor-request-done");
+    } catch (error) {
+      markPhase("anchor-request-done", "refused");
+      throw error;
+    }
+  };
+}
 async function exitWhenAnchored(run5, { now = Date.now, sleep: sleep6 = (ms) => new Promise((resolve38) => setTimeout(resolve38, ms)), ring } = {}) {
   const deadline = now() + EXIT_ANCHOR_WAIT_MS;
   for (; ; ) {
@@ -106245,7 +106359,9 @@ async function exitWhenAnchored(run5, { now = Date.now, sleep: sleep6 = (ms) =>
       if (start + waitMs > deadline) throw error;
       const before = subAnchors ? await readRingBefore(ring, start) : void 0;
       progress(`your self-payment's note is spendable after the next pool anchor at ${new Date(anchorAt).toISOString().slice(11, 19)}Z; waiting ${Math.ceil(waitMs / 1e3)} s (nothing was signed for the exit): ${anchorWaitText(start)}; the exit then runs by itself`);
+      markPhase("anchor-wait-start");
       await sleepForAnchor(waitMs, { ring, before, now, sleep: sleep6 });
+      markPhase("anchor-wait-done");
     }
   }
 }
@@ -106452,6 +106568,7 @@ var init_cli2 = __esm({
     init_privateSend();
     init_promised();
     init_usdcWords();
+    init_phaseTiming();
     USAGE2 = "node --import tsx wallet/src/unshield/cli.mjs --wallet <encrypted-file> --passphrase-file <file> [--rpc-file <file>] --payer-proof-tools <manifest> --exit-proof-tools <manifest> --profile <public-profile.json> --program <address> --facilitator <https-origin> --unshield-id <id> --amount <atomic> --to <token-account> --recipient-owner <pubkey> [--history-rpc <own|url>] [--parts <1-8>] [--max-delay-minutes <0-60>]";
     REQUIRED2 = [
       "wallet",
@@ -117330,7 +117447,7 @@ async function runUnshield({
     recipientOwner: owner.toBase58(),
     allowForeignRecipient: true,
     relaySubmit: facilitatorExitRelay(facilitatorOrigin2),
-    requestAnchor: facilitatorAnchor(facilitatorOrigin2),
+    requestAnchor: markedAnchorRequest(facilitatorAnchor(facilitatorOrigin2)),
     deps: { walkHistory: walk(exitProofTools.deploymentIdentity) }
   }), { ring: { connection: session.connection, pool: store.state.pool } }));
   mark("unshield-exited");
@@ -117390,7 +117507,7 @@ async function runDirectExit({
       recipientOwner: owner.toBase58(),
       allowForeignRecipient: true,
       relaySubmit: facilitatorExitRelay(facilitatorOrigin2),
-      requestAnchor: facilitatorAnchor(facilitatorOrigin2),
+      requestAnchor: markedAnchorRequest(facilitatorAnchor(facilitatorOrigin2)),
       deps: { walkHistory: walk(exitProofTools.deploymentIdentity), proveExit }
     }), { ring: { connection: session.connection, pool: store.state.pool } }));
   } catch (error) {
@@ -146364,7 +146481,7 @@ init_cli();
 init_floatPay();
 import { randomBytes as randomBytes33 } from "node:crypto";
 import { dirname as dirname29, join as join36, resolve as resolve37 } from "node:path";
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { fileURLToPath as fileURLToPath22 } from "node:url";
 
 // wallet/src/fetch/index.mjs
@@ -146387,6 +146504,8 @@ init_recoveryFile();
 init_config2();
 init_proofTools();
 init_proxy();
+init_facilitatorOnion();
+init_timing();
 init_migration();
 init_successions();
 init_chain2();
@@ -146512,10 +146631,23 @@ function readPassphrase(path, access) {
 }
 async function runSetup(options, deps = {}) {
   const home = resolve26(options.home);
-  const onStage = options.onStage ?? (() => {
-  });
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const warnings = [];
+  const setupStartedAt = Date.now();
+  const heldMarks = [];
+  let writeMark;
+  const mark = (phase, outcome, at = Date.now()) => {
+    try {
+      if (writeMark) writeMark(phase, outcome, at);
+      else heldMarks.push([phase, outcome, at]);
+    } catch {
+    }
+  };
+  const onStage = (stage, detail) => {
+    if (stage !== "proof-tools" || detail === void 0) mark(`stage-${stage}`);
+    (options.onStage ?? (() => {
+    }))(stage, detail);
+  };
   onStage("platform");
   const platform = proverPlatform({ platform: deps.platform, hasWsl: deps.hasWsl });
   if (!platform.ok) throw fail40(platform.code, platform.detail);
@@ -146539,6 +146671,10 @@ async function runSetup(options, deps = {}) {
   } catch (error) {
     releaseError = error;
   }
+  mark("release-read", release ? void 0 : "failed");
+  const race = firstOnionRace(facilitator);
+  if (race !== void 0) mark("onion-race-start", void 0, race.startedAt);
+  if (race?.endedAt !== void 0) mark("onion-race-end", race.answered ? "answered" : "none", race.endedAt);
   let identity;
   if (release) {
     expected = await trustServedSet({ home, facilitator, release, expected, fetchImpl: deps.fetchImpl ?? fetch });
@@ -146708,19 +146844,56 @@ async function runSetup(options, deps = {}) {
   }
   const keep = old?.proofToolsRelease && old.pool === identity.pool ? { proofTools: old.proofTools, exitProofTools: old.exitProofTools, profile: old.profile, proofToolsRelease: old.proofToolsRelease } : {};
   writeSetupConfig(home, { ...base, ...keep });
+  try {
+    writeMark = (deps.timingLog ?? createTimingLog)(`${walletFile}.timing.log`, { component: "setup" }).start({ startedAt: setupStartedAt });
+    for (const [phase, outcome, at] of heldMarks.splice(0)) writeMark(phase, outcome, at);
+  } catch {
+  }
   onStage("proof-tools");
   let tools;
-  if (release) {
-    tools = await installProofTools({
-      facilitator,
-      toolsRoot: join30(home, "proof-tools"),
-      expected,
-      fetchImpl: deps.fetchImpl,
-      onProgress: (progress3) => onStage("proof-tools", progress3)
+  let warm;
+  let warmCode;
+  const warmAllowed = typeof deps.startWarm === "function" && !(tor && !inTorRun());
+  const startWarm = (proofToolsPath) => {
+    if (warm !== void 0 || !warmAllowed) return;
+    try {
+      warm = deps.startWarm({ walletFile, passphrase: passphrase2, proofToolsPath, program: identity.program, facilitator }) ?? null;
+    } catch {
+      warm = null;
+    }
+    if (!warm) return;
+    mark("attest-start");
+    warm.exited.then((code2) => {
+      if (warmCode !== void 0) return;
+      warmCode = code2;
+      mark("attest-end", code2 === 0 ? "ok" : `exit${code2}`);
+    }, () => {
     });
-  } else {
-    const folder = join30(home, "proof-tools", old.proofToolsRelease.dir);
-    tools = { ...old.proofToolsRelease, folder, downloaded: 0, ...toolPaths(folder) };
+  };
+  try {
+    if (release) {
+      tools = await installProofTools({
+        facilitator,
+        toolsRoot: join30(home, "proof-tools"),
+        expected,
+        fetchImpl: deps.fetchImpl,
+        onProgress: (progress3) => onStage("proof-tools", progress3),
+        mark: (phase, outcome) => mark(`tools-${phase}`, outcome),
+        onFileWritten: ({ path, file }) => {
+          if (path === "proof-tools.json") startWarm(file);
+        }
+      });
+    } else {
+      const folder = join30(home, "proof-tools", old.proofToolsRelease.dir);
+      tools = { ...old.proofToolsRelease, folder, downloaded: 0, ...toolPaths(folder) };
+    }
+  } finally {
+    if (warm && warmCode === void 0) {
+      warmCode = "stopped";
+      mark("attest-end", "stopped");
+      await Promise.resolve().then(() => warm.stop()).catch(() => {
+      });
+    }
   }
   onStage("config");
   const config = {
@@ -146744,10 +146917,200 @@ async function runSetup(options, deps = {}) {
     passphraseGenerated,
     proofTools: { dir: tools.dir, downloaded: tools.downloaded, folder: tools.folder },
     platform: platform.wsl ? "windows+wsl" : "linux",
-    warnings
+    warnings,
+    ...warmCode === 0 ? { firstBalanceReady: true } : {}
   });
 }
 
+// wallet/src/setup/setupWarm.mjs
+import { spawn as spawn5 } from "node:child_process";
+
+// wallet/src/history/keepWarm.mjs
+init_fs();
+init_chain2();
+init_proxy();
+init_recoveredPayment();
+init_rpcDefault();
+init_store();
+init_incremental();
+init_walletHistory();
+import { spawn as spawn4 } from "node:child_process";
+import { randomInt as randomInt7 } from "node:crypto";
+import { resolve as resolve27 } from "node:path";
+var KEEP_WARM_PARENT_ENV = "SHINJUKU_KEEP_WARM_PARENT";
+var KEEP_WARM_ONCE_PARENT_ENV = "SHINJUKU_KEEP_WARM_ONCE_PARENT";
+function watchSetupParentPipe({ stdin = process.stdin, exit = (code2) => process.exit(code2) } = {}) {
+  const parentGone = () => exit(1);
+  for (const event of ["end", "close", "error"]) stdin.on(event, parentGone);
+  stdin.resume();
+  return () => {
+    for (const event of ["end", "close", "error"]) stdin.off(event, parentGone);
+    stdin.destroy();
+  };
+}
+var KEEP_WARM_MIN_MS = 18e4;
+var KEEP_WARM_MAX_MS = 3e5;
+async function keepWarmOnce(values, { io, env = process.env }) {
+  const started = Date.now();
+  const walletPath2 = resolve27(values.get("--wallet"));
+  const passphrase2 = assertPassphrase(values.has("--passphrase-file") ? readFileSync(resolve27(values.get("--passphrase-file")), "utf8").trim() : String(env.SHIELDED_WALLET_PASSPHRASE ?? ""));
+  const store = openWalletStore(walletPath2, passphrase2);
+  const connection = connect2(resolveRpcUrl2({
+    rpcFile: values.get("--rpc-file"),
+    origin: values.get("--memo-service"),
+    readFile: (path) => readFileSync(resolve27(path), "utf8").trim()
+  }).url, "finalized");
+  const proofTools = loadP03PublicPaymentProofTools(resolve27(values.get("--proof-tools")));
+  await loadWalletP03History({
+    store,
+    connection: connectSplit(connection, historyRpcUrl(values.get("--history-rpc"))),
+    programId: values.get("--program"),
+    pool: store.state.pool,
+    deploymentIdentity: proofTools.deploymentIdentity,
+    forceRead: true
+  });
+  io.err(`keep-warm: the pool history is current (${((Date.now() - started) / 1e3).toFixed(1)} s); a payment in the next ${HISTORY_WARM_FRESH_MS / 6e4} minutes reads no pool history while the pool does not move
+`);
+}
+async function keepWarmMain(args, values, { io, env = process.env, entry } = {}) {
+  if (values.has("--once")) {
+    await keepWarmOnce(values, { io, env });
+    return 0;
+  }
+  if (typeof entry !== "string" || !entry) throw new Error("keep_warm_entry_missing");
+  const proxy = childRunProxy(env);
+  let stopped = false;
+  let child;
+  let wake;
+  const stop3 = () => {
+    stopped = true;
+    child?.kill("SIGTERM");
+    wake?.();
+  };
+  process.on("SIGINT", stop3);
+  process.on("SIGTERM", stop3);
+  if (env[KEEP_WARM_PARENT_ENV] === "1") {
+    process.stdin.on("end", stop3);
+    process.stdin.on("close", stop3);
+    process.stdin.on("error", stop3);
+    process.stdin.resume();
+  }
+  try {
+    while (!stopped) {
+      const code2 = await new Promise((done) => {
+        child = spawn4(process.execPath, [...process.execArgv, entry, ...proxy.args, "keep-warm", ...args, "--once"], {
+          env: proxy.env,
+          stdio: ["ignore", "ignore", "inherit"],
+          windowsHide: true
+        });
+        child.on("error", () => done(1));
+        child.on("exit", (exitCode) => done(exitCode ?? 1));
+      });
+      child = void 0;
+      if (stopped) break;
+      if (code2 !== 0) io.err(`keep-warm: this refresh failed (exit ${code2}); the next one runs at its usual time
+`);
+      const gap = randomInt7(KEEP_WARM_MIN_MS, KEEP_WARM_MAX_MS + 1);
+      io.err(`keep-warm: next refresh in ${Math.round(gap / 1e3)} s (stop with Ctrl-C)
+`);
+      await new Promise((done) => {
+        const timer = setTimeout(done, gap);
+        wake = () => {
+          clearTimeout(timer);
+          done();
+        };
+      });
+      wake = void 0;
+    }
+  } finally {
+    process.off("SIGINT", stop3);
+    process.off("SIGTERM", stop3);
+  }
+  return 0;
+}
+
+// wallet/src/setup/setupWarm.mjs
+init_proxy();
+var SETUP_WARM_STOP_WAIT_MS = 5e3;
+function killProcessTree(child, { platform = process.platform, run: run5 = spawn5 } = {}) {
+  if (!Number.isSafeInteger(child?.pid)) return;
+  if (platform === "win32") {
+    try {
+      const killer = run5("taskkill", ["/T", "/F", "/PID", String(child.pid)], { windowsHide: true, stdio: "ignore" });
+      killer?.on?.("error", () => {
+      });
+      killer?.unref?.();
+    } catch {
+    }
+    return;
+  }
+  try {
+    child.kill("SIGTERM");
+  } catch {
+  }
+}
+function startSetupWarm({
+  entry,
+  walletFile,
+  passphrase: passphrase2,
+  passphraseEnv,
+  proofToolsPath,
+  program,
+  facilitator,
+  env = process.env,
+  spawnImpl = spawn5,
+  killTree = killProcessTree
+}) {
+  const proxy = childRunProxy(env);
+  const child = spawnImpl(process.execPath, [
+    ...process.execArgv,
+    entry,
+    ...proxy.args,
+    "keep-warm",
+    "--once",
+    "--wallet",
+    walletFile,
+    "--proof-tools",
+    proofToolsPath,
+    "--program",
+    program,
+    "--memo-service",
+    facilitator
+  ], {
+    env: { ...proxy.env, [passphraseEnv]: passphrase2, [KEEP_WARM_ONCE_PARENT_ENV]: "1" },
+    stdio: ["pipe", "ignore", "ignore"],
+    windowsHide: true
+  });
+  let ended = false;
+  const exited = new Promise((resolve38) => {
+    child.on("error", () => {
+      ended = true;
+      resolve38(1);
+    });
+    child.on("exit", (code2) => {
+      ended = true;
+      resolve38(code2 ?? 1);
+    });
+  });
+  child.stdin?.on?.("error", () => {
+  });
+  return {
+    exited,
+    async stop() {
+      try {
+        child.stdin?.end?.();
+      } catch {
+      }
+      if (!ended) killTree(child);
+      let timer;
+      await Promise.race([exited, new Promise((resolve38) => {
+        timer = setTimeout(resolve38, SETUP_WARM_STOP_WAIT_MS);
+      })]);
+      clearTimeout(timer);
+    }
+  };
+}
+
 // wallet/src/cli/shinjukuWallet.mjs
 init_channel();
 init_family();
@@ -146777,7 +147140,7 @@ init_proxy();
 init_rpcDefault();
 init_secretFile();
 init_serviceUrl();
-import { resolve as resolve27 } from "node:path";
+import { resolve as resolve28 } from "node:path";
 import { fileURLToPath as fileURLToPath19 } from "node:url";
 var USAGE3 = "shinjuku-wallet merge --wallet <encrypted-file> --passphrase-file <file> --program <address> [--dry-run] [--rpc-file <file>] --proof-tools <manifest> --profile <public-profile.json> --facilitator <https-origin> [--history-rpc <own|url>]";
 var VALUED = ["wallet", "passphrase-file", "program", "rpc-file", "proof-tools", "profile", "facilitator", "history-rpc"];
@@ -146820,8 +147183,8 @@ async function main5(args = process.argv.slice(2)) {
   const origin = dryRun ? void 0 : new URL(options.facilitator);
   if (origin && (origin.protocol !== "https:" && !isOnionOrigin(origin) || origin.pathname !== "/" || origin.search)) fail41("facilitator_origin_invalid");
   const historyUrl = historyRpcUrl(options["history-rpc"]);
-  const walletPath2 = resolve27(options.wallet);
-  const passphrase2 = assertPassphrase(readSecretText(resolve27(options["passphrase-file"]), "--passphrase-file"));
+  const walletPath2 = resolve28(options.wallet);
+  const passphrase2 = assertPassphrase(readSecretText(resolve28(options["passphrase-file"]), "--passphrase-file"));
   let release;
   try {
     release = await acquireWalletProcessLease(walletLockPath(walletPath2));
@@ -146840,13 +147203,13 @@ async function main5(args = process.argv.slice(2)) {
         const connection = connect2(resolveRpcUrl2({
           rpcFile: options["rpc-file"],
           origin: origin.origin,
-          readFile: (path) => readFileSync(resolve27(path), "utf8").trim()
+          readFile: (path) => readFileSync(resolve28(path), "utf8").trim()
         }).url, "finalized");
-        const proofTools = loadP03PublicPaymentProofTools(resolve27(options["proof-tools"]));
+        const proofTools = loadP03PublicPaymentProofTools(resolve28(options["proof-tools"]));
         steps = {
           connection,
           proofTools,
-          profile: JSON.parse(readFileSync(resolve27(options.profile), "utf8")),
+          profile: JSON.parse(readFileSync(resolve28(options.profile), "utf8")),
           timing: createTimingLog(`${walletPath2}.timing.log`, { component: "payer" })
         };
       }
@@ -146944,7 +147307,7 @@ async function main5(args = process.argv.slice(2)) {
     await release();
   }
 }
-if (process.argv[1] && resolve27(process.argv[1]) === fileURLToPath19(new URL("__bundled_source__/wallet/src/merge/cli.mjs", import.meta.url).href)) {
+if (process.argv[1] && resolve28(process.argv[1]) === fileURLToPath19(new URL("__bundled_source__/wallet/src/merge/cli.mjs", import.meta.url).href)) {
   main5().catch((error) => {
     console.error(describeCliErrorWithHint(error));
     process.exitCode = 1;
@@ -146953,7 +147316,7 @@ if (process.argv[1] && resolve27(process.argv[1]) === fileURLToPath19(new URL("_
 
 // wallet/src/item/buyItem.mjs
 init_fs();
-import { resolve as resolve28 } from "node:path";
+import { resolve as resolve29 } from "node:path";
 
 // src/shared/blindVoucher.ts
 init_sha256();
@@ -147445,8 +147808,8 @@ async function main6(args = process.argv.slice(2)) {
   }
   if (REQUIRED3.some((key) => !options[key])) throw new Error("p03_item_cli_arguments_missing");
   const historyUrl = historyRpcUrl(options["history-rpc"]);
-  const walletPath2 = resolve28(options.wallet);
-  const passphrase2 = assertPassphrase(readSecretText(resolve28(options["passphrase-file"]), "--passphrase-file"));
+  const walletPath2 = resolve29(options.wallet);
+  const passphrase2 = assertPassphrase(readSecretText(resolve29(options["passphrase-file"]), "--passphrase-file"));
   const timing = createTimingLog(`${walletPath2}.timing.log`, { component: "payer" }).start({ startedAt: performance.timeOrigin });
   timing("process-start", void 0, performance.timeOrigin);
   if (proxyProvenAt() !== void 0) timing("proxy-proven", void 0, proxyProvenAt());
@@ -147463,15 +147826,15 @@ async function main6(args = process.argv.slice(2)) {
     const connection = connect2(resolveRpcUrl2({
       rpcFile: options["rpc-file"],
       origin: options["memo-service"],
-      readFile: (path) => readFileSync(resolve28(path), "utf8").trim()
+      readFile: (path) => readFileSync(resolve29(path), "utf8").trim()
     }).url, "finalized");
     const earlySource = resolveHistorySource(connectSplit(connection, historyUrl), store.state.pool);
     if (earlySource.source === "pinned") earlySource.connection.historyRpcWarm?.();
     connection.getSlot("finalized").catch(() => {
     });
-    const proofTools = loadP03PublicPaymentProofTools(resolve28(options["proof-tools"]));
+    const proofTools = loadP03PublicPaymentProofTools(resolve29(options["proof-tools"]));
     timing("proof-tools");
-    const playToken = options["play-token-file"] ? readFileSync(resolve28(options["play-token-file"]), "utf8").trim() : void 0;
+    const playToken = options["play-token-file"] ? readFileSync(resolve29(options["play-token-file"]), "utf8").trim() : void 0;
     if (playToken !== void 0 && !/^sjp_[A-Za-z0-9_-]{16,200}$/.test(playToken)) throw new Error("p03_item_play_token_invalid");
     const walkHistory = async () => {
       const history = await loadWalletP03History({
@@ -147518,100 +147881,6 @@ async function main6(args = process.argv.slice(2)) {
   }
 }
 
-// wallet/src/history/keepWarm.mjs
-init_fs();
-init_chain2();
-init_proxy();
-init_recoveredPayment();
-init_rpcDefault();
-init_store();
-init_incremental();
-init_walletHistory();
-import { spawn as spawn4 } from "node:child_process";
-import { randomInt as randomInt7 } from "node:crypto";
-import { resolve as resolve29 } from "node:path";
-var KEEP_WARM_PARENT_ENV = "SHINJUKU_KEEP_WARM_PARENT";
-var KEEP_WARM_MIN_MS = 18e4;
-var KEEP_WARM_MAX_MS = 3e5;
-async function keepWarmOnce(values, { io, env = process.env }) {
-  const started = Date.now();
-  const walletPath2 = resolve29(values.get("--wallet"));
-  const passphrase2 = assertPassphrase(values.has("--passphrase-file") ? readFileSync(resolve29(values.get("--passphrase-file")), "utf8").trim() : String(env.SHIELDED_WALLET_PASSPHRASE ?? ""));
-  const store = openWalletStore(walletPath2, passphrase2);
-  const connection = connect2(resolveRpcUrl2({
-    rpcFile: values.get("--rpc-file"),
-    origin: values.get("--memo-service"),
-    readFile: (path) => readFileSync(resolve29(path), "utf8").trim()
-  }).url, "finalized");
-  const proofTools = loadP03PublicPaymentProofTools(resolve29(values.get("--proof-tools")));
-  await loadWalletP03History({
-    store,
-    connection: connectSplit(connection, historyRpcUrl(values.get("--history-rpc"))),
-    programId: values.get("--program"),
-    pool: store.state.pool,
-    deploymentIdentity: proofTools.deploymentIdentity,
-    forceRead: true
-  });
-  io.err(`keep-warm: the pool history is current (${((Date.now() - started) / 1e3).toFixed(1)} s); a payment in the next ${HISTORY_WARM_FRESH_MS / 6e4} minutes reads no pool history while the pool does not move
-`);
-}
-async function keepWarmMain(args, values, { io, env = process.env, entry } = {}) {
-  if (values.has("--once")) {
-    await keepWarmOnce(values, { io, env });
-    return 0;
-  }
-  if (typeof entry !== "string" || !entry) throw new Error("keep_warm_entry_missing");
-  const proxy = childRunProxy(env);
-  let stopped = false;
-  let child;
-  let wake;
-  const stop3 = () => {
-    stopped = true;
-    child?.kill("SIGTERM");
-    wake?.();
-  };
-  process.on("SIGINT", stop3);
-  process.on("SIGTERM", stop3);
-  if (env[KEEP_WARM_PARENT_ENV] === "1") {
-    process.stdin.on("end", stop3);
-    process.stdin.on("close", stop3);
-    process.stdin.on("error", stop3);
-    process.stdin.resume();
-  }
-  try {
-    while (!stopped) {
-      const code2 = await new Promise((done) => {
-        child = spawn4(process.execPath, [...process.execArgv, entry, ...proxy.args, "keep-warm", ...args, "--once"], {
-          env: proxy.env,
-          stdio: ["ignore", "ignore", "inherit"],
-          windowsHide: true
-        });
-        child.on("error", () => done(1));
-        child.on("exit", (exitCode) => done(exitCode ?? 1));
-      });
-      child = void 0;
-      if (stopped) break;
-      if (code2 !== 0) io.err(`keep-warm: this refresh failed (exit ${code2}); the next one runs at its usual time
-`);
-      const gap = randomInt7(KEEP_WARM_MIN_MS, KEEP_WARM_MAX_MS + 1);
-      io.err(`keep-warm: next refresh in ${Math.round(gap / 1e3)} s (stop with Ctrl-C)
-`);
-      await new Promise((done) => {
-        const timer = setTimeout(done, gap);
-        wake = () => {
-          clearTimeout(timer);
-          done();
-        };
-      });
-      wake = void 0;
-    }
-  } finally {
-    process.off("SIGINT", stop3);
-    process.off("SIGTERM", stop3);
-  }
-  return 0;
-}
-
 // wallet/src/cli/shinjukuWallet.mjs
 init_cli3();
 
@@ -149809,7 +150078,7 @@ init_deposit();
 init_fs();
 init_balance();
 init_deposit();
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import { randomBytes as randomBytes25, randomInt as randomInt9 } from "node:crypto";
 import { tmpdir as tmpdir4 } from "node:os";
 import { join as join33, resolve as resolve31 } from "node:path";
@@ -150064,7 +150333,7 @@ async function runStep(ctx, argv2) {
   const file = join33(ctx.tempDir, `step-${randomBytes25(8).toString("hex")}.json`);
   const held = [];
   let last;
-  const proc = spawn5(process.execPath, [...process.execArgv, ctx.entry, ...ctx.proxyArgs, ...argv2], {
+  const proc = spawn6(process.execPath, [...process.execArgv, ctx.entry, ...ctx.proxyArgs, ...argv2], {
     env: { ...ctx.childEnv, [RESULT_FILE_ENV]: file },
     stdio: ["ignore", "ignore", "pipe"],
     windowsHide: true
@@ -151557,7 +151826,7 @@ function startKeepWarm(options, env = process.env) {
     options.memoServiceUrl,
     ...options.historyRpc ? ["--history-rpc", options.historyRpc] : []
   ];
-  const child = spawn6(process.execPath, [...process.execArgv, CLI_FILE, ...proxy.args, ...warmArgs], {
+  const child = spawn7(process.execPath, [...process.execArgv, CLI_FILE, ...proxy.args, ...warmArgs], {
     env: {
       ...proxy.env,
       [PASSPHRASE_ENV2]: options.passphrase,
@@ -151577,6 +151846,11 @@ function startKeepWarm(options, env = process.env) {
   });
   return child;
 }
+function setupWarmStarter(deps) {
+  if (deps.startSetupWarm) return deps.startSetupWarm;
+  if (!process.argv[1] || resolve37(process.argv[1]) !== CLI_FILE) return void 0;
+  return (options) => startSetupWarm({ ...options, entry: CLI_FILE, passphraseEnv: PASSPHRASE_ENV2, env: deps.env ?? process.env });
+}
 function mcpServerOptions(values, deps) {
   const options = payerSessionOptions(values, deps);
   let pool2;
@@ -152143,7 +152417,7 @@ Copy it to two offline places now; it is the only way to restore this wallet.
       lastStage = stage;
       io.err(`${STAGE_TEXT[stage]}...
 `);
-    } }, setupDependencies(deps), inference);
+    } }, { ...setupDependencies(deps), startWarm: setupWarmStarter(deps) }, inference);
   } catch (error) {
     if (/^(setup_[a-z_]+|secret_file_utf16): /.test(String(error?.message))) throw new PublicFailure(error.message);
     throw error;
@@ -152154,7 +152428,9 @@ Copy it to two offline places now; it is the only way to restore this wallet.
     `  limits       ${capText(summary.caps.maxPayment, usdcText3)} per payment, ${capText(summary.caps.maxSession, usdcText3)} in any 24 hours, ${capText(summary.caps.maxTotal, usdcText3)} for the life of the wallet${summary.tor ? "; Tor on" : ""}`,
     `  config       ${summary.configPath}`,
     `  passphrase   ${summary.passphraseFile}${summary.passphraseGenerated ? " (a new random passphrase; only you can read the file; it is never printed)" : ""}`,
-    `  proof tools  ${summary.proofTools.folder} (${summary.proofTools.downloaded ? `${summary.proofTools.downloaded} files downloaded, every hash checked` : "already here, every hash checked"})`
+    `  proof tools  ${summary.proofTools.folder} (${summary.proofTools.downloaded ? `${summary.proofTools.downloaded} files downloaded, every hash checked` : "already here, every hash checked"})`,
+    // The setup warm ended well (setup/setupWarm.mjs); nothing is said when it did not.
+    ...summary.firstBalanceReady ? ["  balance      prepared during setup: your first balance after a deposit shows sooner"] : []
   ];
   if (summary.wallet.status === "created") {
     lines.push(
@@ -155254,8 +155530,11 @@ ${sellerLine}${landedLine}${whyLine}${ambiguousLine}${blockingLine}${hint ? `hin
 // wallet/bin/shinjuku-wallet.mjs
 init_proxy();
 var argv = process.argv.slice(2);
+var wrapper = runNetworkMode() === null && (argv.includes("--tor") || argv.includes("--proxy"));
+var stopSetupWatch = process.env[KEEP_WARM_ONCE_PARENT_ENV] === "1" && !wrapper ? watchSetupParentPipe() : void 0;
 var mcpRefused = async (options) => (await Promise.resolve().then(() => (init_torMissingMcp(), torMissingMcp_exports))).serveTorMissingMcp(options);
 var code = isHelpRequest(argv) ? await runShinjukuWallet(argv) : await proxyEntry(argv, runShinjukuWallet, { mcpRefused });
+stopSetupWatch?.();
 process.exitCode = code;
 if (code !== 0) setTimeout(() => process.exit(code), 2e3).unref();
 else if (mcpServerEndedHere()) setTimeout(() => process.exit(code), 0).unref();