overleaf-review 0.4.0 → 0.6.0

package/dist/chunk-TWIDV42A.js

@@ -0,0 +1,2729 @@
+// src/config.ts
+import "dotenv/config";
+
+// src/lib/credentials.ts
+import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function configDir() {
+  return process.env.OVERLEAF_REVIEW_CONFIG_DIR ?? join(homedir(), ".config", "overleaf-review");
+}
+function credentialsPath() {
+  return join(configDir(), "credentials.json");
+}
+function loadCredentials() {
+  try {
+    return JSON.parse(readFileSync(credentialsPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveCredentials(creds) {
+  mkdirSync(configDir(), { recursive: true });
+  const path = credentialsPath();
+  writeFileSync(path, JSON.stringify({ ...creds, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n");
+  chmodSync(path, 384);
+  return path;
+}
+
+// src/lib/project-config.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, renameSync, unlinkSync } from "fs";
+import { join as join2 } from "path";
+var REPO_CONFIG_PATH = join2(".overleaf", "config.json");
+function loadProjectConfig() {
+  try {
+    return JSON.parse(readFileSync2(REPO_CONFIG_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveProjectConfig(cfg) {
+  mkdirSync2(".overleaf", { recursive: true });
+  const temp = `${REPO_CONFIG_PATH}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync2(temp, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
+    renameSync(temp, REPO_CONFIG_PATH);
+  } catch (error) {
+    try {
+      unlinkSync(temp);
+    } catch {
+    }
+    throw error;
+  }
+  return REPO_CONFIG_PATH;
+}
+
+// src/config.ts
+function resolveBaseUrl() {
+  return process.env.OVERLEAF_BASE_URL ?? loadProjectConfig().baseUrl ?? loadCredentials().baseUrl ?? "https://www.overleaf.com";
+}
+function resolveSession2() {
+  const value = process.env.OVERLEAF_SESSION2 || loadCredentials().session2;
+  if (!value) {
+    throw new Error("Not authenticated \u2014 run `overleaf-review login` (or set OVERLEAF_SESSION2).");
+  }
+  return value;
+}
+function resolveProjectId() {
+  const value = process.env.OVERLEAF_PROJECT_ID || loadProjectConfig().projectId;
+  if (!value) {
+    throw new Error(
+      "No project linked \u2014 run `overleaf-review link --project <id>` (or set OVERLEAF_PROJECT_ID)."
+    );
+  }
+  return value;
+}
+var config = {
+  get baseUrl() {
+    return resolveBaseUrl();
+  },
+  get session2() {
+    return resolveSession2();
+  },
+  get projectId() {
+    return resolveProjectId();
+  },
+  /** Cookie header value used for both HTTP and the websocket handshake. */
+  get cookie() {
+    return `overleaf_session2=${this.session2}`;
+  }
+};
+
+// src/overleaf-socket.ts
+import WebSocket from "ws";
+function utf8Decode(binary) {
+  return Buffer.from(binary, "latin1").toString("utf8");
+}
+var OverleafSocket = class {
+  constructor(baseUrl, cookie, opts = {}) {
+    this.baseUrl = baseUrl;
+    this.debug = opts.debug ?? true;
+    for (const part of cookie.split(";")) {
+      const eq = part.indexOf("=");
+      if (eq > 0) this.cookies.set(part.slice(0, eq).trim(), part.slice(eq + 1).trim());
+    }
+  }
+  baseUrl;
+  ws;
+  ackId = 1;
+  pendingAcks = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  heartbeat;
+  debug;
+  cookies = /* @__PURE__ */ new Map();
+  /** Browser-like headers — Overleaf's proxy can 502 non-browser upgrades. */
+  get browserHeaders() {
+    return {
+      Cookie: this.cookieHeader,
+      Origin: this.baseUrl,
+      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+    };
+  }
+  get cookieHeader() {
+    return [...this.cookies].map(([k, v]) => `${k}=${v}`).join("; ");
+  }
+  /** Merge Set-Cookie values — notably the GCLB load-balancer affinity cookie. */
+  absorbCookies(setCookies) {
+    for (const sc of setCookies) {
+      const pair = sc.split(";", 1)[0];
+      const eq = pair.indexOf("=");
+      if (eq > 0) this.cookies.set(pair.slice(0, eq).trim(), pair.slice(eq + 1).trim());
+    }
+  }
+  /** Subscribe to a server-pushed event (e.g. otUpdateApplied). */
+  on(event, handler) {
+    const list = this.handlers.get(event) ?? [];
+    list.push(handler);
+    this.handlers.set(event, list);
+    return () => this.off(event, handler);
+  }
+  /** Remove a previously registered server-pushed event handler. */
+  off(event, handler) {
+    const list = this.handlers.get(event);
+    if (!list) return;
+    const next = list.filter((candidate) => candidate !== handler);
+    if (next.length) this.handlers.set(event, next);
+    else this.handlers.delete(event);
+  }
+  async connect(projectId) {
+    const handshakeUrl = `${this.baseUrl}/socket.io/1/?projectId=${projectId}&t=${Date.now()}`;
+    const res = await fetch(handshakeUrl, { headers: this.browserHeaders });
+    const setCookies = res.headers.getSetCookie?.() ?? [];
+    this.absorbCookies(setCookies);
+    if (this.debug) console.log(`[socket] cookies now: ${[...this.cookies.keys()].join(", ")}`);
+    if (!res.ok) {
+      throw new Error(
+        `socket.io handshake failed: ${res.status} ${res.statusText}. Check the session cookie and that the account is logged in.`
+      );
+    }
+    const body = await res.text();
+    const [sid, hbTimeout, , transports] = body.split(":");
+    if (this.debug) console.log(`[socket] handshake ok: ${body}`);
+    const wsUrl = `${this.baseUrl.replace(/^http/, "ws")}/socket.io/1/websocket/${sid}`;
+    if (this.debug) console.log(`[socket] transports=${transports}; ws=${wsUrl}`);
+    this.ws = new WebSocket(wsUrl, { headers: this.browserHeaders });
+    await new Promise((resolve2, reject) => {
+      this.ws.once("open", () => resolve2());
+      this.ws.once("error", reject);
+      this.ws.once("unexpected-response", (_req, response) => {
+        let errBody = "";
+        response.on("data", (chunk) => errBody += chunk.toString());
+        response.on(
+          "end",
+          () => reject(
+            new Error(
+              `ws upgrade rejected: ${response.statusCode} ${response.statusMessage}
+  headers: ${JSON.stringify(response.headers)}
+  body: ${errBody.slice(0, 800)}`
+            )
+          )
+        );
+      });
+    });
+    this.ws.on("message", (data) => this.onFrame(utf8Decode(data.toString())));
+    const intervalMs = (Number(hbTimeout) || 30) * 800;
+    this.heartbeat = setInterval(() => this.send("2::"), intervalMs);
+    if (this.debug) console.log("[socket] websocket open");
+  }
+  /** Emit an event and resolve with the server's ack payload (array of args). */
+  emit(name, args, timeoutMs = 15e3) {
+    const id = this.ackId++;
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingAcks.delete(id);
+        reject(new Error(`emit('${name}') timed out after ${timeoutMs}ms with no ack`));
+      }, timeoutMs);
+      this.pendingAcks.set(id, (payload) => {
+        clearTimeout(timer);
+        resolve2(payload);
+      });
+      this.send(`5:${id}+::${JSON.stringify({ name, args })}`);
+    });
+  }
+  onFrame(frame) {
+    if (this.debug) console.log("[socket] <-", frame.slice(0, 200));
+    const type = frame[0];
+    const c1 = frame.indexOf(":");
+    const c2 = frame.indexOf(":", c1 + 1);
+    const c3 = frame.indexOf(":", c2 + 1);
+    const data = c3 === -1 ? "" : frame.slice(c3 + 1);
+    switch (type) {
+      case "2":
+        this.send("2::");
+        break;
+      case "5": {
+        try {
+          const { name, args } = JSON.parse(data);
+          for (const h of this.handlers.get(name) ?? []) h(args);
+        } catch {
+        }
+        break;
+      }
+      case "6": {
+        const plus = data.indexOf("+");
+        const ackId = Number(plus === -1 ? data : data.slice(0, plus));
+        const payload = plus === -1 ? [] : JSON.parse(data.slice(plus + 1));
+        this.pendingAcks.get(ackId)?.(payload);
+        this.pendingAcks.delete(ackId);
+        break;
+      }
+    }
+  }
+  send(frame) {
+    if (this.debug && !frame.startsWith("2")) console.log("[socket] ->", frame.slice(0, 200));
+    this.ws.send(frame);
+  }
+  close() {
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    this.ws?.close();
+  }
+};
+
+// src/lib/session.ts
+function collectDocs(rootFolder) {
+  const out = [];
+  const walk = (folders, prefix) => {
+    for (const f of folders ?? []) {
+      const dir = f.name && f.name !== "rootFolder" ? prefix ? `${prefix}/${f.name}` : f.name : prefix;
+      for (const d of f.docs ?? []) {
+        out.push({ _id: d._id, name: d.name, path: dir ? `${dir}/${d.name}` : d.name });
+      }
+      walk(f.folders ?? [], dir);
+    }
+  };
+  walk(rootFolder ?? [], "");
+  return out;
+}
+async function openProject(opts = {}) {
+  const socket = new OverleafSocket(config.baseUrl, config.cookie, { debug: opts.debug ?? false });
+  const pushed = new Promise((resolve2) => socket.on("joinProjectResponse", resolve2));
+  await socket.connect(config.projectId);
+  const first = await Promise.race([
+    pushed,
+    new Promise((r) => setTimeout(() => r(null), 6e3))
+  ]);
+  let publicId = "";
+  let project;
+  if (first) {
+    publicId = first[0]?.publicId ?? "";
+    project = first[0]?.project;
+  } else {
+    const r = await socket.emit("joinProject", [{ project_id: config.projectId }]);
+    project = r[1];
+  }
+  return { socket, publicId, project, docs: collectDocs(project?.rootFolder) };
+}
+async function joinDoc(socket, docId) {
+  const res = await socket.emit("joinDoc", [docId, { encodeRanges: true }]);
+  const [err, lines, version, , ranges] = res;
+  if (err) throw new Error(`joinDoc error: ${JSON.stringify(err)}`);
+  return { version, lines: lines ?? [], ranges: ranges ?? {} };
+}
+async function applyOtUpdateAndWait(socket, docId, update, timeoutMs = 3e4) {
+  let timer;
+  let stopApplied = () => {
+  };
+  let stopError = () => {
+  };
+  const applied = new Promise((resolve2, reject) => {
+    stopApplied = socket.on("otUpdateApplied", (args) => {
+      const event = args[0];
+      if (event?.doc === docId && Number.isSafeInteger(event.v) && event.v >= update.v && !Object.prototype.hasOwnProperty.call(event, "op")) {
+        resolve2();
+      }
+    });
+    stopError = socket.on("otUpdateError", (args) => {
+      const metadata = args[1];
+      if (metadata?.doc_id && metadata.doc_id !== docId) return;
+      reject(new Error(`Overleaf failed to apply the OT update: ${JSON.stringify(args)}`));
+    });
+    timer = setTimeout(
+      () => reject(new Error(`OT update for ${docId} was queued but not confirmed within ${timeoutMs}ms`)),
+      timeoutMs
+    );
+  });
+  void applied.catch(() => {
+  });
+  try {
+    const ack = await socket.emit("applyOtUpdate", [docId, update], timeoutMs);
+    if (ack?.[0]) throw new Error(`Overleaf rejected the OT update: ${JSON.stringify(ack[0])}`);
+    await applied;
+  } finally {
+    if (timer) clearTimeout(timer);
+    stopApplied();
+    stopError();
+  }
+}
+
+// src/lib/rest.ts
+var UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+function headers(extra = {}) {
+  return { Cookie: config.cookie, "User-Agent": UA, Origin: config.baseUrl, ...extra };
+}
+async function getCsrfToken() {
+  const res = await fetch(`${config.baseUrl}/project/${config.projectId}`, { headers: headers() });
+  const html = await res.text();
+  const m = html.match(/<meta\s+name="ol-csrfToken"\s+content="([^"]+)"/) ?? html.match(/"csrfToken"\s*:\s*"([^"]+)"/) ?? html.match(/csrfToken\s*[:=]\s*["']([^"']+)["']/);
+  if (!m) {
+    throw new Error(
+      `CSRF token not found (HTTP ${res.status}). If this is a login page, the session cookie is invalid/expired.`
+    );
+  }
+  return m[1];
+}
+async function getThreads() {
+  const res = await fetch(`${config.baseUrl}/project/${config.projectId}/threads`, {
+    headers: headers()
+  });
+  if (!res.ok) throw new Error(`getThreads ${res.status}: ${(await res.text()).slice(0, 200)}`);
+  return res.json();
+}
+var RestRequestError = class extends Error {
+  constructor(message, status, responseBody) {
+    super(message);
+    this.status = status;
+    this.responseBody = responseBody;
+    this.name = "RestRequestError";
+  }
+  status;
+  responseBody;
+};
+function threadMessages(thread) {
+  if (!thread || typeof thread !== "object") return [];
+  const messages = thread.messages;
+  return Array.isArray(messages) ? messages.filter((message) => Boolean(message && typeof message === "object")) : [];
+}
+function threadMessageId(message) {
+  const value = message?.id ?? message?._id;
+  return typeof value === "string" && value ? value : void 0;
+}
+function timestampMs(message) {
+  const raw = message.timestamp ?? message.createdAt ?? message.created_at;
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return raw < 1e11 ? raw * 1e3 : raw;
+  }
+  if (typeof raw === "string") {
+    const numeric = Number(raw);
+    if (Number.isFinite(numeric) && raw.trim()) {
+      return numeric < 1e11 ? numeric * 1e3 : numeric;
+    }
+    const parsed = Date.parse(raw);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return void 0;
+}
+function findRecentIdenticalMessage(thread, content, nowMs = Date.now(), windowMs = 5 * 60 * 1e3) {
+  const earliest = nowMs - Math.max(0, windowMs);
+  return threadMessages(thread).filter((message) => {
+    if (message.content !== content) return false;
+    const timestamp = timestampMs(message);
+    return timestamp !== void 0 && timestamp >= earliest && timestamp <= nowMs + 6e4;
+  }).sort((a, b) => (timestampMs(b) ?? 0) - (timestampMs(a) ?? 0))[0];
+}
+function findNewIdenticalMessage(beforeThread, afterThread, content, returnedMessageId) {
+  const after = threadMessages(afterThread);
+  if (returnedMessageId) {
+    return after.find(
+      (message) => threadMessageId(message) === returnedMessageId && message.content === content
+    );
+  }
+  const beforeIds = new Set(
+    threadMessages(beforeThread).map(threadMessageId).filter((id) => Boolean(id))
+  );
+  const candidates = [...after].reverse().filter((message) => {
+    if (message.content !== content) return false;
+    const id = threadMessageId(message);
+    return Boolean(id && !beforeIds.has(id));
+  });
+  return candidates.length === 1 ? candidates[0] : void 0;
+}
+function extractPostedMessageId(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const object = value;
+  for (const key of ["message_id", "messageId"]) {
+    if (typeof object[key] === "string" && object[key]) return object[key];
+  }
+  for (const key of ["message", "data"]) {
+    const nested = object[key];
+    if (nested && typeof nested === "object") {
+      const nestedId = threadMessageId(nested) ?? extractPostedMessageId(nested);
+      if (nestedId) return nestedId;
+    }
+  }
+  return threadMessageId(object);
+}
+async function observePostedThreadMessage(threadId, beforeThread, content, returnedMessageId, options = {}) {
+  const timeoutMs = Math.max(0, options.timeoutMs ?? 5e3);
+  const intervalMs = Math.max(10, options.intervalMs ?? 250);
+  const deadline = Date.now() + timeoutMs;
+  let attempts = 0;
+  let lastThread;
+  let lastError;
+  do {
+    attempts += 1;
+    try {
+      lastThread = (await getThreads())[threadId];
+      const message = findNewIdenticalMessage(
+        beforeThread,
+        lastThread,
+        content,
+        returnedMessageId
+      );
+      if (message) return { message, thread: lastThread, attempts };
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+    }
+    if (Date.now() >= deadline) break;
+    await new Promise((resolve2) => setTimeout(resolve2, Math.min(intervalMs, deadline - Date.now())));
+  } while (Date.now() <= deadline);
+  return {
+    thread: lastThread,
+    attempts,
+    ...lastError ? { lastError } : {}
+  };
+}
+async function postThreadMessageDetailed(threadId, content, csrf) {
+  const res = await fetch(
+    `${config.baseUrl}/project/${config.projectId}/thread/${threadId}/messages`,
+    {
+      method: "POST",
+      headers: headers({ "Content-Type": "application/json", "X-CSRF-Token": csrf }),
+      body: JSON.stringify({ content })
+    }
+  );
+  const rawBody = await res.text();
+  if (!res.ok) {
+    throw new RestRequestError(
+      `postThreadMessage ${res.status}: ${rawBody.slice(0, 300)}`,
+      res.status,
+      rawBody.slice(0, 1e3)
+    );
+  }
+  let responseBody;
+  if (rawBody) {
+    try {
+      responseBody = JSON.parse(rawBody);
+    } catch {
+      responseBody = rawBody.slice(0, 1e3);
+    }
+  }
+  return {
+    status: res.status,
+    messageId: extractPostedMessageId(responseBody),
+    ...responseBody === void 0 ? {} : { responseBody }
+  };
+}
+async function setThreadResolved(docId, threadId, reopen, csrf) {
+  const action = reopen ? "reopen" : "resolve";
+  const res = await fetch(
+    `${config.baseUrl}/project/${config.projectId}/doc/${docId}/thread/${threadId}/${action}`,
+    { method: "POST", headers: headers({ "X-CSRF-Token": csrf }) }
+  );
+  if (!res.ok) {
+    throw new Error(`${action} thread ${res.status}: ${(await res.text()).slice(0, 200)}`);
+  }
+  return res.status;
+}
+async function acceptChanges(docId, changeIds, csrf) {
+  const res = await fetch(
+    `${config.baseUrl}/project/${config.projectId}/doc/${docId}/changes/accept`,
+    {
+      method: "POST",
+      headers: headers({ "X-CSRF-Token": csrf, "Content-Type": "application/json" }),
+      body: JSON.stringify({ change_ids: changeIds })
+    }
+  );
+  if (!res.ok) throw new Error(`acceptChanges ${res.status}: ${(await res.text()).slice(0, 200)}`);
+  return res.status;
+}
+async function uploadFile(folderId, name, bytes, csrf) {
+  const form = new FormData();
+  form.append("qqfile", new Blob([new Uint8Array(bytes)]), name);
+  form.append("name", name);
+  form.append("relativePath", "null");
+  const res = await fetch(
+    `${config.baseUrl}/project/${config.projectId}/upload?folder_id=${folderId}`,
+    // Deliberately no Content-Type — fetch sets the multipart boundary itself.
+    { method: "POST", headers: headers({ "X-CSRF-Token": csrf }), body: form }
+  );
+  if (!res.ok) throw new Error(`upload ${res.status}: ${(await res.text()).slice(0, 200)}`);
+  return res.json();
+}
+async function deleteMessage(threadId, messageId, csrf) {
+  const res = await fetch(
+    `${config.baseUrl}/project/${config.projectId}/thread/${threadId}/messages/${messageId}`,
+    { method: "DELETE", headers: headers({ "X-CSRF-Token": csrf }) }
+  );
+  if (!res.ok) throw new Error(`deleteMessage ${res.status}: ${(await res.text()).slice(0, 200)}`);
+  return res.status;
+}
+async function deleteThread(docId, threadId, csrf) {
+  const res = await fetch(
+    `${config.baseUrl}/project/${config.projectId}/doc/${docId}/thread/${threadId}`,
+    { method: "DELETE", headers: headers({ "X-CSRF-Token": csrf }) }
+  );
+  if (!res.ok) throw new Error(`deleteThread ${res.status}: ${(await res.text()).slice(0, 200)}`);
+  return res.status;
+}
+async function validateSession(baseUrl, session2) {
+  const res = await fetch(`${baseUrl}/project`, {
+    headers: { Cookie: `overleaf_session2=${session2}`, "User-Agent": UA },
+    redirect: "follow"
+  });
+  const html = await res.text();
+  if (!res.ok) throw new Error(`Session validation failed (HTTP ${res.status}); log in again or check access.`);
+  const looksLikeLogin = res.url.includes("/login") || /name="ol-page"\s+content="login"/.test(html) || html.includes('id="loginForm"');
+  if (looksLikeLogin) {
+    throw new Error("Session cookie is invalid or expired (got the login page).");
+  }
+  const m = html.match(/name="ol-usersEmail"\s+content="([^"]+)"/) ?? html.match(/"email":"([^"@]+@[^"]+)"/);
+  return m ? m[1] : "your Overleaf account";
+}
+function accountIdFromSettings(html) {
+  const tag = html.match(/<meta\b[^>]*\bname=["']ol-user["'][^>]*>/i)?.[0];
+  const encoded = tag?.match(/\bcontent=(?:"([^"]*)"|'([^']*)')/i);
+  if (!encoded) throw new Error("Authenticated account ID not found; refusing author-sensitive mutation.");
+  const json = (encoded[1] ?? encoded[2]).replace(/&(?:quot|apos|amp|lt|gt|#\d+|#x[0-9a-f]+);/gi, (entity) => {
+    const named = { "&quot;": '"', "&apos;": "'", "&amp;": "&", "&lt;": "<", "&gt;": ">" };
+    if (named[entity.toLowerCase()]) return named[entity.toLowerCase()];
+    const hex = entity.toLowerCase().startsWith("&#x");
+    return String.fromCodePoint(parseInt(entity.slice(hex ? 3 : 2, -1), hex ? 16 : 10));
+  });
+  const user = JSON.parse(json);
+  const id = user?.id ?? user?._id;
+  if (user?.id && user?._id && user.id !== user._id) throw new Error("Conflicting authenticated account IDs.");
+  if (typeof id !== "string" || !/^[0-9a-f]{24}$/i.test(id)) {
+    throw new Error("Invalid authenticated account ID; refusing author-sensitive mutation.");
+  }
+  return id;
+}
+async function getAuthenticatedUserId() {
+  const res = await fetch(`${config.baseUrl}/user/settings`, {
+    headers: headers(),
+    redirect: "error",
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!res.ok) throw new Error(`Account verification failed (HTTP ${res.status}); refresh login.`);
+  return accountIdFromSettings(await res.text());
+}
+
+// src/lib/workspace-path.ts
+import { existsSync, realpathSync } from "fs";
+import { dirname, isAbsolute, relative, resolve, sep } from "path";
+function isOutside(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel);
+}
+function workspaceRelativePath(input, root = process.cwd()) {
+  if (typeof input !== "string" || !input.length) throw new Error("workspace path is empty");
+  if (isAbsolute(input) || /^[\\/]/.test(input) || /^[a-zA-Z]:[\\/]/.test(input)) {
+    throw new Error(`Absolute paths are not allowed: ${input}`);
+  }
+  const portable = input.replace(/\\/g, "/");
+  if (portable.split("/").includes("..")) {
+    throw new Error(`Parent path traversal is not allowed: ${input}`);
+  }
+  const target = resolve(root, ...portable.split("/"));
+  const absoluteRoot = resolve(root);
+  if (isOutside(absoluteRoot, target) || target === absoluteRoot) {
+    throw new Error(`Path must identify a file inside the working tree: ${input}`);
+  }
+  return relative(absoluteRoot, target).split(sep).join("/");
+}
+function workspaceReadPath(input, root = process.cwd()) {
+  const rel = workspaceRelativePath(input, root);
+  const realRoot = realpathSync(root);
+  const lexicalTarget = resolve(root, ...rel.split("/"));
+  const realTarget = realpathSync(lexicalTarget);
+  if (isOutside(realRoot, realTarget) || realTarget === realRoot) {
+    throw new Error(`Path resolves outside the working tree: ${input}`);
+  }
+  return lexicalTarget;
+}
+function workspaceWritePath(input, root = process.cwd()) {
+  const rel = workspaceRelativePath(input, root);
+  const lexicalTarget = resolve(root, ...rel.split("/"));
+  const realRoot = realpathSync(root);
+  if (existsSync(lexicalTarget)) {
+    const target = realpathSync(lexicalTarget);
+    if (isOutside(realRoot, target) || target === realRoot) {
+      throw new Error(`Path resolves outside the working tree: ${input}`);
+    }
+    return lexicalTarget;
+  }
+  let ancestor = dirname(lexicalTarget);
+  while (!existsSync(ancestor)) {
+    const parent = dirname(ancestor);
+    if (parent === ancestor) throw new Error(`Cannot resolve a safe parent for ${input}`);
+    ancestor = parent;
+  }
+  const realAncestor = realpathSync(ancestor);
+  if (isOutside(realRoot, realAncestor)) {
+    throw new Error(`Path has an ancestor outside the working tree: ${input}`);
+  }
+  return lexicalTarget;
+}
+
+// src/lib/submission-lock.ts
+import { createHash, randomUUID } from "crypto";
+import {
+  closeSync,
+  existsSync as existsSync2,
+  fsyncSync,
+  mkdirSync as mkdirSync3,
+  openSync,
+  readFileSync as readFileSync3,
+  realpathSync as realpathSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+var MUTATION_LOCK_PATH = join3(".overleaf", "mutation.lock");
+function mutationLockPath(root = process.cwd()) {
+  const key = createHash("sha256").update(realpathSync2(root), "utf8").digest("hex").slice(0, 32);
+  return join3(tmpdir(), `overleaf-review-${key}.lock`);
+}
+function acquireMutationLock(projectId, options = {}) {
+  const root = options.root ?? process.cwd();
+  const path = options.path ? workspaceWritePath(options.path, root) : mutationLockPath(root);
+  const displayPath = options.path ?? path;
+  mkdirSync3(dirname2(path), { recursive: true });
+  const token = randomUUID();
+  let fd;
+  try {
+    fd = openSync(path, "wx", 384);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    let owner = "";
+    try {
+      const parsed = JSON.parse(readFileSync3(path, "utf8"));
+      const details = [
+        typeof parsed.pid === "number" ? `pid ${parsed.pid}` : void 0,
+        typeof parsed.startedAt === "string" ? `since ${parsed.startedAt}` : void 0,
+        typeof parsed.projectId === "string" ? `project ${parsed.projectId}` : void 0
+      ].filter(Boolean);
+      if (details.length) owner = ` (${details.join(", ")})`;
+    } catch {
+    }
+    throw new Error(
+      `Another overleaf-review mutation holds ${displayPath}${owner}. Wait for it to finish. If its process crashed, inspect any relevant receipt and live project before removing the lock manually.`,
+      { cause: error }
+    );
+  }
+  try {
+    writeFileSync3(
+      fd,
+      `${JSON.stringify(
+        {
+          token,
+          pid: process.pid,
+          projectId,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        null,
+        2
+      )}
+`,
+      "utf8"
+    );
+    fsyncSync(fd);
+  } catch (error) {
+    closeSync(fd);
+    if (existsSync2(path)) unlinkSync2(path);
+    throw error;
+  }
+  closeSync(fd);
+  let released = false;
+  return {
+    path,
+    token,
+    release() {
+      if (released) return;
+      try {
+        const current = JSON.parse(readFileSync3(path, "utf8"));
+        if (current.token === token) unlinkSync2(path);
+        released = true;
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          released = true;
+          return;
+        }
+        throw error;
+      }
+    }
+  };
+}
+
+// src/lib/review-edits.ts
+import { diffWordsWithSpace } from "diff";
+
+// src/lib/three-way.ts
+import { diffChars } from "diff";
+function textEdits(base, target) {
+  const edits = [];
+  let basePos = 0;
+  let pending;
+  const flush = () => {
+    if (!pending) return;
+    if (pending.start !== pending.end || pending.text.length) edits.push(pending);
+    pending = void 0;
+  };
+  for (const part of diffChars(base, target)) {
+    if (!part.added && !part.removed) {
+      flush();
+      basePos += part.value.length;
+      continue;
+    }
+    pending ??= { start: basePos, end: basePos, text: "" };
+    if (part.removed) {
+      pending.end += part.value.length;
+      basePos += part.value.length;
+    } else {
+      pending.text += part.value;
+    }
+  }
+  flush();
+  return edits;
+}
+function sameEdit(a, b) {
+  return a.start === b.start && a.end === b.end && a.text === b.text;
+}
+function reverseCodePoints(text) {
+  return Array.from(text).reverse().join("");
+}
+function ambiguousEditAnchors(base, target) {
+  const forward = textEdits(base, target);
+  const reverse = textEdits(reverseCodePoints(base), reverseCodePoints(target)).map((edit) => ({
+    start: base.length - edit.end,
+    end: base.length - edit.start,
+    text: reverseCodePoints(edit.text)
+  })).sort((a, b) => a.start - b.start || a.end - b.end);
+  const ambiguities = [];
+  const count = Math.max(forward.length, reverse.length);
+  for (let index = 0; index < count; index++) {
+    const forwardEdit = forward[index] ?? reverse[index];
+    const reverseEdit = reverse[index] ?? forward[index];
+    if (sameEdit(forwardEdit, reverseEdit)) continue;
+    ambiguities.push({
+      forward: forwardEdit,
+      reverse: reverseEdit,
+      envelopeStart: Math.min(forwardEdit.start, reverseEdit.start),
+      envelopeEnd: Math.max(
+        forwardEdit.start,
+        forwardEdit.end,
+        reverseEdit.start,
+        reverseEdit.end
+      )
+    });
+  }
+  return ambiguities;
+}
+function editTouchesEnvelope(edit, start, end) {
+  if (edit.start === edit.end) return edit.start >= start && edit.start <= end;
+  return edit.start <= end && edit.end >= start;
+}
+function editsConflict(a, b) {
+  const aInsert = a.start === a.end;
+  const bInsert = b.start === b.end;
+  if (aInsert && bInsert) return a.start === b.start;
+  if (aInsert) return a.start > b.start && a.start < b.end;
+  if (bInsert) return b.start > a.start && b.start < a.end;
+  return a.start < b.end && b.start < a.end;
+}
+function mapBasePosition(position, liveEdits, includeInsertionAtPosition) {
+  let mapped = position;
+  for (const edit of liveEdits) {
+    if (edit.start === edit.end) {
+      if (edit.start < position || includeInsertionAtPosition && edit.start === position) {
+        mapped += edit.text.length;
+      }
+      continue;
+    }
+    if (edit.end <= position) mapped += edit.text.length - (edit.end - edit.start);
+  }
+  return mapped;
+}
+function applyEdits(source, edits) {
+  let result = source;
+  const ordered = edits.map((edit, index) => ({ edit, index })).sort(
+    (a, b) => b.edit.start - a.edit.start || b.edit.end - a.edit.end || b.index - a.index
+  );
+  for (const { edit } of ordered) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return result;
+}
+function threeWayMerge(base, local, live) {
+  const localEdits = textEdits(base, local);
+  const liveEdits = textEdits(base, live);
+  const ambiguousAnchors = ambiguousEditAnchors(base, local);
+  const conflicts = [];
+  const alreadyAppliedLocalEdits = [];
+  const toApply = [];
+  for (const localEdit of localEdits) {
+    if (liveEdits.some((liveEdit) => sameEdit(localEdit, liveEdit))) {
+      alreadyAppliedLocalEdits.push(localEdit);
+      continue;
+    }
+    const ambiguity = ambiguousAnchors.find((candidate) => sameEdit(candidate.forward, localEdit));
+    if (ambiguity) {
+      const touching = liveEdits.filter(
+        (liveEdit) => editTouchesEnvelope(liveEdit, ambiguity.envelopeStart, ambiguity.envelopeEnd)
+      );
+      if (touching.length) {
+        for (const liveEdit of touching) {
+          conflicts.push({ local: localEdit, live: liveEdit, reason: "ambiguous-local-anchor" });
+        }
+        continue;
+      }
+    }
+    const overlapping = liveEdits.filter((liveEdit) => editsConflict(localEdit, liveEdit));
+    if (overlapping.length) {
+      for (const liveEdit of overlapping) {
+        conflicts.push({ local: localEdit, live: liveEdit, reason: "overlapping-edits" });
+      }
+      continue;
+    }
+    if (localEdit.start === localEdit.end) {
+      const point = mapBasePosition(localEdit.start, liveEdits, false);
+      toApply.push({ start: point, end: point, text: localEdit.text });
+    } else {
+      const start = mapBasePosition(localEdit.start, liveEdits, true);
+      const end = mapBasePosition(localEdit.end, liveEdits, false);
+      toApply.push({ start, end, text: localEdit.text });
+    }
+  }
+  return {
+    text: conflicts.length ? void 0 : applyEdits(live, toApply),
+    localEdits,
+    liveEdits,
+    appliedLocalEdits: toApply,
+    alreadyAppliedLocalEdits,
+    conflicts
+  };
+}
+
+// src/lib/review-edits.ts
+var MAX_GAP_CHARS = 40;
+var MAX_GAP_WORDS = 3;
+var MAX_GROUP_CHARS = 320;
+var BOUNDARY = /[.!?;:](?:["'”’\)\]]*)\s|[.!?;:]$|\r?\n\s*\r?\n|[\\$%{}&]/u;
+function buildReviewEdits(source, target, options = {}) {
+  if (options.explicitEdits) {
+    const edits2 = validateExplicitEdits(source, options.explicitEdits);
+    if (applyTextEdits(source, edits2) !== target) throw new Error("Explicit blocks do not reconstruct the intended file.");
+    for (const edit of edits2) {
+      if (options.protectedSpans?.some((span) => edit.start <= span.end && span.start <= edit.end)) {
+        throw new Error("Explicit block touches a comment, pending suggestion, or concurrent edit; narrow the block or resolve the conflict first.");
+      }
+    }
+    return edits2;
+  }
+  const edits = [];
+  let sourcePos = 0;
+  let pending;
+  const flush = () => {
+    if (pending) edits.push(pending);
+    pending = void 0;
+  };
+  for (const part of diffWordsWithSpace(source, target)) {
+    if (!part.added && !part.removed) {
+      flush();
+      sourcePos += part.value.length;
+    } else {
+      pending ??= { start: sourcePos, end: sourcePos, text: "" };
+      if (part.removed) {
+        sourcePos += part.value.length;
+        pending.end = sourcePos;
+      } else {
+        pending.text += part.value;
+      }
+    }
+  }
+  flush();
+  if (options.group === false) return edits;
+  const groups = [];
+  for (const edit of edits) {
+    const previous = groups[groups.length - 1];
+    if (!previous) {
+      groups.push({ ...edit });
+      continue;
+    }
+    const gap = source.slice(previous.end, edit.start);
+    const protectedGap = options.protectedSpans?.some(
+      (span) => span.start === span.end ? span.start >= previous.end && span.start <= edit.start : span.start < edit.start && span.end > previous.end
+    );
+    const canGroup = !protectedGap && gap.length <= MAX_GAP_CHARS && (gap.match(/\S+/gu)?.length ?? 0) <= MAX_GAP_WORDS && !BOUNDARY.test(source.slice(previous.start, edit.start)) && !BOUNDARY.test(previous.text + gap) && edit.end - previous.start <= MAX_GROUP_CHARS && previous.text.length + gap.length + edit.text.length <= MAX_GROUP_CHARS;
+    if (canGroup) {
+      previous.end = edit.end;
+      previous.text += gap + edit.text;
+    } else {
+      groups.push({ ...edit });
+    }
+  }
+  return groups;
+}
+function validateExplicitEdits(source, value) {
+  if (!Array.isArray(value) || !value.length) throw new Error("Explicit blocks must be a nonempty array.");
+  let previousEnd = -1;
+  return value.map((edit) => {
+    if (!edit || !Number.isSafeInteger(edit.start) || !Number.isSafeInteger(edit.end) || edit.start < 0 || edit.end < edit.start || edit.end > source.length || typeof edit.text !== "string" || edit.start <= previousEnd || source.slice(edit.start, edit.end) === edit.text) {
+      throw new Error("Explicit blocks must be valid, ordered, separated replacements with a text change.");
+    }
+    previousEnd = edit.end;
+    return { start: edit.start, end: edit.end, text: edit.text };
+  });
+}
+function applyTextEdits(source, edits) {
+  for (const edit of [...edits].reverse()) {
+    source = source.slice(0, edit.start) + edit.text + source.slice(edit.end);
+  }
+  return source;
+}
+function parseReplacementManifest(base, value) {
+  const manifest = value;
+  if (!Array.isArray(manifest?.replacements) || !manifest.replacements.length) {
+    throw new Error("Replacement manifest requires a nonempty replacements array.");
+  }
+  const edits = manifest.replacements.map((block) => {
+    if (block && ["supersedes", "reason", "comments"].some((key) => Object.hasOwn(block, key))) {
+      throw new Error("Reviewed overlap fields require the reviewed plan workflow; use review plan --file --edits --out.");
+    }
+    if (!block || typeof block.before !== "string" || !block.before.length || typeof block.after !== "string" || block.occurrence !== void 0 && (!Number.isSafeInteger(block.occurrence) || block.occurrence < 1)) {
+      throw new Error("Each replacement requires nonempty before, after text, and optionally a positive occurrence.");
+    }
+    const matches = [];
+    for (let p = base.indexOf(block.before); p !== -1; p = base.indexOf(block.before, p + 1)) matches.push(p);
+    if (!matches.length || matches.length > 1 && block.occurrence === void 0) {
+      throw new Error("Replacement before text is absent or ambiguous in the saved base; specify occurrence for repeated text.");
+    }
+    const start = matches[(block.occurrence ?? 1) - 1];
+    if (start === void 0) throw new Error("Replacement occurrence is absent from the saved base.");
+    return { start, end: start + block.before.length, text: block.after };
+  }).sort((a, b) => a.start - b.start);
+  return validateExplicitEdits(base, edits);
+}
+function bindExplicitEdits(base, local, live, edits, options) {
+  const checked = validateExplicitEdits(base, edits);
+  if (applyTextEdits(base, checked) !== local) {
+    throw new Error("Replacement manifest must describe every local change exactly.");
+  }
+  const changes = textEdits(base, live);
+  const mapped = checked.map((edit) => {
+    let offset = 0;
+    for (const change of changes) {
+      if (change.start <= edit.end && edit.start <= change.end) {
+        throw new Error("A concurrent edit touches an explicit replacement block; refresh and re-plan.");
+      }
+      if (change.end < edit.start) offset += change.text.length - (change.end - change.start);
+    }
+    return { ...edit, start: edit.start + offset, end: edit.end + offset };
+  });
+  return { ...options, explicitEdits: mapped };
+}
+function reviewGroupingOptions(base, live, ranges, direct = false) {
+  const protectedSpans = [];
+  for (const range of ranges.changes ?? []) {
+    if (typeof range.op?.p === "number") {
+      protectedSpans.push({ start: range.op.p, end: range.op.p + (range.op.i?.length ?? 0) });
+    }
+  }
+  for (const range of ranges.comments ?? []) {
+    if (typeof range.op?.p === "number") {
+      protectedSpans.push({ start: range.op.p, end: range.op.p + (range.op.c?.length ?? 0) });
+    }
+  }
+  let offset = 0;
+  for (const edit of textEdits(base, live)) {
+    const start = edit.start + offset;
+    protectedSpans.push({ start, end: start + edit.text.length });
+    offset += edit.text.length - (edit.end - edit.start);
+  }
+  return { group: !direct, protectedSpans };
+}
+
+// src/lib/document-match.ts
+var AmbiguousDocumentError = class extends Error {
+  constructor(identifier, matches) {
+    super(
+      `Document name "${identifier}" is ambiguous (${matches.map((doc) => doc.path).join(", ")}); use the exact project path.`
+    );
+    this.name = "AmbiguousDocumentError";
+  }
+};
+function matchDocument(identifier, docs) {
+  const exact = docs.filter((doc) => doc.path === identifier);
+  if (exact.length > 1) throw new AmbiguousDocumentError(identifier, exact);
+  if (exact.length === 1) return exact[0];
+  if (identifier.includes("/") || identifier.includes("\\")) return void 0;
+  const basename2 = identifier.replace(/\\/g, "/").split("/").pop() ?? identifier;
+  const matches = docs.filter((doc) => doc.name === basename2);
+  if (matches.length > 1) throw new AmbiguousDocumentError(identifier, matches);
+  return matches[0];
+}
+
+// src/lib/receipts.ts
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync3,
+  fsyncSync as fsyncSync2,
+  mkdirSync as mkdirSync4,
+  openSync as openSync2,
+  readFileSync as readFileSync4,
+  readdirSync,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { basename, dirname as dirname3, join as join4 } from "path";
+var RECEIPT_SCHEMA_VERSION = 1;
+var DEFAULT_RECEIPTS_DIR = join4(".overleaf", "receipts");
+function safeFilenamePart(value) {
+  const safe = value.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  return safe || "operation";
+}
+function writeJsonAtomic(path, value) {
+  const targetDir = dirname3(path);
+  mkdirSync4(targetDir, { recursive: true });
+  const tempPath = join4(
+    targetDir,
+    `.${basename(path)}.${process.pid}.${randomUUID2()}.tmp`
+  );
+  let fd;
+  try {
+    fd = openSync2(tempPath, "wx", 384);
+    writeFileSync4(fd, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+    fsyncSync2(fd);
+    closeSync2(fd);
+    fd = void 0;
+    renameSync2(tempPath, path);
+    let dirFd;
+    try {
+      dirFd = openSync2(targetDir, "r");
+      fsyncSync2(dirFd);
+    } catch {
+    } finally {
+      if (dirFd !== void 0) closeSync2(dirFd);
+    }
+  } finally {
+    if (fd !== void 0) closeSync2(fd);
+    if (existsSync3(tempPath)) unlinkSync3(tempPath);
+  }
+}
+function beginReceipt(operation, details, options = {}) {
+  const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+  const operationId = options.operationId ?? randomUUID2();
+  const receipt = {
+    schemaVersion: RECEIPT_SCHEMA_VERSION,
+    operationId,
+    operation,
+    status: "started",
+    startedAt: now,
+    updatedAt: now,
+    details
+  };
+  const dir = options.receiptsDir ?? DEFAULT_RECEIPTS_DIR;
+  const timestamp = now.replace(/[:.]/g, "-");
+  const path = join4(dir, `${timestamp}-${safeFilenamePart(operation)}-${operationId}.json`);
+  writeJsonAtomic(path, receipt);
+  return { path, receipt };
+}
+function updateReceipt(handle, status, details, options = {}) {
+  const receipt = {
+    ...handle.receipt,
+    status,
+    updatedAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    details: { ...handle.receipt.details, ...details }
+  };
+  writeJsonAtomic(handle.path, receipt);
+  return { path: handle.path, receipt };
+}
+function readReceipts(receiptsDir = DEFAULT_RECEIPTS_DIR) {
+  let names;
+  try {
+    names = readdirSync(receiptsDir).filter((name) => name.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const receipts = [];
+  for (const name of names) {
+    const path = join4(receiptsDir, name);
+    try {
+      const receipt = JSON.parse(readFileSync4(path, "utf8"));
+      if (receipt?.schemaVersion === RECEIPT_SCHEMA_VERSION && typeof receipt.operationId === "string" && typeof receipt.operation === "string" && typeof receipt.updatedAt === "string" && receipt.details && typeof receipt.details === "object") {
+        receipts.push({ path, receipt });
+      }
+    } catch {
+    }
+  }
+  return receipts.sort((a, b) => b.receipt.updatedAt.localeCompare(a.receipt.updatedAt));
+}
+
+// src/lib/sync-state.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync5,
+  renameSync as renameSync3,
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { dirname as dirname4, join as join5 } from "path";
+var BASE_STATE_SCHEMA_VERSION = 1;
+var BASE_STATE_PATH = join5(".overleaf", "base.json");
+function sha256(text) {
+  return createHash2("sha256").update(text, "utf8").digest("hex");
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      const item = value[key];
+      if (item !== void 0) out[key] = canonicalize(item);
+    }
+    return out;
+  }
+  return value;
+}
+function stableJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function sortedRanges(values) {
+  return (values ?? []).map(canonicalize).sort((a, b) => {
+    const left = stableJson(a);
+    const right = stableJson(b);
+    return left < right ? -1 : left > right ? 1 : 0;
+  });
+}
+function fingerprintRanges(ranges) {
+  return sha256(
+    stableJson({
+      comments: sortedRanges(ranges.comments),
+      changes: sortedRanges(ranges.changes)
+    })
+  );
+}
+function assertBaseState(value, path) {
+  if (!value || typeof value !== "object") throw new Error(`Invalid base state in ${path}`);
+  const state = value;
+  if (state.schemaVersion !== BASE_STATE_SCHEMA_VERSION || typeof state.projectId !== "string" || !state.documents || typeof state.documents !== "object") {
+    throw new Error(
+      `Unsupported or invalid base state in ${path}; run fetch to create a new synchronization base.`
+    );
+  }
+  for (const [docId, raw] of Object.entries(state.documents)) {
+    const doc = raw;
+    if (doc.docId !== docId || typeof doc.path !== "string" || typeof doc.text !== "string" || typeof doc.hash !== "string" || doc.hash !== sha256(doc.text)) {
+      throw new Error(`Invalid document ${docId} in ${path}`);
+    }
+  }
+}
+function loadBaseState(path = BASE_STATE_PATH) {
+  let raw;
+  try {
+    raw = readFileSync5(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in ${path}; run fetch to recreate the synchronization base.`);
+  }
+  assertBaseState(parsed, path);
+  return parsed;
+}
+function saveBaseState(state, path = BASE_STATE_PATH) {
+  mkdirSync5(dirname4(path), { recursive: true });
+  const temp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync5(temp, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+    renameSync3(temp, path);
+  } catch (error) {
+    try {
+      unlinkSync4(temp);
+    } catch {
+    }
+    throw error;
+  }
+}
+function mergeBaseDocuments(projectId, documents, path = BASE_STATE_PATH) {
+  const previous = loadBaseState(path);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const state = {
+    schemaVersion: BASE_STATE_SCHEMA_VERSION,
+    projectId,
+    updatedAt: now,
+    documents: previous?.projectId === projectId ? { ...previous.documents } : {}
+  };
+  for (const doc of documents) state.documents[doc.docId] = doc;
+  saveBaseState(state, path);
+  return state;
+}
+
+// src/lib/tracked-changes.ts
+import { randomBytes } from "crypto";
+var TRACKED_CHANGE_SEED_BYTES = 9;
+function createTrackedChangeSeed(bytes = randomBytes) {
+  const entropy = bytes(TRACKED_CHANGE_SEED_BYTES);
+  if (entropy.byteLength !== TRACKED_CHANGE_SEED_BYTES) {
+    throw new Error(
+      `tracked-change seed source returned ${entropy.byteLength} bytes; expected ${TRACKED_CHANGE_SEED_BYTES}`
+    );
+  }
+  return Buffer.from(entropy).toString("hex");
+}
+var TrackedChangeMutationError = class extends Error {
+  constructor(message, result, cause) {
+    super(message, cause === void 0 ? void 0 : { cause });
+    this.result = result;
+    this.name = "TrackedChangeMutationError";
+  }
+  result;
+};
+function uniqueChangeIds(changeIds) {
+  return [...new Set(changeIds)];
+}
+function changeIdsInRanges(ranges) {
+  return [...new Set(ranges.map((range) => range.id))];
+}
+function remainingChangeIds(ranges, requestedIds) {
+  const present = new Set(changeIdsInRanges(ranges));
+  return uniqueChangeIds(requestedIds).filter((id) => present.has(id));
+}
+function inverseOf(range) {
+  const { p, i, d } = range.op ?? {};
+  if (!Number.isSafeInteger(p) || p < 0) {
+    throw new Error(`tracked change ${range.id} has an invalid position: ${String(p)}`);
+  }
+  if (typeof i === "string" && d === void 0) return { p, d: i, u: true };
+  if (typeof d === "string" && i === void 0) return { p, i: d, u: true };
+  throw new Error(`tracked change ${range.id} does not contain exactly one insert/delete op`);
+}
+function applyUndo(text, op, changeId) {
+  if (op.p > text.length) {
+    throw new Error(
+      `tracked change ${changeId} starts at ${op.p}, beyond document length ${text.length}`
+    );
+  }
+  if ("d" in op) {
+    const actual = text.slice(op.p, op.p + op.d.length);
+    if (actual !== op.d) {
+      throw new Error(
+        `tracked insertion ${changeId} no longer matches document text at ${op.p}: expected ${JSON.stringify(op.d)}, found ${JSON.stringify(actual)}`
+      );
+    }
+    return text.slice(0, op.p) + text.slice(op.p + op.d.length);
+  }
+  return text.slice(0, op.p) + op.i + text.slice(op.p);
+}
+function buildRejectionPlan(currentText, ranges, requestedIds) {
+  const requested = new Set(uniqueChangeIds(requestedIds));
+  const fragments = ranges.filter((range) => requested.has(range.id));
+  fragments.sort((a, b) => b.op.p - a.op.p);
+  const operations = [];
+  let expectedText = currentText;
+  for (const range of fragments) {
+    const inverse = inverseOf(range);
+    expectedText = applyUndo(expectedText, inverse, range.id);
+    operations.push(inverse);
+  }
+  return {
+    changeIds: changeIdsInRanges(fragments),
+    fragmentCount: fragments.length,
+    operations,
+    expectedText
+  };
+}
+
+// src/commands/consolidate.ts
+import { readFileSync as readFileSync7 } from "fs";
+
+// src/commands/push.ts
+import {
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync6,
+  readdirSync as readdirSync2,
+  renameSync as renameSync4,
+  statSync,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { createHash as createHash3 } from "crypto";
+import { dirname as dirname5, relative as relative2, resolve as resolvePath, sep as sep2 } from "path";
+
+// src/lib/tracked-overlap.ts
+function spanOverlapsEdit(start, end, edit) {
+  const editIsPoint = edit.start === edit.end;
+  const rangeIsPoint = start === end;
+  if (editIsPoint && rangeIsPoint) return edit.start === start;
+  if (editIsPoint) return edit.start > start && edit.start < end;
+  if (rangeIsPoint) return start >= edit.start && start < edit.end;
+  return edit.start < end && start < edit.end;
+}
+function overlapsEdit(change, edit) {
+  const p = change.op?.p;
+  if (typeof p !== "number") return false;
+  const inserted = typeof change.op?.i === "string" ? change.op.i : void 0;
+  const changeStart = p;
+  const changeEnd = p + (inserted?.length ?? 0);
+  return spanOverlapsEdit(changeStart, changeEnd, edit);
+}
+function findTrackedChangeOverlaps(changes, proposedEdits) {
+  const out = [];
+  for (const change of changes ?? []) {
+    for (const proposedEdit of proposedEdits) {
+      if (overlapsEdit(change, proposedEdit)) {
+        out.push({ changeId: change.id ?? "(unknown)", change, proposedEdit });
+      }
+    }
+  }
+  return out;
+}
+function findCommentOverlaps(comments, proposedEdits) {
+  const out = [];
+  for (const comment of comments ?? []) {
+    const p = comment.op?.p;
+    const anchor = comment.op?.c;
+    if (typeof p !== "number" || typeof anchor !== "string") continue;
+    for (const proposedEdit of proposedEdits) {
+      if (spanOverlapsEdit(p, p + anchor.length, proposedEdit)) {
+        out.push({
+          threadId: comment.op?.t ?? comment.id ?? "(unknown)",
+          position: p,
+          anchor,
+          comment,
+          proposedEdit
+        });
+      }
+    }
+  }
+  return out;
+}
+
+// src/lib/snapshots.ts
+import { join as join6 } from "path";
+var SNAPSHOTS_DIR = join6(".overleaf", "snapshots");
+function snapshotTimestamp(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+function snapshotRelativePath(timestamp, projectPath, root = process.cwd()) {
+  if (!/^[0-9TZ-]+$/.test(timestamp)) throw new Error(`Invalid snapshot timestamp: ${timestamp}`);
+  const safeProjectPath = workspaceRelativePath(projectPath, root);
+  return workspaceRelativePath(join6(SNAPSHOTS_DIR, timestamp, safeProjectPath), root);
+}
+
+// src/commands/push.ts
+var PUSH_PLAN_SCHEMA_VERSION = 4;
+var PUSH_PLAN_KIND = "overleaf-review-push-plan";
+var PushSubmissionError = class extends Error {
+  constructor(message, receiptPath, status, documents, cause) {
+    super(message, cause === void 0 ? void 0 : { cause });
+    this.receiptPath = receiptPath;
+    this.status = status;
+    this.documents = documents;
+    this.name = "PushSubmissionError";
+  }
+  receiptPath;
+  status;
+  documents;
+};
+var PushPlanningError = class extends Error {
+  constructor(message, conflicts = [], overlaps = []) {
+    super(message);
+    this.conflicts = conflicts;
+    this.overlaps = overlaps;
+    this.name = "PushPlanningError";
+  }
+  conflicts;
+  overlaps;
+};
+var PushPlanValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PushPlanValidationError";
+  }
+};
+function validatePushOptions(opts) {
+  if (opts.edits && (opts.plan || !opts.file || opts.direct || opts.unsafeNoBase)) {
+    throw new Error("--edits requires --file and a saved base, and cannot be combined with --plan, --direct or --unsafe-no-base.");
+  }
+  if (opts.docName && !opts.file) {
+    throw new Error("--doc requires --file; bulk pushes cannot map multiple local files to one document.");
+  }
+}
+function buildOps(source, target, options = {}) {
+  const ops = [];
+  let offset = 0;
+  for (const edit of buildReviewEdits(source, target, options)) {
+    const p = edit.start + offset;
+    const deleted = source.slice(edit.start, edit.end);
+    if (deleted) ops.push({ p, d: deleted });
+    if (edit.text) ops.push({ p, i: edit.text });
+    offset += edit.text.length - deleted.length;
+  }
+  const rebuilt = applyOps(source, ops);
+  if (rebuilt !== target) {
+    throw new Error("internal error: generated OT operations do not reconstruct target text");
+  }
+  return ops;
+}
+function buildOperationFootprint(source, target, options = {}) {
+  return buildReviewEdits(source, target, options);
+}
+function applyOps(source, ops) {
+  let text = source;
+  for (const op of ops) {
+    if (!Number.isSafeInteger(op.p) || op.p < 0 || op.p > text.length) {
+      throw new Error(`invalid operation position ${String(op.p)} for ${text.length}-character text`);
+    }
+    const hasInsert = typeof op.i === "string";
+    const hasDelete = typeof op.d === "string";
+    if (hasInsert === hasDelete) throw new Error("operation must contain exactly one of i or d");
+    if (hasInsert) {
+      text = text.slice(0, op.p) + op.i + text.slice(op.p);
+    } else {
+      const deletion = op.d;
+      const actual = text.slice(op.p, op.p + deletion.length);
+      if (actual !== deletion) {
+        throw new Error(
+          `delete operation mismatch at ${op.p}: expected ${JSON.stringify(deletion)}, found ${JSON.stringify(actual)}`
+        );
+      }
+      text = text.slice(0, op.p) + text.slice(op.p + deletion.length);
+    }
+  }
+  return text;
+}
+function preview(op) {
+  const kind = op.i != null ? "insert" : "delete";
+  const text = (op.i ?? op.d ?? "").replace(/\n/g, "\u23CE");
+  const clip = text.length > 60 ? text.slice(0, 60) + "\u2026" : text;
+  return `  ${kind.padEnd(6)} @ ${String(op.p).padStart(5)}  "${clip}"`;
+}
+function toOverleafPath(file) {
+  return workspaceRelativePath(file);
+}
+var IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".overleaf", "tmp", "dist"]);
+function discoverLocalTex(dir = process.cwd(), acc = []) {
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".") || IGNORE_DIRS.has(entry.name)) continue;
+    const full = resolvePath(dir, entry.name);
+    if (entry.isDirectory()) discoverLocalTex(full, acc);
+    else if (entry.name.endsWith(".tex")) {
+      acc.push(relative2(process.cwd(), full).split(sep2).join("/"));
+    }
+  }
+  return acc;
+}
+function pickDoc(file, docName, docs) {
+  return matchDocument(docName?.replace(/\\/g, "/") ?? toOverleafPath(file), docs);
+}
+function formatConflicts(conflicts) {
+  return conflicts.flatMap(
+    ({ docPath, conflicts: items }) => items.map(
+      ({ local, live, reason }) => reason === "ambiguous-local-anchor" ? `${docPath}: repeated-text anchor for local [${local.start},${local.end}) is ambiguous and its envelope is touched by live [${live.start},${live.end}); refresh and reapply this edit explicitly` : `${docPath}: local [${local.start},${local.end}) overlaps live [${live.start},${live.end})`
+    )
+  ).join("\n  ");
+}
+function serializeOverlaps(overlaps) {
+  return overlaps.map(({ changeId, proposedEdit, change }) => ({
+    changeId,
+    proposedEdit,
+    trackedOp: {
+      p: change.op?.p,
+      i: change.op?.i,
+      d: change.op?.d
+    }
+  })).sort((a, b) => {
+    const left = stableJson(a);
+    const right = stableJson(b);
+    return left < right ? -1 : left > right ? 1 : 0;
+  });
+}
+function serializeActiveTrackedRanges(changes) {
+  const ranges = (changes ?? []).map((change, index) => {
+    const id = change?.id;
+    const p = change?.op?.p;
+    const hasInsert = typeof change?.op?.i === "string";
+    const hasDelete = typeof change?.op?.d === "string";
+    if (typeof id !== "string" || !Number.isSafeInteger(p) || p < 0 || hasInsert === hasDelete) {
+      throw new Error(`Overleaf returned an invalid tracked range at index ${index}`);
+    }
+    return {
+      id,
+      op: {
+        p,
+        ...hasInsert ? { i: change.op.i } : { d: change.op.d }
+      },
+      ...change.metadata && typeof change.metadata === "object" ? { metadata: change.metadata } : {}
+    };
+  });
+  return ranges.sort((a, b) => {
+    const left = stableJson(a);
+    const right = stableJson(b);
+    return left < right ? -1 : left > right ? 1 : 0;
+  });
+}
+function serializeCommentOverlaps(overlaps) {
+  return overlaps.map(({ threadId, position, anchor, proposedEdit }) => ({
+    threadId,
+    position,
+    anchor,
+    proposedEdit
+  })).sort((a, b) => {
+    const left = stableJson(a);
+    const right = stableJson(b);
+    return left < right ? -1 : left > right ? 1 : 0;
+  });
+}
+async function createPlan(opts = {}) {
+  validatePushOptions(opts);
+  const manifest = opts.edits ? JSON.parse(readFileSync6(workspaceReadPath(opts.edits), "utf8")) : void 0;
+  if (opts.plan) throw new Error("createPlan does not accept an existing plan");
+  const basePath = opts.basePath ?? BASE_STATE_PATH;
+  const baseState = loadBaseState(basePath);
+  if (baseState && baseState.projectId !== config.projectId && !opts.unsafeNoBase) {
+    throw new PushPlanningError(
+      `Saved base belongs to project ${baseState.projectId}, not ${config.projectId}; run fetch first.`
+    );
+  }
+  const { socket, project, docs } = await openProject();
+  try {
+    const projectId = String(project?._id ?? config.projectId);
+    if (projectId !== config.projectId) {
+      throw new PushPlanningError(
+        `Connected project id ${projectId} does not match configured project ${config.projectId}.`
+      );
+    }
+    const files = opts.file ? [workspaceRelativePath(opts.file)] : discoverLocalTex();
+    if (!files.length) {
+      const emptyPlan = {
+        kind: PUSH_PLAN_KIND,
+        schemaVersion: PUSH_PLAN_SCHEMA_VERSION,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        projectId,
+        projectName: String(project?.name ?? "(unknown)"),
+        direct: Boolean(opts.direct),
+        unsafeNoBase: Boolean(opts.unsafeNoBase),
+        allowOverlap: Boolean(opts.allowOverlap),
+        documents: []
+      };
+      if (opts.planOut) writePushPlan(emptyPlan, opts.planOut);
+      return emptyPlan;
+    }
+    const documents = [];
+    const conflicts = [];
+    const blockedOverlaps = [];
+    for (const file of files) {
+      let local;
+      try {
+        local = readFileSync6(workspaceReadPath(file), "utf8");
+      } catch (error) {
+        throw new Error(`Cannot safely read ${file}: ${error.message}`);
+      }
+      const doc = pickDoc(file, opts.docName, docs);
+      if (!doc) {
+        throw new Error(
+          `No Overleaf document matches ${file}; push it with --file and --doc using the exact project path.`
+        );
+      }
+      const state = await joinDoc(socket, doc._id);
+      const live = state.lines.join("\n");
+      const savedBase = baseState?.projectId === projectId ? baseState.documents[doc._id] : void 0;
+      if (!savedBase && !opts.unsafeNoBase) {
+        throw new PushPlanningError(
+          `No saved synchronization base for ${doc.path}. Run fetch first, or explicitly use \`--unsafe-no-base\` to request legacy two-way behavior.`
+        );
+      }
+      const base = savedBase?.text ?? live;
+      const merge = threeWayMerge(base, local, live);
+      if (merge.conflicts.length) {
+        conflicts.push({ localPath: file, docPath: doc.path, conflicts: merge.conflicts });
+        continue;
+      }
+      const expected = merge.text;
+      const explicitEdits = manifest ? parseReplacementManifest(base, manifest) : void 0;
+      let grouping = reviewGroupingOptions(base, live, state.ranges, opts.direct);
+      if (explicitEdits) grouping = bindExplicitEdits(base, local, live, explicitEdits, grouping);
+      const ops = buildOps(live, expected, grouping);
+      if (!ops.length) continue;
+      const proposedEdits = buildOperationFootprint(live, expected, grouping);
+      const activeTrackedRanges = serializeActiveTrackedRanges(state.ranges.changes);
+      assertTrackedRangeBudget(activeTrackedRanges.length, ops.length, Boolean(opts.direct), doc.path);
+      const overlaps = serializeOverlaps(
+        findTrackedChangeOverlaps(state.ranges.changes, proposedEdits)
+      );
+      const commentOverlaps = serializeCommentOverlaps(
+        findCommentOverlaps(state.ranges.comments, proposedEdits)
+      );
+      if (overlaps.length && !opts.allowOverlap) {
+        blockedOverlaps.push({ localPath: file, docPath: doc.path, overlaps });
+        continue;
+      }
+      documents.push({
+        ...explicitEdits ? { explicitEdits } : {},
+        localPath: toOverleafPath(file),
+        docId: doc._id,
+        docPath: doc.path,
+        baseSource: savedBase ? "saved" : "live-unsafe",
+        baseHash: sha256(base),
+        localHash: sha256(local),
+        liveHash: sha256(live),
+        liveVersion: state.version,
+        rangeFingerprint: fingerprintRanges(state.ranges),
+        ops,
+        expectedHash: sha256(expected),
+        tcSeed: opts.direct ? null : createTrackedChangeSeed(),
+        activeTrackedRanges,
+        trackedChangeOverlaps: overlaps,
+        commentOverlaps
+      });
+    }
+    if (conflicts.length || blockedOverlaps.length) {
+      const parts = [];
+      if (conflicts.length) parts.push(`Concurrent edit conflicts:
+  ${formatConflicts(conflicts)}`);
+      if (blockedOverlaps.length) {
+        const lines = blockedOverlaps.flatMap(
+          ({ docPath, overlaps }) => overlaps.map(
+            ({ changeId, proposedEdit }) => `${docPath}: proposed [${proposedEdit.start},${proposedEdit.end}) overlaps change ${changeId}`
+          )
+        );
+        parts.push(
+          `Active tracked-change overlaps:
+  ${lines.join("\n  ")}
+Re-plan with --allow-overlap only after inspecting these changes.`
+        );
+      }
+      throw new PushPlanningError(parts.join("\n\n"), conflicts, blockedOverlaps);
+    }
+    const plan = {
+      kind: PUSH_PLAN_KIND,
+      schemaVersion: PUSH_PLAN_SCHEMA_VERSION,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectId,
+      projectName: String(project?.name ?? "(unknown)"),
+      direct: Boolean(opts.direct),
+      unsafeNoBase: documents.some((doc) => doc.baseSource === "live-unsafe"),
+      allowOverlap: Boolean(opts.allowOverlap),
+      documents
+    };
+    if (opts.planOut) writePushPlan(plan, opts.planOut);
+    return plan;
+  } finally {
+    socket.close();
+  }
+}
+function assertHash(value, field) {
+  if (typeof value !== "string" || !/^[0-9a-f]{64}$/.test(value)) {
+    throw new PushPlanValidationError(`Invalid ${field} in push plan`);
+  }
+}
+function validatePushPlan(value) {
+  if (!value || typeof value !== "object") throw new PushPlanValidationError("Push plan is not an object");
+  const plan = value;
+  if (plan.kind !== PUSH_PLAN_KIND || plan.schemaVersion !== PUSH_PLAN_SCHEMA_VERSION) {
+    throw new PushPlanValidationError("Unsupported push-plan kind or schema version; create a new plan with the current tool.");
+  }
+  if (typeof plan.projectId !== "string" || typeof plan.projectName !== "string" || typeof plan.createdAt !== "string" || typeof plan.direct !== "boolean" || typeof plan.unsafeNoBase !== "boolean" || typeof plan.allowOverlap !== "boolean" || !Array.isArray(plan.documents)) {
+    throw new PushPlanValidationError("Push plan is missing required fields");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const seenLocalPaths = /* @__PURE__ */ new Set();
+  for (const doc of plan.documents) {
+    if (doc?.explicitEdits !== void 0 && (!Array.isArray(doc.explicitEdits) || !doc.explicitEdits.length || !doc.explicitEdits.every(validTextEdit) || plan.direct || doc.baseSource !== "saved")) throw new PushPlanValidationError("Invalid explicit replacement blocks in push plan.");
+    if (!doc || typeof doc.localPath !== "string" || typeof doc.docId !== "string" || typeof doc.docPath !== "string" || doc.baseSource !== "saved" && doc.baseSource !== "live-unsafe" || !Number.isSafeInteger(doc.liveVersion) || doc.liveVersion < 0 || !Array.isArray(doc.ops) || doc.ops.length === 0 || !Array.isArray(doc.activeTrackedRanges) || !Array.isArray(doc.trackedChangeOverlaps) || !Array.isArray(doc.commentOverlaps)) {
+      throw new PushPlanValidationError("Push plan contains an invalid document");
+    }
+    try {
+      if (workspaceRelativePath(doc.localPath) !== doc.localPath || workspaceRelativePath(doc.docPath) !== doc.docPath) {
+        throw new Error("path is not normalized");
+      }
+    } catch (error) {
+      throw new PushPlanValidationError(
+        `Unsafe or invalid path in push plan: ${error.message}`
+      );
+    }
+    if (seen.has(doc.docId)) throw new PushPlanValidationError(`Duplicate document ${doc.docId} in plan`);
+    seen.add(doc.docId);
+    if (seenLocalPaths.has(doc.localPath)) {
+      throw new PushPlanValidationError(`Duplicate local path ${doc.localPath} in plan`);
+    }
+    seenLocalPaths.add(doc.localPath);
+    assertHash(doc.baseHash, "baseHash");
+    assertHash(doc.localHash, "localHash");
+    assertHash(doc.liveHash, "liveHash");
+    assertHash(doc.rangeFingerprint, "rangeFingerprint");
+    assertHash(doc.expectedHash, "expectedHash");
+    for (const op of doc.ops) {
+      if (!op || !Number.isSafeInteger(op.p) || op.p < 0 || typeof op.i === "string" === (typeof op.d === "string") || typeof (op.i ?? op.d) === "string" && (op.i ?? op.d).length === 0) {
+        throw new PushPlanValidationError(`Invalid operation in ${doc.docPath}`);
+      }
+    }
+    for (const range of doc.activeTrackedRanges) {
+      if (!range || typeof range.id !== "string" || !Number.isSafeInteger(range.op?.p) || range.op.p < 0 || typeof range.op.i === "string" === (typeof range.op.d === "string") || range.metadata !== void 0 && (!range.metadata || typeof range.metadata !== "object")) {
+        throw new PushPlanValidationError(`Invalid active tracked range in ${doc.docPath}`);
+      }
+    }
+    for (const overlap of doc.trackedChangeOverlaps) {
+      if (!overlap || typeof overlap.changeId !== "string" || !validTextEdit(overlap.proposedEdit) || !Number.isSafeInteger(overlap.trackedOp?.p)) {
+        throw new PushPlanValidationError(`Invalid tracked-change overlap in ${doc.docPath}`);
+      }
+    }
+    for (const overlap of doc.commentOverlaps) {
+      if (!overlap || typeof overlap.threadId !== "string" || !Number.isSafeInteger(overlap.position) || overlap.position < 0 || typeof overlap.anchor !== "string" || !validTextEdit(overlap.proposedEdit)) {
+        throw new PushPlanValidationError(`Invalid comment overlap in ${doc.docPath}`);
+      }
+    }
+    if (plan.direct) {
+      if (doc.tcSeed !== null) throw new PushPlanValidationError("Direct plan must not contain tcSeed");
+    } else if (typeof doc.tcSeed !== "string" || !/^[0-9a-f]{18}$/.test(doc.tcSeed)) {
+      throw new PushPlanValidationError(`Invalid tracked-change seed in ${doc.docPath}`);
+    }
+    if (!plan.allowOverlap && doc.trackedChangeOverlaps.length) {
+      throw new PushPlanValidationError("Plan contains blocked tracked-change overlaps");
+    }
+    if (doc.baseSource === "live-unsafe" && doc.baseHash !== doc.liveHash) {
+      throw new PushPlanValidationError(`Unsafe base must equal planned live text in ${doc.docPath}`);
+    }
+  }
+  return plan;
+}
+function validTextEdit(value) {
+  if (!value || typeof value !== "object") return false;
+  const edit = value;
+  return Boolean(
+    Number.isSafeInteger(edit.start) && Number.isSafeInteger(edit.end) && edit.start >= 0 && edit.end >= edit.start && typeof edit.text === "string"
+  );
+}
+function readPushPlan(path, workspaceRoot = process.cwd()) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync6(workspaceReadPath(path, workspaceRoot), "utf8"));
+  } catch (error) {
+    throw new PushPlanValidationError(`Cannot read push plan ${path}: ${error.message}`);
+  }
+  return validatePushPlan(parsed);
+}
+function writePushPlan(plan, path, workspaceRoot = process.cwd()) {
+  validatePushPlan(plan);
+  const target = workspaceWritePath(path, workspaceRoot);
+  mkdirSync6(dirname5(target), { recursive: true });
+  const temp = `${target}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync6(temp, JSON.stringify(plan, null, 2) + "\n", { mode: 384 });
+    renameSync4(temp, target);
+  } catch (error) {
+    try {
+      unlinkSync5(temp);
+    } catch {
+    }
+    throw error;
+  }
+}
+function trackedChangeIdsForSeed(seed, count) {
+  return Array.from(
+    { length: count },
+    (_, index) => `${seed}${(index + 1).toString(16).padStart(6, "0")}`
+  );
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function overleafSnapshotHash(text) {
+  return createHash3("sha1").update(`blob ${text.length}\0`, "utf8").update(text, "utf8").digest("hex");
+}
+function validatePlannedIntent(planned, base, local, live, grouping = reviewGroupingOptions(base, live, {})) {
+  if (sha256(base) !== planned.baseHash) {
+    throw new PushPlanValidationError(`Synchronization base changed for ${planned.docPath}.`);
+  }
+  if (sha256(local) !== planned.localHash) {
+    throw new PushPlanValidationError(`${planned.localPath} changed after planning.`);
+  }
+  if (sha256(live) !== planned.liveHash) {
+    throw new PushPlanValidationError(`${planned.docPath} text changed after planning.`);
+  }
+  const merge = threeWayMerge(base, local, live);
+  if (merge.conflicts.length || merge.text === void 0) {
+    throw new PushPlanValidationError(
+      `${planned.docPath} no longer has the conflict-free intent recorded by the plan.`
+    );
+  }
+  const expected = merge.text;
+  if (stableJson(buildOps(live, expected, grouping)) !== stableJson(planned.ops) || sha256(expected) !== planned.expectedHash) {
+    throw new PushPlanValidationError(
+      `Operations in ${planned.docPath} do not match its saved Base\u2192Local intent.`
+    );
+  }
+  return expected;
+}
+function validateReviewBinding(planned, state, live, expected, allowOverlap, grouping) {
+  if (state.version !== planned.liveVersion) {
+    throw new PushPlanValidationError(
+      `${planned.docPath} version changed from ${planned.liveVersion} to ${state.version}; create a new plan.`
+    );
+  }
+  if (fingerprintRanges(state.ranges) !== planned.rangeFingerprint) {
+    throw new PushPlanValidationError(
+      `${planned.docPath} comments or tracked ranges changed after planning; create a new plan.`
+    );
+  }
+  const footprint = buildOperationFootprint(live, expected, grouping);
+  const activeTrackedRanges = serializeActiveTrackedRanges(state.ranges.changes);
+  const trackedOverlaps = serializeOverlaps(
+    findTrackedChangeOverlaps(state.ranges.changes, footprint)
+  );
+  const commentOverlaps = serializeCommentOverlaps(
+    findCommentOverlaps(state.ranges.comments, footprint)
+  );
+  if (stableJson(activeTrackedRanges) !== stableJson(planned.activeTrackedRanges)) {
+    throw new PushPlanValidationError(
+      `Active tracked-range data is invalid for ${planned.docPath}; create a new plan.`
+    );
+  }
+  if (stableJson(trackedOverlaps) !== stableJson(planned.trackedChangeOverlaps)) {
+    throw new PushPlanValidationError(
+      `Tracked-change overlap data is invalid for ${planned.docPath}; create a new plan.`
+    );
+  }
+  if (trackedOverlaps.length && !allowOverlap) {
+    throw new PushPlanValidationError(
+      `${planned.docPath} operations overlap active tracked changes; create a plan with --allow-overlap only after inspecting them.`
+    );
+  }
+  if (stableJson(commentOverlaps) !== stableJson(planned.commentOverlaps)) {
+    throw new PushPlanValidationError(
+      `Comment-overlap data is invalid for ${planned.docPath}; create a new plan.`
+    );
+  }
+}
+function baseTextForPlan(plan, planned, live, basePath) {
+  if (planned.baseSource === "live-unsafe") {
+    if (!plan.unsafeNoBase) {
+      throw new PushPlanValidationError(`${planned.docPath} uses an unauthorized unsafe base.`);
+    }
+    return live;
+  }
+  const state = loadBaseState(basePath);
+  const saved = state?.projectId === plan.projectId ? state.documents[planned.docId] : void 0;
+  if (!saved || saved.hash !== planned.baseHash || sha256(saved.text) !== planned.baseHash) {
+    throw new PushPlanValidationError(
+      `Synchronization base for ${planned.docPath} changed after planning; create a new plan.`
+    );
+  }
+  return saved.text;
+}
+async function bindPlanDocument(plan, planned, socket, basePath) {
+  let local;
+  try {
+    local = readFileSync6(workspaceReadPath(planned.localPath), "utf8");
+  } catch (error) {
+    throw new PushPlanValidationError(
+      `Cannot read planned local file ${planned.localPath}: ${errorMessage(error)}`
+    );
+  }
+  const state = await joinDoc(socket, planned.docId);
+  const live = state.lines.join("\n");
+  const base = baseTextForPlan(plan, planned, live, basePath);
+  let grouping = reviewGroupingOptions(base, live, state.ranges, plan.direct);
+  if (planned.explicitEdits) grouping = bindExplicitEdits(base, local, live, planned.explicitEdits, grouping);
+  const expected = validatePlannedIntent(planned, base, local, live, grouping);
+  validateReviewBinding(planned, state, live, expected, plan.allowOverlap, grouping);
+  assertTrackedRangeBudget(state.ranges.changes?.length ?? 0, planned.ops.length, plan.direct, planned.docPath);
+  return { plan: planned, state, expected };
+}
+var MAX_TRACKED_RANGES = 2e3;
+function assertTrackedRangeBudget(activeCount, operationCount, direct, docPath) {
+  if (direct || operationCount === 0) return;
+  if (activeCount + operationCount > MAX_TRACKED_RANGES) {
+    throw new PushPlanValidationError(
+      `${docPath}: ${activeCount} active tracked ranges + ${operationCount} proposed operations exceeds the conservative ${MAX_TRACKED_RANGES}-range budget. Overleaf rejects documents with too many tracked changes. Reduce the revision or arrange review of existing suggestions before submitting; smaller batches do not remove accumulated ranges.`
+    );
+  }
+}
+function verifiedTrackedIds(plan, planned, after) {
+  if (plan.direct) return [];
+  const actualIds = new Set((after.ranges.changes ?? []).map((change) => String(change.id)));
+  if (planned.trackedChangeOverlaps.length) {
+    const ids = [...actualIds].filter(
+      (id) => new RegExp(`^${planned.tcSeed}[0-9a-f]{6}$`).test(id)
+    );
+    if (!ids.length) {
+      throw new Error(
+        `Verification failed for ${planned.docPath}: no tracked ranges with seed ${planned.tcSeed} were created.`
+      );
+    }
+    return ids;
+  }
+  const expectedIds = trackedChangeIdsForSeed(planned.tcSeed, planned.ops.length);
+  const missing = expectedIds.filter((id) => !actualIds.has(id));
+  if (missing.length) {
+    throw new Error(
+      `Verification failed for ${planned.docPath}: tracked ranges were not created for ${missing.join(", ")}.`
+    );
+  }
+  return expectedIds;
+}
+function definitelyRejectedApply(error) {
+  const message = errorMessage(error);
+  return message.includes("Overleaf rejected the OT update") || message.includes("Overleaf failed to apply the OT update");
+}
+function initialReceiptDocuments(plan) {
+  return plan.documents.map((doc) => ({
+    docId: doc.docId,
+    docPath: doc.docPath,
+    localPath: doc.localPath,
+    opCount: doc.ops.length,
+    expectedHash: doc.expectedHash,
+    status: "pending",
+    mutationAttempted: false
+  }));
+}
+function pushReceiptNeedsQuarantine(receipt) {
+  if (receipt.status === "ambiguous") return true;
+  if (receipt.status !== "in_progress") return false;
+  const documents = receipt.details?.documents;
+  return Array.isArray(documents) && documents.some(
+    (document) => Boolean(document) && typeof document === "object" && (document.mutationAttempted === true || typeof document.mutationStartedAt === "string")
+  );
+}
+function receiptDocumentIds(receipt) {
+  const documents = receipt.details?.documents;
+  if (!Array.isArray(documents)) return [];
+  return documents.flatMap((document) => {
+    if (!document || typeof document !== "object") return [];
+    const docId = document.docId;
+    return typeof docId === "string" ? [docId] : [];
+  });
+}
+function quarantinedPlanDocuments(plan, receipts) {
+  const plannedIds = new Set(plan.documents.map((document) => document.docId));
+  const disposition = /* @__PURE__ */ new Map();
+  const newestFirst = [...receipts].sort(
+    (a, b) => String(b.receipt.updatedAt ?? "").localeCompare(String(a.receipt.updatedAt ?? ""))
+  );
+  for (const { receipt } of newestFirst) {
+    if (receipt.operation !== "push" || receipt.details?.projectId !== plan.projectId) {
+      continue;
+    }
+    const reconciles = receipt.status === "succeeded" && receipt.details.acknowledgedAmbiguousRetry === true;
+    const quarantines = pushReceiptNeedsQuarantine(receipt);
+    if (!reconciles && !quarantines) continue;
+    for (const docId of receiptDocumentIds(receipt)) {
+      if (plannedIds.has(docId) && !disposition.has(docId)) {
+        disposition.set(docId, reconciles ? "reconciled" : "quarantined");
+      }
+    }
+  }
+  return plan.documents.filter((document) => disposition.get(document.docId) === "quarantined").map((document) => document.docPath);
+}
+function synchronizeLocalAfterRemote(localPath, plannedLocalHash, remoteText, workspaceRoot = process.cwd()) {
+  const localFile = workspaceReadPath(localPath, workspaceRoot);
+  const currentLocal = readFileSync6(localFile, "utf8");
+  if (sha256(currentLocal) !== plannedLocalHash) {
+    throw new Error(`${localPath} changed while the plan was being submitted; local file left untouched.`);
+  }
+  if (currentLocal === remoteText) return {};
+  const timestamp = `${snapshotTimestamp()}-${process.pid}`;
+  const snapshotPath = snapshotRelativePath(timestamp, localPath, workspaceRoot);
+  const snapshotFile = workspaceWritePath(snapshotPath, workspaceRoot);
+  mkdirSync6(dirname5(snapshotFile), { recursive: true });
+  writeFileSync6(snapshotFile, currentLocal, { flag: "wx", mode: 384 });
+  const target = workspaceWritePath(localPath, workspaceRoot);
+  const temp = `${target}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync6(temp, remoteText, { mode: statSync(localFile).mode & 511 });
+    if (sha256(readFileSync6(localFile, "utf8")) !== plannedLocalHash) {
+      throw new Error(`${localPath} changed while the plan was being submitted; local file left untouched.`);
+    }
+    renameSync4(temp, target);
+  } catch (error) {
+    try {
+      unlinkSync5(temp);
+    } catch {
+    }
+    throw error;
+  }
+  return { snapshotPath };
+}
+async function submitPlan(planOrPath, opts = {}) {
+  const plan = typeof planOrPath === "string" ? readPushPlan(planOrPath) : validatePushPlan(planOrPath);
+  const totalOps = plan.documents.reduce((sum, doc) => sum + doc.ops.length, 0);
+  const planHash = sha256(stableJson(plan));
+  const receiptDocuments = initialReceiptDocuments(plan);
+  let receipt = beginReceipt(
+    "push",
+    {
+      projectId: plan.projectId,
+      direct: plan.direct,
+      planCreatedAt: plan.createdAt,
+      planHash,
+      totalOps,
+      phase: "preflight",
+      plan,
+      documents: receiptDocuments
+    },
+    { receiptsDir: opts.receiptsDir }
+  );
+  const completed = [];
+  const basePath = opts.basePath ?? BASE_STATE_PATH;
+  let opened;
+  let mutationLock;
+  let unknownMutationOutcome = false;
+  let failureStatus;
+  try {
+    if (plan.projectId !== config.projectId) {
+      throw new PushPlanValidationError(
+        `Plan is for project ${plan.projectId}, but this repository is linked to ${config.projectId}.`
+      );
+    }
+    mutationLock = acquireMutationLock(plan.projectId);
+    const priorReceipts = readReceipts(opts.receiptsDir);
+    const quarantinedDocuments = quarantinedPlanDocuments(plan, priorReceipts);
+    if (quarantinedDocuments.length && !opts.allowAmbiguousRetry) {
+      throw new PushPlanValidationError(
+        `A prior push has an unresolved outcome for: ${quarantinedDocuments.join(", ")}. Wait for delayed updates, inspect Overleaf and its receipt, then create a fresh plan. Only after manual reconciliation may you submit with --acknowledge-ambiguous.`
+      );
+    }
+    if (!plan.documents.length) {
+      receipt = updateReceipt(receipt, "skipped", {
+        phase: "complete",
+        outcome: "empty_plan",
+        documents: receiptDocuments
+      });
+      return {
+        projectId: plan.projectId,
+        direct: plan.direct,
+        totalOps,
+        documents: completed,
+        receiptPath: receipt.path
+      };
+    }
+    opened = await openProject();
+    const { socket, project, docs } = opened;
+    const connectedProjectId = String(project?._id ?? config.projectId);
+    if (connectedProjectId !== plan.projectId) {
+      throw new PushPlanValidationError(
+        `Connected project ${connectedProjectId} does not match plan ${plan.projectId}.`
+      );
+    }
+    const docsById = new Map(docs.map((doc) => [doc._id, doc]));
+    for (const planned of plan.documents) {
+      const doc = docsById.get(planned.docId);
+      if (!doc || doc.path !== planned.docPath) {
+        throw new PushPlanValidationError(
+          `Document ${planned.docPath} (${planned.docId}) no longer exists at its planned path.`
+        );
+      }
+    }
+    for (const planned of plan.documents) {
+      await bindPlanDocument(plan, planned, socket, basePath);
+    }
+    receipt = updateReceipt(receipt, "in_progress", {
+      phase: "applying",
+      preflightVerifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...opts.allowAmbiguousRetry && quarantinedDocuments.length ? {
+        acknowledgedAmbiguousRetry: true,
+        reconciledAmbiguousDocuments: quarantinedDocuments
+      } : {},
+      documents: receiptDocuments
+    });
+    for (let index = 0; index < plan.documents.length; index++) {
+      const planned = plan.documents[index];
+      const { state, expected } = await bindPlanDocument(
+        plan,
+        planned,
+        socket,
+        basePath
+      );
+      receiptDocuments[index] = {
+        ...receiptDocuments[index],
+        status: "applying",
+        mutationAttempted: true,
+        mutationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      receipt = updateReceipt(receipt, "in_progress", {
+        phase: "applying",
+        currentDocument: planned.docPath,
+        documents: receiptDocuments
+      });
+      unknownMutationOutcome = true;
+      let applyError;
+      try {
+        await applyOtUpdateAndWait(socket, planned.docId, {
+          doc: planned.docId,
+          op: planned.ops,
+          v: state.version,
+          meta: plan.direct ? {} : { tc: planned.tcSeed },
+          hash: overleafSnapshotHash(expected)
+        });
+      } catch (error) {
+        applyError = error;
+      }
+      let after;
+      try {
+        after = await joinDoc(socket, planned.docId);
+      } catch (readbackError) {
+        const definitelyRejected = Boolean(applyError && definitelyRejectedApply(applyError));
+        failureStatus = definitelyRejected ? "failed" : "ambiguous";
+        unknownMutationOutcome = !definitelyRejected;
+        receiptDocuments[index] = {
+          ...receiptDocuments[index],
+          status: failureStatus,
+          ...applyError ? { transportError: errorMessage(applyError) } : {},
+          error: `Readback failed: ${errorMessage(readbackError)}`
+        };
+        throw new Error(
+          `${planned.docPath} could not be verified after its update: ${errorMessage(readbackError)}`
+        );
+      }
+      const afterText = after.lines.join("\n");
+      if (afterText !== expected || sha256(afterText) !== planned.expectedHash) {
+        const definitelyRejected = Boolean(applyError && definitelyRejectedApply(applyError));
+        failureStatus = definitelyRejected ? "failed" : "ambiguous";
+        unknownMutationOutcome = !definitelyRejected;
+        receiptDocuments[index] = {
+          ...receiptDocuments[index],
+          status: failureStatus,
+          afterVersion: after.version,
+          ...applyError ? { transportError: errorMessage(applyError) } : {},
+          error: "Overleaf text does not match the planned result"
+        };
+        throw new Error(
+          `Verification failed for ${planned.docPath}: Overleaf text does not match the planned result.`
+        );
+      }
+      let trackedChangeIds;
+      try {
+        trackedChangeIds = verifiedTrackedIds(plan, planned, after);
+      } catch (error) {
+        const ambiguousTransport = Boolean(applyError && !definitelyRejectedApply(applyError));
+        unknownMutationOutcome = ambiguousTransport;
+        failureStatus = ambiguousTransport ? "ambiguous" : "failed";
+        receiptDocuments[index] = {
+          ...receiptDocuments[index],
+          status: failureStatus,
+          afterVersion: after.version,
+          ...applyError ? { transportError: errorMessage(applyError) } : {},
+          error: errorMessage(error)
+        };
+        throw error;
+      }
+      unknownMutationOutcome = false;
+      try {
+        const localSync = synchronizeLocalAfterRemote(
+          planned.localPath,
+          planned.localHash,
+          afterText
+        );
+        if (localSync.snapshotPath) {
+          receiptDocuments[index] = {
+            ...receiptDocuments[index],
+            localSnapshotPath: localSync.snapshotPath
+          };
+        }
+        const base = {
+          docId: planned.docId,
+          path: planned.docPath,
+          text: afterText,
+          hash: planned.expectedHash,
+          version: after.version,
+          rangeFingerprint: fingerprintRanges(after.ranges),
+          fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        mergeBaseDocuments(plan.projectId, [base], basePath);
+      } catch (error) {
+        failureStatus = "failed";
+        receiptDocuments[index] = {
+          ...receiptDocuments[index],
+          status: "remote_verified_local_failed",
+          afterVersion: after.version,
+          trackedChangeIds,
+          ...applyError ? { transportError: errorMessage(applyError) } : {},
+          error: errorMessage(error)
+        };
+        throw new Error(
+          `${planned.docPath} was verified on Overleaf, but local synchronization failed: ` + errorMessage(error)
+        );
+      }
+      const result = {
+        docId: planned.docId,
+        docPath: planned.docPath,
+        version: after.version,
+        hash: planned.expectedHash,
+        trackedChangeIds
+      };
+      completed.push(result);
+      receiptDocuments[index] = {
+        ...receiptDocuments[index],
+        status: "verified",
+        verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        afterVersion: after.version,
+        trackedChangeIds,
+        ...applyError ? { transportError: errorMessage(applyError) } : {}
+      };
+      receipt = updateReceipt(receipt, "in_progress", {
+        phase: "applying",
+        completedDocuments: completed.map((doc) => doc.docPath),
+        documents: receiptDocuments
+      });
+    }
+    receipt = updateReceipt(receipt, "succeeded", {
+      phase: "complete",
+      verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      completedDocuments: completed.map((doc) => doc.docPath),
+      documents: receiptDocuments
+    });
+    return {
+      projectId: plan.projectId,
+      direct: plan.direct,
+      totalOps,
+      documents: completed,
+      receiptPath: receipt.path
+    };
+  } catch (error) {
+    const status = failureStatus ?? (unknownMutationOutcome ? "ambiguous" : "failed");
+    receipt = updateReceipt(receipt, status, {
+      phase: status === "ambiguous" ? "mutation_outcome_unknown" : "failed",
+      failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      error: errorMessage(error),
+      completedDocuments: completed.map((doc) => doc.docPath),
+      documents: receiptDocuments
+    });
+    throw new PushSubmissionError(
+      `${errorMessage(error)} Audit receipt: ${receipt.path}`,
+      receipt.path,
+      status,
+      receiptDocuments,
+      error
+    );
+  } finally {
+    try {
+      opened?.socket.close();
+    } finally {
+      mutationLock?.release();
+    }
+  }
+}
+function printPlan(plan) {
+  console.log(
+    plan.direct ? "Mode: DIRECT \u2014 plain edits (not marked as suggestions)" : "Mode: SUGGESTIONS \u2014 tracked changes for co-authors to accept/reject"
+  );
+  for (const doc of plan.documents) {
+    const ins = doc.ops.filter((op) => op.i != null).length;
+    const del = doc.ops.filter((op) => op.d != null).length;
+    console.log(
+      `
+${doc.localPath} \u2192 ${doc.docPath} (v${doc.liveVersion}): ${doc.ops.length} op(s), ${ins} ins / ${del} del`
+    );
+    if (!plan.direct) {
+      console.log(
+        `  Tracked-range budget: ${doc.activeTrackedRanges.length} existing + ${doc.ops.length} proposed operations / ${MAX_TRACKED_RANGES}. A phrase replacement uses one deletion and one insertion.`
+      );
+    }
+    for (const op of doc.ops.slice(0, 12)) console.log(preview(op));
+    if (doc.ops.length > 12) console.log(`  \u2026 and ${doc.ops.length - 12} more`);
+    for (const overlap of doc.commentOverlaps) {
+      console.log(
+        `  \u2139\uFE0F  touches comment ${overlap.threadId} @ ${overlap.position}: ${JSON.stringify(overlap.anchor)}`
+      );
+    }
+  }
+}
+async function push(opts) {
+  validatePushOptions(opts);
+  const { isReviewedManifest, createReviewedFilePlan, applyReviewedFilePlan, REVIEWED_FILE_KIND } = await import("./reviewed-replace-A7C4UNJS.js");
+  if (opts.edits && isReviewedManifest(JSON.parse(readFileSync6(workspaceReadPath(opts.edits), "utf8")))) {
+    await createReviewedFilePlan(opts);
+    return;
+  }
+  if (opts.plan) {
+    const supplied = typeof opts.plan === "string" ? JSON.parse(readFileSync6(workspaceReadPath(opts.plan), "utf8")) : opts.plan;
+    if (supplied?.kind === REVIEWED_FILE_KIND) {
+      await applyReviewedFilePlan(supplied, opts);
+      return;
+    }
+    const result2 = await submitPlan(opts.plan, {
+      basePath: opts.basePath,
+      receiptsDir: opts.receiptsDir,
+      allowAmbiguousRetry: opts.allowAmbiguousRetry
+    });
+    console.log(
+      `\u2705 Submitted and verified ${result2.totalOps} ${result2.direct ? "direct edit(s)" : "tracked suggestion(s)"} across ${result2.documents.length} file(s).`
+    );
+    console.log(`Audit receipt: ${result2.receiptPath}`);
+    return;
+  }
+  const plan = await createPlan(opts);
+  if (!plan.documents.length) {
+    console.log("Nothing to push \u2014 no unapplied local edits were found.");
+    if (opts.planOut) console.log(`Saved empty plan to ${opts.planOut}.`);
+    return;
+  }
+  printPlan(plan);
+  if (opts.planOut) {
+    console.log(`
+Saved binding plan to ${opts.planOut}; nothing sent to Overleaf.`);
+    return;
+  }
+  if (opts.dryRun) {
+    console.log("\n(dry run \u2014 nothing sent to Overleaf)");
+    return;
+  }
+  const result = await submitPlan(plan, {
+    basePath: opts.basePath,
+    receiptsDir: opts.receiptsDir,
+    allowAmbiguousRetry: opts.allowAmbiguousRetry
+  });
+  console.log(
+    `
+\u2705 Pushed and verified ${result.totalOps} ${result.direct ? "direct edit(s)" : "tracked suggestion(s)"} across ${result.documents.length} file(s).`
+  );
+  console.log(`Audit receipt: ${result.receiptPath}`);
+}
+
+// src/lib/consolidation.ts
+function checkedSnapshot(value) {
+  const snapshot = value;
+  if (!snapshot || typeof snapshot.projectId !== "string" || !snapshot.projectId || typeof snapshot.docId !== "string" || !snapshot.docId || typeof snapshot.docPath !== "string" || !Number.isSafeInteger(snapshot.version) || snapshot.version < 0 || typeof snapshot.text !== "string" || !Array.isArray(snapshot.ranges?.changes) || !Array.isArray(snapshot.ranges?.comments) || !snapshot.threads || typeof snapshot.threads !== "object" || Array.isArray(snapshot.threads)) throw new Error("Consolidation requires a full document snapshot: projectId, docId, docPath, version, text, ranges and threads.");
+  for (const range of snapshot.ranges.changes) {
+    const op = range?.op;
+    if (typeof range?.id !== "string" || !range.id || !op || !Number.isSafeInteger(op.p) || op.p < 0 || op.p > snapshot.text.length || typeof op.i === "string" === (typeof op.d === "string") || !(op.i ?? op.d)?.length || typeof op.i === "string" && snapshot.text.slice(op.p, op.p + op.i.length) !== op.i) throw new Error("Snapshot contains an invalid or stale tracked range.");
+  }
+  for (const range of snapshot.ranges.comments) {
+    const op = range?.op;
+    if (!op || !Number.isSafeInteger(op.p) || op.p < 0 || op.p > snapshot.text.length || typeof op.c !== "string" || typeof op.t !== "string" || snapshot.text.slice(op.p, op.p + op.c.length) !== op.c) throw new Error("Snapshot contains an invalid or stale comment anchor.");
+  }
+  return snapshot;
+}
+function touches(start, end, range) {
+  return start <= range.end && range.start <= end;
+}
+function protectedRanges(snapshot, selected) {
+  const ranges = [
+    ...snapshot.ranges.changes.filter((range) => !selected.has(range.id)).map((range) => ({
+      start: range.op.p,
+      end: range.op.p + (range.op.i?.length ?? 0),
+      kind: "unselected-change",
+      id: range.id
+    })),
+    ...snapshot.ranges.comments.map((range) => ({
+      start: range.op.p,
+      end: range.op.p + range.op.c.length,
+      kind: "comment",
+      id: range.op.t
+    }))
+  ];
+  return ranges.map((range) => ({ ...range, originalStart: range.start, originalEnd: range.end }));
+}
+function planConsolidation(value, authorId, requestedIds) {
+  const snapshot = structuredClone(checkedSnapshot(value));
+  if (!authorId) throw new Error("Choose the author id whose suggestions should be consolidated.");
+  const selectedIds = [...new Set(requestedIds ?? snapshot.ranges.changes.filter((range) => range.metadata?.user_id === authorId).map((range) => range.id))];
+  if (!selectedIds.length) throw new Error("No tracked changes match the selected author.");
+  const selected = new Set(selectedIds);
+  for (const id of selected) {
+    const fragments = snapshot.ranges.changes.filter((range) => range.id === id);
+    if (!fragments.length) throw new Error(`Tracked change ${id} is absent from the snapshot.`);
+    if (fragments.some((range) => range.metadata?.user_id !== authorId)) {
+      throw new Error(`Tracked change ${id} includes a different or unknown author.`);
+    }
+  }
+  const undo = buildRejectionPlan(snapshot.text, snapshot.ranges.changes, selectedIds);
+  const protectedState = protectedRanges(snapshot, selected);
+  const blockers = [];
+  for (const op of undo.operations) {
+    for (const range of protectedState) {
+      if (touches(op.p, op.p + ("d" in op ? op.d.length : 0), range)) {
+        blockers.push({ kind: range.kind, id: range.id, phase: "undo" });
+      }
+      const offset = "i" in op ? op.i.length : -op.d.length;
+      if (op.p < range.start) {
+        range.start += offset;
+        range.end += offset;
+      }
+    }
+  }
+  const grouping = { protectedSpans: protectedState };
+  const reapply = buildOps(undo.expectedText, snapshot.text, grouping);
+  const footprint = buildOperationFootprint(undo.expectedText, snapshot.text, grouping);
+  for (const edit of footprint) {
+    for (const range of protectedState) {
+      if (touches(edit.start, edit.end, range)) {
+        blockers.push({ kind: range.kind, id: range.id, phase: "reapply" });
+      }
+    }
+  }
+  if (applyOps(undo.expectedText, reapply) !== snapshot.text) {
+    throw new Error("Grouped revisions do not reconstruct the proposed text.");
+  }
+  const newRanges = [];
+  let delta = 0;
+  for (const [index, edit] of footprint.entries()) {
+    const p = edit.start + delta;
+    const deleted = undo.expectedText.slice(edit.start, edit.end);
+    if (edit.text) newRanges.push({ id: `preview-insert-${index}`, op: { p, i: edit.text } });
+    if (deleted) newRanges.push({ id: `preview-delete-${index}`, op: { p: p + edit.text.length, d: deleted } });
+    delta += edit.text.length - deleted.length;
+  }
+  const reconstructed = buildRejectionPlan(snapshot.text, newRanges, newRanges.map((range) => range.id));
+  if (reconstructed.expectedText !== undo.expectedText) {
+    throw new Error("Grouped revisions do not preserve the text beneath the selected suggestions.");
+  }
+  const beforeCount = snapshot.ranges.changes.length;
+  const projectedCount = beforeCount - undo.fragmentCount + reapply.length;
+  const uniqueBlockers = [...new Map(blockers.map((blocker) => [JSON.stringify(blocker), blocker])).values()];
+  return {
+    kind: "overleaf-review-consolidation-plan",
+    schemaVersion: 2,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: uniqueBlockers.length ? "blocked" : projectedCount >= beforeCount ? "no-reduction" : "ready",
+    authorId,
+    selectedIds,
+    beforeCount,
+    selectedFragmentCount: undo.fragmentCount,
+    projectedCount,
+    projectedReduction: beforeCount - projectedCount,
+    blockers: uniqueBlockers,
+    binding: {
+      projectId: snapshot.projectId,
+      docId: snapshot.docId,
+      version: snapshot.version,
+      textHash: sha256(snapshot.text),
+      rangeFingerprint: fingerprintRanges(snapshot.ranges),
+      threadsHash: sha256(stableJson(snapshot.threads))
+    },
+    textProof: {
+      proposedHash: sha256(snapshot.text),
+      selectedRejectedHash: sha256(undo.expectedText),
+      selectedRejectedText: undo.expectedText,
+      forwardVerified: true,
+      reverseVerified: true
+    },
+    candidate: uniqueBlockers.length ? null : { undo: undo.operations, reapply },
+    backup: snapshot,
+    limitations: [
+      "Only review consolidate --apply accepts this artifact; review submit does not.",
+      "Preserves the current pending proposal, not an earlier historical review state.",
+      "Projected count assumes isolated ranges; server transformations need sandbox verification.",
+      "Consolidation would create new change IDs and timestamps for the selected author."
+    ]
+  };
+}
+function validateConsolidationPlan(value) {
+  const plan = value;
+  if (!plan || plan.kind !== "overleaf-review-consolidation-plan" || plan.schemaVersion !== 2 || !Array.isArray(plan.selectedIds) || !plan.selectedIds.every((id) => typeof id === "string") || typeof plan.authorId !== "string" || typeof plan.createdAt !== "string") {
+    throw new Error("Unsupported consolidation plan; create a new plan.");
+  }
+  const expected = planConsolidation(plan.backup, plan.authorId, plan.selectedIds);
+  if (stableJson({ ...plan, createdAt: "" }) !== stableJson({ ...expected, createdAt: "" })) {
+    throw new Error("Consolidation plan was altered or cannot be reproduced from its backup.");
+  }
+  if (plan.status !== "ready" || !plan.candidate || plan.projectedCount > MAX_TRACKED_RANGES) {
+    throw new Error("Consolidation is blocked, does not reduce ranges, or exceeds the range budget.");
+  }
+  rejectedText(plan.backup);
+  return plan;
+}
+function rejectedText(snapshot) {
+  return buildRejectionPlan(
+    snapshot.text,
+    snapshot.ranges.changes,
+    snapshot.ranges.changes.map((range) => range.id)
+  ).expectedText;
+}
+function assertConsolidationBinding(plan, live) {
+  checkedSnapshot(live);
+  if (live.projectId !== plan.backup.projectId || live.docId !== plan.backup.docId || live.docPath !== plan.backup.docPath || live.version !== plan.backup.version || live.text !== plan.backup.text || stableJson(live.ranges) !== stableJson(plan.backup.ranges) || stableJson(live.threads) !== stableJson(plan.backup.threads)) {
+    throw new Error("Document, version, review ranges or threads changed after consolidation planning; re-plan.");
+  }
+}
+function verifyConsolidation(plan, value, seed) {
+  const after = checkedSnapshot(value);
+  const before = plan.backup;
+  if (!/^[0-9a-f]{18}$/.test(seed) || after.projectId !== before.projectId || after.docId !== before.docId || after.docPath !== before.docPath || after.version !== before.version + 1 || after.text !== before.text) {
+    throw new Error("Consolidation text, identity or document version failed verification.");
+  }
+  const selected = new Set(plan.selectedIds);
+  if (after.ranges.changes.some((range) => selected.has(range.id))) throw new Error("Old tracked-change IDs remain after consolidation.");
+  const originalOther = before.ranges.changes.filter((range) => !selected.has(range.id));
+  const otherIds = new Set(originalOther.map((range) => range.id));
+  const actualOther = after.ranges.changes.filter((range) => otherIds.has(range.id));
+  const fresh = after.ranges.changes.filter((range) => !otherIds.has(range.id));
+  const canonical = (ranges) => stableJson(ranges.map((range) => stableJson(range)).sort());
+  if (canonical(originalOther) !== canonical(actualOther) || canonical(before.ranges.comments) !== canonical(after.ranges.comments) || stableJson(before.threads) !== stableJson(after.threads)) {
+    throw new Error("Comments, threads or unselected suggestions changed during consolidation.");
+  }
+  if (fresh.some((range) => !new RegExp(`^${seed}[0-9a-f]{6}$`).test(range.id) || range.metadata?.user_id !== plan.authorId) || after.ranges.changes.length > plan.projectedCount || after.ranges.changes.length >= plan.beforeCount) {
+    throw new Error("Consolidated range count or author attribution failed verification.");
+  }
+  const changeIds = [...new Set(fresh.map((range) => range.id))];
+  if (buildRejectionPlan(after.text, after.ranges.changes, changeIds).expectedText !== plan.textProof.selectedRejectedText || rejectedText(after) !== rejectedText(before)) {
+    throw new Error("Consolidation changed the text beneath pending suggestions.");
+  }
+  return { changeIds, rangeCount: after.ranges.changes.length };
+}
+
+// src/lib/consolidation-submit.ts
+async function submitConsolidation(value, transport) {
+  const plan = validateConsolidationPlan(value);
+  const planHash = sha256(stableJson(plan));
+  const options = { receiptsDir: transport.receiptsDir };
+  const relevant = readReceipts(transport.receiptsDir).filter((handle) => handle.receipt.operation === "consolidate" && handle.receipt.details.projectId === plan.binding.projectId && handle.receipt.details.docId === plan.binding.docId);
+  const uncertain = relevant.find((handle) => handle.receipt.status === "ambiguous" || handle.receipt.status === "in_progress");
+  if (uncertain) {
+    throw new Error(`Earlier consolidation has an uncertain outcome. Inspect and reconcile ${uncertain.path}; no automatic retry was sent.`);
+  }
+  const prior = relevant.find((handle) => handle.receipt.status === "succeeded" && handle.receipt.details.planHash === planHash);
+  if (prior) return { receiptPath: prior.path, alreadyApplied: true };
+  let receipt = beginReceipt("consolidate", {
+    projectId: plan.binding.projectId,
+    docId: plan.binding.docId,
+    docPath: plan.backup.docPath,
+    planHash,
+    plan,
+    phase: "preflight"
+  }, options);
+  let attempted = false;
+  try {
+    if (await transport.accountId() !== plan.authorId) {
+      throw new Error("Consolidation can only reapply suggestions belonging to the authenticated account.");
+    }
+    const before = await transport.snapshot();
+    assertConsolidationBinding(plan, before);
+    const seed = createTrackedChangeSeed();
+    if (before.ranges.changes.some((range) => range.id.startsWith(seed))) {
+      throw new Error("Tracked-change seed collision; create a fresh consolidation attempt.");
+    }
+    const update = {
+      doc: before.docId,
+      v: before.version,
+      op: [...plan.candidate.undo, ...plan.candidate.reapply],
+      meta: { tc: seed },
+      hash: overleafSnapshotHash(before.text)
+    };
+    receipt = updateReceipt(receipt, "in_progress", {
+      phase: "sending",
+      before,
+      seed,
+      update,
+      mutationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    attempted = true;
+    await transport.send(update);
+    const after = await transport.snapshot();
+    receipt = updateReceipt(receipt, "in_progress", { phase: "verifying", after });
+    const result = verifyConsolidation(plan, after, seed);
+    receipt = updateReceipt(receipt, "succeeded", { phase: "complete", result });
+    return { receiptPath: receipt.path, alreadyApplied: false, ...result };
+  } catch (error) {
+    receipt = updateReceipt(receipt, attempted ? "ambiguous" : "failed", {
+      phase: attempted ? "outcome_unknown" : "preflight_failed",
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw new Error(`${error instanceof Error ? error.message : String(error)}. Receipt: ${receipt.path}. ` + (attempted ? "Do not retry or auto-rollback; inspect live review state and the saved backup first." : "Nothing sent."), { cause: error });
+  }
+}
+
+// src/commands/consolidate.ts
+async function readConsolidationSnapshot(opened, doc) {
+  if (String(opened.project?._id) !== config.projectId) throw new Error("Connected project identity could not be verified.");
+  const before = await joinDoc(opened.socket, doc._id);
+  const threads = await getThreads();
+  const after = await joinDoc(opened.socket, doc._id);
+  const afterThreads = await getThreads();
+  if (before.version !== after.version || before.lines.join("\n") !== after.lines.join("\n") || stableJson(before.ranges) !== stableJson(after.ranges) || stableJson(threads) !== stableJson(afterThreads)) {
+    throw new Error("The document or review state changed during snapshot capture.");
+  }
+  return {
+    projectId: config.projectId,
+    docId: doc._id,
+    docPath: doc.path,
+    version: after.version,
+    text: after.lines.join("\n"),
+    ranges: { changes: after.ranges.changes ?? [], comments: after.ranges.comments ?? [] },
+    threads: afterThreads
+  };
+}
+async function consolidateApply(path) {
+  const plan = validateConsolidationPlan(JSON.parse(readFileSync7(workspaceReadPath(path), "utf8")));
+  if (config.projectId !== plan.binding.projectId) throw new Error("Consolidation plan belongs to a different project.");
+  const lock = acquireMutationLock(config.projectId);
+  let opened;
+  try {
+    opened = await openProject();
+    const project = opened;
+    const doc = project.docs.find((doc2) => doc2._id === plan.binding.docId && doc2.path === plan.backup.docPath);
+    if (!doc) throw new Error("Planned consolidation document is absent or renamed.");
+    const result = await submitConsolidation(plan, {
+      accountId: getAuthenticatedUserId,
+      snapshot: () => readConsolidationSnapshot(project, doc),
+      send: (update) => applyOtUpdateAndWait(project.socket, doc._id, update)
+    });
+    console.log(result.alreadyApplied ? "This consolidation plan was already applied; nothing resent." : `Verified consolidation: ${plan.beforeCount} \u2192 ${result.rangeCount} tracked ranges. Both text views and protected review state preserved.`);
+    console.log(`Audit receipt and backup: ${result.receiptPath}`);
+  } finally {
+    try {
+      opened?.socket.close();
+    } finally {
+      lock.release();
+    }
+  }
+}
+async function consolidatePreview(options) {
+  let snapshot;
+  if (options.snapshot) {
+    snapshot = JSON.parse(readFileSync7(workspaceReadPath(options.snapshot), "utf8"));
+  } else {
+    if (!options.doc) throw new Error("Consolidation requires --doc or --snapshot.");
+    const projectId = config.projectId;
+    const lock = acquireMutationLock(projectId);
+    let opened;
+    try {
+      opened = await openProject();
+      const doc = matchDocument(options.doc, opened.docs);
+      if (!doc) throw new Error(`Document not found: ${options.doc}`);
+      snapshot = await readConsolidationSnapshot(opened, doc);
+    } finally {
+      try {
+        opened?.socket.close();
+      } finally {
+        lock.release();
+      }
+    }
+  }
+  const plan = planConsolidation(snapshot, options.author, options.changeIds);
+  writeJsonAtomic(workspaceWritePath(options.out), plan);
+  console.log(`Consolidation dry run for ${snapshot.docPath}: ${plan.status}`);
+  console.log(`Tracked ranges: ${plan.beforeCount} \u2192 ${plan.projectedCount} projected (${plan.selectedFragmentCount} selected).`);
+  for (const blocker of plan.blockers) {
+    console.log(`  Blocked by ${blocker.kind} ${blocker.id} during ${blocker.phase}.`);
+  }
+  console.log(`Full backup and text proofs saved to ${options.out}.`);
+  console.log("Nothing sent to Overleaf. Inspect the plan before review consolidate --apply --plan <file>.");
+}
+
+export {
+  saveCredentials,
+  saveProjectConfig,
+  config,
+  openProject,
+  joinDoc,
+  applyOtUpdateAndWait,
+  getCsrfToken,
+  getThreads,
+  RestRequestError,
+  threadMessages,
+  threadMessageId,
+  findRecentIdenticalMessage,
+  observePostedThreadMessage,
+  postThreadMessageDetailed,
+  setThreadResolved,
+  acceptChanges,
+  uploadFile,
+  deleteMessage,
+  deleteThread,
+  validateSession,
+  getAuthenticatedUserId,
+  workspaceRelativePath,
+  workspaceReadPath,
+  workspaceWritePath,
+  acquireMutationLock,
+  parseReplacementManifest,
+  bindExplicitEdits,
+  matchDocument,
+  writeJsonAtomic,
+  beginReceipt,
+  updateReceipt,
+  readReceipts,
+  BASE_STATE_PATH,
+  sha256,
+  stableJson,
+  fingerprintRanges,
+  loadBaseState,
+  mergeBaseDocuments,
+  createTrackedChangeSeed,
+  TrackedChangeMutationError,
+  uniqueChangeIds,
+  remainingChangeIds,
+  buildRejectionPlan,
+  SNAPSHOTS_DIR,
+  snapshotTimestamp,
+  snapshotRelativePath,
+  checkedSnapshot,
+  readConsolidationSnapshot,
+  consolidateApply,
+  consolidatePreview,
+  applyOps,
+  overleafSnapshotHash,
+  MAX_TRACKED_RANGES,
+  synchronizeLocalAfterRemote,
+  push
+};