tandem-editor 0.1.2 → 0.2.0

package/dist/server/index.js

@@ -1550,9 +1550,138 @@ var init_types2 = __esm({
   }
 });
 
+// src/server/file-io/docx-walker.ts
+import { parseDocument as parseDocument2 } from "htmlparser2";
+function isElement2(node) {
+  return node.type === "tag";
+}
+function getAttr(el, name) {
+  return el.attribs?.[name];
+}
+function getTextContent(node) {
+  if (node.type === "text") return node.data;
+  if (!isElement2(node)) return "";
+  return node.children.map(getTextContent).join("");
+}
+function findAllByName(name, nodes) {
+  const results = [];
+  for (const node of nodes) {
+    if (isElement2(node)) {
+      if (node.name === name) results.push(node);
+      results.push(...findAllByName(name, node.children));
+    }
+  }
+  return results;
+}
+function detectHeadingLevel(paragraph) {
+  for (const child of paragraph.children) {
+    if (!isElement2(child) || child.name !== "w:pPr") continue;
+    for (const prop of child.children) {
+      if (!isElement2(prop) || prop.name !== "w:pStyle") continue;
+      const val = getAttr(prop, "w:val") || "";
+      const match = val.match(/^heading\s*(\d)$/i);
+      if (match) {
+        const level = parseInt(match[1], 10);
+        if (level >= 1 && level <= 6) return level;
+      }
+    }
+  }
+  return 0;
+}
+function walkDocumentBody(xml, callbacks = {}) {
+  const doc = parseDocument2(xml, { xmlMode: true });
+  let offset = 0;
+  let firstParagraph = true;
+  const textParts = [];
+  let currentParagraph;
+  let currentParagraphId;
+  let currentRun;
+  function walk(nodes) {
+    for (const node of nodes) {
+      if (!isElement2(node)) continue;
+      if (node.name === "w:p") {
+        if (!firstParagraph) {
+          offset += 1;
+          textParts.push("\n");
+        }
+        firstParagraph = false;
+        const prevParagraph = currentParagraph;
+        const prevParagraphId = currentParagraphId;
+        currentParagraph = node;
+        currentParagraphId = getAttr(node, "w14:paraId");
+        const headingLevel = detectHeadingLevel(node);
+        if (headingLevel > 0) {
+          const prefixLen = headingPrefixLength(headingLevel);
+          offset += prefixLen;
+          textParts.push("#".repeat(headingLevel) + " ");
+        }
+        walk(node.children);
+        currentParagraph = prevParagraph;
+        currentParagraphId = prevParagraphId;
+      } else if (node.name === "w:del") {
+      } else if (node.name === "w:commentRangeStart") {
+        const id = getAttr(node, "w:id");
+        if (id) {
+          callbacks.onCommentStart?.({
+            commentId: id,
+            offset,
+            paragraph: currentParagraph,
+            paragraphId: currentParagraphId
+          });
+        }
+      } else if (node.name === "w:commentRangeEnd") {
+        const id = getAttr(node, "w:id");
+        if (id) {
+          callbacks.onCommentEnd?.(id, offset);
+        }
+      } else if (node.name === "w:instrText") {
+      } else if (node.name === "w:t") {
+        const text = getTextContent(node);
+        if (callbacks.onText && currentRun && currentParagraph) {
+          callbacks.onText({
+            run: currentRun,
+            textNode: node,
+            offsetStart: offset,
+            text,
+            paragraph: currentParagraph,
+            paragraphId: currentParagraphId
+          });
+        }
+        offset += text.length;
+        textParts.push(text);
+      } else if (SINGLE_CHAR_ELEMENTS.has(node.name)) {
+        offset += 1;
+        textParts.push(" ");
+      } else if (node.name === "w:r") {
+        const prevRun = currentRun;
+        currentRun = node;
+        walk(node.children);
+        currentRun = prevRun;
+      } else {
+        walk(node.children);
+      }
+    }
+  }
+  const bodyElements = findAllByName("w:body", doc.children);
+  if (bodyElements.length === 0) {
+    return { totalLength: 0, flatText: "" };
+  }
+  walk(bodyElements[0].children);
+  const flatText = textParts.join("");
+  return { totalLength: offset, flatText };
+}
+var SINGLE_CHAR_ELEMENTS;
+var init_docx_walker = __esm({
+  "src/server/file-io/docx-walker.ts"() {
+    "use strict";
+    init_offsets();
+    SINGLE_CHAR_ELEMENTS = /* @__PURE__ */ new Set(["w:tab", "w:br", "w:noBreakHyphen", "w:softHyphen", "w:sym"]);
+  }
+});
+
 // src/server/file-io/docx-comments.ts
 import JSZip from "jszip";
-import { parseDocument as parseDocument2 } from "htmlparser2";
+import { parseDocument as parseDocument3 } from "htmlparser2";
 async function extractDocxComments(buffer3) {
   const zip = await JSZip.loadAsync(buffer3);
   const commentsXml = await zip.file("word/comments.xml")?.async("text");
@@ -1583,7 +1712,7 @@ async function extractDocxComments(buffer3) {
   return result;
 }
 function parseCommentMetadata(xml) {
-  const doc = parseDocument2(xml, { xmlMode: true });
+  const doc = parseDocument3(xml, { xmlMode: true });
   const map = /* @__PURE__ */ new Map();
   for (const comment of findAllByName("w:comment", doc.children)) {
     const id = getAttr(comment, "w:id");
@@ -1597,49 +1726,22 @@ function parseCommentMetadata(xml) {
   return map;
 }
 function calculateCommentRanges(xml) {
-  const doc = parseDocument2(xml, { xmlMode: true });
   const ranges = /* @__PURE__ */ new Map();
   const openRanges = /* @__PURE__ */ new Map();
-  let offset = 0;
-  let firstParagraph = true;
-  function walk(nodes) {
-    for (const node of nodes) {
-      if (!isElement2(node)) continue;
-      if (node.name === "w:p") {
-        if (!firstParagraph) offset += 1;
-        firstParagraph = false;
-        const headingLevel = detectHeadingLevel(node);
-        if (headingLevel > 0) {
-          offset += headingPrefixLength(headingLevel);
-        }
-        walk(node.children);
-      } else if (node.name === "w:commentRangeStart") {
-        const id = getAttr(node, "w:id");
-        if (id) openRanges.set(id, offset);
-      } else if (node.name === "w:commentRangeEnd") {
-        const id = getAttr(node, "w:id");
-        if (id && openRanges.has(id)) {
-          ranges.set(id, { from: toFlatOffset(openRanges.get(id)), to: toFlatOffset(offset) });
-          openRanges.delete(id);
-        }
-      } else if (node.name === "w:t") {
-        const text = getTextContent(node);
-        offset += text.length;
-      } else if (node.name === "w:tab" || node.name === "w:br") {
-        offset += 1;
-      } else {
-        walk(node.children);
+  walkDocumentBody(xml, {
+    onCommentStart({ commentId, offset }) {
+      openRanges.set(commentId, offset);
+    },
+    onCommentEnd(commentId, offset) {
+      if (openRanges.has(commentId)) {
+        ranges.set(commentId, {
+          from: toFlatOffset(openRanges.get(commentId)),
+          to: toFlatOffset(offset)
+        });
+        openRanges.delete(commentId);
       }
     }
-  }
-  const bodyElements = findAllByName("w:body", doc.children);
-  if (bodyElements.length === 0) {
-    console.error(
-      "[docx-comments] No <w:body> found in document.xml \u2014 cannot calculate comment ranges"
-    );
-    return ranges;
-  }
-  walk(bodyElements[0].children);
+  });
   if (openRanges.size > 0) {
     console.error(
       `[docx-comments] ${openRanges.size} comment range(s) had start markers but no end markers: ${[...openRanges.keys()].join(", ")}`
@@ -1647,21 +1749,6 @@ function calculateCommentRanges(xml) {
   }
   return ranges;
 }
-function detectHeadingLevel(paragraph) {
-  for (const child of paragraph.children) {
-    if (!isElement2(child) || child.name !== "w:pPr") continue;
-    for (const prop of child.children) {
-      if (!isElement2(prop) || prop.name !== "w:pStyle") continue;
-      const val = getAttr(prop, "w:val") || "";
-      const match = val.match(/^heading\s*(\d)$/i);
-      if (match) {
-        const level = parseInt(match[1], 10);
-        if (level >= 1 && level <= 6) return level;
-      }
-    }
-  }
-  return 0;
-}
 function injectCommentsAsAnnotations(doc, comments) {
   if (comments.length === 0) return 0;
   const map = doc.getMap(Y_MAP_ANNOTATIONS);
@@ -1698,35 +1785,864 @@ function injectCommentsAsAnnotations(doc, comments) {
   }
   return injected;
 }
-function isElement2(node) {
-  return node.type === "tag";
-}
-function getAttr(el, name) {
-  return el.attribs?.[name];
-}
-function getTextContent(node) {
-  if (node.type === "text") return node.data;
-  if (!isElement2(node)) return "";
-  return node.children.map(getTextContent).join("");
-}
-function findAllByName(name, nodes) {
-  const results = [];
-  for (const node of nodes) {
-    if (isElement2(node)) {
-      if (node.name === name) results.push(node);
-      results.push(...findAllByName(name, node.children));
-    }
-  }
-  return results;
-}
 var init_docx_comments = __esm({
   "src/server/file-io/docx-comments.ts"() {
     "use strict";
     init_constants();
-    init_offsets();
     init_positions2();
     init_types2();
     init_queue();
+    init_docx_walker();
+  }
+});
+
+// node_modules/domelementtype/dist/index.js
+function isTag(element) {
+  return element.type === ElementType.Tag || element.type === ElementType.Script || element.type === ElementType.Style;
+}
+var ElementType, Root, Text, Directive, Comment, Script, Style, Tag, CDATA, Doctype;
+var init_dist = __esm({
+  "node_modules/domelementtype/dist/index.js"() {
+    "use strict";
+    (function(ElementType2) {
+      ElementType2["Root"] = "root";
+      ElementType2["Text"] = "text";
+      ElementType2["Directive"] = "directive";
+      ElementType2["Comment"] = "comment";
+      ElementType2["Script"] = "script";
+      ElementType2["Style"] = "style";
+      ElementType2["Tag"] = "tag";
+      ElementType2["CDATA"] = "cdata";
+      ElementType2["Doctype"] = "doctype";
+    })(ElementType || (ElementType = {}));
+    Root = ElementType.Root;
+    Text = ElementType.Text;
+    Directive = ElementType.Directive;
+    Comment = ElementType.Comment;
+    Script = ElementType.Script;
+    Style = ElementType.Style;
+    Tag = ElementType.Tag;
+    CDATA = ElementType.CDATA;
+    Doctype = ElementType.Doctype;
+  }
+});
+
+// node_modules/domhandler/dist/node.js
+function isTag2(node) {
+  return isTag(node);
+}
+function isCDATA(node) {
+  return node.type === ElementType.CDATA;
+}
+function isText2(node) {
+  return node.type === ElementType.Text;
+}
+function isComment(node) {
+  return node.type === ElementType.Comment;
+}
+function isDirective(node) {
+  return node.type === ElementType.Directive;
+}
+function isDocument(node) {
+  return node.type === ElementType.Root;
+}
+function cloneNode(node, recursive = false) {
+  let result;
+  if (isText2(node)) {
+    result = new Text2(node.data);
+  } else if (isComment(node)) {
+    result = new Comment2(node.data);
+  } else if (isTag2(node)) {
+    const children = recursive ? cloneChildren(node.children) : [];
+    const clone = new Element(node.name, { ...node.attribs }, children);
+    for (const child of children) {
+      child.parent = clone;
+    }
+    if (node.namespace != null) {
+      clone.namespace = node.namespace;
+    }
+    if (node["x-attribsNamespace"]) {
+      clone["x-attribsNamespace"] = { ...node["x-attribsNamespace"] };
+    }
+    if (node["x-attribsPrefix"]) {
+      clone["x-attribsPrefix"] = { ...node["x-attribsPrefix"] };
+    }
+    result = clone;
+  } else if (isCDATA(node)) {
+    const children = recursive ? cloneChildren(node.children) : [];
+    const clone = new CDATA2(children);
+    for (const child of children) {
+      child.parent = clone;
+    }
+    result = clone;
+  } else if (isDocument(node)) {
+    const children = recursive ? cloneChildren(node.children) : [];
+    const clone = new Document(children);
+    for (const child of children) {
+      child.parent = clone;
+    }
+    if (node["x-mode"]) {
+      clone["x-mode"] = node["x-mode"];
+    }
+    result = clone;
+  } else if (isDirective(node)) {
+    const instruction = new ProcessingInstruction(node.name, node.data);
+    if (node["x-name"] != null) {
+      instruction["x-name"] = node["x-name"];
+      instruction["x-publicId"] = node["x-publicId"];
+      instruction["x-systemId"] = node["x-systemId"];
+    }
+    result = instruction;
+  } else {
+    throw new Error(`Not implemented yet: ${node.type}`);
+  }
+  result.startIndex = node.startIndex;
+  result.endIndex = node.endIndex;
+  if (node.sourceCodeLocation != null) {
+    result.sourceCodeLocation = node.sourceCodeLocation;
+  }
+  return result;
+}
+function cloneChildren(childs) {
+  const children = childs.map((child) => cloneNode(child, true));
+  for (let index = 1; index < children.length; index++) {
+    children[index].prev = children[index - 1];
+    children[index - 1].next = children[index];
+  }
+  return children;
+}
+var Node, DataNode, Text2, Comment2, ProcessingInstruction, NodeWithChildren, CDATA2, Document, Element;
+var init_node = __esm({
+  "node_modules/domhandler/dist/node.js"() {
+    "use strict";
+    init_dist();
+    Node = class {
+      /** Parent of the node */
+      parent = null;
+      /** Previous sibling */
+      prev = null;
+      /** Next sibling */
+      next = null;
+      /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */
+      startIndex = null;
+      /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */
+      endIndex = null;
+      // Read-write aliases for properties
+      /**
+       * Same as {@link parent}.
+       * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+       */
+      get parentNode() {
+        return this.parent;
+      }
+      set parentNode(parent) {
+        this.parent = parent;
+      }
+      /**
+       * Same as {@link prev}.
+       * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+       */
+      get previousSibling() {
+        return this.prev;
+      }
+      set previousSibling(previous) {
+        this.prev = previous;
+      }
+      /**
+       * Same as {@link next}.
+       * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+       */
+      get nextSibling() {
+        return this.next;
+      }
+      set nextSibling(next) {
+        this.next = next;
+      }
+      /**
+       * Clone this node, and optionally its children.
+       * @param recursive Clone child nodes as well.
+       * @returns A clone of the node.
+       */
+      cloneNode(recursive = false) {
+        return cloneNode(this, recursive);
+      }
+    };
+    DataNode = class extends Node {
+      data;
+      /**
+       * @param data The content of the data node
+       */
+      constructor(data) {
+        super();
+        this.data = data;
+      }
+      /**
+       * Same as {@link data}.
+       * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+       */
+      get nodeValue() {
+        return this.data;
+      }
+      set nodeValue(data) {
+        this.data = data;
+      }
+    };
+    Text2 = class extends DataNode {
+      type = ElementType.Text;
+      get nodeType() {
+        return 3;
+      }
+    };
+    Comment2 = class extends DataNode {
+      type = ElementType.Comment;
+      get nodeType() {
+        return 8;
+      }
+    };
+    ProcessingInstruction = class extends DataNode {
+      type = ElementType.Directive;
+      name;
+      constructor(name, data) {
+        super(data);
+        this.name = name;
+      }
+      get nodeType() {
+        return 1;
+      }
+      /** If this is a doctype, the document type name (parse5 only). */
+      "x-name";
+      /** If this is a doctype, the document type public identifier (parse5 only). */
+      "x-publicId";
+      /** If this is a doctype, the document type system identifier (parse5 only). */
+      "x-systemId";
+    };
+    NodeWithChildren = class extends Node {
+      children;
+      /**
+       * @param children Children of the node. Only certain node types can have children.
+       */
+      constructor(children) {
+        super();
+        this.children = children;
+      }
+      // Aliases
+      /** First child of the node. */
+      get firstChild() {
+        return this.children[0] ?? null;
+      }
+      /** Last child of the node. */
+      get lastChild() {
+        return this.children.length > 0 ? this.children[this.children.length - 1] : null;
+      }
+      /**
+       * Same as {@link children}.
+       * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+       */
+      get childNodes() {
+        return this.children;
+      }
+      set childNodes(children) {
+        this.children = children;
+      }
+    };
+    CDATA2 = class extends NodeWithChildren {
+      type = ElementType.CDATA;
+      get nodeType() {
+        return 4;
+      }
+    };
+    Document = class extends NodeWithChildren {
+      type = ElementType.Root;
+      get nodeType() {
+        return 9;
+      }
+    };
+    Element = class extends NodeWithChildren {
+      name;
+      attribs;
+      type;
+      /**
+       * @param name Name of the tag, eg. `div`, `span`.
+       * @param attribs Object mapping attribute names to attribute values.
+       * @param children Children of the node.
+       * @param type Node type used for the new node instance.
+       */
+      constructor(name, attribs, children = [], type = name === "script" ? ElementType.Script : name === "style" ? ElementType.Style : ElementType.Tag) {
+        super(children);
+        this.name = name;
+        this.attribs = attribs;
+        this.type = type;
+      }
+      get nodeType() {
+        return 1;
+      }
+      // DOM Level 1 aliases
+      /**
+       * Same as {@link name}.
+       * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+       */
+      get tagName() {
+        return this.name;
+      }
+      set tagName(name) {
+        this.name = name;
+      }
+      get attributes() {
+        return Object.keys(this.attribs).map((name) => ({
+          name,
+          value: this.attribs[name],
+          namespace: this["x-attribsNamespace"]?.[name],
+          prefix: this["x-attribsPrefix"]?.[name]
+        }));
+      }
+      /** Element namespace (parse5 only). */
+      namespace;
+      /** Element attribute namespaces (parse5 only). */
+      "x-attribsNamespace";
+      /** Element attribute namespace-related prefixes (parse5 only). */
+      "x-attribsPrefix";
+    };
+  }
+});
+
+// node_modules/domhandler/dist/index.js
+var init_dist2 = __esm({
+  "node_modules/domhandler/dist/index.js"() {
+    "use strict";
+    init_node();
+  }
+});
+
+// src/server/file-io/docx-apply.ts
+import JSZip2 from "jszip";
+import { parseDocument as parseDocument4 } from "htmlparser2";
+import render from "dom-serializer";
+function buildOffsetMap(xml, targetOffsets) {
+  const entries = /* @__PURE__ */ new Map();
+  const commentParagraphIds = /* @__PURE__ */ new Map();
+  const hits = [];
+  const { totalLength, flatText } = walkDocumentBody(xml, {
+    onText(hit) {
+      hits.push(hit);
+    },
+    onCommentStart(hit) {
+      if (hit.paragraphId) {
+        commentParagraphIds.set(hit.commentId, hit.paragraphId);
+      }
+    }
+  });
+  for (const offset of targetOffsets) {
+    if (offset === totalLength && hits.length > 0) {
+      const lastHit = hits[hits.length - 1];
+      entries.set(offset, {
+        run: lastHit.run,
+        textNode: lastHit.textNode,
+        charIndex: lastHit.text.length,
+        paragraph: lastHit.paragraph,
+        paragraphId: lastHit.paragraphId
+      });
+      continue;
+    }
+    for (let i = 0; i < hits.length; i++) {
+      const hit = hits[i];
+      const start = hit.offsetStart;
+      const end = start + hit.text.length;
+      if (offset >= start && offset < end) {
+        entries.set(offset, {
+          run: hit.run,
+          textNode: hit.textNode,
+          charIndex: offset - start,
+          paragraph: hit.paragraph,
+          paragraphId: hit.paragraphId
+        });
+        break;
+      }
+      if (offset === end) {
+        const nextHit = hits[i + 1];
+        if (!nextHit || nextHit.offsetStart !== offset) {
+          entries.set(offset, {
+            run: hit.run,
+            textNode: hit.textNode,
+            charIndex: hit.text.length,
+            paragraph: hit.paragraph,
+            paragraphId: hit.paragraphId
+          });
+          break;
+        }
+      }
+    }
+  }
+  let walkerBody;
+  let walkerDoc;
+  if (hits.length > 0) {
+    let node = hits[0].paragraph.parent;
+    while (node && isElement2(node) && node.name !== "w:body") {
+      node = node.parent;
+    }
+    walkerBody = node;
+    if (!walkerBody || walkerBody.name !== "w:body") {
+      throw new Error("Could not recover w:body from walker's parsed DOM");
+    }
+    walkerDoc = walkerBody.parent;
+  } else {
+    const doc = parseDocument4(xml, { xmlMode: true });
+    const bodyElements = findAllByName("w:body", doc.children);
+    walkerBody = bodyElements[0] ?? new Element("w:body", {});
+    walkerDoc = doc;
+  }
+  return {
+    get(offset) {
+      return entries.get(offset);
+    },
+    flatText,
+    totalLength,
+    body: walkerBody,
+    doc: walkerDoc,
+    commentParagraphIds
+  };
+}
+function getNodeText(node) {
+  for (const child of node.children) {
+    if (child.type === "text") return child.data;
+  }
+  return "";
+}
+function setNodeText(node, text) {
+  const textChild = new Text2(text);
+  textChild.parent = node;
+  node.children = [textChild];
+  if (text.startsWith(" ") || text.endsWith(" ")) {
+    node.attribs["xml:space"] = "preserve";
+  } else {
+    delete node.attribs["xml:space"];
+  }
+}
+function cloneRPr(rPr) {
+  const serialized = render(rPr, { xmlMode: true });
+  const doc = parseDocument4(serialized, { xmlMode: true });
+  return doc.children[0];
+}
+function findRPr(run) {
+  for (const child of run.children) {
+    if (isElement2(child) && child.name === "w:rPr") return child;
+  }
+  return void 0;
+}
+function buildRun(textElementName, text, rPrSource) {
+  const children = [];
+  if (rPrSource) {
+    const cloned = cloneRPr(rPrSource);
+    children.push(cloned);
+  }
+  const textChild = new Text2(text);
+  const attribs = {};
+  if (text.startsWith(" ") || text.endsWith(" ")) {
+    attribs["xml:space"] = "preserve";
+  }
+  const textNode = new Element(textElementName, attribs, [textChild]);
+  textChild.parent = textNode;
+  children.push(textNode);
+  const run = new Element("w:r", {}, children);
+  for (const child of children) {
+    child.parent = run;
+  }
+  return run;
+}
+function insertChild(parent, index, node) {
+  parent.children.splice(index, 0, node);
+  node.parent = parent;
+}
+function removeChild(node) {
+  if (!node.parent) return;
+  const parent = node.parent;
+  const idx = parent.children.indexOf(node);
+  if (idx >= 0) parent.children.splice(idx, 1);
+  node.parent = null;
+}
+function applySingleSuggestion(offsetMap, suggestion) {
+  const { from, to, newText, author, date, revisionId } = suggestion;
+  const fromEntry = offsetMap.get(from);
+  const toEntry = offsetMap.get(to);
+  if (!fromEntry || !toEntry) {
+    return { ok: false, reason: `Could not resolve offsets: from=${from} to=${to}` };
+  }
+  if (fromEntry.paragraph !== toEntry.paragraph) {
+    return { ok: false, reason: "Cross-paragraph suggestions not yet supported" };
+  }
+  const paragraph = fromEntry.paragraph;
+  if (fromEntry.charIndex > 0) {
+    splitRun(fromEntry.run, fromEntry.textNode, fromEntry.charIndex, paragraph);
+    const idx = paragraph.children.indexOf(fromEntry.run);
+    const nextRun = paragraph.children[idx + 1];
+    if (!nextRun || !isElement2(nextRun) || nextRun.name !== "w:r") {
+      return { ok: false, reason: "Split failed: no next run after from-split" };
+    }
+    fromEntry.run = nextRun;
+    const nextTextNode = findTextNode(nextRun);
+    if (!nextTextNode) {
+      return { ok: false, reason: "Run contains no text element" };
+    }
+    fromEntry.textNode = nextTextNode;
+    fromEntry.charIndex = 0;
+  }
+  const toText = getNodeText(toEntry.textNode);
+  if (toEntry.charIndex < toText.length && toEntry.charIndex > 0) {
+    splitRun(toEntry.run, toEntry.textNode, toEntry.charIndex, paragraph);
+  } else if (toEntry.charIndex === 0) {
+  }
+  const runsToDelete = [];
+  let collecting = false;
+  for (const child of paragraph.children) {
+    if (!isElement2(child) || child.name !== "w:r") {
+      if (collecting && child === toEntry.run) break;
+      continue;
+    }
+    if (child === fromEntry.run) {
+      collecting = true;
+    }
+    if (collecting) {
+      if (toEntry.charIndex === 0 && child === toEntry.run) {
+        break;
+      }
+      runsToDelete.push(child);
+      if (child === toEntry.run) {
+        break;
+      }
+    }
+  }
+  if (runsToDelete.length === 0) {
+    if (from === to && newText.length > 0) {
+      const insertionPoint = paragraph.children.indexOf(fromEntry.run);
+      const rPr = findRPr(fromEntry.run);
+      const insRun = buildRun("w:t", newText, rPr);
+      const ins2 = new Element(
+        "w:ins",
+        {
+          "w:id": String(revisionId + 1),
+          "w:author": author,
+          "w:date": date
+        },
+        [insRun]
+      );
+      insRun.parent = ins2;
+      insertChild(paragraph, insertionPoint, ins2);
+      return { ok: true };
+    }
+    return { ok: false, reason: "No runs found in deletion range" };
+  }
+  const rPrSource = findRPr(runsToDelete[0]);
+  const delChildren = [];
+  for (const run of runsToDelete) {
+    const tn = findTextNode(run);
+    if (!tn) continue;
+    const text = getNodeText(tn);
+    const delRun = buildRun("w:delText", text, findRPr(run));
+    delChildren.push(delRun);
+  }
+  const del = new Element(
+    "w:del",
+    {
+      "w:id": String(revisionId),
+      "w:author": author,
+      "w:date": date
+    },
+    delChildren
+  );
+  for (const child of delChildren) {
+    child.parent = del;
+  }
+  let ins;
+  if (newText.length > 0) {
+    const insRun = buildRun("w:t", newText, rPrSource);
+    ins = new Element(
+      "w:ins",
+      {
+        "w:id": String(revisionId + 1),
+        "w:author": author,
+        "w:date": date
+      },
+      [insRun]
+    );
+    insRun.parent = ins;
+  }
+  const firstRunIndex = paragraph.children.indexOf(runsToDelete[0]);
+  for (const run of runsToDelete) {
+    removeChild(run);
+  }
+  insertChild(paragraph, firstRunIndex, del);
+  if (ins) {
+    insertChild(paragraph, firstRunIndex + 1, ins);
+  }
+  return { ok: true };
+}
+function splitRun(run, textNode, charIndex, paragraph) {
+  const fullText = getNodeText(textNode);
+  const before = fullText.slice(0, charIndex);
+  const after = fullText.slice(charIndex);
+  setNodeText(textNode, before);
+  const rPr = findRPr(run);
+  const newRun = buildRun("w:t", after, rPr);
+  const idx = paragraph.children.indexOf(run);
+  insertChild(paragraph, idx + 1, newRun);
+}
+function findTextNode(run) {
+  for (const child of run.children) {
+    if (isElement2(child) && child.name === "w:t") return child;
+  }
+  return void 0;
+}
+async function applyTrackedChanges(docxBuffer, suggestions, options) {
+  const zip = await JSZip2.loadAsync(docxBuffer);
+  const documentXml = await zip.file("word/document.xml")?.async("text");
+  if (!documentXml) {
+    throw new Error("Missing word/document.xml in .docx archive");
+  }
+  const date = options.date ?? (/* @__PURE__ */ new Date()).toISOString();
+  const targetOffsets = /* @__PURE__ */ new Set();
+  for (const s of suggestions) {
+    targetOffsets.add(s.from);
+    targetOffsets.add(s.to);
+  }
+  const offsetMap = buildOffsetMap(documentXml, targetOffsets);
+  if (offsetMap.flatText !== options.ydocFlatText) {
+    throw new Error(
+      "Flat text mismatch: the .docx content does not match the Y.Doc flat text. The file may have changed since it was loaded."
+    );
+  }
+  const sorted = [...suggestions].sort((a, b) => b.from - a.from);
+  const valid = [];
+  const rejectedDetails = [];
+  for (const s of sorted) {
+    if (s.textSnapshot !== void 0) {
+      const actual = offsetMap.flatText.slice(s.from, s.to);
+      if (actual !== s.textSnapshot) {
+        rejectedDetails.push({
+          id: s.id,
+          reason: `Text snapshot mismatch: expected "${s.textSnapshot}", got "${actual}"`
+        });
+        continue;
+      }
+    }
+    const fromEntry = offsetMap.get(s.from);
+    const toEntry = offsetMap.get(s.to);
+    if (!fromEntry || !toEntry) {
+      rejectedDetails.push({
+        id: s.id,
+        reason: `Could not resolve offsets: from=${s.from} to=${s.to}`
+      });
+      continue;
+    }
+    valid.push(s);
+  }
+  const validAfterOverlapCheck = [];
+  let lastFrom = Infinity;
+  for (const s of valid) {
+    if (s.to > lastFrom) {
+      rejectedDetails.push({
+        id: s.id,
+        reason: `Overlapping range [${s.from}, ${s.to}) conflicts with another suggestion`
+      });
+      continue;
+    }
+    lastFrom = s.from;
+    validAfterOverlapCheck.push(s);
+  }
+  const validAfterComplexCheck = [];
+  for (const s of validAfterOverlapCheck) {
+    const fromEntry = offsetMap.get(s.from);
+    const toEntry = offsetMap.get(s.to);
+    const paragraph = fromEntry.paragraph;
+    let collecting = false;
+    let hasComplex = false;
+    for (const child of paragraph.children) {
+      if (!isElement2(child) || child.name !== "w:r") continue;
+      if (child === fromEntry.run) collecting = true;
+      if (collecting) {
+        for (const rc of child.children) {
+          if (isElement2(rc) && COMPLEX_RUN_ELEMENTS.has(rc.name)) {
+            hasComplex = true;
+            break;
+          }
+        }
+        if (hasComplex) break;
+        if (child === toEntry.run) break;
+      }
+    }
+    if (hasComplex) {
+      rejectedDetails.push({
+        id: s.id,
+        reason: "Overlaps a complex element (footnote, drawing, or field) and couldn't be applied"
+      });
+    } else {
+      validAfterComplexCheck.push(s);
+    }
+  }
+  const validAfterRunCheck = [];
+  const claimedRuns = /* @__PURE__ */ new Map();
+  for (const s of validAfterComplexCheck) {
+    const fromEntry = offsetMap.get(s.from);
+    const toEntry = offsetMap.get(s.to);
+    const paragraph = fromEntry.paragraph;
+    const touchedRuns = [];
+    let collecting = false;
+    for (const child of paragraph.children) {
+      if (!isElement2(child) || child.name !== "w:r") continue;
+      if (child === fromEntry.run) collecting = true;
+      if (collecting) {
+        touchedRuns.push(child);
+        if (child === toEntry.run) break;
+      }
+    }
+    let conflict = false;
+    for (const run of touchedRuns) {
+      if (claimedRuns.has(run)) {
+        rejectedDetails.push({
+          id: s.id,
+          reason: "Targets the same text run as another suggestion"
+        });
+        conflict = true;
+        break;
+      }
+    }
+    if (!conflict) {
+      for (const run of touchedRuns) {
+        claimedRuns.set(run, s.id);
+      }
+      validAfterRunCheck.push(s);
+    }
+  }
+  const doc = offsetMap.doc;
+  const idMatches = documentXml.match(/w:id="(\d+)"/g) || [];
+  let maxId = 0;
+  for (const m of idMatches) {
+    const num = parseInt(m.match(/\d+/)[0], 10);
+    if (num > maxId) maxId = num;
+  }
+  let applied = 0;
+  const appliedSuggestions = [];
+  for (const s of validAfterRunCheck) {
+    maxId += 2;
+    const result = applySingleSuggestion(offsetMap, {
+      from: s.from,
+      to: s.to,
+      newText: s.newText,
+      author: options.author,
+      date,
+      revisionId: maxId - 1
+    });
+    if (result.ok) {
+      applied++;
+      appliedSuggestions.push(s);
+    } else {
+      rejectedDetails.push({ id: s.id, reason: result.reason ?? "Unknown error" });
+    }
+  }
+  const serialized = render(doc, { xmlMode: true });
+  zip.file("word/document.xml", serialized);
+  const commentsResolved = await resolveWordComments(
+    zip,
+    offsetMap.commentParagraphIds,
+    appliedSuggestions
+  );
+  const buffer3 = Buffer.from(await zip.generateAsync({ type: "nodebuffer" }));
+  return {
+    buffer: buffer3,
+    applied,
+    rejected: rejectedDetails.length,
+    rejectedDetails,
+    commentsResolved
+  };
+}
+async function resolveWordComments(zip, commentParagraphIds, appliedSuggestions) {
+  const toResolve = [];
+  for (const s of appliedSuggestions) {
+    if (!s.importCommentId) continue;
+    const paraId = commentParagraphIds.get(s.importCommentId);
+    if (!paraId) {
+      console.warn(`[docx-apply] No paraId for comment ${s.importCommentId}; skipping resolution`);
+      continue;
+    }
+    toResolve.push({ commentId: s.importCommentId, paraId });
+  }
+  if (toResolve.length === 0) return 0;
+  const seen = /* @__PURE__ */ new Set();
+  const unique = toResolve.filter((r) => {
+    if (seen.has(r.commentId)) return false;
+    seen.add(r.commentId);
+    return true;
+  });
+  const existingXml = await zip.file("word/commentsExtended.xml")?.async("text");
+  if (existingXml) {
+    const doc = parseDocument4(existingXml, { xmlMode: true });
+    const root = doc.children.find((c) => isElement2(c) && c.name === "w15:commentsEx");
+    if (root) {
+      const existingParaIds = /* @__PURE__ */ new Set();
+      for (const child of root.children) {
+        if (isElement2(child) && child.name === "w15:commentEx") {
+          const pid = getAttr(child, "w15:paraId");
+          if (pid) existingParaIds.add(pid);
+        }
+      }
+      for (const { paraId } of unique) {
+        if (existingParaIds.has(paraId)) continue;
+        const entry = new Element("w15:commentEx", {
+          "w15:paraId": paraId,
+          "w15:done": "1"
+        });
+        insertChild(root, root.children.length, entry);
+      }
+      zip.file("word/commentsExtended.xml", render(doc, { xmlMode: true }));
+    }
+  } else {
+    const entries = unique.map((r) => `<w15:commentEx w15:paraId="${r.paraId}" w15:done="1"/>`).join("");
+    const newXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w15:commentsEx xmlns:w15="${W15_NS}">${entries}</w15:commentsEx>`;
+    zip.file("word/commentsExtended.xml", newXml);
+    const relsXml = await zip.file("word/_rels/document.xml.rels")?.async("text");
+    if (relsXml) {
+      const relsDoc = parseDocument4(relsXml, { xmlMode: true });
+      const relsRoot = relsDoc.children.find((c) => isElement2(c) && c.name === "Relationships");
+      if (relsRoot) {
+        const existingIds = findAllByName("Relationship", relsRoot.children).map((r) => getAttr(r, "Id") || "").filter((id) => id.startsWith("rId")).map((id) => parseInt(id.slice(3), 10)).filter((n) => !isNaN(n));
+        const nextId = existingIds.length > 0 ? Math.max(...existingIds) + 1 : 100;
+        const rel = new Element("Relationship", {
+          Id: `rId${nextId}`,
+          Type: "http://schemas.microsoft.com/office/2011/relationships/commentsExtended",
+          Target: "commentsExtended.xml"
+        });
+        insertChild(relsRoot, relsRoot.children.length, rel);
+        zip.file("word/_rels/document.xml.rels", render(relsDoc, { xmlMode: true }));
+      }
+    }
+    const ctXml = await zip.file("[Content_Types].xml")?.async("text");
+    if (ctXml) {
+      const ctDoc = parseDocument4(ctXml, { xmlMode: true });
+      const typesRoot = ctDoc.children.find((c) => isElement2(c) && c.name === "Types");
+      if (typesRoot) {
+        const override = new Element("Override", {
+          PartName: "/word/commentsExtended.xml",
+          ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml"
+        });
+        insertChild(typesRoot, typesRoot.children.length, override);
+        zip.file("[Content_Types].xml", render(ctDoc, { xmlMode: true }));
+      }
+    }
+  }
+  return unique.length;
+}
+var COMPLEX_RUN_ELEMENTS, W15_NS;
+var init_docx_apply = __esm({
+  "src/server/file-io/docx-apply.ts"() {
+    "use strict";
+    init_dist2();
+    init_docx_walker();
+    COMPLEX_RUN_ELEMENTS = /* @__PURE__ */ new Set([
+      "w:footnoteReference",
+      "w:endnoteReference",
+      "w:drawing",
+      "w:pict",
+      "w:fldChar"
+    ]);
+    W15_NS = "http://schemas.microsoft.com/office/word/2012/wordml";
   }
 });
 
@@ -1741,6 +2657,17 @@ async function atomicWrite(filePath, content) {
   await fs2.writeFile(tempPath, content, "utf-8");
   await fs2.rename(tempPath, filePath);
 }
+async function atomicWriteBuffer(filePath, content) {
+  const tempPath = path4.join(path4.dirname(filePath), `.tandem-tmp-${Date.now()}`);
+  await fs2.writeFile(tempPath, content);
+  try {
+    await fs2.rename(tempPath, filePath);
+  } catch (err) {
+    await fs2.unlink(tempPath).catch(() => {
+    });
+    throw err;
+  }
+}
 var markdownAdapter, plaintextAdapter, docxAdapter, adapters;
 var init_file_io = __esm({
   "src/server/file-io/index.ts"() {
@@ -1749,6 +2676,7 @@ var init_file_io = __esm({
     init_docx();
     init_docx_comments();
     init_document_model();
+    init_docx_apply();
     markdownAdapter = {
       canSave: true,
       load(doc, content) {
@@ -2355,15 +3283,16 @@ function attachObservers(docName, doc) {
     if (txn.origin === MCP_ORIGIN) return;
     if (event.keysChanged.has("selection")) {
       const selection = userAwareness.get("selection");
+      if (!selection || selection.from === selection.to) return;
       pushEvent({
         id: generateEventId(),
         type: "selection:changed",
         timestamp: Date.now(),
         documentId: docName,
         payload: {
-          from: selection?.from ?? 0,
-          to: selection?.to ?? 0,
-          selectedText: selection?.from !== selection?.to ? selection?.selectedText ?? "" : ""
+          from: selection.from,
+          to: selection.to,
+          selectedText: selection.selectedText ?? ""
         }
       });
     }
@@ -2580,7 +3509,7 @@ var init_launcher = __esm({
 });
 
 // src/server/index.ts
-import path8 from "path";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/server/mcp/server.ts
@@ -3578,6 +4507,181 @@ init_constants();
 init_document_model();
 init_file_opener();
 init_document_service();
+
+// src/server/mcp/docx-apply.ts
+init_document_service();
+init_constants();
+init_positions2();
+init_document_model();
+init_file_io();
+import { z as z4 } from "zod";
+import fs5 from "fs/promises";
+import path8 from "path";
+async function applyChangesCore(documentId, author, backupPath) {
+  const r = requireDocument(documentId);
+  if (!r) throw Object.assign(new Error("No document is open."), { code: "NO_DOCUMENT" });
+  const { doc: ydoc, filePath } = r;
+  const docState = getCurrentDoc(documentId);
+  if (!docState) throw Object.assign(new Error("No document is open."), { code: "NO_DOCUMENT" });
+  if (docState.format !== "docx") {
+    throw Object.assign(
+      new Error(`Apply changes is only supported for .docx files (this is ${docState.format}).`),
+      { code: "UNSUPPORTED_FORMAT" }
+    );
+  }
+  if (docState.source !== "file") {
+    throw Object.assign(new Error("Cannot apply changes to uploaded files. Save to disk first."), {
+      code: "INVALID_PATH"
+    });
+  }
+  const map = ydoc.getMap(Y_MAP_ANNOTATIONS);
+  const suggestions = [];
+  let pendingCount = 0;
+  for (const [, raw] of map) {
+    const ann = raw;
+    if (ann.type !== "suggestion") continue;
+    if (ann.status === "pending") {
+      pendingCount++;
+      continue;
+    }
+    if (ann.status !== "accepted") continue;
+    let from = ann.range.from;
+    let to = ann.range.to;
+    if (ann.relRange) {
+      const resolvedFrom = relPosToFlatOffset(ydoc, ann.relRange.fromRel);
+      const resolvedTo = relPosToFlatOffset(ydoc, ann.relRange.toRel);
+      if (resolvedFrom !== null && resolvedTo !== null) {
+        if (resolvedFrom > resolvedTo) {
+          console.error(
+            `[docx-apply] Inverted CRDT range for ${ann.id}: [${resolvedFrom}, ${resolvedTo}]; skipping`
+          );
+          continue;
+        }
+        from = resolvedFrom;
+        to = resolvedTo;
+      }
+    }
+    let newText = "";
+    try {
+      const parsed = JSON.parse(ann.content);
+      newText = parsed.newText;
+    } catch {
+      newText = ann.content;
+    }
+    let importCommentId;
+    if (ann.id.startsWith("import-")) {
+      const withoutPrefix = ann.id.slice("import-".length);
+      const lastDash = withoutPrefix.lastIndexOf("-");
+      if (lastDash > 0) {
+        importCommentId = withoutPrefix.slice(0, lastDash);
+      }
+    }
+    suggestions.push({
+      id: ann.id,
+      from,
+      to,
+      newText,
+      textSnapshot: ann.textSnapshot,
+      importCommentId
+    });
+  }
+  if (suggestions.length === 0) {
+    throw Object.assign(new Error("No accepted suggestions to apply."), { code: "NO_SUGGESTIONS" });
+  }
+  const ydocFlatText = extractText(ydoc);
+  const buffer3 = await fs5.readFile(filePath);
+  const result = await applyTrackedChanges(buffer3, suggestions, {
+    author: author ?? "Tandem Review",
+    ydocFlatText
+  });
+  let resolvedBackup = backupPath ?? filePath.replace(/\.docx$/i, ".backup.docx");
+  try {
+    await fs5.access(resolvedBackup);
+    const ext = path8.extname(resolvedBackup);
+    const base = resolvedBackup.slice(0, -ext.length);
+    resolvedBackup = `${base}-${Date.now()}${ext}`;
+  } catch {
+  }
+  await fs5.copyFile(filePath, resolvedBackup);
+  const [origStat, backupStat] = await Promise.all([fs5.stat(filePath), fs5.stat(resolvedBackup)]);
+  if (origStat.size !== backupStat.size) {
+    throw Object.assign(new Error("Backup verification failed: file sizes do not match."), {
+      code: "BACKUP_FAILED"
+    });
+  }
+  await atomicWriteBuffer(filePath, result.buffer);
+  const output = {
+    applied: result.applied,
+    rejected: result.rejected,
+    rejectedDetails: result.rejectedDetails,
+    commentsResolved: result.commentsResolved,
+    backupPath: resolvedBackup
+  };
+  if (pendingCount > 0) {
+    output.pendingWarning = `${pendingCount} suggestion(s) are still pending review and were not applied.`;
+  }
+  return output;
+}
+function registerApplyTools(server) {
+  server.tool(
+    "tandem_applyChanges",
+    "Apply all accepted suggestions to the .docx file as tracked changes (w:del + w:ins). Creates a backup before writing. Only works on .docx files opened from disk.",
+    {
+      documentId: z4.string().optional().describe("Target document ID (defaults to active doc)"),
+      author: z4.string().optional().describe("Author name for tracked changes (default: 'Tandem Review')"),
+      backupPath: z4.string().optional().describe("Custom backup path (default: {name}.backup.docx)")
+    },
+    withErrorBoundary("tandem_applyChanges", async (args) => {
+      try {
+        const result = await applyChangesCore(args.documentId, args.author, args.backupPath);
+        return mcpSuccess(result);
+      } catch (err) {
+        const e = err;
+        if (e.code === "NO_DOCUMENT") return noDocumentError();
+        if (e.code === "NO_SUGGESTIONS") return mcpError("NO_SUGGESTIONS", e.message);
+        if (e.code === "UNSUPPORTED_FORMAT") return mcpError("FORMAT_ERROR", e.message);
+        if (e.code === "INVALID_PATH") return mcpError("FORMAT_ERROR", e.message);
+        if (e.code === "BACKUP_FAILED") return mcpError("BACKUP_FAILED", e.message);
+        throw err;
+      }
+    })
+  );
+  server.tool(
+    "tandem_restoreBackup",
+    "Restore a .docx file from its backup ({name}.backup.docx). Use after tandem_applyChanges if the result is unsatisfactory.",
+    {
+      documentId: z4.string().optional().describe("Target document ID (defaults to active doc)")
+    },
+    withErrorBoundary("tandem_restoreBackup", async (args) => {
+      const r = requireDocument(args.documentId);
+      if (!r) return noDocumentError();
+      const { filePath } = r;
+      const backupPath = filePath.replace(/\.docx$/i, ".backup.docx");
+      try {
+        await fs5.access(backupPath);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          return mcpError("FILE_NOT_FOUND", `No backup file found at ${backupPath}`);
+        }
+        throw err;
+      }
+      await fs5.copyFile(backupPath, filePath);
+      const [backupStat, restoredStat] = await Promise.all([
+        fs5.stat(backupPath),
+        fs5.stat(filePath)
+      ]);
+      if (backupStat.size !== restoredStat.size) {
+        throw new Error("Restore verification failed: file sizes do not match.");
+      }
+      return mcpSuccess({
+        message: `Restored ${path8.basename(filePath)} from backup.`,
+        restoredFrom: backupPath
+      });
+    })
+  );
+}
+
+// src/server/mcp/api-routes.ts
 function isHostAllowed(host) {
   const reqHost = (host ?? "").split(":")[0];
   return reqHost === "localhost" || reqHost === "127.0.0.1";
@@ -3590,9 +4694,11 @@ function errorCodeToHttpStatus(code) {
   switch (code) {
     case "ENOENT":
     case "FILE_NOT_FOUND":
+    case "NO_DOCUMENT":
       return 404;
     case "INVALID_PATH":
     case "UNSUPPORTED_FORMAT":
+    case "NO_SUGGESTIONS":
       return 400;
     case "FILE_TOO_LARGE":
       return 413;
@@ -3601,6 +4707,8 @@ function errorCodeToHttpStatus(code) {
       return 423;
     case "EACCES":
       return 403;
+    case "BACKUP_FAILED":
+      return 500;
     default:
       return 500;
   }
@@ -3624,11 +4732,13 @@ function errorCodeToLabel(code) {
   switch (code) {
     case "ENOENT":
     case "FILE_NOT_FOUND":
-      return "FILE_NOT_FOUND";
+    case "NO_DOCUMENT":
+      return "NOT_FOUND";
     case "INVALID_PATH":
       return "INVALID_PATH";
     case "UNSUPPORTED_FORMAT":
-      return "UNSUPPORTED_FORMAT";
+    case "NO_SUGGESTIONS":
+      return "BAD_REQUEST";
     case "FILE_TOO_LARGE":
       return "FILE_TOO_LARGE";
     case "EBUSY":
@@ -3636,6 +4746,8 @@ function errorCodeToLabel(code) {
       return "FILE_LOCKED";
     case "EACCES":
       return "PERMISSION_DENIED";
+    case "BACKUP_FAILED":
+      return "INTERNAL";
     default:
       return "INTERNAL";
   }
@@ -3767,11 +4879,37 @@ function registerApiRoutes(app, largeBody) {
       sendApiError(res, err);
     }
   });
+  app.options("/api/apply-changes", apiMiddleware);
+  app.post("/api/apply-changes", apiMiddleware, largeBody, async (req, res) => {
+    const { documentId, author, backupPath } = req.body ?? {};
+    if (documentId !== void 0 && typeof documentId !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "documentId must be a string" });
+      return;
+    }
+    if (author !== void 0 && typeof author !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "author must be a string" });
+      return;
+    }
+    if (backupPath !== void 0 && typeof backupPath !== "string") {
+      res.status(400).json({ error: "BAD_REQUEST", message: "backupPath must be a string" });
+      return;
+    }
+    try {
+      const result = await applyChangesCore(
+        documentId,
+        author,
+        backupPath
+      );
+      res.json({ data: result });
+    } catch (err) {
+      sendApiError(res, err);
+    }
+  });
 }
 
 // src/server/mcp/awareness.ts
 init_provider();
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 init_utils();
 init_constants();
 init_queue();
@@ -3781,7 +4919,7 @@ function registerAwarenessTools(server) {
     "tandem_getSelections",
     "Get text currently selected by the user in the editor",
     {
-      documentId: z4.string().optional().describe("Target document ID (defaults to active document)")
+      documentId: z5.string().optional().describe("Target document ID (defaults to active document)")
     },
     withErrorBoundary("tandem_getSelections", async ({ documentId }) => {
       const current = getCurrentDoc(documentId);
@@ -3802,7 +4940,7 @@ function registerAwarenessTools(server) {
     "tandem_getActivity",
     "Check if the user is actively editing and where their cursor is",
     {
-      documentId: z4.string().optional().describe("Target document ID (defaults to active document)")
+      documentId: z5.string().optional().describe("Target document ID (defaults to active document)")
     },
     withErrorBoundary("tandem_getActivity", async ({ documentId }) => {
       const current = getCurrentDoc(documentId);
@@ -3831,7 +4969,7 @@ function registerAwarenessTools(server) {
     "tandem_checkInbox",
     "Check for user actions you haven't seen yet \u2014 new highlights, comments, questions, flags, and responses to your annotations. Call this after completing any task, between steps, and whenever you pause. Low token cost.",
     {
-      documentId: z4.string().optional().describe("Target document ID (defaults to active document)")
+      documentId: z5.string().optional().describe("Target document ID (defaults to active document)")
     },
     withErrorBoundary("tandem_checkInbox", async ({ documentId }) => {
       const current = getCurrentDoc(documentId);
@@ -3924,9 +5062,9 @@ function registerAwarenessTools(server) {
     "tandem_reply",
     "Send a chat message to the user in the Tandem sidebar. Use this to respond to chat messages from tandem_checkInbox.",
     {
-      text: z4.string().describe("Your message to the user"),
-      replyTo: z4.string().optional().describe("ID of the user message you are replying to"),
-      documentId: z4.string().optional().describe("Document context for this reply (defaults to active document)")
+      text: z5.string().describe("Your message to the user"),
+      replyTo: z5.string().optional().describe("ID of the user message you are replying to"),
+      documentId: z5.string().optional().describe("Document context for this reply (defaults to active document)")
     },
     withErrorBoundary("tandem_reply", async ({ text, replyTo, documentId }) => {
       const ctrlDoc = getOrCreateDocument(CTRL_ROOM);
@@ -4120,7 +5258,7 @@ init_constants();
 init_types();
 init_queue();
 init_provider();
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 function getFullText(docName) {
   const doc = getOrCreateDocument(docName);
   return extractText(doc);
@@ -4176,9 +5314,9 @@ function registerNavigationTools(server) {
     "tandem_search",
     "Search for text in the document. Returns matching positions.",
     {
-      query: z5.string().describe("Search query (supports regex)"),
-      regex: z5.boolean().optional().describe("Treat query as regex"),
-      documentId: z5.string().optional().describe("Target document ID (defaults to active document)")
+      query: z6.string().describe("Search query (supports regex)"),
+      regex: z6.boolean().optional().describe("Treat query as regex"),
+      documentId: z6.string().optional().describe("Target document ID (defaults to active document)")
     },
     withErrorBoundary("tandem_search", async ({ query, regex, documentId }) => {
       const current = getCurrentDoc(documentId);
@@ -4193,9 +5331,9 @@ function registerNavigationTools(server) {
     "tandem_resolveRange",
     "Find text and return a valid range. Safer than raw character offsets under concurrent editing.",
     {
-      pattern: z5.string().describe("Text to find"),
-      occurrence: z5.number().optional().describe("Which occurrence (1-based, default 1)"),
-      documentId: z5.string().optional().describe("Target document ID (defaults to active document)")
+      pattern: z6.string().describe("Text to find"),
+      occurrence: z6.number().optional().describe("Which occurrence (1-based, default 1)"),
+      documentId: z6.string().optional().describe("Target document ID (defaults to active document)")
     },
     withErrorBoundary("tandem_resolveRange", async ({ pattern, occurrence = 1, documentId }) => {
       const current = getCurrentDoc(documentId);
@@ -4210,9 +5348,9 @@ function registerNavigationTools(server) {
     "tandem_setStatus",
     'Update Claude status text shown to user (e.g., "Reviewing cost figures..."). Tip: call tandem_checkInbox after completing work to see if the user has responded.',
     {
-      text: z5.string().describe("Status text"),
-      focusParagraph: z5.number().optional().describe("Index of paragraph Claude is focusing on"),
-      documentId: z5.string().optional().describe("Target document ID (defaults to active document)")
+      text: z6.string().describe("Status text"),
+      focusParagraph: z6.number().optional().describe("Index of paragraph Claude is focusing on"),
+      documentId: z6.string().optional().describe("Target document ID (defaults to active document)")
     },
     withErrorBoundary("tandem_setStatus", async ({ text, focusParagraph, documentId }) => {
       const current = getCurrentDoc(documentId);
@@ -4240,10 +5378,10 @@ function registerNavigationTools(server) {
     "tandem_getContext",
     "Read content around a range without pulling the full document. Reduces token usage.",
     {
-      from: z5.number().describe("Start position"),
-      to: z5.number().describe("End position"),
-      windowSize: z5.number().optional().describe("Characters of context before/after (default 500)"),
-      documentId: z5.string().optional().describe("Target document ID (defaults to active document)")
+      from: z6.number().describe("Start position"),
+      to: z6.number().describe("End position"),
+      windowSize: z6.number().optional().describe("Characters of context before/after (default 500)"),
+      documentId: z6.string().optional().describe("Target document ID (defaults to active document)")
     },
     withErrorBoundary(
       "tandem_getContext",
@@ -4283,6 +5421,7 @@ function createMcpServer() {
   registerAnnotationTools(server);
   registerNavigationTools(server);
   registerAwarenessTools(server);
+  registerApplyTools(server);
   return server;
 }
 function jsonrpcId(body) {
@@ -4640,8 +5779,8 @@ async function main() {
     ]);
     httpServer = srv;
     if (getOpenDocs().size === 0 && !process.env.TANDEM_NO_SAMPLE) {
-      const samplePath = path8.resolve(
-        path8.dirname(fileURLToPath2(import.meta.url)),
+      const samplePath = path9.resolve(
+        path9.dirname(fileURLToPath2(import.meta.url)),
         "../../sample/welcome.md"
       );
       openFileByPath(samplePath).then(() => {