tandem-editor 0.2.9 → 0.2.11

package/dist/server/index.js

@@ -92,7 +92,13 @@ async function startHocuspocus(port) {
         console.error(`[Hocuspocus] Merged pre-existing content into document: ${documentName}`);
       }
       documents.set(documentName, document);
-      onDocSwapped?.(documentName, document);
+      if (onDocSwapped) {
+        onDocSwapped(documentName, document);
+      } else {
+        console.error(
+          `[Tandem] WARN: onDocSwapped callback not registered during doc load for ${documentName}. Server-side observers will NOT be attached. Call setDocLifecycleCallbacks() before starting Hocuspocus.`
+        );
+      }
       return document;
     },
     async afterUnloadDocument({ documentName }) {
@@ -228,6 +234,25 @@ var init_platform = __esm({
 import fs from "fs/promises";
 import path2 from "path";
 import * as Y2 from "yjs";
+async function atomicWrite(sessionPath, content) {
+  const tmpPath = `${sessionPath}.tmp`;
+  await fs.writeFile(tmpPath, content, "utf-8");
+  for (let attempt = 0; attempt < RENAME_MAX_RETRIES; attempt++) {
+    try {
+      await fs.rename(tmpPath, sessionPath);
+      return;
+    } catch (err) {
+      const code = err.code;
+      if ((code === "EPERM" || code === "EACCES") && attempt < RENAME_MAX_RETRIES - 1) {
+        await new Promise((r) => setTimeout(r, RENAME_RETRY_BASE_MS * 2 ** attempt));
+        continue;
+      }
+      await fs.unlink(tmpPath).catch(() => {
+      });
+      throw err;
+    }
+  }
+}
 function sessionKey(filePath) {
   return encodeURIComponent(filePath.replace(/\\/g, "/"));
 }
@@ -255,15 +280,7 @@ async function saveSession(filePath, format, doc) {
     sessionDirReady = true;
   }
   const sessionPath = path2.join(SESSION_DIR, `${key}.json`);
-  const tmpPath = `${sessionPath}.tmp`;
-  await fs.writeFile(tmpPath, JSON.stringify(data), "utf-8");
-  try {
-    await fs.rename(tmpPath, sessionPath);
-  } catch (err) {
-    await fs.unlink(tmpPath).catch(() => {
-    });
-    throw err;
-  }
+  await atomicWrite(sessionPath, JSON.stringify(data));
 }
 async function loadSession(filePath) {
   const key = sessionKey(filePath);
@@ -334,15 +351,7 @@ async function saveCtrlSession(doc) {
   const ydocState = Buffer.from(state).toString("base64");
   const data = { ydocState, lastAccessed: Date.now() };
   const sessionPath = path2.join(SESSION_DIR, `${CTRL_SESSION_KEY}.json`);
-  const tmpPath = `${sessionPath}.tmp`;
-  await fs.writeFile(tmpPath, JSON.stringify(data), "utf-8");
-  try {
-    await fs.rename(tmpPath, sessionPath);
-  } catch (err) {
-    await fs.unlink(tmpPath).catch(() => {
-    });
-    throw err;
-  }
+  await atomicWrite(sessionPath, JSON.stringify(data));
 }
 async function loadCtrlSession() {
   const sessionPath = path2.join(SESSION_DIR, `${CTRL_SESSION_KEY}.json`);
@@ -441,7 +450,7 @@ function stopAutoSave() {
   }
   autoSaveCallback = null;
 }
-var AUTO_SAVE_INTERVAL, sessionDirReady, CTRL_SESSION_KEY, autoSaveTimer, autoSaveCallback;
+var AUTO_SAVE_INTERVAL, RENAME_MAX_RETRIES, RENAME_RETRY_BASE_MS, sessionDirReady, CTRL_SESSION_KEY, autoSaveTimer, autoSaveCallback;
 var init_manager = __esm({
   "src/server/session/manager.ts"() {
     "use strict";
@@ -449,6 +458,8 @@ var init_manager = __esm({
     init_constants();
     init_queue();
     AUTO_SAVE_INTERVAL = 60 * 1e3;
+    RENAME_MAX_RETRIES = 3;
+    RENAME_RETRY_BASE_MS = 50;
     sessionDirReady = false;
     CTRL_SESSION_KEY = CTRL_ROOM;
     autoSaveTimer = null;
@@ -456,6 +467,74 @@ var init_manager = __esm({
   }
 });
 
+// src/server/file-watcher.ts
+import fs2 from "fs";
+function watchFile(filePath, onChanged) {
+  if (watched.has(filePath)) return;
+  let watcher;
+  try {
+    watcher = fs2.watch(filePath, (eventType) => {
+      if (eventType !== "change") return;
+      const entry = watched.get(filePath);
+      if (!entry) return;
+      if (entry.suppressed) {
+        entry.suppressed = false;
+        return;
+      }
+      if (entry.timer !== null) {
+        clearTimeout(entry.timer);
+      }
+      entry.timer = setTimeout(() => {
+        entry.timer = null;
+        onChanged(filePath).catch((err) => {
+          console.error(`[FileWatcher] onChanged callback failed for ${filePath}:`, err);
+        });
+      }, 500);
+    });
+  } catch (err) {
+    console.error(`[FileWatcher] Failed to watch ${filePath}:`, err);
+    return;
+  }
+  watcher.on("error", (err) => {
+    console.error(`[FileWatcher] Watcher error for ${filePath}:`, err);
+    unwatchFile(filePath);
+  });
+  watched.set(filePath, { watcher, timer: null, suppressed: false });
+  console.error(`[FileWatcher] Watching ${filePath}`);
+}
+function suppressNextChange(filePath) {
+  const entry = watched.get(filePath);
+  if (entry) {
+    entry.suppressed = true;
+  }
+}
+function unwatchFile(filePath) {
+  const entry = watched.get(filePath);
+  if (!entry) return;
+  if (entry.timer !== null) {
+    clearTimeout(entry.timer);
+  }
+  try {
+    entry.watcher.close();
+  } catch (err) {
+    console.error(`[FileWatcher] watcher.close() failed for ${filePath}:`, err);
+  }
+  watched.delete(filePath);
+  console.error(`[FileWatcher] Unwatched ${filePath}`);
+}
+function unwatchAll() {
+  for (const filePath of [...watched.keys()]) {
+    unwatchFile(filePath);
+  }
+}
+var watched;
+var init_file_watcher = __esm({
+  "src/server/file-watcher.ts"() {
+    "use strict";
+    watched = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/server/file-io/mdast-ydoc.ts
 import * as Y3 from "yjs";
 function mdastToYDoc(doc, tree) {
@@ -1512,7 +1591,24 @@ function refreshRange(ann, ydoc, map) {
   }
   const newFrom = relPosToFlatOffset(ydoc, ann.relRange.fromRel);
   const newTo = relPosToFlatOffset(ydoc, ann.relRange.toRel);
-  if (newFrom === null || newTo === null) return ann;
+  if (newFrom === null || newTo === null) {
+    if (newFrom !== null || newTo !== null) {
+      console.error(
+        `[positions] refreshRange: partial CRDT resolution for ${ann.id} (from: ${newFrom !== null ? "ok" : "dead"}, to: ${newTo !== null ? "ok" : "dead"})`
+      );
+    }
+    const fromRel = flatOffsetToRelPos(ydoc, ann.range.from, 0);
+    const toRel = flatOffsetToRelPos(ydoc, ann.range.to, -1);
+    if (fromRel && toRel) {
+      const updated2 = { ...ann, relRange: { fromRel, toRel } };
+      if (map) map.set(ann.id, updated2);
+      return updated2;
+    }
+    const stripped = { ...ann };
+    delete stripped.relRange;
+    if (map) map.set(ann.id, stripped);
+    return stripped;
+  }
   if (newFrom > newTo) {
     console.error(
       `[positions] refreshRange: inverted CRDT range for annotation ${ann.id}: resolved [${newFrom}, ${newTo}] from flat [${ann.range.from}, ${ann.range.to}]`
@@ -2676,23 +2772,23 @@ var init_docx_apply = __esm({
 });
 
 // src/server/file-io/index.ts
-import fs2 from "fs/promises";
+import fs3 from "fs/promises";
 import path4 from "path";
 function getAdapter(format) {
   return adapters[format] ?? plaintextAdapter;
 }
-async function atomicWrite(filePath, content) {
+async function atomicWrite2(filePath, content) {
   const tempPath = path4.join(path4.dirname(filePath), `.tandem-tmp-${Date.now()}`);
-  await fs2.writeFile(tempPath, content, "utf-8");
-  await fs2.rename(tempPath, filePath);
+  await fs3.writeFile(tempPath, content, "utf-8");
+  await fs3.rename(tempPath, filePath);
 }
 async function atomicWriteBuffer(filePath, content) {
   const tempPath = path4.join(path4.dirname(filePath), `.tandem-tmp-${Date.now()}`);
-  await fs2.writeFile(tempPath, content);
+  await fs3.writeFile(tempPath, content);
   try {
-    await fs2.rename(tempPath, filePath);
+    await fs3.rename(tempPath, filePath);
   } catch (err) {
-    await fs2.unlink(tempPath).catch(() => {
+    await fs3.unlink(tempPath).catch(() => {
     });
     throw err;
   }
@@ -2755,6 +2851,58 @@ var init_file_io = __esm({
   }
 });
 
+// src/server/notifications.ts
+function pushNotification(notification) {
+  buffer.push(notification);
+  while (buffer.length > NOTIFICATION_BUFFER_SIZE) {
+    buffer.shift();
+  }
+  for (const cb of subscribers) {
+    try {
+      cb(notification);
+    } catch (err) {
+      console.error("[Notifications] Subscriber threw during dispatch:", err);
+    }
+  }
+}
+function subscribe(cb) {
+  subscribers.add(cb);
+  return () => {
+    subscribers.delete(cb);
+  };
+}
+var buffer, subscribers;
+var init_notifications = __esm({
+  "src/server/notifications.ts"() {
+    "use strict";
+    init_constants();
+    buffer = [];
+    subscribers = /* @__PURE__ */ new Set();
+  }
+});
+
+// src/shared/utils.ts
+function generateId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function generateAnnotationId() {
+  return generateId("ann");
+}
+function generateMessageId() {
+  return generateId("msg");
+}
+function generateEventId() {
+  return generateId("evt");
+}
+function generateNotificationId() {
+  return generateId("ntf");
+}
+var init_utils = __esm({
+  "src/shared/utils.ts"() {
+    "use strict";
+  }
+});
+
 // src/server/mcp/file-opener.ts
 var file_opener_exports = {};
 __export(file_opener_exports, {
@@ -2762,7 +2910,7 @@ __export(file_opener_exports, {
   openFileByPath: () => openFileByPath,
   openFileFromContent: () => openFileFromContent
 });
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 import fsSync from "fs";
 import path5 from "path";
 import { randomUUID } from "crypto";
@@ -2793,7 +2941,7 @@ async function openFileByPath(filePath, options) {
       { code: "UNSUPPORTED_FORMAT" }
     );
   }
-  const stat = await fs3.stat(resolved);
+  const stat = await fs4.stat(resolved);
   if (stat.size > MAX_FILE_SIZE) {
     throw Object.assign(new Error("File exceeds 50MB limit."), { code: "FILE_TOO_LARGE" });
   }
@@ -2862,7 +3010,7 @@ async function openFileByPath(filePath, options) {
   }
   if (!restoredFromSession) {
     const adapter = getAdapter(format);
-    const fileContent = isDocx ? await fs3.readFile(resolved) : await fs3.readFile(resolved, "utf-8");
+    const fileContent = isDocx ? await fs4.readFile(resolved) : await fs4.readFile(resolved, "utf-8");
     await adapter.load(doc, fileContent);
   }
   addDoc(id, { id, filePath: resolved, format, readOnly, source: "file" });
@@ -2871,6 +3019,9 @@ async function openFileByPath(filePath, options) {
   initSavedBaseline(doc);
   broadcastOpenDocs();
   ensureAutoSave();
+  if (format !== "docx") {
+    wireFileWatcher(id, resolved, format);
+  }
   return {
     ...buildResult(doc, {
       documentId: id,
@@ -2928,7 +3079,7 @@ async function clearAndReload(id, doc, filePath, format, existing) {
   let preparedComments;
   let preparedContent;
   if (isDocx) {
-    const buffer3 = await fs3.readFile(filePath);
+    const buffer3 = await fs4.readFile(filePath);
     [preparedHtml, preparedComments] = await Promise.all([
       loadDocx(buffer3),
       extractDocxComments(buffer3).catch((err) => {
@@ -2940,7 +3091,7 @@ async function clearAndReload(id, doc, filePath, format, existing) {
       })
     ]);
   } else {
-    preparedContent = await fs3.readFile(filePath, "utf-8");
+    preparedContent = await fs4.readFile(filePath, "utf-8");
   }
   try {
     doc.transact(() => {
@@ -3014,6 +3165,90 @@ function buildResult(doc, base) {
     ...warnings.length > 0 ? { warnings } : {}
   };
 }
+async function reloadFromDisk(id, filePath, format) {
+  if (reloadInProgress.has(id)) {
+    console.error(`[FileWatcher] reload already in progress for ${id}, skipping`);
+    return;
+  }
+  reloadInProgress.add(id);
+  try {
+    console.error(`[FileWatcher] reloadFromDisk: reloading ${id} from ${filePath}`);
+    const doc = getOrCreateDocument(id);
+    const fileContent = await fs4.readFile(filePath, "utf-8");
+    doc.transact(() => {
+      const awareness = doc.getMap(Y_MAP_AWARENESS);
+      awareness.forEach((_, k) => awareness.delete(k));
+      const userAwareness = doc.getMap(Y_MAP_USER_AWARENESS);
+      userAwareness.forEach((_, k) => userAwareness.delete(k));
+      if (format === "md") {
+        loadMarkdown(doc, fileContent);
+      } else {
+        populateYDoc(doc, fileContent);
+      }
+    }, MCP_ORIGIN);
+    const annotationMap = doc.getMap(Y_MAP_ANNOTATIONS);
+    const annotations = [];
+    annotationMap.forEach((val) => annotations.push(val));
+    if (annotations.length > 0) {
+      const refreshed = refreshAllRanges(annotations, doc, annotationMap);
+      doc.transact(() => {
+        for (const ann of refreshed) {
+          if (!ann.textSnapshot) continue;
+          const vr = validateRange(doc, ann.range.from, ann.range.to, {
+            textSnapshot: ann.textSnapshot
+          });
+          if (vr.ok) continue;
+          if (vr.code === "RANGE_MOVED") {
+            const relocated = anchoredRange(doc, vr.resolvedFrom, vr.resolvedTo, ann.textSnapshot);
+            if (relocated.ok) {
+              const updated = {
+                ...ann,
+                range: relocated.range,
+                relRange: relocated.fullyAnchored ? relocated.relRange : void 0
+              };
+              annotationMap.set(ann.id, updated);
+            }
+          }
+        }
+      }, MCP_ORIGIN);
+    }
+    attachObservers(id, doc);
+    console.error(`[FileWatcher] reloadFromDisk: complete for ${id}`);
+  } finally {
+    reloadInProgress.delete(id);
+  }
+}
+function wireFileWatcher(id, filePath, format) {
+  try {
+    watchFile(filePath, async () => {
+      try {
+        await reloadFromDisk(id, filePath, format);
+        pushNotification({
+          id: generateNotificationId(),
+          type: "file-reloaded",
+          severity: "info",
+          message: `File changed on disk \u2014 reloaded: ${path5.basename(filePath)}`,
+          documentId: id,
+          dedupKey: `reload:${id}`,
+          timestamp: Date.now()
+        });
+      } catch (err) {
+        console.error(`[FileWatcher] reloadFromDisk failed for ${filePath}:`, err);
+        pushNotification({
+          id: generateNotificationId(),
+          type: "general-error",
+          severity: "warning",
+          message: `Failed to reload ${path5.basename(filePath)} from disk`,
+          documentId: id,
+          dedupKey: `reload-error:${id}`,
+          timestamp: Date.now()
+        });
+      }
+    });
+  } catch (err) {
+    console.error(`[FileWatcher] wireFileWatcher failed for ${filePath}:`, err);
+  }
+}
 function ensureAutoSave() {
   if (isAutoSaveRunning()) return;
   startAutoSave(async () => {
@@ -3023,6 +3258,7 @@ function ensureAutoSave() {
     }
   });
 }
+var reloadInProgress;
 var init_file_opener = __esm({
   "src/server/mcp/file-opener.ts"() {
     "use strict";
@@ -3030,6 +3266,10 @@ var init_file_opener = __esm({
     init_constants();
     init_queue();
     init_file_io();
+    init_file_watcher();
+    init_positions2();
+    init_notifications();
+    init_utils();
     init_markdown();
     init_docx();
     init_docx_html();
@@ -3037,6 +3277,7 @@ var init_file_opener = __esm({
     init_manager();
     init_document_model();
     init_document_service();
+    reloadInProgress = /* @__PURE__ */ new Set();
   }
 });
 
@@ -3121,6 +3362,7 @@ async function closeDocumentById(id) {
     return { success: false, error: `Document ${id} not found.` };
   }
   const closedPath = docState.filePath;
+  unwatchFile(docState.filePath);
   try {
     const doc = getOrCreateDocument(id);
     await saveSession(docState.filePath, docState.format, doc);
@@ -3205,34 +3447,13 @@ var init_document_service = __esm({
     init_manager();
     init_constants();
     init_queue();
+    init_file_watcher();
     openDocs = /* @__PURE__ */ new Map();
     setShouldKeepDocument((name) => openDocs.has(name) || name === CTRL_ROOM);
     activeDocId = null;
   }
 });
 
-// src/shared/utils.ts
-function generateId(prefix) {
-  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-}
-function generateAnnotationId() {
-  return generateId("ann");
-}
-function generateMessageId() {
-  return generateId("msg");
-}
-function generateEventId() {
-  return generateId("evt");
-}
-function generateNotificationId() {
-  return generateId("ntf");
-}
-var init_utils = __esm({
-  "src/shared/utils.ts"() {
-    "use strict";
-  }
-});
-
 // src/server/events/types.ts
 var init_types3 = __esm({
   "src/server/events/types.ts"() {
@@ -3266,18 +3487,18 @@ function untrackPayloadId(event) {
   else emittedPayloadIds.set(id, count - 1);
 }
 function pushEvent(event) {
-  buffer.push(event);
+  buffer2.push(event);
   trackPayloadId(event);
-  while (buffer.length > CHANNEL_EVENT_BUFFER_SIZE) {
-    const evicted = buffer.shift();
+  while (buffer2.length > CHANNEL_EVENT_BUFFER_SIZE) {
+    const evicted = buffer2.shift();
     if (evicted) untrackPayloadId(evicted);
   }
   const now = Date.now();
-  while (buffer.length > 0 && now - buffer[0].timestamp > CHANNEL_EVENT_BUFFER_AGE_MS) {
-    const evicted = buffer.shift();
+  while (buffer2.length > 0 && now - buffer2[0].timestamp > CHANNEL_EVENT_BUFFER_AGE_MS) {
+    const evicted = buffer2.shift();
     if (evicted) untrackPayloadId(evicted);
   }
-  for (const cb of subscribers) {
+  for (const cb of subscribers2) {
     try {
       cb(event);
     } catch (err) {
@@ -3285,16 +3506,16 @@ function pushEvent(event) {
     }
   }
 }
-function subscribe(cb) {
-  subscribers.add(cb);
+function subscribe2(cb) {
+  subscribers2.add(cb);
 }
 function unsubscribe(cb) {
-  subscribers.delete(cb);
+  subscribers2.delete(cb);
 }
 function replaySince(lastEventId) {
-  const idx = buffer.findIndex((e) => e.id === lastEventId);
-  if (idx === -1) return [...buffer];
-  return buffer.slice(idx + 1);
+  const idx = buffer2.findIndex((e) => e.id === lastEventId);
+  if (idx === -1) return [...buffer2];
+  return buffer2.slice(idx + 1);
 }
 function attachObservers(docName, doc) {
   detachObservers(docName);
@@ -3471,7 +3692,7 @@ function attachCtrlObservers() {
 function reattachCtrlObservers() {
   attachCtrlObservers();
 }
-var MCP_ORIGIN, docObservers, emittedPayloadIds, buffer, subscribers, ctrlCleanups;
+var MCP_ORIGIN, docObservers, emittedPayloadIds, buffer2, subscribers2, ctrlCleanups;
 var init_queue = __esm({
   "src/server/events/queue.ts"() {
     "use strict";
@@ -3482,8 +3703,8 @@ var init_queue = __esm({
     MCP_ORIGIN = "mcp";
     docObservers = /* @__PURE__ */ new Map();
     emittedPayloadIds = /* @__PURE__ */ new Map();
-    buffer = [];
-    subscribers = /* @__PURE__ */ new Set();
+    buffer2 = [];
+    subscribers2 = /* @__PURE__ */ new Set();
     ctrlCleanups = [];
   }
 });
@@ -3663,34 +3884,12 @@ function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/server/notifications.ts
-init_constants();
-var buffer2 = [];
-var subscribers2 = /* @__PURE__ */ new Set();
-function pushNotification(notification) {
-  buffer2.push(notification);
-  while (buffer2.length > NOTIFICATION_BUFFER_SIZE) {
-    buffer2.shift();
-  }
-  for (const cb of subscribers2) {
-    try {
-      cb(notification);
-    } catch (err) {
-      console.error("[Notifications] Subscriber threw during dispatch:", err);
-    }
-  }
-}
-function subscribe2(cb) {
-  subscribers2.add(cb);
-  return () => {
-    subscribers2.delete(cb);
-  };
-}
-
 // src/server/mcp/document.ts
+init_notifications();
 init_utils();
 init_offsets();
 init_file_io();
+init_file_watcher();
 
 // src/server/mcp/convert.ts
 init_provider();
@@ -3698,7 +3897,7 @@ init_document_model();
 init_file_io();
 init_file_opener();
 init_document_service();
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import path7 from "path";
 async function findAvailablePath(basePath) {
   const dir = path7.dirname(basePath);
@@ -3709,7 +3908,7 @@ async function findAvailablePath(basePath) {
   let counter = 0;
   while (counter <= MAX_ATTEMPTS) {
     try {
-      await fs4.access(candidate);
+      await fs5.access(candidate);
       counter++;
       candidate = path7.join(dir, `${name}-${counter}${ext}`);
     } catch (err) {
@@ -3758,7 +3957,7 @@ async function convertToMarkdown(documentId, outputPath) {
       });
     }
     try {
-      const stat = await fs4.stat(resolvedOutput);
+      const stat = await fs5.stat(resolvedOutput);
       if (stat.isDirectory()) {
         const baseName = path7.basename(docState.filePath, path7.extname(docState.filePath));
         resolvedOutput = path7.join(resolvedOutput, `${baseName}.md`);
@@ -3772,7 +3971,7 @@ async function convertToMarkdown(documentId, outputPath) {
     resolvedOutput = path7.join(sourceDir, `${baseName}.md`);
   }
   resolvedOutput = await findAvailablePath(resolvedOutput);
-  await atomicWrite(resolvedOutput, markdown);
+  await atomicWrite2(resolvedOutput, markdown);
   try {
     const openResult = await openFileByPath(resolvedOutput);
     return {
@@ -4065,7 +4264,8 @@ function registerDocumentTools(server) {
           });
         }
         const output = adapter.save(r.doc);
-        await atomicWrite(r.filePath, output);
+        suppressNextChange(r.filePath);
+        await atomicWrite2(r.filePath, output);
         await saveSession(r.filePath, format, r.doc);
         const meta = r.doc.getMap(Y_MAP_DOCUMENT_META);
         r.doc.transact(() => meta.set(Y_MAP_SAVED_AT_VERSION, Date.now()), MCP_ORIGIN);
@@ -4202,6 +4402,7 @@ function registerDocumentTools(server) {
 init_docx();
 init_types2();
 init_positions2();
+init_notifications();
 init_utils();
 init_positions2();
 function getDocAndAnnotations(documentId) {
@@ -4583,6 +4784,7 @@ init_constants();
 init_document_model();
 init_file_opener();
 init_document_service();
+init_notifications();
 
 // src/server/mcp/docx-apply.ts
 init_document_service();
@@ -4591,7 +4793,7 @@ init_positions2();
 init_document_model();
 init_file_io();
 import { z as z4 } from "zod";
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 import path8 from "path";
 async function applyChangesCore(documentId, author, backupPath) {
   const r = requireDocument(documentId);
@@ -4673,21 +4875,21 @@ async function applyChangesCore(documentId, author, backupPath) {
     throw Object.assign(new Error("No accepted suggestions to apply."), { code: "NO_SUGGESTIONS" });
   }
   const ydocFlatText = extractText(ydoc);
-  const buffer3 = await fs5.readFile(filePath);
+  const buffer3 = await fs6.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);
+    await fs6.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)]);
+  await fs6.copyFile(filePath, resolvedBackup);
+  const [origStat, backupStat] = await Promise.all([fs6.stat(filePath), fs6.stat(resolvedBackup)]);
   if (origStat.size !== backupStat.size) {
     throw Object.assign(new Error("Backup verification failed: file sizes do not match."), {
       code: "BACKUP_FAILED"
@@ -4742,17 +4944,17 @@ function registerApplyTools(server) {
       const { filePath } = r;
       const backupPath = filePath.replace(/\.docx$/i, ".backup.docx");
       try {
-        await fs5.access(backupPath);
+        await fs6.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);
+      await fs6.copyFile(backupPath, filePath);
       const [backupStat, restoredStat] = await Promise.all([
-        fs5.stat(backupPath),
-        fs5.stat(filePath)
+        fs6.stat(backupPath),
+        fs6.stat(filePath)
       ]);
       if (backupStat.size !== restoredStat.size) {
         throw new Error("Restore verification failed: file sizes do not match.");
@@ -4856,7 +5058,7 @@ function notifyStreamHandler(req, res) {
     clearInterval(keepalive);
     unsubscribe2();
   }
-  const unsubscribe2 = subscribe2((notification) => {
+  const unsubscribe2 = subscribe((notification) => {
     try {
       res.write(`data: ${JSON.stringify(notification)}
 
@@ -5216,7 +5418,7 @@ function sseHandler(req, res) {
       unsubscribe(onEvent);
     }
   };
-  subscribe(onEvent);
+  subscribe2(onEvent);
   keepalive = setInterval(() => {
     res.write(": keepalive\n\n");
   }, CHANNEL_SSE_KEEPALIVE_MS);
@@ -5680,12 +5882,12 @@ init_manager();
 init_platform();
 
 // src/server/version-check.ts
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 import path9 from "path";
 async function checkVersionChange(currentVersion, versionFilePath) {
   let storedVersion = null;
   try {
-    storedVersion = (await fs6.readFile(versionFilePath, "utf-8")).trim();
+    storedVersion = (await fs7.readFile(versionFilePath, "utf-8")).trim();
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.error("[Tandem] Failed to read last-seen-version:", err);
@@ -5693,8 +5895,8 @@ async function checkVersionChange(currentVersion, versionFilePath) {
   }
   const result = storedVersion === null ? "first-install" : storedVersion === currentVersion ? "current" : "upgraded";
   if (result !== "current") {
-    await fs6.mkdir(path9.dirname(versionFilePath), { recursive: true });
-    await fs6.writeFile(versionFilePath, currentVersion, "utf-8");
+    await fs7.mkdir(path9.dirname(versionFilePath), { recursive: true });
+    await fs7.writeFile(versionFilePath, currentVersion, "utf-8");
   }
   return result;
 }
@@ -5718,6 +5920,7 @@ function isKnownHocuspocusError(err) {
 // src/server/index.ts
 init_queue();
 init_document_service();
+init_file_watcher();
 init_file_opener();
 init_document_model();
 
@@ -5855,6 +6058,7 @@ async function shutdown(signal) {
   isShuttingDown = true;
   console.error(`[Tandem] ${signal} received, saving session...`);
   try {
+    unwatchAll();
     await saveCurrentSession();
     stopAutoSave();
   } catch (err) {