@deeeed/metamask-harness 0.81.0 → 0.82.0

package/adapters/{terminal → web-dapp}/lib/processes.mjs

@@ -1,4 +1,4 @@
-// Stop the terminal slot browser and wallet host by their pid files and prove
+// Stop the web-dapp slot browser and wallet host by their pid files and prove
 // the slot CDP port is released. A pid is signalled only when its command line
 // carries this slot's owner marker for that process kind. A pid file naming a
 // dead process is removed; one naming a live process without the marker is
@@ -10,7 +10,7 @@ import { existsSync, readFileSync, rmSync } from 'node:fs';
 import net from 'node:net';
 import path from 'node:path';
 
-import { terminalRuntimeDir } from '../../../library/actions/terminal/platform/runtime.mjs';
+import { webDappPolicy, webDappRuntimeDir } from '../../../library/actions/web-dapp/platform/runtime.mjs';
 
 export function pidAlive(pid) {
   if (!Number.isInteger(Number(pid)) || Number(pid) <= 0) return false;
@@ -58,7 +58,7 @@ export const OWNER_FLAG = '--mm-harness-owner';
 export const OWNER_KINDS = Object.freeze(['browser', 'wallet-host', 'console-collector']);
 
 export function ownerMarker(kind, runtimeDir) {
-  if (!OWNER_KINDS.includes(kind)) throw new Error(`unknown terminal process kind ${kind}`);
+  if (!OWNER_KINDS.includes(kind)) throw new Error(`unknown web-dapp process kind ${kind}`);
   const id = createHash('sha256').update(path.resolve(runtimeDir)).digest('hex').slice(0, 32);
   return `${OWNER_FLAG}=${kind}-${id}`;
 }
@@ -104,10 +104,10 @@ export async function terminate(pid, graceMs = 8000) {
   return true;
 }
 
-// The console collector a run started (src/adapters/terminal/console-capture.ts)
+// The console collector a run started (src/adapters/web-dapp/console-capture.ts)
 // outlives browser relaunches inside the run; stop and cleanup end it.
 export async function stopConsoleCollector(target, { log = () => {}, runtimeDir } = {}) {
-  const runtime = runtimeDir ?? terminalRuntimeDir(target);
+  const runtime = runtimeDir ?? webDappRuntimeDir(target);
   const pidFile = path.join(runtime, 'console-tail.pid');
   const pid = readPid(pidFile);
   if (!pid) return { stopped: null };
@@ -149,8 +149,8 @@ export function cdpListenerPids(port) {
   }
 }
 
-export async function stopTerminalBrowser(target, { cdpPort, log = () => {}, runtimeDir } = {}) {
-  const runtime = runtimeDir ?? terminalRuntimeDir(target);
+export async function stopWebDappBrowser(target, { cdpPort, log = () => {}, runtimeDir } = {}) {
+  const runtime = runtimeDir ?? webDappRuntimeDir(target);
   const stopped = [];
   const stale = [];
   const foreign = [];
@@ -181,7 +181,7 @@ export async function stopTerminalBrowser(target, { cdpPort, log = () => {}, run
       await new Promise((resolve) => setTimeout(resolve, 250));
       free = await portFree(cdpPort);
     }
-    if (!free) throw new Error(`CDP port ${cdpPort} is still in use after stopping the terminal browser; another process owns it.`);
+    if (!free) throw new Error(`CDP port ${cdpPort} is still in use after stopping the ${webDappPolicy().adapterId} browser; another process owns it.`);
   }
   return { stopped, stale, foreign, cdpPortFree: free };
 }

package/adapters/{terminal → web-dapp}/lib/readiness.mjs

@@ -1,4 +1,4 @@
-// Read-only readiness of a Web Terminal slot for recipe runs: checkout shape,
+// Read-only readiness of a web-dapp slot for recipe runs: checkout shape,
 // dependencies, the slot dev server, forced testnet, wallet fixture, browser,
 // MetaMask extension copy and the per-slot CDP port. Never launches anything
 // except the optional short-lived browser start probe.
@@ -7,23 +7,13 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 
-import { canonicalPath, fixtureEntry, loadWalletFixture, readBrowserState, terminalRuntimeDir, viemAccountFromEntry } from '../../../library/actions/terminal/platform/runtime.mjs';
+import { canonicalPath, fixtureEntry, loadWalletFixture, readBrowserState, viemAccountFromEntry, webDappPolicy, webDappRuntimeDir } from '../../../library/actions/web-dapp/platform/runtime.mjs';
 import { ownsProcess, pidAlive, portFree } from './processes.mjs';
 
 function check(id, ok, detail, { required = true, status } = {}) {
   return { id, status: status ?? (ok ? 'pass' : 'fail'), required, detail };
 }
 
-export function isTerminalCheckout(target) {
-  try {
-    const pkg = JSON.parse(readFileSync(path.join(target, 'package.json'), 'utf8'));
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    return Boolean(deps.next) && existsSync(path.join(target, 'src/features/perpetuals'));
-  } catch {
-    return false;
-  }
-}
-
 async function httpStatus(url, timeoutMs = 20000) {
   try {
     const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs), redirect: 'manual' });
@@ -39,9 +29,9 @@ async function httpStatus(url, timeoutMs = 20000) {
 // NEXT_PUBLIC_HYPERLIQUID_FORCE_TESTNET). Process inspection cannot prove
 // what the browser talks to (macOS reports a process's initial environment,
 // and lsof cannot see other users' sockets), so this only warns; the browser
-// is held to testnet by the network and wallet layers (mainnet-guard.mjs, the
-// wallet host). Each listener on the app port must descend from the pid-file
-// process and run from the checkout (its cwd); every process on the way from
+// is held to testnet by the network and wallet layers (the venue policy's
+// blocked hosts, the wallet host). Each listener on the app port must descend
+// from the pid-file process and run from the checkout (its cwd); every process on the way from
 // a listener up to the pid-file process is read exactly (argv and environment
 // entries from sysctl KERN_PROCARGS2) and must carry the testnet variable. An
 // unreadable process makes the result unknown.
@@ -183,14 +173,14 @@ export function devServerTestnetDiagnostic(target, { appPort, variable, probe =
 export const MAINNET_CONFIRMATION = 'REAL_FUNDS';
 
 // The launch only checks the requested network: mainnet needs the real-funds
-// confirmation. Testnet is enforced inside the browser (mainnet-guard.mjs).
+// confirmation. Testnet is enforced inside the browser (the venue policy's blocked hosts).
 export function assertLaunchNetwork(_target, { network, mainnetConfirmation } = {}) {
   const requested = network == null || network === '' ? 'testnet' : String(network);
   if (requested !== 'testnet' && requested !== 'mainnet') {
     throw new Error(`network must be testnet or mainnet, got ${JSON.stringify(network)}.`);
   }
   if (requested === 'mainnet' && mainnetConfirmation !== MAINNET_CONFIRMATION) {
-    throw new Error(`network=mainnet needs mainnet_confirmation=${MAINNET_CONFIRMATION}; refusing to launch the terminal browser.`);
+    throw new Error(`network=mainnet needs mainnet_confirmation=${MAINNET_CONFIRMATION}; refusing to launch the ${webDappPolicy().adapterId} browser.`);
   }
   return requested;
 }
@@ -200,10 +190,10 @@ function listing(names) {
   return names.length > 1 ? `${names.slice(0, -1).join(', ')} and ${names.at(-1)}` : names.join('');
 }
 
-// `policy`: the venue policy (adapters/terminal/policy.mjs): dependencies,
-// startPath, testnetVariable.
-export async function terminalReadiness({
-  policy,
+// `policy`: the venue policy (checkout, dependencies, startPath, testnetVariable);
+// by default the one RECIPE_WEB_DAPP_POLICY names.
+export async function webDappReadiness({
+  policy = webDappPolicy(),
   target,
   appPort,
   cdpPort,
@@ -213,8 +203,8 @@ export async function terminalReadiness({
   probeBrowser = undefined,
 }) {
   const checks = [];
-  const shape = isTerminalCheckout(target);
-  checks.push(check('checkout', shape, shape ? 'Next.js checkout with src/features/perpetuals' : `${target} is not a Web Terminal checkout`));
+  const shape = policy.checkout.matches(target);
+  checks.push(check('checkout', shape, shape ? policy.checkout.label : `${target} is not a ${policy.checkout.name} checkout`));
   const deps = policy.dependencies.filter((name) => !existsSync(path.join(target, 'node_modules', name, 'package.json')));
   checks.push(check('dependencies', deps.length === 0, deps.length === 0 ? `${listing(policy.dependencies)} installed` : `missing: ${deps.join(', ')} (run npm ci on Node 22)`));
 
@@ -224,7 +214,7 @@ export async function terminalReadiness({
   } else {
     checks.push(check('app-dev-server', false, 'no dev-server port; pass --watcher-port <port> or set TERMINAL_APP_PORT'));
   }
-  // Advisory: the browser enforces testnet itself (mainnet-guard.mjs).
+  // Advisory: the browser enforces testnet itself (the venue policy's blocked hosts).
   const testnet = devServerTestnetDiagnostic(target, { appPort, variable: policy.testnetVariable });
   checks.push(check('testnet-forced', testnet.known && testnet.forced, testnet.detail, {
     required: false,
@@ -264,7 +254,7 @@ export async function terminalReadiness({
     : 'TERMINAL_EXTENSION_CHECKOUT unset or not installed (needed to import the wallet into the extension)', { required: extensionRequired }));
 
   const state = await readBrowserState(target);
-  const runtime = terminalRuntimeDir(target);
+  const runtime = webDappRuntimeDir(target);
   const live = Boolean(state && ownsProcess('browser', state.browserPid, runtime) && ownsProcess('wallet-host', state.hostPid, runtime));
   if (cdpPort) {
     const free = await portFree(cdpPort);

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// stop.mjs — stop the terminal slot browser, wallet host and console collector, verify the CDP port
+// stop.mjs — stop the web-dapp slot browser, wallet host and console collector, verify the CDP port
 // is free. Idempotent: nothing running is success.
 //
 // Inputs: --target <checkout> [--cdp-port <port>] [--json]
@@ -9,7 +9,8 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { stopConsoleCollector, stopTerminalBrowser } from './lib/processes.mjs';
+import { webDappPolicy } from '../../library/actions/web-dapp/platform/runtime.mjs';
+import { stopConsoleCollector, stopWebDappBrowser } from './lib/processes.mjs';
 
 const usage = 'Usage: stop.mjs --target <checkout> [--cdp-port <port>] [--json]';
 
@@ -26,8 +27,8 @@ if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.me
   const target = value('--target') ?? process.cwd();
   const rawPort = value('--cdp-port') ?? process.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT;
   try {
-    const log = (message) => process.stderr.write(`[terminal/stop] ${message}\n`);
-    const result = await stopTerminalBrowser(target, { cdpPort: rawPort ? Number(rawPort) : undefined, log });
+    const log = (message) => process.stderr.write(`[${webDappPolicy().adapterId}/stop] ${message}\n`);
+    const result = await stopWebDappBrowser(target, { cdpPort: rawPort ? Number(rawPort) : undefined, log });
     const collector = await stopConsoleCollector(target, { log });
     process.stdout.write(`${JSON.stringify({ status: 'pass', ...result, consoleCollector: collector })}\n`);
   } catch (error) {

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

@@ -1,20 +1,21 @@
 #!/usr/bin/env node
-// verify.mjs — `mm-harness verify --adapter terminal`: read-only readiness of a
-// Web Terminal slot (checkout, deps, dev server, forced testnet, fixture,
+// verify.mjs — `mm-harness verify --adapter <web-dapp adapter>`: read-only readiness of a
+// web-dapp slot (checkout, deps, dev server, forced testnet, fixture,
 // browser start probe, MetaMask extension copy, CDP port).
 //
-// Inputs: --policy-module <venue policy module> --target <checkout> [--cdp-port <port>] [--watcher-port <app port>]
+// Inputs: --target <checkout> [--cdp-port <port>] [--watcher-port <app port>]
 //   [--signer extension|injected] [--account <name>] [--json]
 // Outputs: readiness JSON (or a human summary) on stdout. Exit 0 ready; 1 not ready.
 // Never launches the slot browser or the dev server.
 
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
 
 import { resolveBrowser } from './launch.mjs';
-import { terminalReadiness } from './lib/readiness.mjs';
+import { webDappPolicy } from '../../library/actions/web-dapp/platform/runtime.mjs';
+import { webDappReadiness } from './lib/readiness.mjs';
 
-const usage = 'Usage: verify.mjs --policy-module <venue policy module> --target <checkout> [--cdp-port <port>] [--watcher-port <app port>] [--signer extension|injected] [--account <name>] [--json]';
+const usage = 'Usage: verify.mjs --target <checkout> [--cdp-port <port>] [--watcher-port <app port>] [--signer extension|injected] [--account <name>] [--json]';
 
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
   const argv = process.argv.slice(2);
@@ -27,13 +28,8 @@ if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.me
     return index >= 0 ? argv[index + 1] : undefined;
   };
   const num = (raw) => (raw && /^\d+$/u.test(raw) ? Number(raw) : undefined);
-  const policyModule = value('--policy-module');
-  if (!policyModule) {
-    process.stderr.write(`Missing --policy-module\n${usage}\n`);
-    process.exit(2);
-  }
-  const { policy } = await import(pathToFileURL(path.resolve(policyModule)).href);
-  const report = await terminalReadiness({
+  const policy = webDappPolicy();
+  const report = await webDappReadiness({
     policy,
     target: path.resolve(value('--target') ?? process.cwd()),
     appPort: num(value('--watcher-port') ?? process.env.TERMINAL_APP_PORT ?? process.env.WATCHER_PORT),
@@ -43,13 +39,13 @@ if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.me
     probeBrowser: resolveBrowser,
   });
   if (argv.includes('--json')) {
-    process.stdout.write(`${JSON.stringify({ schemaVersion: 1, command: 'verify', adapter: 'terminal', ...report }, null, 2)}\n`);
+    process.stdout.write(`${JSON.stringify({ schemaVersion: 1, command: 'verify', adapter: policy.adapterId, ...report }, null, 2)}\n`);
   } else {
     for (const check of report.checks) {
       const mark = check.status === 'pass' ? '✓' : check.status === 'warn' || !check.required ? '·' : '✗';
       process.stdout.write(`${mark} ${check.id}: ${check.detail}\n`);
     }
-    process.stdout.write(report.status === 'pass' ? 'terminal slot ready\n' : `not ready: ${report.failed.join(', ')}\n`);
+    process.stdout.write(report.status === 'pass' ? `${policy.adapterId} slot ready\n` : `not ready: ${report.failed.join(', ')}\n`);
   }
   process.exit(report.status === 'pass' ? 0 : 1);
 }

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
@@ -27,20 +27,20 @@
 import { appendFileSync, chmodSync, existsSync, unwatchFile, watchFile, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { pathToFileURL } from 'node:url';
 
 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 { hostOf, isMainnetVenueUrl } 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';
 
 const { captureMacFrontmost, macFocusDisabled } = createRequire(import.meta.url)('@farmslot/adapter-web/macos-focus');
 
 function usage() {
-  return 'Usage: wallet-host.mjs --cdp-port <port> --runtime-dir <dir> --signer <extension|injected> --app-origin <url> --policy-module <venue policy module> [--network testnet|mainnet] [--mainnet-hosts <h1,h2>] [--testnet-hosts <h1,h2>] [--extension-id <id>] [--target <checkout> --account <name> --start-chain <id>] [--observe-focus 1] [--window x,y,w,h] [--start-path <path>] [--mm-harness-owner=<marker>]';
+  return 'Usage: wallet-host.mjs --cdp-port <port> --runtime-dir <dir> --signer <extension|injected> --app-origin <url> [--network testnet|mainnet] [--mainnet-hosts <h1,h2>] [--testnet-hosts <h1,h2>] [--extension-id <id>] [--target <checkout> --account <name> --start-chain <id>] [--observe-focus 1] [--window x,y,w,h] [--start-path <path>] [--mm-harness-owner=<marker>]';
 }
 
 function parseArgs(argv) {
@@ -59,16 +59,16 @@ function parseArgs(argv) {
     args[flag.slice(2)] = argv[index + 1];
     index += 1;
   }
-  for (const key of ['cdp-port', 'runtime-dir', 'signer', 'app-origin', 'policy-module']) {
+  for (const key of ['cdp-port', 'runtime-dir', 'signer', 'app-origin']) {
     if (!args[key]) throw new Error(`Missing --${key}\n${usage()}`);
   }
   return args;
 }
 
 const args = parseArgs(process.argv.slice(2));
-// The venue policy (the Terminal's adapters/terminal/policy.mjs): link hosts,
-// the probe host, the typed-data refusal and the start page.
-const { policy } = await import(pathToFileURL(path.resolve(args['policy-module'])).href);
+// 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');
@@ -111,7 +111,6 @@ 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'] ?? policy.startChain) });
@@ -334,7 +333,7 @@ client.on('Page.frameNavigated', ({ frame }, sessionId) => {
   }
 });
 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)}`);
@@ -361,7 +360,7 @@ 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)}`);
   }

package/dist/adapters/extension/run.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { EXIT, optionFlag, optionString } from "@farmslot/recipe-cli/harness";
+import { EXIT, optionFlag } from "@farmslot/recipe-cli/harness";
 import { verifyOwnedCollectorControl } from "../console-capture.js";
 import { resolveExtensionBrowserPid } from "./browser-pid.js";
 import {
@@ -38,28 +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 {
-        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) => ({
@@ -207,16 +188,12 @@ const extensionObservation = {
     start: async (context) => {
       const observation = await import("../../performance-observation.js");
       return observation.startRunPerformanceObservation({
-        backend: (target, env, ports) => observation.createExtensionPerformanceObserver(target, env, ports),
+        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,

package/dist/adapters/plugin-surface.js

@@ -0,0 +1,98 @@
+import path from "node:path";
+import {
+  adapterPlugin,
+  adapterSelectionFailureOut,
+  ensureAdapterLoaded,
+  selectedAdapterId
+} from "@farmslot/recipe-cli/harness";
+import { configPath, declaredLibraryPathEnv, readConfig } from "../review/knowledge.js";
+import { adapterRegistry } from "./registry.js";
+import { bindWebDappPolicy } from "./web-dapp/surface.js";
+function configuredLibrarySources() {
+  let libraries;
+  try {
+    libraries = readConfig(configPath()).libraries;
+  } catch {
+    return [];
+  }
+  return Object.entries(libraries ?? {}).map(([name, root]) => ({ name, root: path.resolve(root) }));
+}
+function operatorLibraryEnv() {
+  const declared = declaredLibraryPathEnv();
+  if (!declared) return process.env;
+  const env = { ...process.env };
+  if (declared.value === void 0) delete env.RECIPE_LIBRARY_PATH;
+  else env.RECIPE_LIBRARY_PATH = declared.value;
+  return env;
+}
+async function loadSelectedAdapter(command, args) {
+  const passthrough = args.indexOf("--");
+  const own = passthrough < 0 ? args : args.slice(0, passthrough);
+  const libraries = [];
+  own.forEach((arg, index) => {
+    if (arg === "--library" && own[index + 1] !== void 0) libraries.push(own[index + 1]);
+    else if (arg.startsWith("--library=")) libraries.push(arg.slice("--library=".length));
+  });
+  const selected = selectedAdapterId(args);
+  try {
+    await ensureAdapterLoaded(selected, {
+      libraries,
+      configured: configuredLibrarySources(),
+      env: operatorLibraryEnv(),
+      adopt: adoptPluginAdapter
+    });
+    return void 0;
+  } catch (error) {
+    const refusal = error;
+    if (typeof refusal.code !== "string" || typeof refusal.userAction !== "string") throw error;
+    if (selected !== void 0 && adapterRegistry.has(selected) && refusal.code !== "ADAPTER_ID_CONFLICT") {
+      return void 0;
+    }
+    return adapterSelectionFailureOut(own.includes("--json"), command, {
+      code: refusal.code,
+      message: String(refusal.message),
+      userAction: refusal.userAction
+    });
+  }
+}
+const ADAPTER_PLUGIN_ENV = "METAMASK_RECIPE_ADAPTER_PLUGIN";
+function adoptPluginAdapter(adapter) {
+  const surface = bindWebDappPolicy(adapter);
+  return {
+    ...surface,
+    run: {
+      ...surface.run,
+      envKeys: [...surface.run?.envKeys ?? [], ADAPTER_PLUGIN_ENV],
+      activateEnv(projectRoot, options) {
+        surface.run?.activateEnv?.(projectRoot, options);
+        process.env[ADAPTER_PLUGIN_ENV] = `${adapter.id} ${adapterPlugin(adapter.id)?.digest ?? "unknown"}`;
+      }
+    },
+    runwayProvision: surface.runwayProvision ?? {
+      async run(target) {
+        return {
+          schemaVersion: 1,
+          command: "provision",
+          adapter: adapter.id,
+          target: path.resolve(target),
+          status: "fail",
+          exitCode: 2,
+          error: {
+            code: "UNSUPPORTED_ADAPTER",
+            message: `${adapter.id} has no mobile simulator to provision.`,
+            userAction: `mm-harness run <recipe> --adapter ${adapter.id}`
+          }
+        };
+      }
+    },
+    readiness: surface.readiness ?? { compatibilityMode: () => "unsupported/no bridge" },
+    fixtures: surface.fixtures ?? { operations: [] }
+  };
+}
+export {
+  ADAPTER_PLUGIN_ENV,
+  adoptPluginAdapter,
+  configuredLibrarySources,
+  loadSelectedAdapter,
+  operatorLibraryEnv
+};

package/dist/adapters/surface.js

@@ -3,7 +3,7 @@ import { adapterRegistry } from "./registry.js";
 import "./mobile/surface.js";
 import "./extension/surface.js";
 import "./core/surface.js";
-import "./terminal/surface.js";
+import "./web-dapp/surface.js";
 function getAdapterSurface(adapter) {
   return adapterRegistry.get(adapter);
 }

package/dist/adapters/{terminal → web-dapp}/actions.js

@@ -1,7 +1,7 @@
 import { manifestPath } from "../../paths.js";
 import { perpsOrderInputFindings } from "../perps-order-inputs.js";
-const terminalActions = {
-  manifestPath: () => manifestPath("terminal"),
+const webDappActions = {
+  manifestPath: () => manifestPath("web-dapp"),
   semantic: [
     "app.network_capture",
     "app.network_assert",
@@ -12,8 +12,8 @@ const terminalActions = {
   ui: (harness, { hudPolicy }) => ({
     base: harness.createCdpWebUiTransport({
       async withPage(input, callback) {
-        const { withTerminalPage } = await import("../../../library/actions/terminal/platform/page.mjs");
-        return withTerminalPage(
+        const { withAppPage } = await import("../../../library/actions/web-dapp/platform/page.mjs");
+        return withAppPage(
           {
             action: input.action,
             node: input.node,
@@ -29,8 +29,8 @@ const terminalActions = {
     }),
     async execute(action, node, context, standard) {
       if (action === "app.hud") {
-        const { showTerminalHud } = await import("../../../library/actions/terminal/platform/hud.mjs");
-        return showTerminalHud(
+        const { showAppHud } = await import("../../../library/actions/web-dapp/platform/hud.mjs");
+        return showAppHud(
           { action, node, context: { nodeId: context.nodeId, projectRoot: context.projectRoot } },
           { hudPolicy }
         );
@@ -42,5 +42,5 @@ const terminalActions = {
   inputFindings: (nodeId, node) => perpsOrderInputFindings(nodeId, node, { ensureChecksOnly: false })
 };
 export {
-  terminalActions
+  webDappActions
 };

package/dist/adapters/web-dapp/console-capture.js

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import path from "node:path";
+import { recipeRuntimePath } from "@farmslot/recipe-cli/harness";
+import { verifyCapture } from "../../../library/actions/shared/console-collector.mjs";
+import { ensureConsoleCollector } from "../console-capture.js";
+import { webDappAdapterId } from "../../../adapters/web-dapp/lib/policy.mjs";
+const WEB_DAPP_CONSOLE_FILES = Object.freeze({
+  app: "app-console.log",
+  extension: "extension-console.log",
+  collectorLog: "console-tail.log",
+  pidFile: "console-tail.pid"
+});
+function webDappRuntimeFile(target, name) {
+  let root = path.resolve(target);
+  try {
+    root = fs.realpathSync(root);
+  } catch {
+  }
+  return recipeRuntimePath(root, webDappAdapterId(), name);
+}
+function webDappCaptureFiles(target) {
+  return {
+    extensionLog: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.extension),
+    pageLog: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.app),
+    collectorLog: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.collectorLog),
+    pidFile: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.pidFile)
+  };
+}
+function webDappCdpPort() {
+  return process.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT;
+}
+async function ensureWebDappConsoleCapture(target) {
+  const cdpPort = webDappCdpPort();
+  if (!cdpPort) {
+    const id = webDappAdapterId();
+    throw new Error(`${id.charAt(0).toUpperCase()}${id.slice(1)} console capture requires the slot CDP port.`);
+  }
+  await ensureConsoleCollector({
+    cdpPort,
+    ...webDappCaptureFiles(target),
+    waitForAttachment: false,
+    cwd: target
+  });
+}
+async function verifyWebDappConsoleControl(capture) {
+  let browser = null;
+  try {
+    const value = JSON.parse(fs.readFileSync(webDappRuntimeFile(capture.projectRoot, "browser.json"), "utf8"));
+    browser = typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    browser = null;
+  }
+  if (typeof browser?.appOrigin !== "string") return { ok: false, detail: "no slot browser state (browser.json) to verify the page console capture against" };
+  return verifyCapture({ cdpPort: capture.cdpPort, log: capture.pageLog, target: "page", appOrigin: browser.appOrigin });
+}
+export {
+  WEB_DAPP_CONSOLE_FILES,
+  ensureWebDappConsoleCapture,
+  verifyWebDappConsoleControl,
+  webDappCaptureFiles,
+  webDappCdpPort,
+  webDappRuntimeFile
+};

package/dist/adapters/web-dapp/doctor-checks.js

@@ -0,0 +1,33 @@
+import { POLICY_ENV, webDappPolicy } from "../../../adapters/web-dapp/lib/policy.mjs";
+import { webDappAppPort, webDappCdpPort } from "./surface.js";
+async function webDappDoctorChecks(target) {
+  if (!process.env[POLICY_ENV]) {
+    return [{
+      id: "web-dapp-venue-policy",
+      status: "fail",
+      required: true,
+      message: "web-dapp needs a venue policy: select an adapter that extends it (e.g. --adapter terminal with its recipe library on RECIPE_LIBRARY_PATH)."
+    }];
+  }
+  const policy = webDappPolicy();
+  const { webDappReadiness } = await import("../../../adapters/web-dapp/lib/readiness.mjs");
+  const { resolveBrowser } = await import("../../../adapters/web-dapp/launch.mjs");
+  const report = await webDappReadiness({
+    policy,
+    target,
+    appPort: webDappAppPort(),
+    cdpPort: webDappCdpPort(),
+    signer: process.env.TERMINAL_SIGNER || "extension",
+    account: process.env.TERMINAL_ACCOUNT || "dev1",
+    probeBrowser: resolveBrowser
+  });
+  return report.checks.map((check) => ({
+    id: `${policy.adapterId}-${check.id}`,
+    status: check.status === "pass" ? "pass" : "fail",
+    required: check.required,
+    message: check.detail
+  }));
+}
+export {
+  webDappDoctorChecks
+};