@abraca/dabra 1.6.0 → 1.8.1

package/dist/abracadabra-provider.cjs

@@ -2840,6 +2840,7 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 		this.childAccessTimes = /* @__PURE__ */ new Map();
 		this.pinnedChildren = /* @__PURE__ */ new Set();
 		this.boundHandleYSubdocsChange = this.handleYSubdocsChange.bind(this);
+		this.hasCachedContent = false;
 		this._client = client;
 		this.abracadabraConfig = configuration;
 		this.subdocLoading = configuration.subdocLoading ?? "lazy";
@@ -2877,8 +2878,14 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 	async _initFromOfflineStore() {
 		if (!this.offlineStore) return;
 		const [snapshot, pending] = await Promise.all([this.offlineStore.getDocSnapshot().catch(() => null), this.offlineStore.getPendingUpdates().catch(() => [])]);
-		if (snapshot) yjs.applyUpdate(this.document, snapshot, this.offlineStore);
-		for (const update of pending) yjs.applyUpdate(this.document, update, this.offlineStore);
+		if (snapshot) {
+			yjs.applyUpdate(this.document, snapshot, this.offlineStore);
+			this.hasCachedContent = true;
+		}
+		for (const update of pending) {
+			yjs.applyUpdate(this.document, update, this.offlineStore);
+			this.hasCachedContent = true;
+		}
 	}
 	authenticatedHandler(scope) {
 		super.authenticatedHandler(scope);
@@ -13191,8 +13198,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"
@@ -13212,7 +13223,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 };
@@ -13235,8 +13249,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"
@@ -13253,7 +13271,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 });
@@ -13424,7 +13443,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":
@@ -13437,7 +13456,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;
 		}
 	}
@@ -13964,6 +13983,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).
 	*/
@@ -14150,6 +14182,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;
@@ -14162,6 +14507,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;
@@ -14187,6 +14533,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;