leafrelay 0.2.2 → 0.2.4

package/dist/{chunk-Q3R5N4YE.js → chunk-OZ4FLSVP.js}

@@ -18,10 +18,12 @@ import { createHash } from "crypto";
 import { posix } from "path";
 import DiffMatchPatch from "diff-match-patch";
 import { posix as posix2 } from "path";
+import DiffMatchPatch2 from "diff-match-patch";
 import { createHash as createHash2 } from "crypto";
 import { diff3Merge } from "node-diff3";
-import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3, resolve as resolve4 } from "path";
+import { randomUUID } from "crypto";
+import { mkdir as mkdir3, readFile as readFile4, readdir as readdir2, rename, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join2, resolve as resolve4 } from "path";
 var PACKET_TYPES = [
   "disconnect",
   "connect",
@@ -152,6 +154,7 @@ var OverleafRealtimeSocket = class {
   cookie;
   socket;
   connected = false;
+  projectJoined = false;
   explicitlyDisconnected = false;
   reconnectEnabled;
   reconnectAttempts = 0;
@@ -160,7 +163,6 @@ var OverleafRealtimeSocket = class {
   closeTimeoutMs = 6e4;
   acknowledgementId = 0;
   acknowledgements = /* @__PURE__ */ new Map();
-  sendBuffer = [];
   io = {
     reconnect: (enabled) => {
       this.reconnectEnabled = enabled;
@@ -192,15 +194,24 @@ var OverleafRealtimeSocket = class {
     if (id && callback) {
       this.acknowledgements.set(id, callback);
     }
-    this.send(encodePacket({
+    const packet = encodePacket({
       type: "event",
       id,
       ack: callback ? "data" : void 0,
       name: event,
       args
-    }));
+    });
+    if (!this.sendApplicationEvent(packet) && callback) {
+      if (id) {
+        this.acknowledgements.delete(id);
+      }
+      queueMicrotask(() => callback(new Error("The Overleaf project session is not connected.")));
+    }
     return this;
   }
+  markProjectJoined() {
+    this.projectJoined = true;
+  }
   disconnect() {
     this.explicitlyDisconnected = true;
     this.reconnectEnabled = false;
@@ -215,6 +226,7 @@ var OverleafRealtimeSocket = class {
   }
   async connect() {
     try {
+      this.projectJoined = false;
       const handshakeUrl = new URL("/socket.io/1/", this.endpoint.origin);
       for (const [name, value] of this.endpoint.searchParams) {
         handshakeUrl.searchParams.set(name, value);
@@ -243,7 +255,7 @@ var OverleafRealtimeSocket = class {
       this.socket.addEventListener("open", () => this.events.emit("connecting", "websocket"));
       this.socket.addEventListener("message", (event) => void this.receive(event.data));
       this.socket.addEventListener("error", (error2) => this.events.emit("error", error2));
-      this.socket.addEventListener("close", () => this.handleClose());
+      this.socket.addEventListener("close", (event) => this.handleClose(event));
     } catch (error2) {
       this.events.emit("connect_failed", error2);
       this.events.emit("error", error2);
@@ -263,7 +275,6 @@ var OverleafRealtimeSocket = class {
         const wasReconnecting = this.reconnectAttempts > 0;
         this.connected = true;
         this.events.emit("connect");
-        this.flush();
         if (wasReconnecting) {
           this.events.emit("reconnect", "websocket", this.reconnectAttempts);
           this.reconnectAttempts = 0;
@@ -309,16 +320,16 @@ var OverleafRealtimeSocket = class {
     }
   }
   send(packet) {
-    if (!this.connected || this.socket?.readyState !== WebSocket.OPEN) {
-      this.sendBuffer.push(packet);
-      return;
+    if (this.connected && this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(packet);
     }
-    this.socket.send(packet);
   }
-  flush() {
-    while (this.sendBuffer.length > 0 && this.socket?.readyState === WebSocket.OPEN) {
-      this.socket.send(this.sendBuffer.shift());
+  sendApplicationEvent(packet) {
+    if (!this.connected || !this.projectJoined || this.socket?.readyState !== WebSocket.OPEN) {
+      return false;
     }
+    this.socket.send(packet);
+    return true;
   }
   resetInactivityTimer() {
     if (this.inactivityTimer) {
@@ -326,20 +337,25 @@ var OverleafRealtimeSocket = class {
     }
     this.inactivityTimer = setTimeout(() => this.closeSocket("timeout"), this.closeTimeoutMs);
   }
-  handleClose() {
+  handleClose(event) {
     const wasConnected = this.connected;
     this.connected = false;
+    this.projectJoined = false;
     if (this.inactivityTimer) {
       clearTimeout(this.inactivityTimer);
     }
     if (wasConnected) {
-      this.events.emit("disconnect", "transport close");
+      const detail = event.reason ? `: ${event.reason}` : "";
+      const reason = `transport close (code ${event.code})${detail}`;
+      this.failAcknowledgements(reason);
+      this.events.emit("disconnect", reason);
     }
     this.scheduleReconnect();
   }
   closeSocket(reason) {
     const wasConnected = this.connected;
     this.connected = false;
+    this.projectJoined = false;
     if (this.inactivityTimer) {
       clearTimeout(this.inactivityTimer);
     }
@@ -347,12 +363,20 @@ var OverleafRealtimeSocket = class {
     this.socket = void 0;
     socket?.close();
     if (wasConnected) {
+      this.failAcknowledgements(reason);
       this.events.emit("disconnect", reason);
     }
     if (!this.explicitlyDisconnected) {
       this.scheduleReconnect();
     }
   }
+  failAcknowledgements(reason) {
+    const error2 = new Error(`Overleaf realtime connection closed: ${reason}`);
+    for (const callback of this.acknowledgements.values()) {
+      callback(error2);
+    }
+    this.acknowledgements.clear();
+  }
   scheduleReconnect() {
     if (!this.reconnectEnabled || this.explicitlyDisconnected || this.reconnectTimer) {
       return;
@@ -1188,6 +1212,8 @@ var SocketIOAPI = class _SocketIOAPI {
   static alternativeSocketFactory;
   scheme;
   record;
+  joinedProject;
+  pendingProjectJoin;
   _handlers = [];
   connectedPublicId;
   socket;
@@ -1224,6 +1250,8 @@ var SocketIOAPI = class _SocketIOAPI {
         break;
       case "realtime":
         this.record = void 0;
+        this.joinedProject = void 0;
+        this.resetProjectJoin(new Error("The realtime connection was replaced."));
         const query = `?projectId=${this.projectId}&t=${Date.now()}`;
         this.socket = this.api._initSocketV0(this.identity, query);
         break;
@@ -1266,6 +1294,11 @@ var SocketIOAPI = class _SocketIOAPI {
     });
     this.socket.on("disconnect", (reason) => {
       log("SocketIOAPI: disconnect event", { scheme: this.scheme, projectId: this.projectId, reason });
+      if (this.scheme === "realtime") {
+        this.joinedProject = void 0;
+        this.connectedPublicId = void 0;
+        this.resetProjectJoin(new Error(`Overleaf realtime connection closed: ${String(reason ?? "unknown")}`));
+      }
     });
     this.socket.on("reconnecting", (delay, attempt) => {
       log("SocketIOAPI: reconnecting", { scheme: this.scheme, projectId: this.projectId, delay, attempt });
@@ -1290,21 +1323,49 @@ var SocketIOAPI = class _SocketIOAPI {
       error(`Overleaf connection error: ${message}`);
     });
     if (this.scheme === "realtime") {
-      this.record = new Promise((resolve6, reject) => {
-        this.socket.on("joinProjectResponse", (res) => {
-          const publicId = res.publicId;
-          const project = res.project;
-          this.connectedPublicId = publicId;
-          for (const handler of this._handlers) {
-            handler.onConnectionAccepted?.(publicId);
-          }
-          resolve6(project);
-        });
-        this.socket.on("connectionRejected", (err) => {
-          reject(err?.message || err);
-        });
+      this.pendingProjectJoin ??= this.createProjectJoin();
+      this.socket.on("joinProjectResponse", (res) => {
+        const publicId = res.publicId;
+        const project = res.project;
+        this.socket.markProjectJoined?.();
+        log("SocketIOAPI: project joined", { scheme: this.scheme, projectId: this.projectId, publicId });
+        this.connectedPublicId = publicId;
+        this.joinedProject = project;
+        this.pendingProjectJoin?.resolve(project);
+        for (const handler of this._handlers) {
+          handler.onProjectJoined?.(project);
+          handler.onConnectionAccepted?.(publicId);
+        }
       });
+      this.socket.on("connectionRejected", (err) => {
+        this.pendingProjectJoin?.reject(err?.message || err);
+      });
+    }
+  }
+  createProjectJoin() {
+    let resolve6;
+    let reject;
+    const promise = new Promise((resolveProject, rejectProject) => {
+      resolve6 = resolveProject;
+      reject = rejectProject;
+    });
+    void promise.catch(() => void 0);
+    return { promise, resolve: resolve6, reject };
+  }
+  resetProjectJoin(reason) {
+    if (reason !== void 0) {
+      this.pendingProjectJoin?.reject(reason);
+    }
+    this.pendingProjectJoin = this.createProjectJoin();
+  }
+  waitForRealtimeProject() {
+    return this.joinedProject ? Promise.resolve(this.joinedProject) : this.pendingProjectJoin.promise;
+  }
+  async emitProjectEvent(event, ...args) {
+    if (this.scheme === "realtime") {
+      await this.waitForRealtimeProject();
     }
+    return this.emit(event, ...args);
   }
   disconnect() {
     this.socket.disconnect();
@@ -1364,10 +1425,12 @@ var SocketIOAPI = class _SocketIOAPI {
           });
           break;
         case handlers.onDisconnected:
-          this.socket.on("disconnect", () => {
-            handler();
+          this.socket.on("disconnect", (reason) => {
+            handler(reason);
           });
           break;
+        case handlers.onProjectJoined:
+          break;
         case handlers.onConnectionAccepted:
           this.socket.on("connectionAccepted", (_, publicId) => {
             handler(publicId);
@@ -1437,7 +1500,7 @@ var SocketIOAPI = class _SocketIOAPI {
           timeoutPromise
         ]);
       case "realtime":
-        return Promise.race([this.record, timeoutPromise]);
+        return Promise.race([this.waitForRealtimeProject(), timeoutPromise]);
     }
   }
   /**
@@ -1446,7 +1509,7 @@ var SocketIOAPI = class _SocketIOAPI {
    * @returns {Promise}
    */
   async joinDoc(docId) {
-    return this.emit("joinDoc", docId, { encodeRanges: true }).then((returns) => {
+    return this.emitProjectEvent("joinDoc", docId, { encodeRanges: true }).then((returns) => {
       const [docLinesAscii, version, updates, ranges] = returns;
       const docLines = docLinesAscii.map((line) => decodePackedUtf8(line));
       return { docLines, version, updates, ranges };
@@ -1458,7 +1521,7 @@ var SocketIOAPI = class _SocketIOAPI {
    * @returns {Promise}
    */
   async leaveDoc(docId) {
-    return this.emit("leaveDoc", docId).then(() => {
+    return this.emitProjectEvent("leaveDoc", docId).then(() => {
       return;
     });
   }
@@ -1470,7 +1533,7 @@ var SocketIOAPI = class _SocketIOAPI {
    */
   async applyOtUpdate(docId, update) {
     try {
-      await this.emit("applyOtUpdate", docId, update);
+      await this.emitProjectEvent("applyOtUpdate", docId, update);
     } catch (error2) {
       let detail;
       if (error2 instanceof Error) {
@@ -1492,7 +1555,7 @@ var SocketIOAPI = class _SocketIOAPI {
    * @returns {Promise}
    */
   async getConnectedUsers() {
-    return this.emit("clientTracking.getConnectedUsers").then((returns) => {
+    return this.emitProjectEvent("clientTracking.getConnectedUsers").then((returns) => {
       const [connectedUsers] = returns;
       return connectedUsers;
     });
@@ -1503,7 +1566,7 @@ var SocketIOAPI = class _SocketIOAPI {
    * @returns {Promise}
    */
   async updatePosition(doc_id, row, column) {
-    return this.emit("clientTracking.updatePosition", { row, column, doc_id }).then(() => {
+    return this.emitProjectEvent("clientTracking.updatePosition", { row, column, doc_id }).then(() => {
       return;
     });
   }
@@ -1767,7 +1830,9 @@ var RemoteProject = class {
   project;
   entries = /* @__PURE__ */ new Map();
   idToPath = /* @__PURE__ */ new Map();
+  collaboratorNames = /* @__PURE__ */ new Map();
   changeHandler;
+  reconnectHandler;
   externalTransport;
   async connect() {
     if (this.externalTransport) {
@@ -1782,6 +1847,7 @@ var RemoteProject = class {
       this.socket = new SocketIOAPI(this.url, this.api, this.identity, this.projectId);
     }
     this.project = await this.socket.joinProject(this.projectId);
+    this.indexCollaborators();
     this.reindex();
     this.registerEvents();
   }
@@ -1792,6 +1858,19 @@ var RemoteProject = class {
   }
   onChange(handler) {
     this.changeHandler = handler;
+    return () => {
+      if (this.changeHandler === handler) {
+        this.changeHandler = void 0;
+      }
+    };
+  }
+  onReconnect(handler) {
+    this.reconnectHandler = handler;
+    return () => {
+      if (this.reconnectHandler === handler) {
+        this.reconnectHandler = void 0;
+      }
+    };
   }
   listEntries() {
     return [...this.entries.values()];
@@ -2006,11 +2085,40 @@ var RemoteProject = class {
       collection.splice(index, 1);
     }
   }
-  emitChange(path, previousPath) {
-    this.changeHandler?.({ path: normalizePath(path), previousPath });
+  emitChange(path, previousPath, actor) {
+    this.changeHandler?.({ path: normalizePath(path), previousPath, actor });
+  }
+  indexCollaborators() {
+    for (const member of [this.project.owner, ...this.project.members]) {
+      if (!member?._id) {
+        continue;
+      }
+      const name = [member.first_name, member.last_name].filter(Boolean).join(" ").trim();
+      if (name) {
+        this.collaboratorNames.set(member._id, name);
+      }
+    }
+  }
+  actor(userId) {
+    if (!userId) {
+      return void 0;
+    }
+    const name = this.collaboratorNames.get(userId);
+    return name ? `${name} (Overleaf)` : `Overleaf user ${userId}`;
   }
   registerEvents() {
     this.socket.updateEventHandlers({
+      onProjectJoined: (project) => {
+        this.project = project;
+        this.indexCollaborators();
+        this.reindex();
+        this.reconnectHandler?.();
+      },
+      onClientUpdated: (user) => {
+        if (user.user_id && user.name) {
+          this.collaboratorNames.set(user.user_id, user.name);
+        }
+      },
       onFileCreated: (parentId, type, entity) => {
         const parent = this.folderById(parentId);
         if (!parent || type === "outputs") {
@@ -2075,12 +2183,121 @@ var RemoteProject = class {
       onFileChanged: (update) => {
         const path = this.idToPath.get(update.doc);
         if (path) {
-          this.emitChange(path);
+          this.emitChange(path, void 0, this.actor(update.meta?.user_id));
         }
       }
     });
   }
 };
+var decoder = new TextDecoder("utf-8", { fatal: true });
+function decode(content) {
+  if (content === void 0) {
+    return "";
+  }
+  if (content.includes(0)) {
+    return void 0;
+  }
+  try {
+    return decoder.decode(content);
+  } catch {
+    return void 0;
+  }
+}
+function lineStarts(content) {
+  const starts = [0];
+  for (let index = 0; index < content.length; index++) {
+    if (content[index] === "\n" && index + 1 < content.length) {
+      starts.push(index + 1);
+    }
+  }
+  return starts;
+}
+function lineAt(starts, offset) {
+  let low = 0;
+  let high = starts.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (starts[middle] <= offset) {
+      low = middle + 1;
+    } else {
+      high = middle;
+    }
+  }
+  return Math.max(1, low);
+}
+function toLineRange(content, start, end) {
+  const starts = lineStarts(content);
+  const safeStart = Math.min(start, Math.max(0, content.length - 1));
+  const safeEnd = Math.min(Math.max(start, end - 1), Math.max(0, content.length - 1));
+  return { start: lineAt(starts, safeStart), end: lineAt(starts, safeEnd) };
+}
+function mergeRanges(ranges) {
+  const merged = [];
+  for (const range of ranges.sort((a, b) => a.start - b.start)) {
+    const previous = merged.at(-1);
+    if (previous && range.start <= previous.end + 1) {
+      previous.end = Math.max(previous.end, range.end);
+    } else {
+      merged.push({ ...range });
+    }
+  }
+  return merged;
+}
+function formatRanges(ranges) {
+  const shown = ranges.slice(0, 3).map((range) => range.start === range.end ? String(range.start) : `${range.start}-${range.end}`);
+  return `${shown.join(", ")}${ranges.length > shown.length ? ` (+${ranges.length - shown.length} more)` : ""}`;
+}
+function describeContentChange(before, after) {
+  if (before && after && Buffer.from(before).equals(Buffer.from(after))) {
+    return void 0;
+  }
+  const oldText = decode(before);
+  const newText = decode(after);
+  if (oldText === void 0 || newText === void 0) {
+    return `binary bytes ${before?.byteLength ?? 0} -> ${after?.byteLength ?? 0}`;
+  }
+  if (oldText.length === 0 && newText.length === 0) {
+    return void 0;
+  }
+  if (oldText.length === 0) {
+    const count = lineStarts(newText).length;
+    return `added lines ${count === 1 ? "1" : `1-${count}`}`;
+  }
+  if (newText.length === 0) {
+    const count = lineStarts(oldText).length;
+    return `removed lines ${count === 1 ? "1" : `1-${count}`}`;
+  }
+  const changes = [];
+  let oldOffset = 0;
+  let newOffset = 0;
+  let current;
+  const finish = () => {
+    if (current) {
+      changes.push(current);
+      current = void 0;
+    }
+  };
+  for (const [operation, value] of new DiffMatchPatch2().diff_main(oldText, newText)) {
+    if (operation === 0) {
+      finish();
+      oldOffset += value.length;
+      newOffset += value.length;
+      continue;
+    }
+    current ??= { oldStart: oldOffset, oldEnd: oldOffset, newStart: newOffset, newEnd: newOffset };
+    if (operation === -1) {
+      oldOffset += value.length;
+    }
+    if (operation === 1) {
+      newOffset += value.length;
+    }
+    current.oldEnd = oldOffset;
+    current.newEnd = newOffset;
+  }
+  finish();
+  const ranges = mergeRanges(changes.map((change) => change.newEnd > change.newStart ? toLineRange(newText, change.newStart, change.newEnd) : toLineRange(oldText, change.oldStart, change.oldEnd)));
+  return ranges.length === 0 ? void 0 : `lines ${formatRanges(ranges)}`;
+}
 var textDecoder = new TextDecoder("utf-8", { fatal: true });
 var textEncoder = new TextEncoder();
 function decodeText(content) {
@@ -2120,32 +2337,19 @@ function mergeText(baseContent, localContent, remoteContent) {
     content: textEncoder.encode(regions.flatMap((region) => region.ok ?? []).join(""))
   };
 }
-var SYNC_STATE_SCHEMA_VERSION = 2;
+var SYNC_STATE_SCHEMA_VERSION = 1;
 function sha256(content) {
   return createHash2("sha256").update(content).digest("hex");
 }
-function parseSyncState(serialized, projectUri) {
-  try {
-    const state = JSON.parse(serialized);
-    if (state.schemaVersion !== 1 && state.schemaVersion !== SYNC_STATE_SCHEMA_VERSION || state.projectUri !== projectUri || !Number.isInteger(state.remoteVersion) || typeof state.files !== "object" || state.files === null) {
-      return void 0;
-    }
-    return {
-      ...state,
-      schemaVersion: SYNC_STATE_SCHEMA_VERSION,
-      textBases: typeof state.textBases === "object" && state.textBases !== null ? state.textBases : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-function createSyncState(projectUri, remoteVersion) {
+function createSyncState(projectUri, remoteVersion, initialized = true) {
   return {
     schemaVersion: SYNC_STATE_SCHEMA_VERSION,
     projectUri,
     remoteVersion,
+    initialized,
     files: {},
-    textBases: {}
+    textBases: {},
+    conflicts: {}
   };
 }
 function updateSyncCheckpoint(state, path, content) {
@@ -2158,10 +2362,12 @@ function updateSyncCheckpoint(state, path, content) {
   }
 }
 function removeSyncCheckpoint(state, path) {
-  for (const checkpointPath of Object.keys(state.files)) {
+  const checkpointPaths = /* @__PURE__ */ new Set([...Object.keys(state.files), ...Object.keys(state.conflicts)]);
+  for (const checkpointPath of checkpointPaths) {
     if (checkpointPath === path || checkpointPath.startsWith(`${path}/`)) {
       delete state.files[checkpointPath];
       delete state.textBases[checkpointPath];
+      delete state.conflicts[checkpointPath];
     }
   }
 }
@@ -2184,41 +2390,54 @@ var SyncEngine = class {
   queue = Promise.resolve();
   conflicts = /* @__PURE__ */ new Set();
   stopLocalWatch;
+  stopRemoteChange;
+  stopRemoteReconnect;
   eventTimers = /* @__PURE__ */ new Map();
+  stopped = false;
   async start() {
+    this.stopped = false;
     this.state = await this.options.stateStore.load();
     const currentVersion = await this.options.remote.getCurrentVersion();
     const localFiles = await this.options.local.listFiles();
     const remoteFiles = this.remoteFilePaths();
-    if (!this.state) {
-      this.state = createSyncState(this.options.projectUri, currentVersion);
-      if (localFiles.length !== 0 && remoteFiles.length !== 0) {
-        throw new Error("Synchronization paused: both the local and Overleaf projects contain files, but no common checkpoint exists.");
-      }
-      const source = localFiles.length === 0 ? "remote" : "local";
-      for (const path of source === "remote" ? remoteFiles : localFiles) {
-        await this.reconcilePath(path, source);
-      }
-      this.state.remoteVersion = currentVersion;
-      await this.options.stateStore.save(this.state);
+    if (!this.state || !this.state.initialized) {
+      await this.initializeState(currentVersion, localFiles, remoteFiles);
     } else {
+      this.restoreConflicts();
       await this.startupReconcile(currentVersion, localFiles, remoteFiles);
     }
     this.stopLocalWatch = await this.options.local.watch((path) => this.schedule(path, "local"));
-    this.options.remote.onChange((change) => {
+    this.stopRemoteChange = this.options.remote.onChange((change) => {
+      if (this.stopped) {
+        return;
+      }
       if (change.previousPath) {
-        this.schedule(change.previousPath, "remote");
+        this.schedule(change.previousPath, "remote", change.actor);
+      }
+      this.schedule(change.path, "remote", change.actor);
+    });
+    this.stopRemoteReconnect = this.options.remote.onReconnect?.(() => {
+      if (this.stopped) {
+        return;
       }
-      this.schedule(change.path, "remote");
+      this.queue = this.queue.then(() => this.reconcileAfterReconnect()).catch((error2) => {
+        this.options.log(`Failed to reconcile after reconnecting: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      });
     });
     this.options.log(`Synchronization active at Overleaf version ${this.state.remoteVersion}.`);
   }
   async stop() {
-    for (const timer of this.eventTimers.values()) {
-      clearTimeout(timer);
+    this.stopped = true;
+    this.stopRemoteChange?.();
+    this.stopRemoteChange = void 0;
+    this.stopRemoteReconnect?.();
+    this.stopRemoteReconnect = void 0;
+    for (const pending of this.eventTimers.values()) {
+      clearTimeout(pending.timer);
     }
     this.eventTimers.clear();
     await this.stopLocalWatch?.();
+    this.stopLocalWatch = void 0;
     await this.queue;
   }
   getConflicts() {
@@ -2254,15 +2473,95 @@ var SyncEngine = class {
         await this.options.local.remove(normalized);
         removeSyncCheckpoint(this.state, normalized);
       }
-      await this.options.stateStore.save(this.state);
       this.conflicts.delete(normalized);
+      delete this.state.conflicts[normalized];
+      await this.options.stateStore.save(this.state);
       this.options.log(`Resolved ${normalized} using ${winner === "local" ? "local" : "Overleaf"} content.`);
     });
   }
   async retry(path) {
     const normalized = normalizePath2(path);
+    const reason = this.state.conflicts[normalized];
     this.conflicts.delete(normalized);
-    await this.enqueue(() => this.reconcilePath(normalized, "local"));
+    delete this.state.conflicts[normalized];
+    try {
+      await this.enqueue(() => this.reconcilePath(normalized, "local"));
+    } catch (error2) {
+      if (reason !== void 0) {
+        this.conflicts.add(normalized);
+        this.state.conflicts[normalized] = reason;
+        await this.options.stateStore.save(this.state);
+      }
+      throw error2;
+    }
+  }
+  async initializeState(currentVersion, localFiles, remoteFiles) {
+    if (!this.state) {
+      this.state = createSyncState(this.options.projectUri, currentVersion, false);
+      await this.options.stateStore.save(this.state);
+    }
+    this.restoreConflicts();
+    const paths = /* @__PURE__ */ new Set([...localFiles, ...remoteFiles, ...Object.keys(this.state.files)]);
+    for (const path of [...paths].sort()) {
+      const normalized = normalizePath2(path);
+      if (this.conflicts.has(normalized)) {
+        continue;
+      }
+      if (this.state.files[normalized] !== void 0) {
+        await this.reconcilePath(normalized, "local");
+        continue;
+      }
+      await this.initializePath(normalized);
+    }
+    this.state.remoteVersion = currentVersion;
+    this.state.initialized = true;
+    await this.options.stateStore.save(this.state);
+    if (this.conflicts.size !== 0) {
+      this.options.log(`Synchronization remains active; ${this.conflicts.size} conflicting path(s) are paused.`);
+    }
+  }
+  async initializePath(path) {
+    const remoteEntry = this.options.remote.entry(path);
+    if (remoteEntry?.type === "folder") {
+      return;
+    }
+    const localContent = await this.options.local.read(path);
+    const remoteContent = isRemoteFile(remoteEntry) ? await this.options.remote.read(path) : void 0;
+    const localHash = localContent && sha256(localContent);
+    const remoteHash = remoteContent && sha256(remoteContent);
+    if (localHash === remoteHash) {
+      if (localContent) {
+        updateSyncCheckpoint(this.state, path, localContent);
+        await this.options.stateStore.save(this.state);
+      }
+      return;
+    }
+    if (!localContent && remoteContent) {
+      await this.options.local.write(path, remoteContent);
+      updateSyncCheckpoint(this.state, path, remoteContent);
+      await this.options.stateStore.save(this.state);
+      this.logChange("pull", "add", path, void 0, remoteContent);
+      return;
+    }
+    await this.recordConflict(
+      path,
+      remoteContent ? "Local and Overleaf content differ, but no common checkpoint exists." : "The local path has no matching Overleaf file and no common checkpoint exists."
+    );
+  }
+  restoreConflicts() {
+    for (const [path, reason] of Object.entries(this.state.conflicts)) {
+      if (this.conflicts.has(path)) {
+        continue;
+      }
+      this.conflicts.add(path);
+      this.options.onConflict(path, reason);
+    }
+  }
+  async recordConflict(path, reason) {
+    this.conflicts.add(path);
+    this.state.conflicts[path] = reason;
+    await this.options.stateStore.save(this.state);
+    this.options.onConflict(path, reason);
   }
   async startupReconcile(currentVersion, localFiles, remoteFiles) {
     const state = this.state;
@@ -2291,6 +2590,11 @@ var SyncEngine = class {
     }
     const candidates = new Set(localChanged);
     const knownFiles = /* @__PURE__ */ new Set([...Object.keys(state.files), ...localFiles, ...remoteFiles]);
+    for (const path of [...localFiles, ...remoteFiles]) {
+      if (state.files[path] === void 0) {
+        candidates.add(path);
+      }
+    }
     for (const change of remoteDiff.diff) {
       const paths = [change.pathname, change.newPathname].filter((path) => Boolean(path));
       for (const changedPath of paths.map(normalizePath2)) {
@@ -2324,30 +2628,61 @@ var SyncEngine = class {
       this.options.log(`Synchronization remains active; ${this.conflicts.size} conflicting path(s) are paused.`);
     }
   }
-  schedule(path, source) {
+  async reconcileAfterReconnect() {
+    if (this.stopped) {
+      return;
+    }
+    const currentVersion = await this.options.remote.getCurrentVersion();
+    await this.startupReconcile(
+      currentVersion,
+      await this.options.local.listFiles(),
+      this.remoteFilePaths()
+    );
+    this.options.log(`Realtime connection restored at Overleaf version ${currentVersion}.`);
+  }
+  schedule(path, source, actor) {
     const normalized = normalizePath2(path);
-    if (this.shouldIgnore(normalized) || this.conflicts.has(normalized)) {
+    if (this.stopped || this.shouldIgnore(normalized) || this.conflicts.has(normalized)) {
       return;
     }
     const previous = this.eventTimers.get(normalized);
     if (previous) {
-      clearTimeout(previous);
+      clearTimeout(previous.timer);
     }
-    this.eventTimers.set(normalized, setTimeout(() => {
-      this.eventTimers.delete(normalized);
-      this.queue = this.queue.then(() => this.reconcilePath(normalized, source)).catch((error2) => {
-        this.options.log(`Failed to synchronize ${normalized}: ${error2 instanceof Error ? error2.message : String(error2)}`);
-      });
-    }, 250));
+    const actors = previous?.actors ?? /* @__PURE__ */ new Set();
+    let unknownRemoteActor = previous?.unknownRemoteActor ?? false;
+    if (source === "remote") {
+      if (actor) {
+        actors.add(actor);
+      } else {
+        unknownRemoteActor = true;
+      }
+    }
+    const pending = {
+      source: previous?.source === "local" || source === "local" ? "local" : "remote",
+      actors,
+      unknownRemoteActor,
+      timer: setTimeout(() => {
+        this.eventTimers.delete(normalized);
+        if (this.stopped) {
+          return;
+        }
+        const remoteActor = pending.unknownRemoteActor ? void 0 : pending.actors.size === 1 ? [...pending.actors][0] : pending.actors.size > 1 ? "multiple Overleaf collaborators" : void 0;
+        this.queue = this.queue.then(() => this.reconcilePath(normalized, pending.source, remoteActor)).catch((error2) => {
+          this.options.log(`Failed to synchronize ${normalized}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        });
+      }, 250)
+    };
+    this.eventTimers.set(normalized, pending);
   }
   enqueue(operation) {
     const result = this.queue.then(operation);
     this.queue = result.then(() => void 0, () => void 0);
     return result;
   }
-  async reconcilePath(path, source) {
+  async reconcilePath(path, source, actor) {
     const normalized = normalizePath2(path);
-    if (this.shouldIgnore(normalized) || this.conflicts.has(normalized)) {
+    if (this.stopped || this.shouldIgnore(normalized) || this.conflicts.has(normalized)) {
       return;
     }
     const remoteEntry = this.options.remote.entry(normalized);
@@ -2357,38 +2692,43 @@ var SyncEngine = class {
     const localContent = await this.options.local.read(normalized);
     const remoteContent = isRemoteFile(remoteEntry) ? await this.options.remote.read(normalized) : void 0;
     const baseHash = this.state.files[normalized];
+    const baseContent = readTextBase(this.state, normalized);
     const localHash = localContent && sha256(localContent);
     const remoteHash = remoteContent && sha256(remoteContent);
     if (localHash === remoteHash) {
-      if (localContent) {
-        updateSyncCheckpoint(this.state, normalized, localContent);
-      } else {
-        removeSyncCheckpoint(this.state, normalized);
+      if (localHash !== baseHash) {
+        if (localContent) {
+          updateSyncCheckpoint(this.state, normalized, localContent);
+        } else {
+          removeSyncCheckpoint(this.state, normalized);
+        }
+        await this.options.stateStore.save(this.state);
       }
-      await this.options.stateStore.save(this.state);
       return;
     }
     const localChanged = localHash !== baseHash;
     const remoteChanged = remoteHash !== baseHash;
     if (localChanged && remoteChanged) {
-      const base = readTextBase(this.state, normalized);
-      if (base && localContent && remoteContent) {
-        const merged = mergeText(base, localContent, remoteContent);
+      if (baseContent && localContent && remoteContent) {
+        const merged = mergeText(baseContent, localContent, remoteContent);
         if (merged.status === "merged" && merged.content) {
           await this.options.local.write(normalized, merged.content);
           await this.options.remote.write(normalized, merged.content);
           updateSyncCheckpoint(this.state, normalized, merged.content);
           await this.options.stateStore.save(this.state);
-          this.logChange("merge", "update", normalized);
+          this.logChange("merge", "update", normalized, baseContent, merged.content, actor);
           return;
         }
       }
-      this.conflicts.add(normalized);
       const reason = "Both local and Overleaf content changed since the last synchronized checkpoint.";
-      this.options.onConflict(normalized, reason);
+      await this.recordConflict(normalized, reason);
+      return;
+    }
+    if (source === "remote" && localChanged && !remoteChanged) {
       return;
     }
     if (localChanged || !remoteChanged && source === "local") {
+      let pushedContent = localContent;
       if (!localContent) {
         if (remoteEntry) {
           await this.options.remote.remove(normalized);
@@ -2400,13 +2740,21 @@ var SyncEngine = class {
         if (sha256(synchronized) !== sha256(localContent)) {
           await this.options.local.write(normalized, synchronized);
         }
+        pushedContent = synchronized;
         updateSyncCheckpoint(this.state, normalized, synchronized);
       }
       await this.options.stateStore.save(this.state);
       if (!localContent && remoteEntry) {
-        this.logChange("push", "delete", normalized);
+        this.logChange("push", "delete", normalized, baseContent ?? remoteContent, void 0, actor);
       } else if (localContent) {
-        this.logChange("push", remoteEntry ? "update" : "add", normalized);
+        this.logChange(
+          "push",
+          remoteEntry ? "update" : "add",
+          normalized,
+          baseContent ?? remoteContent,
+          pushedContent,
+          actor
+        );
       }
       return;
     }
@@ -2421,13 +2769,26 @@ var SyncEngine = class {
     }
     await this.options.stateStore.save(this.state);
     if (!remoteContent && localContent) {
-      this.logChange("pull", "delete", normalized);
+      this.logChange("pull", "delete", normalized, baseContent ?? localContent, void 0, actor);
     } else if (remoteContent) {
-      this.logChange("pull", localContent ? "update" : "add", normalized);
-    }
-  }
-  logChange(direction, operation, path) {
-    this.options.log(`[${direction}] ${operation} ${JSON.stringify(path)}`);
+      this.logChange(
+        "pull",
+        localContent ? "update" : "add",
+        normalized,
+        baseContent ?? localContent,
+        remoteContent,
+        actor
+      );
+    }
+  }
+  logChange(direction, operation, path, before, after, actor) {
+    const summary = describeContentChange(before, after);
+    const source = direction === "push" ? "local filesystem" : direction === "pull" ? actor ?? "Overleaf" : `local filesystem + ${actor ?? "Overleaf"}`;
+    this.options.log([
+      `[${direction}] ${operation} ${JSON.stringify(path)}`,
+      summary,
+      `source=${source}`
+    ].filter(Boolean).join("; "));
   }
   remoteFilePaths() {
     return this.options.remote.listEntries().filter((entry) => isRemoteFile(entry) && !this.shouldIgnore(entry.path)).map((entry) => entry.path);
@@ -2436,39 +2797,325 @@ var SyncEngine = class {
     return this.options.ignore(path) || path.split("/").some((part) => part.startsWith("."));
   }
 };
+var HASH_PATTERN = /^[a-f0-9]{64}$/;
+var encoder = new TextEncoder();
+function json(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function pathKey(path) {
+  return sha256(encoder.encode(path));
+}
+async function readJson(path) {
+  return JSON.parse(await readFile4(path, "utf8"));
+}
+async function listFiles(directory) {
+  const result = [];
+  const visit = async (current) => {
+    let entries;
+    try {
+      entries = await readdir2(current, { withFileTypes: true });
+    } catch (error2) {
+      if (error2.code === "ENOENT") {
+        return;
+      }
+      throw error2;
+    }
+    for (const entry of entries) {
+      const path = join2(current, entry.name);
+      if (entry.isDirectory()) {
+        await visit(path);
+      } else if (entry.isFile()) {
+        result.push(path);
+      }
+    }
+  };
+  await visit(directory);
+  return result;
+}
+async function atomicWrite(path, content) {
+  await mkdir3(dirname3(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile3(temporary, content);
+    await rename(temporary, path);
+  } finally {
+    await rm2(temporary, { force: true });
+  }
+}
+function parseFormat(value, projectUri) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const format = value;
+  return format.schemaVersion === SYNC_STATE_SCHEMA_VERSION && format.projectUri === projectUri;
+}
+function parseCursor(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const cursor = value;
+  return Number.isInteger(cursor.remoteVersion) && cursor.remoteVersion >= 0 && typeof cursor.initialized === "boolean";
+}
+function parsePathRecord(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value;
+  if (typeof record.path !== "string" || !record.path.startsWith("/")) {
+    return false;
+  }
+  if (record.hash !== void 0 && (typeof record.hash !== "string" || !HASH_PATTERN.test(record.hash))) {
+    return false;
+  }
+  if (record.baseHash !== void 0 && (typeof record.baseHash !== "string" || !HASH_PATTERN.test(record.baseHash) || record.hash !== record.baseHash)) {
+    return false;
+  }
+  if (record.conflict !== void 0 && typeof record.conflict !== "string") {
+    return false;
+  }
+  return record.hash !== void 0 || record.conflict !== void 0;
+}
+function createRecord(state, path) {
+  const hash = state.files[path];
+  const textBase = state.textBases[path];
+  const conflict = state.conflicts[path];
+  if (hash === void 0 && conflict === void 0) {
+    return void 0;
+  }
+  return {
+    path,
+    ...hash === void 0 ? {} : { hash },
+    ...textBase === void 0 ? {} : { baseHash: hash },
+    ...conflict === void 0 ? {} : { conflict }
+  };
+}
 var FileSyncStateStore = class {
   constructor(directory, projectUri) {
     this.projectUri = projectUri;
-    this.path = resolve4(directory, ".overleaf", "sync-state.json");
+    const overleafDirectory = resolve4(directory, ".overleaf");
+    this.legacyPath = join2(overleafDirectory, "sync-state.json");
+    this.syncDirectory = join2(overleafDirectory, "sync");
+    this.formatPath = join2(this.syncDirectory, "format.json");
+    this.cursorPath = join2(this.syncDirectory, "cursor.json");
+    this.pathsDirectory = join2(this.syncDirectory, "paths");
+    this.basesDirectory = join2(this.syncDirectory, "bases");
   }
   projectUri;
-  path;
-  serialized;
+  legacyPath;
+  syncDirectory;
+  formatPath;
+  cursorPath;
+  pathsDirectory;
+  basesDirectory;
+  persistedRecords = /* @__PURE__ */ new Map();
+  persistedCursor;
+  invalidRecordPaths = /* @__PURE__ */ new Set();
+  initialized = false;
   async load() {
+    this.invalidRecordPaths.clear();
     try {
-      const content = await readFile4(this.path, "utf8");
-      const state = parseSyncState(content, this.projectUri);
-      if (state) {
-        this.serialized = `${JSON.stringify(state, null, 2)}
-`;
+      const format = await readJson(this.formatPath);
+      const cursor = await readJson(this.cursorPath);
+      if (!parseFormat(format, this.projectUri) || !parseCursor(cursor)) {
+        return void 0;
+      }
+      const state = {
+        schemaVersion: SYNC_STATE_SCHEMA_VERSION,
+        projectUri: this.projectUri,
+        remoteVersion: cursor.remoteVersion,
+        initialized: cursor.initialized,
+        files: {},
+        textBases: {},
+        conflicts: {}
+      };
+      const records = /* @__PURE__ */ new Map();
+      const referencedBases = /* @__PURE__ */ new Set();
+      let stateIncomplete = false;
+      for (const recordPath of await listFiles(this.pathsDirectory)) {
+        const record = await this.loadRecord(recordPath);
+        if (!record) {
+          if (recordPath.endsWith(".json")) {
+            this.invalidRecordPaths.add(recordPath);
+            stateIncomplete = true;
+          } else {
+            await rm2(recordPath, { force: true });
+          }
+          continue;
+        }
+        if (record.hash !== void 0) {
+          state.files[record.path] = record.hash;
+        }
+        if (record.baseHash !== void 0) {
+          let textBase;
+          try {
+            textBase = await readFile4(this.basePath(record.baseHash), "utf8");
+          } catch (error2) {
+            if (error2.code === "ENOENT") {
+              this.invalidRecordPaths.add(recordPath);
+              stateIncomplete = true;
+              delete state.files[record.path];
+              continue;
+            }
+            throw error2;
+          }
+          if (sha256(encoder.encode(textBase)) !== record.baseHash) {
+            this.invalidRecordPaths.add(recordPath);
+            stateIncomplete = true;
+            delete state.files[record.path];
+            continue;
+          }
+          state.textBases[record.path] = textBase;
+          referencedBases.add(record.baseHash);
+        }
+        if (record.conflict !== void 0) {
+          state.conflicts[record.path] = record.conflict;
+        }
+        records.set(record.path, json(record));
+      }
+      if (stateIncomplete) {
+        state.initialized = false;
       }
+      await this.removeOrphanBases(referencedBases);
+      this.persistedRecords = records;
+      this.persistedCursor = json(cursor);
+      this.initialized = true;
       return state;
     } catch (error2) {
-      if (error2.code === "ENOENT") {
+      if (error2.code === "ENOENT" || error2 instanceof SyntaxError) {
         return void 0;
       }
       throw error2;
     }
   }
   async save(state) {
-    const serialized = `${JSON.stringify(state, null, 2)}
-`;
-    if (serialized === this.serialized) {
+    if (state.projectUri !== this.projectUri || state.schemaVersion !== SYNC_STATE_SCHEMA_VERSION) {
+      throw new Error("Cannot persist synchronization state for a different project or schema.");
+    }
+    if (!this.initialized) {
+      await this.initializeStorage();
+    }
+    const paths = /* @__PURE__ */ new Set([
+      ...this.persistedRecords.keys(),
+      ...Object.keys(state.files),
+      ...Object.keys(state.conflicts)
+    ]);
+    const obsoleteBases = /* @__PURE__ */ new Set();
+    for (const path of [...paths].sort()) {
+      const record = createRecord(state, path);
+      const serialized = record && json(record);
+      const previous = this.persistedRecords.get(path);
+      if (serialized === previous) {
+        continue;
+      }
+      if (previous) {
+        const previousRecord = JSON.parse(previous);
+        if (previousRecord.baseHash) {
+          obsoleteBases.add(previousRecord.baseHash);
+        }
+      }
+      if (!record || !serialized) {
+        await rm2(this.recordPath(path), { force: true });
+        this.persistedRecords.delete(path);
+        continue;
+      }
+      if (record.baseHash) {
+        const textBase = state.textBases[path];
+        if (textBase === void 0 || sha256(encoder.encode(textBase)) !== record.baseHash) {
+          throw new Error(`Text checkpoint does not match its content hash: ${path}`);
+        }
+        await this.writeBase(record.baseHash, textBase);
+      }
+      const destination = this.recordPath(path);
+      await atomicWrite(destination, serialized);
+      this.invalidRecordPaths.delete(destination);
+      this.persistedRecords.set(path, serialized);
+    }
+    const cursor = json({ remoteVersion: state.remoteVersion, initialized: state.initialized });
+    if (cursor !== this.persistedCursor) {
+      await atomicWrite(this.cursorPath, cursor);
+      this.persistedCursor = cursor;
+    }
+    if (state.initialized) {
+      await Promise.all([...this.invalidRecordPaths].map((path) => rm2(path, { force: true })));
+      this.invalidRecordPaths.clear();
+    }
+    await rm2(this.legacyPath, { force: true });
+    await this.removeObsoleteBases(state, obsoleteBases);
+  }
+  async initializeStorage() {
+    await rm2(this.syncDirectory, { recursive: true, force: true });
+    await mkdir3(this.pathsDirectory, { recursive: true });
+    await mkdir3(this.basesDirectory, { recursive: true });
+    await atomicWrite(this.formatPath, json({
+      schemaVersion: SYNC_STATE_SCHEMA_VERSION,
+      projectUri: this.projectUri
+    }));
+    this.persistedRecords.clear();
+    this.persistedCursor = void 0;
+    this.invalidRecordPaths.clear();
+    this.initialized = true;
+  }
+  recordPath(path) {
+    const key = pathKey(path);
+    return join2(this.pathsDirectory, key.slice(0, 2), `${key}.json`);
+  }
+  async loadRecord(recordPath) {
+    if (!recordPath.endsWith(".json")) {
+      return void 0;
+    }
+    try {
+      const record = await readJson(recordPath);
+      if (!parsePathRecord(record) || recordPath !== this.recordPath(record.path)) {
+        return void 0;
+      }
+      return record;
+    } catch (error2) {
+      if (error2.code === "ENOENT" || error2 instanceof SyntaxError) {
+        return void 0;
+      }
+      throw error2;
+    }
+  }
+  basePath(hash) {
+    return join2(this.basesDirectory, hash.slice(0, 2), `${hash}.txt`);
+  }
+  async writeBase(hash, content) {
+    const path = this.basePath(hash);
+    try {
+      if (sha256(encoder.encode(await readFile4(path, "utf8"))) === hash) {
+        return;
+      }
+    } catch (error2) {
+      if (error2.code !== "ENOENT") {
+        throw error2;
+      }
+    }
+    await atomicWrite(path, content);
+  }
+  async removeObsoleteBases(state, candidates) {
+    if (candidates.size === 0) {
       return;
     }
-    await mkdir3(dirname3(this.path), { recursive: true });
-    await writeFile3(this.path, serialized, "utf8");
-    this.serialized = serialized;
+    const referenced = /* @__PURE__ */ new Set();
+    for (const [path, textBase] of Object.entries(state.textBases)) {
+      if (textBase !== void 0 && state.files[path] !== void 0) {
+        referenced.add(state.files[path]);
+      }
+    }
+    for (const hash of candidates) {
+      if (!referenced.has(hash)) {
+        await rm2(this.basePath(hash), { force: true });
+      }
+    }
+  }
+  async removeOrphanBases(referencedHashes) {
+    const referencedPaths = new Set([...referencedHashes].map((hash) => this.basePath(hash)));
+    for (const path of await listFiles(this.basesDirectory)) {
+      if (!referencedPaths.has(path)) {
+        await rm2(path, { force: true });
+      }
+    }
   }
 };
 async function startServe(directory = process.cwd(), options = {}) {
@@ -2534,4 +3181,4 @@ export {
   RemoteProject,
   startServe
 };
-//# sourceMappingURL=chunk-Q3R5N4YE.js.map
+//# sourceMappingURL=chunk-OZ4FLSVP.js.map