@deeeed/metamask-harness 0.79.0 → 0.81.0

package/dist/adapters/mobile/frame-metrics.js

@@ -1,118 +0,0 @@
-const MIN_ACTIVE_INTERVALS = 5;
-function summarizeFrames(samples) {
-  const allValidSamples = samples.filter(
-    (sample) => Number.isFinite(sample.durationMs) && sample.durationMs > 0
-  );
-  const frameBudgetMs = commonFrameBudget(allValidSamples);
-  const cadenceSamples = allValidSamples.length > 0 && allValidSamples.every((sample) => sample.cadenceInterval === true);
-  const cadenceGaps = cadenceSamples && frameBudgetMs ? allValidSamples.filter(
-    (sample) => sample.durationMs > frameBudgetMs * 3.01
-  ) : [];
-  const validSamples = cadenceGaps.length > 0 ? allValidSamples.filter(
-    (sample) => sample.durationMs <= (frameBudgetMs ?? 0) * 3.01
-  ) : allValidSamples;
-  const durations = validSamples.map((sample) => sample.durationMs).sort((first, second) => first - second);
-  if (durations.length === 0) {
-    return {
-      fpsUnavailableReason: frameBudgetMs ? "insufficient_active_frames" : "refresh_rate_unavailable",
-      ...cadenceGaps.length > 0 ? {
-        cadenceGapCount: cadenceGaps.length,
-        longestCadenceGapMs: round(
-          Math.max(...cadenceGaps.map((sample) => sample.durationMs))
-        )
-      } : {},
-      ...frameBudgetMs ? {
-        frameBudgetMs: round(frameBudgetMs),
-        refreshRateHz: round(1e3 / frameBudgetMs)
-      } : {},
-      frameCount: 0
-    };
-  }
-  const frameBudgetOutcomes = validSamples.map((sample) => sample.overBudget).filter((value) => value !== void 0);
-  const missedFrameBudgetCount = frameBudgetOutcomes.filter(Boolean).length;
-  const activeIntervals = frameBudgetMs ? activeRenderingIntervals(validSamples, frameBudgetMs) : [];
-  const activeElapsedMs = activeIntervals.reduce(
-    (total, interval) => total + interval,
-    0
-  );
-  const hasActiveFps = cadenceGaps.length === 0 && activeIntervals.length >= MIN_ACTIVE_INTERVALS && activeElapsedMs > 0;
-  const refreshRateHz = frameBudgetMs ? 1e3 / frameBudgetMs : void 0;
-  return {
-    ...hasActiveFps ? {
-      activeFps: round(
-        Math.min(
-          refreshRateHz ?? Number.POSITIVE_INFINITY,
-          activeIntervals.length * 1e3 / activeElapsedMs
-        )
-      ),
-      fpsIntervalCount: activeIntervals.length
-    } : {
-      fpsUnavailableReason: frameBudgetMs ? cadenceGaps.length > 0 ? "unclassified_cadence_gap" : "insufficient_active_frames" : "refresh_rate_unavailable"
-    },
-    ...cadenceGaps.length > 0 ? {
-      cadenceGapCount: cadenceGaps.length,
-      longestCadenceGapMs: round(
-        Math.max(...cadenceGaps.map((sample) => sample.durationMs))
-      )
-    } : {},
-    ...frameBudgetMs ? {
-      frameBudgetMs: round(frameBudgetMs),
-      refreshRateHz: round(1e3 / frameBudgetMs)
-    } : {},
-    frameCount: durations.length,
-    ...frameBudgetOutcomes.length === validSamples.length ? {
-      overBudgetFrameCount: missedFrameBudgetCount,
-      overBudgetFramePercent: round(
-        missedFrameBudgetCount / validSamples.length * 100
-      )
-    } : {},
-    longestFrameMs: round(durations.at(-1) ?? 0),
-    p50FrameMs: round(percentile(durations, 0.5)),
-    p95FrameMs: round(percentile(durations, 0.95)),
-    p99FrameMs: round(percentile(durations, 0.99))
-  };
-}
-function commonFrameBudget(samples) {
-  const budgets = samples.map((sample) => sample.frameBudgetMs).filter(
-    (value) => value !== void 0 && Number.isFinite(value) && value > 0
-  ).sort((first, second) => first - second);
-  return budgets.length > 0 ? percentile(budgets, 0.5) : void 0;
-}
-function activeRenderingIntervals(samples, frameBudgetMs) {
-  if (samples.every((sample) => sample.cadenceInterval === true)) {
-    return samples.map((sample) => sample.durationMs).filter(
-      (durationMs) => Number.isFinite(durationMs) && durationMs > 0 && durationMs <= frameBudgetMs * 3.01
-    );
-  }
-  const ordered = [...samples].map((sample) => ({
-    ...sample,
-    startedAtEpochMs: sample.startedAtEpochMs ?? sample.completedAtEpochMs - sample.durationMs
-  })).sort((first, second) => first.startedAtEpochMs - second.startedAtEpochMs);
-  const intervals = [];
-  for (let index = 1; index < ordered.length; index += 1) {
-    const previous = ordered[index - 1];
-    const current = ordered[index];
-    if (!previous || !current) continue;
-    const interval = current.startedAtEpochMs - previous.startedAtEpochMs;
-    if (!Number.isFinite(interval) || interval <= 0) continue;
-    const continuous = interval <= frameBudgetMs * 3.01;
-    const explainedBySlowFrame = Math.max(previous.durationMs, current.durationMs) >= interval - frameBudgetMs * 1.01;
-    if (continuous || explainedBySlowFrame) intervals.push(interval);
-  }
-  return intervals;
-}
-function percentile(sorted, quantile) {
-  if (sorted.length === 1) return sorted[0] ?? 0;
-  const position = (sorted.length - 1) * quantile;
-  const lower = Math.floor(position);
-  const upper = Math.ceil(position);
-  const lowerValue = sorted[lower] ?? 0;
-  const upperValue = sorted[upper] ?? lowerValue;
-  return lowerValue + (upperValue - lowerValue) * (position - lower);
-}
-function round(value) {
-  return Math.round(value * 1e3) / 1e3;
-}
-export {
-  summarizeFrames
-};

package/dist/adapters/mobile/video-recorder.js

@@ -1,289 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import { optionalVideoTiming } from "@farmslot/recipe-runner";
-import {
-  ANDROID_RECORDING_TARGET_PREFIX,
-  IOS_SIMULATOR_RECORDING_TARGET_PREFIX
-} from "../../recording-target.js";
-const RECORDING_START_TIMEOUT_MS = 5e3;
-const RECORDING_STOP_TIMEOUT_MS = 1e4;
-const RECORDING_TIME_LIMIT_SECONDS = 0;
-function androidScreenrecordArgs(remotePath) {
-  return [
-    "shell",
-    "screenrecord",
-    "--time-limit",
-    String(RECORDING_TIME_LIMIT_SECONDS),
-    remotePath
-  ];
-}
-function createAndroidVideoRecorder(serial) {
-  return {
-    name: "adb-screenrecord",
-    platform: "android",
-    doctor: async () => doctorAndroidRecorder(serial),
-    start: (request) => startAndroidRecording(serial, request)
-  };
-}
-function createIosSimulatorVideoRecorder(simulator) {
-  return {
-    name: "simctl-recordVideo",
-    platform: "ios",
-    doctor: async () => doctorIosSimulatorRecorder(simulator),
-    start: (request) => startIosSimulatorRecording(simulator, request)
-  };
-}
-function doctorIosSimulatorRecorder(simulator) {
-  const state = runSimctl(["getenv", simulator, "SIMULATOR_UDID"]);
-  if (state.status !== 0 || !state.stdout.trim()) {
-    return {
-      ok: false,
-      code: "ios_simulator_unavailable",
-      message: `iOS simulator ${simulator} is not booted: ${commandFailure(state)}`,
-      suggestedFix: `Boot ${simulator} and run xcrun simctl getenv ${simulator} SIMULATOR_UDID.`
-    };
-  }
-  return {
-    ok: true,
-    code: "ok",
-    message: `iOS simulator recording is ready on ${simulator}.`
-  };
-}
-async function startIosSimulatorRecording(simulator, request) {
-  const targetSimulator = iosTargetSimulator(request);
-  if (targetSimulator !== simulator) {
-    throw new Error(
-      `iOS recording target ${targetSimulator ?? "<missing>"} does not match selected simulator ${simulator}.`
-    );
-  }
-  fs.mkdirSync(path.dirname(request.outputPath), { recursive: true });
-  const child = spawn(
-    "xcrun",
-    [
-      "simctl",
-      "io",
-      simulator,
-      "recordVideo",
-      "--codec=h264",
-      "--force",
-      request.outputPath
-    ],
-    { stdio: ["ignore", "pipe", "pipe"] }
-  );
-  const output = [];
-  child.stdout?.setEncoding("utf8");
-  child.stderr?.setEncoding("utf8");
-  child.stdout?.on("data", (chunk) => output.push(String(chunk)));
-  child.stderr?.on("data", (chunk) => output.push(String(chunk)));
-  await waitForIosRecordingStart(child, output);
-  let stopped = false;
-  return {
-    async stop() {
-      if (stopped) {
-        throw new Error(
-          `iOS simulator recording on ${simulator} was already stopped.`
-        );
-      }
-      stopped = true;
-      child.kill("SIGINT");
-      await waitForChildExit(
-        child,
-        RECORDING_STOP_TIMEOUT_MS,
-        "iOS simulator recordVideo"
-      );
-      const recorded = fs.statSync(request.outputPath);
-      if (!recorded.isFile() || recorded.size <= 0) {
-        throw new Error(
-          `iOS simulator recording output is empty: ${request.outputPath}`
-        );
-      }
-      return {
-        recorder: {
-          name: "simctl-recordVideo",
-          platform: "ios",
-          target: { selector: "simulator", value: simulator }
-        }
-      };
-    }
-  };
-}
-function doctorAndroidRecorder(serial) {
-  const state = runAdb(serial, ["get-state"]);
-  if (state.status !== 0 || state.stdout.trim() !== "device") {
-    return {
-      ok: false,
-      code: "android_device_unavailable",
-      message: `Android device ${serial} is not ready: ${commandFailure(state)}`,
-      suggestedFix: `Run adb -s ${serial} get-state and reconnect or unlock the device.`
-    };
-  }
-  const screenrecord = runAdb(serial, ["shell", "screenrecord", "--help"]);
-  if (screenrecord.status !== 0) {
-    return {
-      ok: false,
-      code: "android_screenrecord_unavailable",
-      message: `Android screenrecord is unavailable on ${serial}: ${commandFailure(screenrecord)}`,
-      suggestedFix: `Run adb -s ${serial} shell screenrecord --help.`
-    };
-  }
-  return {
-    ok: true,
-    code: "ok",
-    message: `Android screen recording is ready on ${serial}.`
-  };
-}
-async function startAndroidRecording(serial, request) {
-  const targetSerial = androidTargetSerial(request);
-  if (targetSerial !== serial) {
-    throw new Error(
-      `Android recording target ${targetSerial ?? "<missing>"} does not match selected device ${serial}.`
-    );
-  }
-  const existingPid = screenrecordPid(serial);
-  if (existingPid) {
-    throw new Error(
-      `Android screenrecord is already running on ${serial} (pid ${existingPid}). Stop that recording before retrying.`
-    );
-  }
-  const remotePath = `/sdcard/Download/mm-harness-recipe-${Date.now()}-${process.pid}.mp4`;
-  const startedAtUnixMs = Date.now();
-  const child = spawn(
-    "adb",
-    ["-s", serial, ...androidScreenrecordArgs(remotePath)],
-    { stdio: ["ignore", "pipe", "pipe"] }
-  );
-  const stderr = [];
-  child.stderr?.setEncoding("utf8");
-  child.stderr?.on("data", (chunk) => stderr.push(String(chunk)));
-  child.stdout?.resume();
-  const recorderPid = await waitForScreenrecordStart(serial, child, stderr);
-  let stopped = false;
-  return {
-    async stop() {
-      if (stopped) {
-        throw new Error(`Android screen recording on ${serial} was already stopped.`);
-      }
-      stopped = true;
-      try {
-        stopRemoteScreenrecord(serial, recorderPid);
-        await waitForChildExit(
-          child,
-          RECORDING_STOP_TIMEOUT_MS,
-          "Android screenrecord"
-        );
-        const stoppedAtUnixMs = Date.now();
-        fs.mkdirSync(path.dirname(request.outputPath), { recursive: true });
-        const pull = runAdb(serial, ["pull", remotePath, request.outputPath]);
-        if (pull.status !== 0) {
-          throw new Error(
-            `Could not pull Android recording from ${serial}: ${commandFailure(pull)}`
-          );
-        }
-        const output = fs.statSync(request.outputPath);
-        if (!output.isFile() || output.size <= 0) {
-          throw new Error(`Android recording output is empty: ${request.outputPath}`);
-        }
-        return {
-          ...await optionalVideoTiming(request.outputPath, { startedAtUnixMs, stoppedAtUnixMs }),
-          recorder: {
-            name: "adb-screenrecord",
-            platform: "android",
-            target: { selector: "adb-serial", value: serial }
-          }
-        };
-      } finally {
-        runAdb(serial, ["shell", "rm", "-f", remotePath]);
-      }
-    }
-  };
-}
-function androidTargetSerial(request) {
-  if (request.target.kind === "android-device") return request.target.serial;
-  if (request.target.kind !== "window-id") return void 0;
-  if (!request.target.windowId.startsWith(ANDROID_RECORDING_TARGET_PREFIX)) return void 0;
-  return request.target.windowId.slice(ANDROID_RECORDING_TARGET_PREFIX.length) || void 0;
-}
-async function waitForScreenrecordStart(serial, child, stderr) {
-  const deadline = Date.now() + RECORDING_START_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    if (child.exitCode !== null) {
-      throw new Error(
-        `Android screenrecord exited before capture started (exit ${child.exitCode}): ${stderr.join("").trim() || "no recorder output"}`
-      );
-    }
-    const pid = screenrecordPid(serial);
-    if (pid) return pid;
-    await sleep(100);
-  }
-  child.kill("SIGTERM");
-  throw new Error(
-    `Android screenrecord did not start on ${serial} within ${RECORDING_START_TIMEOUT_MS}ms.`
-  );
-}
-function stopRemoteScreenrecord(serial, pid) {
-  const stop = runAdb(serial, ["shell", "kill", "-2", pid]);
-  if (stop.status !== 0 && screenrecordPid(serial) === pid) {
-    throw new Error(`Could not stop Android screenrecord pid ${pid}: ${commandFailure(stop)}`);
-  }
-}
-async function waitForChildExit(child, timeoutMs, recorderName) {
-  if (child.exitCode !== null) return;
-  await new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      child.kill("SIGTERM");
-      reject(new Error(`${recorderName} did not stop within ${timeoutMs}ms.`));
-    }, timeoutMs);
-    child.once("exit", () => {
-      clearTimeout(timeout);
-      resolve();
-    });
-  });
-}
-async function waitForIosRecordingStart(child, output) {
-  const deadline = Date.now() + RECORDING_START_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    if (child.exitCode !== null) {
-      throw new Error(
-        `iOS simulator recordVideo exited before capture started (exit ${child.exitCode}): ${output.join("").trim() || "no recorder output"}`
-      );
-    }
-    if (output.join("").includes("Recording started")) return;
-    await sleep(100);
-  }
-  if (child.exitCode === null) return;
-  throw new Error(
-    `iOS simulator recordVideo did not start within ${RECORDING_START_TIMEOUT_MS}ms.`
-  );
-}
-function iosTargetSimulator(request) {
-  if (request.target.kind !== "window-id") return void 0;
-  if (!request.target.windowId.startsWith(
-    IOS_SIMULATOR_RECORDING_TARGET_PREFIX
-  )) {
-    return void 0;
-  }
-  return request.target.windowId.slice(IOS_SIMULATOR_RECORDING_TARGET_PREFIX.length) || void 0;
-}
-function screenrecordPid(serial) {
-  const result = runAdb(serial, ["shell", "pidof", "screenrecord"]);
-  if (result.status !== 0) return void 0;
-  return result.stdout.trim().split(/\s+/u).find(Boolean);
-}
-function runAdb(serial, args) {
-  return spawnSync("adb", ["-s", serial, ...args], { encoding: "utf8" });
-}
-function runSimctl(args) {
-  return spawnSync("xcrun", ["simctl", ...args], { encoding: "utf8" });
-}
-function commandFailure(result) {
-  return result.stderr.trim() || result.stdout.trim() || `exit ${result.status ?? "unknown"}`;
-}
-function sleep(durationMs) {
-  return new Promise((resolve) => setTimeout(resolve, durationMs));
-}
-export {
-  androidScreenrecordArgs,
-  createAndroidVideoRecorder,
-  createIosSimulatorVideoRecorder
-};

package/dist/artifact-files.js

@@ -1,92 +0,0 @@
-import { constants as fsConstants } from "node:fs";
-import {
-  lstat,
-  mkdir,
-  open,
-  readFile,
-  realpath,
-  writeFile
-} from "node:fs/promises";
-import path from "node:path";
-async function writeContainedArtifact(artifactsDir, relativePath, value, label) {
-  const file = resolveContainedArtifact(artifactsDir, relativePath, label);
-  await mkdir(path.dirname(file), { recursive: true });
-  await assertContainedParent(artifactsDir, file, label);
-  await assertNotSymlink(file, label);
-  const handle = await open(
-    file,
-    fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_TRUNC | fsConstants.O_NOFOLLOW,
-    384
-  );
-  try {
-    await handle.writeFile(value);
-  } finally {
-    await handle.close();
-  }
-}
-async function readContainedJsonArtifact(artifactsDir, relativePath, maxBytes, label) {
-  const file = resolveContainedArtifact(artifactsDir, relativePath, label);
-  await assertContainedParent(artifactsDir, file, label);
-  await assertNotSymlink(file, label);
-  const handle = await open(file, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
-  try {
-    const info = await handle.stat();
-    if (!info.isFile() || info.size > maxBytes) {
-      throw new Error(`${label} is not a bounded regular file.`);
-    }
-    return JSON.parse(await handle.readFile("utf8"));
-  } finally {
-    await handle.close();
-  }
-}
-async function indexArtifactManifest(manifestPath, entries) {
-  const parsed = JSON.parse(await readFile(manifestPath, "utf8"));
-  const manifest = asRecord(parsed);
-  const replacementPaths = new Set(entries.map((entry) => entry.path));
-  const current = Array.isArray(manifest.artifacts) ? manifest.artifacts.filter(
-    (artifact) => !replacementPaths.has(String(asRecord(artifact).path ?? ""))
-  ) : [];
-  await writeFile(
-    manifestPath,
-    `${JSON.stringify(
-      { ...manifest, artifacts: [...current, ...entries] },
-      null,
-      2
-    )}
-`
-  );
-}
-function resolveContainedArtifact(artifactsDir, relativePath, label) {
-  const root = path.resolve(artifactsDir);
-  const file = path.resolve(root, relativePath);
-  const relative = path.relative(root, file);
-  if (relative.startsWith("..") || path.isAbsolute(relative)) {
-    throw new Error(`${label} path must stay inside artifactsDir.`);
-  }
-  return file;
-}
-async function assertContainedParent(artifactsDir, file, label) {
-  const root = await realpath(artifactsDir);
-  const parent = await realpath(path.dirname(file));
-  const relative = path.relative(root, parent);
-  if (relative.startsWith("..") || path.isAbsolute(relative)) {
-    throw new Error(`${label} parent must stay inside artifactsDir.`);
-  }
-}
-async function assertNotSymlink(file, label) {
-  try {
-    if ((await lstat(file)).isSymbolicLink()) {
-      throw new Error(`${label} must not be a symbolic link.`);
-    }
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-  }
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-export {
-  indexArtifactManifest,
-  readContainedJsonArtifact,
-  writeContainedArtifact
-};

package/dist/checkout-lock.js

@@ -1,149 +0,0 @@
-import { ensureRuntimeDirectory, processIdentity } from "@farmslot/recipe-runner/runtime/operation";
-import { randomUUID } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-import { recipeRuntimeDir } from "./paths.js";
-function acquireCheckoutLock(target, operation) {
-  const repoRoot = fs.realpathSync(target);
-  const lockPath = path.join(repoRoot, recipeRuntimeDir(), "sandbox.lock");
-  ensureRuntimeDirectory(path.dirname(lockPath));
-  const inheritedToken = process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN;
-  for (let attempt = 0; attempt < 4; attempt += 1) {
-    try {
-      const identity = processIdentity(process.pid);
-      if (!identity) throw new Error("Cannot identify checkout lock owner process");
-      const fd = fs.openSync(lockPath, "wx", 384);
-      fs.fchmodSync(fd, 384);
-      const token = randomUUID();
-      const owner = {
-        schemaVersion: 1,
-        pid: process.pid,
-        processStartedAt: identity,
-        operation,
-        repoRoot,
-        token,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      fs.writeFileSync(fd, `${JSON.stringify(owner, null, 2)}
-`);
-      fs.closeSync(fd);
-      process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN = token;
-      return {
-        path: lockPath,
-        release: () => {
-          const current = readOwner(lockPath);
-          if (current?.pid === process.pid && current.token === token && !childrenAlive(current)) {
-            fs.rmSync(lockPath, { force: true });
-            fs.rmSync(path.join(path.dirname(lockPath), "lock-members", token), { recursive: true, force: true });
-          }
-          if (process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN === token) {
-            if (inheritedToken) process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN = inheritedToken;
-            else delete process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN;
-          }
-        }
-      };
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-      const owner = readOwner(lockPath);
-      if (inheritedToken && owner?.token === inheritedToken && owner.repoRoot === repoRoot && typeof owner.pid === "number" && ownerAlive(owner)) {
-        trackCheckoutChild(repoRoot, process.pid);
-        return { path: lockPath, release: () => void 0 };
-      }
-      if (owner && typeof owner.pid === "number" && ownerAlive(owner)) {
-        return {
-          path: lockPath,
-          owner,
-          message: `checkout sandbox is busy with ${String(owner.operation ?? "another operation")} (pid ${owner.pid}).`
-        };
-      }
-      if (!owner || childrenAlive(owner)) {
-        return { path: lockPath, owner, message: `checkout sandbox owner is unreadable or has surviving child processes. Inspect ${lockPath} and its lock-members directory; remove the lock only after verifying all recorded processes have exited.` };
-      }
-      claimStaleLock(lockPath, owner);
-    }
-  }
-  return { path: lockPath, owner: readOwner(lockPath), message: "checkout sandbox lock could not be acquired." };
-}
-function claimStaleLock(lockPath, expectedOwner) {
-  const claimedPath = `${lockPath}.stale-${process.pid}-${randomUUID()}`;
-  try {
-    fs.renameSync(lockPath, claimedPath);
-  } catch (error) {
-    if (error.code === "ENOENT") return;
-    throw error;
-  }
-  try {
-    const claimedOwner = readOwner(claimedPath);
-    if (!sameOwner(claimedOwner, expectedOwner) || claimedOwner && typeof claimedOwner.pid === "number" && (ownerAlive(claimedOwner) || childrenAlive(claimedOwner))) {
-      try {
-        fs.linkSync(claimedPath, lockPath);
-      } catch (error) {
-        if (error.code !== "EEXIST") throw error;
-      }
-    } else if (typeof claimedOwner?.token === "string" && /^[a-f0-9-]{36}$/.test(claimedOwner.token)) {
-      fs.rmSync(path.join(path.dirname(lockPath), "lock-members", claimedOwner.token), { recursive: true, force: true });
-    }
-  } finally {
-    fs.rmSync(claimedPath, { force: true });
-  }
-}
-function sameOwner(left, right) {
-  if (!left || !right) return left === right;
-  return left.pid === right.pid && left.token === right.token && left.startedAt === right.startedAt && left.repoRoot === right.repoRoot;
-}
-function readOwner(lockPath) {
-  try {
-    const value = JSON.parse(fs.readFileSync(lockPath, "utf8"));
-    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-  } catch {
-    return null;
-  }
-}
-function ownerAlive(owner) {
-  if (typeof owner.pid !== "number") return true;
-  if (typeof owner.processStartedAt === "string") return processIdentity(owner.pid) === owner.processStartedAt;
-  return processAlive(owner.pid);
-}
-function childrenAlive(owner) {
-  if (typeof owner.repoRoot !== "string" || typeof owner.token !== "string" || !/^[a-f0-9-]{36}$/.test(owner.token)) return false;
-  const directory = path.join(owner.repoRoot, recipeRuntimeDir(), "lock-members", owner.token);
-  if (!fs.existsSync(directory)) return false;
-  return fs.readdirSync(directory).filter((name) => name.endsWith(".json")).some((name) => {
-    const child = readOwner(path.join(directory, name));
-    if (child && typeof child.processGroupId === "number" && child.processGroupId > 0) return processAlive(-child.processGroupId);
-    return !child || typeof child.pid !== "number" || typeof child.processStartedAt !== "string" || child.pid !== owner.pid && processIdentity(child.pid) === child.processStartedAt;
-  });
-}
-function trackCheckoutChild(target, pid, ownsProcessGroup = false) {
-  const repoRoot = fs.realpathSync(target);
-  const lockPath = path.join(repoRoot, recipeRuntimeDir(), "sandbox.lock");
-  const owner = readOwner(lockPath);
-  if (!owner || owner.token !== process.env.MM_HARNESS_CHECKOUT_LOCK_TOKEN || typeof owner.token !== "string" || !/^[a-f0-9-]{36}$/.test(owner.token)) return () => void 0;
-  const identity = processIdentity(pid);
-  if (!identity && !ownsProcessGroup) return () => void 0;
-  const directory = path.join(repoRoot, recipeRuntimeDir(), "lock-members", owner.token);
-  ensureRuntimeDirectory(directory);
-  const file = path.join(directory, `${pid}.json`);
-  const previous = readOwner(file);
-  const group = ownsProcessGroup || previous?.processStartedAt === identity && previous?.processGroupId === pid;
-  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
-  fs.writeFileSync(temporary, JSON.stringify({ pid, processStartedAt: identity, ...group ? { processGroupId: pid } : {} }), { mode: 384 });
-  fs.chmodSync(temporary, 384);
-  fs.renameSync(temporary, file);
-  return () => {
-    const current = readOwner(file);
-    if (current?.pid === pid && current.processStartedAt === identity) fs.rmSync(file, { force: true });
-  };
-}
-function processAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
-export {
-  acquireCheckoutLock,
-  trackCheckoutChild
-};