@abraca/dabra 1.2.0 → 1.3.1

package/dist/abracadabra-provider.cjs

@@ -3252,6 +3252,30 @@ var AbracadabraClient = class {
 			auth: false
 		});
 	}
+	/** Request a device session token after successful crypto auth. Requires valid JWT. */
+	async requestDeviceSession(opts) {
+		return this.request("POST", "/auth/device-session", { body: {
+			publicKey: opts.publicKey,
+			deviceName: opts.deviceName
+		} });
+	}
+	/** Exchange a device session token for a fresh JWT. No biometric/passkey needed. */
+	async refreshWithDeviceSession(sessionToken) {
+		const res = await this.request("POST", "/auth/refresh", {
+			body: { sessionToken },
+			auth: false
+		});
+		this.token = res.token;
+		return res.token;
+	}
+	/** List active device sessions for the authenticated user. */
+	async listDeviceSessions() {
+		return (await this.request("GET", "/auth/device-session")).sessions;
+	}
+	/** Revoke a device session by ID. */
+	async revokeDeviceSession(sessionId) {
+		await this.request("DELETE", `/auth/device-session/${encodeURIComponent(sessionId)}`);
+	}
 	/**
 	* Fetch a short-lived anonymous pairing token for WebRTC signaling.
 	* No authentication required. The token only grants access to `__pairing_*` rooms.
@@ -7340,6 +7364,30 @@ var CryptoIdentityKeystore = class {
 			db.close();
 		}
 	}
+	/**
+	* Updates the cached username for a given credential (or the first cached identity).
+	* Call this after the user sets/changes their display name so it persists across devices.
+	*/
+	async setUsername(username, credentialIdHint) {
+		const db = await openDb$4();
+		try {
+			if (credentialIdHint) {
+				const stored = await dbGet(db, credentialIdHint);
+				if (stored) await dbPut(db, credentialIdHint, {
+					...stored,
+					username
+				});
+			} else {
+				const all = await dbGetAll(db);
+				if (all.length > 0) await dbPut(db, all[0].key, {
+					...all[0].value,
+					username
+				});
+			}
+		} finally {
+			db.close();
+		}
+	}
 	/** Returns true if an identity is cached in IndexedDB. */
 	async hasIdentity() {
 		const db = await openDb$4();
@@ -9984,6 +10032,8 @@ var AbracadabraWebRTC = class AbracadabraWebRTC extends EventEmitter {
 		this.yjsChannels = /* @__PURE__ */ new Map();
 		this.fileChannels = /* @__PURE__ */ new Map();
 		this.e2eeChannels = /* @__PURE__ */ new Map();
+		this._resolvedE2ee = null;
+		this._resolveE2eePromise = null;
 		this.peers = /* @__PURE__ */ new Map();
 		this.localPeerId = null;
 		this.isConnected = false;
@@ -10124,6 +10174,8 @@ var AbracadabraWebRTC = class AbracadabraWebRTC extends EventEmitter {
 			this.signaling.destroy();
 			this.signaling = null;
 		}
+		this._resolvedE2ee = null;
+		this._resolveE2eePromise = null;
 		this.removeAllListeners();
 	}
 	setMuted(muted) {
@@ -10250,25 +10302,69 @@ var AbracadabraWebRTC = class AbracadabraWebRTC extends EventEmitter {
 		this.attachDataHandlers(peerId, pc);
 		return pc;
 	}
+	/** Resolve the E2EE identity, supporting both pre-resolved objects and lazy factories. */
+	async resolveE2ee() {
+		if (this._resolvedE2ee) return this._resolvedE2ee;
+		if (!this.config.e2ee) return null;
+		if (typeof this.config.e2ee === "function") {
+			if (!this._resolveE2eePromise) this._resolveE2eePromise = this.config.e2ee().then((id) => {
+				this._resolvedE2ee = id;
+				return id;
+			});
+			return this._resolveE2eePromise;
+		}
+		this._resolvedE2ee = this.config.e2ee;
+		return this._resolvedE2ee;
+	}
 	attachDataHandlers(peerId, pc) {
-		if (this.config.e2ee) {
-			const e2ee = new E2EEChannel(this.config.e2ee, this.config.docId);
+		if (!this.config.e2ee) {
+			this.startDataSync(peerId, pc);
+			return;
+		}
+		let e2ee = null;
+		const pendingMessages = [];
+		let pendingKeyExchangeChannel = null;
+		pc.router.on("channelMessage", async ({ name, data }) => {
+			if (name !== KEY_EXCHANGE_CHANNEL) return;
+			const buf = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+			if (!e2ee) {
+				pendingMessages.push(buf);
+				return;
+			}
+			try {
+				await e2ee.handleKeyExchange(buf);
+			} catch (err) {
+				this.emit("e2eeFailed", {
+					peerId,
+					error: err
+				});
+			}
+		});
+		pc.router.on("channelOpen", ({ name, channel }) => {
+			if (name !== KEY_EXCHANGE_CHANNEL) return;
+			if (!e2ee) {
+				pendingKeyExchangeChannel = channel;
+				return;
+			}
+			channel.send(e2ee.getKeyExchangeMessage());
+		});
+		this.resolveE2ee().then(async (identity) => {
+			if (!identity) {
+				this.startDataSync(peerId, pc);
+				return;
+			}
+			e2ee = new E2EEChannel(identity, this.config.docId);
 			this.e2eeChannels.set(peerId, e2ee);
 			pc.router.setEncryptor(e2ee);
-			pc.router.on("channelMessage", async ({ name, data }) => {
-				if (name === KEY_EXCHANGE_CHANNEL) try {
-					const buf = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
-					await e2ee.handleKeyExchange(buf);
-				} catch (err) {
-					this.emit("e2eeFailed", {
-						peerId,
-						error: err
-					});
-				}
-			});
-			pc.router.on("channelOpen", ({ name, channel }) => {
-				if (name === KEY_EXCHANGE_CHANNEL) channel.send(e2ee.getKeyExchangeMessage());
-			});
+			if (pendingKeyExchangeChannel) pendingKeyExchangeChannel.send(e2ee.getKeyExchangeMessage());
+			for (const msg of pendingMessages) try {
+				await e2ee.handleKeyExchange(msg);
+			} catch (err) {
+				this.emit("e2eeFailed", {
+					peerId,
+					error: err
+				});
+			}
 			e2ee.on("established", () => {
 				this.emit("e2eeEstablished", { peerId });
 				this.startDataSync(peerId, pc);
@@ -10279,7 +10375,13 @@ var AbracadabraWebRTC = class AbracadabraWebRTC extends EventEmitter {
 					error: err
 				});
 			});
-		} else this.startDataSync(peerId, pc);
+		}).catch((err) => {
+			this.emit("e2eeFailed", {
+				peerId,
+				error: err
+			});
+			this.startDataSync(peerId, pc);
+		});
 	}
 	startDataSync(peerId, pc) {
 		if (this.config.document && this.config.enableDocSync) {