overleaf-review 0.5.0 → 0.6.0

package/dist/reviewed-replace-A7C4UNJS.js

@@ -0,0 +1,431 @@
+import {
+  BASE_STATE_PATH,
+  MAX_TRACKED_RANGES,
+  RestRequestError,
+  acquireMutationLock,
+  applyOps,
+  applyOtUpdateAndWait,
+  beginReceipt,
+  bindExplicitEdits,
+  buildRejectionPlan,
+  checkedSnapshot,
+  config,
+  createTrackedChangeSeed,
+  fingerprintRanges,
+  getAuthenticatedUserId,
+  getCsrfToken,
+  getThreads,
+  loadBaseState,
+  matchDocument,
+  mergeBaseDocuments,
+  openProject,
+  overleafSnapshotHash,
+  parseReplacementManifest,
+  postThreadMessageDetailed,
+  readConsolidationSnapshot,
+  readReceipts,
+  sha256,
+  stableJson,
+  synchronizeLocalAfterRemote,
+  threadMessageId,
+  threadMessages,
+  updateReceipt,
+  workspaceReadPath,
+  workspaceRelativePath,
+  workspaceWritePath,
+  writeJsonAtomic
+} from "./chunk-TWIDV42A.js";
+
+// src/commands/reviewed-replace.ts
+import { readFileSync } from "fs";
+
+// src/lib/reviewed-rewrite.ts
+var REVIEWED_REWRITE_KIND = "overleaf-review-reviewed-rewrite-plan";
+function locateAnchor(text, anchor, occurrence) {
+  if (typeof anchor !== "string" || !anchor.length || occurrence !== void 0 && (!Number.isSafeInteger(occurrence) || occurrence < 1)) {
+    throw new Error("Comment anchorAfter must be nonempty, with an optional positive occurrence.");
+  }
+  const matches = [];
+  for (let p = text.indexOf(anchor); p !== -1; p = text.indexOf(anchor, p + 1)) matches.push(p);
+  if (!matches.length || matches.length > 1 && occurrence === void 0 || matches[(occurrence ?? 1) - 1] === void 0) {
+    throw new Error("Comment anchorAfter is absent or ambiguous in the revised block; specify occurrence.");
+  }
+  return matches[(occurrence ?? 1) - 1];
+}
+var canonical = (ranges) => stableJson(ranges.map((range) => stableJson(range)).sort());
+function planReviewedRewrite(value, authorId, input) {
+  const backup = structuredClone(checkedSnapshot(value));
+  if (typeof authorId !== "string" || !authorId || !Array.isArray(input) || !input.length) {
+    throw new Error("Reviewed rewrite requires an authenticated author and explicit blocks.");
+  }
+  const blocks = structuredClone(input);
+  const selected = /* @__PURE__ */ new Set();
+  const movedThreads = /* @__PURE__ */ new Set();
+  let end = -1;
+  for (const block of blocks) {
+    if (!block || !Number.isSafeInteger(block.start) || !Number.isSafeInteger(block.end) || block.start <= end || block.start < 0 || block.end <= block.start || block.end > backup.text.length || typeof block.text !== "string" || typeof block.reason !== "string" || !block.reason.trim() || !Array.isArray(block.supersedes) || !Array.isArray(block.comments)) {
+      throw new Error("Reviewed blocks require separated valid spans, after text, a reason, supersedes and comments arrays.");
+    }
+    end = block.end;
+    const touches = (p, length) => p <= block.end && p + length >= block.start;
+    const contained = (p, length) => p >= block.start && p + length <= block.end;
+    for (const id of block.supersedes) {
+      if (typeof id !== "string" || selected.has(id)) throw new Error("Superseded IDs must be unique across the plan.");
+      const fragments = backup.ranges.changes.filter((range) => range.id === id);
+      if (!fragments.length || fragments.some((range) => !contained(range.op.p, range.op.i?.length ?? 0))) {
+        throw new Error(`Suggestion ${id} is absent or has fragments outside its approved block.`);
+      }
+      selected.add(id);
+    }
+    const unapproved = backup.ranges.changes.filter((range) => touches(range.op.p, range.op.i?.length ?? 0) && !block.supersedes.includes(range.id));
+    if (unapproved.length) throw new Error(`Unapproved suggestion IDs touching the block: ${[...new Set(unapproved.map((range) => range.id))].join(", ")}. Inspect and include their IDs or narrow the block.`);
+    for (const comment of block.comments) {
+      if (!comment || typeof comment.thread !== "string" || movedThreads.has(comment.thread) || comment.reply !== void 0 && (typeof comment.reply !== "string" || !comment.reply.trim())) {
+        throw new Error("Comment mappings require unique thread IDs and nonempty optional replies.");
+      }
+      const ranges = backup.ranges.comments.filter((range) => range.op?.t === comment.thread);
+      if (ranges.length !== 1 || !contained(ranges[0].op.p, ranges[0].op.c.length) || !backup.threads[comment.thread]) {
+        throw new Error(`Thread ${comment.thread} is absent, duplicated, or extends outside its approved block.`);
+      }
+      locateAnchor(block.text, comment.anchorAfter, comment.occurrence);
+      movedThreads.add(comment.thread);
+    }
+    const unapprovedComments = backup.ranges.comments.filter((range) => touches(range.op.p, range.op.c.length) && !block.comments.some((comment) => comment.thread === range.op.t));
+    if (unapprovedComments.length) throw new Error(`Unapproved comment threads touching the block: ${unapprovedComments.map((range) => range.op.t).join(", ")}. Specify their new anchors.`);
+  }
+  const selectedIds = [...selected];
+  const undo = buildRejectionPlan(backup.text, backup.ranges.changes, selectedIds);
+  const selectedRanges = backup.ranges.changes.filter((range) => selected.has(range.id));
+  const deltaFor = (ranges) => ranges.reduce((sum, range) => sum + (range.op.d?.length ?? 0) - (range.op.i?.length ?? 0), 0);
+  let baselineOffset = 0;
+  let finalOffset = 0;
+  const expectedNewOps = [];
+  const anchorOps = [];
+  const decisions = blocks.map((block) => {
+    const ranges = selectedRanges.filter((range) => block.supersedes.includes(range.id));
+    const baselineStart = block.start + baselineOffset;
+    const baselineLength = block.end - block.start + deltaFor(ranges);
+    const baseline = undo.expectedText.slice(baselineStart, baselineStart + baselineLength);
+    if (baseline === block.text) throw new Error("The revised block equals its underlying text; reject the old suggestions instead of creating an empty revision.");
+    const finalStart = block.start + finalOffset;
+    if (block.text) expectedNewOps.push({ p: finalStart, i: block.text });
+    if (baseline) expectedNewOps.push({ p: finalStart + block.text.length, d: baseline });
+    for (const comment of block.comments) {
+      anchorOps.push({ p: finalStart + locateAnchor(block.text, comment.anchorAfter, comment.occurrence), c: comment.anchorAfter, t: comment.thread });
+    }
+    baselineOffset += deltaFor(ranges);
+    finalOffset += block.text.length - (block.end - block.start);
+    return { ...block, before: backup.text.slice(block.start, block.end), baseline, baselineStart, finalStart, supersededRanges: ranges };
+  });
+  const replace = [];
+  for (const block of [...decisions].reverse()) {
+    if (block.baseline) replace.push({ p: block.baselineStart, d: block.baseline });
+    if (block.text) replace.push({ p: block.baselineStart, i: block.text });
+  }
+  const expectedText = applyOps(undo.expectedText, replace);
+  let directText = backup.text;
+  for (const block of [...blocks].reverse()) directText = directText.slice(0, block.start) + block.text + directText.slice(block.end);
+  if (expectedText !== directText) throw new Error("Rewrite does not reconstruct the exact approved text.");
+  const shiftOutside = (p) => p + blocks.filter((block) => block.end < p).reduce((sum, block) => sum + block.text.length - (block.end - block.start), 0);
+  const expectedUnselected = backup.ranges.changes.filter((range) => !selected.has(range.id)).map((range) => ({ ...range, op: { ...range.op, p: shiftOutside(range.op.p) } }));
+  const expectedComments = backup.ranges.comments.map((range) => {
+    const moved = anchorOps.find((op) => op.t === range.op.t);
+    return { ...range, op: { ...range.op, p: moved ? moved.p : shiftOutside(range.op.p), ...moved ? { c: moved.c } : {} } };
+  });
+  const virtualRanges = expectedNewOps.map((op, index) => ({ id: `new-${index}`, op }));
+  if (buildRejectionPlan(expectedText, virtualRanges, virtualRanges.map((range) => range.id)).expectedText !== undo.expectedText) {
+    throw new Error("Rewrite does not preserve its rejection baseline.");
+  }
+  const projectedCount = expectedUnselected.length + expectedNewOps.length;
+  if (projectedCount > MAX_TRACKED_RANGES) throw new Error(`Rewrite exceeds the ${MAX_TRACKED_RANGES}-range budget.`);
+  return {
+    kind: REVIEWED_REWRITE_KIND,
+    schemaVersion: 1,
+    authorId,
+    backup,
+    blocks,
+    selectedIds,
+    decisions,
+    ops: [...undo.operations, ...replace, ...anchorOps],
+    expectedText,
+    rejectionText: undo.expectedText,
+    allRejectedText: buildRejectionPlan(backup.text, backup.ranges.changes, backup.ranges.changes.map((range) => range.id)).expectedText,
+    expectedNewOps,
+    expectedUnselected,
+    expectedComments,
+    projectedCount,
+    replies: blocks.flatMap((block) => block.comments.filter((comment) => comment.reply !== void 0).map((comment) => ({ thread: comment.thread, message: comment.reply })))
+  };
+}
+function validateReviewedRewrite(value) {
+  const plan = value;
+  if (!plan || plan.kind !== REVIEWED_REWRITE_KIND || plan.schemaVersion !== 1) throw new Error("Unsupported reviewed-rewrite plan.");
+  const derived = planReviewedRewrite(plan.backup, plan.authorId, plan.blocks);
+  if (stableJson(plan) !== stableJson(derived)) throw new Error("Reviewed-rewrite plan was altered or cannot be reproduced.");
+  return plan;
+}
+function verifyReviewedRewrite(plan, value, seed) {
+  const after = checkedSnapshot(value);
+  if (!/^[0-9a-f]{18}$/.test(seed) || after.projectId !== plan.backup.projectId || after.docId !== plan.backup.docId || after.docPath !== plan.backup.docPath || after.version !== plan.backup.version + 1 || after.text !== plan.expectedText) {
+    throw new Error("Rewritten document identity, version or text failed verification.");
+  }
+  const originalIds = new Set(plan.expectedUnselected.map((range) => range.id));
+  const fresh = after.ranges.changes.filter((range) => !originalIds.has(range.id));
+  if (after.ranges.changes.some((range) => plan.selectedIds.includes(range.id)) || fresh.some((range) => !new RegExp(`^${seed}[0-9a-f]{6}$`).test(range.id) || range.metadata?.user_id !== plan.authorId) || canonical(fresh.map((range) => range.op)) !== canonical(plan.expectedNewOps) || canonical(after.ranges.changes.filter((range) => originalIds.has(range.id))) !== canonical(plan.expectedUnselected) || canonical(after.ranges.comments) !== canonical(plan.expectedComments) || stableJson(after.threads) !== stableJson(plan.backup.threads)) {
+    throw new Error("Rewritten ranges, author attribution, comment anchors or threads failed verification.");
+  }
+  if (buildRejectionPlan(after.text, after.ranges.changes, fresh.map((range) => range.id)).expectedText !== plan.rejectionText || buildRejectionPlan(after.text, after.ranges.changes, after.ranges.changes.map((range) => range.id)).expectedText !== plan.allRejectedText) {
+    throw new Error("Rewrite changed the intended rejection baseline.");
+  }
+}
+
+// src/lib/reviewed-submit.ts
+function checkOriginalThreads(plan, threads) {
+  for (const [id, original] of Object.entries(plan.backup.threads)) {
+    const before = original;
+    const after = threads[id];
+    if (!after || stableJson({ ...before, messages: void 0 }) !== stableJson({ ...after, messages: void 0 })) {
+      throw new Error(`Thread ${id} state changed since rewriting; review it before posting replies.`);
+    }
+    for (const message of threadMessages(before)) {
+      if (!threadMessages(after).some((candidate) => stableJson(candidate) === stableJson(message))) {
+        throw new Error(`An existing message in thread ${id} changed or disappeared.`);
+      }
+    }
+  }
+}
+function recoverMessage(reply, thread, authorId) {
+  const oldIds = new Set(threadMessages(reply.beforeThread).map(threadMessageId));
+  const matches = threadMessages(thread).filter((message) => {
+    const id = threadMessageId(message);
+    const user = message.user;
+    const author = message.user_id ?? user?.id ?? user?._id;
+    return id && !oldIds.has(id) && message.content === reply.message && (reply.messageId ? id === reply.messageId : author === authorId);
+  });
+  return matches.length === 1 ? threadMessageId(matches[0]) : void 0;
+}
+async function submitReviewedRewrite(value, transport) {
+  const plan = validateReviewedRewrite(value);
+  const planHash = sha256(stableJson(plan));
+  const history = readReceipts(transport.receiptsDir).filter((handle) => handle.receipt.operation === "reviewed-rewrite" && handle.receipt.details.projectId === plan.backup.projectId && handle.receipt.details.docId === plan.backup.docId);
+  const uncertain = history.find((handle) => handle.receipt.details.textStatus === "sending");
+  if (uncertain) throw new Error(`An earlier text update has an uncertain outcome: ${uncertain.path}. No automatic retry.`);
+  const prior = history.find((handle) => handle.receipt.details.planHash === planHash && (handle.receipt.details.textStatus === "verified" || handle.receipt.status === "succeeded"));
+  if (prior?.receipt.status === "succeeded") return { receiptPath: prior.path, alreadyApplied: true };
+  let receipt = prior ?? beginReceipt("reviewed-rewrite", {
+    projectId: plan.backup.projectId,
+    docId: plan.backup.docId,
+    planHash,
+    plan,
+    textStatus: "pending",
+    replies: plan.replies.map((reply) => ({ ...reply, status: "pending" }))
+  }, { receiptsDir: transport.receiptsDir });
+  let textStatus = String(receipt.receipt.details.textStatus);
+  const replies = structuredClone(receipt.receipt.details.replies);
+  let seed = receipt.receipt.details.seed;
+  try {
+    if (await transport.accountId() !== plan.authorId) throw new Error("Authenticated account differs from the approved new revision author.");
+    if (textStatus !== "verified") {
+      const before = await transport.snapshot();
+      if (stableJson(before) !== stableJson(plan.backup)) throw new Error("Document or review state changed after planning; re-plan.");
+      seed = createTrackedChangeSeed();
+      if (before.ranges.changes.some((range) => range.id.startsWith(seed))) throw new Error("Tracked seed collision.");
+      const update = {
+        doc: before.docId,
+        v: before.version,
+        op: plan.ops,
+        meta: { tc: seed },
+        hash: overleafSnapshotHash(plan.expectedText)
+      };
+      receipt = updateReceipt(receipt, "in_progress", { textStatus: "sending", seed, before, update });
+      textStatus = "sending";
+      await transport.send(update);
+      const after = await transport.snapshot();
+      receipt = updateReceipt(receipt, "in_progress", { after });
+      verifyReviewedRewrite(plan, after, seed);
+      receipt = updateReceipt(receipt, "in_progress", { textStatus: "verified" });
+      textStatus = "verified";
+    }
+    const live = await transport.snapshot();
+    verifyReviewedRewrite(plan, { ...live, threads: plan.backup.threads }, seed);
+    checkOriginalThreads(plan, live.threads);
+    await transport.syncLocal?.(live);
+    for (const reply of replies) {
+      let threads = await transport.threads();
+      checkOriginalThreads(plan, threads);
+      if (reply.status === "verified") {
+        if (!threadMessages(threads[reply.thread]).some((message) => threadMessageId(message) === reply.messageId && message.content === reply.message)) {
+          throw new Error("A previously verified reply is missing or edited; no automatic repost.");
+        }
+        continue;
+      }
+      if (reply.status === "sending") {
+        const recovered = recoverMessage(reply, threads[reply.thread], plan.authorId);
+        if (!recovered) throw new Error(`Reply in thread ${reply.thread} has an uncertain outcome; inspect the receipt before any retry.`);
+        reply.messageId = recovered;
+        reply.status = "verified";
+        receipt = updateReceipt(receipt, "in_progress", { replies });
+        continue;
+      }
+      const current = await transport.snapshot();
+      verifyReviewedRewrite(plan, { ...current, threads: plan.backup.threads }, seed);
+      checkOriginalThreads(plan, current.threads);
+      reply.beforeThread = current.threads[reply.thread];
+      reply.status = "sending";
+      receipt = updateReceipt(receipt, "in_progress", { replies });
+      try {
+        const result = await transport.postReply(reply.thread, reply.message);
+        reply.messageId = result.messageId;
+        receipt = updateReceipt(receipt, "in_progress", { replies });
+      } catch (error) {
+        if (error instanceof RestRequestError && error.status >= 400 && error.status < 500 && error.status !== 408) {
+          reply.status = "failed";
+          receipt = updateReceipt(receipt, "in_progress", { replies });
+        }
+        throw error;
+      }
+      threads = await transport.threads();
+      checkOriginalThreads(plan, threads);
+      const id = recoverMessage(reply, threads[reply.thread], plan.authorId);
+      if (!id) throw new Error(`Reply in thread ${reply.thread} was not verified; retry only to reconcile, not repost.`);
+      reply.messageId = id;
+      reply.status = "verified";
+      receipt = updateReceipt(receipt, "in_progress", { replies });
+    }
+    receipt = updateReceipt(receipt, "succeeded", { replies, phase: "complete" });
+    return { receiptPath: receipt.path, alreadyApplied: false };
+  } catch (error) {
+    const ambiguous = textStatus === "sending" || replies.some((reply) => reply.status === "sending");
+    receipt = updateReceipt(receipt, ambiguous ? "ambiguous" : "failed", {
+      textStatus,
+      replies,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw new Error(`${textStatus === "verified" ? "Manuscript verified; follow-up incomplete. " : ""}${error instanceof Error ? error.message : String(error)} Receipt: ${receipt.path}`, { cause: error });
+  }
+}
+
+// src/commands/reviewed-replace.ts
+var REVIEWED_FILE_KIND = "overleaf-review-reviewed-file-plan";
+function isReviewedManifest(value) {
+  const manifest = value;
+  return Array.isArray(manifest?.replacements) && manifest.replacements.some((block) => block && ["supersedes", "reason", "comments"].some((key) => Object.hasOwn(block, key)));
+}
+function resolveReviewedBlocks(base, local, live, value) {
+  const manifest = value;
+  if (!Array.isArray(manifest?.replacements) || !manifest.replacements.length) throw new Error("Reviewed manifest requires replacements.");
+  const resolved = manifest.replacements.map((block) => {
+    const [edit] = parseReplacementManifest(base, { replacements: [{ before: block.before, after: block.after, occurrence: block.occurrence }] });
+    return { ...edit, supersedes: block.supersedes ?? [], reason: block.reason, comments: block.comments ?? [] };
+  }).sort((a, b) => a.start - b.start);
+  const mapped = bindExplicitEdits(base, local, live, resolved, {}).explicitEdits;
+  return resolved.map((block, index) => ({ ...block, ...mapped[index] }));
+}
+async function createReviewedFilePlan(opts) {
+  if (!opts.edits || !opts.file || !opts.planOut || opts.direct || opts.unsafeNoBase || opts.allowOverlap || opts.plan) {
+    throw new Error("Reviewed overlaps require --file, --edits and --out/--plan-out, with a saved base. Broad overlap/direct overrides are not supported.");
+  }
+  const localPath = workspaceRelativePath(opts.file);
+  const manifest = JSON.parse(readFileSync(workspaceReadPath(opts.edits), "utf8"));
+  const localText = readFileSync(workspaceReadPath(localPath), "utf8");
+  const saved = loadBaseState(opts.basePath ?? BASE_STATE_PATH);
+  const lock = acquireMutationLock(config.projectId);
+  let opened;
+  try {
+    const authorId = await getAuthenticatedUserId();
+    opened = await openProject();
+    const doc = matchDocument(opts.docName ?? localPath, opened.docs);
+    if (!doc) throw new Error("Reviewed rewrite document not found.");
+    const base = saved?.projectId === config.projectId ? saved.documents[doc._id] : void 0;
+    if (!base) throw new Error("Fetch this document first to save its synchronization base.");
+    const snapshot = await readConsolidationSnapshot(opened, doc);
+    const blocks = resolveReviewedBlocks(base.text, localText, snapshot.text, manifest);
+    const rewrite = planReviewedRewrite(snapshot, authorId, blocks);
+    const plan = { kind: REVIEWED_FILE_KIND, schemaVersion: 1, localPath, baseText: base.text, localText, manifest, rewrite };
+    writeJsonAtomic(workspaceWritePath(opts.planOut), plan);
+    console.log(`Reviewed paragraph plan saved to ${opts.planOut}; nothing sent.`);
+    for (const block of rewrite.decisions) {
+      console.log(`
+Block [${block.start},${block.end}): ${block.reason}`);
+      console.log(`  Underlying: ${JSON.stringify(block.baseline)}
+  Current: ${JSON.stringify(block.before)}
+  Proposed: ${JSON.stringify(block.text)}`);
+      console.log(`  Supersedes: ${block.supersedes.join(", ") || "(none)"}; moves ${block.comments.length} comment anchor(s).`);
+    }
+    console.log(`Projected tracked ranges: ${snapshot.ranges.changes.length} \u2192 ${rewrite.projectedCount}; planned replies: ${rewrite.replies.length}.`);
+    console.log("Rejecting the new revision restores the underlying text, not the old suggestion cards. Submit only during a quiet editing window.");
+    return plan;
+  } finally {
+    try {
+      opened?.socket.close();
+    } finally {
+      lock.release();
+    }
+  }
+}
+function validateReviewedFilePlan(value) {
+  const plan = value;
+  if (!plan || plan.kind !== REVIEWED_FILE_KIND || plan.schemaVersion !== 1 || typeof plan.baseText !== "string" || typeof plan.localText !== "string" || workspaceRelativePath(plan.localPath) !== plan.localPath) throw new Error("Invalid reviewed-file plan.");
+  validateReviewedRewrite(plan.rewrite);
+  const blocks = resolveReviewedBlocks(plan.baseText, plan.localText, plan.rewrite.backup.text, plan.manifest);
+  if (stableJson(blocks) !== stableJson(plan.rewrite.blocks)) throw new Error("Reviewed blocks do not match the saved Base\u2192Local intent.");
+  return plan;
+}
+async function applyReviewedFilePlan(value, opts) {
+  if (opts.direct || opts.allowOverlap || opts.unsafeNoBase || opts.allowAmbiguousRetry || opts.dryRun || opts.edits || opts.file || opts.docName || opts.planOut) {
+    throw new Error("Reviewed submission accepts only its saved plan; overrides and ambiguous replay are not allowed.");
+  }
+  const plan = validateReviewedFilePlan(value);
+  if (config.projectId !== plan.rewrite.backup.projectId) throw new Error("Reviewed plan belongs to another project.");
+  const basePath = opts.basePath ?? BASE_STATE_PATH;
+  const lock = acquireMutationLock(config.projectId);
+  let opened;
+  try {
+    const local = readFileSync(workspaceReadPath(plan.localPath), "utf8");
+    const base = loadBaseState(basePath);
+    const baseText = base?.projectId === config.projectId ? base.documents[plan.rewrite.backup.docId]?.text : void 0;
+    if (![plan.localText, plan.rewrite.expectedText].includes(local) || baseText !== plan.baseText && baseText !== plan.rewrite.expectedText) {
+      throw new Error("Local file or synchronization base changed after planning.");
+    }
+    opened = await openProject();
+    const project = opened;
+    const doc = project.docs.find((doc2) => doc2._id === plan.rewrite.backup.docId && doc2.path === plan.rewrite.backup.docPath);
+    if (!doc) throw new Error("Reviewed document is absent or renamed.");
+    const result = await submitReviewedRewrite(plan.rewrite, {
+      receiptsDir: opts.receiptsDir,
+      accountId: getAuthenticatedUserId,
+      threads: getThreads,
+      snapshot: () => readConsolidationSnapshot(project, doc),
+      send: (update) => applyOtUpdateAndWait(project.socket, doc._id, update),
+      postReply: async (thread, message) => postThreadMessageDetailed(thread, message, await getCsrfToken()),
+      syncLocal: async (after) => {
+        synchronizeLocalAfterRemote(plan.localPath, sha256(plan.localText), after.text);
+        mergeBaseDocuments(config.projectId, [{
+          docId: doc._id,
+          path: doc.path,
+          text: after.text,
+          hash: sha256(after.text),
+          version: after.version,
+          rangeFingerprint: fingerprintRanges(after.ranges),
+          fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }], basePath);
+      }
+    });
+    console.log(result.alreadyApplied ? "This reviewed rewrite was already completed; nothing resent." : "Verified paragraph rewrite, comment anchors, and planned replies.");
+    console.log(`Audit receipt and full review backup: ${result.receiptPath}`);
+  } finally {
+    try {
+      opened?.socket.close();
+    } finally {
+      lock.release();
+    }
+  }
+}
+export {
+  REVIEWED_FILE_KIND,
+  applyReviewedFilePlan,
+  createReviewedFilePlan,
+  isReviewedManifest,
+  resolveReviewedBlocks,
+  validateReviewedFilePlan
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overleaf-review",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "The missing review layer for Overleaf's Git bridge — sync comments and tracked changes between Overleaf and your local repo.",
   "type": "module",
   "license": "MIT",
@@ -42,6 +42,8 @@
     "probe:track": "tsx src/probes/03-write-track-change.ts",
     "probe:consolidation-model": "tsx src/probes/04-consolidation-model.ts",
     "probe:review-live": "tsx src/probes/05-review-live.ts",
+    "probe:reviewed-model": "tsx src/probes/06-reviewed-model.ts",
+    "probe:reviewed-live": "tsx src/probes/07-reviewed-live.ts",
     "typecheck": "tsc --noEmit",
     "test": "tsx --test test/*.test.ts",
     "check": "npm run typecheck && npm test && npm run build"