@deeeed/metamask-harness 0.80.0 → 0.81.0

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

@@ -0,0 +1,68 @@
+import path from "node:path";
+import brokerModule from "@farmslot/recipe-runner/cdp-broker";
+import configModule from "@farmslot/adapter-rn/bridge-runtime/lib/config.cjs";
+const { brokerSocketPath, createBrokerClient } = brokerModule;
+const { resolvePort } = configModule;
+async function createMobileNetworkBackend(target, env) {
+  const { client } = await connectMobileBroker(target, env);
+  return {
+    start(params) {
+      return client.control("capture-start", params, 1e4);
+    },
+    async end(id) {
+      return asRecord(await client.control("capture-end", { id }, 1e4));
+    },
+    async close() {
+      client.close();
+    }
+  };
+}
+async function connectMobileBroker(target, env) {
+  const runtimeDir = env.RECIPE_RUNTIME_DIR ? path.resolve(target, env.RECIPE_RUNTIME_DIR) : path.join(target, "temp", "recipe", "runtime");
+  const socketPath = brokerSocketPath(
+    runtimeDir,
+    resolvePort(env, target)
+  );
+  const discoveryClient = await createBrokerClient(socketPath, "", 1e4);
+  let targets;
+  try {
+    targets = await discoveryClient.control(
+      "resolve-targets",
+      { nameIncludes: mobileTargetPin(env) },
+      1e4
+    );
+  } finally {
+    discoveryClient.close();
+  }
+  const deviceId = selectMobileBrokerTarget(targets, env);
+  const client = await createBrokerClient(socketPath, deviceId, 1e4);
+  return { client, deviceId };
+}
+function selectMobileBrokerTarget(value, env) {
+  const targets = Array.isArray(value) ? value.map(asRecord).filter((target) => target.deviceId) : [];
+  const pin = mobileTargetPin(env);
+  const candidates = pin ? targets.filter(
+    (target) => String(target.name ?? "").toLowerCase().includes(pin.toLowerCase())
+  ) : targets;
+  if (candidates.length !== 1) {
+    throw new Error(
+      `Mobile network observation requires one broker target; found ${candidates.length}.`
+    );
+  }
+  return String(candidates[0].deviceId);
+}
+function mobileTargetPin(env) {
+  const platform = String(
+    env.RECIPE_RN_EXPLICIT_PLATFORM ?? env.RECIPE_HARNESS_PLATFORM ?? ""
+  ).toLowerCase();
+  return String(
+    platform === "android" ? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? "" : platform === "ios" ? env.IOS_SIMULATOR ?? "" : env.IOS_SIMULATOR ?? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? ""
+  ).trim();
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export {
+  connectMobileBroker,
+  createMobileNetworkBackend
+};

package/dist/adapters/mobile/performance-observer.js

@@ -1,9 +1,7 @@
 import {
   createCdpTraceCollector
 } from "../performance/cdp-trace.js";
-import {
-  connectMobileBroker
-} from "../../network-observation.js";
+import { connectMobileBroker } from "./network-observer.js";
 import { createAndroidGfxinfoPerformanceBackend } from "./android-gfxinfo-performance.js";
 async function createMobilePerformanceBackend(target, env) {
   if (resolvePlatform(env) === "android") {

package/dist/adapters/mobile/run.js

@@ -1,4 +1,4 @@
-import { isRecord } from "@farmslot/recipe-cli/harness";
+import { EXIT, isRecord } from "@farmslot/recipe-cli/harness";
 import { spawnSync } from "node:child_process";
 import path from "node:path";
 import { IOS_SIMULATOR_RECORDING_TARGET_PREFIX } from "@farmslot/adapter-rn";
@@ -8,6 +8,7 @@ import {
   resolveAndroidDeviceSerial,
   resolveMobileIosSimulatorName
 } from "./recording-target.js";
+import { emitProofFailure } from "../proof-failure.js";
 import { mobileAppIdentityEnv } from "./app-identity.js";
 import { requireCurrentMobileReleaseArtifactState } from "./release-artifact-state.js";
 const EXPLICIT_DEVICE_KEYS = [
@@ -51,7 +52,10 @@ const mobileRun = {
     ADB_SERIAL: process.env.ADB_SERIAL,
     ANDROID_SERIAL: process.env.ANDROID_SERIAL,
     ...mobileAppIdentityEnv(),
-    METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME: process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME
+    METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME: process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME,
+    // The platform `--platform`/`--device` pinned; the React Native bridge
+    // matches its target against it.
+    RECIPE_RN_EXPLICIT_PLATFORM: process.env.RECIPE_RN_EXPLICIT_PLATFORM
   }),
   // An installed release artifact is opaque: no harness HUD inside it.
   autoHud: () => process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME !== "1",
@@ -65,12 +69,28 @@ const mobileRun = {
   // source only matters for a development build the caller did not restart.
   runtimeCheck({ target, heal, state, json, appRestartAuthored }) {
     if (requireCurrentMobileReleaseArtifactState(target) !== null || appRestartAuthored) return void 0;
-    return async () => {
-      const { ensureMobileProofRuntime } = await import("../../commands/run-engine.js");
-      return ensureMobileProofRuntime(target, heal, state, json);
-    };
+    return () => ensureMobileProofRuntime(target, heal, state, json);
   }
 };
+async function ensureMobileProofRuntime(target, _heal, state, json, deps = {}) {
+  const source = await import("./source-freshness.js");
+  const check = deps.check ?? (() => source.mobileSourceCheck(target));
+  const initial = check();
+  if (initial.status === "unavailable") {
+    emitProofFailure(json, { recoverable: false, error: initial.error });
+    return EXIT.usage;
+  }
+  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 message = `Mobile loaded source is not current (${initial.status}).`;
+  emitProofFailure(json, {
+    recoverable: true,
+    mutations: state.mutations,
+    error: { code: "MOBILE_SOURCE_NOT_LOADED", message, userAction }
+  });
+  return EXIT.infra;
+}
 const mobileRecording = {
   target: (context) => resolveMobileRecordingTarget(context),
   // An Android device records through the mirror, with screenrecord as the
@@ -127,11 +147,13 @@ const mobileDiagnostics = {
 };
 const mobileObservation = {
   network: {
-    backend: async (target, env) => (await import("../../network-observation.js")).createMobileNetworkBackend(target, env)
+    backend: async (target, env) => (await import("./network-observer.js")).createMobileNetworkBackend(target, env)
   },
   performance: {
-    backend: async (target, env) => (await import("./performance-observer.js")).createMobilePerformanceBackend(target, env),
-    platform: (env) => devicePlatformFromEnv(env)
+    start: async (context) => (await import("../../performance-observation.js")).startRunPerformanceObservation({
+      backend: async (target, env) => (await import("./performance-observer.js")).createMobilePerformanceBackend(target, env),
+      platform: (env) => devicePlatformFromEnv(env)
+    }, context)
   }
 };
 function runMobileIssueCommand(projectRoot, command) {
@@ -150,6 +172,7 @@ function runMobileIssueCommand(projectRoot, command) {
   }
 }
 export {
+  ensureMobileProofRuntime,
   mobileDiagnostics,
   mobileObservation,
   mobileRecording,

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

@@ -0,0 +1,36 @@
+function perpsOrderInputFindings(nodeId, node, { ensureChecksOnly }) {
+  const action = node.action;
+  const state = typeof node.state === "string" ? node.state.toLowerCase() : void 0;
+  const createsOrder = action === "metamask.perps.place_order" || !ensureChecksOnly && (action === "metamask.perps.ensure_positions" || action === "metamask.perps.ensure_orders") && (state === "open" || state === "present");
+  if (!createsOrder) return [];
+  const findings = [];
+  const requireOneOf = (names, message) => {
+    const present = names.some((name) => {
+      const value = node[name];
+      return value !== void 0 && value !== null && value !== "";
+    });
+    if (present) return;
+    findings.push({
+      severity: "error",
+      code: "recipe.missing_param",
+      path: `workflow.nodes.${nodeId}.${names[0]}`,
+      message
+    });
+  };
+  requireOneOf(
+    ["market", "symbol"],
+    `${action} requires market=<symbol> (or symbol=<symbol>) before it may create an order`
+  );
+  requireOneOf(
+    ["side"],
+    `${action} requires side=long or side=short before it may create an order`
+  );
+  requireOneOf(
+    ["amount", "notional"],
+    `${action} requires amount=<usd> or notional=<usd> before it may create an order`
+  );
+  return findings;
+}
+export {
+  perpsOrderInputFindings
+};

package/dist/adapters/proof-failure.js

@@ -0,0 +1,11 @@
+function emitProofFailure(json, failure) {
+  if (json) {
+    console.log(JSON.stringify({ schemaVersion: 1, status: "fail", ...failure }, null, 2));
+    return;
+  }
+  console.error(`\u2717 ${failure.error.message}`);
+  console.error(`  Next: ${failure.error.userAction}`);
+}
+export {
+  emitProofFailure
+};

package/dist/adapters/terminal/actions.js

@@ -1,4 +1,5 @@
 import { manifestPath } from "../../paths.js";
+import { perpsOrderInputFindings } from "../perps-order-inputs.js";
 const terminalActions = {
   manifestPath: () => manifestPath("terminal"),
   semantic: [
@@ -36,7 +37,9 @@ const terminalActions = {
       }
       return standard();
     }
-  })
+  }),
+  // ensure_positions and ensure_orders with an open or present state place an order.
+  inputFindings: (nodeId, node) => perpsOrderInputFindings(nodeId, node, { ensureChecksOnly: false })
 };
 export {
   terminalActions

package/dist/adapters/terminal/doctor-checks.js

@@ -2,7 +2,9 @@ import { terminalAppPort, terminalCdpPort } from "./surface.js";
 async function terminalDoctorChecks(target) {
   const { terminalReadiness } = await import("../../../adapters/terminal/lib/readiness.mjs");
   const { resolveBrowser } = await import("../../../adapters/terminal/launch.mjs");
+  const { policy } = await import("../../../adapters/terminal/policy.mjs");
   const report = await terminalReadiness({
+    policy,
     target,
     appPort: terminalAppPort(),
     cdpPort: terminalCdpPort(),

package/dist/adapters/terminal/launch.js

@@ -46,6 +46,9 @@ async function launchTerminal({ options, target, jsonOutput, stream, usage }) {
     cdpPort,
     "--app-port",
     appPort,
+    // The Terminal's venue policy (Hyperliquid hosts, refusal, start page).
+    "--policy-module",
+    path.join(runnerDir, "adapters", "terminal", "policy.mjs"),
     "--signer",
     str(options, "signer") ?? process.env.TERMINAL_SIGNER ?? "extension",
     "--account",

package/dist/adapters/terminal/overlay.js

@@ -3,7 +3,14 @@ import { runnerDir } from "../../paths.js";
 const terminalHarness = {
   install: { entry: "adapters/terminal/inject.mjs", fallback: "adapters/terminal/inject.mjs", node: true },
   cleanup: { entry: "adapters/terminal/cleanup.mjs", fallback: "adapters/terminal/cleanup.mjs", node: true },
-  verify: () => ({ command: process.execPath, prefixArgs: [path.join(runnerDir, "adapters", "terminal", "verify.mjs")] }),
+  verify: () => ({
+    command: process.execPath,
+    prefixArgs: [
+      path.join(runnerDir, "adapters", "terminal", "verify.mjs"),
+      "--policy-module",
+      path.join(runnerDir, "adapters", "terminal", "policy.mjs")
+    ]
+  }),
   restart: "mm-harness launch"
 };
 const terminalRuntimeContext = {

package/dist/adapters/terminal/run.js

@@ -40,11 +40,16 @@ function walletRequestFindings(lines) {
 }
 const terminalObservation = {
   network: {
-    backend: async (_target, env, artifactsDir) => (await import("../../network-observation.js")).createExtensionNetworkBackend(env, artifactsDir)
+    backend: async (_target, env, artifactsDir) => (await import("../extension/network-observer.js")).createExtensionNetworkBackend(env, artifactsDir)
   },
   performance: {
-    backend: async (target, env, ports) => (await import("../../performance-observation.js")).createExtensionPerformanceObserver(target, env, ports),
-    platform: (env) => devicePlatformFromEnv(env)
+    start: async (context) => {
+      const observation = await import("../../performance-observation.js");
+      return observation.startRunPerformanceObservation({
+        backend: (target, env, ports) => observation.createExtensionPerformanceObserver(target, env, ports),
+        platform: (env) => devicePlatformFromEnv(env)
+      }, context);
+    }
   }
 };
 export {

package/dist/adapters/terminal/surface.js

@@ -39,7 +39,9 @@ const terminalSurface = defineAdapter({
   },
   async runtimeStatus(target) {
     const { terminalReadiness: terminalReadiness2 } = await import("../../../adapters/terminal/lib/readiness.mjs");
+    const { policy } = await import("../../../adapters/terminal/policy.mjs");
     const report = await terminalReadiness2({
+      policy,
       target: path.resolve(target),
       appPort: terminalAppPort(),
       cdpPort: terminalCdpPort(),

package/dist/adapters.js

@@ -1,14 +1,13 @@
 import http from "node:http";
 import { createHash } from "node:crypto";
 import { compatibilityMode, fixtureSummary, repoShape } from "./doctor.js";
-import { runLiveAdapterScript } from "@farmslot/recipe-cli/harness";
+import { liveAdapterProcessTimeoutMs, runLiveAdapterScript, runNetworkCaptureAction } from "@farmslot/recipe-cli/harness";
 import { trustedMutationContextExtras } from "./funding-execution-context.js";
 import { LIBRARY_ACTION_NAMESPACE } from "./paths.js";
 import { liveTsxCandidates } from "./live-tsx.js";
 import { resolveWalletImportCredentials, validateWalletImportOptions } from "../library/actions/shared/wallet/import-source.mjs";
 import { isRecord, traceText } from "./action-values.js";
 import { getAdapterSurface } from "./adapters/surface.js";
-import { handleRunNetworkAction } from "./network-observation.js";
 import { handleRunPerformanceAction } from "./performance-observation.js";
 function simpleAdapter(action, executor) {
   return {
@@ -100,6 +99,12 @@ function liveRuntimeConfigured(platform, node) {
   if (!getAdapterSurface(platform).actions.liveNeedsCdpPort) return true;
   return Boolean(node.cdp_port ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT);
 }
+const IMMEDIATE_CLOSE_ALLOWANCE_MS = 18e4;
+function withImmediateCloseBudget(action, node) {
+  if (action !== `${LIBRARY_ACTION_NAMESPACE}.perps.place_order`) return node;
+  if (node.close_immediately !== true && node.closeImmediately !== true) return node;
+  return { ...node, live_adapter_timeout_ms: liveAdapterProcessTimeoutMs(node) + IMMEDIATE_CLOSE_ALLOWANCE_MS };
+}
 async function runLiveFirst(platform, action, node, context, forceLive = false, preparedLiveAdapters) {
   if (node.allow_static_placeholder === true) {
     throw new Error(
@@ -111,7 +116,7 @@ async function runLiveFirst(platform, action, node, context, forceLive = false,
     platform,
     action,
     namespace: LIBRARY_ACTION_NAMESPACE,
-    node,
+    node: withImmediateCloseBudget(action, node),
     context,
     prepared: preparedLiveAdapters?.get(action),
     contextExtras: trustedMutationContextExtras(context),
@@ -131,6 +136,15 @@ function liveAdapterPathHint(platform, action) {
   }
   return `library/actions/${platform}/${action.replaceAll(".", "/")}.mjs`;
 }
+async function handleRunNetworkAction(platform, action, node, context) {
+  if (!getAdapterSurface(platform).observation?.network?.actions) return null;
+  if (action === "app.network_assert") {
+    const assertion = await import("../library/actions/shared/app/network-assert.mjs");
+    return { output: await assertion.assertNetwork({ action, node, context }) };
+  }
+  if (action !== "app.network_capture") return null;
+  return runNetworkCaptureAction(platform, node, context);
+}
 async function semanticResult(platform, action, node, context, forceLive = false, preparedLiveAdapters) {
   const performanceAction = await handleRunPerformanceAction(
     platform,
@@ -368,7 +382,9 @@ function createMetaMaskAdapters(adapter, declaredCustomActions = [], preparedLiv
   return adapters;
 }
 export {
+  IMMEDIATE_CLOSE_ALLOWANCE_MS,
   createMetaMaskAdapters,
   createMetaMaskUiTransport,
-  normalizeUiWaitNode
+  normalizeUiWaitNode,
+  withImmediateCloseBudget
 };

package/dist/cli.js

@@ -1,18 +1,24 @@
 import "./host.js";
 import "./adapters/surface.js";
+import fs from "node:fs";
 import {
   detectAdapter,
+  handleActions,
+  handleCall,
   handleHarness,
   handleLast,
   handleLaunch,
   handleReload,
+  handleRun,
   handleStop,
   parseArgs,
   targetPath
 } from "@farmslot/recipe-cli/harness";
 import { stopProjectCollector } from "../library/actions/shared/analytics/collector.mjs";
 import { adapterRegistry } from "./adapters/registry.js";
-import { handleActions } from "./commands/manifest.js";
+import { applyDeviceTargeting } from "./commands/device-target.js";
+import { metaMaskEngine } from "./engine.js";
+import { walletFixturePath } from "./paths.js";
 import { handleDoctor } from "./commands/doctor.js";
 import { handleProvision } from "./commands/provision.js";
 import { handleRuntimeHealth } from "./commands/runtime-health.js";
@@ -20,9 +26,7 @@ import { handleRuntimeLaunch } from "./commands/runtime-launch.js";
 import { handleRuntimeDecision } from "./commands/runtime-decision.js";
 import { handleResolveExtension } from "./commands/resolve-extension.js";
 import { handleEnsureReady } from "./commands/ensure-ready.js";
-import { handleRun } from "./commands/run.js";
 import { handleSelfTest } from "./commands/self-test.js";
-import { handleCall } from "./commands/call.js";
 import { handleCompletionCandidates, invalidateCompletionCache } from "./commands/completion-candidates.js";
 import { handleLogs } from "./commands/logs.js";
 import { handleDebug } from "./commands/debug.js";
@@ -45,15 +49,35 @@ const stopOptions = {
     return collector.stopped && collector.pid !== null ? [{ label: "analytics collector", pid: collector.pid }] : [];
   }
 };
+const targetDevice = (command, adapter, options) => applyDeviceTargeting(command, adapter, options, { gate: true, rerun: "" });
+const runOptions = {
+  engine: metaMaskEngine,
+  targetDevice,
+  plan: {
+    // The wallet fixture `fixtures set` seeds.
+    steps: (target) => [{
+      step: "fixture.file",
+      confidence: "static",
+      status: "ok",
+      detail: fs.existsSync(walletFixturePath(target)) ? `present: ${walletFixturePath(target)}` : `absent: ${walletFixturePath(target)} (fixtures set to seed)`
+    }],
+    launchDetail: "would launch/attach the app + heal transport (Metro/Chrome/CDP) before executing"
+  }
+};
+const callOptions = {
+  engine: metaMaskEngine,
+  targetDevice,
+  // A wallet action makes the most useful first example.
+  exampleAction: (names) => names.find((name) => /wallet|unlock/u.test(name))
+};
 const COMMANDS = {
-  actions: handleActions,
+  actions: (parsed) => handleActions(parsed, { catalog: metaMaskEngine }),
   doctor: handleDoctor,
   "runtime-health": handleRuntimeHealth,
   "runtime-decision": handleRuntimeDecision,
   "runtime-launch": handleRuntimeLaunch,
   "resolve-extension": handleResolveExtension,
   "ensure-ready": handleEnsureReady,
-  run: handleRun,
   "self-test": handleSelfTest
 };
 const OVERLAY_COMMANDS = ["install", "verify", "cleanup"];
@@ -114,7 +138,8 @@ async function main(argv) {
   if (command === "status" || command === "health" || command === "home") {
     return handleStatus(parseArgs(argv.slice(1)));
   }
-  if (command === "call") return handleCall(argv.slice(1));
+  if (command === "run") return handleRun(argv.slice(1), runOptions);
+  if (command === "call") return handleCall(argv.slice(1), callOptions);
   if (command === "completion-candidates") return handleCompletionCandidates(argv.slice(1));
   if (command === "provision") return handleProvision(parseArgs(argv.slice(1)));
   if (OVERLAY_COMMANDS.includes(command)) {

package/dist/commands/check.js

@@ -8,6 +8,7 @@ const JS_TS_EXT_RE = /\.(?:c|m)?jsx?$|\.tsx?$/u;
 const FORMAT_EXT_RE = /\.(?:c|m)?jsx?$|\.tsx?$|\.json$|\.md$|\.css$|\.scss$|\.ya?ml$/u;
 const TEST_FILE_RE = /(?:^|[./_-])(?:test|spec)\.(?:c|m)?jsx?$|(?:^|[./_-])(?:test|spec)\.tsx?$/u;
 const ESLINT_SUPPRESSION_RE = /^\s*eslint-disable(?:-line|-next-line)?\b/u;
+const EXTENSION_LOCALE_RE = /^app\/_locales\//u;
 async function handleCheck(argv) {
   const { positional, options } = parseArgs(argv);
   const action = positional[0];
@@ -52,10 +53,12 @@ async function handleCheck(argv) {
   const mergeBase = resolveMergeBase(target, baseRef);
   const changedFiles = listChangedFiles(target, mergeBase, artifactsDir);
   const existingChangedFiles = changedFiles.filter((file) => fs.existsSync(path.join(target, file)));
+  const untracked = untrackedFiles(target);
   const suppressionCheck = checkNewEslintSuppressions({
     target,
     artifactsDir,
     mergeBase,
+    untracked,
     files: existingChangedFiles.filter((file) => JS_TS_EXT_RE.test(file))
   });
   const policyFailed = suppressionCheck.status === "fail";
@@ -97,6 +100,9 @@ async function handleCheck(argv) {
         files: existingChangedFiles.filter((file) => TEST_FILE_RE.test(file))
       })
     );
+    if (adapter === "extension") {
+      checks.push(...runExtensionDiffChecks({ target, artifactsDir, packageJson, files: changedFiles }));
+    }
     if (profile === "full") {
       checks.push(runTypecheck({ target, artifactsDir, packageJson }));
     } else {
@@ -187,10 +193,10 @@ function listChangedFiles(target, mergeBase, artifactsDir) {
     }
   };
   if (mergeBase) {
-    addLines(runCommand("git", ["diff", "--name-only", "--diff-filter=ACMR", `${mergeBase}...HEAD`], target).stdout);
+    addLines(runCommand("git", ["diff", "--name-only", "--no-renames", "--diff-filter=ACMRD", `${mergeBase}...HEAD`], target).stdout);
   }
-  addLines(runCommand("git", ["diff", "--name-only", "--diff-filter=ACMR", "HEAD"], target).stdout);
-  addLines(runCommand("git", ["diff", "--cached", "--name-only", "--diff-filter=ACMR"], target).stdout);
+  addLines(runCommand("git", ["diff", "--name-only", "--no-renames", "--diff-filter=ACMRD", "HEAD"], target).stdout);
+  addLines(runCommand("git", ["diff", "--cached", "--name-only", "--no-renames", "--diff-filter=ACMRD"], target).stdout);
   addLines(runCommand("git", ["ls-files", "--others", "--exclude-standard"], target).stdout);
   return [...files].filter((file) => !isUnderArtifactsDir(target, artifactsDir, file)).sort();
 }
@@ -209,9 +215,7 @@ function checkNewEslintSuppressions(input) {
   if (input.files.length === 0) {
     return { id, label, status: "skip", reason: "no changed JS/TS files" };
   }
-  const untracked = new Set(
-    runCommand("git", ["ls-files", "--others", "--exclude-standard"], input.target).stdout.split("\n").map((file) => normalizeRelativePath(file.trim())).filter(Boolean)
-  );
+  const { untracked } = input;
   const findings = [];
   const trackedFiles = input.files.filter((file) => !untracked.has(normalizeRelativePath(file)));
   if (trackedFiles.length > 0) {
@@ -240,6 +244,26 @@ function checkNewEslintSuppressions(input) {
     reason: `${findings.length} newly added eslint-disable directive(s)`
   } : { id, label, status: "pass", logPath };
 }
+function untrackedFiles(target) {
+  return new Set(
+    runCommand("git", ["ls-files", "--others", "--exclude-standard"], target).stdout.split("\n").map((file) => normalizeRelativePath(file.trim())).filter(Boolean)
+  );
+}
+function runExtensionDiffChecks(input) {
+  const scripts = input.packageJson?.scripts && typeof input.packageJson.scripts === "object" ? input.packageJson.scripts : {};
+  const results = [];
+  if (typeof scripts["verify-locales"] === "string") {
+    results.push(
+      input.files.some((file) => EXTENSION_LOCALE_RE.test(normalizeRelativePath(file))) ? runCheckCommand("verify-locales", "Locale strings", input.target, input.artifactsDir, "yarn", ["verify-locales", "--quiet"]) : { id: "verify-locales", label: "Locale strings", status: "skip", reason: "no app/_locales changes" }
+    );
+  }
+  if (typeof scripts["circular-deps:check"] === "string") {
+    results.push(
+      input.files.some((file) => JS_TS_EXT_RE.test(file)) ? runCheckCommand("circular-deps", "Circular dependencies", input.target, input.artifactsDir, "yarn", ["circular-deps:check"]) : { id: "circular-deps", label: "Circular dependencies", status: "skip", reason: "no JS/TS changes" }
+    );
+  }
+  return results;
+}
 function findAddedSuppressions(diff) {
   const findings = [];
   let file = "";

package/dist/commands/completion-candidates.js

@@ -1,4 +1,4 @@
-import { EXIT, parseArgs, optionFlag, optionString, optionStrings, resolveAdapter, targetPath } from "@farmslot/recipe-cli/harness";
+import { EXIT, listRunnableRecipes, parseArgs, optionFlag, optionString, optionStrings, resolveAdapter, resolveLibrarySources, targetPath } from "@farmslot/recipe-cli/harness";
 import { resolveActionManifest } from "../manifest.js";
 import {
   invalidateCompletionCache,
@@ -6,7 +6,7 @@ import {
   writeCompletionCandidates
 } from "../completions-cache.js";
 import { importRecipeProtocol } from "../paths.js";
-import { listRunnableRecipes, resolveMetaMaskLibrarySources } from "./run-engine.js";
+import { metaMaskEngine } from "../engine.js";
 async function handleCompletionCandidates(argv) {
   const kind = argv[0];
   const { options } = parseArgs(argv.slice(1));
@@ -20,7 +20,7 @@ async function handleCompletionCandidates(argv) {
   let candidates;
   if (kind === "actions") {
     adapter = resolveAdapter(options).adapter;
-    const sources = await resolveMetaMaskLibrarySources(optionStrings(options, "library"));
+    const sources = await resolveLibrarySources(metaMaskEngine, optionStrings(options, "library"));
     const { manifest } = await resolveActionManifest(adapter, optionString(options, "actionManifest"), sources);
     const { getRecipeActionManifestActionNames } = await importRecipeProtocol();
     candidates = getRecipeActionManifestActionNames(manifest);
@@ -30,8 +30,8 @@ async function handleCompletionCandidates(argv) {
     const cacheKey = `recipes:${adapter}`;
     candidates = readFreshCandidates(target, cacheKey);
     if (!candidates) {
-      const sources = await resolveMetaMaskLibrarySources(optionStrings(options, "library")).catch(() => void 0);
-      candidates = sources ? (await listRunnableRecipes(adapter, sources)).map((recipe) => recipe.name) : [];
+      const sources = await resolveLibrarySources(metaMaskEngine, optionStrings(options, "library")).catch(() => void 0);
+      candidates = sources ? (await listRunnableRecipes(metaMaskEngine, adapter, sources)).map((recipe) => recipe.name) : [];
       writeCompletionCandidates(target, cacheKey, candidates);
     }
   }

package/dist/commands/self-test.js

@@ -1,10 +1,10 @@
-import { optionFlag, optionString, requiredOption } from "@farmslot/recipe-cli/harness";
+import { optionFlag, optionString, requiredOption, runRecipe } from "@farmslot/recipe-cli/harness";
 import { mkdtemp } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { loadActionManifest, validateManifest } from "../manifest.js";
 import { recipePath, runnerDir } from "../paths.js";
-import { runRecipe } from "./run-engine.js";
+import { metaMaskEngine } from "../engine.js";
 async function handleSelfTest({ options }) {
   const result = await runSelfTest(options);
   if (optionFlag(options, "json")) console.log(JSON.stringify(result, null, 2));
@@ -23,7 +23,8 @@ async function runSelfTest(options) {
       const manifestValidation = await validateManifest(manifest);
       const smokeRecipe = recipePath(`${adapter}/runner/smoke.recipe.json`);
       const artifactsDir = path.join(root, adapter);
-      const result = await runRecipe(adapter, smokeRecipe, artifactsDir, runnerDir, void 0, {
+      const result = await runRecipe(metaMaskEngine, adapter, smokeRecipe, artifactsDir, runnerDir, void 0, {
+        cli: { adapter },
         platform: { skipExtensionRuntimePrepare: true }
       });
       runs.push({ adapter, manifestValidation: manifestValidation.summary, artifactsDir, result });

package/dist/engine.js

@@ -0,0 +1,57 @@
+import path from "node:path";
+import { resolveAdapter } from "@farmslot/recipe-cli/harness";
+import { getAdapterSurface } from "./adapters/surface.js";
+import { consoleClassifier } from "./console-classifier.js";
+import {
+  authorizeTrustedMutationPlan,
+  fixturePolicyMutationBase,
+  fundingOptionsFromCli,
+  isFixturePolicyBase,
+  loadTrustedMutationBase
+} from "./funding-execution-context.js";
+import { resolveActionManifest, validateManifest } from "./manifest.js";
+import { LIBRARY_ACTION_NAMESPACE, runnerDir } from "./paths.js";
+import { metaMaskActionExecutionCapabilities } from "./recipe-security.js";
+const metaMaskEngine = {
+  bundledLibrary: {
+    name: "metamask",
+    root: path.resolve(runnerDir, "library"),
+    actionNamespace: LIBRARY_ACTION_NAMESPACE
+  },
+  resolveActionManifest,
+  validateManifest,
+  actionCapabilities: metaMaskActionExecutionCapabilities,
+  createRunner: async (adapter, manifest, { trustedMutation, ...options }) => {
+    const { createMetaMaskRunner } = await import("./runner.js");
+    return trustedMutation === NO_PLAN_MUTATION ? createMetaMaskRunner(adapter, manifest, { ...options, suppressLibraryResolutionLogs: true }) : createMetaMaskRunner(adapter, manifest, { ...options, trustedMutation });
+  },
+  // Funding files from the run's command line, bound to the run's plan. Without
+  // them, a platform whose actions take a trusted mutation (the Extension) runs a
+  // plan with external mutations in the fixture-policy lane, where each action
+  // applies the shared order policy; any other plan runs without one.
+  trustedMutation: {
+    load: async ({ cli, ...run }) => await loadTrustedMutationBase({ ...fundingOptionsFromCli(cli), ...run }) ?? (takesTrustedMutation(cli) ? fixturePolicyMutationBase({ artifactsDir: run.artifactsDir, rootRecipe: run.rootRecipe }) : void 0),
+    authorize: async (base, plan) => {
+      if (!base || base === NO_PLAN_MUTATION) return void 0;
+      if (isFixturePolicyBase(base) && !plan.nodes.some((node) => node.capabilities.includes("external-mutation"))) {
+        return NO_PLAN_MUTATION;
+      }
+      return authorizeTrustedMutationPlan(base, plan);
+    }
+  },
+  console: consoleClassifier,
+  runnerIncludes: ["src", "adapters", "library", "bin", "dist", "package.json"]
+};
+const NO_PLAN_MUTATION = /* @__PURE__ */ Symbol("no plan mutation");
+function takesTrustedMutation(cli) {
+  let adapter;
+  try {
+    ({ adapter } = resolveAdapter(cli));
+  } catch {
+    return false;
+  }
+  return getAdapterSurface(adapter).actions.trustedMutation === true;
+}
+export {
+  metaMaskEngine
+};