@abraca/dabra 1.5.0 → 1.8.0

package/dist/abracadabra-provider.cjs

@@ -2317,6 +2317,7 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 			onAwarenessUpdate: () => null,
 			onAwarenessChange: () => null,
 			onStateless: () => null,
+			onServerError: () => null,
 			onUnsyncedChanges: () => null
 		};
 		this.isSynced = false;
@@ -2348,6 +2349,7 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 		this.on("awarenessUpdate", this.configuration.onAwarenessUpdate);
 		this.on("awarenessChange", this.configuration.onAwarenessChange);
 		this.on("stateless", this.configuration.onStateless);
+		this.on("serverError", this.configuration.onServerError);
 		this.on("unsyncedChanges", this.configuration.onUnsyncedChanges);
 		this.on("authenticated", this.configuration.onAuthenticated);
 		this.on("authenticationFailed", this.configuration.onAuthenticationFailed);
@@ -2463,6 +2465,19 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 		if (state) this.emit("synced", { state });
 	}
 	receiveStateless(payload) {
+		try {
+			const parsed = JSON.parse(payload);
+			if (parsed?.type === "error" && parsed.source && parsed.code) {
+				const { source, code, message } = parsed;
+				console.warn(`[Abracadabra] Server error: ${source} (${code}) — ${message}`);
+				this.emit("serverError", {
+					source,
+					code,
+					message: message ?? ""
+				});
+				return;
+			}
+		} catch {}
 		this.emit("stateless", { payload });
 	}
 	async connect() {
@@ -2808,6 +2823,9 @@ function isValidDocId(id) {
 *     refreshed from the server on every reconnect.
 */
 var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvider {
+	static {
+		this.MAX_CHILDREN = 20;
+	}
 	constructor(configuration) {
 		const resolved = { ...configuration };
 		const client = configuration.client ?? null;
@@ -2819,6 +2837,8 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 		this.effectiveRole = null;
 		this.childProviders = /* @__PURE__ */ new Map();
 		this.pendingLoads = /* @__PURE__ */ new Map();
+		this.childAccessTimes = /* @__PURE__ */ new Map();
+		this.pinnedChildren = /* @__PURE__ */ new Set();
 		this.boundHandleYSubdocsChange = this.handleYSubdocsChange.bind(this);
 		this._client = client;
 		this.abracadabraConfig = configuration;
@@ -3013,7 +3033,10 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 	*/
 	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.childProviders.has(childId)) {
+			this.childAccessTimes.set(childId, Date.now());
+			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);
@@ -3038,6 +3061,8 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 		});
 		childProvider.attach();
 		this.childProviders.set(childId, childProvider);
+		this.childAccessTimes.set(childId, Date.now());
+		this.evictLRU();
 		this.emit("subdocLoaded", {
 			childId,
 			provider: childProvider
@@ -3049,6 +3074,44 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 		if (provider) {
 			provider.destroy();
 			this.childProviders.delete(childId);
+			this.childAccessTimes.delete(childId);
+			this.pinnedChildren.delete(childId);
+		}
+	}
+	/**
+	* Mark a child as pinned so LRU eviction will not remove it.
+	* Use this when a document is actively being viewed by the user.
+	*/
+	pinChild(childId) {
+		this.pinnedChildren.add(childId);
+	}
+	/**
+	* Unpin a child, allowing LRU eviction to reclaim it when capacity is exceeded.
+	*/
+	unpinChild(childId) {
+		this.pinnedChildren.delete(childId);
+		this.evictLRU();
+	}
+	/**
+	* Evict least-recently-used unpinned child providers until the cache is
+	* at or below MAX_CHILDREN.
+	*/
+	evictLRU() {
+		if (this.childProviders.size <= AbracadabraProvider.MAX_CHILDREN) return;
+		const evictable = [];
+		for (const [id] of this.childProviders) {
+			if (this.pinnedChildren.has(id)) continue;
+			evictable.push({
+				id,
+				accessTime: this.childAccessTimes.get(id) ?? 0
+			});
+		}
+		evictable.sort((a, b) => a.accessTime - b.accessTime);
+		let toEvict = this.childProviders.size - AbracadabraProvider.MAX_CHILDREN;
+		for (const entry of evictable) {
+			if (toEvict <= 0) break;
+			this.unloadChild(entry.id);
+			toEvict--;
 		}
 	}
 	/** Return all currently-loaded child providers. */
@@ -3108,6 +3171,8 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 		const childIds = [...this.childProviders.keys()];
 		for (const provider of this.childProviders.values()) provider.destroy();
 		this.childProviders.clear();
+		this.childAccessTimes.clear();
+		this.pinnedChildren.clear();
 		const wsProviderMap = this.configuration.websocketProvider?.configuration?.providerMap;
 		if (wsProviderMap) for (const childId of childIds) wsProviderMap.delete(childId);
 		this.offlineStore?.destroy();
@@ -10906,35 +10971,57 @@ var E2EAbracadabraProvider = class E2EAbracadabraProvider extends AbracadabraPro
 * This propagates "last edited" timestamps to all peers via the root CRDT,
 * without requiring any server-side changes.
 *
-* Limitation: at least one client must have the child doc open after an edit
-* for the timestamp to propagate (eventually consistent).
+* A trailing-edge throttle (default 5 s) limits writes to avoid CRDT bloat
+* on the root doc during rapid typing.
 */
 /**
-* Attach an observer that writes `updatedAt: Date.now()` to the root
-* doc-tree entry for `childDocId` whenever the child doc receives a
-* non-offline update.
+* Attach an observer that writes `updatedAt` to the root doc-tree entry for
+* `childDocId` whenever the child doc receives a non-offline update.
 *
-* @param treeMap     The root doc's "doc-tree" Y.Map.
-* @param childDocId  The child document's UUID (key in treeMap).
-* @param childDoc    The child Y.Doc to observe.
+* Writes are throttled: the first qualifying update records the timestamp;
+* a trailing-edge timer flushes it to the tree map after `throttleMs`.
+*
+* @param treeMap       The root doc's "doc-tree" Y.Map.
+* @param childDocId    The child document's UUID (key in treeMap).
+* @param childDoc      The child Y.Doc to observe.
 * @param offlineStore  The child provider's OfflineStore (used to detect
 *                      offline-replay origins and skip them). Pass null when
 *                      the offline store is disabled.
-* @returns           Cleanup function — call on provider destroy.
-*/
-function attachUpdatedAtObserver(treeMap, childDocId, childDoc, offlineStore) {
-	function handler(update, origin) {
-		if (offlineStore !== null && origin === offlineStore) return;
+* @param options       Optional config. `throttleMs` controls the write
+*                      interval (default 5000).
+* @returns             Cleanup function — call on provider destroy.  Flushes
+*                      any pending write before detaching.
+*/
+function attachUpdatedAtObserver(treeMap, childDocId, childDoc, offlineStore, options) {
+	const throttleMs = options?.throttleMs ?? 5e3;
+	let latestTs = 0;
+	let timer = null;
+	function flush() {
+		if (latestTs === 0) return;
+		const ts = latestTs;
+		latestTs = 0;
+		timer = null;
 		const raw = treeMap.get(childDocId);
 		if (!raw) return;
 		const entry = raw instanceof yjs.Map ? raw.toJSON() : raw;
 		treeMap.set(childDocId, {
 			...entry,
-			updatedAt: Date.now()
+			updatedAt: ts
 		});
 	}
+	function handler(_update, origin) {
+		if (offlineStore !== null && origin === offlineStore) return;
+		latestTs = Date.now();
+		if (timer === null) timer = setTimeout(flush, throttleMs);
+	}
 	childDoc.on("update", handler);
-	return () => childDoc.off("update", handler);
+	return () => {
+		childDoc.off("update", handler);
+		if (timer !== null) {
+			clearTimeout(timer);
+			flush();
+		}
+	};
 }
 
 //#endregion
@@ -11204,7 +11291,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 	async _syncWithSemaphore(docId, updatedAt) {
 		if (this._destroyed) return true;
 		const existing = this.syncStates.get(docId);
-		if (existing && existing.status === "synced" && existing.lastSynced !== null && existing.lastSynced >= updatedAt) {
+		if (existing && existing.status === "synced" && existing.lastSynced !== null && existing.lastSynced + 200 >= updatedAt) {
 			this.emit("stateChanged", {
 				docId,
 				state: existing
@@ -11256,6 +11343,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 		}
 	}
 	async _syncNonE2EDoc(docId) {
+		const treeMap = this.rootProvider.document.getMap("doc-tree");
 		const alreadyCached = this.rootProvider.children.has(docId);
 		if (!alreadyCached) {
 			if ((this.rootProvider.configuration?.websocketProvider?.configuration?.providerMap)?.has(docId)) return {
@@ -11266,27 +11354,33 @@ var BackgroundSyncManager = class extends EventEmitter {
 			};
 		}
 		const childProvider = await this.rootProvider.loadChild(docId);
-		await childProvider.ready;
-		await this._waitForSynced(childProvider);
-		{
-			const treeEntry = this.rootProvider.document.getMap("doc-tree").get(docId);
-			this.emit("docSynced", {
+		try {
+			await childProvider.ready;
+			await this._waitForSynced(childProvider);
+			{
+				const treeEntry = treeMap.get(docId);
+				this.emit("docSynced", {
+					docId,
+					document: childProvider.document,
+					label: treeEntry?.label ?? "",
+					meta: treeEntry?.meta
+				});
+			}
+			if (this.opts.prefetchFiles && this.fileBlobStore) this._prefetchDocFiles(docId, childProvider.document).catch(() => null);
+			const treeEntry = treeMap.get(docId);
+			const treeUpdatedAt = treeEntry?.updatedAt ?? treeEntry?.createdAt ?? 0;
+			return {
 				docId,
-				document: childProvider.document,
-				label: treeEntry?.label ?? "",
-				meta: treeEntry?.meta
-			});
+				status: "synced",
+				lastSynced: Math.max(Date.now(), treeUpdatedAt),
+				isE2E: false
+			};
+		} finally {
+			if (!alreadyCached) this.rootProvider.unloadChild(docId);
 		}
-		if (this.opts.prefetchFiles && this.fileBlobStore) this._prefetchDocFiles(docId, childProvider.document).catch(() => null);
-		if (!alreadyCached) this.rootProvider.unloadChild(docId);
-		return {
-			docId,
-			status: "synced",
-			lastSynced: Date.now(),
-			isE2E: false
-		};
 	}
 	async _syncE2EDoc(docId) {
+		const treeMap = this.rootProvider.document.getMap("doc-tree");
 		const docKeyManager = this.rootProvider.abracadabraConfig?.docKeyManager;
 		const keystore = this.rootProvider.abracadabraConfig?.keystore;
 		if (!docKeyManager || !keystore) return {
@@ -11307,7 +11401,7 @@ var BackgroundSyncManager = class extends EventEmitter {
 			await childProvider.ready;
 			await this._waitForSynced(childProvider);
 			{
-				const treeEntry = this.rootProvider.document.getMap("doc-tree").get(docId);
+				const treeEntry = treeMap.get(docId);
 				this.emit("docSynced", {
 					docId,
 					document: childDoc,
@@ -11316,10 +11410,12 @@ var BackgroundSyncManager = class extends EventEmitter {
 				});
 			}
 			if (this.opts.prefetchFiles && this.fileBlobStore) this._prefetchDocFiles(docId, childDoc).catch(() => null);
+			const treeEntry = treeMap.get(docId);
+			const treeUpdatedAt = treeEntry?.updatedAt ?? treeEntry?.createdAt ?? 0;
 			return {
 				docId,
 				status: "synced",
-				lastSynced: Date.now(),
+				lastSynced: Math.max(Date.now(), treeUpdatedAt),
 				isE2E: true
 			};
 		} finally {
@@ -13095,8 +13191,12 @@ var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
 	/**
 	* Approve the pending pairing request. Calls `client.addKey()` to
 	* register Device B's public key, then notifies Device B.
+	*
+	* @param client Authenticated REST client.
+	* @param masterPublicKey Approver's account-level Ed25519 public key (base64url).
+	*   Sent to Device B so it can adopt the master's identity doc.
 	*/
-	async approve(client) {
+	async approve(client, masterPublicKey) {
 		if (this.role !== "approver") return {
 			success: false,
 			error: "Only the approver can approve"
@@ -13116,7 +13216,10 @@ var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
 				deviceName: req.deviceName,
 				x25519Key: req.x25519Key
 			});
-			this.sendMessage({ type: "pair-approved" });
+			this.sendMessage({
+				type: "pair-approved",
+				masterPublicKey
+			});
 			this._pendingRequest = null;
 			this.emit("pairingComplete", { success: true });
 			return { success: true };
@@ -13139,8 +13242,12 @@ var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
 	* Approve via server-side device invite. Creates a single-use invite code
 	* and sends it to Device B over the E2EE channel. Device B redeems it
 	* independently via HTTP — Device A can go offline after this.
+	*
+	* @param client Authenticated REST client.
+	* @param masterPublicKey Approver's account-level Ed25519 public key (base64url).
+	*   Sent to Device B so it can adopt the master's identity doc.
 	*/
-	async approveWithInvite(client) {
+	async approveWithInvite(client, masterPublicKey) {
 		if (this.role !== "approver") return {
 			success: false,
 			error: "Only the approver can approve"
@@ -13157,7 +13264,8 @@ var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
 			const { code } = await client.createDeviceInvite();
 			this.sendMessage({
 				type: "pair-invite-code",
-				code
+				code,
+				masterPublicKey
 			});
 			this._pendingRequest = null;
 			this.emit("pairingComplete", { success: true });
@@ -13328,7 +13436,7 @@ var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
 				break;
 			case "pair-approved":
 				if (this.role !== "requester") return;
-				this.emit("approved");
+				this.emit("approved", { masterPublicKey: msg.masterPublicKey });
 				this.emit("pairingComplete", { success: true });
 				break;
 			case "pair-rejected":
@@ -13341,7 +13449,7 @@ var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
 				break;
 			case "pair-invite-code":
 				if (this.role !== "requester") return;
-				this.emit("inviteCode", msg.code);
+				this.emit("inviteCode", msg.code, msg.masterPublicKey);
 				break;
 		}
 	}
@@ -13868,6 +13976,19 @@ var IdentityDocProvider = class extends EventEmitter {
 		return this.profileMap.size === 0 && this.serversMap.size === 0;
 	}
 	/**
+	* Enable WebRTC P2P sync at runtime.
+	* Use this for claimed/passkey users where E2EE identity derivation
+	* was deferred to avoid biometric prompts on page load.
+	*/
+	enableWebRTC(webrtcConfig) {
+		if (this._destroyed || this.webrtc) return;
+		this.config = {
+			...this.config,
+			webrtc: webrtcConfig
+		};
+		this._connectWebRTC();
+	}
+	/**
 	* Update the sync server URL at runtime (e.g. when user changes their
 	* designated sync server in settings).
 	*/
@@ -14054,6 +14175,319 @@ var DeviceRegistrationService = class {
 	}
 };
 
+//#endregion
+//#region packages/provider/src/ChatClient.ts
+const DEFAULT_TIMEOUT_MS$1 = 1e4;
+/**
+* Typed client for the Abracadabra chat feature.
+*
+* Wraps a connected provider (or base provider) and translates JSON envelopes
+* on the stateless channel into typed method calls and events.
+*
+* Events emitted:
+*   - `message`      → ChatMessage       (new message broadcast)
+*   - `typing`       → ChatTypingEvent   (typing indicator broadcast)
+*   - `readReceipt`  → ChatReadReceipt   (mark_read broadcast)
+*/
+var ChatClient = class extends EventEmitter {
+	constructor(provider, options) {
+		super();
+		this.pending = /* @__PURE__ */ new Map();
+		this.provider = provider;
+		this.responseTimeoutMs = options?.responseTimeoutMs ?? DEFAULT_TIMEOUT_MS$1;
+		this.boundOnStateless = (data) => this.handleStateless(data.payload);
+		this.provider.on("stateless", this.boundOnStateless);
+	}
+	/** Stop listening for chat messages. Does not disconnect the underlying provider. */
+	destroy() {
+		this.provider.off("stateless", this.boundOnStateless);
+		for (const queue of this.pending.values()) for (const p of queue) {
+			clearTimeout(p.timer);
+			p.reject(/* @__PURE__ */ new Error("ChatClient destroyed"));
+		}
+		this.pending.clear();
+		this.removeAllListeners();
+	}
+	/** Send a chat message on a channel. Fire-and-forget (the server broadcasts). */
+	sendMessage(input) {
+		this.provider.sendStateless(JSON.stringify({
+			type: "chat:send",
+			channel: input.channel,
+			content: input.content,
+			...input.sender_name !== void 0 ? { sender_name: input.sender_name } : {}
+		}));
+	}
+	/** Fetch historical messages for a channel. Resolves with the server response. */
+	getHistory(input) {
+		const promise = this.enqueue("chat:history");
+		this.provider.sendStateless(JSON.stringify({
+			type: "chat:history",
+			channel: input.channel,
+			...input.before !== void 0 ? { before: input.before } : {},
+			...input.limit !== void 0 ? { limit: input.limit } : {}
+		}));
+		return promise;
+	}
+	/** Broadcast a typing indicator on a channel. */
+	sendTyping(channel) {
+		this.provider.sendStateless(JSON.stringify({
+			type: "chat:typing",
+			channel
+		}));
+	}
+	/** List the current user's channels (ordered by last activity). */
+	listChannels() {
+		const promise = this.enqueue("chat:channels");
+		this.provider.sendStateless(JSON.stringify({ type: "chat:channels" }));
+		return promise;
+	}
+	/** Mark a channel read up to `timestamp` (unix ms). */
+	markRead(channel, timestamp) {
+		this.provider.sendStateless(JSON.stringify({
+			type: "chat:mark_read",
+			channel,
+			timestamp
+		}));
+	}
+	/** Fetch per-user read cursors for a channel. */
+	getReadCursors(channel) {
+		const promise = this.enqueue("chat:read_cursors");
+		this.provider.sendStateless(JSON.stringify({
+			type: "chat:read_cursors",
+			channel
+		}));
+		return promise;
+	}
+	onMessage(fn) {
+		return this.on("message", fn);
+	}
+	onTyping(fn) {
+		return this.on("typing", fn);
+	}
+	onReadReceipt(fn) {
+		return this.on("readReceipt", fn);
+	}
+	enqueue(type) {
+		return new Promise((resolve, reject) => {
+			const entry = {
+				resolve,
+				reject,
+				timer: setTimeout(() => {
+					this.removePending(type, entry);
+					reject(/* @__PURE__ */ new Error(`ChatClient: timeout waiting for ${type} response`));
+				}, this.responseTimeoutMs)
+			};
+			const queue = this.pending.get(type) ?? [];
+			queue.push(entry);
+			this.pending.set(type, queue);
+		});
+	}
+	removePending(type, entry) {
+		const queue = this.pending.get(type);
+		if (!queue) return;
+		const idx = queue.indexOf(entry);
+		if (idx >= 0) queue.splice(idx, 1);
+		if (queue.length === 0) this.pending.delete(type);
+	}
+	resolveNext(type, value) {
+		const queue = this.pending.get(type);
+		if (!queue || queue.length === 0) return false;
+		const next = queue.shift();
+		if (queue.length === 0) this.pending.delete(type);
+		clearTimeout(next.timer);
+		next.resolve(value);
+		return true;
+	}
+	handleStateless(payload) {
+		let parsed;
+		try {
+			parsed = JSON.parse(payload);
+		} catch {
+			return;
+		}
+		const type = parsed?.type;
+		if (typeof type !== "string" || !type.startsWith("chat:")) return;
+		switch (type) {
+			case "chat:message": {
+				const { type: _t, ...rest } = parsed;
+				this.emit("message", rest);
+				break;
+			}
+			case "chat:history":
+				this.resolveNext("chat:history", {
+					channel: parsed.channel,
+					messages: parsed.messages ?? []
+				});
+				break;
+			case "chat:channels":
+				this.resolveNext("chat:channels", { channels: parsed.channels ?? [] });
+				break;
+			case "chat:typing":
+				this.emit("typing", {
+					channel: parsed.channel,
+					sender_id: parsed.sender_id,
+					sender_name: parsed.sender_name ?? null
+				});
+				break;
+			case "chat:read_receipt":
+				this.emit("readReceipt", {
+					channel: parsed.channel,
+					user_id: parsed.user_id,
+					last_read_at: parsed.last_read_at
+				});
+				break;
+			case "chat:read_cursors":
+				this.resolveNext("chat:read_cursors", {
+					channel: parsed.channel,
+					cursors: parsed.cursors ?? []
+				});
+				break;
+			default: break;
+		}
+	}
+};
+
+//#endregion
+//#region packages/provider/src/NotificationsClient.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+/**
+* Typed client for the Abracadabra notifications feature.
+*
+* Emits:
+*   - `new`        → NotificationRecord      (incoming notify:new broadcast)
+*   - `readUpdate` → NotificationReadUpdate  (broadcast after mark_read / mark_all_read)
+*/
+var NotificationsClient = class extends EventEmitter {
+	constructor(provider, options) {
+		super();
+		this.pending = /* @__PURE__ */ new Map();
+		this.provider = provider;
+		this.responseTimeoutMs = options?.responseTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+		this.boundOnStateless = (data) => this.handleStateless(data.payload);
+		this.provider.on("stateless", this.boundOnStateless);
+	}
+	destroy() {
+		this.provider.off("stateless", this.boundOnStateless);
+		for (const queue of this.pending.values()) for (const p of queue) {
+			clearTimeout(p.timer);
+			p.reject(/* @__PURE__ */ new Error("NotificationsClient destroyed"));
+		}
+		this.pending.clear();
+		this.removeAllListeners();
+	}
+	/**
+	* Create a notification targeting a specific recipient. Requires elevated role
+	* (service or admin); a `server:error` event with code `forbidden` is emitted
+	* by the underlying provider if the caller lacks permission.
+	*/
+	create(input) {
+		this.provider.sendStateless(JSON.stringify({
+			type: "notify:create",
+			recipient_id: input.recipient_id,
+			...input.notification_type !== void 0 ? { notification_type: input.notification_type } : {},
+			title: input.title,
+			...input.body !== void 0 ? { body: input.body } : {},
+			...input.icon !== void 0 ? { icon: input.icon } : {},
+			...input.link !== void 0 ? { link: input.link } : {},
+			...input.source_id !== void 0 ? { source_id: input.source_id } : {}
+		}));
+	}
+	/** Fetch notification history for the current user. */
+	fetch(input = {}) {
+		const promise = this.enqueue("notify:history");
+		this.provider.sendStateless(JSON.stringify({
+			type: "notify:fetch",
+			...input.before !== void 0 ? { before: input.before } : {},
+			...input.limit !== void 0 ? { limit: input.limit } : {},
+			...input.unread_only !== void 0 ? { unread_only: input.unread_only } : {}
+		}));
+		return promise;
+	}
+	/** Mark a single notification, or a batch, as read. */
+	markRead(target) {
+		const body = { type: "notify:mark_read" };
+		if ("id" in target) body.id = target.id;
+		else body.ids = target.ids;
+		this.provider.sendStateless(JSON.stringify(body));
+	}
+	/** Mark every notification for the current user as read. */
+	markAllRead() {
+		this.provider.sendStateless(JSON.stringify({ type: "notify:mark_all_read" }));
+	}
+	/** Mark all notifications generated by the given source (e.g. a chat channel) as read. */
+	markReadBySource(sourceId) {
+		this.provider.sendStateless(JSON.stringify({
+			type: "notify:mark_read_by_source",
+			source_id: sourceId
+		}));
+	}
+	onNew(fn) {
+		return this.on("new", fn);
+	}
+	onReadUpdate(fn) {
+		return this.on("readUpdate", fn);
+	}
+	enqueue(type) {
+		return new Promise((resolve, reject) => {
+			const entry = {
+				resolve,
+				reject,
+				timer: setTimeout(() => {
+					this.removePending(type, entry);
+					reject(/* @__PURE__ */ new Error(`NotificationsClient: timeout waiting for ${type} response`));
+				}, this.responseTimeoutMs)
+			};
+			const queue = this.pending.get(type) ?? [];
+			queue.push(entry);
+			this.pending.set(type, queue);
+		});
+	}
+	removePending(type, entry) {
+		const queue = this.pending.get(type);
+		if (!queue) return;
+		const idx = queue.indexOf(entry);
+		if (idx >= 0) queue.splice(idx, 1);
+		if (queue.length === 0) this.pending.delete(type);
+	}
+	resolveNext(type, value) {
+		const queue = this.pending.get(type);
+		if (!queue || queue.length === 0) return false;
+		const next = queue.shift();
+		if (queue.length === 0) this.pending.delete(type);
+		clearTimeout(next.timer);
+		next.resolve(value);
+		return true;
+	}
+	handleStateless(payload) {
+		let parsed;
+		try {
+			parsed = JSON.parse(payload);
+		} catch {
+			return;
+		}
+		const type = parsed?.type;
+		if (typeof type !== "string" || !type.startsWith("notify:")) return;
+		switch (type) {
+			case "notify:new": {
+				const { type: _t, ...rest } = parsed;
+				this.emit("new", rest);
+				break;
+			}
+			case "notify:history":
+				this.resolveNext("notify:history", { notifications: parsed.notifications ?? [] });
+				break;
+			case "notify:read_update": {
+				const update = { recipient_id: parsed.recipient_id };
+				if (parsed.ids !== void 0) update.ids = parsed.ids;
+				if (parsed.all !== void 0) update.all = parsed.all;
+				this.emit("readUpdate", update);
+				break;
+			}
+			default: break;
+		}
+	}
+};
+
 //#endregion
 exports.AbracadabraBaseProvider = AbracadabraBaseProvider;
 exports.AbracadabraClient = AbracadabraClient;
@@ -14066,6 +14500,7 @@ exports.BackgroundSyncManager = BackgroundSyncManager;
 exports.BackgroundSyncPersistence = BackgroundSyncPersistence;
 exports.BroadcastChannelSync = BroadcastChannelSync;
 exports.CHANNEL_NAMES = CHANNEL_NAMES;
+exports.ChatClient = ChatClient;
 exports.ConnectionTimeout = ConnectionTimeout;
 exports.CryptoIdentityKeystore = CryptoIdentityKeystore;
 exports.DEFAULT_FILE_CHUNK_SIZE = DEFAULT_FILE_CHUNK_SIZE;
@@ -14091,6 +14526,7 @@ exports.KEY_EXCHANGE_CHANNEL = KEY_EXCHANGE_CHANNEL;
 exports.ManualSignaling = ManualSignaling;
 exports.MessageTooBig = MessageTooBig;
 exports.MessageType = MessageType;
+exports.NotificationsClient = NotificationsClient;
 exports.OfflineStore = OfflineStore;
 exports.PeerConnection = PeerConnection;
 exports.ResetConnection = ResetConnection;