@kavishdua/proctor 1.0.0 → 1.2.0

package/dist/dynamic-worker.js

@@ -0,0 +1,776 @@
+// src/dynamic-worker.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+import { spawnSync as spawnSync4 } from "child_process";
+import picomatch from "picomatch";
+
+// src/dynamic/snapshots.ts
+import { spawnSync } from "child_process";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, symlinkSync, writeFileSync, copyFileSync, chmodSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+var EXCLUDED = /^(?:bench\/(?:dynamic|heldout)(?:\/|$))|(?:^|\/)(?:\.git|node_modules|\.venv|venv|__pycache__)(?:\/|$)/;
+var MAX_BYTES = 64 * 1024 * 1024;
+function git(cwd, args, input) {
+  const r = spawnSync("git", args, { cwd, input, maxBuffer: MAX_BYTES, timeout: 15e3, env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_CONFIG_NOSYSTEM: "1" } });
+  if (r.status !== 0) throw Error("cannot read local Git snapshot");
+  return r.stdout;
+}
+function validPath(path) {
+  return !isAbsolute(path) && !path.split("/").some((p) => p === ".." || p === "" || p.includes("\\"));
+}
+function snapshot(cwd, ref) {
+  const entries = git(cwd, ref ? ["ls-tree", "-rz", "--full-tree", ref] : ["ls-files", "--stage", "-z"]).toString().split("\0").filter(Boolean).map((row) => {
+    const tab = row.indexOf("	");
+    const meta = row.slice(0, tab).split(" "), path = row.slice(tab + 1);
+    return { path, mode: meta[0], sha: meta[ref ? 2 : 1] };
+  }).filter((e) => !EXCLUDED.test(e.path));
+  if (entries.some((e) => !validPath(e.path) || !/^100(644|755)$/.test(e.mode))) throw Error("not run: symlink, submodule or unsafe tracked path");
+  const blobs = git(cwd, ["cat-file", "--batch"], entries.map((e) => e.sha).join("\n") + "\n");
+  const files = /* @__PURE__ */ new Map();
+  let offset = 0;
+  for (const entry of entries) {
+    const newline = blobs.indexOf(10, offset);
+    const [sha, kind, sizeText] = blobs.subarray(offset, newline).toString().split(" ");
+    const size = Number(sizeText);
+    if (sha !== entry.sha || kind !== "blob" || !Number.isSafeInteger(size)) throw Error("unreadable Git blob");
+    offset = newline + 1;
+    files.set(entry.path, { data: blobs.subarray(offset, offset + size), mode: parseInt(entry.mode, 8) & 511 });
+    offset += size + 1;
+  }
+  return files;
+}
+function loadSnapshots(options2) {
+  const top = git(options2.cwd, ["rev-parse", "--show-toplevel"]).toString().trim();
+  if (resolve(top) !== resolve(options2.cwd)) throw Error("not run: invoke dynamic checks at the repository root");
+  const ref = options2.base ? git(top, ["merge-base", "--", options2.base, "HEAD"]).toString().trim() : "HEAD";
+  const old = snapshot(top, ref);
+  const next = snapshot(top, options2.staged ? void 0 : "HEAD");
+  if (!options2.base && !options2.staged) {
+    for (const file of options2.files) {
+      if (file.from && file.from !== "/dev/null" && file.from !== file.to) next.delete(file.from);
+      const path = file.to;
+      if (!path || path === "/dev/null") {
+        if (file.from) next.delete(file.from);
+        continue;
+      }
+      if (!validPath(path) || EXCLUDED.test(path)) continue;
+      const disk = join(top, path);
+      if (!existsSync(disk)) {
+        next.delete(path);
+        continue;
+      }
+      const stat = lstatSync(disk);
+      if (!stat.isFile()) throw Error("not run: changed symlink or non-regular file");
+      if (stat.size > MAX_BYTES) throw Error("snapshot size limit");
+      next.set(path, { data: readFileSync(disk), mode: stat.mode & 511 });
+    }
+  }
+  for (const tree of [old, next]) {
+    if ([...tree.values()].reduce((sum, f) => sum + f.data.length, 0) > MAX_BYTES) throw Error("snapshot size limit");
+  }
+  for (const path of ["package.json", "package-lock.json", "yarn.lock", "pnpm-lock.yaml", "requirements.txt", "poetry.lock", "uv.lock"]) {
+    if (old.get(path)?.data.toString() !== next.get(path)?.data.toString()) throw Error(`not run: dependency manifest changed (${path})`);
+  }
+  return { old, next };
+}
+function copyDependencies(source, target, sourceRoot, targetRoot) {
+  const stat = lstatSync(source);
+  if (stat.isSymbolicLink()) {
+    const destination = resolve(dirname(source), readlinkSync(source));
+    const rel = relative(sourceRoot, destination);
+    if (rel.startsWith(".." + sep) || rel === ".." || isAbsolute(rel)) throw Error("not run: dependency symlink points outside node_modules");
+    symlinkSync(relative(dirname(target), join(targetRoot, rel)), target);
+  } else if (stat.isDirectory()) {
+    mkdirSync(target, { recursive: true });
+    for (const name of readdirSync(source)) copyDependencies(join(source, name), join(target, name), sourceRoot, targetRoot);
+  } else if (stat.isFile()) {
+    copyFileSync(source, target);
+    chmodSync(target, stat.mode & 511);
+  }
+}
+function materialize(tree, dir, cwd) {
+  mkdirSync(dir, { recursive: true });
+  for (const [path, file] of tree) {
+    const target = join(dir, path);
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, file.data, { mode: file.mode });
+  }
+  const deps = join(cwd, "node_modules");
+  if (existsSync(deps)) copyDependencies(deps, join(dir, "node_modules"), deps, join(dir, "node_modules"));
+}
+
+// src/dynamic/adapters.ts
+import { stripVTControlCharacters } from "util";
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+function detectAdapter(tree, tests) {
+  const pkgText = tree.get("package.json")?.data.toString();
+  if (pkgText) {
+    const pkg = JSON.parse(pkgText);
+    const script = pkg.scripts?.test;
+    if (typeof script === "string") {
+      if (/\bvitest\b/.test(script)) return { command: "npm", args: ["run", "test", "--", "--run", "--reporter=json"], kind: "vitest" };
+      if (/\bjest\b/.test(script)) return { command: "npm", args: ["run", "test", "--", "--json", "--runInBand", "--watch=false"], kind: "jest" };
+      if (/\bnode\b.*--test\b/.test(script)) return { command: "npm", args: ["run", "test"], kind: "tap" };
+      throw Error("not run: unrecognized package test script (node:test, jest and vitest supported)");
+    }
+  }
+  const js = tests.filter((p) => /\.(?:mjs|cjs|js)$/.test(p));
+  if (js.length) return { command: process.execPath, args: ["--test", "--test-reporter=tap", ...js], kind: "tap" };
+  const py = tests.filter((p) => p.endsWith(".py"));
+  if (py.length) {
+    const pytest = ["pytest.ini", "conftest.py"].some((p) => tree.has(p)) || /\[tool\.pytest/.test(tree.get("pyproject.toml")?.data.toString() ?? "") || py.some((p) => /(?:^|\n)\s*(?:import pytest|from pytest\b)/.test(tree.get(p)?.data.toString() ?? ""));
+    return pytest ? { command: "python3", args: ["-m", "pytest", "-q", "--tb=short", "--junitxml=.proctor-junit.xml"], kind: "pytest" } : { command: "python3", args: ["-m", "unittest", "discover", "-v"], kind: "unittest", testFiles: py };
+  }
+  throw Error("not run: no supported Node or Python tests found");
+}
+function uniqueOutcomes(rows) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const [id] of rows) counts.set(id, (counts.get(id) ?? 0) + 1);
+  return {
+    passed: rows.filter(([id, pass]) => pass && counts.get(id) === 1).map(([id]) => id),
+    failed: rows.filter(([id, pass]) => !pass && counts.get(id) === 1).map(([id]) => id)
+  };
+}
+function parseResults(kind, stdout, stderr, junit = "") {
+  const rows = [];
+  if (kind === "tap") {
+    for (const match of stdout.matchAll(/^\s*(not )?ok \d+ - (.+?)(?: #.*)?$/gm)) {
+      if (/ # (?:SKIP|TODO)/i.test(match[0])) continue;
+      rows.push([match[2].trim(), !match[1]]);
+    }
+  } else if (kind === "unittest") {
+    for (const match of stderr.matchAll(/^(.+? \(.+?\)) \.\.\. (ok|FAIL|ERROR)\s*$/gm)) rows.push([match[1], match[2] === "ok"]);
+  } else if (kind === "pytest") {
+    const decode = (s) => s.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+    for (const m of junit.matchAll(/<testcase\b([^>]*?)(?:\/>|>([\s\S]*?)<\/testcase>)/g)) {
+      if (/<skipped\b/.test(m[2] ?? "")) continue;
+      const cls = /\bclassname="([^"]*)"/.exec(m[1])?.[1];
+      const name = /\bname="([^"]*)"/.exec(m[1])?.[1];
+      if (name) rows.push([decode(`${cls ?? ""}::${name}`), !/<(?:failure|error)\b/.test(m[2] ?? "")]);
+    }
+  } else {
+    let result2;
+    for (const stream of [stdout, stderr]) {
+      const start = stream.indexOf("{"), end = stream.lastIndexOf("}");
+      if (start < 0 || end < start) continue;
+      try {
+        const candidate = JSON.parse(stream.slice(start, end + 1));
+        if (Array.isArray(candidate.testResults)) {
+          result2 = candidate;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (!result2) throw Error("test reporter did not produce readable JSON");
+    for (const suite of result2.testResults ?? []) {
+      for (const test of suite.assertionResults ?? []) {
+        if (test.status === "passed" || test.status === "failed") rows.push([test.fullName ?? [...test.ancestorTitles ?? [], test.title].join(" "), test.status === "passed"]);
+      }
+    }
+  }
+  return uniqueOutcomes(rows);
+}
+var PYTHON_FUNCTIONS = `import ast,json,sys
+tree=ast.parse(open(sys.argv[1],encoding='utf-8').read())
+print(json.dumps([n.name for n in tree.body if isinstance(n,(ast.FunctionDef,ast.AsyncFunctionDef)) and n.name.startswith('test_')]))
+`;
+var PYTHON_CALL = `import asyncio,importlib.util,inspect,os,sys
+file,name=sys.argv[1:]
+sys.path.insert(0,os.path.dirname(os.path.abspath(file)))
+spec=importlib.util.spec_from_file_location('proctor_test',file)
+module=importlib.util.module_from_spec(spec)
+sys.modules[spec.name]=module
+spec.loader.exec_module(module)
+result=getattr(module,name)()
+if inspect.isawaitable(result): asyncio.run(result)
+`;
+function runPythonFiles(adapter, dir, label, discovery, env) {
+  if (!adapter.testFiles?.length) throw Error(`cannot run ${label}: no Python files for direct execution`);
+  const passed = [], failed = [], details = [];
+  const fileRuns = [];
+  const helper = ".proctor-python-test.py";
+  writeFileSync2(join2(dir, helper), PYTHON_CALL);
+  for (const file of adapter.testFiles) {
+    const collected = spawnSync2(adapter.command, ["-c", PYTHON_FUNCTIONS, file], { cwd: dir, encoding: "utf8", maxBuffer: 128 * 1024, env });
+    if (collected.error || collected.signal) throw Error(`cannot inspect ${file}: ${collected.error?.message ?? collected.signal}`);
+    const names = collected.status === 0 ? JSON.parse(collected.stdout) : [];
+    if (new Set(names).size !== names.length) throw Error(`cannot run ${label}: duplicate Python function names in ${file}`);
+    const invocations = names.length ? names.map((name) => ({ id: `${file}::${name}`, args: [helper, file, name] })) : [{ id: file, args: [file] }];
+    for (const { id, args } of invocations) {
+      const r = spawnSync2(adapter.command, args, { cwd: dir, encoding: "utf8", maxBuffer: 2 * 1024 * 1024, env });
+      if (r.error || r.signal || r.status === null) throw Error(`cannot run ${label}, ${file}: ${r.error?.message ?? r.signal ?? "no exit code"}`);
+      fileRuns.push({ file: id, command: [adapter.command, ...args].join(" "), exitCode: r.status });
+      (r.status === 0 ? passed : failed).push(id);
+      details.push(`${id}: exit ${r.status}
+${r.stdout ?? ""}${r.stderr ?? ""}`);
+    }
+  }
+  return {
+    label,
+    command: `${adapter.command} -m unittest discover -v, then direct Python files`,
+    exitCode: failed.length ? 1 : 0,
+    passed,
+    failed,
+    fileRuns,
+    detail: stripVTControlCharacters(`${discovery}
+${details.join("\n")}`).slice(-1200)
+  };
+}
+function runTests(adapter, dir, label, extraEnv = {}) {
+  const artifact = join2(dir, ".proctor-junit.xml");
+  if (adapter.kind === "pytest") rmSync(artifact, { force: true });
+  const env = { ...process.env, ...extraEnv, PWD: dir, ...adapter.kind === "tap" && adapter.command === "npm" ? { NODE_OPTIONS: "--test-reporter=tap" } : {} };
+  const r = spawnSync2(adapter.command, adapter.args, { cwd: dir, encoding: "utf8", maxBuffer: 2 * 1024 * 1024, env });
+  if (r.error || r.signal) throw Error(`cannot run ${label}: ${r.error?.message ?? r.signal}`);
+  const stdout = r.stdout ?? "", stderr = r.stderr ?? "";
+  const outcomes = parseResults(adapter.kind, stdout, stderr, existsSync2(artifact) ? readFileSync2(artifact, "utf8") : "");
+  if (adapter.kind === "unittest") {
+    const real = [...outcomes.passed, ...outcomes.failed].filter((id) => !id.includes("unittest.loader._FailedTest"));
+    const discovered = Number(/^Ran (\d+) tests? in /m.exec(stderr)?.[1] ?? 0);
+    const collectionFailed = outcomes.failed.some((id) => id.includes("unittest.loader._FailedTest"));
+    if (!real.length && (discovered === 0 || collectionFailed)) return runPythonFiles(adapter, dir, label, stdout + stderr, env);
+    if (collectionFailed) throw Error(`cannot run ${label}: unittest collection failed beside real cases`);
+  }
+  if (outcomes.passed.length + outcomes.failed.length === 0) throw Error(`cannot run ${label}: no named test results (exit ${r.status}); ${String(stdout + stderr).replace(/\s+/g, " ").slice(-300)}`);
+  if (r.status !== 0 && outcomes.failed.length === 0) throw Error(`cannot run ${label}: command exited ${r.status} without a named failing test`);
+  if (r.status === 0 && outcomes.failed.length) throw Error(`cannot run ${label}: reporter and exit code disagree`);
+  return {
+    label,
+    command: (adapter.kind === "tap" && adapter.command === "npm" ? "NODE_OPTIONS=--test-reporter=tap " : "") + [adapter.command, ...adapter.args].join(" "),
+    exitCode: r.status,
+    ...outcomes,
+    detail: stripVTControlCharacters(String(stdout + stderr)).slice(-1200)
+  };
+}
+
+// src/dynamic/signals.ts
+var LITERAL = String.raw`(?:-?\d+(?:\.\d+)?|true|false|None|True|False|null|"[^"\n]*"|'[^'\n]*')`;
+var ASSERTION_PATTERNS = [
+  new RegExp(String.raw`^\s*((?:assert\.(?:strictEqual|equal|deepEqual|deepStrictEqual)|self\.assertEqual)\(.+?,\s*)(${LITERAL})(\s*\)\s*;?\s*)$`),
+  new RegExp(String.raw`^\s*(expect\(.+?\)\.to(?:Be|Equal|StrictEqual)\(\s*)(${LITERAL})(\s*\)\s*;?\s*)$`),
+  new RegExp(String.raw`^(\s*assert\s+.+?\s*==\s*)(${LITERAL})(\s*)$`)
+];
+var assertion = (line) => ASSERTION_PATTERNS.map((pattern) => pattern.exec(line)).find(Boolean);
+function expectationChanges(before, after) {
+  const assertions = (text) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const line of text.split("\n")) {
+      const match = assertion(line);
+      if (match) map.set(match[1].trim() + match[3].trim(), match[2]);
+    }
+    return map;
+  };
+  const a = assertions(before), b = assertions(after);
+  return [...a].filter(([key, value]) => b.has(key) && b.get(key) !== value).map(([key, value]) => ({ before: value, after: b.get(key) }));
+}
+function expectedEdits(before, after) {
+  return expectationChanges(before, after).length > 0;
+}
+function expectationOnlyEdit(before, after) {
+  const canonical2 = (text) => text.split("\n").map((line) => {
+    const match = assertion(line);
+    return match ? `${match[1]}__EXPECTED_LITERAL__${match[3]}` : line;
+  }).join("\n");
+  return expectedEdits(before, after) && canonical2(before) === canonical2(after);
+}
+function documentedIntent(old, next) {
+  for (const [path, file] of next) {
+    if (!/(?:^|\/)(?:SPEC[^/]*|CHANGELOG[^/]*)\.(?:md|rst|txt)$/i.test(path)) continue;
+    const before = old.get(path)?.data.toString() ?? "";
+    const previous = new Set(before.split("\n"));
+    if (file.data.toString().split("\n").some((line) => line.trim() && !/^\s*#/.test(line) && !previous.has(line))) return true;
+  }
+  return false;
+}
+function definesPythonFunction(text, name) {
+  for (const match of text.matchAll(/^\s*def (\w+)\s*\(/gm)) {
+    if (match[1] === name) return true;
+  }
+  return false;
+}
+function locateTest(id, tree, tests) {
+  if (tests.includes(id) && tree.has(id)) return id;
+  const [plainFile, plainFunction] = id.split("::");
+  if (plainFunction && plainFile && tests.includes(plainFile) && tree.has(plainFile)) return plainFile;
+  const python = (/^(test\w+) \(/.exec(id)?.[1] ?? id.split("::").at(-1))?.replace(/\[.*$/, "");
+  const exact = tests.filter((p) => {
+    const text = tree.get(p)?.data.toString() ?? "";
+    return text.includes(`'${id}'`) || text.includes(`"${id}"`) || p.endsWith(".py") && !!python && definesPythonFunction(text, python);
+  });
+  if (exact.length) return exact.length === 1 ? exact[0] : void 0;
+  const nested = tests.filter((p) => [...(tree.get(p)?.data.toString() ?? "").matchAll(/\b(?:test|it)\s*\(\s*(['"])([^'"\n]+)\1/g)].some((m) => id.endsWith(" " + m[2])));
+  return nested.length === 1 ? nested[0] : void 0;
+}
+var UNARY_ARITHMETIC = /^(\w+)\s*[*+\/-]\s*-?\d+(?:\.\d+)?$/;
+var PY_BRANCH = /if\s+(\w+)\s*==\s*(-?\d+(?:\.\d+)?|True|False|"[^"\\\n]*"|'[^'\\\n]*')\s*:\s*return\s+(-?\d+(?:\.\d+)?|True|False|"[^"\\\n]*"|'[^'\\\n]*')/;
+var JS_BRANCH = /if\s*\(\s*(\w+)\s*===?\s*(-?\d+(?:\.\d+)?|true|false|"[^"\\\n]*"|'[^'\\\n]*')\s*\)\s*(?:\{\s*)?return\s+(-?\d+(?:\.\d+)?|true|false|"[^"\\\n]*"|'[^'\\\n]*');?\s*\}?/;
+function simpleReference(expression, arg, py) {
+  if (expression === arg) return true;
+  const numeric = UNARY_ARITHMETIC.exec(expression);
+  const method = /^(\w+)\.(\w+)\(\)$/.exec(expression);
+  const negate = /^(?:!\s*|not\s+)(\w+)$/.exec(expression);
+  const concat = /^(?:(\w+)\s*\+\s*(?:"[^"\\\n]*"|'[^'\\\n]*')|(?:"[^"\\\n]*"|'[^'\\\n]*')\s*\+\s*(\w+))$/.exec(expression);
+  return numeric?.[1] === arg || negate?.[1] === arg || concat?.[1] === arg || concat?.[2] === arg || method?.[1] === arg && (py ? ["lower", "upper", "strip"] : ["toLowerCase", "toUpperCase", "trim"]).includes(method[2]);
+}
+function probeLiteral(text) {
+  if (text.startsWith('"') || text.startsWith("'")) return text.slice(1, -1);
+  if (/^(?:true|True|false|False)$/.test(text)) return text === "true" || text === "True";
+  return Number(text);
+}
+function probeInputs(input) {
+  if (typeof input === "boolean") return [!input, input];
+  if (typeof input === "string") return [`${input}a`, input, `b${input}`];
+  return [input - 1, input, input + 1];
+}
+function pythonBody(text, name, arg) {
+  const header = `def ${name}(${arg}):`;
+  const start = text.indexOf(header);
+  if (start < 0 || start > 0 && text[start - 1] !== "\n") return void 0;
+  const lines = text.slice(start + header.length).split("\n");
+  const body = [];
+  for (const line of lines.slice(1)) {
+    if (line.trim() === "") {
+      body.push(line);
+      continue;
+    }
+    if (/^[ \t]/.test(line)) {
+      body.push(line);
+      continue;
+    }
+    break;
+  }
+  return body.length ? body.join("\n") : void 0;
+}
+function jsBody(text, name, arg) {
+  for (const marker of [`export function ${name}(${arg})`, `function ${name}(${arg})`]) {
+    const start = text.indexOf(marker);
+    if (start < 0) continue;
+    const open = text.indexOf("{", start + marker.length);
+    if (open < 0) return void 0;
+    const close = text.indexOf("\n}", open);
+    if (close < 0) return void 0;
+    return text.slice(open + 1, close);
+  }
+  return void 0;
+}
+function findProbes(old, next, isTest) {
+  const probes = [];
+  for (const [file, entry] of next) {
+    if (isTest(file) || !/\.(?:js|mjs|cjs|py)$/.test(file)) continue;
+    const before = old.get(file)?.data.toString(), after = entry.data.toString();
+    if (!before || before === after) continue;
+    const py = file.endsWith(".py");
+    const functions = py ? [...before.matchAll(/^def (\w+)\((\w+)\):\n[ \t]+return ([^\n]+)\n?/gm)] : [...before.matchAll(/(?:export\s+)?function (\w+)\((\w+)\)\s*\{\s*return\s+([^;{}\n]+);?\s*\}/g)];
+    for (const fn of functions) {
+      const [, name, arg, expression] = fn;
+      if (!simpleReference(expression.trim(), arg, py)) continue;
+      if (!py && !before.includes(`export function ${name}`) && !before.includes("module.exports") && !before.includes(`exports.${name}`)) continue;
+      const body = py ? pythonBody(after, name, arg) : jsBody(after, name, arg);
+      if (!body) continue;
+      const branchMatch = (py ? PY_BRANCH : JS_BRANCH).exec(body);
+      const branch = branchMatch && branchMatch[1] === arg ? branchMatch : void 0;
+      if (!branch || !body.includes(expression.trim())) continue;
+      const remainder = body.replace(branch[0], "").replace(/return\s+/, "").replace(/[;\s]/g, "");
+      if (remainder !== expression.replace(/\s/g, "")) continue;
+      probes.push({ file, name, input: probeLiteral(branch[2]), returned: probeLiteral(branch[3]), line: after.slice(0, after.indexOf(branch[0])).split("\n").length, language: py ? "python" : "js" });
+    }
+  }
+  return probes.slice(0, 8);
+}
+
+// src/dynamic/mutations.ts
+import { parse } from "acorn";
+import { spawnSync as spawnSync3 } from "child_process";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3, relative as relative2, sep as sep2 } from "path";
+import { fileURLToPath } from "url";
+var MUTATION_LIMIT = 4;
+function changedSourceLines(before, after) {
+  const a = before.split("\n"), b = after.split("\n");
+  if (a.length * b.length > 4e6) return /* @__PURE__ */ new Set();
+  const width = b.length + 1, rows = new Uint16Array((a.length + 1) * width);
+  for (let i2 = a.length - 1; i2 >= 0; i2--) for (let j2 = b.length - 1; j2 >= 0; j2--) {
+    rows[i2 * width + j2] = a[i2] === b[j2] ? rows[(i2 + 1) * width + j2 + 1] + 1 : Math.max(rows[(i2 + 1) * width + j2], rows[i2 * width + j2 + 1]);
+  }
+  const changed = /* @__PURE__ */ new Set();
+  let i = 0, j = 0;
+  while (i < a.length || j < b.length) {
+    if (i < a.length && j < b.length && a[i] === b[j]) {
+      i++;
+      j++;
+    } else if (j < b.length && (i === a.length || rows[i * width + j + 1] >= rows[(i + 1) * width + j])) {
+      changed.add(++j);
+    } else i++;
+  }
+  return changed;
+}
+var PYTHON_PROFILE = `import atexit,json,os,sys,threading
+root=os.getcwd()+os.sep
+calls=set()
+def record(frame,event,arg):
+    if event=='call' and frame.f_code.co_filename.startswith(root):
+        calls.add((frame.f_code.co_filename,frame.f_code.co_firstlineno))
+def save():
+    with open(os.path.join(os.environ['PROCTOR_CALLS'],'python-'+str(os.getpid())+'.json'),'w') as out:
+        json.dump(sorted(calls),out)
+sys.setprofile(record)
+threading.setprofile(record)
+atexit.register(save)
+`;
+function coverageEnvironment(dir) {
+  const path = join3(dir, ".proctor-calls"), hooks = join3(path, "hooks");
+  mkdirSync2(hooks, { recursive: true });
+  writeFileSync3(join3(hooks, "sitecustomize.py"), PYTHON_PROFILE);
+  return { path, env: { NODE_V8_COVERAGE: path, PROCTOR_CALLS: path, PYTHONPATH: hooks } };
+}
+function readCalls(path, dir) {
+  const calls = { js: /* @__PURE__ */ new Map(), python: /* @__PURE__ */ new Map() };
+  for (const name of readdirSync2(path).filter((p) => p.endsWith(".json")).slice(0, 100)) {
+    try {
+      const text = readFileSync3(join3(path, name), "utf8");
+      if (text.length > 4 * 1024 * 1024) continue;
+      const data = JSON.parse(text);
+      if (name.startsWith("python-")) {
+        for (const [file, line] of data) calls.python.set(file, [...calls.python.get(file) ?? [], line]);
+      } else for (const script of data.result ?? []) {
+        if (!script.url.startsWith("file:")) continue;
+        const file = fileURLToPath(script.url);
+        if (relative2(dir, file).startsWith(".." + sep2)) continue;
+        const ranges = script.functions.map((fn) => fn.ranges[0]).filter((r) => r.count > 0).map((r) => ({ start: r.startOffset, end: r.endOffset }));
+        calls.js.set(file, [...calls.js.get(file) ?? [], ...ranges]);
+      }
+    } catch {
+    }
+  }
+  return calls;
+}
+var OMIT = /* @__PURE__ */ Symbol("deleted statement");
+function canonical(value, target, replacement) {
+  if (target && value === target) return canonical(replacement);
+  if (Array.isArray(value)) return value.map((v) => canonical(v, target, replacement)).filter((v) => v !== OMIT);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).filter(([key]) => !["start", "end", "loc", "raw"].includes(key)).sort(([a], [b]) => a.localeCompare(b)).map(([key, v]) => [key, canonical(v, target, replacement)]));
+}
+var parseJs = (source) => parse(source, { ecmaVersion: "latest", sourceType: "module", locations: true });
+function jsMutations(before, source, called) {
+  let ast, previous;
+  try {
+    ast = parseJs(source);
+    previous = parseJs(before);
+  } catch {
+    return [];
+  }
+  const fingerprint = (node) => JSON.stringify(canonical(node));
+  const original = /* @__PURE__ */ new Set();
+  function remember(node) {
+    if (["ReturnStatement", "ThrowStatement", "ExpressionStatement", "VariableDeclaration", "IfStatement"].includes(node.type)) original.add(fingerprint(node));
+    if (node.type === "IfStatement") original.add(fingerprint(node.test));
+    for (const value of Object.values(node)) {
+      if (Array.isArray(value)) {
+        for (const child of value) if (child?.type) remember(child);
+      } else if (value && typeof value === "object" && "type" in value) remember(value);
+    }
+  }
+  remember(previous);
+  const changed = changedSourceLines(before, source), candidates = [];
+  const used = /* @__PURE__ */ new Set();
+  function visit(node, fn) {
+    if (candidates.length >= MUTATION_LIMIT) return;
+    if (["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].includes(node.type)) fn = node;
+    const line = node.loc.start.line;
+    if (fn && changed.has(line) && !used.has(line) && !original.has(fingerprint(node)) && called.some((r) => r.start === fn.start && r.end === fn.end)) {
+      const start = source.lastIndexOf("\n", node.start - 1) + 1;
+      const end = source.indexOf("\n", node.end);
+      const lineEnd = end < 0 ? source.length : end;
+      const fullLine = /^\s*$/.test(source.slice(start, node.start)) && /^\s*$/.test(source.slice(node.end, lineEnd));
+      const attempts = [];
+      if (fullLine && node.loc.end.line === line && ["ReturnStatement", "ThrowStatement", "ExpressionStatement", "VariableDeclaration", "IfStatement"].includes(node.type)) {
+        attempts.push({ text: source.slice(0, node.start) + source.slice(node.end), replacement: OMIT, target: node, operation: "delete statement" });
+      }
+      if (node.type === "IfStatement") {
+        const test = node.test;
+        if (test.loc.end.line === line && !original.has(fingerprint(test))) attempts.push({
+          text: source.slice(0, test.start) + `!(${source.slice(test.start, test.end)})` + source.slice(test.end),
+          target: test,
+          replacement: { type: "UnaryExpression", operator: "!", prefix: true, argument: canonical(test) },
+          operation: "negate condition"
+        });
+      }
+      for (const attempt of attempts) {
+        try {
+          const parsed = parseJs(attempt.text);
+          if (JSON.stringify(canonical(parsed)) !== JSON.stringify(canonical(ast, attempt.target, attempt.replacement))) continue;
+          candidates.push({ line, functionName: fn.id?.name ?? "<anonymous>", source: attempt.text, operation: attempt.operation });
+          used.add(line);
+          break;
+        } catch {
+        }
+      }
+    }
+    for (const value of Object.values(node)) {
+      if (Array.isArray(value)) {
+        for (const child of value) if (child?.type) visit(child, fn);
+      } else if (value && typeof value === "object" && "type" in value) visit(value, fn);
+    }
+  }
+  visit(ast);
+  return candidates.slice(0, MUTATION_LIMIT);
+}
+var PYTHON_MUTATIONS = `import ast,copy,json,sys
+data=json.load(sys.stdin)
+source=data['source']
+lines=source.splitlines(keepends=True)
+tree=ast.parse(source)
+original={ast.dump(n) for n in ast.walk(ast.parse(data['before'])) if isinstance(n,(ast.stmt,ast.expr))}
+# Require a lossless syntax round trip before editing this file.
+assert ast.dump(ast.parse(ast.unparse(tree)))==ast.dump(tree)
+changed=set(data['changed'])
+called=set(data['called'])
+out=[]
+used=set()
+def offset(line,col):
+    return sum(map(len,lines[:line-1]))+len(lines[line-1].encode('utf-8')[:col].decode('utf-8'))
+class Replace(ast.NodeTransformer):
+    def __init__(self,target,replacement): self.target,self.replacement=target,replacement
+    def visit(self,node):
+        if node is self.target: return self.replacement
+        return super().visit(node)
+def visit(node,fn=None):
+    if len(out)>=4: return
+    if isinstance(node,(ast.FunctionDef,ast.AsyncFunctionDef)):
+        fn=node if not node.decorator_list and isinstance(node,ast.FunctionDef) else None
+    line=getattr(node,'lineno',0)
+    if fn and fn.lineno in called and line in changed and line not in used and ast.dump(node) not in original:
+        attempts=[]
+        if isinstance(node,(ast.Return,ast.Raise,ast.Assign,ast.AnnAssign,ast.AugAssign,ast.Expr,ast.If)):
+            start=offset(line,node.col_offset)
+            end=offset(node.end_lineno,node.end_col_offset)
+            if node.end_lineno==line and not source[offset(line,0):start].strip() and not source[end:offset(line,len(lines[line-1].encode('utf-8')))].strip():
+                attempts.append((source[:start]+source[end:],node,None,'delete statement'))
+        target=node.test if isinstance(node,ast.If) else node.value if isinstance(node,ast.Return) else None
+        if target is not None and target.lineno==target.end_lineno and ast.dump(target) not in original:
+            start=offset(target.lineno,target.col_offset)
+            end=offset(target.end_lineno,target.end_col_offset)
+            replacement=ast.UnaryOp(op=ast.Not(),operand=copy.deepcopy(target))
+            attempts.append((source[:start]+'not ('+source[start:end]+')'+source[end:],target,replacement,'negate condition' if isinstance(node,ast.If) else 'negate return'))
+        for text,target,replacement,operation in attempts:
+            try:
+                parsed=ast.parse(text)
+                memo={}
+                expected=copy.deepcopy(tree,memo)
+                expected=Replace(memo[id(target)],replacement).visit(expected)
+                same=ast.dump(parsed)==ast.dump(expected) and ast.dump(ast.parse(ast.unparse(parsed)))==ast.dump(parsed)
+            except (SyntaxError,ValueError): same=False
+            if same:
+                out.append(dict(line=line,functionName=fn.name,source=text,operation=operation))
+                used.add(line)
+                break
+    for child in ast.iter_child_nodes(node): visit(child,fn)
+visit(tree)
+print(json.dumps(out[:4]))
+`;
+function pythonMutations(before, source, called, dir) {
+  const r = spawnSync3("python3", ["-c", PYTHON_MUTATIONS], {
+    cwd: dir,
+    encoding: "utf8",
+    maxBuffer: 2 * 1024 * 1024,
+    input: JSON.stringify({ before, source, changed: [...changedSourceLines(before, source)], called })
+  });
+  if (r.status !== 0) return [];
+  try {
+    return JSON.parse(r.stdout);
+  } catch {
+    return [];
+  }
+}
+
+// src/dynamic-worker.ts
+var options = JSON.parse(readFileSync4(process.argv[2], "utf8"));
+var scratch = dirname2(process.argv[2]);
+var result = { status: "completed", findings: [], runs: [], notes: [], elapsedMs: 0 };
+function evidence(...runs) {
+  return runs.map((r) => `${r.label}: \`${r.command}\`, exit ${r.exitCode}, ${r.passed.length} passed, ${r.failed.length} failed${r.failed.length ? ` (${r.failed.join(", ")})` : ""}${r.fileRuns ? "; " + r.fileRuns.map((f) => `\`${f.command}\`, exit ${f.exitCode}, file ${f.file}`).join("; ") : ""}`).join("; ");
+}
+function finding(id, file, message, runs, line = 1) {
+  result.findings.push({ verifierId: id, severity: "warn", file, line, message: `${message} Evidence: ${evidence(...runs)}.`, suggestion: "Review the observed behavior and add a focused regression test. Runtime evidence cannot establish intent." });
+}
+try {
+  let run2 = function(tree, label) {
+    const dir = join4(scratch, `run-${result.runs.length + 1}`);
+    materialize(tree, dir, options.cwd);
+    const runAdapter = detectAdapter(tree, [...tree.keys()].filter((p) => isTest(p)));
+    const testRun = runTests(runAdapter, dir, label);
+    result.runs.push(testRun);
+    return { run: testRun, dir };
+  }, withTests2 = function(source, tests) {
+    const hybrid = new Map(source);
+    for (const p of /* @__PURE__ */ new Set([...oldTests, ...nextTests])) hybrid.delete(p);
+    for (const [p, data] of tests) if (isTest(p)) hybrid.set(p, data);
+    return hybrid;
+  };
+  run = run2, withTests = withTests2;
+  const { old, next } = loadSnapshots(options);
+  const isTest = picomatch(options.testPathGlobs, { dot: true });
+  const oldTests = [...old.keys()].filter((p) => isTest(p)), nextTests = [...next.keys()].filter((p) => isTest(p));
+  const adapter = detectAdapter(old, oldTests);
+  const nextAdapter = detectAdapter(next, nextTests);
+  if (adapter.kind !== nextAdapter.kind) throw Error("not run: test framework changed");
+  if ([...next.keys()].some((p) => !isTest(p) && /\.(?:go|rs|java|rb|php|cs|kt|cpp|c|swift)$/.test(p) && old.get(p)?.data.toString() !== next.get(p)?.data.toString())) {
+    result.notes.push("not run: probes for languages other than Node JavaScript and Python");
+  }
+  const original = run2(old, "original tests / original code").run;
+  const current = run2(next, "new tests / new code");
+  if (original.failed.length && current.run.exitCode === 0) {
+    result.notes.push("Original tests are red and new tests are green. Continue with per-test comparisons and applicable probes; this is a normal fix shape.");
+  }
+  const testChanges = [.../* @__PURE__ */ new Set([...oldTests, ...nextTests])].filter((p) => old.get(p)?.data.toString() !== next.get(p)?.data.toString());
+  const changedSource = [.../* @__PURE__ */ new Set([...old.keys(), ...next.keys()])].some((p) => !isTest(p) && !/\.(?:md|rst|txt)$/i.test(p) && old.get(p)?.data.toString() !== next.get(p)?.data.toString());
+  const intent = documentedIntent(old, next);
+  const edits = testChanges.filter((p) => expectedEdits(old.get(p)?.data.toString() ?? "", next.get(p)?.data.toString() ?? ""));
+  const cross = testChanges.length ? run2(withTests2(next, old), "original tests / new code").run : current.run;
+  if (!intent) {
+    for (const id of cross.failed.filter((id2) => original.passed.includes(id2))) {
+      const file = locateTest(id, old, oldTests);
+      if (file && !edits.includes(file)) finding("DY001", file, `Previously passing original test ${JSON.stringify(id)} fails against the new code`, [original, current.run, cross]);
+    }
+  }
+  let reverse;
+  if (testChanges.length) {
+    reverse = run2(withTests2(old, next), "new tests / original code").run;
+    const both = current.run.passed.filter((id) => reverse.passed.includes(id));
+    if (both.length) result.notes.push(`${both.length} named tests passed on both code revisions. This alone does not show that changed tests exercise the change and is not a finding.`);
+    if (!changedSource && !intent && testChanges.length === 1 && edits.length && expectationOnlyEdit(old.get(edits[0])?.data.toString() ?? "", next.get(edits[0])?.data.toString() ?? "")) {
+      const rejected = reverse.failed.filter((id) => original.passed.includes(id));
+      const accepted = reverse.passed.filter((id) => original.failed.includes(id));
+      for (const id of [...rejected, ...accepted]) {
+        const file = locateTest(id, old, oldTests);
+        const mismatch = accepted.includes(id) ? "failed with the original expectation, but the edited expectation passes on that same old code; the edit already matches the old behavior" : "passed with the original expectation, but the edited expectation fails on that same old code";
+        if (file && edits.includes(file)) finding("DY003", file, `Only the expected literal changed (${expectationChanges(old.get(file)?.data.toString() ?? "", next.get(file)?.data.toString() ?? "").map((e) => `${e.before} to ${e.after}`).join(", ")}): test ${JSON.stringify(id)} ${mismatch}`, [original, current.run, reverse]);
+      }
+    }
+  }
+  if (current.run.exitCode === 0 && !testChanges.length && !intent) {
+    for (const probe of findProbes(old, next, isTest)) {
+      const values = probeInputs(probe.input);
+      const observed = [];
+      const probeRuns = [];
+      for (const [tree, label] of [[old, "probe / original code"], [next, "probe / new code"]]) {
+        const dir = join4(scratch, `probe-${result.runs.length + 1}`);
+        materialize(tree, dir, options.cwd);
+        let command, args;
+        if (probe.language === "js") {
+          const script = `const m=await import(${JSON.stringify("./" + probe.file)});const f=m[${JSON.stringify(probe.name)}]??m.default?.[${JSON.stringify(probe.name)}];console.log(JSON.stringify(${JSON.stringify(values)}.map(x=>f(x))));`;
+          writeFileSync4(join4(dir, ".proctor-probe.mjs"), script);
+          command = process.execPath;
+          args = [".proctor-probe.mjs"];
+        } else {
+          const script = `import importlib.util,json
+s=importlib.util.spec_from_file_location('probe',${JSON.stringify(probe.file)})
+m=importlib.util.module_from_spec(s)
+s.loader.exec_module(m)
+print(json.dumps([getattr(m,${JSON.stringify(probe.name)})(x) for x in json.loads(${JSON.stringify(JSON.stringify(values))})]))
+`;
+          writeFileSync4(join4(dir, ".proctor-probe.py"), script);
+          command = "python3";
+          args = [".proctor-probe.py"];
+        }
+        const r = spawnSync4(command, args, { cwd: dir, encoding: "utf8", maxBuffer: 128 * 1024 });
+        if (r.status !== 0) {
+          observed.length = 0;
+          break;
+        }
+        let outputs;
+        try {
+          outputs = JSON.parse(r.stdout);
+        } catch {
+          observed.length = 0;
+          break;
+        }
+        if (!Array.isArray(outputs) || outputs.length !== values.length || outputs.some((n) => !["number", "string", "boolean"].includes(typeof n) || typeof n === "number" && !Number.isFinite(n))) {
+          observed.length = 0;
+          break;
+        }
+        observed.push(outputs);
+        const pr = { label, command: `${command} ${args.join(" ")} (${probe.file}:${probe.name}, inputs ${JSON.stringify(values)})`, exitCode: 0, passed: [], failed: [], detail: `outputs ${JSON.stringify(outputs)}` };
+        result.runs.push(pr);
+        probeRuns.push(pr);
+      }
+      if (observed.length === 2 && values.every((_, i) => i === 1 || observed[0][i] === observed[1][i]) && observed[0][1] !== observed[1][1]) {
+        finding("DY002", probe.file, `Literal branch in ${probe.name} contradicts the original simple reference only at ${JSON.stringify(probe.input)}: old ${JSON.stringify(observed[0])}, new ${JSON.stringify(observed[1])}, inputs ${JSON.stringify(values)}`, [original, current.run, ...probeRuns], probe.line);
+      }
+    }
+  }
+  if (original.failed.length && current.run.exitCode === 0 && !testChanges.length && !intent) {
+    try {
+      const coverage = coverageEnvironment(current.dir);
+      const control = runTests(nextAdapter, current.dir, "new tests / new code coverage control", coverage.env);
+      result.runs.push(control);
+      const samePasses = (a, b) => a.exitCode === 0 && b.exitCode === 0 && !a.failed.length && !b.failed.length && a.passed.length > 0 && a.passed.length === b.passed.length && a.passed.every((id) => b.passed.includes(id));
+      if (samePasses(current.run, control)) {
+        const calls = readCalls(coverage.path, current.dir);
+        let count = 0;
+        for (const [file, entry] of next) {
+          if (count >= MUTATION_LIMIT) break;
+          if (isTest(file) || !/\.(?:js|mjs|cjs|py)$/.test(file)) continue;
+          const before = old.get(file)?.data.toString() ?? "", source = entry.data.toString();
+          if (before === source) continue;
+          const path = join4(current.dir, file);
+          const candidates = file.endsWith(".py") ? pythonMutations(before, source, calls.python.get(path) ?? [], current.dir) : jsMutations(before, source, calls.js.get(path) ?? []);
+          for (const mutation of candidates) {
+            if (count >= MUTATION_LIMIT) break;
+            count++;
+            let mutant;
+            try {
+              writeFileSync4(path, mutation.source);
+              mutant = runTests(nextAdapter, current.dir, `mutation ${count}: ${mutation.operation}, ${file}:${mutation.line} (${mutation.functionName})`);
+              result.runs.push(mutant);
+            } catch {
+            } finally {
+              writeFileSync4(path, source);
+            }
+            if (mutant && samePasses(current.run, mutant)) {
+              const restored = runTests(nextAdapter, current.dir, `mutation ${count}: restored control`);
+              result.runs.push(restored);
+              if (samePasses(current.run, restored)) finding(
+                "DY004",
+                file,
+                `${mutation.operation} at ${file}:${mutation.line} in called function ${mutation.functionName} left every named test passing; this changed statement has no demonstrated test protection`,
+                [original, current.run, control, mutant, restored],
+                mutation.line
+              );
+            }
+          }
+        }
+        result.notes.push(`Mutation-lite: ${Math.min(count, MUTATION_LIMIT)} candidates run, cap ${MUTATION_LIMIT}; only parser-confirmed statements in called functions are eligible.`);
+      } else result.notes.push("not run: mutation-lite coverage control did not reproduce the green suite");
+    } catch (error) {
+      result.notes.push(`not run: mutation-lite could not establish reliable evidence: ${String(error)}`);
+    }
+  }
+  const raceFiles = testChanges.filter((p) => /(?:sleep\s*\(|setTimeout\s*\(|\bretry\b|\bretries\b)/.test(next.get(p)?.data.toString() ?? "") && (next.get(p)?.data.toString().match(/sleep\s*\(|setTimeout\s*\(|\bretry\b|\bretries\b/g)?.length ?? 0) > (old.get(p)?.data.toString().match(/sleep\s*\(|setTimeout\s*\(|\bretry\b|\bretries\b/g)?.length ?? 0));
+  if (raceFiles.length && current.run.exitCode === 0) {
+    const repeats = [current.run];
+    for (let i = 1; i <= 3; i++) {
+      const repeated = runTests(nextAdapter, current.dir, `new tests / new code repeat ${i}`);
+      result.runs.push(repeated);
+      repeats.push(repeated);
+    }
+    const ids = new Set(repeats.flatMap((r) => r.failed));
+    for (const id of ids) {
+      const file = locateTest(id, next, raceFiles);
+      if (file && repeats.some((r) => r.passed.includes(id)) && repeats.filter((r) => r.failed.includes(id)).length >= 2) {
+        finding("DY005", file, `Test ${JSON.stringify(id)} has inconsistent outcomes across four runs after adding a sleep or retry; this can also be order dependence`, repeats);
+      }
+    }
+  }
+} catch (error) {
+  result.status = "skipped";
+  result.reason = String(error).replace(/^Error: /, "");
+  result.findings = [];
+}
+var run;
+var withTests;
+process.stdout.write(JSON.stringify(result));