@abraca/dabra 0.1.7 → 0.3.0

package/dist/abracadabra-provider.cjs

@@ -1381,10 +1381,15 @@ var HocuspocusProviderWebsocket = class extends EventEmitter {
 		if (this.connectionAttempt) this.rejectConnectionAttempt();
 		this.status = WebSocketStatus.Disconnected;
 		this.emit("status", { status: WebSocketStatus.Disconnected });
+		const isRateLimited = event?.code === 4429;
 		this.emit("disconnect", { event });
-		if (!this.cancelWebsocketRetry && this.shouldConnect) setTimeout(() => {
-			this.connect();
-		}, this.configuration.delay);
+		if (isRateLimited) this.emit("rateLimited");
+		if (!this.cancelWebsocketRetry && this.shouldConnect) {
+			const delay = isRateLimited ? 6e4 : this.configuration.delay;
+			setTimeout(() => {
+				this.connect();
+			}, delay);
+		}
 	}
 	destroy() {
 		this.emit("destroy");
@@ -1707,6 +1712,7 @@ var HocuspocusProvider = class extends EventEmitter {
 			forceSyncInterval: false,
 			onAuthenticated: () => null,
 			onAuthenticationFailed: () => null,
+			onRateLimited: () => null,
 			onOpen: () => null,
 			onConnect: () => null,
 			onMessage: () => null,
@@ -1738,6 +1744,7 @@ var HocuspocusProvider = class extends EventEmitter {
 		this.forwardClose = (e) => this.emit("close", e);
 		this.forwardDisconnect = (e) => this.emit("disconnect", e);
 		this.forwardDestroy = () => this.emit("destroy");
+		this.forwardRateLimited = () => this.emit("rateLimited");
 		this.setConfiguration(configuration);
 		this.configuration.document = configuration.document ? configuration.document : new yjs.Doc();
 		this.configuration.awareness = configuration.awareness !== void 0 ? configuration.awareness : new Awareness(this.document);
@@ -1752,6 +1759,7 @@ var HocuspocusProvider = class extends EventEmitter {
 		this.on("unsyncedChanges", this.configuration.onUnsyncedChanges);
 		this.on("authenticated", this.configuration.onAuthenticated);
 		this.on("authenticationFailed", this.configuration.onAuthenticationFailed);
+		this.on("rateLimited", this.configuration.onRateLimited);
 		this.awareness?.on("update", () => {
 			this.emit("awarenessUpdate", { states: (0, _abraca_dabra_common.awarenessStatesToArray)(this.awareness.getStates()) });
 		});
@@ -1944,6 +1952,7 @@ var HocuspocusProvider = class extends EventEmitter {
 		this.configuration.websocketProvider.off("disconnect", this.forwardDisconnect);
 		this.configuration.websocketProvider.off("destroy", this.configuration.onDestroy);
 		this.configuration.websocketProvider.off("destroy", this.forwardDestroy);
+		this.configuration.websocketProvider.off("rateLimited", this.forwardRateLimited);
 		this.configuration.websocketProvider.detach(this);
 		this._isAttached = false;
 	}
@@ -1961,6 +1970,7 @@ var HocuspocusProvider = class extends EventEmitter {
 		this.configuration.websocketProvider.on("disconnect", this.forwardDisconnect);
 		this.configuration.websocketProvider.on("destroy", this.configuration.onDestroy);
 		this.configuration.websocketProvider.on("destroy", this.forwardDestroy);
+		this.configuration.websocketProvider.on("rateLimited", this.forwardRateLimited);
 		this.configuration.websocketProvider.attach(this);
 		this._isAttached = true;
 	}
@@ -1981,18 +1991,19 @@ var HocuspocusProvider = class extends EventEmitter {
 
 //#endregion
 //#region packages/provider/src/OfflineStore.ts
-const DB_VERSION = 1;
+const DB_VERSION = 2;
 function idbAvailable() {
 	return typeof globalThis !== "undefined" && "indexedDB" in globalThis;
 }
-function openDb$1(docId) {
+function openDb$1(storeKey) {
 	return new Promise((resolve, reject) => {
-		const req = globalThis.indexedDB.open(`abracadabra:${docId}`, DB_VERSION);
+		const req = globalThis.indexedDB.open(`abracadabra:${storeKey}`, DB_VERSION);
 		req.onupgradeneeded = (event) => {
 			const db = event.target.result;
 			if (!db.objectStoreNames.contains("updates")) db.createObjectStore("updates", { autoIncrement: true });
 			if (!db.objectStoreNames.contains("meta")) db.createObjectStore("meta");
 			if (!db.objectStoreNames.contains("subdoc_queue")) db.createObjectStore("subdoc_queue", { keyPath: "childId" });
+			if (!db.objectStoreNames.contains("doc_state")) db.createObjectStore("doc_state");
 		};
 		req.onsuccess = () => resolve(req.result);
 		req.onerror = () => reject(req.error);
@@ -2005,13 +2016,19 @@ function txPromise(store, request) {
 	});
 }
 var OfflineStore = class {
-	constructor(docId) {
+	/**
+	* @param docId       The document UUID.
+	* @param serverOrigin  Hostname of the server (e.g. "abra.cou.sh").
+	*                    When provided the IndexedDB database is namespaced
+	*                    per-server, preventing cross-server data contamination.
+	*/
+	constructor(docId, serverOrigin) {
 		this.db = null;
-		this.docId = docId;
+		this.storeKey = serverOrigin ? `${serverOrigin}/${docId}` : docId;
 	}
 	async getDb() {
 		if (!idbAvailable()) return null;
-		if (!this.db) this.db = await openDb$1(this.docId).catch(() => null);
+		if (!this.db) this.db = await openDb$1(this.storeKey).catch(() => null);
 		return this.db;
 	}
 	async persistUpdate(update) {
@@ -2035,6 +2052,25 @@ var OfflineStore = class {
 		const tx = db.transaction("updates", "readwrite");
 		await txPromise(tx.objectStore("updates"), tx.objectStore("updates").clear());
 	}
+	/**
+	* Persist a full Y.js state snapshot (Y.encodeStateAsUpdate output).
+	* Replaces any previously stored snapshot.
+	*/
+	async saveDocSnapshot(snapshot) {
+		const db = await this.getDb();
+		if (!db) return;
+		const tx = db.transaction("doc_state", "readwrite");
+		await txPromise(tx.objectStore("doc_state"), tx.objectStore("doc_state").put(snapshot, "snapshot"));
+	}
+	/**
+	* Retrieve the stored full document snapshot, or null if none exists.
+	*/
+	async getDocSnapshot() {
+		const db = await this.getDb();
+		if (!db) return null;
+		const tx = db.transaction("doc_state", "readonly");
+		return await txPromise(tx.objectStore("doc_state"), tx.objectStore("doc_state").get("snapshot")) ?? null;
+	}
 	async getStateVector() {
 		const db = await this.getDb();
 		if (!db) return null;
@@ -2128,10 +2164,16 @@ function isValidDocId(id) {
 *     own AbracadabraProvider instances sharing the same WebSocket connection.
 *
 *  2. Offline-first – persists CRDT updates to IndexedDB so they survive
-*     page reloads and network outages.  On reconnect, pending updates are
-*     flushed before resuming normal sync.
+*     page reloads and network outages.  On startup, the last saved document
+*     snapshot is applied immediately so the UI is usable without a server
+*     connection.  On reconnect, pending updates are flushed and a fresh
+*     snapshot is saved.
+*
+*  3. Server-scoped storage – the IndexedDB database is keyed by server
+*     hostname + docId, preventing cross-server data contamination when the
+*     same docId is used on multiple servers.
 *
-*  3. Permission snapshotting – stores the resolved role locally so the UI
+*  4. Permission snapshotting – stores the resolved role locally so the UI
 *     can gate write operations without a network round-trip.  Role is
 *     refreshed from the server on every reconnect.
 */
@@ -2151,12 +2193,41 @@ var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
 		this._client = client;
 		this.abracadabraConfig = configuration;
 		this.subdocLoading = configuration.subdocLoading ?? "lazy";
-		this.offlineStore = configuration.disableOfflineStore ? null : new OfflineStore(configuration.name);
+		const serverOrigin = AbracadabraProvider.deriveServerOrigin(configuration, client);
+		this.offlineStore = configuration.disableOfflineStore ? null : new OfflineStore(configuration.name, serverOrigin);
 		this.on("subdocRegistered", configuration.onSubdocRegistered ?? (() => null));
 		this.on("subdocLoaded", configuration.onSubdocLoaded ?? (() => null));
 		this.document.on("subdocs", this.boundHandleYSubdocsChange);
 		this.on("synced", () => this.flushPendingUpdates());
 		this.restorePermissionSnapshot();
+		this.ready = this._initFromOfflineStore();
+	}
+	/**
+	* Extract the server hostname from the provider configuration.
+	* Used to namespace the IndexedDB key so docs from different servers
+	* never share the same database.
+	*/
+	static deriveServerOrigin(config, client) {
+		try {
+			const url = config.url ?? config.websocketProvider?.url ?? client?.wsUrl;
+			if (url) return new URL(url).hostname;
+		} catch {}
+	}
+	/**
+	* Load the stored document snapshot (and any pending local edits) from
+	* IndexedDB and apply them to the Y.Doc so the UI can render without a
+	* server connection.
+	*
+	* Uses `this.offlineStore` as the Y.js update origin so that
+	* `documentUpdateHandler` ignores these replayed updates and does not
+	* attempt to re-persist or re-send them.
+	*/
+	async _initFromOfflineStore() {
+		if (!this.offlineStore) return;
+		const snapshot = await this.offlineStore.getDocSnapshot().catch(() => null);
+		if (snapshot) yjs.applyUpdate(this.document, snapshot, this.offlineStore);
+		const pending = await this.offlineStore.getPendingUpdates().catch(() => []);
+		for (const update of pending) yjs.applyUpdate(this.document, update, this.offlineStore);
 	}
 	authenticatedHandler(scope) {
 		super.authenticatedHandler(scope);
@@ -2283,9 +2354,9 @@ var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
 	* child document id.  Each child opens its own WebSocket connection because
 	* the server is document-scoped (one WebSocket ↔ one document).
 	*/
-	async loadChild(childId) {
-		if (!isValidDocId(childId)) throw new Error(`loadChild: "${childId}" is not a valid document ID (must be a UUID). If this node was created with an older version of the app, delete it and recreate it.`);
-		if (this.childProviders.has(childId)) return this.childProviders.get(childId);
+	loadChild(childId) {
+		if (!isValidDocId(childId)) return Promise.reject(/* @__PURE__ */ new Error(`loadChild: "${childId}" is not a valid document ID (must be a UUID). If this node was created with an older version of the app, delete it and recreate it.`));
+		if (this.childProviders.has(childId)) return Promise.resolve(this.childProviders.get(childId));
 		if (this.pendingLoads.has(childId)) return this.pendingLoads.get(childId);
 		const load = this._doLoadChild(childId);
 		this.pendingLoads.set(childId, load);
@@ -2294,7 +2365,7 @@ var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
 	}
 	async _doLoadChild(childId) {
 		const childDoc = new yjs.Doc({ guid: childId });
-		await new Promise((resolve) => {
+		if (this.isConnected) await new Promise((resolve) => {
 			const onRegistered = ({ childId: cid }) => {
 				if (cid === childId) {
 					this.off("subdocRegistered", onRegistered);
@@ -2305,6 +2376,7 @@ var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
 			this.registerSubdoc(childDoc);
 			setTimeout(resolve, 3e3);
 		});
+		else this.registerSubdoc(childDoc);
 		const childProvider = new AbracadabraProvider({
 			name: childId,
 			document: childDoc,
@@ -2337,31 +2409,45 @@ var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
 	/**
 	* Override to persist every local update to IndexedDB before sending it
 	* over the wire, ensuring no work is lost during connection outages.
+	*
+	* Updates applied by the server (origin === this) and updates replayed
+	* from the offline store (origin === this.offlineStore) are both skipped
+	* to avoid loops.
 	*/
 	documentUpdateHandler(update, origin) {
 		if (origin === this) return;
+		if (this.offlineStore !== null && origin === this.offlineStore) return;
 		this.offlineStore?.persistUpdate(update).catch(() => null);
 		super.documentUpdateHandler(update, origin);
 	}
 	/**
-	* After reconnect + sync, flush any updates that were generated while
-	* offline, then flush any queued subdoc registrations.
+	* After reconnect + sync:
+	*  1. Flush any updates that were generated while offline.
+	*  2. Flush any queued subdoc registrations.
+	*  3. Save a fresh full document snapshot for the next offline session.
+	*
+	* Uses a local `store` reference captured at the start so that a concurrent
+	* `destroy()` call setting `offlineStore = null` does not cause null-ref
+	* errors across async await boundaries.
 	*/
 	async flushPendingUpdates() {
-		if (!this.offlineStore) return;
-		const updates = await this.offlineStore.getPendingUpdates();
+		const store = this.offlineStore;
+		if (!store) return;
+		const updates = await store.getPendingUpdates();
 		if (updates.length > 0) {
 			for (const update of updates) this.send(UpdateMessage, {
 				update,
 				documentName: this.configuration.name
 			});
-			await this.offlineStore.clearPendingUpdates();
+			await store.clearPendingUpdates();
 		}
-		const pendingSubdocs = await this.offlineStore.getPendingSubdocs();
+		const pendingSubdocs = await store.getPendingSubdocs();
 		for (const { childId } of pendingSubdocs) this.send(SubdocMessage, {
 			documentName: this.configuration.name,
 			childDocumentName: childId
 		});
+		const snapshot = yjs.encodeStateAsUpdate(this.document);
+		await store.saveDocSnapshot(snapshot).catch(() => null);
 	}
 	get isConnected() {
 		return this.configuration.websocketProvider.status === "connected";