@davmash/bygone 0.10.1 → 0.11.1

package/out/reviewWorkspace.js

@@ -0,0 +1,1129 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/strand/src/input.js
+var require_input = __commonJS({
+  "packages/strand/src/input.js"(exports2, module2) {
+    "use strict";
+    var LIMITS = Object.freeze({ maxFiles: 50, maxFileBytes: 1048576, maxBytes: 4194304, maxRecords: 2e4, timeoutMs: 3e4, maxOutputBytes: 16777216 });
+    function inputProblem(before, after, limits) {
+      if (!before || !after || typeof before !== "object" || typeof after !== "object" || Array.isArray(before) || Array.isArray(after)) return "invalid-snapshot-map";
+      if ((/* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])).size > Math.min(limits.maxFiles, LIMITS.maxFiles)) return "file-budget";
+      let bytes = 0;
+      for (const files of [before, after]) for (const value of Object.values(files)) {
+        if (typeof value !== "string") return "invalid-snapshot-text";
+        const size = Buffer.byteLength(value);
+        bytes += size;
+        if (size > Math.min(limits.maxFileBytes, LIMITS.maxFileBytes)) return "file-byte-budget";
+      }
+      return bytes > Math.min(limits.maxBytes, LIMITS.maxBytes) ? "comparison-byte-budget" : null;
+    }
+    function boundedProcessOptions(options, timeoutKey, outputKey, defaultTimeout) {
+      const timeout = options[timeoutKey] === void 0 ? defaultTimeout : options[timeoutKey];
+      const maxBuffer = options[outputKey] === void 0 ? LIMITS.maxOutputBytes : options[outputKey];
+      if (![timeout, maxBuffer].every((value) => Number.isSafeInteger(value) && value > 0)) return null;
+      return { timeout: Math.min(timeout, defaultTimeout), maxBuffer: Math.min(maxBuffer, LIMITS.maxOutputBytes) };
+    }
+    module2.exports = { LIMITS, inputProblem, boundedProcessOptions };
+  }
+});
+
+// packages/strand/src/source-references.js
+var require_source_references = __commonJS({
+  "packages/strand/src/source-references.js"(exports2, module2) {
+    "use strict";
+    var { createHash: createHash3 } = require("node:crypto");
+    var { inputProblem, LIMITS } = require_input();
+    var digest3 = (text) => createHash3("sha256").update(text, "utf8").digest("hex");
+    var key = (ref) => JSON.stringify([ref.revision, ref.path, ref.start, ref.end, ref.digest]);
+    function identifier(value) {
+      if (typeof value !== "string" || !value.trim() || value.length > 1e5) {
+        throw new TypeError("Expected bounded nonempty identifier");
+      }
+      return value;
+    }
+    function parseSourceRef3(value) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Expected source reference");
+      const revision2 = identifier(value.revision), path = identifier(value.path);
+      if (path.startsWith("/") || /^[A-Za-z]:/.test(path) || path.includes("\\") || path.includes("\0") || path.split("/").some((part) => !part || part === "." || part === "..")) {
+        throw new TypeError("Invalid relative source path");
+      }
+      if (!Number.isSafeInteger(value.start) || !Number.isSafeInteger(value.end) || value.start < 0 || value.end <= value.start) {
+        throw new TypeError("Invalid UTF-16 range");
+      }
+      if (typeof value.digest !== "string" || !/^[a-f0-9]{64}$/.test(value.digest)) throw new TypeError("Expected SHA-256");
+      return { revision: revision2, path, start: value.start, end: value.end, digest: value.digest };
+    }
+    function checkSnapshot(snapshot) {
+      if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)) throw new TypeError("Expected snapshot");
+      identifier(snapshot.revision);
+      const problem = inputProblem(snapshot.files, {}, LIMITS);
+      if (problem) throw new TypeError(problem);
+    }
+    function sourceAt(snapshot, path) {
+      return Object.prototype.hasOwnProperty.call(snapshot.files, path) ? snapshot.files[path] : void 0;
+    }
+    function pinSourceRef2(snapshot, path, start, end) {
+      checkSnapshot(snapshot);
+      const ref = parseSourceRef3({ revision: snapshot.revision, path, start, end, digest: "0".repeat(64) });
+      const text = sourceAt(snapshot, ref.path);
+      if (typeof text !== "string" || end > text.length) throw new TypeError("Source is unavailable or range exceeds file");
+      return { ...ref, digest: digest3(text.slice(start, end)) };
+    }
+    function resolveChecked(ref, snapshot) {
+      if (snapshot.revision !== ref.revision) return { status: "broken", reason: "Revision unavailable in this comparison" };
+      const text = sourceAt(snapshot, ref.path);
+      if (typeof text !== "string" || ref.end > text.length) return { status: "broken", reason: "Source path or range unavailable" };
+      const slice = text.slice(ref.start, ref.end);
+      if (digest3(slice) !== ref.digest) return { status: "broken", reason: "Source digest mismatch" };
+      return { status: "valid", text: slice };
+    }
+    function resolveSourceRef3(value, snapshot) {
+      const ref = parseSourceRef3(value);
+      checkSnapshot(snapshot);
+      return resolveChecked(ref, snapshot);
+    }
+    function boundedList(value) {
+      if (!Array.isArray(value) || value.length > LIMITS.maxRecords) throw new TypeError("Expected bounded reference array");
+      return value;
+    }
+    function relocateSourceRefs2(values, before, after, pairs) {
+      checkSnapshot(before);
+      checkSnapshot(after);
+      const problem = inputProblem(before.files, after.files, LIMITS);
+      if (problem) throw new TypeError(problem);
+      if (before.revision === after.revision) throw new TypeError("Relocation requires distinct snapshot revisions");
+      const refs = boundedList(values).map(parseSourceRef3);
+      const candidates = boundedList(pairs).map((pair) => {
+        if (!pair || typeof pair !== "object") throw new TypeError("Expected correspondence pair");
+        return { before: parseSourceRef3(pair.before), after: parseSourceRef3(pair.after) };
+      });
+      const destinations = /* @__PURE__ */ new Map(), usedAfter = /* @__PURE__ */ new Set();
+      for (const pair of candidates) {
+        const from = key(pair.before), to = key(pair.after);
+        if (destinations.has(from) || usedAfter.has(to)) throw new TypeError("Duplicate correspondence endpoint");
+        destinations.set(from, pair.after);
+        usedAfter.add(to);
+      }
+      for (const pair of candidates) {
+        if (resolveChecked(pair.before, before).status !== "valid" || resolveChecked(pair.after, after).status !== "valid") {
+          throw new TypeError("Invalid correspondence endpoint");
+        }
+      }
+      return refs.map((ref) => {
+        let destination;
+        if (resolveChecked(ref, before).status === "valid") {
+          destination = sourceAt(before, ref.path) === sourceAt(after, ref.path) ? { ...ref, revision: after.revision } : destinations.get(key(ref));
+        }
+        if (!destination) return { status: "unresolved", before: ref };
+        const status2 = ref.digest !== destination.digest ? "changed" : ref.path !== destination.path || ref.start !== destination.start ? "relocated" : "unchanged";
+        return { status: status2, before: ref, after: { ...destination } };
+      });
+    }
+    module2.exports = { parseSourceRef: parseSourceRef3, pinSourceRef: pinSourceRef2, resolveSourceRef: resolveSourceRef3, relocateSourceRefs: relocateSourceRefs2 };
+  }
+});
+
+// packages/strand/source-references.js
+var require_source_references2 = __commonJS({
+  "packages/strand/source-references.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_source_references();
+  }
+});
+
+// src/reviewWorkspace.ts
+var reviewWorkspace_exports = {};
+__export(reviewWorkspace_exports, {
+  commitOid: () => commitOid,
+  comparisonPaths: () => comparisonPaths,
+  git: () => git,
+  inspectWorkspace: () => inspectWorkspace,
+  lineReference: () => lineReference,
+  loadReview: () => loadReview,
+  readEvidenceJson: () => readEvidenceJson,
+  readPinnedFile: () => readPinnedFile,
+  readSnapshot: () => readSnapshot,
+  refreshWorkspace: () => refreshWorkspace,
+  repositoryRoot: () => repositoryRoot,
+  sourceText: () => sourceText,
+  writeReview: () => writeReview
+});
+module.exports = __toCommonJS(reviewWorkspace_exports);
+var import_child_process2 = require("child_process");
+var import_fs2 = require("fs");
+var import_path = require("path");
+var import_util = require("util");
+var import_source_references2 = __toESM(require_source_references2());
+
+// src/requirements.ts
+var import_crypto = require("crypto");
+var import_source_references = __toESM(require_source_references2());
+var digest = (text) => (0, import_crypto.createHash)("sha256").update(text, "utf8").digest("hex");
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Expected object");
+  return value;
+}
+function string(value) {
+  if (typeof value !== "string" || !value.trim() || value.length > 1e5) throw new Error("Expected bounded nonempty string");
+  return value;
+}
+function list(value) {
+  if (!Array.isArray(value) || value.length > 1e3) throw new Error("Expected bounded array");
+  return value;
+}
+function choice(value, choices) {
+  if (!choices.includes(value)) throw new Error(`Expected ${choices.join("/")}`);
+  return value;
+}
+function hash(value) {
+  if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)) throw new Error("Expected SHA-256");
+  return value;
+}
+function revision(value) {
+  if (typeof value !== "string" || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(value)) throw new Error("Expected immutable Git revision");
+  return value;
+}
+function sourceRef(value) {
+  const ref = (0, import_source_references.parseSourceRef)(value);
+  revision(ref.revision);
+  return ref;
+}
+function unique(values) {
+  if (new Set(values).size !== values.length) throw new Error("Duplicate ID");
+}
+function sources(value) {
+  const result = list(value).map((value2) => {
+    const s = record(value2);
+    const source = { title: string(s.title), text: string(s.text), quote: string(s.quote) };
+    if (!source.text.includes(source.quote)) throw new Error("Source quotation does not exist");
+    return source;
+  });
+  if (!result.length) throw new Error("Expected at least one source");
+  return result;
+}
+function parseAnalysis(value) {
+  const a = record(value), scope = list(a.scope).map(string);
+  if (!scope.length) throw new Error("Expected analysis scope");
+  return {
+    base: revision(a.base),
+    head: revision(a.head),
+    producer: string(a.producer),
+    status: choice(a.status, ["complete", "partial", "unavailable"]),
+    scope,
+    limitations: list(a.limitations).map(string),
+    artifactDigest: hash(a.artifactDigest)
+  };
+}
+function parseRequirement(value) {
+  const r = record(value);
+  return { id: string(r.id), text: string(r.text), sources: sources(r.sources) };
+}
+function parseQuestion(value, requirement = string) {
+  const q = record(value);
+  const alternatives = list(q.alternatives).map((value2) => {
+    const a = record(value2);
+    return { text: string(a.text), sources: sources(a.sources) };
+  });
+  const common = { id: string(q.id), requirement: requirement(q.requirement), text: string(q.text), alternatives };
+  const status2 = choice(q.status, ["open", "resolved"]);
+  if (status2 === "open" && q.resolution !== void 0) throw new Error("Open question cannot have a resolution");
+  return status2 === "open" ? { ...common, status: status2 } : { ...common, status: status2, resolution: string(q.resolution) };
+}
+function parseLink(value, requirement = string) {
+  const x = record(value);
+  return { id: string(x.id), requirement: requirement(x.requirement), role: choice(x.role, ["implementation", "test", "context", "counterexample"]), rationale: string(x.rationale), ref: sourceRef(x.ref) };
+}
+function parseRun(value, requirement = string) {
+  const x = record(value), associations = list(x.requirements).map((value2) => {
+    const a = record(value2);
+    return { requirement: requirement(a.requirement), fingerprint: hash(a.fingerprint), scope: string(a.scope) };
+  });
+  unique(associations.map((a) => a.requirement));
+  return { revision: revision(x.revision), requirements: associations, command: string(x.command), outcome: choice(x.outcome, ["passed", "failed"]), outputDigest: hash(x.outputDigest) };
+}
+function correspondenceEvidence(artifact, scope) {
+  const ref = (side, id) => {
+    const symbol = artifact.symbols[side].find((s) => s.id === id);
+    if (!symbol) throw new Error("Unknown correspondence symbol");
+    return sourceRef({
+      revision: side === "before" ? artifact.range.baseOid : artifact.range.headOid,
+      path: symbol.path,
+      start: symbol.start,
+      end: symbol.end,
+      digest: symbol.digest
+    });
+  };
+  return {
+    pairs: artifact.relations.map((r) => ({ before: ref("before", r.sourceId), after: ref("after", r.destinationId) })),
+    analysis: parseAnalysis({
+      base: artifact.range.baseOid,
+      head: artifact.range.headOid,
+      producer: artifact.producer,
+      status: artifact.status,
+      scope: [...scope, ...artifact.diagnostics?.scope || []],
+      limitations: artifact.limitations,
+      artifactDigest: digest(JSON.stringify(artifact))
+    })
+  };
+}
+function parseReview(value) {
+  const r = record(value);
+  if (r.version !== 2) throw new Error("Unsupported review version");
+  const requirements = list(r.requirements).map(parseRequirement);
+  unique(requirements.map((r2) => r2.id));
+  const requirement = (value2) => {
+    const id = string(value2);
+    if (!requirements.some((r2) => r2.id === id)) throw new Error(`Unknown requirement: ${id}`);
+    return id;
+  };
+  const questions = list(r.questions).map((value2) => parseQuestion(value2, requirement));
+  unique(questions.map((q) => q.id));
+  const links = list(r.links).map((value2) => parseLink(value2, requirement));
+  unique(links.map((l) => l.id));
+  const runs = list(r.runs).map((value2) => parseRun(value2, requirement));
+  const decisions = list(r.decisions).map((value2) => {
+    const x = record(value2);
+    return { requirement: requirement(x.requirement), fingerprint: hash(x.fingerprint), note: string(x.note) };
+  });
+  unique(decisions.map((d) => d.requirement));
+  return { version: 2, repository: string(r.repository), base: revision(r.base), head: revision(r.head), requirements, questions, links, runs, analyses: list(r.analyses).map(parseAnalysis), decisions };
+}
+function snapshotsMatch(review, base, head) {
+  if (review.repository !== base.repository || review.repository !== head.repository || review.base !== base.revision || review.head !== head.revision) throw new Error("Repository or comparison mismatch");
+}
+function sourceSubset(snapshot, paths) {
+  const present = [...new Set(paths)].filter((path) => Object.prototype.hasOwnProperty.call(snapshot.files, path));
+  return { revision: snapshot.revision, files: Object.fromEntries(present.map((path) => [path, snapshot.files[path]])) };
+}
+function resolveReference(ref, snapshot) {
+  return (0, import_source_references.resolveSourceRef)(ref, sourceSubset(snapshot, [ref.path]));
+}
+function requirementFingerprint(review, id) {
+  const requirement = review.requirements.find((r) => r.id === id);
+  if (!requirement) throw new Error(`Unknown requirement: ${id}`);
+  return digest(JSON.stringify({
+    repository: review.repository,
+    requirement: parseRequirement(requirement),
+    questions: review.questions.filter((q) => q.requirement === id).map((q) => parseQuestion(q))
+  }));
+}
+function fingerprint(review, id) {
+  return digest(JSON.stringify({
+    repository: review.repository,
+    base: review.base,
+    head: review.head,
+    requirement: requirementFingerprint(review, id),
+    links: review.links.filter((l) => l.requirement === id).map((l) => parseLink(l)),
+    runs: review.runs.filter((r) => r.requirements.some((a) => a.requirement === id)).map((r) => parseRun(r)),
+    analyses: review.analyses.map(parseAnalysis)
+  }));
+}
+function inspect(review, base, head) {
+  snapshotsMatch(review, base, head);
+  const links = review.links.map((link) => ({ ...link, resolution: resolveReference(link.ref, link.ref.revision === base.revision ? base : head) }));
+  const requirements = review.requirements.map((requirement) => {
+    const attached = links.filter((l) => l.requirement === requirement.id);
+    const valid = attached.filter((l) => l.resolution.status === "valid");
+    const key = requirementFingerprint(review, requirement.id);
+    const runs = review.runs.flatMap((run) => run.requirements.filter((a) => a.requirement === requirement.id).map((association) => ({
+      ...run,
+      association,
+      applicability: run.revision !== head.revision ? "historical-revision" : association.fingerprint === key ? "current" : "stale-requirement"
+    })));
+    const currentRuns = runs.filter((r) => r.applicability === "current");
+    const decision = review.decisions.find((d) => d.requirement === requirement.id);
+    return {
+      ...requirement,
+      questions: review.questions.filter((q) => q.requirement === requirement.id),
+      runs,
+      links: attached,
+      implementationLinked: valid.some((l) => l.role === "implementation"),
+      testLinked: valid.some((l) => l.role === "test"),
+      counterexampleLinked: valid.some((l) => l.role === "counterexample"),
+      verification: currentRuns.length ? currentRuns.some((r) => r.outcome === "failed") ? "recorded-failure" : "recorded-pass" : runs.some((r) => r.applicability === "stale-requirement") ? "needs-reassessment" : "not-recorded",
+      reviewer: !decision ? "unreviewed" : decision.fingerprint === fingerprint(review, requirement.id) && attached.every((l) => l.resolution.status === "valid") ? "inspected" : "needs-review",
+      note: decision?.note
+    };
+  });
+  const changedPaths = [.../* @__PURE__ */ new Set([...Object.keys(base.files), ...Object.keys(head.files)])].filter((p) => base.files[p] !== head.files[p]).sort();
+  return {
+    requirements,
+    analyses: review.analyses.map((analysis) => ({
+      ...analysis,
+      relevance: analysis.head !== review.head ? "historical" : analysis.base === review.base ? "current-comparison" : "current-head-delta"
+    })),
+    changedPathsWithoutLinks: changedPaths.filter((p) => !links.some((l) => l.ref.path === p && l.resolution.status === "valid"))
+  };
+}
+function refresh(review, oldHead, newHead, evidence, requirements = review.requirements) {
+  if (review.repository !== oldHead.repository || review.repository !== newHead.repository || review.head !== oldHead.revision) throw new Error("Repository or old head mismatch");
+  revision(oldHead.revision);
+  revision(newHead.revision);
+  if (evidence !== void 0) {
+    record(evidence);
+    if (!Array.isArray(evidence.pairs)) throw new Error("Expected correspondence pairs");
+  }
+  const analysis = evidence === void 0 ? void 0 : parseAnalysis(evidence.analysis);
+  const pairs = evidence === void 0 ? [] : evidence.pairs;
+  if (analysis && (analysis.base !== oldHead.revision || analysis.head !== newHead.revision)) throw new Error("Analysis comparison mismatch");
+  if (analysis?.status === "unavailable" && pairs.length) throw new Error("Unavailable analysis cannot supply pairs");
+  const current = review.links.filter((link) => link.ref.revision !== review.base);
+  let relocated;
+  if (oldHead.revision === newHead.revision) {
+    if (pairs.length) throw new Error("Same-revision updates cannot supply correspondence pairs");
+    relocated = current.map(({ ref }) => resolveReference(ref, oldHead).status === "valid" && resolveReference(ref, newHead).status === "valid" ? { status: "unchanged", before: ref, after: ref } : { status: "unresolved", before: ref });
+  } else {
+    const paths = current.map((link) => link.ref.path);
+    const before = sourceSubset(oldHead, [...paths, ...pairs.map((pair) => pair.before.path)]);
+    const after = sourceSubset(newHead, [...paths, ...pairs.map((pair) => pair.after.path)]);
+    relocated = (0, import_source_references.relocateSourceRefs)(current.map((link) => link.ref), before, after, pairs);
+  }
+  const transitions = [];
+  let index = 0;
+  const links = review.links.map((link) => {
+    const before = link.ref;
+    if (before.revision === review.base) {
+      transitions.push({ link: link.id, status: "base-evidence", before });
+      return link;
+    }
+    const transition = relocated[index++];
+    transitions.push({ ...transition, link: link.id });
+    return transition.status === "unresolved" ? link : { ...link, ref: transition.after };
+  });
+  const next = parseReview({ ...review, head: newHead.revision, requirements, links, analyses: analysis ? [...review.analyses, analysis] : review.analyses });
+  return { review: next, transitions };
+}
+
+// src/changeCorrespondence.ts
+var import_crypto2 = require("crypto");
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+
+// node_modules/diff/lib/index.mjs
+function Diff() {
+}
+Diff.prototype = {
+  diff: function diff(oldString, newString) {
+    var _options$timeout;
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    var callback = options.callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    this.options = options;
+    var self = this;
+    function done(value) {
+      if (callback) {
+        setTimeout(function() {
+          callback(void 0, value);
+        }, 0);
+        return true;
+      } else {
+        return value;
+      }
+    }
+    oldString = this.castInput(oldString);
+    newString = this.castInput(newString);
+    oldString = this.removeEmpty(this.tokenize(oldString));
+    newString = this.removeEmpty(this.tokenize(newString));
+    var newLen = newString.length, oldLen = oldString.length;
+    var editLength = 1;
+    var maxEditLength = newLen + oldLen;
+    if (options.maxEditLength) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    var maxExecutionTime = (_options$timeout = options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity;
+    var abortAfterTimestamp = Date.now() + maxExecutionTime;
+    var bestPath = [{
+      oldPos: -1,
+      lastComponent: void 0
+    }];
+    var newPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done([{
+        value: this.join(newString),
+        count: newString.length
+      }]);
+    }
+    var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    function execEditLength() {
+      for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        var basePath = void 0;
+        var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        var canAdd = false;
+        if (addPath) {
+          var addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        var canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) {
+          basePath = self.addToPath(addPath, true, void 0, 0);
+        } else {
+          basePath = self.addToPath(removePath, void 0, true, 1);
+        }
+        newPos = self.extractCommon(basePath, newString, oldString, diagonalPath);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken));
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    }
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback();
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        var ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  },
+  addToPath: function addToPath(path, added, removed, oldPosInc) {
+    var last = path.lastComponent;
+    if (last && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: {
+          count: last.count + 1,
+          added,
+          removed,
+          previousComponent: last.previousComponent
+        }
+      };
+    } else {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: {
+          count: 1,
+          added,
+          removed,
+          previousComponent: last
+        }
+      };
+    }
+  },
+  extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
+    var newLen = newString.length, oldLen = oldString.length, oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+    }
+    if (commonCount) {
+      basePath.lastComponent = {
+        count: commonCount,
+        previousComponent: basePath.lastComponent
+      };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  },
+  equals: function equals(left, right) {
+    if (this.options.comparator) {
+      return this.options.comparator(left, right);
+    } else {
+      return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  },
+  removeEmpty: function removeEmpty(array) {
+    var ret = [];
+    for (var i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  },
+  castInput: function castInput(value) {
+    return value;
+  },
+  tokenize: function tokenize(value) {
+    return value.split("");
+  },
+  join: function join(chars) {
+    return chars.join("");
+  }
+};
+function buildValues(diff2, lastComponent, newString, oldString, useLongestToken) {
+  var components = [];
+  var nextComponent;
+  while (lastComponent) {
+    components.push(lastComponent);
+    nextComponent = lastComponent.previousComponent;
+    delete lastComponent.previousComponent;
+    lastComponent = nextComponent;
+  }
+  components.reverse();
+  var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0;
+  for (; componentPos < componentLen; componentPos++) {
+    var component = components[componentPos];
+    if (!component.removed) {
+      if (!component.added && useLongestToken) {
+        var value = newString.slice(newPos, newPos + component.count);
+        value = value.map(function(value2, i) {
+          var oldValue = oldString[oldPos + i];
+          return oldValue.length > value2.length ? oldValue : value2;
+        });
+        component.value = diff2.join(value);
+      } else {
+        component.value = diff2.join(newString.slice(newPos, newPos + component.count));
+      }
+      newPos += component.count;
+      if (!component.added) {
+        oldPos += component.count;
+      }
+    } else {
+      component.value = diff2.join(oldString.slice(oldPos, oldPos + component.count));
+      oldPos += component.count;
+      if (componentPos && components[componentPos - 1].added) {
+        var tmp = components[componentPos - 1];
+        components[componentPos - 1] = components[componentPos];
+        components[componentPos] = tmp;
+      }
+    }
+  }
+  var finalComponent = components[componentLen - 1];
+  if (componentLen > 1 && typeof finalComponent.value === "string" && (finalComponent.added || finalComponent.removed) && diff2.equals("", finalComponent.value)) {
+    components[componentLen - 2].value += finalComponent.value;
+    components.pop();
+  }
+  return components;
+}
+var characterDiff = new Diff();
+var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
+var reWhitespace = /\S/;
+var wordDiff = new Diff();
+wordDiff.equals = function(left, right) {
+  if (this.options.ignoreCase) {
+    left = left.toLowerCase();
+    right = right.toLowerCase();
+  }
+  return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);
+};
+wordDiff.tokenize = function(value) {
+  var tokens = value.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/);
+  for (var i = 0; i < tokens.length - 1; i++) {
+    if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {
+      tokens[i] += tokens[i + 2];
+      tokens.splice(i + 1, 2);
+      i--;
+    }
+  }
+  return tokens;
+};
+var lineDiff = new Diff();
+lineDiff.tokenize = function(value) {
+  if (this.options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (var i = 0; i < linesAndNewlines.length; i++) {
+    var line = linesAndNewlines[i];
+    if (i % 2 && !this.options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      if (this.options.ignoreWhitespace) {
+        line = line.trim();
+      }
+      retLines.push(line);
+    }
+  }
+  return retLines;
+};
+function diffLines(oldStr, newStr, callback) {
+  return lineDiff.diff(oldStr, newStr, callback);
+}
+var sentenceDiff = new Diff();
+sentenceDiff.tokenize = function(value) {
+  return value.split(/(\S.+?[.!?])(?=\s+|$)/);
+};
+var cssDiff = new Diff();
+cssDiff.tokenize = function(value) {
+  return value.split(/([{}:;,]|\s+)/);
+};
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof = function(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof(obj);
+}
+var objectPrototypeToString = Object.prototype.toString;
+var jsonDiff = new Diff();
+jsonDiff.useLongestToken = true;
+jsonDiff.tokenize = lineDiff.tokenize;
+jsonDiff.castInput = function(value) {
+  var _this$options = this.options, undefinedReplacement = _this$options.undefinedReplacement, _this$options$stringi = _this$options.stringifyReplacer, stringifyReplacer = _this$options$stringi === void 0 ? function(k, v) {
+    return typeof v === "undefined" ? undefinedReplacement : v;
+  } : _this$options$stringi;
+  return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, "  ");
+};
+jsonDiff.equals = function(left, right) {
+  return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"));
+};
+function canonicalize(obj, stack, replacementStack, replacer, key) {
+  stack = stack || [];
+  replacementStack = replacementStack || [];
+  if (replacer) {
+    obj = replacer(key, obj);
+  }
+  var i;
+  for (i = 0; i < stack.length; i += 1) {
+    if (stack[i] === obj) {
+      return replacementStack[i];
+    }
+  }
+  var canonicalizedObj;
+  if ("[object Array]" === objectPrototypeToString.call(obj)) {
+    stack.push(obj);
+    canonicalizedObj = new Array(obj.length);
+    replacementStack.push(canonicalizedObj);
+    for (i = 0; i < obj.length; i += 1) {
+      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
+    }
+    stack.pop();
+    replacementStack.pop();
+    return canonicalizedObj;
+  }
+  if (obj && obj.toJSON) {
+    obj = obj.toJSON();
+  }
+  if (_typeof(obj) === "object" && obj !== null) {
+    stack.push(obj);
+    canonicalizedObj = {};
+    replacementStack.push(canonicalizedObj);
+    var sortedKeys = [], _key;
+    for (_key in obj) {
+      if (obj.hasOwnProperty(_key)) {
+        sortedKeys.push(_key);
+      }
+    }
+    sortedKeys.sort();
+    for (i = 0; i < sortedKeys.length; i += 1) {
+      _key = sortedKeys[i];
+      canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
+    }
+    stack.pop();
+    replacementStack.pop();
+  } else {
+    canonicalizedObj = obj;
+  }
+  return canonicalizedObj;
+}
+var arrayDiff = new Diff();
+arrayDiff.tokenize = function(value) {
+  return value.slice();
+};
+arrayDiff.join = arrayDiff.removeEmpty = function(value) {
+  return value;
+};
+
+// src/changeCorrespondence.ts
+var MAX_BYTES = 16 * 1024 * 1024;
+var MAX_SOURCE_BYTES = 8 * 1024 * 1024;
+var digest2 = (text) => (0, import_crypto2.createHash)("sha256").update(text, "utf8").digest("hex");
+function object(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid correspondence object.");
+  return value;
+}
+function list2(value, max = 2e4) {
+  if (!Array.isArray(value) || value.length > max) throw new Error("Invalid or over-budget correspondence array.");
+  return value;
+}
+function string2(value) {
+  if (typeof value !== "string" || !value || value.length > 4096) throw new Error("Invalid correspondence string.");
+  return value;
+}
+function integer(value) {
+  if (!Number.isSafeInteger(value) || value < 0) throw new Error("Invalid correspondence offset.");
+  return value;
+}
+function filePath(value) {
+  const name = string2(value);
+  if (name.startsWith("/") || name.includes("\\") || name.includes("\0") || name.split("/").some((p) => !p || p === "." || p === "..")) {
+    throw new Error("Invalid correspondence repository path.");
+  }
+  return name;
+}
+function hash2(value) {
+  const result = string2(value);
+  if (!/^[0-9a-f]{64}$/.test(result)) throw new Error("Invalid correspondence digest.");
+  return result;
+}
+function status(value) {
+  if (value !== "complete" && value !== "partial" && value !== "unavailable") throw new Error("Invalid correspondence analysis status.");
+  return value;
+}
+function readCorrespondenceJson(file) {
+  if ((0, import_fs.statSync)(file).size > MAX_BYTES) throw new Error("Correspondence file exceeds 16 MiB.");
+  return JSON.parse((0, import_fs.readFileSync)(file, "utf8"));
+}
+function validateRange(value, expected) {
+  const input = object(value);
+  for (const key of ["baseOid", "headOid"]) {
+    if (input[key] !== expected[key] || !/^[0-9a-f]{40,64}$/.test(expected[key])) {
+      throw new Error("Correspondence revisions do not match the selected merge-base/head comparison.");
+    }
+  }
+  return { ...expected };
+}
+function validateChangeCorrespondence(repoRoot, input, expected) {
+  const data = object(input);
+  if (data.version !== 1) throw new Error("Unsupported correspondence version.");
+  const range = validateRange(data.range, expected);
+  const documents = object(data.documents), symbols = object(data.symbols);
+  const result = {
+    version: 1,
+    range,
+    producer: string2(data.producer),
+    status: status(data.status),
+    documents: { before: [], after: [] },
+    symbols: { before: [], after: [] },
+    relations: [],
+    unresolved: [],
+    limitations: list2(data.limitations, 100).map(string2)
+  };
+  const entries = /* @__PURE__ */ new Map();
+  const documentsBySide = { before: /* @__PURE__ */ new Map(), after: /* @__PURE__ */ new Map() };
+  const lineIndexes = /* @__PURE__ */ new Map();
+  const lineAt = (side, path, start) => {
+    const key = `${side}:${path}`;
+    let lines = lineIndexes.get(key);
+    if (!lines) {
+      const text = documentsBySide[side].get(path);
+      lines = [0];
+      for (let at = text.indexOf("\n"); at !== -1; at = text.indexOf("\n", at + 1)) lines.push(at + 1);
+      lineIndexes.set(key, lines);
+    }
+    let low = 0, high = lines.length;
+    while (low < high) {
+      const mid = Math.floor((low + high) / 2);
+      if (lines[mid] <= start) low = mid + 1;
+      else high = mid;
+    }
+    return low;
+  };
+  let sourceBytes = 0, symbolBytes = 0;
+  for (const side of ["before", "after"]) {
+    const texts = /* @__PURE__ */ new Map();
+    const oid = side === "before" ? range.baseOid : range.headOid;
+    for (const value of list2(documents[side], 128)) {
+      const doc = object(value), name = filePath(doc.path), expectedDigest = hash2(doc.digest);
+      const documentStatus = string2(doc.status);
+      if (!["complete", "invalid", "unsupported"].includes(documentStatus) || texts.has(name)) throw new Error("Invalid or duplicate correspondence document.");
+      const bytes = (0, import_child_process.execFileSync)("git", ["show", `${oid}:${name}`], { cwd: repoRoot, timeout: 1e4, maxBuffer: 1024 * 1024, stdio: ["ignore", "pipe", "pipe"] });
+      const text = bytes.toString("utf8");
+      sourceBytes += bytes.length;
+      if (sourceBytes > MAX_SOURCE_BYTES || !Buffer.from(text, "utf8").equals(bytes) || digest2(text) !== expectedDigest) {
+        throw new Error(`Correspondence source digest mismatch or source budget exceeded: ${side}/${name}`);
+      }
+      texts.set(name, { text, status: documentStatus });
+      documentsBySide[side].set(name, text);
+      result.documents[side].push({ path: name, digest: expectedDigest, status: documentStatus, text });
+    }
+    for (const value of list2(symbols[side])) {
+      const entry = object(value), name = filePath(entry.path), doc = texts.get(name);
+      const id = string2(entry.id), start = integer(entry.start), end = integer(entry.end);
+      if (!doc || start >= end || end > doc.text.length || entries.has(id)) throw new Error("Invalid correspondence symbol ownership/range/ID.");
+      const text = doc.text.slice(start, end);
+      symbolBytes += Buffer.byteLength(text);
+      if (symbolBytes > MAX_SOURCE_BYTES || digest2(text) !== hash2(entry.digest)) throw new Error(`Correspondence symbol digest mismatch or budget exceeded: ${name}`);
+      const symbol = {
+        id,
+        path: name,
+        name: string2(entry.name),
+        kind: string2(entry.kind),
+        start,
+        end,
+        digest: digest2(text),
+        text,
+        startLine: lineAt(side, name, start),
+        endLine: lineAt(side, name, end - 1)
+      };
+      entries.set(id, { side, symbol, documentStatus: doc.status });
+      result.symbols[side].push(symbol);
+    }
+  }
+  const ids = /* @__PURE__ */ new Set(), sources2 = /* @__PURE__ */ new Set(), destinations = /* @__PURE__ */ new Set();
+  for (const value of list2(data.relations)) {
+    const relation = object(value), id = string2(relation.id), sourceId = string2(relation.sourceId), destinationId = string2(relation.destinationId);
+    const source = entries.get(sourceId), destination = entries.get(destinationId);
+    if (ids.has(id) || sources2.has(sourceId) || destinations.has(destinationId)) throw new Error("Conflicting correspondence continuations; preserve them as unresolved candidates.");
+    if (source?.side !== "before" || destination?.side !== "after" || source.documentStatus !== "complete" || destination.documentStatus !== "complete") {
+      throw new Error("Correspondence endpoints must resolve to valid, parsed before/after documents.");
+    }
+    ids.add(id);
+    sources2.add(sourceId);
+    destinations.add(destinationId);
+    const producers = list2(relation.producers, 10).map(string2);
+    if (relation.coverage !== void 0 && relation.coverage !== "complete") throw new Error("Invalid correspondence relation coverage.");
+    const covered = result.status === "partial" && relation.coverage === "complete" && producers.some((producer) => ["refactoring-miner", "bygone-strand"].includes(producer));
+    if (result.status !== "complete" && !covered && !(producers.includes("exact-declaration") && source.symbol.text === destination.symbol.text)) continue;
+    const a = source.symbol, b = destination.symbol;
+    result.relations.push({
+      id,
+      sourceId,
+      destinationId,
+      producers,
+      pathChanged: a.path !== b.path,
+      nameChanged: a.name !== b.name,
+      ...relation.coverage === "complete" ? { coverage: "complete" } : {},
+      rawEqual: a.text === b.text,
+      behavior: "unassessed",
+      localDiff: (diffLines(a.text, b.text, { timeout: 100, maxEditLength: 2e3 }) || [{ value: a.text, removed: true }, { value: b.text, added: true }]).map((part) => ({
+        value: part.value,
+        ...part.added ? { added: true } : {},
+        ...part.removed ? { removed: true } : {}
+      }))
+    });
+  }
+  for (const value of list2(data.unresolved)) {
+    const candidate = object(value);
+    const sourceIds = list2(candidate.sourceIds).map(string2), destinationIds = list2(candidate.destinationIds).map(string2);
+    if (!sourceIds.length && !destinationIds.length) throw new Error("Unresolved correspondence needs candidate endpoints.");
+    if (sourceIds.some((id) => entries.get(id)?.side !== "before") || destinationIds.some((id) => entries.get(id)?.side !== "after")) {
+      throw new Error("Unresolved correspondence references unknown endpoints.");
+    }
+    if (sourceIds.some((id) => sources2.has(id)) || destinationIds.some((id) => destinations.has(id))) throw new Error("Ambiguous endpoints cannot also be accepted continuations.");
+    result.unresolved.push({ reason: string2(candidate.reason), sourceIds, destinationIds });
+  }
+  if (data.diagnostics !== void 0) {
+    const diagnostics = object(data.diagnostics);
+    if (diagnostics.version !== 1) throw new Error("Unsupported correspondence diagnostics version.");
+    let locationCount = 0;
+    result.diagnostics = { version: 1, scope: list2(diagnostics.scope, 20).map(string2), records: list2(diagnostics.records).map((value) => {
+      const record2 = object(value), category = string2(record2.category);
+      if (!["outside", "syntax", "rejected", "unmatched", "relationship", "problem"].includes(category)) throw new Error("Invalid correspondence diagnostic category.");
+      return {
+        category,
+        reason: string2(record2.reason),
+        ...record2.message !== void 0 ? { message: string2(record2.message) } : {},
+        ...record2.producerId !== void 0 ? { producerId: string2(record2.producerId) } : {},
+        locations: list2(record2.locations, 100).map((value2) => {
+          if (++locationCount > 4e4) throw new Error("Correspondence diagnostic location budget exceeded.");
+          const location = object(value2), path = filePath(location.path);
+          const side = location.side;
+          if (side !== void 0 && side !== "before" && side !== "after") throw new Error("Invalid diagnostic revision side.");
+          const symbolId = location.symbolId === void 0 ? void 0 : string2(location.symbolId);
+          if (symbolId && (entries.get(symbolId)?.side !== side || entries.get(symbolId)?.symbol.path !== path)) throw new Error("Invalid diagnostic symbol reference.");
+          const start = location.start === void 0 ? symbolId ? entries.get(symbolId).symbol.start : void 0 : integer(location.start);
+          const text = side ? documentsBySide[side].get(path) : void 0;
+          if (start !== void 0 && (text === void 0 || start > text.length)) throw new Error("Invalid diagnostic source location.");
+          return {
+            path,
+            ...side ? { side } : {},
+            ...symbolId ? { symbolId } : {},
+            ...start !== void 0 ? { start, line: lineAt(side, path, start) } : {},
+            ...location.reason !== void 0 ? { reason: string2(location.reason) } : {}
+          };
+        })
+      };
+    }) };
+  }
+  return result;
+}
+function loadChangeCorrespondence(repoRoot, file, range) {
+  return validateChangeCorrespondence(repoRoot, readCorrespondenceJson(file), range);
+}
+
+// src/reviewWorkspace.ts
+var MAX_BYTES2 = 16 * 1024 * 1024;
+function readEvidenceJson(file) {
+  if ((0, import_fs2.statSync)(file).size > MAX_BYTES2) throw new Error("Evidence file exceeds 16 MiB");
+  return JSON.parse((0, import_fs2.readFileSync)(file, "utf8"));
+}
+function git(root, args, deadline) {
+  const remaining = deadline === void 0 ? 1e4 : deadline - Date.now();
+  if (remaining <= 0) throw new Error("Dependency source validation time budget exhausted");
+  return (0, import_child_process2.execFileSync)("git", ["--no-replace-objects", "-C", root, ...args], { timeout: Math.min(1e4, remaining), maxBuffer: MAX_BYTES2, stdio: ["ignore", "pipe", "pipe"] });
+}
+function commitOid(root, revision2, deadline) {
+  const oid = git(root, ["rev-parse", "--verify", "--end-of-options", `${revision2}^{commit}`], deadline).toString().trim();
+  if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(oid)) throw new Error("Expected a Git commit");
+  return oid;
+}
+function repositoryRoot(directory) {
+  return git(directory, ["rev-parse", "--show-toplevel"]).toString().trim();
+}
+function readPinnedFile(root, revision2, file, deadline) {
+  (0, import_source_references2.parseSourceRef)({ revision: revision2, path: file, start: 0, end: 1, digest: "0".repeat(64) });
+  if (commitOid(root, revision2, deadline) !== revision2) throw new Error("Evidence requires a full immutable commit ID");
+  const entry = git(root, ["ls-tree", "-z", revision2, "--", `:(literal)${file}`], deadline).toString();
+  if (!entry) return void 0;
+  const match = /^(100644|100755) blob ([a-f0-9]+)\t([^\0]+)\0$/.exec(entry);
+  if (!match || match[3] !== file) throw new Error(`Evidence is not a regular file: ${file}`);
+  const bytes = git(root, ["cat-file", "blob", match[2]], deadline);
+  if (bytes.length > 1024 * 1024 || bytes.includes(0)) throw new Error(`Evidence requires text up to 1 MiB: ${file}`);
+  return { text: new import_util.TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes), blob: match[2] };
+}
+function readSnapshot(root, repository, revision2, paths) {
+  const files = /* @__PURE__ */ Object.create(null);
+  let bytes = 0;
+  for (const file of new Set(paths)) {
+    const source = readPinnedFile(root, revision2, file);
+    if (source) {
+      bytes += Buffer.byteLength(source.text);
+      if (bytes > MAX_BYTES2) throw new Error("Review source budget exceeds 16 MiB");
+      files[file] = source.text;
+    }
+  }
+  return { repository, revision: revision2, files };
+}
+function changedPathGroups(root, base, head) {
+  const records = git(root, ["diff", "--name-status", "--find-renames", "-z", base, head, "--"]).toString().split("\0");
+  const groups = [];
+  for (let i = 0; i < records.length && records[i]; ) {
+    const status2 = records[i++], before = records[i++];
+    groups.push(status2.startsWith("R") ? [before, records[i++]] : [before]);
+  }
+  if (groups.reduce((count, group) => count + group.length, 0) > 2e3) throw new Error("Review exceeds 2000 changed paths");
+  return groups;
+}
+function comparisonPaths(root, base, head, file) {
+  const records = git(root, ["diff", "--name-status", "--find-renames", "-z", base, ...head ? [head] : [], "--"]).toString().split("\0");
+  for (let i = 0; i < records.length && records[i]; ) {
+    const status2 = records[i++], before = records[i++];
+    const after = status2.startsWith("R") || status2.startsWith("C") ? records[i++] : before;
+    if (status2.startsWith("R") && (file === before || file === after)) return { before, after };
+  }
+  return { before: file, after: file };
+}
+function inspectWorkspace(root, review) {
+  const paths = review.links.map((link) => link.ref.path);
+  const base = readSnapshot(root, review.repository, review.base, paths);
+  const head = readSnapshot(root, review.repository, review.head, paths);
+  const result = inspect(review, base, head);
+  const covered = new Set(result.requirements.flatMap((r) => r.links.filter((l) => l.resolution.status === "valid").map((l) => l.ref.path)));
+  return {
+    ...result,
+    changedPathsWithoutLinks: changedPathGroups(root, review.base, review.head).filter((group) => !group.some((file) => covered.has(file))).flat(),
+    checkoutHead: commitOid(root, "HEAD"),
+    dirtyWorkingTreeExcluded: true
+  };
+}
+function loadReview(root, file) {
+  const review = parseReview(readEvidenceJson(file));
+  inspectWorkspace(root, review);
+  return review;
+}
+function refreshWorkspace(root, review, head, correspondence, requirements = review.requirements) {
+  const revision2 = commitOid(root, head);
+  try {
+    git(root, ["merge-base", "--is-ancestor", review.head, revision2]);
+  } catch {
+    throw new Error("Refresh requires a descendant of the captured head; import a new review for a rewritten or unrelated comparison.");
+  }
+  const artifact = correspondence ? loadChangeCorrespondence(root, correspondence, { baseOid: review.head, headOid: revision2 }) : void 0;
+  const evidence = artifact ? correspondenceEvidence(artifact, ["Explicitly supplied correspondence artifact"]) : void 0;
+  const beforePaths = [...review.links.map((l) => l.ref.path), ...evidence?.pairs.map((p) => p.before.path) ?? []];
+  const afterPaths = [...review.links.map((l) => l.ref.path), ...evidence?.pairs.map((p) => p.after.path) ?? []];
+  return refresh(
+    review,
+    readSnapshot(root, review.repository, review.head, beforePaths),
+    readSnapshot(root, review.repository, revision2, afterPaths),
+    evidence,
+    requirements
+  );
+}
+function writeReview(file, review) {
+  (0, import_fs2.writeFileSync)((0, import_path.resolve)(file), JSON.stringify(parseReview(review), null, 2) + "\n", { flag: "wx" });
+}
+function sourceText(root, ref) {
+  const file = readPinnedFile(root, ref.revision, ref.path);
+  if (!file || (0, import_source_references2.resolveSourceRef)(ref, { revision: ref.revision, files: { [ref.path]: file.text } }).status !== "valid") throw new Error("Pinned evidence no longer validates");
+  return file.text;
+}
+function lineReference(root, revision2, file, start, end) {
+  const source = readPinnedFile(root, revision2, file);
+  if (!source || !Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 1 || end < start) throw new Error("Invalid line anchor");
+  const offsets = [0];
+  for (let i = 0; i < source.text.length; i++) if (source.text[i] === "\n" && i + 1 < source.text.length) offsets.push(i + 1);
+  if (end > offsets.length) throw new Error("Line anchor exceeds pinned file");
+  return (0, import_source_references2.pinSourceRef)({ revision: revision2, files: { [file]: source.text } }, file, offsets[start - 1], offsets[end] ?? source.text.length);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  commitOid,
+  comparisonPaths,
+  git,
+  inspectWorkspace,
+  lineReference,
+  loadReview,
+  readEvidenceJson,
+  readPinnedFile,
+  readSnapshot,
+  refreshWorkspace,
+  repositoryRoot,
+  sourceText,
+  writeReview
+});
+//# sourceMappingURL=reviewWorkspace.js.map