@deeeed/metamask-harness 0.86.1 → 0.87.0

package/dist/adapters/mobile/ui.js

@@ -109,6 +109,85 @@ function isRetryableMobileWaitError(error) {
     isRecord(error) && typeof error.code === "string" && RETRYABLE_MOBILE_WAIT_CODES.has(error.code)
   );
 }
+function hiddenRouteExpression(testId) {
+  return `(function(){
+    const hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    if (!hook || !hook.getFiberRoots) return null;
+    const hiddenAt = (props, routeKey) => {
+      const state = props.state;
+      const index = state.routes.findIndex((route) => route && route.key === routeKey);
+      if (index < 0 || typeof state.index !== 'number') return false;
+      if (state.type === 'tab') return index !== state.index;
+      if (state.type !== 'stack') return false;
+      // Mirror native-stack's getModalRouteKeys: an unset presentation after
+      // any modal-family screen is a modal too. On iOS a card pushed after a
+      // modal goes under it, so nothing hides a modal target.
+      const modal = [];
+      for (let position = 0; position <= state.index; position += 1) {
+        const descriptor = props.descriptors[state.routes[position].key];
+        if (!descriptor || !descriptor.options) return false;
+        const presentation = descriptor.options.presentation;
+        modal.push(presentation === undefined || presentation === null
+          ? modal.includes(true)
+          : !['card', 'push'].includes(presentation));
+      }
+      if (modal[index]) return false;
+      for (let above = index + 1; above <= state.index; above += 1) {
+        if (!modal[above]) return true;
+      }
+      return false;
+    };
+    const onHiddenRoute = (fiber) => {
+      let routeKey;
+      for (let owner = fiber.return; owner; owner = owner.return) {
+        const props = owner.memoizedProps;
+        if (!props) continue;
+        if (props.route && typeof props.route.key === 'string') routeKey = props.route.key;
+        if (routeKey && props.descriptors && props.state && Array.isArray(props.state.routes)
+          && hiddenAt(props, routeKey)) return true;
+      }
+      return false;
+    };
+    let matches = 0;
+    let hidden = 0;
+    const visit = (fiber) => {
+      for (; fiber; fiber = fiber.sibling) {
+        if (fiber.memoizedProps && fiber.memoizedProps.testID === ${JSON.stringify(testId)}) {
+          matches += 1;
+          try {
+            if (onHiddenRoute(fiber)) hidden += 1;
+          } catch (error) {
+            // An unreadable navigator counts as visible: never a false absent.
+          }
+        }
+        visit(fiber.child);
+      }
+    };
+    const roots = new Set();
+    for (const id of hook.renderers.keys()) (hook.getFiberRoots(id) || []).forEach((root) => roots.add(root));
+    roots.forEach((root) => visit(root.current));
+    return { matches, hidden };
+  })()`;
+}
+const NATIVE_READ_BUDGET_MS = 2500;
+async function hiddenRouteOnly(input, probeInput, payload, testId, deadline) {
+  const routes = await evalSync(probeInput, hiddenRouteExpression(testId));
+  if (!isRecord(routes) || Number(routes.matches) < 1 || routes.hidden !== routes.matches) return null;
+  const remainingMs = deadline - Date.now();
+  if (remainingMs < NATIVE_READ_BUDGET_MS) return null;
+  let timer;
+  const observed = await Promise.race([
+    observeNativeUi({ refs: ["ui.visible"], node: payload }, input.context),
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve(null), remainingMs);
+    })
+  ]).finally(() => clearTimeout(timer));
+  if (!isRecord(observed) || Array.isArray(observed.warnings) && observed.warnings.length > 0) return null;
+  const visible = isRecord(observed.observations) ? observed.observations["ui.visible"] : void 0;
+  if (!isRecord(visible) || !Array.isArray(visible.items) || visible.truncated === true) return null;
+  const nativeVisible = visible.items.some((item) => isRecord(item) && item.test_id === testId && item.visible !== false);
+  return nativeVisible ? null : { hiddenRoute: true, nativeVisible: false };
+}
 async function waitForMobileTarget(input, payload) {
   const timeoutMs = Number(payload.timeout_ms ?? payload.timeoutMs ?? 1e4);
   const deadline = Date.now() + timeoutMs;
@@ -162,8 +241,22 @@ async function waitForMobileTarget(input, payload) {
       );
     }
     lastResult = result;
-    const present = result.present === true;
-    const visible = result.visible === true;
+    let present = result.present === true;
+    let visible = result.visible === true;
+    let cachedRoute = null;
+    if (expectsAbsent && present && testId && visibility === "tree") {
+      try {
+        cachedRoute = await hiddenRouteOnly(input, probeInput, payload, testId, deadline);
+      } catch (error) {
+        if (!isRetryableMobileWaitError(error)) throw error;
+        lastBridgeError = error;
+      }
+      if (cachedRoute) {
+        present = false;
+        visible = false;
+        lastResult = { ...result, ...cachedRoute };
+      }
+    }
     let textMatched = !expectedText || textMatch === "contains";
     if (expectedText && textMatch === "exact" && textExpression) {
       try {
@@ -186,6 +279,7 @@ async function waitForMobileTarget(input, payload) {
         present,
         visible,
         visibility,
+        ...cachedRoute ?? {},
         ...isRecord(result.rect) ? { rect: result.rect } : {}
       };
     }

package/dist/adapters/perps-order-inputs.js

@@ -1,35 +1,50 @@
+const ORDER_INPUTS = [
+  [["market", "symbol"], "market=<symbol> (or symbol=<symbol>)"],
+  [["side"], "side=long or side=short"],
+  [["amount", "notional"], "amount=<usd> or notional=<usd>"]
+];
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function opensState(value) {
+  const state = typeof value === "string" ? value.toLowerCase() : void 0;
+  return state === "open" || state === "present";
+}
+function hasValue(source, names) {
+  return names.some((name) => {
+    const value = source[name];
+    return value !== void 0 && value !== null && value !== "";
+  });
+}
+function missingOrderInputs(label, has, pathFor) {
+  return ORDER_INPUTS.filter(([names]) => !has(names)).map(([names, wanted]) => ({
+    severity: "error",
+    code: "recipe.missing_param",
+    path: pathFor(names[0]),
+    message: `${label} requires ${wanted} before it may create an order`
+  }));
+}
 function perpsOrderInputFindings(nodeId, node, { ensureChecksOnly }) {
   const action = node.action;
-  const state = typeof node.state === "string" ? node.state.toLowerCase() : void 0;
-  const createsOrder = action === "metamask.perps.place_order" || !ensureChecksOnly && (action === "metamask.perps.ensure_positions" || action === "metamask.perps.ensure_orders") && (state === "open" || state === "present");
-  if (!createsOrder) return [];
-  const findings = [];
-  const requireOneOf = (names, message) => {
-    const present = names.some((name) => {
-      const value = node[name];
-      return value !== void 0 && value !== null && value !== "";
+  if (action === "metamask.perps.start_state") {
+    if (ensureChecksOnly) return [];
+    return ["positions", "orders"].flatMap((key) => {
+      const block = node[key];
+      if (!isRecord(block) || !opensState(block.state)) return [];
+      return missingOrderInputs(
+        `${action} ${key}.state=${String(block.state)}`,
+        (names) => hasValue(block, names) || names[0] !== "amount" && hasValue(node, names),
+        (name) => `workflow.nodes.${nodeId}.${key}.${name}`
+      );
     });
-    if (present) return;
-    findings.push({
-      severity: "error",
-      code: "recipe.missing_param",
-      path: `workflow.nodes.${nodeId}.${names[0]}`,
-      message
-    });
-  };
-  requireOneOf(
-    ["market", "symbol"],
-    `${action} requires market=<symbol> (or symbol=<symbol>) before it may create an order`
-  );
-  requireOneOf(
-    ["side"],
-    `${action} requires side=long or side=short before it may create an order`
-  );
-  requireOneOf(
-    ["amount", "notional"],
-    `${action} requires amount=<usd> or notional=<usd> before it may create an order`
+  }
+  const createsOrder = action === "metamask.perps.place_order" || !ensureChecksOnly && (action === "metamask.perps.ensure_positions" || action === "metamask.perps.ensure_orders") && opensState(node.state);
+  if (!createsOrder) return [];
+  return missingOrderInputs(
+    String(action),
+    (names) => hasValue(node, names),
+    (name) => `workflow.nodes.${nodeId}.${name}`
   );
-  return findings;
 }
 export {
   perpsOrderInputFindings

package/dist/adapters.js

@@ -118,7 +118,10 @@ async function runLiveFirst(platform, action, node, context, forceLive = false,
     platform,
     action,
     namespace: LIBRARY_ACTION_NAMESPACE,
-    node: withImmediateCloseBudget(action, node),
+    node: withImmediateCloseBudget(
+      action,
+      await getAdapterSurface(platform).actions.liveProcessNode?.(action, node, { ...process.env, ...context.env }) ?? node
+    ),
     context,
     prepared: preparedLiveAdapters?.get(action),
     contextExtras: trustedMutationContextExtras(context),

package/dist/commands/doctor.js

@@ -85,11 +85,14 @@ async function handleDoctor({ options }) {
     } catch (error2) {
       runtimeProbeError2 = error2 instanceof Error ? error2.message : String(error2);
     }
-    const ready = runtime2?.decision === "ready";
+    const recorder2 = runtime2?.decision === "ready" ? await readiness.recorder?.() : void 0;
+    const ready2 = doctorReady(runtime2, recorder2);
     const block = readiness.runtimeBlock?.(target, runtime2);
     if (block) failed.push(block.id);
+    if (recorder2?.status === "fail") failed.push(recorder2.id);
     const nextActions = doctorFixNextActions(failed, result2.fixture, adapter, target, block);
-    if (failed.length === 0 && !ready && runtime2?.nextAction) nextActions.push(runtime2.nextAction);
+    if (recorder2?.status === "fail" && recorder2.userAction) nextActions.push(recorder2.userAction);
+    if (failed.length === 0 && runtime2?.decision !== "ready" && runtime2?.nextAction) nextActions.push(runtime2.nextAction);
     const status = result2.status === "pass" && failed.length === 0 ? "pass" : "fail";
     const retryDoctor = `mm-harness doctor --fix --adapter ${adapter} --target ${shellQuote(target)} --json`;
     const fixUserAction = failed.includes("wallet-fixture") ? `choose one wallet fixture source from nextActions, run it, then retry: ${retryDoctor}` : nextActions[0] ?? retryDoctor;
@@ -98,15 +101,16 @@ async function handleDoctor({ options }) {
       message: "doctor --fix could not make every required check pass",
       userAction: fixUserAction
     } : void 0;
-    if (json) console.log(JSON.stringify({ ...result2, status, fixed, failed, ready, runtime: runtime2, ...runtimeProbeError2 ? { runtimeProbeError: runtimeProbeError2 } : {}, nextActions, ...error ? { error } : {} }, null, 2));
+    if (json) console.log(JSON.stringify({ ...result2, status, fixed, failed, ready: ready2, runtime: runtime2, ...recorder2 ? { recorder: recorder2 } : {}, ...runtimeProbeError2 ? { runtimeProbeError: runtimeProbeError2 } : {}, nextActions, ...error ? { error } : {} }, null, 2));
     else {
-      console.log(`${status} ${adapter} ${result2.compatibilityMode} ready=${ready} manifest=${actionManifestPath} fixed=[${fixed.join(",")}] failed=[${failed.join(",")}]`);
+      console.log(`${status} ${adapter} ${result2.compatibilityMode} ready=${ready2} manifest=${actionManifestPath} fixed=[${fixed.join(",")}] failed=[${failed.join(",")}]`);
       if (runtime2) {
         console.log(`runtime: decision=${runtime2.decision}${runtime2.reasonCode ? ` (${runtime2.reasonCode})` : ""}`);
         for (const reason of runtime2.reasons) console.log(`  ${reason}`);
       } else if (runtimeProbeError2) {
         console.log(`runtime probe failed: ${runtimeProbeError2}`);
       }
+      if (recorder2) console.log(`recorder: ${recorder2.status} ${recorder2.message}`);
       for (const action of nextActions) console.error(`  Next: ${action}`);
     }
     return status === "pass" ? 0 : 1;
@@ -154,10 +158,12 @@ async function handleDoctor({ options }) {
     runtimeProbeError = error instanceof Error ? error.message : String(error);
   }
   const runtimeCheck = doctorRuntimeCheck(runtime, runtimeProbeError, expectLive);
+  const recorder = runtime?.decision === "ready" ? await readiness.recorder?.() : void 0;
   const checks = [
     ...result.checks,
     runtimeCheck,
     ...await readiness.liveChecks?.(target) ?? [],
+    ...recorder ? [recorder] : [],
     ...await platformDoctorChecks(adapter, target),
     // Which library plugin code this process loaded: library, module and digest.
     ...adapterPluginChecks()
@@ -182,6 +188,7 @@ async function handleDoctor({ options }) {
       adapter,
       target,
       runtime,
+      recorder,
       doctorResult,
       orphanMetros,
       capture,
@@ -201,7 +208,8 @@ async function handleDoctor({ options }) {
   )?.userAction ?? `mm-harness doctor --fix --adapter ${adapter} --target ${shellQuote(target)} --json`;
   const doctorError = doctorResult.status === "fail" ? { code: "DOCTOR_CHECKS_FAILED", message: "one or more required doctor checks failed", userAction: doctorUserAction } : void 0;
   const next = doctorError?.userAction ?? discovery.deviceDiscoveryErrors?.[0]?.userAction ?? (runtime?.decision === "ready" ? void 0 : runtime?.nextAction);
-  if (json) console.log(JSON.stringify({ ...doctorResult, ready: runtime?.decision === "ready", runtime, view, orphanMetros, capture, skills, update, featureFlags, devices, additionalReachableDevices, ...discovery, ...next ? { next } : {}, ...doctorError ? { error: doctorError } : {} }, null, 2));
+  const ready = doctorReady(runtime, recorder);
+  if (json) console.log(JSON.stringify({ ...doctorResult, ready, runtime, ...recorder ? { recorder } : {}, view, orphanMetros, capture, skills, update, featureFlags, devices, additionalReachableDevices, ...discovery, ...next ? { next } : {}, ...doctorError ? { error: doctorError } : {} }, null, 2));
   else {
     const out = (style, text) => color(style, text, { stream: process.stdout });
     const stateStyle = (value, good) => value === good ? "ok" : "warn";
@@ -222,6 +230,7 @@ async function handleDoctor({ options }) {
     } else if (runtimeProbeError) {
       console.log(`${out("err", "runtime probe failed:")} ${out("dim", runtimeProbeError)}`);
     }
+    if (recorder) console.log(`${out("label", "recorder:")} ${out(recorder.status === "pass" ? "ok" : "err", recorder.status)} ${recorder.message}`);
     console.log(renderCheckoutView(view));
     console.log(`${out("label", "feature flags:")} ${out(
       featureFlags.error || (featureFlags.overrideCount ?? 0) > 0 ? "warn" : "dim",
@@ -246,6 +255,9 @@ async function handleDoctor({ options }) {
   }
   return doctorResult.status === "pass" ? 0 : 1;
 }
+function doctorReady(runtime, recorder) {
+  return runtime?.decision === "ready" && recorder?.status !== "fail";
+}
 async function platformDoctorChecks(adapter, target) {
   try {
     return await getAdapterSurface(adapter).doctor?.(target) ?? [];
@@ -297,17 +309,23 @@ function doctorFixNextActions(failed, fixture, adapter, target, block) {
   if (block?.userAction && failed.includes(block.id)) actions.push(block.userAction);
   return actions;
 }
-function emitExpectLiveVerdict(adapter, target, runtime, verdict) {
+function emitExpectLiveVerdict(adapter, target, runtime, verdict, recorder) {
   const out = (style, text) => color(style, text, { stream: process.stderr });
   const detail = runtime ? `${runtime.decision}${runtime.reasonCode ? ` (${runtime.reasonCode})` : ""}` : "runtime probe unavailable";
   console.error(`${out("err", verdict)} ${out("bold", adapter)} ${detail} ${out("dim", target)}`);
   for (const reason of runtime?.reasons ?? []) console.error(`  ${out("dim", reason)}`);
+  if (recorder?.status === "fail") {
+    console.error(`  ${out("err", "recorder:")} ${recorder.message}${recorder.detail ? ` ${out("dim", recorder.detail)}` : ""}`);
+    console.error(`  Next: ${recorder.userAction}`);
+    return;
+  }
   console.error(`  Next: ${runtime?.nextAction ?? getAdapterSurface(adapter).hints.runtimeProbeRecovery(target)}`);
 }
-function emitExpectLive(adapter, target, runtime, result, orphanMetros, capture, devices, additionalReachableDevices, json, printReady, discovery) {
+function emitExpectLive(adapter, target, runtime, recorder, result, orphanMetros, capture, devices, additionalReachableDevices, json, printReady, discovery) {
   const live = runtime?.decision === "ready";
+  const ready = doctorReady(runtime, recorder);
   if (printReady) {
-    if (live) {
+    if (ready) {
       const indicator = farmslotReadyIndicator(adapter, devices);
       if (indicator) {
         console.log(indicator);
@@ -316,21 +334,21 @@ function emitExpectLive(adapter, target, runtime, result, orphanMetros, capture,
       emitExpectLiveVerdict(adapter, target, runtime, "not-ready");
       return EXIT.runtime;
     }
-    emitExpectLiveVerdict(adapter, target, runtime, "not-live");
+    emitExpectLiveVerdict(adapter, target, runtime, live ? "not-ready" : "not-live", recorder);
     return EXIT.runtime;
   }
   if (json) {
     const userAction = runtime?.nextAction ?? getAdapterSurface(adapter).hints.runtimeProbeRecovery(target);
-    const error = live ? void 0 : { code: "RUNTIME_NOT_LIVE", message: `${adapter} runtime is not live`, userAction };
-    console.log(JSON.stringify({ ...result, ready: live, runtime, orphanMetros, capture, devices, additionalReachableDevices, ...discovery, ...error ? { error } : {} }, null, 2));
-    return live ? EXIT.ok : EXIT.runtime;
+    const error = !live ? { code: "RUNTIME_NOT_LIVE", message: `${adapter} runtime is not live`, userAction } : !ready ? { code: "RECORDER_UNAVAILABLE", message: recorder.message, userAction: recorder.userAction } : void 0;
+    console.log(JSON.stringify({ ...result, ready, runtime, ...recorder ? { recorder } : {}, orphanMetros, capture, devices, additionalReachableDevices, ...discovery, ...error ? { error } : {} }, null, 2));
+    return ready ? EXIT.ok : EXIT.runtime;
   }
   const out = (style, text) => color(style, text, { stream: process.stdout });
-  if (live) {
+  if (ready) {
     console.log(`${out("ok", "live")} ${out("bold", adapter)} runtime ready`);
     return EXIT.ok;
   }
-  emitExpectLiveVerdict(adapter, target, runtime, "not-live");
+  emitExpectLiveVerdict(adapter, target, runtime, live ? "not-ready" : "not-live", recorder);
   return EXIT.runtime;
 }
 function captureHealth(providers) {
@@ -457,6 +475,7 @@ async function runDoctorFix(adapter, target, manifestValidation, json) {
 }
 export {
   doctorFixNextActions,
+  doctorReady,
   handleDoctor,
   skillsView
 };

package/dist/commands/status-probe.js

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import { fixtureSummary } from "../doctor.js";
 import { normalizeFeatureFlagRecord } from "../feature-flags.js";
 import { mobileBridgeScript } from "../adapters/mobile/bridge-script.js";
+import { isAndroidEmulatorSerial } from "../../library/actions/mobile/platform/bridge.mjs";
 const PROBE_TIMEOUT_MS = 2e3;
 function truncateAddress(address) {
   if (!address || address.length <= 10) return address;
@@ -51,7 +52,7 @@ function parseBridgeEntries(raw) {
 function androidModelMatches(deviceName, model, device, devices) {
   if (deviceName === model || deviceName.startsWith(`${model} -`)) return true;
   if (!deviceName.endsWith(` ${model}`) && !deviceName.includes(` ${model} -`)) return false;
-  const physical = (d) => d.platform === "android" && !d.id.startsWith("emulator-");
+  const physical = (d) => d.platform === "android" && !isAndroidEmulatorSerial(d.id);
   if (!physical(device)) return false;
   return devices.filter((d) => physical(d) && d.name === device.name).length === 1;
 }

package/docs/RECIPES.md

@@ -279,6 +279,18 @@ Perps orders follow one rule on Mobile, Extension and Core
   sent or closed.
 - Core still needs `CORE_PERPS_ALLOW_MAINNET_WRITES=1` for any mainnet write.
 
+A Hyperliquid `429 Too Many Requests` fails as `RATE_LIMITED`, naming the call,
+the attempts and the backoff (`library/actions/shared/perps/rate-limit.mjs`).
+Reads retry up to 3 times with exponential backoff and jitter inside the action
+deadline; then wait a minute and rerun. Extension background placement retries
+only when the dispatch itself got the 429 and Hyperliquid's info API then shows
+no open order, no fill and (market orders) no position on the order's side in
+that market since the first dispatch. The receipt records every dispatch 429
+under `rateLimitedDispatches`, with that check or the reason it did not retry;
+without a retry it stays `outcome-unknown`: inspect the market before any rerun.
+A 429 after dispatch is never redispatched, and Mobile placements are not
+retried.
+
 On the Extension, a run without funding files gets that rule through the
 fixture-policy lane: the runner binds the run and a run-owned execution ledger
 (`<artifacts>/mutation-ledger`), and each mutation completes the context from
@@ -417,6 +429,56 @@ For visual PR proof, prefer a short simulator recording or GIF over still
 screenshots when the claim is a UI flow (timing / transitions). Use screenshots
 as supporting stills.
 
+`--record-video=full-run` on a physical Android device records on the device
+with `adb shell screenrecord`, so no other host screen-capture client can stop
+it. screenrecord ends each file at 180 s; the harness starts the next one at
+once and joins them with ffmpeg (required, or set `FFMPEG_PATH`). Each restart
+leaves a gap of about half a second, which the video holds on the last frame
+so video time keeps to wall-clock time. `videos/recipe-run.mp4.capture.json`
+lists the files and their offsets. Screens the app marks secure (FLAG_SECURE)
+record black. An emulator (`emulator-*`) still records its scrcpy window
+through capture-helper, falling back to one screenrecord file when the mirror
+is unavailable. Set `METAMASK_RECIPE_MOBILE_ANDROID_RECORDER` to
+`screenrecord` or `mirror` to force either.
+
+A recording that fails fails the run: the `record.video` trace entry starts
+with `RECORDING_FAILED` or `RECORDER_INTERRUPTED`, names the cause, and says the
+run has no video. When capture stopped mid-run but a finalized partial file was
+kept (capture-helper 0.3.1's `stream_interrupted`, or the screenrecord files
+finished before a failure), the video is published and its manifest entry's
+`recorder.interrupted` gives the code, the cause and the video time up to the
+last captured frame (`coveredMs`). `mm-harness doctor` shows the recorder for
+the selected device and is not ready while it cannot record.
+
+### Mobile setup and command budgets
+
+`metamask.perps.start_state` and `teardown_state` have three budgets:
+
+| Budget | Node field | Emulator / simulator | Physical Android | Env override |
+|---|---|---|---|---|
+| Whole setup | `timeout_ms` | 30 s | 60 s | `MM_HARNESS_MOBILE_SETUP_TIMEOUT_MS` |
+| Each navigation phase | `navigation_timeout_ms` | 15 s | 30 s | `MM_HARNESS_MOBILE_NAVIGATION_TIMEOUT_MS` |
+| Each bridge command | `cdp_timeout_ms` | 15 s | 15 s | none |
+
+A device counts as physical when the run has an explicit adb serial (`--device <serial>`
+or `ADB_SERIAL`) that is not `emulator-*`. Node fields win over the env overrides.
+Each phase (unlock, account, navigation, provider, network, cleanup) runs on the
+rest of the setup budget, or on its slice for navigation, and each bridge command
+inside it is capped by that phase deadline. `navigate` and Perps market/home
+navigation use the same navigation default outside setups.
+
+Errors say which budget ran out:
+
+- `DOMAIN_SETUP_DEADLINE`: a setup phase ran out. The message names the action and
+  phase, the time it ran against its limit, and the setup's elapsed time and
+  limit. Raise `timeout_ms` or `navigation_timeout_ms`.
+- `ACTION_DEADLINE`: the calling action's deadline refused or stopped a bridge
+  command. Route and mode waits treat it as "no answer yet" and end with their
+  own timeout message.
+- `CDP_TIMEOUT` with `CDP_COMMAND_TIMEOUT` in the message: one bridge command hit
+  its own limit while the action still had time. That points at the bridge or app,
+  not the budget.
+
 ### Perps loading lifecycle validation
 
 The Mobile loading recipe shares one graph across Android and iOS. It requires

package/library/actions/core/perps/read_account.mjs

@@ -6,13 +6,15 @@ import {
   redactAccount,
   runAdapter,
 } from './_controller.mjs';
+import { liveAdapterDeadline } from '../../shared/app/live-adapter-deadline.mjs';
+import { withRateLimitRetry } from '../../shared/perps/rate-limit.mjs';
 
 export async function readAccount(input) {
   const { controller, accountAddress, network } = await getCoreController(input);
-  const account = await controller.getAccountState({
+  const account = await withRateLimitRetry('PerpsController.getAccountState', () => controller.getAccountState({
     standalone: true,
     userAddress: accountAddress,
-  });
+  }), { deadline: liveAdapterDeadline(input.node) });
   return {
     action: input.action,
     source: 'perps-controller-standalone',

package/library/actions/core/perps/read_orders.mjs

@@ -7,13 +7,15 @@ import {
   runAdapter,
   selectedItems,
 } from './_controller.mjs';
+import { liveAdapterDeadline } from '../../shared/app/live-adapter-deadline.mjs';
+import { withRateLimitRetry } from '../../shared/perps/rate-limit.mjs';
 
 export async function readOrders(input) {
   const { controller, accountAddress, network } = await getCoreController(input);
-  const orders = await controller.getOpenOrders({
+  const orders = await withRateLimitRetry('PerpsController.getOpenOrders', () => controller.getOpenOrders({
     standalone: true,
     userAddress: accountAddress,
-  });
+  }), { deadline: liveAdapterDeadline(input.node) });
   const matching = selectedItems(input, orders);
   return {
     action: input.action,

package/library/actions/core/perps/read_positions.mjs

@@ -7,13 +7,15 @@ import {
   runAdapter,
   selectedItems,
 } from './_controller.mjs';
+import { liveAdapterDeadline } from '../../shared/app/live-adapter-deadline.mjs';
+import { withRateLimitRetry } from '../../shared/perps/rate-limit.mjs';
 
 export async function readPositions(input) {
   const { controller, accountAddress, network } = await getCoreController(input);
-  const positions = await controller.getPositions({
+  const positions = await withRateLimitRetry('PerpsController.getPositions', () => controller.getPositions({
     standalone: true,
     userAddress: accountAddress,
-  });
+  }), { deadline: liveAdapterDeadline(input.node) });
   const matching = selectedItems(input, positions, 'position');
   return {
     action: input.action,

package/library/actions/extension/analytics/consent.mjs

@@ -85,18 +85,23 @@ export function consentControllerExpression({
         throw new Error('Extension consent state is unavailable.');
       }
       const metamask = root?.metamask ?? root ?? {};
+      // Extension 13.51+ keeps marketing consent in AnalyticsController.optedInToMarketing
+      // (migration 228); older builds expose MetaMetricsController.dataCollectionForMarketing.
+      const dataCollectionForMarketing = typeof metamask.dataCollectionForMarketing === 'boolean'
+        ? metamask.dataCollectionForMarketing
+        : metamask.optedInToMarketing;
       // Debug UI state can lag an acknowledged setter until the next UI sync.
       // Background/snapshot reads have no such subscription to wait for.
       if ((capturedChrome || !storeState) && (
         typeof metamask.optedIn !== 'boolean' ||
-        typeof metamask.dataCollectionForMarketing !== 'boolean'
+        typeof dataCollectionForMarketing !== 'boolean'
       )) {
         throw new Error('Extension consent state did not contain boolean consent fields.');
       }
       return {
         state: {
           optedIn: metamask.optedIn,
-          dataCollectionForMarketing: metamask.dataCollectionForMarketing,
+          dataCollectionForMarketing,
           analyticsId: metamask.analyticsId ? 'set' : null
         },
         source: capturedChrome

package/library/actions/extension/perps/close_visible_position.mjs

@@ -421,10 +421,13 @@ export async function closeVisiblePosition(input) {
   if (partialAmount == null && (!confirmation.fullSizeSelected || !confirmation.marketOrder)) {
     throw new Error('Receipt-bound full close requires the visible 100% market-close form.');
   }
-  // Without a placement receipt the baseline is the in-position balance, which excludes the released margin.
-  const closeReleaseBaseUnits = placement ? null : parseUsdBaseUnits(confirmation.receive);
-  if (!placement && closeReleaseBaseUnits == null) {
-    throw new Error('Close without a placement receipt requires the visible close receive amount.');
+  // Without a placement receipt the baseline is the in-position balance, which excludes the position's
+  // margin. The close returns marginUsed (PnL is already in the balance); the modal receive cross-checks it.
+  const closeReleaseBaseUnits = placement ? null : exactBefore.marginBaseUnits;
+  const closeModalReceiveBaseUnits = placement ? null : parseUsdBaseUnits(confirmation.receive);
+  if (closeModalReceiveBaseUnits != null
+    && BigInt(absoluteDelta(closeModalReceiveBaseUnits, closeReleaseBaseUnits)) > BigInt(balanceToleranceBaseUnits)) {
+    throw new Error('Visible close receive amount disagrees with the position margin beyond the reconciliation tolerance.');
   }
   const closeSizing = partialAmount == null ? { size: sizeMatch[1], side: fundingSide === 'long' ? 'short' : 'long' } : null;
   let submissionObserver = null;
@@ -440,7 +443,8 @@ export async function closeVisiblePosition(input) {
       cleanupOnly,
       fundingBalance,
       tradingContext,
-      ...(closeReleaseBaseUnits != null ? { closeReleaseBaseUnits } : {}),
+      ...(closeReleaseBaseUnits != null ? { closeReleaseBaseUnits, closeReleaseSource: 'position-margin' } : {}),
+      ...(closeModalReceiveBaseUnits != null ? { closeModalReceiveBaseUnits } : {}),
       ...(acceptedFill ? { acceptedFill } : {}),
       ...(closeSizing ? { closeSizing } : {}),
     },

package/library/actions/extension/perps/compare_provider_market.mjs

@@ -1,6 +1,8 @@
 // Fetch production Hyperliquid data and compare it with the opened market's displayed values.
 // Also check the funding countdown and nonblank chart canvases.
 import { dataTestId, marketSymbol, runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { liveAdapterDeadline } from '../../shared/app/live-adapter-deadline.mjs';
+import { withRateLimitRetry } from '../../shared/perps/rate-limit.mjs';
 
 function numeric(value) {
   const match = String(value ?? '').replace(/[$,]/gu, '').match(/-?[0-9]+(?:\.[0-9]+)?/u);
@@ -63,14 +65,16 @@ runAdapter(async (input) => {
   if (endpoint !== 'https://api.hyperliquid.xyz/info') {
     throw new Error('metamask.perps.compare_provider_market endpoint must be the Hyperliquid production info API.');
   }
-  const response = await fetch(endpoint, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ type: 'metaAndAssetCtxs' }),
-    signal: AbortSignal.timeout(Number(input.node?.timeout_ms ?? 15_000)),
-  });
-  if (!response.ok) throw new Error(`Hyperliquid market request failed with HTTP ${response.status}.`);
-  const payload = await response.json();
+  const payload = await withRateLimitRetry('Hyperliquid metaAndAssetCtxs', async () => {
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ type: 'metaAndAssetCtxs' }),
+      signal: AbortSignal.timeout(Number(input.node?.timeout_ms ?? 15_000)),
+    });
+    if (!response.ok) throw new Error(`Hyperliquid market request failed with HTTP ${response.status}.`);
+    return response.json();
+  }, { deadline: liveAdapterDeadline(input.node) });
   const universe = payload?.[0]?.universe;
   const contexts = payload?.[1];
   const index = Array.isArray(universe) ? universe.findIndex((entry) => entry?.name === market) : -1;