@deeeed/metamask-harness 0.34.2 → 0.34.3

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Unreleased
 
+## 0.34.3 - 2026-08-12
+
+### Added
+
+- Add a composable headless Core Perps snapshot recipe that calls the public controller APIs with configurable Terminal endpoints.
+- Add route-agnostic Extension actions and a reusable recipe for post-GC navigation slopes, detached-DOM growth, and equal-duration idle-control memory measurement.
+
+### Fixed
+
+- Preserve an already-foregrounded Android app while recipes toggle network state, avoiding an unnecessary launcher intent during recovery validation.
+
 ## 0.34.2 - 2026-08-11
 
 ### Added

package/dist/adapters.js

@@ -45,7 +45,10 @@ const LIVE_ONLY_PERPS_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.perps.teardown_state",
   "metamask.perps.capture_performance"
 ]);
-const CORE_ONLY_PERPS_ACTIONS = /* @__PURE__ */ new Set(["metamask.perps.read_account"]);
+const CORE_ONLY_PERPS_ACTIONS = /* @__PURE__ */ new Set([
+  "metamask.perps.read_account",
+  "metamask.perps.read_snapshot"
+]);
 const LIVE_ONLY_WALLET_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.wallet.setup",
   "metamask.wallet.ensure_unlocked",
@@ -206,7 +209,7 @@ function createMetaMaskSemanticAdapters(platform, declaredCustomActions = [], pr
       "metamask.perps.prepare_local_snapshot_endpoint"
     ] : [],
     // read_account is core-only: only the headless core adapter implements it.
-    ...platform === "core" ? ["metamask.perps.read_account"] : []
+    ...platform === "core" ? ["metamask.perps.read_account", "metamask.perps.read_snapshot"] : []
   ];
   const bundled = new Set(bundledActions);
   const actions = [.../* @__PURE__ */ new Set([...bundledActions, ...declaredCustomActions])];

package/dist/recipe-security.js

@@ -9,6 +9,7 @@ const READ_ONLY_CUSTOM_ACTIONS = /* @__PURE__ */ new Set([
   "metamask.perps.read_positions",
   "metamask.perps.read_orders",
   "metamask.perps.read_account",
+  "metamask.perps.read_snapshot",
   "metamask.perps.assert_positions",
   "metamask.perps.assert_orders",
   // Collector reads are host-only; starting capture remains arbitrary-code

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

@@ -39,8 +39,9 @@ function messengerEntry(projectRoot) {
 // a persistent auto-reconnecting HyperLiquid WebSocket (HyperLiquidClientService
 // .initialize → wsTransport.ready()); these logs proved the order returns over
 // HTTP while that open socket kept the event loop alive — see disconnectAndExit.
-function buildInfrastructure(stubbed) {
+function buildInfrastructure(stubbed, input) {
   const noop = () => undefined;
+  const terminalApi = resolveTerminalApi(input);
   return {
     logger: {
       error: (error, meta) =>
@@ -79,6 +80,7 @@ function buildInfrastructure(stubbed) {
       setItem: async () => undefined,
       removeItem: async () => undefined,
     },
+    ...(terminalApi ? { terminalApi } : {}),
     rewards: { getPerpsDiscountForAccount: async () => null },
   };
 }
@@ -246,6 +248,25 @@ export function resolveNetwork(input) {
   return raw;
 }
 
+export function resolveTerminalApi(input) {
+  const marketDataUrl = String(
+    input.node?.terminal_market_data_url ??
+      process.env.CORE_PERPS_TERMINAL_MARKET_DATA_URL ??
+      '',
+  ).trim();
+  const globalSnapshotUrl = String(
+    input.node?.terminal_global_snapshot_url ??
+      process.env.CORE_PERPS_TERMINAL_GLOBAL_SNAPSHOT_URL ??
+      '',
+  ).trim();
+
+  if (!marketDataUrl && !globalSnapshotUrl) return undefined;
+  return {
+    ...(marketDataUrl ? { marketDataUrl } : {}),
+    ...(globalSnapshotUrl ? { globalSnapshotUrl } : {}),
+  };
+}
+
 export function requireRuntimeExport(moduleNamespace, exportName, sourceLabel) {
   const value = moduleNamespace?.[exportName] ?? moduleNamespace?.default?.[exportName];
   if (value === undefined) {
@@ -264,8 +285,16 @@ export async function getCoreController(input) {
   if (!projectRoot) throw new Error('core adapter requires context.projectRoot.');
   const accountAddress = await requireAccountAddress(input);
   const network = resolveNetwork(input);
+  const terminalApi = resolveTerminalApi(input);
+  const terminalApiKey = JSON.stringify(terminalApi ?? null);
 
-  if (cached && cached.projectRoot === projectRoot && cached.network === network) {
+  if (
+    cached &&
+    cached.projectRoot === projectRoot &&
+    cached.network === network &&
+    cached.accountAddress.toLowerCase() === accountAddress.toLowerCase() &&
+    cached.terminalApiKey === terminalApiKey
+  ) {
     return { ...cached, accountAddress };
   }
 
@@ -290,7 +319,7 @@ export async function getCoreController(input) {
   );
 
   const stubbed = new Set();
-  const infrastructure = buildInfrastructure(stubbed);
+  const infrastructure = buildInfrastructure(stubbed, input);
 
   // Root + child messenger pair, mirroring the real app wiring (and the core
   // repo's own test harness in
@@ -305,6 +334,7 @@ export async function getCoreController(input) {
     namespace: 'PerpsController',
     parent: rootMessenger,
   });
+  registerSelectedAccountHandler(rootMessenger, messenger, accountAddress);
 
   // Default testnet. Mainnet only on explicit node.network: "mainnet" — mainnet
   // reads are safe; mainnet mutations use real funds (gated in getCoreControllerWithSigner).
@@ -339,7 +369,15 @@ export async function getCoreController(input) {
       );
     }
   }
-  cached = { controller, messenger, rootMessenger, projectRoot, network };
+  cached = {
+    controller,
+    messenger,
+    rootMessenger,
+    projectRoot,
+    network,
+    accountAddress,
+    terminalApiKey,
+  };
   return { ...cached, accountAddress };
 }
 
@@ -366,11 +404,30 @@ export async function getCoreController(input) {
 // getSelectedEvmAccountFromMessenger). These get registered on the root and
 // delegated into the PerpsController child messenger.
 const SIGNER_ACTIONS = [
-  'AccountsController:getSelectedAccount',
   'KeyringController:getState',
   'KeyringController:signTypedMessage',
 ];
 
+function registerSelectedAccountHandler(
+  rootMessenger,
+  childMessenger,
+  address,
+) {
+  rootMessenger.registerActionHandler(
+    'AccountsController:getSelectedAccount',
+    () => ({
+      id: 'core-headless-account',
+      address,
+      type: 'eip155:eoa',
+      metadata: { keyring: { type: 'HD Key Tree' } },
+    }),
+  );
+  rootMessenger.delegate({
+    actions: ['AccountsController:getSelectedAccount'],
+    messenger: childMessenger,
+  });
+}
+
 /**
  * Register the signer-backed external handlers on the root messenger and
  * delegate them into the PerpsController child, mirroring the real app's
@@ -379,26 +436,10 @@ const SIGNER_ACTIONS = [
  * @param rootMessenger - The permissive (MOCK_ANY_NAMESPACE) root messenger.
  * @param childMessenger - The PerpsController-namespaced messenger.
  * @param account - The viem signer account.
- * @param address - The selected EVM account address (0x).
  */
-function registerSignerHandlers(rootMessenger, childMessenger, account, address) {
+function registerSignerHandlers(rootMessenger, childMessenger, account) {
   if (rootMessenger.__coreSignerRegistered) return;
 
-  // AccountsController:getSelectedAccount — getSelectedEvmAccountFromMessenger()
-  // calls this first and uses it when the returned object looks like an account
-  // with an EVM `type`. Minimal InternalAccount shape: address + EVM type, plus
-  // metadata.keyring.type so isSelectedHardwareWallet() sees a software (non-
-  // hardware) keyring and allows user signing.
-  rootMessenger.registerActionHandler(
-    'AccountsController:getSelectedAccount',
-    () => ({
-      id: 'core-headless-signer',
-      address,
-      type: 'eip155:eoa',
-      metadata: { keyring: { type: 'HD Key Tree' } },
-    }),
-  );
-
   // KeyringController:getState — isKeyringUnlocked() reads `.isUnlocked`. The
   // headless keyring is always unlocked (we hold the private key).
   rootMessenger.registerActionHandler('KeyringController:getState', () => ({
@@ -479,7 +520,7 @@ export async function getCoreControllerWithSigner(input) {
   }
 
   const { account, address: signerAddress } = await resolveSignerFromFixture(input);
-  registerSignerHandlers(rootMessenger, childMessenger, account, signerAddress);
+  registerSignerHandlers(rootMessenger, childMessenger, account);
 
   // Bring up the active provider. placeOrder/closePosition call
   // getActiveProvider(), which throws CLIENT_NOT_INITIALIZED until init()
@@ -618,6 +659,17 @@ export function redactPosition(position) {
   };
 }
 
+export function redactAccount(account) {
+  return {
+    totalBalance: account?.totalBalance ?? null,
+    spendableBalance: account?.spendableBalance ?? null,
+    withdrawableBalance: account?.withdrawableBalance ?? null,
+    marginUsed: account?.marginUsed ?? null,
+    unrealizedPnl: account?.unrealizedPnl ?? null,
+    returnOnEquity: account?.returnOnEquity ?? null,
+  };
+}
+
 /**
  * Wrap a controller rejection so its typed code survives as data.
  *

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

@@ -1,15 +1,9 @@
-import { getCoreController, isDirectRun, runAdapter } from './_controller.mjs';
-
-function redactAccount(account) {
-  return {
-    totalBalance: account?.totalBalance ?? null,
-    spendableBalance: account?.spendableBalance ?? null,
-    withdrawableBalance: account?.withdrawableBalance ?? null,
-    marginUsed: account?.marginUsed ?? null,
-    unrealizedPnl: account?.unrealizedPnl ?? null,
-    returnOnEquity: account?.returnOnEquity ?? null,
-  };
-}
+import {
+  getCoreController,
+  isDirectRun,
+  redactAccount,
+  runAdapter,
+} from './_controller.mjs';
 
 export async function readAccount(input) {
   const { controller, accountAddress, network } = await getCoreController(input);

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

@@ -0,0 +1,66 @@
+import {
+  getCoreController,
+  isDirectRun,
+  redactAccount,
+  redactOrder,
+  redactPosition,
+  runAdapter,
+} from './_controller.mjs';
+
+export async function readSnapshotFromController(controller, scope) {
+  const output = {};
+
+  if (scope === 'markets' || scope === 'all') {
+    const markets = await controller.getMarketDataWithPrices({
+      standalone: true,
+    });
+    output.markets = {
+      count: markets.length,
+      dataSources: Array.from(
+        new Set(markets.map((market) => market.dataSource ?? 'provider')),
+      ),
+      marketsWithTrend: markets.filter(
+        (market) => Array.isArray(market.trend) && market.trend.length > 0,
+      ).length,
+      sampleSymbols: markets.slice(0, 10).map((market) => market.symbol),
+    };
+  }
+
+  if (scope === 'account' || scope === 'all') {
+    const snapshot = await controller.getUserDataSnapshot();
+    output.user = {
+      identity: snapshot.identity,
+      positions: snapshot.positions.map(redactPosition),
+      orders: snapshot.orders.map(redactOrder),
+      accountState: redactAccount(snapshot.accountState),
+    };
+  }
+
+  return output;
+}
+
+export async function readSnapshot(input) {
+  const scope = String(input.node?.scope ?? 'all');
+  if (!['markets', 'account', 'all'].includes(scope)) {
+    throw new Error(
+      `metamask.perps.read_snapshot scope must be markets, account, or all; got ${scope}.`,
+    );
+  }
+
+  const { controller, accountAddress, network } =
+    await getCoreController(input);
+  const snapshot = await readSnapshotFromController(controller, scope);
+
+  return {
+    action: input.action,
+    source: 'perps-controller-public-api',
+    network,
+    account: accountAddress,
+    scope,
+    ...snapshot,
+    proofPath:
+      'PerpsController.getMarketDataWithPrices/getUserDataSnapshot',
+  };
+}
+
+if (isDirectRun(import.meta.url)) runAdapter(readSnapshot);

package/library/actions/extension/performance/_navigation-memory.mjs

@@ -0,0 +1,372 @@
+const DEFAULT_SCREEN_TIMEOUT_MS = 15_000;
+const DEFAULT_SETTLE_MS = 1_500;
+const DEFAULT_GC_SETTLE_MS = 300;
+const DEFAULT_ACTION_TIMEOUT_MS = 400_000;
+const DEFAULT_ROUND_DURATION_MS = 10_000;
+
+function finiteNumber(value, fallback, label) {
+  const parsed = value ?? fallback;
+  if (!Number.isFinite(parsed)) throw new Error(`${label} must be a finite number.`);
+  return parsed;
+}
+
+function positiveInteger(value, fallback, label, minimum = 1) {
+  const parsed = finiteNumber(value, fallback, label);
+  if (!Number.isInteger(parsed) || parsed < minimum) {
+    throw new Error(`${label} must be an integer >= ${minimum}.`);
+  }
+  return parsed;
+}
+
+function requiredText(value, label) {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new Error(`${label} is required.`);
+  }
+  return value.trim();
+}
+
+function optionalHash(value, fallback) {
+  const hash = typeof value === 'string' && value.trim() ? value.trim() : fallback;
+  return hash.startsWith('#') ? hash : `#${hash}`;
+}
+
+export function leastSquaresSlope(values) {
+  if (!Array.isArray(values) || values.length < 2 || values.some((value) => !Number.isFinite(value))) {
+    throw new Error('leastSquaresSlope requires at least two finite samples.');
+  }
+  const meanX = (values.length - 1) / 2;
+  const meanY = values.reduce((sum, value) => sum + value, 0) / values.length;
+  let numerator = 0;
+  let denominator = 0;
+  for (let index = 0; index < values.length; index += 1) {
+    numerator += (index - meanX) * (values[index] - meanY);
+    denominator += (index - meanX) ** 2;
+  }
+  return numerator / denominator;
+}
+
+export function assessNavigationSlope(slopes, bounds) {
+  return {
+    nodes: slopes.nodes <= bounds.maxNodesPerCycle,
+    listeners: slopes.listeners <= bounds.maxListenersPerCycle,
+  };
+}
+
+export function countDetachedNodes(snapshot) {
+  const fields = snapshot?.snapshot?.meta?.node_fields;
+  const nodes = snapshot?.nodes;
+  if (!Array.isArray(fields) || !Array.isArray(nodes)) {
+    throw new Error('Heap snapshot is missing node metadata.');
+  }
+  const detachedIndex = fields.indexOf('detachedness');
+  if (detachedIndex < 0) throw new Error('Heap snapshot has no detachedness field.');
+  let count = 0;
+  for (let index = 0; index < nodes.length; index += fields.length) {
+    if (nodes[index + detachedIndex] === 2) count += 1;
+  }
+  return count;
+}
+
+export function navigationMemoryOptions(node, countField = 'cycles', defaultCount = 8) {
+  const screenHash = optionalHash(node.screen_hash ?? node.screenHash, '');
+  if (screenHash === '#') throw new Error('screen_hash is required.');
+  const screenTestId = requiredText(node.screen_test_id ?? node.screenTestId, 'screen_test_id');
+  return {
+    screenHash,
+    screenTestId,
+    returnHash: optionalHash(node.return_hash ?? node.returnHash, '#/'),
+    count: positiveInteger(node[countField], defaultCount, countField, 2),
+    settleMs: positiveInteger(node.settle_ms ?? node.settleMs, DEFAULT_SETTLE_MS, 'settle_ms', 0),
+    gcSettleMs: positiveInteger(node.gc_settle_ms ?? node.gcSettleMs, DEFAULT_GC_SETTLE_MS, 'gc_settle_ms', 0),
+    screenTimeoutMs: positiveInteger(
+      node.screen_timeout_ms ?? node.screenTimeoutMs,
+      DEFAULT_SCREEN_TIMEOUT_MS,
+      'screen_timeout_ms',
+    ),
+    timeoutMs: positiveInteger(node.timeout_ms ?? node.timeoutMs, DEFAULT_ACTION_TIMEOUT_MS, 'timeout_ms'),
+    roundDurationMs: positiveInteger(
+      node.round_duration_ms ?? node.roundDurationMs,
+      DEFAULT_ROUND_DURATION_MS,
+      'round_duration_ms',
+    ),
+  };
+}
+
+function deadlineIn(timeoutMs) {
+  return Date.now() + timeoutMs;
+}
+
+function remaining(deadline, label) {
+  const value = deadline - Date.now();
+  if (value <= 0) throw new Error(`${label} timed out.`);
+  return value;
+}
+
+async function boundedSleep(ms, deadline, label) {
+  if (ms === 0) return;
+  const available = remaining(deadline, label);
+  if (ms > available) throw new Error(`${label} timed out.`);
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function navigateAndSettle(page, hash, testId, options, deadline, label) {
+  await page.navigateHash(hash, Math.min(options.screenTimeoutMs, remaining(deadline, label)));
+  if (testId) {
+    await page.waitForSelector(`[data-testid=${JSON.stringify(testId)}]`, {
+      timeoutMs: Math.min(options.screenTimeoutMs, remaining(deadline, label)),
+    });
+  }
+  await boundedSleep(options.settleMs, deadline, label);
+}
+
+export async function forceGarbageCollection(session, settleMs, deadline) {
+  for (let pass = 0; pass < 2; pass += 1) {
+    await session.call('HeapProfiler.collectGarbage', {}, {
+      timeoutMs: remaining(deadline, 'Forced garbage collection'),
+    });
+    await boundedSleep(settleMs, deadline, 'Forced garbage collection');
+  }
+}
+
+async function readPerformanceMetrics(session, deadline) {
+  const result = await session.call('Performance.getMetrics', {}, {
+    timeoutMs: remaining(deadline, 'Performance metric sampling'),
+  });
+  const metrics = Object.fromEntries((result?.metrics ?? []).map(({ name, value }) => [name, value]));
+  for (const name of ['Nodes', 'JSEventListeners', 'JSHeapUsedSize']) {
+    if (!Number.isFinite(metrics[name])) throw new Error(`CDP metric ${name} is unavailable.`);
+  }
+  return metrics;
+}
+
+async function enableMemoryDomains(session, deadline, includePerformance) {
+  if (includePerformance) {
+    await session.call('Performance.enable', {}, {
+      timeoutMs: remaining(deadline, 'Performance domain setup'),
+    });
+  }
+  await session.call('HeapProfiler.enable', {}, {
+    timeoutMs: remaining(deadline, 'Heap profiler setup'),
+  });
+}
+
+async function samplePostGcMetrics(page, options, deadline, index, navigate, roundDurationMs) {
+  const startedAt = Date.now();
+  if (navigate) {
+    await navigateAndSettle(page, options.returnHash, null, options, deadline, `Navigation cycle ${index}`);
+    await navigateAndSettle(
+      page,
+      options.screenHash,
+      options.screenTestId,
+      options,
+      deadline,
+      `Navigation cycle ${index}`,
+    );
+  }
+  if (roundDurationMs !== undefined) {
+    const waitMs = roundDurationMs - (Date.now() - startedAt);
+    if (waitMs < 0) {
+      throw new Error(
+        `${navigate ? 'Navigation' : 'Idle'} round ${index} exceeded round_duration_ms=${roundDurationMs}.`,
+      );
+    }
+    await boundedSleep(waitMs, deadline, `${navigate ? 'Navigation' : 'Idle'} sample ${index}`);
+  }
+  await forceGarbageCollection(page.session, options.gcSettleMs, deadline);
+  const metrics = await readPerformanceMetrics(page.session, deadline);
+  return {
+    index,
+    nodes: metrics.Nodes,
+    listeners: metrics.JSEventListeners,
+    heapBytes: metrics.JSHeapUsedSize,
+  };
+}
+
+function sampleSlopes(samples) {
+  return {
+    nodes: leastSquaresSlope(samples.map(({ nodes }) => nodes)),
+    listeners: leastSquaresSlope(samples.map(({ listeners }) => listeners)),
+    heapBytes: leastSquaresSlope(samples.map(({ heapBytes }) => heapBytes)),
+  };
+}
+
+export async function measureNavigationSlope(page, options, bounds) {
+  const deadline = deadlineIn(options.timeoutMs);
+  await enableMemoryDomains(page.session, deadline, true);
+  await navigateAndSettle(
+    page,
+    options.screenHash,
+    options.screenTestId,
+    options,
+    deadline,
+    'Initial screen navigation',
+  );
+  const samples = [];
+  for (let cycle = 1; cycle <= options.count; cycle += 1) {
+    samples.push(await samplePostGcMetrics(page, options, deadline, cycle, true));
+  }
+  const slopes = sampleSlopes(samples);
+  const passed = assessNavigationSlope(slopes, bounds);
+  const result = {
+    measurement: 'post-gc-navigation-slope',
+    screen: { hash: options.screenHash, testId: options.screenTestId },
+    cycles: options.count,
+    samples,
+    slopes,
+    bounds,
+    passed,
+  };
+  if (!passed.nodes || !passed.listeners) {
+    throw new Error(
+      `Navigation memory bounds exceeded: nodes ${slopes.nodes.toFixed(2)}/${bounds.maxNodesPerCycle} per cycle; listeners ${slopes.listeners.toFixed(2)}/${bounds.maxListenersPerCycle} per cycle.`,
+    );
+  }
+  return result;
+}
+
+async function takeHeapSnapshot(session, gcSettleMs, deadline) {
+  const chunks = [];
+  const unsubscribe = session.on('HeapProfiler.addHeapSnapshotChunk', (params) => {
+    if (typeof params?.chunk === 'string') chunks.push(params.chunk);
+  });
+  try {
+    await forceGarbageCollection(session, gcSettleMs, deadline);
+    await session.call(
+      'HeapProfiler.takeHeapSnapshot',
+      { reportProgress: false, captureNumericValue: false },
+      { timeoutMs: remaining(deadline, 'Heap snapshot') },
+    );
+  } finally {
+    unsubscribe();
+  }
+  if (chunks.length === 0) throw new Error('Heap snapshot produced no chunks.');
+  return JSON.parse(chunks.join(''));
+}
+
+export async function measureDetachedDom(page, options, maxDetachedGrowth) {
+  const deadline = deadlineIn(options.timeoutMs);
+  await enableMemoryDomains(page.session, deadline, false);
+  await navigateAndSettle(
+    page,
+    options.screenHash,
+    options.screenTestId,
+    options,
+    deadline,
+    'Initial screen navigation',
+  );
+  const before = countDetachedNodes(
+    await takeHeapSnapshot(page.session, options.gcSettleMs, deadline),
+  );
+  for (let cycle = 1; cycle <= options.count; cycle += 1) {
+    await navigateAndSettle(page, options.returnHash, null, options, deadline, `Navigation cycle ${cycle}`);
+    await navigateAndSettle(
+      page,
+      options.screenHash,
+      options.screenTestId,
+      options,
+      deadline,
+      `Navigation cycle ${cycle}`,
+    );
+  }
+  const after = countDetachedNodes(
+    await takeHeapSnapshot(page.session, options.gcSettleMs, deadline),
+  );
+  const result = {
+    measurement: 'post-gc-detached-dom',
+    screen: { hash: options.screenHash, testId: options.screenTestId },
+    cycles: options.count,
+    before,
+    after,
+    growth: after - before,
+    bound: { maxDetachedGrowth },
+    passed: after - before <= maxDetachedGrowth,
+  };
+  if (!result.passed) {
+    throw new Error(
+      `Detached DOM bound exceeded: growth ${result.growth}/${maxDetachedGrowth} nodes.`,
+    );
+  }
+  return result;
+}
+
+async function measureArm(page, options, deadline, navigate) {
+  await navigateAndSettle(
+    page,
+    options.screenHash,
+    options.screenTestId,
+    options,
+    deadline,
+    `${navigate ? 'Navigation' : 'Idle'} arm setup`,
+  );
+  const samples = [];
+  for (let round = 1; round <= options.count; round += 1) {
+    samples.push(
+      await samplePostGcMetrics(
+        page,
+        options,
+        deadline,
+        round,
+        navigate,
+        options.roundDurationMs,
+      ),
+    );
+  }
+  return { samples, slopes: sampleSlopes(samples) };
+}
+
+export async function compareIdleNavigation(page, options, maxAttributableListenersPerCycle) {
+  const deadline = deadlineIn(options.timeoutMs);
+  await enableMemoryDomains(page.session, deadline, true);
+  const idle = await measureArm(page, options, deadline, false);
+  const navigation = await measureArm(page, options, deadline, true);
+  const idleListenersPerCycle = Math.max(0, idle.slopes.listeners);
+  const attributableListenersPerCycle = navigation.slopes.listeners - idleListenersPerCycle;
+  const result = {
+    measurement: 'post-gc-idle-control',
+    screen: { hash: options.screenHash, testId: options.screenTestId },
+    rounds: options.count,
+    idle,
+    navigation,
+    idleListenersPerCycle,
+    attributableListenersPerCycle,
+    bound: { maxAttributableListenersPerCycle },
+    passed: attributableListenersPerCycle <= maxAttributableListenersPerCycle,
+  };
+  if (!result.passed) {
+    throw new Error(
+      `Idle-control bound exceeded: attributable listeners ${attributableListenersPerCycle.toFixed(2)}/${maxAttributableListenersPerCycle} per cycle (navigation ${navigation.slopes.listeners.toFixed(2)}, idle ${idleListenersPerCycle.toFixed(2)}).`,
+    );
+  }
+  return result;
+}
+
+export function navigationSlopeBounds(node) {
+  return {
+    maxNodesPerCycle: finiteNumber(
+      node.max_nodes_per_cycle ?? node.maxNodesPerCycle,
+      2,
+      'max_nodes_per_cycle',
+    ),
+    maxListenersPerCycle: finiteNumber(
+      node.max_listeners_per_cycle ?? node.maxListenersPerCycle,
+      4,
+      'max_listeners_per_cycle',
+    ),
+  };
+}
+
+export function detachedDomBound(node) {
+  return finiteNumber(
+    node.max_detached_growth ?? node.maxDetachedGrowth,
+    50,
+    'max_detached_growth',
+  );
+}
+
+export function idleControlBound(node) {
+  return finiteNumber(
+    node.max_attributable_listeners_per_cycle ?? node.maxAttributableListenersPerCycle,
+    2,
+    'max_attributable_listeners_per_cycle',
+  );
+}