@deeeed/metamask-harness 0.80.0 → 0.82.0

package/adapters/{terminal → web-dapp}/wallet-host.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // wallet-host.mjs — long-running observer (and, in injected mode, signer) for the
-// terminal slot browser.
+// web-dapp slot browser.
 //
 // Purpose:
 //   Attaches to the slot browser over CDP and, for every app document, installs
@@ -28,13 +28,14 @@ import { appendFileSync, chmodSync, existsSync, unwatchFile, watchFile, writeFil
 import { createRequire } from 'node:module';
 import path from 'node:path';
 
+import { createStrictWallet, createWalletRequestBinding, pageReadyExpression, pageScriptSource } from '@farmslot/adapter-web/dapp';
+import { isAppUrl as isExactAppUrl, shortUrl } from '@farmslot/adapter-web/origin';
+
 import { CdpClient, browserWebSocketUrl } from './lib/cdp-client.mjs';
 import { hudFile, hudRenderExpression, readHudState } from './lib/hud.mjs';
-import { LINK_HOSTS, hostOf, isMainnetVenueUrl, mainnetTypedDataReason } from './lib/mainnet-guard.mjs';
+import { fixtureAccount, webDappPolicy } from '../../library/actions/web-dapp/platform/runtime.mjs';
+import { hostOf, isBlockedUrl } from './lib/blocked-hosts.mjs';
 import { ownedBrowserPids } from './lib/processes.mjs';
-import { isAppTopFrameContext, isAppUrl as isExactAppUrl } from './lib/origin.mjs';
-import { LOG_BINDING, REQUEST_BINDING, RESOLVE_FN, pageScriptSource } from './lib/page-script.mjs';
-import { createStrictWallet } from './lib/strict-wallet.mjs';
 
 const { captureMacFrontmost, macFocusDisabled } = createRequire(import.meta.url)('@farmslot/adapter-web/macos-focus');
 
@@ -65,6 +66,10 @@ function parseArgs(argv) {
 }
 
 const args = parseArgs(process.argv.slice(2));
+// The venue policy (e.g. the Terminal plugin's policy.mjs), from RECIPE_WEB_DAPP_POLICY:
+// link hosts, the probe, the typed-data refusal, the start page and chain.
+const policy = webDappPolicy();
+const LINK_HOSTS = new Set(policy.linkHosts);
 const runtimeDir = path.resolve(args['runtime-dir']);
 const logFile = path.join(runtimeDir, 'wallet-requests.jsonl');
 const signer = args.signer;
@@ -79,6 +84,19 @@ if (network === 'testnet' && mainnetHosts.length === 0) throw new Error('testnet
 // only, never a link host (app.hyperliquid-testnet.xyz serves pages and icons).
 const testnetHosts = String(args['testnet-hosts'] ?? '').split(',').filter((host) => host && !LINK_HOSTS.has(host));
 const PROBE_MARK = 'mm-harness-probe=1';
+// A testnet run never lets the typed data the policy refuses reach the signer.
+const refuseTypedData = network === 'testnet' ? policy.refuseTypedData : null;
+// The injected strict wallet presents as MetaMask, so the app connects to it
+// the way it connects to the extension.
+const INJECTED_WALLET = {
+  info: {
+    uuid: '5d1e5b4e-e2e0-4c3f-9a1d-000000000001',
+    name: 'MetaMask (strict test wallet)',
+    icon: "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'/>",
+    rdns: 'io.metamask',
+  },
+  isMetaMask: true,
+};
 
 // The request log is evidence; keep it owner-only even when it already exists.
 if (existsSync(logFile)) chmodSync(logFile, 0o600);
@@ -93,32 +111,25 @@ function say(message) {
 
 let wallet = null;
 if (signer === 'injected') {
-  const { fixtureAccount } = await import('../../library/actions/terminal/platform/runtime.mjs');
   if (!args.target || !args.account) throw new Error('injected mode requires --target and --account');
   const account = await fixtureAccount(path.resolve(args.target), args.account);
-  wallet = createStrictWallet({ account, chainId: Number(args['start-chain'] ?? 42161) });
+  wallet = createStrictWallet({ account, chainId: Number(args['start-chain'] ?? policy.startChain) });
   say(`injected strict wallet ready for ${args.account} (${account.address}) on chain ${wallet.chainId}`);
 }
 
-const source = pageScriptSource({ signer, appOrigin, network });
+const source = pageScriptSource({ signer, appOrigin, refuseTypedData, injectedWallet: INJECTED_WALLET });
 const client = await CdpClient.connect(await browserWebSocketUrl(Number(args['cdp-port'])));
+// Judges each binding call against the frame and document that made it, logs
+// it and, in injected mode, answers it with the strict wallet.
+const binding = createWalletRequestBinding({ client, appOrigin, signer, wallet, refuseTypedData, record: appendEntry, say });
 // Hooks are installed once per target: a second session for the same tab
 // (auto-attach plus a restored tab) would log every request twice.
 const hookedTargets = new Map();
 const appSessions = new Set();
-// Per app session: its target id (= main frame id), the URL its top frame has
-// committed, and live execution contexts, so a binding call can be traced to
-// the frame, document and origin that made it.
+// Per app session: its target id (= main frame id) and the URL its top frame
+// has committed.
 const sessionTargets = new Map();
 const sessionCommittedUrls = new Map();
-const sessionContexts = new Map();
-// Binding calls whose execution context, or that context's document, is not
-// known yet.
-const pendingCalls = new Map();
-// Per app session: the URL of a top-frame commit no execution context has
-// been tied to yet.
-const awaitingDocuments = new Map();
-const PENDING_CALL_TTL_MS = 5000;
 // App sessions whose target runs with domains enabled; the HUD is drawn only
 // there so no evaluate ever waits on a tab paused for setup.
 const hudSessions = new Set();
@@ -129,41 +140,6 @@ function isAppUrl(url) {
   return url === 'about:blank' || url === '' || isExactAppUrl(url, appOrigin);
 }
 
-function isTopDefaultContext(sessionId, context) {
-  return context?.auxData?.isDefault === true && context.auxData.frameId === sessionTargets.get(sessionId);
-}
-
-// A top-frame commit is tied to the top frame's default context of its
-// document: one created before the commit and still untied, or else the next
-// one created.
-// A commit is applied once: Page.getFrameTree and Page.frameNavigated can
-// both report the same document (its loaderId); a second report would leave a
-// stale commit waiting for the next document's context.
-const appliedCommits = new Map();
-function assignDocumentUrl(sessionId, url, loaderId) {
-  if (loaderId) {
-    if (appliedCommits.get(sessionId) === loaderId) return;
-    appliedCommits.set(sessionId, loaderId);
-  }
-  const untied = [...(sessionContexts.get(sessionId)?.values() ?? [])]
-    .filter((context) => isTopDefaultContext(sessionId, context) && context.documentUrl === null);
-  if (untied.length === 0) {
-    awaitingDocuments.set(sessionId, url);
-    return;
-  }
-  for (const context of untied) context.documentUrl = url;
-}
-
-// Judged against the caller's own document, not the tab's latest commit.
-function callerIsAppTopFrame(sessionId, executionContextId) {
-  const context = sessionContexts.get(sessionId)?.get(executionContextId);
-  return isAppTopFrameContext(context, {
-    targetId: sessionTargets.get(sessionId),
-    appOrigin,
-    committedUrl: context?.documentUrl ?? null,
-  });
-}
-
 // MetaMask shows dapp requests in its side panel (the fixture default) or a
 // notification/popup window; only request routes count as confirmations.
 const WALLET_SURFACES = ['sidepanel.html', 'notification.html', 'popup.html'];
@@ -233,9 +209,7 @@ function bounded(promise, label, ms = 10000) {
 async function installAppHooks(sessionId, targetId) {
   appSessions.add(sessionId);
   sessionTargets.set(sessionId, targetId);
-  sessionContexts.set(sessionId, new Map());
-  await bounded(client.send('Runtime.addBinding', { name: LOG_BINDING }, sessionId), 'Runtime.addBinding');
-  if (signer === 'injected') await bounded(client.send('Runtime.addBinding', { name: REQUEST_BINDING }, sessionId), 'Runtime.addBinding');
+  await bounded(binding.install(sessionId, targetId), 'Runtime.addBinding');
   await bounded(client.send('Page.addScriptToEvaluateOnNewDocument', { source, runImmediately: true }, sessionId), 'Page.addScriptToEvaluateOnNewDocument');
   if (network === 'testnet') {
     await bounded(client.send('Fetch.enable', {
@@ -244,16 +218,6 @@ async function installAppHooks(sessionId, targetId) {
   }
 }
 
-// Where a request went, without its query string or body.
-function shortUrl(url) {
-  try {
-    const parsed = new URL(url);
-    return `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
-  } catch {
-    return String(url).slice(0, 120);
-  }
-}
-
 // Venue traffic per app session: the served-network check. Only venue
 // endpoints count (the block list and the testnet endpoints); other hosts on a
 // venue domain, such as the coin icons on app.hyperliquid.xyz, are ignored.
@@ -288,10 +252,10 @@ async function enableAppDomains(sessionId) {
   const { frameTree } = await bounded(client.send('Page.getFrameTree', {}, sessionId), 'Page.getFrameTree');
   if (frameTree?.frame?.url !== undefined) {
     sessionCommittedUrls.set(sessionId, frameTree.frame.url);
-    assignDocumentUrl(sessionId, frameTree.frame.url, frameTree.frame.loaderId);
+    binding.commit(sessionId, frameTree.frame.url, frameTree.frame.loaderId);
   }
   if (appSessions.has(sessionId)) hudSessions.add(sessionId);
-  drainPendingCalls(sessionId);
+  binding.drain(sessionId);
 }
 
 // Redraw the HUD on app pages. The expression is a no-op when the same state
@@ -344,18 +308,13 @@ client.on('Target.targetCreated', ({ targetInfo }) => {
   if (targetInfo.type === 'page') observeWalletSurface(targetInfo.targetId, targetInfo.url);
 });
 client.on('Target.detachedFromTarget', ({ sessionId }) => {
-  // Calls still waiting for their document can no longer be judged.
-  for (const call of pendingCalls.get(sessionId) ?? []) recordUnattributed(call, 'its tab detached first');
-  awaitingDocuments.delete(sessionId);
-  appliedCommits.delete(sessionId);
+  binding.detach(sessionId);
   const targetId = sessionTargets.get(sessionId);
   if (targetId && hookedTargets.get(targetId)?.sessionId === sessionId) hookedTargets.delete(targetId);
   appSessions.delete(sessionId);
   hudSessions.delete(sessionId);
   sessionTargets.delete(sessionId);
   sessionCommittedUrls.delete(sessionId);
-  sessionContexts.delete(sessionId);
-  pendingCalls.delete(sessionId);
 });
 // What the app tab's first navigation did, for the diagnostic when it never
 // commits: main-frame commits, and the document's response or failure.
@@ -370,12 +329,11 @@ client.on('Page.frameNavigated', ({ frame }, sessionId) => {
   if (sessionId === appNavigation.session && !frame.parentId) appNavigation.commits.push(pathOf(frame.url));
   if (appSessions.has(sessionId) && !frame.parentId) {
     sessionCommittedUrls.set(sessionId, frame.url);
-    assignDocumentUrl(sessionId, frame.url, frame.loaderId);
-    drainPendingCalls(sessionId);
+    binding.commit(sessionId, frame.url, frame.loaderId);
   }
 });
 client.on('Fetch.requestPaused', ({ requestId, request, resourceType }, sessionId) => {
-  const mainnet = isMainnetVenueUrl(request.url, mainnetHosts);
+  const mainnet = isBlockedUrl(request.url, mainnetHosts);
   if (mainnet) {
     appendEntry({ kind: 'blocked-mainnet', t: Date.now(), transport: 'http', url: shortUrl(request.url), resourceType, probe: request.url.includes(PROBE_MARK) });
     say(`blocked a mainnet request to ${shortUrl(request.url)}`);
@@ -402,30 +360,11 @@ client.on('Network.webSocketCreated', ({ requestId, url }, sessionId) => {
   if (url.includes(PROBE_MARK)) probeRequests.set(requestId, 'websocket');
   recordVenueTraffic(sessionId, url);
   // The host resolver rule fails the connection; the attempt is still evidence.
-  if (isMainnetVenueUrl(url, mainnetHosts)) {
+  if (isBlockedUrl(url, mainnetHosts)) {
     appendEntry({ kind: 'blocked-mainnet', t: Date.now(), transport: 'websocket', url: shortUrl(url), probe: url.includes(PROBE_MARK) });
     say(`blocked a mainnet WebSocket to ${shortUrl(url)}`);
   }
 });
-client.on('Runtime.executionContextCreated', ({ context }, sessionId) => {
-  const contexts = sessionContexts.get(sessionId);
-  if (!contexts) return;
-  contexts.set(context.id, context);
-  if (isTopDefaultContext(sessionId, context)) {
-    // The navigation this document belongs to may already have committed
-    // (frameNavigated first) or not yet (the context first).
-    const awaiting = awaitingDocuments.get(sessionId);
-    context.documentUrl = awaiting ?? null;
-    awaitingDocuments.delete(sessionId);
-  }
-  drainPendingCalls(sessionId);
-});
-client.on('Runtime.executionContextDestroyed', ({ executionContextId }, sessionId) => {
-  sessionContexts.get(sessionId)?.delete(executionContextId);
-});
-client.on('Runtime.executionContextsCleared', (_params, sessionId) => {
-  sessionContexts.get(sessionId)?.clear();
-});
 for (const event of ['Page.domContentEventFired', 'Page.loadEventFired', 'Page.navigatedWithinDocument']) {
   client.on(event, (_params, sessionId) => {
     if (hudSessions.has(sessionId)) drawHud([sessionId]);
@@ -436,123 +375,6 @@ for (const event of ['Page.domContentEventFired', 'Page.loadEventFired', 'Page.n
 watchFile(hudFile(runtimeDir), { interval: 500 }, () => drawHud());
 const hudRepeat = setInterval(() => drawHud(), 2000);
 
-// Answer a request the host refuses, so the page's promise settles instead of
-// hanging; harmless where the preload (and its resolver) is absent.
-function refuse(sessionId, executionContextId, id, message) {
-  const outcome = { error: { message, code: 4100 } };
-  const expression = `typeof window.${RESOLVE_FN} === 'function' && window.${RESOLVE_FN}(${JSON.stringify(id)}, ${JSON.stringify(outcome)})`;
-  return client.send('Runtime.evaluate', { expression, contextId: executionContextId }, sessionId).catch(() => {});
-}
-
-function requestId(name, payload) {
-  if (name !== REQUEST_BINDING) return null;
-  try {
-    return JSON.parse(payload).id ?? null;
-  } catch {
-    return null;
-  }
-}
-
-async function handleBindingCall({ name, payload, executionContextId }, sessionId) {
-  // Only the app's own top frame may log or ask the injected wallet to sign;
-  // anything else (an iframe, a blank popup, a page the tab navigated to) is
-  // dropped, and a refused request is answered with 4100.
-  if (!callerIsAppTopFrame(sessionId, executionContextId)) {
-    const context = sessionContexts.get(sessionId)?.get(executionContextId);
-    appendEntry({ kind: 'outside-app-frame', t: Date.now(), binding: name === REQUEST_BINDING ? 'request' : 'log', origin: context?.origin ?? null, document: context?.documentUrl ? shortUrl(context.documentUrl) : null });
-    say(`ignored ${name === REQUEST_BINDING ? 'wallet request' : 'log entry'} from outside the app top frame`);
-    const id = requestId(name, payload);
-    if (id !== null) await refuse(sessionId, executionContextId, id, 'Wallet requests are accepted only from the app top frame.');
-    return;
-  }
-  if (name === LOG_BINDING) {
-    try {
-      appendEntry(JSON.parse(payload));
-    } catch (error) {
-      say(`unparseable log payload: ${error.message}`);
-    }
-    return;
-  }
-  if (name !== REQUEST_BINDING || !wallet) return;
-  const { id, method, params } = JSON.parse(payload);
-  if (network === 'testnet' && /^eth_signTypedData/u.test(String(method))) {
-    let reason = null;
-    try {
-      reason = mainnetTypedDataReason(typeof params?.[1] === 'string' ? JSON.parse(params[1]) : params?.[1]);
-    } catch {
-      reason = null;
-    }
-    if (reason) {
-      appendEntry({ kind: 'refused-mainnet', t: Date.now(), method, reason, layer: 'wallet-host' });
-      await refuse(sessionId, executionContextId, id, 'Refused: this test run is held to Hyperliquid testnet and the request signs a mainnet action.');
-      return;
-    }
-  }
-  let outcome;
-  try {
-    outcome = { result: await wallet.request({ method, params }) };
-  } catch (error) {
-    outcome = { error: { message: String(error.message), code: error.code ?? -32603 } };
-  }
-  await client.send(
-    'Runtime.evaluate',
-    { expression: `window.${RESOLVE_FN}(${JSON.stringify(id)}, ${JSON.stringify(outcome)})`, contextId: executionContextId },
-    sessionId,
-  ).catch((error) => say(`resolve ${method} failed: ${error.message}`));
-}
-
-// A binding call can arrive before its execution context is reported (the
-// domains are enabled after the tab resumes), or before its document's commit.
-// Hold it until both are known; after a short wait it cannot be judged: it is
-// logged as unattributed (and a request is refused).
-function drainPendingCalls(sessionId) {
-  const queue = pendingCalls.get(sessionId);
-  if (!queue) return;
-  for (const call of [...queue]) {
-    const known = callAttributable(sessionId, call.executionContextId);
-    if (!known && Date.now() - call.at < PENDING_CALL_TTL_MS) continue;
-    queue.splice(queue.indexOf(call), 1);
-    if (known) {
-      handleBindingCall(call, sessionId);
-      continue;
-    }
-    recordUnattributed(call, 'its document was never attributed');
-    const id = requestId(call.name, call.payload);
-    if (id !== null) refuse(sessionId, call.executionContextId, id, 'Wallet request from a document the harness could not attribute.');
-  }
-}
-
-function recordUnattributed(call, why) {
-  let entry = {};
-  try {
-    entry = JSON.parse(call.payload);
-  } catch {
-    entry = {};
-  }
-  const binding = call.name === REQUEST_BINDING ? 'request' : 'log';
-  appendEntry({ kind: 'unattributed', t: Date.now(), binding, method: typeof entry.method === 'string' ? entry.method : null, loggedKind: typeof entry.kind === 'string' ? entry.kind : null, reason: why });
-  say(`a wallet ${binding === 'request' ? 'request' : 'log entry'} could not be judged (${why}); recorded as unattributed`);
-}
-
-// A binding call can be judged once its execution context is known and, for
-// the top frame's default context, the URL of that context's own document.
-function callAttributable(sessionId, executionContextId) {
-  const context = sessionContexts.get(sessionId)?.get(executionContextId);
-  if (!context) return false;
-  return !isTopDefaultContext(sessionId, context) || context.documentUrl !== null;
-}
-
-client.on('Runtime.bindingCalled', (call, sessionId) => {
-  if (callAttributable(sessionId, call.executionContextId)) {
-    handleBindingCall(call, sessionId);
-    return;
-  }
-  const queue = pendingCalls.get(sessionId) ?? [];
-  queue.push({ ...call, at: Date.now() });
-  pendingCalls.set(sessionId, queue);
-  setTimeout(() => drainPendingCalls(sessionId), PENDING_CALL_TTL_MS + 50);
-});
-
 client.on('close', () => {
   clearInterval(hudRepeat);
   unwatchFile(hudFile(runtimeDir));
@@ -632,7 +454,7 @@ for (const info of startupTabs) {
 // The first app document is a market page: it streams from the venue in the
 // browser, which the served-network check below observes (the home page's
 // data comes from the server render).
-const startUrl = new URL(args['start-path'] || '/order/BTC', `${appOrigin}/`).href;
+const startUrl = new URL(args['start-path'] || policy.startPath, `${appOrigin}/`).href;
 appNavigation.session = appSession;
 const navigation = await bounded(client.send('Page.navigate', { url: startUrl }, appSession), 'Page.navigate', 60000).catch((error) => fail(error.message));
 const navigateStart = Date.now();
@@ -652,13 +474,7 @@ const evaluate = (expression, timeoutMs = 5000) => bounded(
 // The first app document must carry the log binding and the installed
 // preload (its marker), with the page's provider wrapped, or requests on it
 // would go unrecorded.
-const readyExpression = [
-  `typeof window.${LOG_BINDING} === 'function'`,
-  ...(signer === 'injected' ? [`typeof window.${REQUEST_BINDING} === 'function'`] : []),
-  `Boolean(window.__mmTerminalHarness && window.__mmTerminalHarness.signer === ${JSON.stringify(signer)} && window.__mmTerminalHarness.network === ${JSON.stringify(network)})`,
-  // The provider the app sees is the wrapped one, and no wrap failed.
-  'window.__mmTerminalHarness.wrapFailures.length === 0 && window.__mmTerminalHarness.covers(window.ethereum)',
-].join(' && ');
+const readyExpression = pageReadyExpression({ signer, refusesTypedData: refuseTypedData !== null });
 let hooksReady = false;
 for (let attempt = 0; attempt < 50 && !hooksReady; attempt += 1) {
   hooksReady = (await evaluate(readyExpression)) === true;
@@ -670,10 +486,11 @@ if (network === 'testnet') {
   // The block must hold before anything runs: a probe to the mainnet venue
   // from the app page has to fail (HTTP through the request block and the
   // resolver rule, WebSocket through the resolver rule).
-  const host = mainnetHosts.includes('api.hyperliquid.xyz') ? 'api.hyperliquid.xyz' : mainnetHosts[0];
-  const httpProbe = await evaluate(`fetch('https://${host}/info?${PROBE_MARK}', { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{"type":"meta"}' }).then(() => 'reached', () => 'blocked')`, 20000);
-  const resolverProbe = await evaluate(`fetch('https://${host}:${RESOLVER_PROBE_PORT}/info?${PROBE_MARK}', { method: 'POST' }).then(() => 'reached', () => 'blocked')`, 20000);
-  const wsProbe = await evaluate(`new Promise((resolve) => { const socket = new WebSocket('wss://${host}/ws?${PROBE_MARK}'); const done = (value) => { try { socket.close(); } catch {} resolve(value); }; socket.onopen = () => done('reached'); socket.onerror = () => done('blocked'); setTimeout(() => done('timeout'), 10000); })`, 20000);
+  const { probe } = policy;
+  const host = mainnetHosts.includes(probe.host) ? probe.host : mainnetHosts[0];
+  const httpProbe = await evaluate(`fetch('https://${host}${probe.httpPath}?${PROBE_MARK}', { method: 'POST', headers: { 'content-type': 'application/json' }, body: ${JSON.stringify(probe.httpBody)} }).then(() => 'reached', () => 'blocked')`, 20000);
+  const resolverProbe = await evaluate(`fetch('https://${host}:${RESOLVER_PROBE_PORT}${probe.httpPath}?${PROBE_MARK}', { method: 'POST' }).then(() => 'reached', () => 'blocked')`, 20000);
+  const wsProbe = await evaluate(`new Promise((resolve) => { const socket = new WebSocket('wss://${host}${probe.wsPath}?${PROBE_MARK}'); const done = (value) => { try { socket.close(); } catch {} resolve(value); }; socket.onopen = () => done('reached'); socket.onerror = () => done('blocked'); setTimeout(() => done('timeout'), 10000); })`, 20000);
   if (httpProbe !== 'blocked' || resolverProbe !== 'blocked' || wsProbe !== 'blocked') {
     fail(`the mainnet venue is reachable from the app (http ${httpProbe}, resolver ${resolverProbe}, websocket ${wsProbe})`);
   }

package/dist/adapters/core/actions.js

@@ -1,4 +1,5 @@
 import { manifestPath } from "../../paths.js";
+import { perpsOrderInputFindings } from "../perps-order-inputs.js";
 const coreActions = {
   manifestPath: () => manifestPath("core"),
   semantic: [
@@ -14,7 +15,9 @@ const coreActions = {
     env: async (projectRoot, tempDir) => (await import("./live-script-env.js")).coreLiveScriptEnv(projectRoot, tempDir)
   },
   // Core declares no cdp.target; the probe matches the Extension's.
-  cdpTarget: { transport: "chrome-extension-cdp", probePath: "json/version" }
+  cdpTarget: { transport: "chrome-extension-cdp", probePath: "json/version" },
+  // ensure_positions and ensure_orders with an open or present state place an order.
+  inputFindings: (nodeId, node) => perpsOrderInputFindings(nodeId, node, { ensureChecksOnly: false })
 };
 export {
   coreActions

package/dist/adapters/extension/actions.js

@@ -1,4 +1,5 @@
 import { manifestPath } from "../../paths.js";
+import { perpsOrderInputFindings } from "../perps-order-inputs.js";
 import { extensionActionInputFindings } from "./action-inputs.js";
 const extensionActions = {
   manifestPath: () => manifestPath("extension"),
@@ -43,8 +44,11 @@ const extensionActions = {
     })
   }),
   trustedMutation: true,
-  inputFindings: extensionActionInputFindings,
-  ensureChecksOnly: true
+  // ensure_positions and ensure_orders only check state here.
+  inputFindings: (nodeId, node) => [
+    ...extensionActionInputFindings(nodeId, node),
+    ...perpsOrderInputFindings(nodeId, node, { ensureChecksOnly: true })
+  ]
 };
 export {
   extensionActions

package/dist/adapters/extension/network-observer.js

@@ -204,6 +204,19 @@ async function waitForSocket(socketPath) {
   }
   throw new Error("Extension network observer broker did not start.");
 }
+async function createExtensionNetworkBackend(env, artifactsDir) {
+  return createExtensionNetworkObserver(extensionCdpPort(env), artifactsDir);
+}
+function extensionCdpPort(env) {
+  const port = Number(
+    env.CDP_PORT ?? env.RECIPE_CDP_PORT ?? process.env.CDP_PORT
+  );
+  if (!Number.isInteger(port) || port <= 0) {
+    throw new Error("Extension network observation requires CDP_PORT.");
+  }
+  return port;
+}
 export {
+  createExtensionNetworkBackend,
   createExtensionNetworkObserver
 };

package/dist/adapters/extension/run.js

@@ -1,4 +1,5 @@
-import { optionFlag, optionString } from "@farmslot/recipe-cli/harness";
+import path from "node:path";
+import { EXIT, optionFlag } from "@farmslot/recipe-cli/harness";
 import { verifyOwnedCollectorControl } from "../console-capture.js";
 import { resolveExtensionBrowserPid } from "./browser-pid.js";
 import {
@@ -7,6 +8,7 @@ import {
   extensionCdpPort,
   verifyExtensionConsoleControl
 } from "./console-capture.js";
+import { emitProofFailure } from "../proof-failure.js";
 import { launchedBrowser } from "./launched-browser.js";
 const AUTOLAUNCH_ENV = "METAMASK_RECIPE_EXTENSION_AUTOLAUNCH";
 const extensionRun = {
@@ -36,29 +38,9 @@ const extensionRun = {
       pageMode: "home-or-sidepanel"
     });
   },
-  // The proof runtime is checked on the run's own ports: explicit flags win over
-  // the slot's for the check, and the slot's come back afterwards.
-  runtimeCheck({ target, options, heal, state, json, onRecovery }) {
-    return async () => {
-      const previousCdpPort = process.env.CDP_PORT;
-      const previousRecipeCdpPort = process.env.RECIPE_CDP_PORT;
-      const previousWatcherPort = process.env.WATCHER_PORT;
-      const explicitCdpPort = optionString(options, "cdpPort");
-      const explicitWatcherPort = optionString(options, "watcherPort") ?? optionString(options, "metroPort");
-      if (explicitCdpPort) {
-        process.env.CDP_PORT = explicitCdpPort;
-        process.env.RECIPE_CDP_PORT = explicitCdpPort;
-      }
-      if (explicitWatcherPort) process.env.WATCHER_PORT = explicitWatcherPort;
-      try {
-        const { ensureExtensionProofRuntime } = await import("../../commands/run-engine.js");
-        return await ensureExtensionProofRuntime(target, heal, state, json, { onRecovery });
-      } finally {
-        restoreEnv("CDP_PORT", previousCdpPort);
-        restoreEnv("RECIPE_CDP_PORT", previousRecipeCdpPort);
-        restoreEnv("WATCHER_PORT", previousWatcherPort);
-      }
-    };
+  // The proof runtime is checked on the run's own ports (the engine's scope).
+  runtimeCheck({ target, heal, state, json, onRecovery }) {
+    return () => ensureExtensionProofRuntime(target, heal, state, json, { onRecovery });
   },
   launchedBrowser: (target, artifactsDir, cdpPort) => launchedBrowser(target, artifactsDir, cdpPort),
   browserProvenance: (browser) => ({
@@ -68,6 +50,106 @@ const extensionRun = {
     extension_loading: browser.extensionLoading
   })
 };
+async function ensureExtensionProofRuntime(target, heal, state, json, deps = {}) {
+  const decide = deps.decide ?? (async () => {
+    const { decideExtensionReadiness } = await import("./runtime-decision.js");
+    const port = Number(process.env.CDP_PORT);
+    return decideExtensionReadiness(target, {
+      ...Number.isInteger(port) && port > 0 ? { cdpPort: port } : {},
+      pageMode: "home-or-sidepanel"
+    });
+  });
+  const initial = await decide();
+  if (initial.decision === "ready") return null;
+  if (initial.reasonCode === "release-artifact-identity-invalid" || initial.reasonCode === "release-artifact-runtime-missing" || initial.reasonCode === "release-artifact-runtime-stale") {
+    const message = initial.reasons[0] ?? "The loaded release artifact identity is invalid.";
+    const userAction2 = "rerun runtime-launch with the same artifact source";
+    emitProofFailure(json, {
+      recoverable: false,
+      error: { code: "RELEASE_ARTIFACT_NOT_CURRENT", message, userAction: userAction2 }
+    });
+    return EXIT.infra;
+  }
+  if (initial.reasonCode === "runtime-dist-check-failed") {
+    const message = `Extension proof runtime freshness could not be checked: ${initial.reasons[0] ?? initial.decision}`;
+    const userAction2 = `mm-harness doctor --adapter extension --target ${JSON.stringify(path.resolve(target))}`;
+    emitProofFailure(json, {
+      recoverable: false,
+      error: { code: "EXTENSION_RUNTIME_CHECK_FAILED", message, userAction: userAction2 }
+    });
+    return EXIT.infra;
+  }
+  if (![
+    "dist-stale",
+    "dist-missing",
+    "runtime-dist-stale",
+    "runtime-dist-missing"
+  ].includes(initial.reasonCode)) {
+    return null;
+  }
+  const tier = initial.decision === "build" ? "build" : "quick";
+  const canHeal = heal === "auto" || heal === "infra-only" && tier === "quick";
+  const targetArg = JSON.stringify(path.resolve(target));
+  const userAction = tier === "build" ? `mm-harness launch --build --verify --adapter extension --target ${targetArg}` : `mm-harness launch --verify --adapter extension --target ${targetArg}`;
+  if (!canHeal) {
+    const message = `Extension proof runtime is not current (${initial.reasonCode}): ${initial.reasons[0] ?? initial.decision}`;
+    emitProofFailure(json, {
+      recoverable: true,
+      mutations: state.mutations,
+      error: { code: "EXTENSION_RUNTIME_NOT_CURRENT", message, userAction }
+    });
+    return EXIT.infra;
+  }
+  const recoveryCode = tier === "build" ? "extension.runtime_rebuilt" : "extension.runtime_reloaded";
+  const productConfigBlock = tier === "build" ? (await import("./product-config.js")).extensionProductConfigBlock(target) : null;
+  if (productConfigBlock) {
+    const message = productConfigBlock.message;
+    const userAction2 = productConfigBlock.userAction;
+    emitProofFailure(json, {
+      recoverable: false,
+      mutations: state.mutations,
+      error: { code: "EXTENSION_PRODUCT_CONFIG_REQUIRED", message, userAction: userAction2 }
+    });
+    return EXIT.infra;
+  }
+  state.attemptedRecoveries.push(recoveryCode);
+  deps.onRecovery?.(recoveryCode);
+  if (!json)
+    console.error(
+      `\u2192 Extension proof preflight: ${initial.reasonCode}; ${tier === "build" ? "rebuilding" : "reloading"} before execution`
+    );
+  const launch = deps.launch ?? (async (requestedTier) => {
+    const { launchExtension } = await import("../../commands/launch/extension.js");
+    const { readExtensionPinnedFlags } = await import("./feature-flags.js");
+    const { fixtureFeatureFlags, remoteFlagRequestFor } = await import("../../feature-flags.js");
+    const { walletFixturePath } = await import("../../paths.js");
+    return launchExtension(
+      target,
+      requestedTier,
+      false,
+      "fullscreen",
+      remoteFlagRequestFor(readExtensionPinnedFlags(target).pinned ?? fixtureFeatureFlags(walletFixturePath(target)))
+    );
+  });
+  const result = await launch(tier);
+  const verified = result.status === 0 ? await decide() : initial;
+  if (result.status !== 0 || verified.decision !== "ready") {
+    const message = `Extension runtime recovery did not produce a current healthy runtime (${verified.reasonCode}).`;
+    emitProofFailure(json, {
+      recoverable: false,
+      attemptedRecoveries: state.attemptedRecoveries,
+      error: { code: "EXTENSION_RUNTIME_RECOVERY_FAILED", message, userAction, originalError: result.output }
+    });
+    return EXIT.infra;
+  }
+  state.recovered.push(recoveryCode);
+  state.mutations.push({
+    type: "runtime",
+    action: tier === "build" ? "rebuilt" : "reloaded",
+    reasonCode: initial.reasonCode
+  });
+  return null;
+}
 const extensionRecording = {
   target: (context) => resolveExtensionRecordingTarget(context),
   framed: {
@@ -99,19 +181,21 @@ const extensionDiagnostics = {
 };
 const extensionObservation = {
   network: {
-    backend: async (_target, env, artifactsDir) => (await import("../../network-observation.js")).createExtensionNetworkBackend(env, artifactsDir),
+    backend: async (_target, env, artifactsDir) => (await import("./network-observer.js")).createExtensionNetworkBackend(env, artifactsDir),
     actions: true
   },
   performance: {
-    backend: async (target, env, ports) => (await import("../../performance-observation.js")).createExtensionPerformanceObserver(target, env, ports),
-    platform: () => "extension"
+    start: async (context) => {
+      const observation = await import("../../performance-observation.js");
+      return observation.startRunPerformanceObservation({
+        backend: (target, env) => observation.createExtensionPerformanceObserver(target, env),
+        platform: () => "extension"
+      }, context);
+    }
   }
 };
-function restoreEnv(key, value) {
-  if (value === void 0) delete process.env[key];
-  else process.env[key] = value;
-}
 export {
+  ensureExtensionProofRuntime,
   extensionDiagnostics,
   extensionObservation,
   extensionRecording,