farming-code 2.2.29 → 2.2.32

package/backend/review-session-router.cjs

@@ -0,0 +1,93 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var review_session_router_exports = {};
+__export(review_session_router_exports, {
+  createReviewSessionRouter: () => createReviewSessionRouter
+});
+module.exports = __toCommonJS(review_session_router_exports);
+var import_review_session_service = require("./review-session-service.cjs");
+const express = require("express");
+const expressFactory = express;
+function sendError(res, error) {
+  if (error instanceof import_review_session_service.ReviewSessionError) {
+    res.status(error.statusCode).json({ error: error.message });
+    return;
+  }
+  console.error("Review session API error:", error);
+  res.status(500).json({ error: "review session operation failed" });
+}
+function createReviewSessionRouter(service) {
+  const router = expressFactory.Router();
+  router.use(expressFactory.json({ limit: "16kb" }));
+  router.post("/", async (req, res) => {
+    try {
+      res.status(201).json(await service.create({
+        agentId: req.body?.agentId,
+        base: req.body?.base,
+        root: req.body?.root,
+        ...req.body?.modifiedWithinDays !== void 0 ? { modifiedWithinDays: req.body.modifiedWithinDays } : {},
+        ...req.body?.scope !== void 0 ? { scope: req.body.scope } : {},
+        ...req.body?.paths !== void 0 ? { paths: req.body.paths } : {}
+      }));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.post("/acp", async (req, res) => {
+    try {
+      res.status(201).json(await service.createFromAcp({
+        agentId: req.body?.agentId,
+        itemIds: req.body?.itemIds
+      }));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.post("/acp/preview", async (req, res) => {
+    try {
+      res.json(await service.previewFromAcp({
+        agentId: req.body?.agentId,
+        itemIds: req.body?.itemIds
+      }));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.get("/:reviewId", (req, res) => {
+    try {
+      res.json(service.get(req.params.reviewId));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.post("/:reviewId/revisions", async (req, res) => {
+    try {
+      const result = await service.refresh(req.params.reviewId);
+      res.status(result.unchanged ? 200 : 201).json(result);
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  return router;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createReviewSessionRouter
+});

package/backend/review-session-service.cjs

@@ -0,0 +1,470 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var review_session_service_exports = {};
+__export(review_session_service_exports, {
+  ReviewSessionError: () => ReviewSessionError,
+  ReviewSessionService: () => ReviewSessionService,
+  changedPathsFromNameStatus: () => changedPathsFromNameStatus,
+  normalizeCapturePaths: () => normalizeCapturePaths,
+  normalizeHistoricalReviewChanges: () => normalizeHistoricalReviewChanges
+});
+module.exports = __toCommonJS(review_session_service_exports);
+var import_review_session_store = require("./review-session-store.cjs");
+var import_review_diff_service = require("./review-diff-service.cjs");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { createTwoFilesPatch, diffLines } = require("diff");
+const MAX_CAPTURE_FILES = 2e3;
+const MAX_CAPTURE_PATHS = 256;
+const MAX_HISTORICAL_REVIEW_CHARS = 32 * 1024 * 1024;
+const MAX_HISTORICAL_PREVIEW_CHARS = 64 * 1024;
+class ReviewSessionError extends Error {
+  statusCode;
+  constructor(message, statusCode = 400) {
+    super(message);
+    this.name = "ReviewSessionError";
+    this.statusCode = statusCode;
+  }
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function errorField(error, field) {
+  return isObject(error) ? error[field] : void 0;
+}
+function changedPathsFromNameStatus(value) {
+  const tokens = String(value || "").split("\0");
+  const paths = [];
+  for (let index = 0; index < tokens.length; ) {
+    const status = tokens[index++];
+    if (!status) continue;
+    const firstPath = tokens[index++];
+    if (firstPath) paths.push(firstPath);
+    if (status.startsWith("R") || status.startsWith("C")) {
+      const secondPath = tokens[index++];
+      if (secondPath) paths.push(secondPath);
+    }
+  }
+  return [...new Set(paths)];
+}
+function normalizeCapturePaths(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.length > MAX_CAPTURE_PATHS) {
+    throw new ReviewSessionError("review file paths are invalid");
+  }
+  if (value.some((candidate) => typeof candidate !== "string")) {
+    throw new ReviewSessionError("review file paths are invalid");
+  }
+  const paths = value.filter((candidate) => typeof candidate === "string").map((candidate) => candidate.replace(/\\/g, "/").trim());
+  if (paths.some((candidate) => !candidate || candidate.length > 4096 || candidate.startsWith("/") || candidate.includes("\0") || candidate.split("/").some((segment) => !segment || segment === "." || segment === ".."))) {
+    throw new ReviewSessionError("review file paths are invalid");
+  }
+  return [...new Set(paths)];
+}
+function historicalSidePresence(kind) {
+  const normalized = String(kind || "").trim().toLowerCase();
+  return {
+    base: !["add", "added", "create", "created"].includes(normalized),
+    head: !["delete", "deleted", "remove", "removed"].includes(normalized)
+  };
+}
+function workspaceRelativeReviewPath(root, candidate) {
+  if (typeof candidate !== "string" || !candidate.trim()) return "";
+  const raw = candidate.trim();
+  const normalized = raw.replace(/\\/g, "/");
+  let workspaceRoot = root;
+  try {
+    workspaceRoot = fs.realpathSync.native(root);
+  } catch {
+  }
+  let absolute = path.isAbsolute(raw) ? path.resolve(raw) : path.resolve(workspaceRoot, normalized);
+  const missingSegments = [];
+  let existing = absolute;
+  while (!fs.existsSync(existing) && path.dirname(existing) !== existing) {
+    missingSegments.unshift(path.basename(existing));
+    existing = path.dirname(existing);
+  }
+  try {
+    absolute = path.join(fs.realpathSync.native(existing), ...missingSegments);
+  } catch {
+  }
+  const relative = path.relative(workspaceRoot, absolute).replace(/\\/g, "/");
+  if (relative.split("/").includes(".git")) return "";
+  try {
+    return normalizeCapturePaths([relative])?.[0] || "";
+  } catch {
+    return "";
+  }
+}
+function normalizeHistoricalReviewChanges(root, value, workspaceRoot = root) {
+  if (!Array.isArray(value)) throw new ReviewSessionError("ACP review changes are invalid");
+  const changesByPath = /* @__PURE__ */ new Map();
+  let totalChars = 0;
+  for (const rawChange of value) {
+    if (!isObject(rawChange)) continue;
+    const displayPath = workspaceRelativeReviewPath(workspaceRoot, rawChange.path);
+    if (!displayPath) continue;
+    const absolutePath = path.resolve(workspaceRoot, displayPath);
+    const reviewPath = workspaceRelativeReviewPath(root, absolutePath);
+    if (!reviewPath) continue;
+    const oldText = rawChange.oldText == null ? "" : String(rawChange.oldText);
+    const newText = rawChange.newText == null ? "" : String(rawChange.newText);
+    totalChars += Buffer.byteLength(oldText, "utf8") + Buffer.byteLength(newText, "utf8");
+    if (totalChars > MAX_HISTORICAL_REVIEW_CHARS) {
+      throw new ReviewSessionError("ACP review content is too large", 413);
+    }
+    const presence = historicalSidePresence(rawChange.kind);
+    const current = changesByPath.get(reviewPath);
+    if (!current) {
+      changesByPath.set(reviewPath, {
+        basePresent: presence.base,
+        headPresent: presence.head,
+        newText,
+        oldText,
+        path: reviewPath,
+        ...displayPath !== reviewPath ? { displayPath } : {}
+      });
+      continue;
+    }
+    current.headPresent = presence.head;
+    current.newText = newText;
+  }
+  const changes = [...changesByPath.values()];
+  if (changes.length === 0) throw new ReviewSessionError("ACP review has no files inside this workspace");
+  if (changes.length > MAX_CAPTURE_PATHS) throw new ReviewSessionError("ACP review has too many files", 413);
+  return changes;
+}
+function historicalPreviewChange(change) {
+  const oldText = change.basePresent ? change.oldText : "";
+  const newText = change.headPresent ? change.newText : "";
+  const stats = diffLines(oldText, newText).reduce((result, part) => {
+    const count = Number(part.count || 0);
+    if (part.added) result.added += count;
+    if (part.removed) result.removed += count;
+    return result;
+  }, { added: 0, removed: 0 });
+  const patch = createTwoFilesPatch(change.path, change.path, oldText, newText, "before", "after", { context: 3 });
+  return {
+    ...stats,
+    diff: patch.length <= MAX_HISTORICAL_PREVIEW_CHARS ? patch : `${patch.slice(0, MAX_HISTORICAL_PREVIEW_CHARS)}
+
+[Diff detail truncated]`,
+    kind: !change.basePresent ? "added" : !change.headPresent ? "deleted" : "updated",
+    path: change.displayPath || change.path
+  };
+}
+function publicRevision(session, revision) {
+  const previous = revision.previousTree;
+  return {
+    base: session.base,
+    createdAt: revision.createdAt,
+    fixesBase: previous || session.base,
+    head: revision.tree,
+    number: revision.number,
+    reviewId: session.id,
+    root: session.root,
+    ...session.scope ? { scope: session.scope } : {},
+    ...session.modifiedWithinDays ? { modifiedWithinDays: session.modifiedWithinDays } : {},
+    ...session.paths ? { paths: session.paths } : {}
+  };
+}
+class ReviewSessionService {
+  fileService;
+  sessionStore;
+  reviewStateStore;
+  resolveAgentRoot;
+  resolveAcpReviewChanges;
+  refreshQueues;
+  constructor(fileService, sessionStore, reviewStateStore, options = {}) {
+    this.fileService = fileService;
+    this.sessionStore = sessionStore;
+    this.reviewStateStore = reviewStateStore;
+    this.resolveAgentRoot = options.resolveAgentRoot;
+    this.resolveAcpReviewChanges = options.resolveAcpReviewChanges;
+    this.refreshQueues = /* @__PURE__ */ new Map();
+  }
+  enqueueRefresh(reviewId, operation) {
+    const previous = this.refreshQueues.get(reviewId) || Promise.resolve();
+    const next = previous.catch(() => {
+    }).then(operation);
+    this.refreshQueues.set(reviewId, next);
+    const cleanup = () => {
+      if (this.refreshQueues.get(reviewId) === next) this.refreshQueues.delete(reviewId);
+    };
+    next.then(cleanup, cleanup);
+    return next;
+  }
+  async git(root, args, options = {}) {
+    try {
+      return await this.fileService.execFile(this.fileService.gitPath, ["-C", root, ...args], {
+        cwd: root,
+        maxBuffer: this.fileService.diffMaxBuffer,
+        timeout: this.fileService.diffTimeoutMs,
+        ...options
+      });
+    } catch (error) {
+      if (errorField(error, "code") === "ETIMEDOUT") throw new ReviewSessionError("review capture timed out", 504);
+      throw new ReviewSessionError(String(
+        errorField(error, "stderr") || errorField(error, "message") || "git review capture failed"
+      ).trim(), 400);
+    }
+  }
+  async resolveRoot(requestedRoot, agentId) {
+    if (requestedRoot && agentId) throw new ReviewSessionError("only one review workspace target is allowed");
+    let candidate = requestedRoot;
+    if (!candidate && typeof agentId === "string" && agentId.trim()) {
+      candidate = this.resolveAgentRoot?.(agentId.trim());
+      if (!candidate) throw new ReviewSessionError("review agent was not found", 404);
+    }
+    if (typeof candidate !== "string" || !candidate.trim()) {
+      throw new ReviewSessionError("review workspace target is required");
+    }
+    let root;
+    try {
+      root = fs.realpathSync.native(path.resolve(candidate));
+    } catch {
+      throw new ReviewSessionError("review root does not exist", 404);
+    }
+    const { stdout } = await this.git(root, ["rev-parse", "--show-toplevel"]);
+    try {
+      return fs.realpathSync.native(String(stdout).trim());
+    } catch {
+      throw new ReviewSessionError("review root is not a git repository");
+    }
+  }
+  async resolveBase(root, base) {
+    if (typeof base !== "string" || !base.trim() || base.trim().startsWith("-")) {
+      throw new ReviewSessionError("review base is required");
+    }
+    const { stdout } = await this.git(root, ["rev-parse", "--verify", `${base.trim()}^{commit}`]);
+    const resolved = String(stdout).trim();
+    if (!import_review_session_store.OBJECT_ID_PATTERN.test(resolved)) throw new ReviewSessionError("review base is invalid");
+    return resolved;
+  }
+  async captureTreeOnce(root, paths) {
+    const temporaryDir = fs.mkdtempSync(path.join(os.tmpdir(), "farming-review-capture-"));
+    const temporaryIndex = path.join(temporaryDir, "index");
+    const env = { ...process.env, GIT_INDEX_FILE: temporaryIndex };
+    try {
+      await this.git(root, ["read-tree", "HEAD"], { env });
+      if (paths === void 0) {
+        await this.git(root, ["add", "-A", "--", "."], { env });
+      } else if (paths.length > 0) {
+        await this.git(root, ["add", "-A", "--", ...paths], { env });
+      }
+      const { stdout } = await this.git(root, ["write-tree"], { env });
+      const tree = String(stdout).trim();
+      if (!import_review_session_store.OBJECT_ID_PATTERN.test(tree)) throw new ReviewSessionError("git did not produce a review tree", 500);
+      return tree;
+    } finally {
+      fs.rmSync(temporaryDir, { force: true, recursive: true });
+    }
+  }
+  async captureStableTree(root, paths) {
+    const first = await this.captureTreeOnce(root, paths);
+    const second = await this.captureTreeOnce(root, paths);
+    if (first !== second) {
+      throw new ReviewSessionError("workspace changed during review capture; try again when agent writes have settled", 409);
+    }
+    return first;
+  }
+  async writeHistoricalTree(root, changes, side, temporaryDir) {
+    const temporaryIndex = path.join(temporaryDir, `${side}.index`);
+    const contentFile = path.join(temporaryDir, `${side}.content`);
+    const env = { ...process.env, GIT_INDEX_FILE: temporaryIndex };
+    await this.git(root, ["read-tree", "--empty"], { env });
+    for (const change of changes) {
+      const present = side === "base" ? change.basePresent : change.headPresent;
+      if (!present) continue;
+      fs.writeFileSync(contentFile, side === "base" ? change.oldText : change.newText, "utf8");
+      const { stdout: blobOutput } = await this.git(root, ["hash-object", "-w", contentFile]);
+      const blob = String(blobOutput).trim();
+      if (!import_review_session_store.OBJECT_ID_PATTERN.test(blob)) throw new ReviewSessionError("git did not produce a review blob", 500);
+      await this.git(root, ["update-index", "--add", "--cacheinfo", "100644", blob, change.path], { env });
+    }
+    const { stdout } = await this.git(root, ["write-tree"], { env });
+    const tree = String(stdout).trim();
+    if (!import_review_session_store.OBJECT_ID_PATTERN.test(tree)) throw new ReviewSessionError("git did not produce a review tree", 500);
+    return tree;
+  }
+  async captureHistoricalTrees(root, changes) {
+    const temporaryDir = fs.mkdtempSync(path.join(os.tmpdir(), "farming-review-history-"));
+    try {
+      const base = await this.writeHistoricalTree(root, changes, "base", temporaryDir);
+      const head = await this.writeHistoricalTree(root, changes, "head", temporaryDir);
+      return { base, head };
+    } finally {
+      fs.rmSync(temporaryDir, { force: true, recursive: true });
+    }
+  }
+  async keepRevision(root, reviewId, number, tree) {
+    await this.git(root, ["update-ref", `refs/farming/reviews/${reviewId}/${number}`, tree]);
+  }
+  async changedPaths(root, base, head) {
+    const { stdout } = await this.git(root, ["diff", "--name-status", "-z", "--find-renames", base, head]);
+    return changedPathsFromNameStatus(stdout);
+  }
+  async capturePaths(root, options = {}) {
+    const requestedPaths = normalizeCapturePaths(options.paths);
+    if (requestedPaths !== void 0) return requestedPaths;
+    const scope = (0, import_review_diff_service.normalizeWorkingCopyScope)(options.scope);
+    if (!scope) return void 0;
+    const changes = await this.fileService.changes(root, { limit: MAX_CAPTURE_FILES });
+    if (changes.truncated) throw new ReviewSessionError("too many workspace files to capture this review", 413);
+    const selected = (0, import_review_diff_service.filterWorkingCopyChangeItems)(root, changes.items, {
+      scope,
+      modifiedWithinDays: options.modifiedWithinDays
+    });
+    return [...new Set(selected.flatMap((change) => [change.previousPath, change.path]).filter((candidate) => typeof candidate === "string" && candidate.length > 0))];
+  }
+  async create({
+    root: requestedRoot,
+    agentId,
+    base = "HEAD",
+    scope: requestedScope,
+    modifiedWithinDays: requestedDays,
+    paths: requestedPaths
+  }) {
+    const root = await this.resolveRoot(requestedRoot, agentId);
+    const resolvedBase = await this.resolveBase(root, base);
+    const scope = (0, import_review_diff_service.normalizeWorkingCopyScope)(requestedScope);
+    const explicitPaths = normalizeCapturePaths(requestedPaths);
+    if (scope && explicitPaths !== void 0) throw new ReviewSessionError("review scope and file paths cannot be combined");
+    const modifiedWithinDays = scope === "untracked" ? (0, import_review_diff_service.normalizeModifiedWithinDays)(requestedDays) : void 0;
+    const paths = await this.capturePaths(root, { scope, modifiedWithinDays, paths: explicitPaths });
+    const tree = await this.captureStableTree(root, paths);
+    const reviewId = this.sessionStore.newId();
+    await this.keepRevision(root, reviewId, 1, tree);
+    const session = this.sessionStore.create({ base: resolvedBase, id: reviewId, root, tree, scope, modifiedWithinDays, paths: explicitPaths });
+    return publicRevision(session, session.revisions[0]);
+  }
+  async createFromAcp({ agentId, itemIds }) {
+    if (typeof this.resolveAcpReviewChanges !== "function") {
+      throw new ReviewSessionError("ACP review capture is unavailable", 501);
+    }
+    const { changes, root } = await this.resolveAcpChanges(agentId, itemIds);
+    const { base, head } = await this.captureHistoricalTrees(root, changes);
+    if (base === head) throw new ReviewSessionError("ACP review contains no effective file changes");
+    const reviewId = this.sessionStore.newId();
+    await this.git(root, ["update-ref", `refs/farming/reviews/${reviewId}/base`, base]);
+    await this.keepRevision(root, reviewId, 1, head);
+    const paths = changes.map((change) => change.path);
+    const session = this.sessionStore.create({ base, id: reviewId, root, tree: head, paths });
+    return publicRevision(session, session.revisions[0]);
+  }
+  async resolveAcpChanges(agentId, itemIds) {
+    const { rawChanges, workspaceRoot } = await this.resolveAcpPreviewChanges(agentId, itemIds);
+    const root = await this.resolveRoot(void 0, agentId);
+    const changes = normalizeHistoricalReviewChanges(root, rawChanges, workspaceRoot);
+    return { changes, root };
+  }
+  async resolveAcpPreviewChanges(agentId, itemIds) {
+    const requestedWorkspace = typeof agentId === "string" && agentId.trim() ? this.resolveAgentRoot?.(agentId.trim()) : "";
+    let workspaceRoot;
+    try {
+      workspaceRoot = requestedWorkspace ? fs.realpathSync.native(path.resolve(requestedWorkspace)) : "";
+    } catch {
+      throw new ReviewSessionError("review agent workspace does not exist", 404);
+    }
+    if (!workspaceRoot) throw new ReviewSessionError("review agent workspace does not exist", 404);
+    let rawChanges;
+    try {
+      const resolveAcpReviewChanges = this.resolveAcpReviewChanges;
+      if (!resolveAcpReviewChanges) throw new ReviewSessionError("ACP review capture is unavailable", 501);
+      rawChanges = await resolveAcpReviewChanges(agentId, itemIds);
+    } catch (error) {
+      const message = String(errorField(error, "message") || "ACP review changes could not be loaded");
+      const status = message === "Agent not found" || message === "ACP tool call not found" ? 404 : message.includes("invalid") ? 400 : 409;
+      throw new ReviewSessionError(message, status);
+    }
+    return { rawChanges, workspaceRoot };
+  }
+  async previewFromAcp({ agentId, itemIds }) {
+    const { rawChanges, workspaceRoot } = await this.resolveAcpPreviewChanges(agentId, itemIds);
+    const changes = normalizeHistoricalReviewChanges(workspaceRoot, rawChanges, workspaceRoot);
+    return { changes: changes.map(historicalPreviewChange) };
+  }
+  async refresh(reviewId) {
+    if (typeof reviewId !== "string" || !import_review_session_store.REVIEW_ID_PATTERN.test(reviewId)) {
+      throw new ReviewSessionError("review session id is invalid");
+    }
+    return this.enqueueRefresh(reviewId, async () => {
+      const current = this.sessionStore.get(reviewId);
+      if (!current) throw new ReviewSessionError("review session not found", 404);
+      const paths = await this.capturePaths(current.root, current);
+      const tree = await this.captureStableTree(current.root, paths);
+      const previous = current.revisions[current.revisions.length - 1];
+      if (previous.tree === tree) return { ...publicRevision(current, previous), changedPaths: [], unchanged: true };
+      const nextNumber = previous.number + 1;
+      const changedPaths = await this.changedPaths(current.root, previous.tree, tree);
+      await this.keepRevision(current.root, reviewId, nextNumber, tree);
+      const result = this.sessionStore.appendRevision(reviewId, tree);
+      const next = result.session.revisions[result.session.revisions.length - 1];
+      this.reviewStateStore?.inheritPatchset?.({
+        changedPaths,
+        nextPatchset: tree,
+        previousPatchset: previous.tree,
+        reviewId
+      });
+      return { ...publicRevision(result.session, next), changedPaths, unchanged: false };
+    });
+  }
+  get(reviewId) {
+    if (typeof reviewId !== "string" || !import_review_session_store.REVIEW_ID_PATTERN.test(reviewId)) {
+      throw new ReviewSessionError("review session id is invalid");
+    }
+    const session = this.sessionStore.get(reviewId);
+    if (!session) throw new ReviewSessionError("review session not found", 404);
+    const latest = session.revisions[session.revisions.length - 1];
+    return {
+      ...publicRevision(session, latest),
+      revisions: session.revisions.map((revision) => publicRevision(session, revision))
+    };
+  }
+  assertRange(reviewId, requestedRoot, base, head) {
+    if (!reviewId) return;
+    if (typeof reviewId !== "string" || !import_review_session_store.REVIEW_ID_PATTERN.test(reviewId)) {
+      throw new ReviewSessionError("review session id is invalid");
+    }
+    const session = this.sessionStore.get(reviewId);
+    if (!session) throw new ReviewSessionError("review session not found", 404);
+    let root;
+    try {
+      if (typeof requestedRoot !== "string") throw new TypeError("invalid root");
+      root = fs.realpathSync.native(path.resolve(requestedRoot));
+    } catch {
+      throw new ReviewSessionError("review root does not exist", 404);
+    }
+    const revisionTrees = session.revisions.map((revision) => revision.tree);
+    const validBase = typeof base === "string" && (base === session.base || revisionTrees.includes(base));
+    if (root !== session.root || !validBase || typeof head !== "string" || !revisionTrees.includes(head)) {
+      throw new ReviewSessionError("review range does not belong to this session", 409);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReviewSessionError,
+  ReviewSessionService,
+  changedPathsFromNameStatus,
+  normalizeCapturePaths,
+  normalizeHistoricalReviewChanges
+});