@abraca/dabra 2.9.0 → 2.11.0

package/dist/abracadabra-provider.esm.js

@@ -15960,6 +15960,31 @@ const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
 function isValidDocId(id) {
 	return UUID_RE.test(id);
 }
+/**
+* Consecutive transient failures before a doc is promoted from the calm
+* `retrying` status to a genuine `error`. Keeps a single timeout/network blip
+* from flashing a red error badge — the doc only "counts" as broken once it
+* has failed this many passes in a row.
+*/
+const FAILURE_THRESHOLD = 3;
+/** Delay before a one-shot follow-up retry of stragglers after `syncAll()`. */
+const STRAGGLER_RETRY_DELAY_MS = 6e4;
+/**
+* Decide whether a sync failure is permanent (the server will never accept
+* this doc — deleted, forbidden, or an unparseable id) or merely transient
+* (timeout, dropped socket, momentary 5xx). Permanent failures are parked as
+* `unavailable` and never retried; transient ones go through `retrying`.
+*
+* Best-effort: inspects a numeric `status`/`code` if the thrown value carries
+* one, otherwise falls back to message keywords. Defaults to transient so we
+* never give up on a doc we're unsure about.
+*/
+function isPermanentSyncError(err) {
+	const status = typeof err === "object" && err !== null ? Number(err.status ?? err.statusCode ?? err.code) : NaN;
+	if (status === 403 || status === 404 || status === 410 || status === 422) return true;
+	const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+	return /\b(403|404|410|422)\b/.test(msg) || msg.includes("forbidden") || msg.includes("not found") || msg.includes("does not exist") || msg.includes("unprocessable");
+}
 var BackgroundSyncManager = class extends EventEmitter {
 	constructor(rootProvider, client, fileBlobStore, opts) {
 		super();
@@ -15967,12 +15992,13 @@ var BackgroundSyncManager = class extends EventEmitter {
 		this._warnedInvalidIds = /* @__PURE__ */ new Set();
 		this._destroyed = false;
 		this._initPromise = null;
+		this._stragglerTimer = null;
 		this.rootProvider = rootProvider;
 		this.client = client;
 		this.fileBlobStore = fileBlobStore ?? null;
 		this.opts = {
 			concurrency: opts?.concurrency ?? 2,
-			syncTimeout: opts?.syncTimeout ?? 15e3,
+			syncTimeout: opts?.syncTimeout ?? 3e4,
 			prefetchFiles: opts?.prefetchFiles ?? true,
 			throttleMs: opts?.throttleMs ?? 200,
 			maxRetries: opts?.maxRetries ?? 2
@@ -16041,6 +16067,28 @@ var BackgroundSyncManager = class extends EventEmitter {
 			const retryWorkers = Array.from({ length: this.opts.concurrency }, () => retryNext());
 			await Promise.all(retryWorkers);
 		}
+		if (failed.length > 0) this._scheduleStragglerRetry(failed.slice());
+	}
+	/**
+	* Schedule a single delayed retry of the given docs. Replaces any pending
+	* straggler timer so repeated `syncAll()` calls don't stack timers.
+	*/
+	_scheduleStragglerRetry(docIds) {
+		if (this._destroyed || docIds.length === 0) return;
+		if (this._stragglerTimer) clearTimeout(this._stragglerTimer);
+		this._stragglerTimer = setTimeout(() => {
+			this._stragglerTimer = null;
+			if (this._destroyed) return;
+			(async () => {
+				const treeMap = this.rootProvider.document.getMap("doc-tree");
+				for (const docId of docIds) {
+					if (this._destroyed) return;
+					const entry = treeMap.get(docId);
+					const updatedAt = entry?.updatedAt ?? entry?.createdAt ?? 0;
+					await this._syncWithSemaphore(docId, updatedAt);
+				}
+			})();
+		}, STRAGGLER_RETRY_DELAY_MS);
 	}
 	/** Sync a single document by ID. */
 	async syncDoc(docId) {
@@ -16097,6 +16145,10 @@ var BackgroundSyncManager = class extends EventEmitter {
 	}
 	destroy() {
 		this._destroyed = true;
+		if (this._stragglerTimer) {
+			clearTimeout(this._stragglerTimer);
+			this._stragglerTimer = null;
+		}
 		this.removeAllListeners();
 	}
 	/**
@@ -16118,18 +16170,20 @@ var BackgroundSyncManager = class extends EventEmitter {
 				console.warn(`[BackgroundSyncManager] skipping non-UUID doc id "${docId}" in doc-tree — server would reject it (422). Likely a stale entry from an earlier seeder; remove it from the tree to silence this.`);
 			}
 		}
-		const items = filtered.map(([docId, v]) => {
+		const items = [];
+		for (const [docId, v] of filtered) {
 			const state = this.syncStates.get(docId);
+			if (state?.status === "unavailable") continue;
 			const updatedAt = v?.updatedAt ?? v?.createdAt ?? 0;
 			let priority;
 			if (!state || state.status === "pending") priority = Number.MAX_SAFE_INTEGER - updatedAt;
-			else if (state.status === "error") priority = -1;
+			else if (state.status === "error" || state.status === "retrying") priority = -1;
 			else priority = updatedAt;
-			return {
+			items.push({
 				docId,
 				priority
-			};
-		});
+			});
+		}
 		items.sort((a, b) => b.priority - a.priority);
 		return items.map((i) => i.docId);
 	}
@@ -16137,6 +16191,13 @@ var BackgroundSyncManager = class extends EventEmitter {
 	async _syncWithSemaphore(docId, updatedAt) {
 		if (this._destroyed) return true;
 		const existing = this.syncStates.get(docId);
+		if (existing && existing.status === "unavailable") {
+			this.emit("stateChanged", {
+				docId,
+				state: existing
+			});
+			return true;
+		}
 		if (existing && existing.status === "synced" && existing.lastSynced !== null && existing.lastSynced + 200 >= updatedAt) {
 			this.emit("stateChanged", {
 				docId,
@@ -16153,12 +16214,20 @@ var BackgroundSyncManager = class extends EventEmitter {
 				docId,
 				state
 			});
-			return state.status !== "error";
+			return state.status !== "error" && state.status !== "retrying";
 		} finally {
 			this.semaphore.release();
 		}
 	}
 	async _doSyncDoc(docId) {
+		if (!isValidDocId(docId)) return {
+			docId,
+			status: "unavailable",
+			lastSynced: this.syncStates.get(docId)?.lastSynced ?? null,
+			error: "Invalid document id (not a UUID)",
+			consecutiveFailures: 0,
+			isE2E: false
+		};
 		const syncing = {
 			docId,
 			status: "syncing",
@@ -16179,11 +16248,23 @@ var BackgroundSyncManager = class extends EventEmitter {
 			else return await this._syncNonE2EDoc(docId);
 		} catch (err) {
 			const error = err instanceof Error ? err.message : String(err);
+			const prev = this.syncStates.get(docId);
+			const lastSynced = prev?.lastSynced ?? null;
+			if (isPermanentSyncError(err)) return {
+				docId,
+				status: "unavailable",
+				lastSynced,
+				error,
+				consecutiveFailures: 0,
+				isE2E
+			};
+			const consecutiveFailures = (prev?.consecutiveFailures ?? 0) + 1;
 			return {
 				docId,
-				status: "error",
-				lastSynced: this.syncStates.get(docId)?.lastSynced ?? null,
+				status: consecutiveFailures >= FAILURE_THRESHOLD ? "error" : "retrying",
+				lastSynced,
 				error,
+				consecutiveFailures,
 				isE2E
 			};
 		}
@@ -16196,6 +16277,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 				docId,
 				status: "synced",
 				lastSynced: Date.now(),
+				consecutiveFailures: 0,
 				isE2E: false
 			};
 		}
@@ -16219,6 +16301,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 				docId,
 				status: "synced",
 				lastSynced: Math.max(Date.now(), treeUpdatedAt),
+				consecutiveFailures: 0,
 				isE2E: false
 			};
 		} finally {
@@ -16233,6 +16316,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 			docId,
 			status: "skipped",
 			lastSynced: null,
+			consecutiveFailures: 0,
 			isE2E: true
 		};
 		const childDoc = new Y.Doc({ guid: docId });
@@ -16262,6 +16346,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 				docId,
 				status: "synced",
 				lastSynced: Math.max(Date.now(), treeUpdatedAt),
+				consecutiveFailures: 0,
 				isE2E: true
 			};
 		} finally {