@deeeed/metamask-harness 0.83.0 → 0.84.0

package/dist/adapters/extension/runtime.js

@@ -5,6 +5,7 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { importRecipeHarnessRuntimeBrowserExtension, importRecipeHarnessRuntimeCdp, resolveFarmslotPoolDir, runnerDir } from "../../paths.js";
 import { poolFilesForHost } from "../resolve-slot-ports.js";
+import { macosSessionLocked, SESSION_LOCKED_MESSAGE, SESSION_LOCKED_USER_ACTION } from "../../../adapters/shared/session-lock.mjs";
 import { profileProcessPids } from "./validation-process-ownership.js";
 const require2 = createRequire(import.meta.url);
 const { RUNTIME_NONCE_PREFIX, detachedLaunchUnprovenPath, hasDetachedLaunchUnproven, shellQuote } = require2(
@@ -62,7 +63,7 @@ async function assertHealthyExtensionRuntime(options) {
       seededLaunchDir: options.seededLaunchDir
     });
     if (lastReport.status === "PASS") return lastReport;
-    if (lastReport.errorCode === "UI_COMPOSITOR_SUSPENDED" || lastReport.errorCode === "EXTENSION_BACKGROUND_UNRESPONSIVE") {
+    if (lastReport.errorCode === "SESSION_LOCKED" || lastReport.errorCode === "UI_COMPOSITOR_SUSPENDED" || lastReport.errorCode === "EXTENSION_BACKGROUND_UNRESPONSIVE") {
       throw new Error(formatHealthFailure(lastReport, options.projectRoot));
     }
     if (lastReport.errorCode === "FIXTURE_SEED_NOT_APPLIED") {
@@ -149,18 +150,17 @@ async function checkExtensionRuntimeHealth(projectRoot, cdpPort, options = {}) {
       Math.min(1e3, cdpCallTimeoutMs)
     );
     if (compositor.status === "suspended") {
-      const userAction = compositorRecoveryAction(projectRoot);
+      const suspended = `UI_COMPOSITOR_SUSPENDED: the Extension page is reachable over CDP but its render compositor is not advancing (${compositor.reason ?? "unknown reason"}).`;
+      const locked = macosSessionLocked() === true;
       return {
         status: "FAIL",
-        errorCode: "UI_COMPOSITOR_SUSPENDED",
-        userAction,
+        errorCode: locked ? "SESSION_LOCKED" : "UI_COMPOSITOR_SUSPENDED",
+        userAction: locked ? SESSION_LOCKED_USER_ACTION : compositorRecoveryAction(projectRoot),
         cdpPort,
         targetUrl: target.url,
         extensionId: safeExtensionId(target),
         extensionPageTargets: extensionTargets.length,
-        findings: [
-          `UI_COMPOSITOR_SUSPENDED: the Extension page is reachable over CDP but its render compositor is not advancing (${compositor.reason ?? "unknown reason"}).`
-        ],
+        findings: locked ? [`SESSION_LOCKED: ${SESSION_LOCKED_MESSAGE}`, suspended] : [suspended],
         details: {
           projectRoot,
           targetUrls: targets.map((entry) => entry.url).filter(Boolean),
@@ -669,7 +669,7 @@ async function launchLockedValidationBrowser(options) {
   await stopOwnedCdpListener(options.cdpPort, [
     validationRuntimePath,
     path.join(options.projectRoot, recipeRuntimeDir())
-  ]);
+  ], path.join(options.projectRoot, recipeRuntimeDir()));
   assertNoLiveValidationProfileOwners(validationProfileRoot);
   pruneValidationRuns(validationProfileRoot, 0);
   pruneValidationRuns(validationArtifactsRoot, 4);
@@ -933,16 +933,32 @@ function runProcess(command, args, options) {
     });
   });
 }
-async function stopOwnedCdpListener(cdpPort, runtimePaths) {
+async function stopOwnedCdpListener(cdpPort, runtimePaths, checkoutRuntimeRoot) {
   if (process.platform !== "darwin" && process.platform !== "linux") return;
   let listenerPids = await inspectCdpListenerPids(cdpPort);
   if (listenerPids.length === 0) return;
   const identity = runtimePaths.map((runtimePath) => readValidationRuntimeIdentity(runtimePath, cdpPort)).find((candidate) => candidate?.pid === listenerPids[0]);
-  if (!identity || listenerPids.length !== 1 || listenerPids[0] !== identity.pid || !await browserEchoesRuntimeNonce(cdpPort, identity.nonce)) {
-    throw new Error(`Extension validation will not stop an unowned CDP listener on port ${cdpPort}.`);
+  let pid;
+  if (identity && listenerPids.length === 1 && listenerPids[0] === identity.pid && await browserEchoesRuntimeNonce(cdpPort, identity.nonce)) {
+    pid = identity.pid;
+  }
+  if (pid === void 0) {
+    const listeners = await listenerCommands(listenerPids);
+    const listener = listenerPids.length === 1 ? listeners.get(listenerPids[0]) : void 0;
+    if (listener?.chrome && !listener.ambiguous && pathInsideReal(checkoutRuntimeRoot, listener.profile) && (await listenerCommands(listenerPids)).get(listenerPids[0])?.command === listener.command) {
+      pid = listenerPids[0];
+    } else {
+      const seen = listenerPids.map((candidate) => {
+        const profile = listeners.get(candidate)?.profile;
+        return profile ? `pid ${candidate} --user-data-dir=${profile}` : `pid ${candidate}`;
+      }).join("; ");
+      throw new Error(
+        `Extension validation will not stop an unowned CDP listener on port ${cdpPort} (${seen}). Next: if that is this slot's browser, stop it (kill ${listenerPids.join(" ")}); otherwise free port ${cdpPort}. Then rerun.`
+      );
+    }
   }
   try {
-    process.kill(identity.pid, "SIGTERM");
+    process.kill(pid, "SIGTERM");
   } catch (error) {
     if (error.code !== "ESRCH") throw error;
   }
@@ -950,10 +966,10 @@ async function stopOwnedCdpListener(cdpPort, runtimePaths) {
   do {
     await sleep(50);
     listenerPids = await inspectCdpListenerPids(cdpPort);
-  } while ((listenerPids.length > 0 || processExists(identity.pid)) && Date.now() < termDeadline);
-  if (listenerPids.length > 0 || processExists(identity.pid)) {
+  } while ((listenerPids.length > 0 || processExists(pid)) && Date.now() < termDeadline);
+  if (listenerPids.length > 0 || processExists(pid)) {
     try {
-      process.kill(identity.pid, "SIGKILL");
+      process.kill(pid, "SIGKILL");
     } catch (error) {
       if (error.code !== "ESRCH") throw error;
     }
@@ -961,12 +977,48 @@ async function stopOwnedCdpListener(cdpPort, runtimePaths) {
     do {
       await sleep(50);
       listenerPids = await inspectCdpListenerPids(cdpPort);
-    } while ((listenerPids.length > 0 || processExists(identity.pid)) && Date.now() < killDeadline);
+    } while ((listenerPids.length > 0 || processExists(pid)) && Date.now() < killDeadline);
   }
-  if (listenerPids.length > 0 || processExists(identity.pid)) {
+  if (listenerPids.length > 0 || processExists(pid)) {
     throw new Error(`Extension validation could not stop its CDP listener on port ${cdpPort}.`);
   }
 }
+async function listenerCommands(pids) {
+  const listeners = /* @__PURE__ */ new Map();
+  const result = await runProcess("ps", ["-ww", "-o", "pid=,command=", "-p", pids.join(",")], {
+    cwd: runnerDir,
+    env: process.env,
+    timeoutMs: 5e3
+  });
+  if (result.timedOut) return listeners;
+  for (const line of result.stdout.split("\n")) {
+    const match = line.match(/^\s*(\d+)\s+(.*)$/u);
+    if (!match) continue;
+    const command = match[2];
+    const flags = [...command.matchAll(/(?:^|\s)--user-data-dir=/gu)];
+    const last = flags.at(-1);
+    if (!last) continue;
+    const value = command.slice(last.index + last[0].length);
+    const ends = [...value.matchAll(/\s--/gu)].map((end) => end.index);
+    const profile = value.slice(0, ends[0] ?? value.length);
+    const longerReadings = [...ends.slice(1), value.length].map((end) => value.slice(0, end));
+    listeners.set(Number(match[1]), {
+      command,
+      profile,
+      chrome: /chrom/iu.test(path.basename(command.split(/\s-/u)[0])),
+      ambiguous: flags.length > 1 || !path.isAbsolute(profile) || ends.length > 0 && longerReadings.some((reading) => fs.existsSync(reading))
+    });
+  }
+  return listeners;
+}
+function pathInsideReal(root, candidate) {
+  try {
+    const relative = path.relative(fs.realpathSync(root), fs.realpathSync(candidate));
+    return Boolean(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+  } catch {
+    return false;
+  }
+}
 async function inspectCdpListenerPids(cdpPort) {
   const result = await runProcess("lsof", ["-ti", `tcp:${cdpPort}`, "-sTCP:LISTEN"], {
     cwd: runnerDir,
@@ -1040,5 +1092,6 @@ export {
   extensionBackgroundProbeTimeoutMs,
   formatHealthFailure,
   prepareExtensionRuntime,
-  seededLaunchDir
+  seededLaunchDir,
+  stopOwnedCdpListener
 };

package/dist/adapters/mobile/devices.js

@@ -9,7 +9,11 @@ import {
 } from "../../commands/mobile-device-view.js";
 const mobileDevices = {
   view: mobileDeviceView,
-  live: mobileDeviceLiveView,
+  // adapter-sdk's live view names the app's feature-flag overrides `featureFlags`.
+  async live(target, view) {
+    const live = await mobileDeviceLiveView(target, view);
+    return { ...live, featureFlags: live.featureFlagOverrides };
+  },
   renderList: renderMobileDeviceList,
   renderAdditional: renderAdditionalReachableDevices,
   renderLive: renderMobileLiveBlock,

package/dist/adapters/mobile/run.js

@@ -82,7 +82,7 @@ async function ensureMobileProofRuntime(target, _heal, state, json, deps = {}) {
   }
   if (initial.status === "current") return null;
   const targetArg = JSON.stringify(path.resolve(target));
-  const userAction = `mm-harness call app.lifecycle --arg command=restart --adapter mobile --target ${targetArg}`;
+  const userAction = `mm-harness call app.lifecycle command=restart --adapter mobile --target ${targetArg}`;
   const message = `Mobile loaded source is not current (${initial.status}).`;
   emitProofFailure(json, {
     recoverable: true,

package/dist/adapters/mobile/surface.js

@@ -53,9 +53,8 @@ const mobileSurface = defineAdapter({
   devServer: {
     label: "metro",
     describe: () => "Metro dev server",
-    // Metro's leaves read the port as METRO_PORT; run and call take it as --metro-port.
+    // Metro's leaves read the port as METRO_PORT.
     portEnv: ["METRO_PORT"],
-    portFlags: ["metroPort"],
     stop(target) {
       const leaf = path.join(runnerDir, "adapters", "mobile", "stop-metro.sh");
       const args = ["--target", target];

package/dist/adapters/plugin-surface.js

@@ -1,16 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import {
-  adapterPlugin,
-  adapterSelectionFailureOut,
-  ensureAdapterLoaded,
-  selectedAdapterId
-} from "@farmslot/recipe-cli/harness";
+import { fencePolicy, POLICY_DIGEST_ENV, POLICY_ENV, PolicyFenceError } from "@farmslot/adapter-web/web-dapp";
+import { adapterPlugin, AdapterPluginError } from "@farmslot/recipe-cli/harness";
 import { libraryAdapterFiles } from "@farmslot/recipe-runner";
-import { POLICY_ENV } from "../../adapters/web-dapp/lib/policy.mjs";
-import { POLICY_DIGEST_ENV, PolicyFenceError, fencePolicy } from "../../adapters/web-dapp/lib/policy-fence.mjs";
 import { configPath, declaredLibraryPathEnv, readConfig } from "../review/knowledge.js";
-import { adapterRegistry } from "./registry.js";
 import { bindWebDappPolicy } from "./web-dapp/surface.js";
 function configuredLibrarySources() {
   let libraries;
@@ -29,38 +22,6 @@ function operatorLibraryEnv() {
   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);
-  const builtin = selected !== void 0 && adapterRegistry.has(selected);
-  try {
-    await ensureAdapterLoaded(selected, {
-      libraries,
-      configured: configuredLibrarySources(),
-      env: operatorLibraryEnv(),
-      adopt: adoptPluginAdapter
-    });
-    await fenceBoundPolicy();
-    return void 0;
-  } catch (error) {
-    const refusal = error;
-    if (typeof refusal.code !== "string" || typeof refusal.userAction !== "string") throw error;
-    if (builtin && 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";
 let boundPolicy;
 async function fenceBoundPolicy() {
@@ -80,6 +41,16 @@ async function fenceBoundPolicy() {
     throw error;
   }
 }
+async function afterAdapterLoad() {
+  try {
+    await fenceBoundPolicy();
+  } catch (error) {
+    if (error instanceof PolicyFenceError) {
+      throw new AdapterPluginError("ADAPTER_PLUGIN_INVALID", error.message, error.userAction);
+    }
+    throw error;
+  }
+}
 function adoptPluginAdapter(adapter) {
   const surface = bindWebDappPolicy(adapter);
   const policy = adapter;
@@ -120,7 +91,8 @@ function adoptPluginAdapter(adapter) {
 export {
   ADAPTER_PLUGIN_ENV,
   adoptPluginAdapter,
+  afterAdapterLoad,
   configuredLibrarySources,
-  loadSelectedAdapter,
+  fenceBoundPolicy,
   operatorLibraryEnv
 };

package/dist/adapters/session-lock.js

@@ -0,0 +1,23 @@
+import { Writable } from "node:stream";
+import { EXIT, optionFlag } from "@farmslot/recipe-cli/harness";
+import {
+  macosSessionLocked,
+  SESSION_LOCKED_MESSAGE,
+  SESSION_LOCKED_USER_ACTION
+} from "../../adapters/shared/session-lock.mjs";
+import { emitProofFailure } from "./proof-failure.js";
+function refuseLockedSession(json, options = {}) {
+  if (macosSessionLocked() !== true) return null;
+  const error = { code: "SESSION_LOCKED", message: SESSION_LOCKED_MESSAGE, userAction: SESSION_LOCKED_USER_ACTION };
+  if (optionFlag(options, "jsonStream")) emitRunStreamError(error);
+  emitProofFailure(json, { recoverable: false, error });
+  return EXIT.infra;
+}
+function emitRunStreamError(error) {
+  const line = JSON.stringify({ schemaVersion: 1, command: "run", event: "error", error, ts: (/* @__PURE__ */ new Date()).toISOString() });
+  Writable.prototype.write.call(process.stdout, `${line}
+`);
+}
+export {
+  refuseLockedSession
+};

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

@@ -1,23 +1,7 @@
 import fs from "node:fs";
-import path from "node:path";
-import { recipeRuntimePath } from "@farmslot/recipe-cli/harness";
+import { WEB_DAPP_CONSOLE_FILES, webDappAdapterId, webDappRuntimeFile } from "@farmslot/adapter-web/web-dapp";
 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),
@@ -54,10 +38,8 @@ async function verifyWebDappConsoleControl(capture) {
   return verifyCapture({ cdpPort: capture.cdpPort, log: capture.pageLog, target: "page", appOrigin: browser.appOrigin });
 }
 export {
-  WEB_DAPP_CONSOLE_FILES,
   ensureWebDappConsoleCapture,
   verifyWebDappConsoleControl,
   webDappCaptureFiles,
-  webDappCdpPort,
-  webDappRuntimeFile
+  webDappCdpPort
 };

package/dist/adapters/web-dapp/run.js

@@ -1,44 +1,43 @@
+import fs from "node:fs";
 import path from "node:path";
+import { ownsProcess, webDappRuntimeFile } from "@farmslot/adapter-web/web-dapp";
 import { isRecord } from "@farmslot/recipe-cli/harness";
 import { verifyOwnedCollectorControl } from "../console-capture.js";
+import { refuseLockedSession } from "../session-lock.js";
 import { devicePlatformFromEnv } from "../performance/device-platform.js";
 import {
   ensureWebDappConsoleCapture,
   webDappCaptureFiles,
   webDappCdpPort,
-  webDappRuntimeFile,
   verifyWebDappConsoleControl
 } from "./console-capture.js";
+async function webDappRunHeadless(target) {
+  const stateFile = webDappRuntimeFile(target, "browser.json");
+  try {
+    const state = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+    if (isRecord(state) && isRecord(state.browser) && typeof state.browser.headless === "boolean") {
+      if (ownsProcess("browser", state.browserPid, path.dirname(stateFile))) return state.browser.headless;
+    }
+  } catch {
+  }
+  try {
+    const { resolveHeadless } = await import("../../../library/actions/web-dapp/platform/adapter-web-lib.mjs");
+    return resolveHeadless();
+  } catch {
+    return null;
+  }
+}
+const webDappRun = {
+  runtimeCheck: ({ target, options, json }) => async () => await webDappRunHeadless(target) === false ? refuseLockedSession(json, options) : null
+};
 const webDappDiagnostics = {
   console: {
     start: (projectRoot) => ensureWebDappConsoleCapture(projectRoot),
     files: (projectRoot) => webDappCaptureFiles(projectRoot),
     cdpPort: () => webDappCdpPort(),
     verifyControl: (capture) => verifyOwnedCollectorControl(capture, () => verifyWebDappConsoleControl(capture))
-  },
-  requestLog: {
-    path: (projectRoot) => webDappRuntimeFile(projectRoot, "wallet-requests.jsonl"),
-    findings: (lines) => walletRequestFindings(lines)
   }
 };
-function walletRequestFindings(lines) {
-  const findings = [];
-  for (const line of lines) {
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (!isRecord(entry)) continue;
-    let text = null;
-    if (entry.kind === "blocked-mainnet" && entry.probe !== true) text = `blocked-mainnet: ${String(entry.transport ?? "request")} to ${String(entry.url ?? "?")}`;
-    else if (entry.kind === "refused-mainnet") text = `refused-mainnet: ${String(entry.method ?? "?")} (${String(entry.reason ?? "?")})`;
-    else if (entry.kind === "unattributed") text = `unattributed wallet ${entry.binding === "request" ? "request" : "log entry"}${typeof entry.method === "string" ? ` (${entry.method})` : ""}`;
-    if (text) findings.push({ level: "error", source: "wallet", text });
-  }
-  return findings;
-}
 const webDappObservation = {
   network: {
     backend: async (target, env, artifactsDir) => (await import("../extension/network-observer.js")).createLoadedExtensionNetworkBackend(
@@ -59,5 +58,7 @@ const webDappObservation = {
 };
 export {
   webDappDiagnostics,
-  webDappObservation
+  webDappObservation,
+  webDappRun,
+  webDappRunHeadless
 };

package/dist/adapters/web-dapp/surface.js

@@ -1,82 +1,38 @@
-import { shellQuote } from "@farmslot/recipe-cli/harness";
 import path from "node:path";
 import { defineAdapter } from "@farmslot/adapter-sdk";
-import fs from "node:fs";
-import { POLICY_ENV, webDappAdapterId, webDappPolicy } from "../../../adapters/web-dapp/lib/policy.mjs";
-import { WEB_DAPP_CONSOLE_FILES, webDappRuntimeFile } from "./console-capture.js";
-import { stopWebDappBrowserSync } from "./stop.js";
+import {
+  bindWebDappPolicy as bindPolicy,
+  createWebDappAdapter,
+  POLICY_ENV,
+  SIGNER_MODULE_ENV,
+  webDappAdapterId,
+  webDappPolicy
+} from "@farmslot/adapter-web/web-dapp";
+import { runnerDir } from "../../paths.js";
 import { adapterRegistry } from "../registry.js";
 import { webDappActions } from "./actions.js";
-import { webDappHarness, webDappRuntimeContext } from "./overlay.js";
-import { webDappReadiness } from "./readiness.js";
-import { webDappDiagnostics, webDappObservation } from "./run.js";
-function portFromEnv(...names) {
-  for (const name of names) {
-    const raw = process.env[name];
-    if (raw && /^\d+$/u.test(raw)) return Number(raw);
-  }
-  return void 0;
-}
-function webDappAppPort() {
-  return portFromEnv("TERMINAL_APP_PORT", "RECIPE_WATCHER_PORT", "WATCHER_PORT");
-}
-function webDappCdpPort() {
-  return portFromEnv("RECIPE_CDP_PORT", "CDP_PORT");
-}
-function webDappSignerFor(target) {
-  try {
-    const state = JSON.parse(fs.readFileSync(webDappRuntimeFile(target, "browser.json"), "utf8"));
-    if (typeof state.signer === "string") return state.signer;
-  } catch {
-  }
-  return process.env.TERMINAL_SIGNER || "extension";
-}
+import { webDappDiagnostics, webDappObservation, webDappRun } from "./run.js";
+const METAMASK_SIGNER_MODULE = path.join(runnerDir, "adapters", "web-dapp", "metamask-signer.mjs");
 function bindWebDappPolicy(adapter) {
+  bindPolicy(adapter);
   if (adapter.extends === "web-dapp" && typeof adapter.policy?.module === "string") {
-    process.env[POLICY_ENV] = adapter.policy.module;
+    process.env[SIGNER_MODULE_ENV] = METAMASK_SIGNER_MODULE;
   }
   return adapter;
 }
-const webDappSurface = defineAdapter({
+const generic = createWebDappAdapter({
   id: "web-dapp",
-  sdkVersion: 1,
-  headless: false,
-  resolveSlotPorts() {
-  },
-  async runtimeStatus(target) {
-    if (!process.env[POLICY_ENV]) {
-      return {
-        decision: "blocked",
-        reasonCode: "web-dapp-venue-policy",
-        reasons: ["web-dapp needs a venue policy: select an adapter that extends it"],
-        nextAction: "pass --adapter <the adapter that extends web-dapp>, e.g. --adapter terminal, with its recipe library on RECIPE_LIBRARY_PATH",
-        deps: "missing",
-        devServer: { label: "next", status: "down" }
-      };
-    }
-    const policy = webDappPolicy();
-    const { webDappReadiness: webDappReadiness2 } = await import("../../../adapters/web-dapp/lib/readiness.mjs");
-    const report = await webDappReadiness2({
-      policy,
-      target: path.resolve(target),
-      appPort: webDappAppPort(),
-      cdpPort: webDappCdpPort(),
-      signer: process.env.TERMINAL_SIGNER || "extension"
-    });
-    const blocking = report.checks.filter((check) => check.required && check.status === "fail");
-    const devServer = report.checks.find((check) => check.id === "app-dev-server");
-    return {
-      decision: blocking.length === 0 ? "ready" : "blocked",
-      reasonCode: blocking[0]?.id,
-      reasons: (blocking.length ? blocking : report.checks).map((check) => `${check.id}: ${check.detail}`),
-      nextAction: blocking.length === 0 ? void 0 : blocking[0].id === "app-dev-server" || blocking[0].id === "testnet-forced" ? "start the slot dev server with testnet forced (Farmslot preflight), then retry" : `mm-harness doctor --adapter ${policy.adapterId} --target ${shellQuote(path.resolve(target))} --json`,
-      deps: report.checks.find((check) => check.id === "dependencies")?.status === "pass" ? "current" : "missing",
-      devServer: {
-        label: "next",
-        status: devServer?.status === "pass" ? "up" : "down"
-      }
-    };
-  },
+  signerModule: METAMASK_SIGNER_MODULE,
+  cli: "mm-harness",
+  hooks: {
+    actions: webDappActions,
+    run: webDappRun,
+    diagnostics: webDappDiagnostics,
+    observation: webDappObservation
+  }
+});
+const webDappSurface = defineAdapter({
+  ...generic,
   runwayProvision: {
     async run(target, options) {
       return {
@@ -94,41 +50,12 @@ const webDappSurface = defineAdapter({
       };
     }
   },
-  devServer: {
-    label: "browser",
-    describe: () => `${webDappAdapterId()} slot browser and wallet host (the Next.js dev server belongs to the slot)`,
-    stop(target) {
-      const result = stopWebDappBrowserSync(target);
-      return { kind: "stopped", status: result.status, summary: result.summary, output: result.output };
-    }
-  },
-  logSources(target) {
-    return [
-      { label: "app-console", path: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.app) },
-      ...webDappSignerFor(target) === "extension" ? [{ label: "extension-console", path: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.extension) }] : [],
-      { label: "wallet-requests", path: webDappRuntimeFile(target, "wallet-requests.jsonl") },
-      { label: "wallet-host", path: webDappRuntimeFile(target, "wallet-host.log") },
-      { label: "browser", path: webDappRuntimeFile(target, "browser.log") },
-      { label: "next", path: path.join(target, "temp/farmslot/next-dev.log") }
-    ];
-  },
-  // The app page's console and uncaught exceptions, as the Extension's
-  // diagnostics read the extension console: errors make a run REVIEW.
-  appLogSource(target) {
-    return { label: "app-console", path: webDappRuntimeFile(target, WEB_DAPP_CONSOLE_FILES.app) };
-  },
-  flags: { launch: ["freshProfile", "headless", "headful"] },
-  hints: {
-    // Bare web-dapp has no venue: every hint names the adapter that extends it.
-    launch: "pass --adapter <the adapter that extends web-dapp>, e.g. --adapter terminal, with its recipe library on RECIPE_LIBRARY_PATH",
-    relaunch: "pass --adapter <the adapter that extends web-dapp>, e.g. --adapter terminal, with --fresh-profile",
-    runtimeProbeRecovery: () => "pass --adapter <the adapter that extends web-dapp>, e.g. --adapter terminal, with its recipe library on RECIPE_LIBRARY_PATH"
+  // adapter-web's slot readiness (with MetaMask's own checks) and capture providers.
+  readiness: {
+    liveChecks: generic.readiness.liveChecks,
+    captureProviders: generic.readiness.captureProviders,
+    compatibilityMode: (target) => process.env[POLICY_ENV] && webDappPolicy().checkout.matches(target) ? "slot browser over CDP (website; no product bridge)" : "unsupported/no bridge"
   },
-  launch: async (context) => (await import("./launch.js")).launchWebDapp(context),
-  actions: webDappActions,
-  harness: webDappHarness,
-  runtimeContext: webDappRuntimeContext,
-  readiness: webDappReadiness,
   fixtures: { operations: ["init", "sync", "set"] },
   debug: {
     args: ({ devMenu }) => [
@@ -136,14 +63,11 @@ const webDappSurface = defineAdapter({
       "--action",
       devMenu ? "dev-menu" : "debug"
     ]
-  },
-  diagnostics: webDappDiagnostics,
-  observation: webDappObservation
+  }
 });
 adapterRegistry.register(webDappSurface);
 export {
+  METAMASK_SIGNER_MODULE,
   bindWebDappPolicy,
-  webDappAppPort,
-  webDappCdpPort,
   webDappSurface
 };