@abraca/dabra 0.5.0 → 0.7.0

package/dist/abracadabra-provider.cjs

@@ -26,13 +26,23 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-let _abraca_dabra_common = require("@abraca/dabra-common");
 let yjs = require("yjs");
 yjs = __toESM(yjs);
 let _lifeomic_attempt = require("@lifeomic/attempt");
 let _noble_ed25519 = require("@noble/ed25519");
 _noble_ed25519 = __toESM(_noble_ed25519);
 
+//#region packages/provider/src/awarenessStatesToArray.ts
+const awarenessStatesToArray = (states) => {
+	return Array.from(states.entries()).map(([key, value]) => {
+		return {
+			clientId: key,
+			...value
+		};
+	});
+};
+
+//#endregion
 //#region node_modules/lib0/math.js
 /**
 * Common Math expressions.
@@ -1054,6 +1064,37 @@ var EventEmitter = class {
 	}
 };
 
+//#endregion
+//#region packages/provider/src/types.ts
+/**
+* State of the WebSocket connection.
+* https://developer.mozilla.org/de/docs/Web/API/WebSocket/readyState
+*/
+let WsReadyStates = /* @__PURE__ */ function(WsReadyStates) {
+	WsReadyStates[WsReadyStates["Connecting"] = 0] = "Connecting";
+	WsReadyStates[WsReadyStates["Open"] = 1] = "Open";
+	WsReadyStates[WsReadyStates["Closing"] = 2] = "Closing";
+	WsReadyStates[WsReadyStates["Closed"] = 3] = "Closed";
+	return WsReadyStates;
+}({});
+let MessageType = /* @__PURE__ */ function(MessageType) {
+	MessageType[MessageType["Sync"] = 0] = "Sync";
+	MessageType[MessageType["Awareness"] = 1] = "Awareness";
+	MessageType[MessageType["Auth"] = 2] = "Auth";
+	MessageType[MessageType["QueryAwareness"] = 3] = "QueryAwareness";
+	MessageType[MessageType["Subdoc"] = 4] = "Subdoc";
+	MessageType[MessageType["Stateless"] = 5] = "Stateless";
+	MessageType[MessageType["CLOSE"] = 7] = "CLOSE";
+	MessageType[MessageType["SyncStatus"] = 8] = "SyncStatus";
+	return MessageType;
+}({});
+let WebSocketStatus = /* @__PURE__ */ function(WebSocketStatus) {
+	WebSocketStatus["Connecting"] = "connecting";
+	WebSocketStatus["Connected"] = "connected";
+	WebSocketStatus["Disconnected"] = "disconnected";
+	return WebSocketStatus;
+}({});
+
 //#endregion
 //#region packages/provider/src/IncomingMessage.ts
 var IncomingMessage = class {
@@ -1088,26 +1129,6 @@ var IncomingMessage = class {
 	}
 };
 
-//#endregion
-//#region packages/provider/src/types.ts
-let MessageType = /* @__PURE__ */ function(MessageType) {
-	MessageType[MessageType["Sync"] = 0] = "Sync";
-	MessageType[MessageType["Awareness"] = 1] = "Awareness";
-	MessageType[MessageType["Auth"] = 2] = "Auth";
-	MessageType[MessageType["QueryAwareness"] = 3] = "QueryAwareness";
-	MessageType[MessageType["Subdoc"] = 4] = "Subdoc";
-	MessageType[MessageType["Stateless"] = 5] = "Stateless";
-	MessageType[MessageType["CLOSE"] = 7] = "CLOSE";
-	MessageType[MessageType["SyncStatus"] = 8] = "SyncStatus";
-	return MessageType;
-}({});
-let WebSocketStatus = /* @__PURE__ */ function(WebSocketStatus) {
-	WebSocketStatus["Connecting"] = "connecting";
-	WebSocketStatus["Connected"] = "connected";
-	WebSocketStatus["Disconnected"] = "disconnected";
-	return WebSocketStatus;
-}({});
-
 //#endregion
 //#region packages/provider/src/OutgoingMessage.ts
 var OutgoingMessage = class {
@@ -1138,8 +1159,8 @@ var CloseMessage = class extends OutgoingMessage {
 };
 
 //#endregion
-//#region packages/provider/src/HocuspocusProviderWebsocket.ts
-var HocuspocusProviderWebsocket = class extends EventEmitter {
+//#region packages/provider/src/AbracadabraWS.ts
+var AbracadabraWS = class extends EventEmitter {
 	constructor(configuration) {
 		super();
 		this.messageQueue = [];
@@ -1372,7 +1393,7 @@ var HocuspocusProviderWebsocket = class extends EventEmitter {
 		}
 	}
 	send(message) {
-		if (this.webSocket?.readyState === _abraca_dabra_common.WsReadyStates.Open) this.webSocket.send(message);
+		if (this.webSocket?.readyState === WsReadyStates.Open) this.webSocket.send(message);
 		else this.messageQueue.push(message);
 	}
 	onClose({ event }) {
@@ -1400,6 +1421,46 @@ var HocuspocusProviderWebsocket = class extends EventEmitter {
 		this.cleanupWebSocket();
 	}
 };
+/** @deprecated Use AbracadabraWS */
+const HocuspocusProviderWebsocket = AbracadabraWS;
+
+//#endregion
+//#region packages/provider/src/auth.ts
+let AuthMessageType = /* @__PURE__ */ function(AuthMessageType) {
+	AuthMessageType[AuthMessageType["Token"] = 0] = "Token";
+	AuthMessageType[AuthMessageType["PermissionDenied"] = 1] = "PermissionDenied";
+	AuthMessageType[AuthMessageType["Authenticated"] = 2] = "Authenticated";
+	return AuthMessageType;
+}({});
+const writeAuthentication = (encoder, auth) => {
+	writeVarUint(encoder, AuthMessageType.Token);
+	writeVarString(encoder, auth);
+};
+const writePermissionDenied = (encoder, reason) => {
+	writeVarUint(encoder, AuthMessageType.PermissionDenied);
+	writeVarString(encoder, reason);
+};
+const writeAuthenticated = (encoder, scope) => {
+	writeVarUint(encoder, AuthMessageType.Authenticated);
+	writeVarString(encoder, scope);
+};
+const writeTokenSyncRequest = (encoder) => {
+	writeVarUint(encoder, AuthMessageType.Token);
+};
+const readAuthMessage = (decoder, sendToken, permissionDeniedHandler, authenticatedHandler) => {
+	switch (readVarUint(decoder)) {
+		case AuthMessageType.Token:
+			sendToken();
+			break;
+		case AuthMessageType.PermissionDenied:
+			permissionDeniedHandler(readVarString(decoder));
+			break;
+		case AuthMessageType.Authenticated:
+			authenticatedHandler(readVarString(decoder));
+			break;
+		default:
+	}
+};
 
 //#endregion
 //#region node_modules/y-protocols/sync.js
@@ -1581,7 +1642,7 @@ var MessageReceiver = class {
 	}
 	applyAuthMessage(provider) {
 		const { message } = this;
-		(0, _abraca_dabra_common.readAuthMessage)(message.decoder, provider.sendToken.bind(provider), provider.permissionDeniedHandler.bind(provider), provider.authenticatedHandler.bind(provider));
+		readAuthMessage(message.decoder, provider.sendToken.bind(provider), provider.permissionDeniedHandler.bind(provider), provider.authenticatedHandler.bind(provider));
 	}
 	applyQueryAwarenessMessage(provider) {
 		if (!provider.awareness) return;
@@ -1618,7 +1679,7 @@ var AuthenticationMessage = class extends OutgoingMessage {
 		if (typeof args.token === "undefined") throw new Error("The authentication message requires `token` as an argument.");
 		writeVarString(this.encoder, args.documentName);
 		writeVarUint(this.encoder, this.type);
-		(0, _abraca_dabra_common.writeAuthentication)(this.encoder, args.token);
+		writeAuthentication(this.encoder, args.token);
 		return this.encoder;
 	}
 };
@@ -1694,14 +1755,14 @@ var UpdateMessage = class extends OutgoingMessage {
 };
 
 //#endregion
-//#region packages/provider/src/HocuspocusProvider.ts
+//#region packages/provider/src/AbracadabraBaseProvider.ts
 var AwarenessError = class extends Error {
 	constructor(..._args) {
 		super(..._args);
 		this.code = 1001;
 	}
 };
-var HocuspocusProvider = class extends EventEmitter {
+var AbracadabraBaseProvider = class extends EventEmitter {
 	constructor(configuration) {
 		super();
 		this.configuration = {
@@ -1761,10 +1822,10 @@ var HocuspocusProvider = class extends EventEmitter {
 		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()) });
+			this.emit("awarenessUpdate", { states: awarenessStatesToArray(this.awareness.getStates()) });
 		});
 		this.awareness?.on("change", () => {
-			this.emit("awarenessChange", { states: (0, _abraca_dabra_common.awarenessStatesToArray)(this.awareness.getStates()) });
+			this.emit("awarenessChange", { states: awarenessStatesToArray(this.awareness.getStates()) });
 		});
 		this.document.on("update", this.boundDocumentUpdateHandler);
 		this.awareness?.on("update", this.boundAwarenessUpdateHandler);
@@ -1775,7 +1836,7 @@ var HocuspocusProvider = class extends EventEmitter {
 	setConfiguration(configuration = {}) {
 		if (!configuration.websocketProvider) {
 			this.manageSocket = true;
-			this.configuration.websocketProvider = new HocuspocusProviderWebsocket(configuration);
+			this.configuration.websocketProvider = new AbracadabraWS(configuration);
 		}
 		this.configuration = {
 			...this.configuration,
@@ -1875,11 +1936,11 @@ var HocuspocusProvider = class extends EventEmitter {
 	}
 	async connect() {
 		if (this.manageSocket) return this.configuration.websocketProvider.connect();
-		console.warn("HocuspocusProvider::connect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.");
+		console.warn("AbracadabraBaseProvider::connect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.");
 	}
 	disconnect() {
 		if (this.manageSocket) return this.configuration.websocketProvider.disconnect();
-		console.warn("HocuspocusProvider::disconnect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.");
+		console.warn("AbracadabraBaseProvider::disconnect() is deprecated and does not do anything. Please connect/disconnect on the websocketProvider, or attach/deattach providers.");
 	}
 	async onOpen(event) {
 		this.isAuthenticated = false;
@@ -1988,16 +2049,18 @@ var HocuspocusProvider = class extends EventEmitter {
 		this.awareness.setLocalStateField(key, value);
 	}
 };
+/** @deprecated Use AbracadabraBaseProvider */
+const HocuspocusProvider = AbracadabraBaseProvider;
 
 //#endregion
 //#region packages/provider/src/OfflineStore.ts
-const DB_VERSION = 2;
-function idbAvailable() {
+const DB_VERSION$3 = 2;
+function idbAvailable$3() {
 	return typeof globalThis !== "undefined" && "indexedDB" in globalThis;
 }
-function openDb$1(storeKey) {
+function openDb$4(storeKey) {
 	return new Promise((resolve, reject) => {
-		const req = globalThis.indexedDB.open(`abracadabra:${storeKey}`, DB_VERSION);
+		const req = globalThis.indexedDB.open(`abracadabra:${storeKey}`, DB_VERSION$3);
 		req.onupgradeneeded = (event) => {
 			const db = event.target.result;
 			if (!db.objectStoreNames.contains("updates")) db.createObjectStore("updates", { autoIncrement: true });
@@ -2009,7 +2072,7 @@ function openDb$1(storeKey) {
 		req.onerror = () => reject(req.error);
 	});
 }
-function txPromise(store, request) {
+function txPromise$2(store, request) {
 	return new Promise((resolve, reject) => {
 		request.onsuccess = () => resolve(request.result);
 		request.onerror = () => reject(request.error);
@@ -2024,18 +2087,22 @@ var OfflineStore = class {
 	*/
 	constructor(docId, serverOrigin) {
 		this.db = null;
+		this.dbPromise = null;
 		this.storeKey = serverOrigin ? `${serverOrigin}/${docId}` : docId;
 	}
-	async getDb() {
-		if (!idbAvailable()) return null;
-		if (!this.db) this.db = await openDb$1(this.storeKey).catch(() => null);
-		return this.db;
+	getDb() {
+		if (!idbAvailable$3()) return Promise.resolve(null);
+		if (!this.dbPromise) this.dbPromise = openDb$4(this.storeKey).catch(() => null).then((db) => {
+			this.db = db;
+			return db;
+		});
+		return this.dbPromise;
 	}
 	async persistUpdate(update) {
 		const db = await this.getDb();
 		if (!db) return;
 		const store = db.transaction("updates", "readwrite").objectStore("updates");
-		await txPromise(store, store.add(update));
+		await txPromise$2(store, store.add(update));
 	}
 	async getPendingUpdates() {
 		const db = await this.getDb();
@@ -2050,7 +2117,7 @@ var OfflineStore = class {
 		const db = await this.getDb();
 		if (!db) return;
 		const tx = db.transaction("updates", "readwrite");
-		await txPromise(tx.objectStore("updates"), tx.objectStore("updates").clear());
+		await txPromise$2(tx.objectStore("updates"), tx.objectStore("updates").clear());
 	}
 	/**
 	* Persist a full Y.js state snapshot (Y.encodeStateAsUpdate output).
@@ -2060,7 +2127,7 @@ var OfflineStore = class {
 		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"));
+		await txPromise$2(tx.objectStore("doc_state"), tx.objectStore("doc_state").put(snapshot, "snapshot"));
 	}
 	/**
 	* Retrieve the stored full document snapshot, or null if none exists.
@@ -2069,37 +2136,37 @@ var OfflineStore = class {
 		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;
+		return await txPromise$2(tx.objectStore("doc_state"), tx.objectStore("doc_state").get("snapshot")) ?? null;
 	}
 	async getStateVector() {
 		const db = await this.getDb();
 		if (!db) return null;
 		const tx = db.transaction("meta", "readonly");
-		return await txPromise(tx.objectStore("meta"), tx.objectStore("meta").get("sv")) ?? null;
+		return await txPromise$2(tx.objectStore("meta"), tx.objectStore("meta").get("sv")) ?? null;
 	}
 	async saveStateVector(sv) {
 		const db = await this.getDb();
 		if (!db) return;
 		const tx = db.transaction("meta", "readwrite");
-		await txPromise(tx.objectStore("meta"), tx.objectStore("meta").put(sv, "sv"));
+		await txPromise$2(tx.objectStore("meta"), tx.objectStore("meta").put(sv, "sv"));
 	}
 	async getPermissionSnapshot() {
 		const db = await this.getDb();
 		if (!db) return null;
 		const tx = db.transaction("meta", "readonly");
-		return await txPromise(tx.objectStore("meta"), tx.objectStore("meta").get("role")) ?? null;
+		return await txPromise$2(tx.objectStore("meta"), tx.objectStore("meta").get("role")) ?? null;
 	}
 	async savePermissionSnapshot(role) {
 		const db = await this.getDb();
 		if (!db) return;
 		const tx = db.transaction("meta", "readwrite");
-		await txPromise(tx.objectStore("meta"), tx.objectStore("meta").put(role, "role"));
+		await txPromise$2(tx.objectStore("meta"), tx.objectStore("meta").put(role, "role"));
 	}
 	async queueSubdoc(entry) {
 		const db = await this.getDb();
 		if (!db) return;
 		const tx = db.transaction("subdoc_queue", "readwrite");
-		await txPromise(tx.objectStore("subdoc_queue"), tx.objectStore("subdoc_queue").put(entry));
+		await txPromise$2(tx.objectStore("subdoc_queue"), tx.objectStore("subdoc_queue").put(entry));
 	}
 	async getPendingSubdocs() {
 		const db = await this.getDb();
@@ -2114,7 +2181,7 @@ var OfflineStore = class {
 		const db = await this.getDb();
 		if (!db) return;
 		const tx = db.transaction("subdoc_queue", "readwrite");
-		await txPromise(tx.objectStore("subdoc_queue"), tx.objectStore("subdoc_queue").delete(childId));
+		await txPromise$2(tx.objectStore("subdoc_queue"), tx.objectStore("subdoc_queue").delete(childId));
 	}
 	destroy() {
 		this.db?.close();
@@ -2157,7 +2224,7 @@ function isValidDocId(id) {
 	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
 }
 /**
-* AbracadabraProvider extends HocuspocusProvider with:
+* AbracadabraProvider extends AbracadabraBaseProvider with:
 *
 *  1. Subdocument lifecycle – intercepts Y.Doc subdoc events and syncs them
 *     with the server via MSG_SUBDOC (4) frames.  Child documents get their
@@ -2177,7 +2244,7 @@ function isValidDocId(id) {
 *     can gate write operations without a network round-trip.  Role is
 *     refreshed from the server on every reconnect.
 */
-var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
+var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvider {
 	constructor(configuration) {
 		const resolved = { ...configuration };
 		const client = configuration.client ?? null;
@@ -2224,9 +2291,8 @@ var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
 	*/
 	async _initFromOfflineStore() {
 		if (!this.offlineStore) return;
-		const snapshot = await this.offlineStore.getDocSnapshot().catch(() => null);
+		const [snapshot, pending] = await Promise.all([this.offlineStore.getDocSnapshot().catch(() => null), this.offlineStore.getPendingUpdates().catch(() => [])]);
 		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) {
@@ -2365,18 +2431,7 @@ var AbracadabraProvider = class AbracadabraProvider extends HocuspocusProvider {
 	}
 	async _doLoadChild(childId) {
 		const childDoc = new yjs.Doc({ guid: childId });
-		if (this.isConnected) await new Promise((resolve) => {
-			const onRegistered = ({ childId: cid }) => {
-				if (cid === childId) {
-					this.off("subdocRegistered", onRegistered);
-					resolve();
-				}
-			};
-			this.on("subdocRegistered", onRegistered);
-			this.registerSubdoc(childDoc);
-			setTimeout(resolve, 3e3);
-		});
-		else this.registerSubdoc(childDoc);
+		this.registerSubdoc(childDoc);
 		const childProvider = new AbracadabraProvider({
 			name: childId,
 			document: childDoc,
@@ -2470,6 +2525,7 @@ var AbracadabraClient = class {
 		this.persistAuth = config.persistAuth ?? typeof localStorage !== "undefined";
 		this.storageKey = config.storageKey ?? "abracadabra:auth";
 		this._fetch = config.fetch ?? globalThis.fetch.bind(globalThis);
+		this.cache = config.cache ?? null;
 		this._token = config.token ?? this.loadPersistedToken() ?? null;
 	}
 	get token() {
@@ -2567,7 +2623,13 @@ var AbracadabraClient = class {
 	}
 	/** Get the current user's profile. */
 	async getMe() {
-		return this.request("GET", "/users/me");
+		if (this.cache) {
+			const cached = await this.cache.getCurrentProfile();
+			if (cached) return cached;
+		}
+		const profile = await this.request("GET", "/users/me");
+		if (this.cache) await this.cache.setCurrentProfile(profile).catch(() => null);
+		return profile;
 	}
 	/** Update the current user's display name. */
 	async updateMe(opts) {
@@ -2579,15 +2641,28 @@ var AbracadabraClient = class {
 	}
 	/** Get document metadata. */
 	async getDoc(docId) {
-		return this.request("GET", `/docs/${encodeURIComponent(docId)}`);
+		if (this.cache) {
+			const cached = await this.cache.getDoc(docId);
+			if (cached) return cached;
+		}
+		const meta = await this.request("GET", `/docs/${encodeURIComponent(docId)}`);
+		if (this.cache) await this.cache.setDoc(meta).catch(() => null);
+		return meta;
 	}
 	/** Delete a document (requires Owner role). Cascades to children and uploads. */
 	async deleteDoc(docId) {
 		await this.request("DELETE", `/docs/${encodeURIComponent(docId)}`);
+		if (this.cache) await this.cache.invalidateDoc(docId).catch(() => null);
 	}
 	/** List immediate child documents. */
 	async listChildren(docId) {
-		return (await this.request("GET", `/docs/${encodeURIComponent(docId)}/children`)).children;
+		if (this.cache) {
+			const cached = await this.cache.getChildren(docId);
+			if (cached) return cached;
+		}
+		const res = await this.request("GET", `/docs/${encodeURIComponent(docId)}/children`);
+		if (this.cache) await this.cache.setChildren(docId, res.children).catch(() => null);
+		return res.children;
 	}
 	/** Create a child document under a parent (requires write permission). */
 	async createChild(docId, opts) {
@@ -2595,7 +2670,13 @@ var AbracadabraClient = class {
 	}
 	/** List all permissions for a document (requires read access). */
 	async listPermissions(docId) {
-		return (await this.request("GET", `/docs/${encodeURIComponent(docId)}/permissions`)).permissions;
+		if (this.cache) {
+			const cached = await this.cache.getPermissions(docId);
+			if (cached) return cached;
+		}
+		const res = await this.request("GET", `/docs/${encodeURIComponent(docId)}/permissions`);
+		if (this.cache) await this.cache.setPermissions(docId, res.permissions).catch(() => null);
+		return res.permissions;
 	}
 	/** Grant or change a user's role on a document (requires Owner). */
 	async setPermission(docId, opts) {
@@ -2617,11 +2698,19 @@ var AbracadabraClient = class {
 			body: formData
 		});
 		if (!res.ok) throw await this.toError(res);
-		return res.json();
+		const meta = await res.json();
+		if (this.cache) await this.cache.invalidateUploads(docId).catch(() => null);
+		return meta;
 	}
 	/** List all uploads for a document. */
 	async listUploads(docId) {
-		return (await this.request("GET", `/docs/${encodeURIComponent(docId)}/uploads`)).uploads;
+		if (this.cache) {
+			const cached = await this.cache.getUploads(docId);
+			if (cached) return cached;
+		}
+		const res = await this.request("GET", `/docs/${encodeURIComponent(docId)}/uploads`);
+		if (this.cache) await this.cache.setUploads(docId, res.uploads).catch(() => null);
+		return res.uploads;
 	}
 	/** Download an upload as a Blob. */
 	async getUpload(docId, uploadId) {
@@ -2637,11 +2726,19 @@ var AbracadabraClient = class {
 	/** Delete an upload (requires uploader or document Owner). */
 	async deleteUpload(docId, uploadId) {
 		await this.request("DELETE", `/docs/${encodeURIComponent(docId)}/uploads/${encodeURIComponent(uploadId)}`);
+		if (this.cache) await this.cache.invalidateUploads(docId).catch(() => null);
 	}
 	/** Health check — no auth required. */
 	async health() {
 		return this.request("GET", "/health", { auth: false });
 	}
+	/**
+	* Fetch server metadata including the optional `index_doc_id` entry point.
+	* No auth required.
+	*/
+	async serverInfo() {
+		return this.request("GET", "/info", { auth: false });
+	}
 	async request(method, path, opts) {
 		const auth = opts?.auth ?? true;
 		const headers = {};
@@ -2689,6 +2786,49 @@ var AbracadabraClient = class {
 	}
 };
 
+//#endregion
+//#region packages/provider/src/CloseEvents.ts
+/**
+* The server is terminating the connection because a data frame was received
+* that is too large.
+* See: https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
+*/
+const MessageTooBig = {
+	code: 1009,
+	reason: "Message Too Big"
+};
+/**
+* The server successfully processed the request, asks that the requester reset
+* its document view, and is not returning any content.
+*/
+const ResetConnection = {
+	code: 4205,
+	reason: "Reset Connection"
+};
+/**
+* Similar to Forbidden, but specifically for use when authentication is required and has
+* failed or has not yet been provided.
+*/
+const Unauthorized = {
+	code: 4401,
+	reason: "Unauthorized"
+};
+/**
+* The request contained valid data and was understood by the server, but the server
+* is refusing action.
+*/
+const Forbidden = {
+	code: 4403,
+	reason: "Forbidden"
+};
+/**
+* The server timed out waiting for the request.
+*/
+const ConnectionTimeout = {
+	code: 4408,
+	reason: "Connection Timeout"
+};
+
 //#endregion
 //#region node_modules/@noble/hashes/esm/utils.js
 /** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
@@ -3366,7 +3506,7 @@ const DB_NAME = "abracadabra:identity";
 const STORE_NAME = "identity";
 const RECORD_KEY = "current";
 const HKDF_INFO = new TextEncoder().encode("abracadabra-identity-v1");
-function openDb() {
+function openDb$3() {
 	return new Promise((resolve, reject) => {
 		const req = indexedDB.open(DB_NAME, 1);
 		req.onupgradeneeded = () => {
@@ -3449,7 +3589,7 @@ var CryptoIdentityKeystore = class {
 			name: "AES-GCM",
 			iv
 		}, aesKey, privateKey);
-		const db = await openDb();
+		const db = await openDb$3();
 		await dbPut(db, {
 			username,
 			publicKey: toBase64url(publicKey),
@@ -3472,7 +3612,7 @@ var CryptoIdentityKeystore = class {
 	* @returns base64url-encoded Ed25519 signature (64 bytes).
 	*/
 	async sign(challengeB64) {
-		const db = await openDb();
+		const db = await openDb$3();
 		const stored = await dbGet(db);
 		db.close();
 		if (!stored) throw new Error("No identity stored. Call register() first.");
@@ -3501,7 +3641,7 @@ var CryptoIdentityKeystore = class {
 	}
 	/** Returns the stored base64url public key, or null if no identity exists. */
 	async getPublicKey() {
-		const db = await openDb();
+		const db = await openDb$3();
 		const stored = await dbGet(db);
 		db.close();
 		return stored?.publicKey ?? null;
@@ -3514,35 +3654,551 @@ var CryptoIdentityKeystore = class {
 	* a real display name via PATCH /users/me.
 	*/
 	async getUsername() {
-		const db = await openDb();
+		const db = await openDb$3();
 		const stored = await dbGet(db);
 		db.close();
 		return stored?.username ?? null;
 	}
 	/** Returns true if an identity is stored in IndexedDB. */
 	async hasIdentity() {
-		const db = await openDb();
+		const db = await openDb$3();
 		const stored = await dbGet(db);
 		db.close();
 		return stored !== void 0;
 	}
 	/** Remove the stored identity from IndexedDB. */
 	async clear() {
-		const db = await openDb();
+		const db = await openDb$3();
 		await dbDelete(db);
 		db.close();
 	}
 };
 
 //#endregion
+//#region packages/provider/src/DocumentCache.ts
+const DB_VERSION$2 = 1;
+const DEFAULT_TTL_MS = 300 * 1e3;
+function idbAvailable$2() {
+	return typeof globalThis !== "undefined" && "indexedDB" in globalThis;
+}
+function openDb$2(origin) {
+	return new Promise((resolve, reject) => {
+		const req = globalThis.indexedDB.open(`abracadabra:meta-cache:${origin}`, DB_VERSION$2);
+		req.onupgradeneeded = (event) => {
+			const db = event.target.result;
+			for (const name of [
+				"doc_meta",
+				"children",
+				"user_profile",
+				"permissions",
+				"uploads"
+			]) if (!db.objectStoreNames.contains(name)) db.createObjectStore(name);
+		};
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error);
+	});
+}
+function txPromise$1(store, request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+	});
+}
+var DocumentCache = class {
+	constructor(serverOrigin, opts) {
+		this.dbPromise = null;
+		this.db = null;
+		this.origin = serverOrigin;
+		this.ttlMs = opts?.ttlMs ?? DEFAULT_TTL_MS;
+	}
+	getDb() {
+		if (!idbAvailable$2()) return Promise.resolve(null);
+		if (!this.dbPromise) this.dbPromise = openDb$2(this.origin).catch(() => null).then((db) => {
+			this.db = db;
+			return db;
+		});
+		return this.dbPromise;
+	}
+	isExpired(cachedAt) {
+		return Date.now() - cachedAt > this.ttlMs;
+	}
+	async getWithTtl(storeName, key) {
+		const db = await this.getDb();
+		if (!db) return null;
+		const tx = db.transaction(storeName, "readonly");
+		const result = await txPromise$1(tx.objectStore(storeName), tx.objectStore(storeName).get(key));
+		if (!result) return null;
+		if (this.isExpired(result.cachedAt)) {
+			this.deleteKey(storeName, key).catch(() => null);
+			return null;
+		}
+		return result.value;
+	}
+	async setWithTtl(storeName, key, value) {
+		const db = await this.getDb();
+		if (!db) return;
+		const entry = {
+			value,
+			cachedAt: Date.now()
+		};
+		const tx = db.transaction(storeName, "readwrite");
+		await txPromise$1(tx.objectStore(storeName), tx.objectStore(storeName).put(entry, key));
+	}
+	async deleteKey(storeName, key) {
+		const db = await this.getDb();
+		if (!db) return;
+		const tx = db.transaction(storeName, "readwrite");
+		await txPromise$1(tx.objectStore(storeName), tx.objectStore(storeName).delete(key));
+	}
+	async getDoc(docId) {
+		return this.getWithTtl("doc_meta", docId);
+	}
+	async setDoc(meta) {
+		return this.setWithTtl("doc_meta", meta.id, meta);
+	}
+	async invalidateDoc(docId) {
+		await this.deleteKey("doc_meta", docId).catch(() => null);
+	}
+	async getChildren(parentId) {
+		return this.getWithTtl("children", parentId);
+	}
+	async setChildren(parentId, items) {
+		return this.setWithTtl("children", parentId, items);
+	}
+	async invalidateChildren(parentId) {
+		await this.deleteKey("children", parentId).catch(() => null);
+	}
+	async getProfile(userId) {
+		return this.getWithTtl("user_profile", userId);
+	}
+	async setProfile(profile) {
+		return this.setWithTtl("user_profile", profile.id, profile);
+	}
+	/** Get the cached profile for the currently authenticated user. */
+	async getCurrentProfile() {
+		return this.getWithTtl("user_profile", "__current__");
+	}
+	/** Cache a profile both by its ID and as the current user. */
+	async setCurrentProfile(profile) {
+		await Promise.all([this.setWithTtl("user_profile", profile.id, profile), this.setWithTtl("user_profile", "__current__", profile)]);
+	}
+	async getPermissions(docId) {
+		return this.getWithTtl("permissions", docId);
+	}
+	async setPermissions(docId, items) {
+		return this.setWithTtl("permissions", docId, items);
+	}
+	async getUploads(docId) {
+		return this.getWithTtl("uploads", docId);
+	}
+	async setUploads(docId, items) {
+		return this.setWithTtl("uploads", docId, items);
+	}
+	async invalidateUploads(docId) {
+		await this.deleteKey("uploads", docId).catch(() => null);
+	}
+	destroy() {
+		this.db?.close();
+		this.db = null;
+	}
+};
+
+//#endregion
+//#region packages/provider/src/SearchIndex.ts
+const DB_VERSION$1 = 1;
+function idbAvailable$1() {
+	return typeof globalThis !== "undefined" && "indexedDB" in globalThis;
+}
+function openDb$1(origin) {
+	return new Promise((resolve, reject) => {
+		const req = globalThis.indexedDB.open(`abracadabra:search:${origin}`, DB_VERSION$1);
+		req.onupgradeneeded = (event) => {
+			const db = event.target.result;
+			if (!db.objectStoreNames.contains("postings")) db.createObjectStore("postings");
+			if (!db.objectStoreNames.contains("doc_trigrams")) db.createObjectStore("doc_trigrams");
+		};
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error);
+	});
+}
+/** Extract the set of trigrams for a piece of text. */
+function extractTrigrams(text) {
+	const trigrams = /* @__PURE__ */ new Set();
+	const padded = ` ${text.toLowerCase()} `;
+	for (let i = 0; i <= padded.length - 3; i++) trigrams.add(padded.slice(i, i + 3));
+	return trigrams;
+}
+/** Merge trigrams from multiple texts into a single set. */
+function extractAllTrigrams(texts) {
+	const result = /* @__PURE__ */ new Set();
+	for (const t of texts) for (const trigram of extractTrigrams(t)) result.add(trigram);
+	return result;
+}
+var SearchIndex = class {
+	constructor(serverOrigin) {
+		this.dbPromise = null;
+		this.db = null;
+		this.origin = serverOrigin;
+	}
+	getDb() {
+		if (!idbAvailable$1()) return Promise.resolve(null);
+		if (!this.dbPromise) this.dbPromise = openDb$1(this.origin).catch(() => null).then((db) => {
+			this.db = db;
+			return db;
+		});
+		return this.dbPromise;
+	}
+	/**
+	* Replace the index for docId with the given texts.
+	* Old trigram associations are removed before new ones are added.
+	*/
+	async index(docId, texts) {
+		const db = await this.getDb();
+		if (!db) return;
+		const newTrigrams = extractAllTrigrams(texts);
+		return new Promise((resolve, reject) => {
+			const tx = db.transaction(["postings", "doc_trigrams"], "readwrite");
+			tx.oncomplete = () => resolve();
+			tx.onerror = () => reject(tx.error);
+			const postings = tx.objectStore("postings");
+			const docTrigramsStore = tx.objectStore("doc_trigrams");
+			const oldReq = docTrigramsStore.get(docId);
+			oldReq.onsuccess = () => {
+				const oldTrigrams = oldReq.result ?? [];
+				let pending = oldTrigrams.length + newTrigrams.size + 1;
+				function done() {
+					pending--;
+				}
+				for (const trigram of oldTrigrams) {
+					const req = postings.get(trigram);
+					req.onsuccess = () => {
+						const updated = (req.result ?? []).filter((id) => id !== docId);
+						if (updated.length === 0) postings.delete(trigram);
+						else postings.put(updated, trigram);
+						done();
+					};
+					req.onerror = done;
+				}
+				for (const trigram of newTrigrams) {
+					const req = postings.get(trigram);
+					req.onsuccess = () => {
+						const list = req.result ?? [];
+						if (!list.includes(docId)) list.push(docId);
+						postings.put(list, trigram);
+						done();
+					};
+					req.onerror = done;
+				}
+				const writeReq = docTrigramsStore.put([...newTrigrams], docId);
+				writeReq.onsuccess = done;
+				writeReq.onerror = done;
+			};
+			oldReq.onerror = () => reject(oldReq.error);
+		});
+	}
+	/** Remove all indexed content for a document. */
+	async remove(docId) {
+		const db = await this.getDb();
+		if (!db) return;
+		return new Promise((resolve, reject) => {
+			const tx = db.transaction(["postings", "doc_trigrams"], "readwrite");
+			tx.oncomplete = () => resolve();
+			tx.onerror = () => reject(tx.error);
+			const postings = tx.objectStore("postings");
+			const docTrigramsStore = tx.objectStore("doc_trigrams");
+			const oldReq = docTrigramsStore.get(docId);
+			oldReq.onsuccess = () => {
+				const oldTrigrams = oldReq.result ?? [];
+				for (const trigram of oldTrigrams) {
+					const req = postings.get(trigram);
+					req.onsuccess = () => {
+						const updated = (req.result ?? []).filter((id) => id !== docId);
+						if (updated.length === 0) postings.delete(trigram);
+						else postings.put(updated, trigram);
+					};
+				}
+				docTrigramsStore.delete(docId);
+			};
+			oldReq.onerror = () => reject(oldReq.error);
+		});
+	}
+	/**
+	* Search for documents matching the query.
+	* Returns results sorted by score (matching trigram count) descending.
+	*/
+	async search(query, limit = 20) {
+		const db = await this.getDb();
+		if (!db) return [];
+		const queryTrigrams = [...extractTrigrams(query)];
+		if (queryTrigrams.length === 0) return [];
+		return new Promise((resolve, reject) => {
+			const tx = db.transaction("postings", "readonly");
+			const postings = tx.objectStore("postings");
+			const scores = /* @__PURE__ */ new Map();
+			let remaining = queryTrigrams.length;
+			for (const trigram of queryTrigrams) {
+				const req = postings.get(trigram);
+				req.onsuccess = () => {
+					const docIds = req.result ?? [];
+					for (const docId of docIds) scores.set(docId, (scores.get(docId) ?? 0) + 1);
+					remaining--;
+					if (remaining === 0) resolve([...scores.entries()].map(([docId, score]) => ({
+						docId,
+						score
+					})).sort((a, b) => b.score - a.score).slice(0, limit));
+				};
+				req.onerror = () => {
+					remaining--;
+					if (remaining === 0) resolve([...scores.entries()].map(([docId, score]) => ({
+						docId,
+						score
+					})).sort((a, b) => b.score - a.score).slice(0, limit));
+				};
+			}
+			tx.onerror = () => reject(tx.error);
+		});
+	}
+	destroy() {
+		this.db?.close();
+		this.db = null;
+	}
+};
+
+//#endregion
+//#region packages/provider/src/FileBlobStore.ts
+const DB_VERSION = 1;
+function idbAvailable() {
+	return typeof globalThis !== "undefined" && "indexedDB" in globalThis;
+}
+function openDb(origin) {
+	return new Promise((resolve, reject) => {
+		const req = globalThis.indexedDB.open(`abracadabra:files:${origin}`, DB_VERSION);
+		req.onupgradeneeded = (event) => {
+			const db = event.target.result;
+			if (!db.objectStoreNames.contains("blobs")) db.createObjectStore("blobs");
+			if (!db.objectStoreNames.contains("upload_queue")) db.createObjectStore("upload_queue", { keyPath: "id" });
+		};
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error);
+	});
+}
+function txPromise(store, request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+	});
+}
+var FileBlobStore = class extends EventEmitter {
+	constructor(serverOrigin, client) {
+		super();
+		this.dbPromise = null;
+		this.db = null;
+		this.objectUrls = /* @__PURE__ */ new Map();
+		this._flushing = false;
+		this.origin = serverOrigin;
+		this.client = client;
+		this._onlineHandler = () => {
+			this.flushQueue().catch(() => null);
+		};
+		if (typeof window !== "undefined") window.addEventListener("online", this._onlineHandler);
+	}
+	getDb() {
+		if (!idbAvailable()) return Promise.resolve(null);
+		if (!this.dbPromise) this.dbPromise = openDb(this.origin).catch(() => null).then((db) => {
+			this.db = db;
+			return db;
+		});
+		return this.dbPromise;
+	}
+	blobKey(docId, uploadId) {
+		return `${docId}/${uploadId}`;
+	}
+	/**
+	* Return a local object URL for a file.
+	* On first call the blob is downloaded from the server and cached in IDB.
+	* Returns null when offline and the blob is not yet cached, or when
+	* URL.createObjectURL is unavailable (e.g. Node.js / SSR).
+	*/
+	async getBlobUrl(docId, uploadId) {
+		if (typeof window === "undefined") return null;
+		const key = this.blobKey(docId, uploadId);
+		const existing = this.objectUrls.get(key);
+		if (existing) return existing;
+		const db = await this.getDb();
+		if (db) {
+			const tx = db.transaction("blobs", "readonly");
+			const entry = await txPromise(tx.objectStore("blobs"), tx.objectStore("blobs").get(key));
+			if (entry) {
+				const url = URL.createObjectURL(entry.blob);
+				this.objectUrls.set(key, url);
+				return url;
+			}
+		}
+		let blob;
+		try {
+			blob = await this.client.getUpload(docId, uploadId);
+		} catch {
+			return null;
+		}
+		if (db) {
+			const entry = {
+				blob,
+				mime_type: blob.type,
+				filename: uploadId,
+				cachedAt: Date.now()
+			};
+			db.transaction("blobs", "readwrite").objectStore("blobs").put(entry, key);
+		}
+		const url = URL.createObjectURL(blob);
+		this.objectUrls.set(key, url);
+		return url;
+	}
+	/** Revoke the object URL and remove the blob from cache. */
+	async evictBlob(docId, uploadId) {
+		const key = this.blobKey(docId, uploadId);
+		const url = this.objectUrls.get(key);
+		if (url) {
+			URL.revokeObjectURL(url);
+			this.objectUrls.delete(key);
+		}
+		const db = await this.getDb();
+		if (!db) return;
+		const tx = db.transaction("blobs", "readwrite");
+		await txPromise(tx.objectStore("blobs"), tx.objectStore("blobs").delete(key));
+	}
+	/**
+	* Queue a file for upload. Works offline — the entry is persisted to IDB
+	* and flushed the next time the queue is flushed.
+	* Returns the generated queue entry id.
+	*/
+	async queueUpload(docId, file, filename) {
+		const id = crypto.randomUUID();
+		const entry = {
+			id,
+			docId,
+			file,
+			filename: file instanceof File ? file.name : filename ?? "file",
+			status: "pending",
+			createdAt: Date.now()
+		};
+		const db = await this.getDb();
+		if (db) {
+			const tx = db.transaction("upload_queue", "readwrite");
+			await txPromise(tx.objectStore("upload_queue"), tx.objectStore("upload_queue").put(entry));
+		}
+		this.emit("upload:queued", entry);
+		return id;
+	}
+	/** Return all upload queue entries. */
+	async getQueue() {
+		const db = await this.getDb();
+		if (!db) return [];
+		return new Promise((resolve, reject) => {
+			const req = db.transaction("upload_queue", "readonly").objectStore("upload_queue").getAll();
+			req.onsuccess = () => resolve(req.result);
+			req.onerror = () => reject(req.error);
+		});
+	}
+	/**
+	* Upload all pending queue entries via AbracadabraClient.
+	* Safe to call repeatedly — a concurrent call is a no-op.
+	* Entries that fail are marked with status "error" and left in the queue.
+	*/
+	async flushQueue() {
+		if (this._flushing) return;
+		this._flushing = true;
+		try {
+			const pending = (await this.getQueue()).filter((e) => e.status === "pending");
+			for (const entry of pending) {
+				await this._updateQueueEntry(entry.id, { status: "uploading" });
+				this.emit("upload:started", {
+					...entry,
+					status: "uploading"
+				});
+				try {
+					await this.client.upload(entry.docId, entry.file, entry.filename);
+					await this._updateQueueEntry(entry.id, { status: "done" });
+					this.emit("upload:done", {
+						...entry,
+						status: "done"
+					});
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					await this._updateQueueEntry(entry.id, {
+						status: "error",
+						error: message
+					});
+					this.emit("upload:error", {
+						...entry,
+						status: "error",
+						error: message
+					});
+				}
+			}
+		} finally {
+			this._flushing = false;
+		}
+	}
+	async _updateQueueEntry(id, patch) {
+		const db = await this.getDb();
+		if (!db) return;
+		return new Promise((resolve, reject) => {
+			const tx = db.transaction("upload_queue", "readwrite");
+			const store = tx.objectStore("upload_queue");
+			const req = store.get(id);
+			req.onsuccess = () => {
+				if (!req.result) {
+					resolve();
+					return;
+				}
+				const updated = {
+					...req.result,
+					...patch
+				};
+				store.put(updated);
+				tx.oncomplete = () => resolve();
+				tx.onerror = () => reject(tx.error);
+			};
+			req.onerror = () => reject(req.error);
+		});
+	}
+	destroy() {
+		if (typeof window !== "undefined") window.removeEventListener("online", this._onlineHandler);
+		for (const url of this.objectUrls.values()) URL.revokeObjectURL(url);
+		this.objectUrls.clear();
+		this.db?.close();
+		this.db = null;
+		this.removeAllListeners();
+	}
+};
+
+//#endregion
+exports.AbracadabraBaseProvider = AbracadabraBaseProvider;
 exports.AbracadabraClient = AbracadabraClient;
 exports.AbracadabraProvider = AbracadabraProvider;
+exports.AbracadabraWS = AbracadabraWS;
+exports.AuthMessageType = AuthMessageType;
 exports.AwarenessError = AwarenessError;
+exports.ConnectionTimeout = ConnectionTimeout;
 exports.CryptoIdentityKeystore = CryptoIdentityKeystore;
+exports.DocumentCache = DocumentCache;
+exports.FileBlobStore = FileBlobStore;
+exports.Forbidden = Forbidden;
 exports.HocuspocusProvider = HocuspocusProvider;
 exports.HocuspocusProviderWebsocket = HocuspocusProviderWebsocket;
+exports.MessageTooBig = MessageTooBig;
 exports.MessageType = MessageType;
 exports.OfflineStore = OfflineStore;
+exports.ResetConnection = ResetConnection;
+exports.SearchIndex = SearchIndex;
 exports.SubdocMessage = SubdocMessage;
+exports.Unauthorized = Unauthorized;
 exports.WebSocketStatus = WebSocketStatus;
+exports.WsReadyStates = WsReadyStates;
+exports.awarenessStatesToArray = awarenessStatesToArray;
+exports.readAuthMessage = readAuthMessage;
+exports.writeAuthenticated = writeAuthenticated;
+exports.writeAuthentication = writeAuthentication;
+exports.writePermissionDenied = writePermissionDenied;
+exports.writeTokenSyncRequest = writeTokenSyncRequest;
 //# sourceMappingURL=abracadabra-provider.cjs.map