leafrelay 0.2.6 → 0.2.7

package/dist/{chunk-FBT2UYMY.js → chunk-3TTRDNHP.js}

@@ -2449,19 +2449,30 @@ var SyncEngine = class {
   stopRemoteReconnect;
   eventTimers = /* @__PURE__ */ new Map();
   stopped = false;
+  failedPaths = /* @__PURE__ */ new Map();
+  retryTimer;
+  retryDelayMs = 3e4;
+  pendingRemoteVersion;
+  pendingInitialization = false;
+  get syncError() {
+    if (this.failedPaths.size === 0) {
+      return void 0;
+    }
+    const [path, failure] = this.failedPaths.entries().next().value;
+    return `${this.failedPaths.size} path(s) could not synchronize, including ${path}: ${failure.message}. Other paths remain active; failed paths will retry automatically.`;
+  }
   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();
-    this.options.log(`Checking replica at Overleaf version ${currentVersion}: ${localFiles.length} local file(s), ${remoteFiles.length} remote file(s).`);
-    if (!this.state || !this.state.initialized) {
-      await this.initializeState(currentVersion, localFiles, remoteFiles);
-    } else {
-      this.restoreConflicts();
-      await this.startupReconcile(currentVersion, localFiles, remoteFiles);
+    const startup = this.enqueue(() => this.initialize());
+    try {
+      await startup;
+    } catch (error2) {
+      await this.stop();
+      throw error2;
     }
+  }
+  async initialize() {
+    this.state = await this.options.stateStore.load();
     this.stopLocalWatch = await this.options.local.watch((path) => this.schedule(path, "local"));
     this.stopRemoteChange = this.options.remote.onChange((change) => {
       if (this.stopped) {
@@ -2480,10 +2491,24 @@ var SyncEngine = class {
         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}.`);
+    const currentVersion = await this.options.remote.getCurrentVersion();
+    const localFiles = await this.options.local.listFiles();
+    const remoteFiles = this.remoteFilePaths();
+    this.options.log(`Checking replica at Overleaf version ${currentVersion}: ${localFiles.length} local file(s), ${remoteFiles.length} remote file(s).`);
+    if (!this.state || !this.state.initialized) {
+      await this.initializeState(currentVersion, localFiles, remoteFiles);
+    } else {
+      this.restoreConflicts();
+      await this.startupReconcile(currentVersion, localFiles, remoteFiles);
+    }
+    this.options.log(this.syncError ? `Synchronization active with pending retries. ${this.syncError}` : `Synchronization active at Overleaf version ${this.state.remoteVersion}.`);
   }
   async stop() {
     this.stopped = true;
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = void 0;
+    }
     this.stopRemoteChange?.();
     this.stopRemoteChange = void 0;
     this.stopRemoteReconnect?.();
@@ -2557,21 +2582,25 @@ var SyncEngine = class {
       await this.options.stateStore.save(this.state);
     }
     this.restoreConflicts();
+    this.pendingRemoteVersion = currentVersion;
+    this.pendingInitialization = true;
     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;
+      try {
+        if (this.state.files[normalized] !== void 0) {
+          await this.synchronizePath(normalized, "local");
+        } else {
+          await this.initializePath(normalized);
+        }
+      } catch (error2) {
+        this.recordFailure(normalized, "local", error2);
       }
-      await this.initializePath(normalized);
     }
-    this.state.remoteVersion = currentVersion;
-    this.state.initialized = true;
-    await this.options.stateStore.save(this.state);
+    await this.finishRemoteBatch();
     if (this.conflicts.size !== 0) {
       this.options.log(`Synchronization remains active; ${this.conflicts.size} conflicting path(s) are paused.`);
     }
@@ -2644,7 +2673,7 @@ var SyncEngine = class {
         throw new Error("Synchronization paused: Overleaf history is unavailable, so remote changes cannot be distinguished safely.");
       }
     }
-    const candidates = new Set(localChanged);
+    const candidates = /* @__PURE__ */ new Set([...localChanged, ...this.failedPaths.keys()]);
     const knownFiles = /* @__PURE__ */ new Set([...Object.keys(state.files), ...localFiles, ...remoteFiles]);
     for (const path of [...localFiles, ...remoteFiles]) {
       if (state.files[path] === void 0) {
@@ -2652,6 +2681,9 @@ var SyncEngine = class {
       }
     }
     for (const change of remoteDiff.diff) {
+      if (!change.operation) {
+        continue;
+      }
       const paths = [change.pathname, change.newPathname].filter((path) => Boolean(path));
       for (const changedPath of paths.map(normalizePath2)) {
         let matched = false;
@@ -2666,21 +2698,19 @@ var SyncEngine = class {
         }
       }
     }
-    let failed = false;
+    this.pendingRemoteVersion = currentVersion;
     this.options.log(`Reconciling ${candidates.size} changed path(s).`);
     for (const path of [...candidates].sort()) {
+      if (this.stopped) {
+        return;
+      }
       try {
-        await this.reconcilePath(path, localChanged.has(path) ? "local" : "remote");
+        await this.synchronizePath(path, localChanged.has(path) ? "local" : "remote");
       } catch (error2) {
-        failed = true;
-        this.options.log(`Failed to synchronize ${path}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        this.recordFailure(path, localChanged.has(path) ? "local" : "remote", error2);
       }
     }
-    if (failed) {
-      throw new Error("Synchronization paused for failed paths; successful paths were checkpointed.");
-    }
-    state.remoteVersion = currentVersion;
-    await this.options.stateStore.save(state);
+    await this.finishRemoteBatch();
     if (this.conflicts.size !== 0) {
       this.options.log(`Synchronization remains active; ${this.conflicts.size} conflicting path(s) are paused.`);
     }
@@ -2695,7 +2725,7 @@ var SyncEngine = class {
       await this.options.local.listFiles(),
       this.remoteFilePaths()
     );
-    this.options.log(`Realtime connection restored at Overleaf version ${currentVersion}.`);
+    this.options.log(this.syncError ? `Realtime connection restored; ${this.syncError}` : `Realtime connection restored at Overleaf version ${currentVersion}.`);
   }
   schedule(path, source, actor) {
     const normalized = normalizePath2(path);
@@ -2725,13 +2755,72 @@ var SyncEngine = class {
           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)}`);
+        this.queue = this.queue.then(() => this.synchronizePath(normalized, pending.source, remoteActor)).catch((error2) => {
+          this.recordFailure(normalized, pending.source, error2, remoteActor);
         });
       }, 250)
     };
     this.eventTimers.set(normalized, pending);
   }
+  async synchronizePath(path, source, actor) {
+    if (this.pendingInitialization && this.state.files[path] === void 0) {
+      await this.initializePath(path);
+    } else {
+      await this.reconcilePath(path, source, actor);
+    }
+    if (this.failedPaths.delete(path)) {
+      this.options.onSyncError?.(this.syncError);
+    }
+  }
+  recordFailure(path, source, error2, actor) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    this.failedPaths.set(path, { source, actor, message });
+    this.options.log(`Failed to synchronize ${path}: ${message}; retrying without stopping other paths.`);
+    this.options.onSyncError?.(this.syncError);
+    this.scheduleRetry();
+  }
+  scheduleRetry() {
+    if (this.stopped || this.retryTimer || this.failedPaths.size === 0) {
+      return;
+    }
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = void 0;
+      void this.enqueue(async () => {
+        if (this.stopped) {
+          return;
+        }
+        for (const [path, failure] of [...this.failedPaths]) {
+          if (this.stopped) {
+            return;
+          }
+          try {
+            await this.synchronizePath(path, failure.source, failure.actor);
+            this.options.log(`Recovered synchronization for ${path}.`);
+          } catch (error2) {
+            const message = error2 instanceof Error ? error2.message : String(error2);
+            this.failedPaths.set(path, { ...failure, message });
+            this.options.log(`Retry failed for ${path}: ${message}`);
+          }
+        }
+        await this.finishRemoteBatch();
+      }).catch((error2) => this.options.log(`Could not checkpoint retry batch: ${String(error2)}`)).finally(() => {
+        this.retryDelayMs = this.failedPaths.size ? Math.min(this.retryDelayMs * 2, 12e4) : 3e4;
+        this.scheduleRetry();
+      });
+    }, this.retryDelayMs);
+  }
+  async finishRemoteBatch() {
+    if (this.stopped || this.failedPaths.size || this.pendingRemoteVersion === void 0) {
+      return;
+    }
+    this.state.remoteVersion = this.pendingRemoteVersion;
+    if (this.pendingInitialization) {
+      this.state.initialized = true;
+    }
+    await this.options.stateStore.save(this.state);
+    this.pendingRemoteVersion = void 0;
+    this.pendingInitialization = false;
+  }
   enqueue(operation) {
     const result = this.queue.then(operation);
     this.queue = result.then(() => void 0, () => void 0);
@@ -3194,6 +3283,7 @@ async function startServe(directory = process.cwd(), options = {}) {
     remote,
     stateStore: new FileSyncStateStore(root, settings.uri),
     ignore,
+    onSyncError: options.onSyncError,
     log: options.log ?? log,
     onConflict: options.onConflict ?? ((path, reason) => {
       (options.log ?? log)(`Conflict paused for ${path}: ${reason}`);
@@ -3211,6 +3301,7 @@ async function startServe(directory = process.cwd(), options = {}) {
     serverName: settings.serverName,
     projectId: settings.projectId,
     projectName: settings.projectName,
+    syncError: () => engine.syncError,
     conflicts: () => engine.getConflicts(),
     resolveConflict: (path, winner) => engine.resolveConflict(path, winner),
     retry: (path) => engine.retry(path),
@@ -3239,4 +3330,4 @@ export {
   RemoteProject,
   startServe
 };
-//# sourceMappingURL=chunk-FBT2UYMY.js.map
+//# sourceMappingURL=chunk-3TTRDNHP.js.map