tandem-editor 0.1.2 → 0.2.1

package/dist/server/index.js

@@ -71,12 +71,14 @@ async function startHocuspocus(port) {
     // stdout is the MCP wire — suppress the startup banner
     async onConnect({ request, documentName }) {
       const origin = request?.headers?.origin;
-      if (origin) {
-        const url = new URL(origin);
-        if (url.hostname !== "localhost" && url.hostname !== "127.0.0.1") {
-          console.error(`[Hocuspocus] Rejected connection from origin: ${origin}`);
-          throw new Error("Connection rejected: invalid origin");
-        }
+      if (!origin) {
+        console.error("[Hocuspocus] Rejected connection: missing Origin header");
+        throw new Error("Connection rejected: missing origin header");
+      }
+      const url = new URL(origin);
+      if (url.hostname !== "localhost" && url.hostname !== "127.0.0.1") {
+        console.error(`[Hocuspocus] Rejected connection from origin: ${origin}`);
+        throw new Error("Connection rejected: invalid origin");
       }
       console.error(`[Hocuspocus] Client connected to: ${documentName}`);
     },
@@ -144,7 +146,8 @@ function freePort(port) {
     } else {
       freePortUnix(port);
     }
-  } catch {
+  } catch (err) {
+    console.error(`[Tandem] freePort(${port}): ${err instanceof Error ? err.message : err}`);
   }
 }
 async function waitForPort(port, timeoutMs = 5e3) {
@@ -153,9 +156,7 @@ async function waitForPort(port, timeoutMs = 5e3) {
     if (await tryBind(port)) return;
     await new Promise((r) => setTimeout(r, 200));
   }
-  console.error(
-    `[Tandem] Warning: port ${port} still not available after ${timeoutMs}ms, proceeding anyway`
-  );
+  throw new Error(`Port ${port} still not available after ${timeoutMs}ms`);
 }
 function tryBind(port) {
   return new Promise((resolve, reject) => {
@@ -275,7 +276,16 @@ async function loadSession(filePath) {
   try {
     const content = await fs.readFile(sessionPath, "utf-8");
     return JSON.parse(content);
-  } catch {
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return null;
+    if (err instanceof SyntaxError) {
+      console.error(`[Tandem] Corrupted session file ${sessionPath}, removing:`, err.message);
+      await fs.unlink(sessionPath).catch(() => {
+      });
+      return null;
+    }
+    console.error(`[Tandem] Failed to read session ${sessionPath}:`, err);
     return null;
   }
 }
@@ -344,7 +354,16 @@ async function loadCtrlSession() {
     const content = await fs.readFile(sessionPath, "utf-8");
     const data = JSON.parse(content);
     return data.ydocState ?? null;
-  } catch {
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return null;
+    if (err instanceof SyntaxError) {
+      console.error(`[Tandem] Corrupted ctrl session ${sessionPath}, removing:`, err.message);
+      await fs.unlink(sessionPath).catch(() => {
+      });
+      return null;
+    }
+    console.error(`[Tandem] Failed to read ctrl session:`, err);
     return null;
   }
 }
@@ -378,18 +397,26 @@ async function listSessionFilePaths() {
 }
 async function cleanupSessions() {
   let cleaned = 0;
+  let files;
   try {
-    const files = await fs.readdir(SESSION_DIR);
-    const now = Date.now();
-    for (const file of files) {
+    files = await fs.readdir(SESSION_DIR);
+  } catch (err) {
+    if (err.code === "ENOENT") return 0;
+    console.error("[Tandem] Failed to read session directory:", err);
+    return 0;
+  }
+  const now = Date.now();
+  for (const file of files) {
+    try {
       const filePath = path2.join(SESSION_DIR, file);
       const stat = await fs.stat(filePath);
       if (now - stat.mtimeMs > SESSION_MAX_AGE) {
         await fs.unlink(filePath);
         cleaned++;
       }
+    } catch (err) {
+      console.error(`[Tandem] cleanupSessions: failed to process ${file}:`, err);
     }
-  } catch {
   }
   return cleaned;
 }
@@ -1200,9 +1227,11 @@ var init_docx_html = __esm({
       del: () => ({ strike: {} }),
       sup: () => ({ superscript: {} }),
       sub: () => ({ subscript: {} }),
-      a: (el) => ({
-        link: { href: el.attribs.href || "" }
-      })
+      a: (el) => {
+        const href = el.attribs.href || "";
+        const safeHref = /^https?:\/\//i.test(href) || href.startsWith("mailto:") ? href : "";
+        return { link: { href: safeHref } };
+      }
     };
     BLOCK_TAGS = /* @__PURE__ */ new Set([
       "h1",
@@ -1550,9 +1579,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 +1741,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,136 +1755,923 @@ 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);
+  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);
+      }
+    }
+  });
+  if (openRanges.size > 0) {
+    console.error(
+      `[docx-comments] ${openRanges.size} comment range(s) had start markers but no end markers: ${[...openRanges.keys()].join(", ")}`
+    );
+  }
+  return ranges;
+}
+function injectCommentsAsAnnotations(doc, comments) {
+  if (comments.length === 0) return 0;
+  const map = doc.getMap(Y_MAP_ANNOTATIONS);
+  let injected = 0;
+  doc.transact(() => {
+    for (const comment of comments) {
+      const result = anchoredRange(doc, toFlatOffset(comment.from), toFlatOffset(comment.to));
+      if (!result.ok) {
+        console.error(
+          `[docx-comments] Skipping imported comment ${comment.commentId}: range [${comment.from}, ${comment.to}] \u2014 ${result.code}`
+        );
+        continue;
+      }
+      const id = `import-${comment.commentId}-${Date.now()}`;
+      const content = comment.authorName !== "Unknown" ? `[${comment.authorName}] ${comment.bodyText}` : comment.bodyText;
+      const annotation = {
+        id,
+        author: "import",
+        type: "comment",
+        range: { from: result.range.from, to: result.range.to },
+        content,
+        status: "pending",
+        timestamp: comment.date ? new Date(comment.date).getTime() : Date.now()
+      };
+      if (result.fullyAnchored) {
+        annotation.relRange = result.relRange;
+      }
+      map.set(id, annotation);
+      injected++;
+    }
+  }, MCP_ORIGIN);
+  if (injected > 0 || comments.length > 0) {
+    console.error(`[docx-comments] Imported ${injected}/${comments.length} Word comments`);
+  }
+  return injected;
+}
+var init_docx_comments = __esm({
+  "src/server/file-io/docx-comments.ts"() {
+    "use strict";
+    init_constants();
+    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;
         }
-        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);
+      }
+    }
+  }
+  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;
+          }
         }
-      } 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);
+        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 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;
+  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);
+    }
   }
-  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(", ")}`
-    );
+  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" });
+    }
   }
-  return ranges;
+  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
+  };
 }
-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;
-      }
+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 });
   }
-  return 0;
-}
-function injectCommentsAsAnnotations(doc, comments) {
-  if (comments.length === 0) return 0;
-  const map = doc.getMap(Y_MAP_ANNOTATIONS);
-  let injected = 0;
-  doc.transact(() => {
-    for (const comment of comments) {
-      const result = anchoredRange(doc, toFlatOffset(comment.from), toFlatOffset(comment.to));
-      if (!result.ok) {
-        console.error(
-          `[docx-comments] Skipping imported comment ${comment.commentId}: range [${comment.from}, ${comment.to}] \u2014 ${result.code}`
-        );
-        continue;
+  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);
+        }
       }
-      const id = `import-${comment.commentId}-${Date.now()}`;
-      const content = comment.authorName !== "Unknown" ? `[${comment.authorName}] ${comment.bodyText}` : comment.bodyText;
-      const annotation = {
-        id,
-        author: "import",
-        type: "comment",
-        range: { from: result.range.from, to: result.range.to },
-        content,
-        status: "pending",
-        timestamp: comment.date ? new Date(comment.date).getTime() : Date.now()
-      };
-      if (result.fullyAnchored) {
-        annotation.relRange = result.relRange;
+      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);
       }
-      map.set(id, annotation);
-      injected++;
+      zip.file("word/commentsExtended.xml", render(doc, { xmlMode: true }));
     }
-  }, MCP_ORIGIN);
-  if (injected > 0 || comments.length > 0) {
-    console.error(`[docx-comments] Imported ${injected}/${comments.length} Word 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));
+  } 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 results;
+  return unique.length;
 }
-var init_docx_comments = __esm({
-  "src/server/file-io/docx-comments.ts"() {
+var COMPLEX_RUN_ELEMENTS, W15_NS;
+var init_docx_apply = __esm({
+  "src/server/file-io/docx-apply.ts"() {
     "use strict";
-    init_constants();
-    init_offsets();
-    init_positions2();
-    init_types2();
-    init_queue();
+    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 +2686,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 +2705,7 @@ var init_file_io = __esm({
     init_docx();
     init_docx_comments();
     init_document_model();
+    init_docx_apply();
     markdownAdapter = {
       canSave: true,
       load(doc, content) {
@@ -1813,7 +2770,13 @@ async function openFileByPath(filePath, options) {
   let resolved = path5.resolve(filePath);
   try {
     resolved = fsSync.realpathSync(resolved);
-  } catch {
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.error(
+        `[Tandem] realpathSync failed for ${filePath} (${code}), using path.resolve fallback`
+      );
+    }
     resolved = path5.resolve(filePath);
   }
   if (process.platform === "win32" && (resolved.startsWith("\\\\") || resolved.startsWith("//"))) {
@@ -2098,25 +3061,29 @@ function toDocListEntry(d) {
   };
 }
 function broadcastOpenDocs() {
+  const docList = Array.from(openDocs.values()).map(toDocListEntry);
+  const id = activeDocId;
   try {
-    const docList = Array.from(openDocs.values()).map(toDocListEntry);
-    const id = activeDocId;
     const ctrl = getOrCreateDocument(CTRL_ROOM);
     const ctrlMeta = ctrl.getMap(Y_MAP_DOCUMENT_META);
     ctrl.transact(() => {
       ctrlMeta.set("openDocuments", docList);
       ctrlMeta.set("activeDocumentId", id);
     }, MCP_ORIGIN);
-    for (const [docId] of openDocs) {
+  } catch (err) {
+    console.error("[Tandem] broadcastOpenDocs: failed to update CTRL_ROOM:", err);
+  }
+  for (const [docId] of openDocs) {
+    try {
       const ydoc = getOrCreateDocument(docId);
       const meta = ydoc.getMap(Y_MAP_DOCUMENT_META);
       ydoc.transact(() => {
         meta.set("openDocuments", docList);
         meta.set("activeDocumentId", id);
       }, MCP_ORIGIN);
+    } catch (err) {
+      console.error(`[Tandem] broadcastOpenDocs: failed to update doc ${docId}:`, err);
     }
-  } catch (err) {
-    console.error("[Tandem] broadcastOpenDocs error:", err);
   }
 }
 async function closeDocumentById(id) {
@@ -2184,7 +3151,8 @@ async function restoreOpenDocuments(previousActiveDocId) {
       const code = err.code;
       if (code === "ENOENT") {
         console.error(`[Tandem] Skipping deleted file (removing stale session): ${filePath}`);
-        deleteSession(filePath).catch(() => {
+        deleteSession(filePath).catch((err2) => {
+          console.error(`[Tandem] Failed to delete stale session for ${filePath}:`, err2);
         });
       } else {
         console.error(`[Tandem] Failed to restore ${filePath}:`, err);
@@ -2355,15 +3323,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 +3549,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
@@ -3272,7 +4241,14 @@ function createAnnotation(map, ydoc, type, anchored, content, extras) {
 }
 function collectAnnotations(map) {
   const result = [];
-  map.forEach((value) => result.push(value));
+  map.forEach((value, key) => {
+    const ann = value;
+    if (ann && typeof ann === "object" && typeof ann.id === "string" && typeof ann.type === "string" && typeof ann.status === "string" && ann.range && typeof ann.range.from === "number" && typeof ann.range.to === "number") {
+      result.push(ann);
+    } else {
+      console.warn(`[Tandem] Skipping malformed annotation entry: ${key}`);
+    }
+  });
   return result;
 }
 function registerAnnotationTools(server) {
@@ -3578,6 +4554,189 @@ 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"
+    });
+  }
+  if (backupPath) {
+    const resolvedBp = path8.resolve(backupPath);
+    if (process.platform === "win32" && (resolvedBp.startsWith("\\\\") || resolvedBp.startsWith("//"))) {
+      throw Object.assign(new Error("UNC paths are not supported for security reasons."), {
+        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 +4749,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 +4762,8 @@ function errorCodeToHttpStatus(code) {
       return 423;
     case "EACCES":
       return 403;
+    case "BACKUP_FAILED":
+      return 500;
     default:
       return 500;
   }
@@ -3624,11 +4787,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 +4801,8 @@ function errorCodeToLabel(code) {
       return "FILE_LOCKED";
     case "EACCES":
       return "PERMISSION_DENIED";
+    case "BACKUP_FAILED":
+      return "INTERNAL";
     default:
       return "INTERNAL";
   }
@@ -3676,7 +4843,11 @@ function notifyStreamHandler(req, res) {
   const keepalive = setInterval(() => {
     try {
       if (!res.writableEnded) res.write(": keepalive\n\n");
-    } catch {
+    } catch (err) {
+      console.error(
+        "[NotifyStream] Keepalive write failed, cleaning up:",
+        err instanceof Error ? err.message : err
+      );
       cleanup();
     }
   }, CHANNEL_SSE_KEEPALIVE_MS);
@@ -3767,11 +4938,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 +4978,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 +4999,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 +5028,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 +5121,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,22 +5317,31 @@ 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);
 }
 function searchText(fullText, query, useRegex) {
+  const MAX_MATCHES = 1e4;
   const matches = [];
   try {
     const pattern = useRegex ? new RegExp(query, "gi") : new RegExp(escapeRegex(query), "gi");
     let match;
+    const start = Date.now();
     while ((match = pattern.exec(fullText)) !== null) {
       matches.push({
         from: toFlatOffset(match.index),
         to: toFlatOffset(match.index + match[0].length),
         text: match[0]
       });
+      if (matches.length >= MAX_MATCHES) {
+        return { matches, error: `Search capped at ${MAX_MATCHES} matches` };
+      }
+      if (Date.now() - start > 2e3) {
+        return { matches, error: "Search timed out \u2014 simplify the regex pattern" };
+      }
+      if (match[0].length === 0) pattern.lastIndex++;
     }
   } catch (err) {
     return { matches: [], error: `Invalid regex: ${getErrorMessage(err)}` };
@@ -4176,9 +5382,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 +5399,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 +5416,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 +5446,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 +5489,7 @@ function createMcpServer() {
   registerAnnotationTools(server);
   registerNavigationTools(server);
   registerAwarenessTools(server);
+  registerApplyTools(server);
   return server;
 }
 function jsonrpcId(body) {
@@ -4362,14 +5569,18 @@ async function startMcpServerHttp(port, host = "127.0.0.1") {
     await currentTransport.handleRequest(req, res, req.body);
     currentTransport = null;
   });
-  app.get("/health", (_req, res) => {
-    res.json({
-      status: "ok",
-      version: APP_VERSION,
-      transport: "http",
-      hasSession: currentTransport !== null
-    });
-  });
+  app.get(
+    "/health",
+    apiMiddleware,
+    (_req, res) => {
+      res.json({
+        status: "ok",
+        version: APP_VERSION,
+        transport: "http",
+        hasSession: currentTransport !== null
+      });
+    }
+  );
   app.get(
     "/.well-known/oauth-protected-resource/mcp",
     (_req, res) => {
@@ -4438,7 +5649,7 @@ function isKnownHocuspocusError(err) {
   }
   const msg = err.message;
   if (msg.startsWith("WebSocket is not open")) return true;
-  if (msg === "Unexpected end of array" || msg === "Integer out of Range") return true;
+  if (msg.includes("Unexpected end of array") || msg.includes("Integer out of Range")) return true;
   if (msg.startsWith("Received a message with an unknown type:")) return true;
   return false;
 }
@@ -4631,7 +5842,11 @@ async function main() {
   if (transportMode === "http") {
     freePort(wsPort);
     freePort(mcpPort);
-    await Promise.all([waitForPort(wsPort), waitForPort(mcpPort)]);
+    try {
+      await Promise.all([waitForPort(wsPort), waitForPort(mcpPort)]);
+    } catch (err) {
+      console.error(`[Tandem] ${err instanceof Error ? err.message : err} \u2014 proceeding anyway`);
+    }
     const [srv] = await Promise.all([
       startMcpServerHttp(mcpPort),
       startHocuspocus(wsPort).then(() => {
@@ -4640,8 +5855,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(() => {
@@ -4667,7 +5882,11 @@ async function main() {
   } else {
     (async () => {
       freePort(wsPort);
-      await waitForPort(wsPort);
+      try {
+        await waitForPort(wsPort);
+      } catch (err) {
+        console.error(`[Tandem] ${err instanceof Error ? err.message : err} \u2014 proceeding anyway`);
+      }
       await startHocuspocus(wsPort);
       console.error(`[Tandem] Hocuspocus WebSocket server running on ws://localhost:${wsPort}`);
     })().catch((err) => {