@deeeed/metamask-harness 0.78.0 → 0.80.0

package/dist/run-recording.js

@@ -1,481 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import { optionalVideoTiming, readCaptureHelperTiming, writeRecordingTimeline } from "@farmslot/recipe-harness";
-import { getAdapterSurface } from "./adapters/surface.js";
-import {
-  captureHelperSupportsRecordSessionSnapshots,
-  captureHelperSupportsCapability
-} from "./recording-target.js";
-const activeRecordingsByPid = /* @__PURE__ */ new Map();
-const ACTIVE_EXTENSION_RECORDING_PID = "METAMASK_RECIPE_EXTENSION_ACTIVE_RECORDING_PID";
-async function startRecipeRecording(adapter, projectRoot, artifactsDir, options) {
-  if (!options.record) return void 0;
-  if (process.platform !== "darwin") {
-    console.error(
-      "WARN: --record-video uses capture-helper and is currently supported only on macOS; continuing without video."
-    );
-    return void 0;
-  }
-  const framed = getAdapterSurface(adapter).recording?.framed;
-  if (!framed) return void 0;
-  const cdpPort = options.cdpPort ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT;
-  if (!captureHelperSupportsRecordSessionSnapshots(projectRoot)) {
-    console.error(
-      "WARN: framed extension recording requires capture-helper capability record_session_snapshot; falling back to harness --record-video."
-    );
-    return void 0;
-  }
-  const pid = framed.browserPid(projectRoot, artifactsDir, cdpPort);
-  if (!pid) {
-    console.error(
-      `WARN: framed extension recording could not resolve browser PID from CDP port ${cdpPort ?? "<unset>"}; falling back to harness --record-video.`
-    );
-    return void 0;
-  }
-  const recordArgs = ["record", "--framed", "--pid", String(pid)];
-  const relativePath = "videos/full-run.mp4";
-  const outputPath = path.join(artifactsDir, relativePath);
-  const { stagingDir, stagedPath } = preparePrivateRecordingDestination(
-    artifactsDir,
-    outputPath
-  );
-  let child;
-  const startedAtUnixMs = Date.now();
-  try {
-    child = spawn(captureHelperPath(), [...recordArgs, "--output", stagedPath], {
-      cwd: projectRoot,
-      env: process.env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch (error) {
-    cleanupRecordingStaging(stagingDir);
-    throw error;
-  }
-  const recording = {
-    child,
-    startedAtUnixMs,
-    nativeTiming: captureHelperSupportsCapability(projectRoot, "record_session_timing_v1"),
-    outputPath,
-    stagingDir,
-    stagedPath,
-    relativePath,
-    pid,
-    stdout: "",
-    stderr: "",
-    exited: false,
-    exitCode: null,
-    frameReady: false,
-    finalized: false,
-    previousActiveRecordingPid: process.env[ACTIVE_EXTENSION_RECORDING_PID],
-    stderrBuffer: "",
-    pendingSnapshots: /* @__PURE__ */ new Map()
-  };
-  child.stdout.on("data", (chunk) => {
-    recording.stdout += String(chunk);
-  });
-  child.stderr.on("data", (chunk) => {
-    recording.stderr += String(chunk);
-    handleRecordingStderr(recording, String(chunk));
-  });
-  child.on("error", (error) => {
-    recording.error = error;
-    recording.stderr += error.message;
-    recording.exited = true;
-  });
-  child.on("close", (exitCode) => {
-    recording.stoppedAtUnixMs = Date.now();
-    recording.exited = true;
-    recording.exitCode = exitCode;
-    activeRecordingsByPid.delete(recording.pid);
-    restoreActiveRecordingEnvironment(recording);
-    rejectPendingSnapshots(recording, new Error(`capture-helper recording exited before snapshot completed (code=${exitCode ?? "unknown"})`));
-  });
-  await waitForRecordingReady(recording, 15e3);
-  if (recording.exited) {
-    cleanupRecordingStaging(recording.stagingDir);
-    throw new Error(
-      `capture-helper exited before recording its first frame (code=${recording.exitCode ?? "unknown"}): ${recording.stderr || recording.stdout}`
-    );
-  }
-  if (!recording.frameReady) {
-    try {
-      await stopRecordingProcess(recording);
-    } finally {
-      cleanupRecordingStaging(recording.stagingDir);
-    }
-    throw new Error(
-      `capture-helper did not record a frame within 15000ms: ${recording.stderr || recording.stdout || "no recorder output"}`
-    );
-  }
-  activeRecordingsByPid.set(pid, recording);
-  process.env[ACTIVE_EXTENSION_RECORDING_PID] = String(pid);
-  console.error(`INFO: recording recipe video with capture-helper pid=${pid} output=${outputPath}`);
-  return recording;
-}
-async function captureActiveRecipeRecordingSnapshot(pid, outputPath, timeoutMs = 3e4) {
-  const recording = activeRecordingsByPid.get(pid);
-  if (!recording || recording.exited) return void 0;
-  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-  fs.rmSync(outputPath, { force: true });
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      recording.pendingSnapshots.delete(outputPath);
-      reject(new Error(`capture-helper record session snapshot timed out after ${timeoutMs}ms: ${outputPath}`));
-    }, timeoutMs);
-    recording.pendingSnapshots.set(outputPath, { outputPath, timer, resolve, reject });
-    recording.child.stdin.write(`snapshot ${outputPath}
-`, (error) => {
-      if (!error) return;
-      clearTimeout(timer);
-      recording.pendingSnapshots.delete(outputPath);
-      reject(error);
-    });
-  });
-}
-async function stopRecipeRecording(recording, result) {
-  if (!recording || recording.finalized) return;
-  recording.finalized = true;
-  try {
-    await stopRecordingProcess(recording);
-    const validation = await validateRecordingArtifact(recording);
-    if (validation.ok === false) {
-      throw new Error(
-        `capture-helper recording did not produce a usable video artifact: ${validation.reason}`
-      );
-    }
-    publishRecordingArtifact(recording);
-    if (result) await addRecordingArtifactToManifest(result, recording);
-  } catch (error) {
-    if (result) removeRecordingArtifactFromManifest(result, recording.relativePath);
-    throw error;
-  } finally {
-    activeRecordingsByPid.delete(recording.pid);
-    restoreActiveRecordingEnvironment(recording);
-    cleanupRecordingStaging(recording.stagingDir);
-  }
-}
-async function stopRecordingProcess(recording) {
-  if (!recording.exited && !recording.child.stdin.destroyed) {
-    recording.child.stdin.end("stop\n");
-    await waitForRecordingExit(recording, 15e3);
-  }
-  if (!recording.exited) {
-    recording.child.kill("SIGINT");
-    await waitForRecordingExit(recording, 5e3);
-  }
-  if (!recording.exited) {
-    recording.child.kill("SIGTERM");
-    await waitForRecordingExit(recording, 3e3);
-  }
-  if (!recording.exited) {
-    recording.child.kill("SIGKILL");
-    await waitForRecordingExit(recording, 2e3);
-  }
-  if (!recording.exited) {
-    throw new Error(`capture-helper recording process did not exit: pid=${recording.child.pid ?? "unknown"}`);
-  }
-}
-async function waitForRecordingExit(recording, timeoutMs) {
-  if (recording.exited) return;
-  await new Promise((resolve) => {
-    const finish = () => {
-      clearTimeout(timer);
-      recording.child.removeListener("close", finish);
-      resolve();
-    };
-    const timer = setTimeout(finish, timeoutMs);
-    recording.child.once("close", finish);
-    if (recording.exited) finish();
-  });
-}
-async function waitForRecordingReady(recording, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (!recording.frameReady && !recording.exited && Date.now() < deadline) {
-    await sleep(50);
-  }
-}
-function handleRecordingStderr(recording, chunk) {
-  recording.stderrBuffer += chunk;
-  let newlineIndex = recording.stderrBuffer.indexOf("\n");
-  while (newlineIndex !== -1) {
-    const line = recording.stderrBuffer.slice(0, newlineIndex).trim();
-    recording.stderrBuffer = recording.stderrBuffer.slice(newlineIndex + 1);
-    if (line) handleRecordingEventLine(recording, line);
-    newlineIndex = recording.stderrBuffer.indexOf("\n");
-  }
-}
-function handleRecordingEventLine(recording, line) {
-  let event;
-  try {
-    const parsed = JSON.parse(line);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
-    event = parsed;
-  } catch {
-    return;
-  }
-  if (event.type === "info" && typeof event.msg === "string" && /^record frames=[1-9]\d*$/.test(event.msg)) {
-    recording.frameReady = true;
-  }
-  if (event.type === "record_complete" && event.output === recording.stagedPath) {
-    recording.completedVideo = typeof event.frames === "number" && event.frames > 0;
-    if (typeof event.recording_id === "string") recording.completedRecordingId = event.recording_id;
-  }
-  const output = typeof event.output === "string" ? event.output : void 0;
-  if (!output) return;
-  const pending = recording.pendingSnapshots.get(output);
-  if (!pending) return;
-  if (event.type === "snapshot") {
-    clearTimeout(pending.timer);
-    recording.pendingSnapshots.delete(output);
-    pending.resolve(event);
-    return;
-  }
-  if (event.type === "error") {
-    clearTimeout(pending.timer);
-    recording.pendingSnapshots.delete(output);
-    pending.reject(new Error(String(event.message ?? `capture-helper snapshot failed: ${output}`)));
-  }
-}
-function rejectPendingSnapshots(recording, error) {
-  for (const pending of recording.pendingSnapshots.values()) {
-    clearTimeout(pending.timer);
-    pending.reject(error);
-  }
-  recording.pendingSnapshots.clear();
-}
-async function validateRecordingArtifact(recording) {
-  if (!fs.existsSync(recording.stagedPath)) {
-    return { ok: false, reason: `missing output ${recording.stagedPath}` };
-  }
-  const stagedStat = fs.lstatSync(recording.stagedPath);
-  if (stagedStat.isSymbolicLink() || !stagedStat.isFile()) {
-    return { ok: false, reason: `unsafe non-regular output ${recording.stagedPath}` };
-  }
-  const size = stagedStat.size;
-  if (size === 0) {
-    return { ok: false, reason: `empty output ${recording.stagedPath}` };
-  }
-  const recorderOutput = `${recording.stdout}
-${recording.stderr}`;
-  if (recording.nativeTiming) {
-    if (!recording.completedVideo) return { ok: false, reason: "Missing finalized video completion" };
-    recording.nativeTimingEvidence = await readNativeRecordingTiming(recording);
-    return { ok: true };
-  }
-  if (!recorderOutput.includes("record_complete")) {
-    return {
-      ok: false,
-      reason: `capture-helper did not report record_complete for ${recording.stagedPath}: ${recorderOutput.trim() || "no recorder output"}`
-    };
-  }
-  const ffprobe = spawnSync(
-    "ffprobe",
-    ["-hide_banner", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", recording.stagedPath],
-    { encoding: "utf8" }
-  );
-  if (ffprobe.error && ffprobe.error.code === "ENOENT") {
-    return { ok: true };
-  }
-  if (ffprobe.error) {
-    return { ok: false, reason: `ffprobe failed for ${recording.stagedPath}: ${ffprobe.error.message}` };
-  }
-  if (ffprobe.status !== 0) {
-    return {
-      ok: false,
-      reason: `invalid MP4 ${recording.stagedPath}: ${ffprobe.stderr.trim() || ffprobe.stdout.trim() || `ffprobe exited ${ffprobe.status}`}`
-    };
-  }
-  const durationSeconds = Number(ffprobe.stdout.trim());
-  if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) {
-    return { ok: false, reason: `MP4 has no positive duration: ${recording.stagedPath}` };
-  }
-  return { ok: true };
-}
-async function readNativeRecordingTiming(recording) {
-  try {
-    if (!recording.completedRecordingId) throw new Error("Missing native recording completion identity");
-    const sidecar = recording.stagedPath + ".timing.json";
-    const entry = fs.lstatSync(sidecar);
-    if (!entry.isFile() || entry.isSymbolicLink()) throw new Error("Native timing must be a regular file");
-    const native = JSON.parse(fs.readFileSync(sidecar, "utf8"));
-    if (native.recording_id !== recording.completedRecordingId) throw new Error("Native recording identity mismatch");
-    return await readCaptureHelperTiming(recording.stagedPath);
-  } catch (error) {
-    return { timingUnavailableReason: error instanceof Error ? error.message : String(error) };
-  }
-}
-function preparePrivateRecordingDestination(artifactsDir, outputPath) {
-  const outputDir = path.dirname(outputPath);
-  ensureRecordingDirectory(path.resolve(artifactsDir), outputDir);
-  refuseRecordingDestinationSymlink(outputPath);
-  const stagingDir = fs.mkdtempSync(path.join(outputDir, ".mm-harness-recording-"));
-  fs.chmodSync(stagingDir, 448);
-  return {
-    stagingDir,
-    stagedPath: path.join(stagingDir, "full-run.mp4")
-  };
-}
-function ensureRecordingDirectory(artifactsRoot, outputDir) {
-  fs.mkdirSync(artifactsRoot, { recursive: true });
-  requireRecordingDirectory(artifactsRoot);
-  const relative = path.relative(artifactsRoot, outputDir);
-  let current = artifactsRoot;
-  for (const segment of relative.split(path.sep).filter(Boolean)) {
-    current = path.join(current, segment);
-    try {
-      fs.mkdirSync(current);
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-    }
-    requireRecordingDirectory(current);
-  }
-}
-function requireRecordingDirectory(directory) {
-  const entry = fs.lstatSync(directory);
-  if (entry.isDirectory() && !entry.isSymbolicLink()) return;
-  throw new Error(
-    `Refusing unsafe recording artifact directory: ${directory}
-Next: replace ${JSON.stringify(directory)} with a regular directory and retry the recipe.`
-  );
-}
-function publishRecordingArtifact(recording) {
-  publishPrivateRecordingFile(recording.stagedPath, recording.outputPath);
-  if (recording.nativeTimingEvidence?.timing) {
-    try {
-      publishPrivateRecordingFile(recording.stagedPath + ".timing.json", recording.outputPath + ".timing.json");
-    } catch (error) {
-      recording.nativeTimingEvidence = { timingUnavailableReason: error instanceof Error ? error.message : String(error) };
-    }
-  }
-}
-function publishPrivateRecordingFile(sourcePath, outputPath) {
-  const noFollow = fs.constants.O_NOFOLLOW ?? 0;
-  let descriptor;
-  try {
-    descriptor = fs.openSync(sourcePath, fs.constants.O_RDONLY | noFollow);
-    const stagedStat = fs.fstatSync(descriptor);
-    if (!stagedStat.isFile()) {
-      throw unsafeRecordingArtifactError(sourcePath);
-    }
-    fs.fchmodSync(descriptor, 384);
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("Next:")) throw error;
-    throw unsafeRecordingArtifactError(
-      sourcePath,
-      error instanceof Error ? error.message : String(error)
-    );
-  } finally {
-    if (descriptor !== void 0) fs.closeSync(descriptor);
-  }
-  refuseRecordingDestinationSymlink(outputPath);
-  fs.renameSync(sourcePath, outputPath);
-}
-function refuseRecordingDestinationSymlink(outputPath) {
-  try {
-    const destination = fs.lstatSync(outputPath);
-    if (destination.isSymbolicLink()) {
-      throw new Error(
-        `Refusing recording artifact destination symlink: ${outputPath}
-Next: rm -- ${JSON.stringify(outputPath)} and retry the recipe.`
-      );
-    }
-    if (!destination.isFile()) {
-      throw new Error(
-        `Refusing non-file recording artifact destination: ${outputPath}
-Next: remove ${JSON.stringify(outputPath)} and retry the recipe.`
-      );
-    }
-  } catch (error) {
-    if (error.code === "ENOENT") return;
-    throw error;
-  }
-}
-function unsafeRecordingArtifactError(stagedPath, detail) {
-  return new Error(
-    `Capture-helper recording output is not a safe regular file: ${stagedPath}${detail ? ` (${detail})` : ""}.
-Next: capture-helper doctor --json`
-  );
-}
-function cleanupRecordingStaging(stagingDir) {
-  try {
-    fs.rmSync(stagingDir, { recursive: true, force: true });
-  } catch (error) {
-    console.error(
-      `WARN: could not remove capture-helper staging directory ${stagingDir}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-function restoreActiveRecordingEnvironment(recording) {
-  if (process.env[ACTIVE_EXTENSION_RECORDING_PID] !== String(recording.pid)) return;
-  if (recording.previousActiveRecordingPid === void 0) {
-    delete process.env[ACTIVE_EXTENSION_RECORDING_PID];
-    return;
-  }
-  process.env[ACTIVE_EXTENSION_RECORDING_PID] = recording.previousActiveRecordingPid;
-}
-async function addRecordingArtifactToManifest(result, recording) {
-  const manifestPath = result.artifactManifestPath;
-  if (!manifestPath || !fs.existsSync(manifestPath)) {
-    console.error(`WARN: cannot add video artifact to missing artifact manifest: ${manifestPath ?? "<unset>"}`);
-    return;
-  }
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
-  if (!Array.isArray(manifest.artifacts)) manifest.artifacts = [];
-  manifest.artifacts = manifest.artifacts.filter((artifact) => artifact.path !== recording.relativePath);
-  const timing = recording.nativeTiming ? recording.nativeTimingEvidence ?? { timingUnavailableReason: "Native recording timing unavailable" } : await optionalVideoTiming(recording.outputPath, {
-    startedAtUnixMs: recording.startedAtUnixMs,
-    stoppedAtUnixMs: recording.stoppedAtUnixMs ?? Date.now()
-  });
-  if (recording.nativeTimingEvidence?.timing) manifest.artifacts.push({ path: recording.relativePath + ".timing.json", type: "json", category: "system", label: "Native recording and screenshot timing" });
-  let timelinePath;
-  let timelineUnavailableReason = timing.timingUnavailableReason;
-  if (timing.timing) {
-    try {
-      const raw = JSON.parse(fs.readFileSync(result.tracePath, "utf8"));
-      const trace = Array.isArray(raw) ? raw : raw.entries;
-      timelinePath = await writeRecordingTimeline(path.dirname(manifestPath), recording.relativePath, timing.timing, trace);
-      manifest.artifacts.push({ path: timelinePath, type: "json", label: "Recording frames and action markers", category: "system" });
-    } catch (error) {
-      timelineUnavailableReason = error instanceof Error ? error.message : String(error);
-    }
-  }
-  manifest.artifacts.push({
-    path: recording.relativePath,
-    type: "video",
-    label: "Full recipe replay video",
-    category: "evidence",
-    mimeType: "video/mp4",
-    record: "full_run",
-    ...timelinePath ? { timelinePath } : { timelineUnavailableReason },
-    metadata: {
-      provider: "capture-helper",
-      mode: "full_run",
-      pid: recording.pid
-    }
-  });
-  fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
-`);
-}
-function removeRecordingArtifactFromManifest(result, relativePath) {
-  const manifestPath = result.artifactManifestPath;
-  if (!manifestPath || !fs.existsSync(manifestPath)) return;
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
-  if (!Array.isArray(manifest.artifacts)) return;
-  const nextArtifacts = manifest.artifacts.filter((artifact) => artifact.path !== relativePath);
-  if (nextArtifacts.length === manifest.artifacts.length) return;
-  manifest.artifacts = nextArtifacts;
-  fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
-`);
-}
-function captureHelperPath() {
-  return process.env.CAPTURE_HELPER_PATH || "capture-helper";
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-export {
-  captureActiveRecipeRecordingSnapshot,
-  startRecipeRecording,
-  stopRecipeRecording
-};

package/dist/runtime-proof.js

@@ -1,90 +0,0 @@
-import assert from "node:assert/strict";
-import { normalizeRecipeRef, validateRecipeArtifactPackage } from "@farmslot/protocol";
-function validateRuntimeProof(bundle, smokeTarget) {
-  const checked = validateRecipeArtifactPackage(bundle);
-  assert.equal(checked.status, "valid", JSON.stringify(checked.findings));
-  const { recipe, summary, trace, manifest, recipeResolution, resolvedRecipes } = bundle;
-  assert.equal(summary.status, "pass", "Runtime recipe did not pass");
-  const entries = Array.isArray(trace) ? trace : trace.entries;
-  assert(entries.length && entries.every((entry) => entry.ok === true), "Runtime trace contains failed or unknown actions");
-  assert(entries.some((entry) => entry.action === "end" && entry.status === "pass" && !String(entry.nodeId ?? entry.id).includes("/")), "Runtime recipe did not reach its passing end");
-  const documents = new Map(recipeResolution.dependencies.map((dependency) => [normalizeRecipeRef(dependency.ref), resolvedRecipes[dependency.digest]]));
-  const nodes = collectProofNodes(recipe, documents);
-  const executed = new Map(entries.map((entry, index) => [entry.nodeId ?? entry.id, { entry, index }]));
-  function proves(id) {
-    const node = nodes.get(id);
-    const current = executed.get(id);
-    if (!current || current.entry.action !== node.action) return false;
-    if (node.action === "call") return [...nodes.keys()].some((child) => child.startsWith(`${id}/`) && proves(child));
-    if (!assertions.has(node.action) || !current.entry.output || typeof current.entry.output !== "object") return false;
-    if (node.action === "assert_output") {
-      const source = assertionSource(id, node);
-      const prior = executed.get(source);
-      const action = nodes.get(source)?.action;
-      return Boolean(prior && prior.index < current.index && action && action === prior.entry.action && isObservation(action));
-    }
-    if (node.action === "ui.wait_for") return entries.slice(0, current.index).some((entry) => inputs.has(entry.action));
-    return typeof node.path === "string" && manifest.artifacts.some((artifact) => artifact.path === node.path && artifact.category === "proof");
-  }
-  assert(recipe.proofTargets?.length, "Runtime recipe has no behavioral proof targets");
-  for (const target of recipe.proofTargets) {
-    const linked = [...nodes].filter(([, node]) => node.proves?.includes(target.id));
-    assert(linked.some(([id]) => proves(id)), `Proof target ${target.id} has no executed runtime assertion`);
-  }
-  if (smokeTarget) assert(recipe.proofTargets.some((target) => target.id === smokeTarget), "Smoke target is absent from recipe");
-}
-const assertions = /* @__PURE__ */ new Set(["assert_output", "assert_json", "ui.wait_for"]);
-const controls = /* @__PURE__ */ new Set(["end", "wait", "manual", "switch", "call", "index_artifacts", "assert_exit_code", "assert_file", "branch", "repeat", "set", "log"]);
-const inputs = /* @__PURE__ */ new Set(["ui.press", "ui.key_press", "ui.set_input", "ui.swipe", "ui.drag", "ui.long_press"]);
-function isObservation(action) {
-  return !controls.has(action) && !assertions.has(action);
-}
-function assertionSource(id, node) {
-  const prefix = id.includes("/") ? id.slice(0, id.lastIndexOf("/") + 1) : "";
-  return prefix + String(node.source ?? node.node ?? "");
-}
-function collectProofNodes(recipe, documents) {
-  const nodes = /* @__PURE__ */ new Map();
-  function collect(document, prefix = "", stack = /* @__PURE__ */ new Set()) {
-    for (const [id, node] of Object.entries(document.workflow.nodes)) {
-      nodes.set(prefix + id, node);
-      if (node.action === "call" && typeof node.ref === "string") {
-        const ref = normalizeRecipeRef(node.ref);
-        assert(!stack.has(ref), "Recursive recipe proof");
-        const nested = documents.get(ref);
-        assert(nested, `Missing resolved recipe ${ref}`);
-        collect(nested, `${prefix}${id}/`, new Set(stack).add(ref));
-      }
-    }
-  }
-  collect(recipe);
-  return nodes;
-}
-function validateRuntimeProofPlan(recipe, documents = /* @__PURE__ */ new Map()) {
-  const finding = (code, path, message) => ({ severity: "error", code, path, message });
-  if (!recipe.proofTargets?.length) return [finding("proof.targets_missing", "proofTargets", "Behavioral proof requires at least one proof target.")];
-  const nodes = collectProofNodes(recipe, documents);
-  const hasInput = [...nodes.values()].some((node) => inputs.has(node.action));
-  function eligible(id) {
-    const node = nodes.get(id);
-    if (node.action === "call") return [...nodes.keys()].some((child) => child.startsWith(`${id}/`) && eligible(child));
-    if (node.action === "assert_output") {
-      const source = nodes.get(assertionSource(id, node));
-      return Boolean(source && isObservation(source.action));
-    }
-    if (node.action === "ui.wait_for") return hasInput;
-    return node.action === "assert_json" && typeof node.path === "string";
-  }
-  return recipe.proofTargets.flatMap((target, index) => {
-    const linked = [...nodes].filter(([, node]) => node.proves?.includes(target.id));
-    return linked.some(([id]) => eligible(id)) ? [] : [finding(
-      "proof.no_runtime_assertion",
-      `proofTargets[${index}]`,
-      `Proof target ${target.id} has no potentially eligible runtime assertion. Bind proves to assert_output over an observation, ui.wait_for with an input action, assert_json over a proof artifact, or a call containing one. Runtime order, outcomes and artifact indexing remain unverified.`
-    )];
-  });
-}
-export {
-  validateRuntimeProof,
-  validateRuntimeProofPlan
-};

package/library/actions/mobile/platform/tool-paths.mjs

@@ -1,123 +0,0 @@
-// Locate executable adb and idb clients, cache their paths, and export tool-path environment overrides.
-import { constants as fsConstants, accessSync, readdirSync, realpathSync, statSync } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const TOOL_ENV = {
-  adb: 'MM_HARNESS_ADB_PATH',
-  idb: 'MM_HARNESS_IDB_PATH',
-};
-
-const TOOL_RECOVERY = {
-  adb: 'brew install android-platform-tools',
-  idb: 'brew install idb-companion pipx python@3.13 && pipx install fb-idb --python python3.13',
-};
-
-const resolvedPaths = new Map();
-
-export function mobileToolRecovery(tool) {
-  assertTool(tool);
-  return TOOL_RECOVERY[tool];
-}
-
-export function mobileToolEnvName(tool) {
-  assertTool(tool);
-  return TOOL_ENV[tool];
-}
-
-export function resolveMobileToolPath(tool, { required = false } = {}) {
-  assertTool(tool);
-  const cached = resolvedPaths.get(tool);
-  if (cached && executablePath(cached)) return cached;
-
-  for (const candidate of candidatesFor(tool)) {
-    const resolved = executablePath(candidate);
-    if (!resolved) continue;
-    resolvedPaths.set(tool, resolved);
-    process.env[TOOL_ENV[tool]] = resolved;
-    return resolved;
-  }
-
-  resolvedPaths.delete(tool);
-  if (!required) return null;
-  const label = tool === 'adb' ? 'Android SDK Platform-Tools (adb)' : 'Facebook idb client';
-  throw new Error(
-    `${label} is required but no executable was found.\n` +
-      `  Next: ${TOOL_RECOVERY[tool]}`,
-  );
-}
-
-export function resolveAndExportMobileToolPaths(platform) {
-  if (platform === 'android') {
-    return { adb: resolveMobileToolPath('adb', { required: true }), idb: null };
-  }
-  if (platform === 'ios') {
-    return { adb: null, idb: resolveMobileToolPath('idb') };
-  }
-  return {
-    adb: resolveMobileToolPath('adb'),
-    idb: resolveMobileToolPath('idb'),
-  };
-}
-
-export function clearMobileToolPathCache() {
-  resolvedPaths.clear();
-}
-
-function candidatesFor(tool) {
-  const override = process.env[TOOL_ENV[tool]];
-  const pathCandidates = String(process.env.PATH ?? '')
-    .split(path.delimiter)
-    .filter(Boolean)
-    .map((directory) => path.join(directory, tool));
-  const candidates = override ? [override] : [];
-  candidates.push(...pathCandidates);
-  if (tool === 'adb') {
-    for (const root of [
-      process.env.ANDROID_HOME,
-      process.env.ANDROID_SDK_ROOT,
-      path.join(os.homedir(), 'Library/Android/sdk'),
-      path.join(os.homedir(), 'Android/Sdk'),
-    ]) {
-      if (root) candidates.push(path.join(root, 'platform-tools', 'adb'));
-    }
-  } else {
-    if (process.env.IDB_PATH) candidates.push(process.env.IDB_PATH);
-    candidates.push(
-      '/opt/homebrew/bin/idb',
-      '/usr/local/bin/idb',
-      path.join(os.homedir(), '.local/bin/idb'),
-    );
-    candidates.push(...pythonUserCandidates());
-  }
-  return [...new Set(candidates.map((candidate) => path.resolve(candidate)))];
-}
-
-function pythonUserCandidates() {
-  const root = path.join(os.homedir(), 'Library/Python');
-  try {
-    return readdirSync(root, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
-      .map((entry) => path.join(root, entry.name, 'bin/idb'));
-  } catch {
-    return [];
-  }
-}
-
-function executablePath(candidate) {
-  try {
-    const resolved = realpathSync(candidate);
-    const stat = statSync(resolved);
-    if (!stat.isFile()) return null;
-    accessSync(resolved, fsConstants.X_OK);
-    return path.resolve(resolved);
-  } catch {
-    return null;
-  }
-}
-
-function assertTool(tool) {
-  if (tool !== 'adb' && tool !== 'idb') {
-    throw new Error(`Unsupported mobile device tool: ${String(tool)}.`);
-  }
-}