@abraca/dabra 2.8.0 → 2.10.0

package/dist/abracadabra-provider.esm.js

@@ -1203,6 +1203,8 @@ var AbracadabraWS = class extends EventEmitter {
 		this.identifier = 0;
 		this.intervals = { connectionChecker: null };
 		this.connectionAttempt = null;
+		this.onlineListener = null;
+		this.offlineListener = null;
 		this.receivedOnOpenPayload = void 0;
 		this.closeTries = 0;
 		this.setConfiguration(configuration);
@@ -1221,8 +1223,39 @@ var AbracadabraWS = class extends EventEmitter {
 		this.on("close", this.onClose.bind(this));
 		this.on("message", this.onMessage.bind(this));
 		this.intervals.connectionChecker = setInterval(this.checkConnection.bind(this), this.configuration.messageReconnectTimeout / 10);
+		if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+			this.onlineListener = this.handleOnline.bind(this);
+			this.offlineListener = this.handleOffline.bind(this);
+			window.addEventListener("online", this.onlineListener);
+			window.addEventListener("offline", this.offlineListener);
+		}
 		if (this.shouldConnect) this.connect();
 	}
+	/**
+	* Whether the device currently believes it has network connectivity.
+	*
+	* Treats "unknown" as online: in Node and other non-browser environments
+	* `navigator` (or `navigator.onLine`) is absent, and we must not gate
+	* reconnection there — only the browser exposes a trustworthy signal.
+	*/
+	get isOnline() {
+		return typeof navigator === "undefined" || navigator.onLine !== false;
+	}
+	handleOnline() {
+		if (this.shouldConnect && this.status !== WebSocketStatus.Connected) this.connect();
+	}
+	handleOffline() {
+		if (this.cancelWebsocketRetry) {
+			this.cancelWebsocketRetry();
+			this.cancelWebsocketRetry = void 0;
+		}
+		try {
+			this.webSocket?.close();
+			this.messageQueue = [];
+		} catch (e) {
+			console.error(e);
+		}
+	}
 	async onOpen(event) {
 		this.status = WebSocketStatus.Connected;
 		this.emit("status", { status: WebSocketStatus.Connected });
@@ -1252,6 +1285,10 @@ var AbracadabraWS = class extends EventEmitter {
 	}
 	async connect() {
 		if (this.status === WebSocketStatus.Connected) return;
+		if (!this.isOnline) {
+			this.shouldConnect = true;
+			return;
+		}
 		if (this.cancelWebsocketRetry) {
 			this.cancelWebsocketRetry();
 			this.cancelWebsocketRetry = void 0;
@@ -1416,7 +1453,7 @@ var AbracadabraWS = class extends EventEmitter {
 		const isRateLimited = event?.code === 4429 || event === 4429;
 		this.emit("disconnect", { event });
 		if (isRateLimited) this.emit("rateLimited");
-		if (!this.cancelWebsocketRetry && this.shouldConnect) {
+		if (!this.cancelWebsocketRetry && this.shouldConnect && this.isOnline) {
 			const delay = isRateLimited ? 6e4 : this.configuration.delay;
 			setTimeout(() => {
 				this.connect();
@@ -1426,6 +1463,12 @@ var AbracadabraWS = class extends EventEmitter {
 	destroy() {
 		this.shouldConnect = false;
 		this.emit("destroy");
+		if (typeof window !== "undefined" && typeof window.removeEventListener === "function") {
+			if (this.onlineListener) window.removeEventListener("online", this.onlineListener);
+			if (this.offlineListener) window.removeEventListener("offline", this.offlineListener);
+		}
+		this.onlineListener = null;
+		this.offlineListener = null;
 		clearInterval(this.intervals.connectionChecker);
 		this.stopConnectionAttempt();
 		this.disconnect();
@@ -15917,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();
@@ -15924,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
@@ -15998,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) {
@@ -16054,6 +16145,10 @@ var BackgroundSyncManager = class extends EventEmitter {
 	}
 	destroy() {
 		this._destroyed = true;
+		if (this._stragglerTimer) {
+			clearTimeout(this._stragglerTimer);
+			this._stragglerTimer = null;
+		}
 		this.removeAllListeners();
 	}
 	/**
@@ -16075,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);
 	}
@@ -16094,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,
@@ -16110,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",
@@ -16136,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
 			};
 		}
@@ -16153,6 +16277,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 				docId,
 				status: "synced",
 				lastSynced: Date.now(),
+				consecutiveFailures: 0,
 				isE2E: false
 			};
 		}
@@ -16176,6 +16301,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 				docId,
 				status: "synced",
 				lastSynced: Math.max(Date.now(), treeUpdatedAt),
+				consecutiveFailures: 0,
 				isE2E: false
 			};
 		} finally {
@@ -16190,6 +16316,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 			docId,
 			status: "skipped",
 			lastSynced: null,
+			consecutiveFailures: 0,
 			isE2E: true
 		};
 		const childDoc = new Y.Doc({ guid: docId });
@@ -16219,6 +16346,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 				docId,
 				status: "synced",
 				lastSynced: Math.max(Date.now(), treeUpdatedAt),
+				consecutiveFailures: 0,
 				isE2E: true
 			};
 		} finally {