@abraca/dabra 1.0.20 → 1.0.22

package/dist/abracadabra-provider.esm.js

@@ -2792,7 +2792,7 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 		this._client = client;
 		this.abracadabraConfig = configuration;
 		this.subdocLoading = configuration.subdocLoading ?? "lazy";
-		const serverOrigin = AbracadabraProvider.deriveServerOrigin(configuration, client);
+		const serverOrigin = configuration.serverAgnostic ? void 0 : 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));
@@ -3198,10 +3198,30 @@ var AbracadabraClient = class {
 	async listKeys() {
 		return (await this.request("GET", "/auth/keys")).keys;
 	}
+	/** Rename a registered device key. */
+	async renameKey(keyId, deviceName) {
+		await this.request("PATCH", `/auth/keys/${encodeURIComponent(keyId)}`, { body: { deviceName } });
+	}
 	/** Revoke a public key by its ID. */
 	async revokeKey(keyId) {
 		await this.request("DELETE", `/auth/keys/${encodeURIComponent(keyId)}`);
 	}
+	/** Create a single-use device invite code for pairing a new device to this account. */
+	async createDeviceInvite(opts) {
+		return this.request("POST", "/auth/device-invite", { body: opts?.expiresIn != null ? { expiresIn: opts.expiresIn } : {} });
+	}
+	/** Redeem a device invite code to register a new device key. Returns a JWT token. */
+	async redeemDeviceInvite(opts) {
+		return this.request("POST", "/auth/device-redeem", {
+			body: {
+				code: opts.code,
+				publicKey: opts.publicKey,
+				x25519Key: opts.x25519Key,
+				deviceName: opts.deviceName
+			},
+			auth: false
+		});
+	}
 	/** Get encryption info for a document. */
 	async getDocEncryption(docId) {
 		return this.request("GET", `/docs/${encodeURIComponent(docId)}/encryption`);
@@ -9897,19 +9917,23 @@ var AbracadabraWebRTC = class AbracadabraWebRTC extends EventEmitter {
 	}
 	/**
 	* Send a custom string message to a specific peer via a data channel.
+	* When E2EE is active, the message is encrypted through the router.
 	*/
 	sendCustomMessage(peerId, payload) {
 		const pc = this.peerConnections.get(peerId);
 		if (!pc) return;
-		let channel = pc.router.getChannel("custom");
+		const channelName = "custom";
+		let channel = pc.router.getChannel(channelName);
 		if (!channel || channel.readyState !== "open") {
-			channel = pc.router.createChannel("custom", { ordered: true });
+			channel = pc.router.createChannel(channelName, { ordered: true });
 			channel.onopen = () => {
-				channel.send(payload);
+				const data = new TextEncoder().encode(payload);
+				pc.router.send(channelName, data);
 			};
 			return;
 		}
-		channel.send(payload);
+		const data = new TextEncoder().encode(payload);
+		pc.router.send(channelName, data);
 	}
 	/**
 	* Send a custom string message to all connected peers.
@@ -10256,6 +10280,270 @@ var ManualSignaling = class extends EventEmitter {
 	}
 };
 
+//#endregion
+//#region packages/provider/src/webrtc/DevicePairingChannel.ts
+/**
+* DevicePairingChannel
+*
+* Enables cross-device identity pairing over an E2EE WebRTC data channel.
+* Device A (approver) creates a pairing session with a short code. Device B
+* (requester) joins with the code. After E2EE is established, Device B sends
+* its public key and Device A registers it via `addKey()`.
+*
+* Reuses the existing WebRTC stack: SignalingSocket, PeerConnection,
+* DataChannelRouter, and E2EEChannel (X25519 ECDH + AES-256-GCM).
+*/
+/** Ambiguity-free charset (no 0/O/1/I). */
+const CODE_CHARSET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+const CODE_LENGTH = 6;
+const PAIRING_TIMEOUT_MS = 300 * 1e3;
+function generatePairingCode() {
+	const bytes = crypto.getRandomValues(new Uint8Array(CODE_LENGTH));
+	return Array.from(bytes).map((b) => CODE_CHARSET[b % 32]).join("");
+}
+function codeToRoomId(code) {
+	const hash = sha256(new TextEncoder().encode(code.toUpperCase()));
+	return `__pairing_${Array.from(hash.slice(0, 8)).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
+	constructor(role, pairingCode, config) {
+		super();
+		this.config = config;
+		this.webrtc = null;
+		this.timeoutHandle = null;
+		this._destroyed = false;
+		this._pendingRequest = null;
+		this._connectedPeerId = null;
+		this.role = role;
+		this.pairingCode = pairingCode;
+	}
+	/**
+	* Create an approver session (Device A). Returns the channel and a
+	* 6-character pairing code to share with Device B.
+	*/
+	static createApprover(config) {
+		const code = generatePairingCode();
+		const channel = new DevicePairingChannel("approver", code, config);
+		channel.start();
+		return {
+			channel,
+			pairingCode: code
+		};
+	}
+	/**
+	* Create a requester session (Device B). Joins with a pairing code
+	* obtained from Device A.
+	*/
+	static createRequester(config, pairingCode) {
+		const channel = new DevicePairingChannel("requester", pairingCode.toUpperCase().replace(/[^A-Z2-9]/g, ""), config);
+		channel.start();
+		return channel;
+	}
+	/**
+	* Approve the pending pairing request. Calls `client.addKey()` to
+	* register Device B's public key, then notifies Device B.
+	*/
+	async approve(client) {
+		if (this.role !== "approver") return {
+			success: false,
+			error: "Only the approver can approve"
+		};
+		if (!this._pendingRequest) return {
+			success: false,
+			error: "No pending pairing request"
+		};
+		if (!this._connectedPeerId) return {
+			success: false,
+			error: "Peer not connected"
+		};
+		const req = this._pendingRequest;
+		try {
+			await client.addKey({
+				publicKey: req.publicKey,
+				deviceName: req.deviceName,
+				x25519Key: req.x25519Key
+			});
+			this.sendMessage({ type: "pair-approved" });
+			this._pendingRequest = null;
+			this.emit("pairingComplete", { success: true });
+			return { success: true };
+		} catch (err) {
+			const error = err?.message ?? "Failed to register device key";
+			this.sendMessage({
+				type: "pair-rejected",
+				reason: error
+			});
+			this._pendingRequest = null;
+			const result = {
+				success: false,
+				error
+			};
+			this.emit("pairingComplete", result);
+			return result;
+		}
+	}
+	/**
+	* 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.
+	*/
+	async approveWithInvite(client) {
+		if (this.role !== "approver") return {
+			success: false,
+			error: "Only the approver can approve"
+		};
+		if (!this._pendingRequest) return {
+			success: false,
+			error: "No pending pairing request"
+		};
+		if (!this._connectedPeerId) return {
+			success: false,
+			error: "Peer not connected"
+		};
+		try {
+			const { code } = await client.createDeviceInvite();
+			this.sendMessage({
+				type: "pair-invite-code",
+				code
+			});
+			this._pendingRequest = null;
+			this.emit("pairingComplete", { success: true });
+			return { success: true };
+		} catch (err) {
+			const error = err?.message ?? "Failed to create device invite";
+			this.sendMessage({
+				type: "pair-rejected",
+				reason: error
+			});
+			this._pendingRequest = null;
+			const result = {
+				success: false,
+				error
+			};
+			this.emit("pairingComplete", result);
+			return result;
+		}
+	}
+	/**
+	* Reject the pending pairing request.
+	*/
+	reject(reason = "Rejected by user") {
+		if (this.role !== "approver" || !this._pendingRequest) return;
+		this.sendMessage({
+			type: "pair-rejected",
+			reason
+		});
+		this._pendingRequest = null;
+		this.emit("pairingComplete", {
+			success: false,
+			error: reason
+		});
+	}
+	/**
+	* Send a pairing request to Device A. Call this after the "connected"
+	* event fires.
+	*/
+	requestPairing(request) {
+		if (this.role !== "requester") return;
+		this.sendMessage({
+			type: "pair-request",
+			publicKey: request.publicKey,
+			x25519Key: request.x25519Key,
+			deviceName: request.deviceName
+		});
+	}
+	get isDestroyed() {
+		return this._destroyed;
+	}
+	destroy() {
+		if (this._destroyed) return;
+		this._destroyed = true;
+		if (this.timeoutHandle) {
+			clearTimeout(this.timeoutHandle);
+			this.timeoutHandle = null;
+		}
+		if (this.webrtc) {
+			this.webrtc.destroy();
+			this.webrtc = null;
+		}
+		this.removeAllListeners();
+	}
+	start() {
+		this.webrtc = new AbracadabraWebRTC({
+			docId: codeToRoomId(this.pairingCode),
+			url: this.config.serverUrl,
+			token: this.config.token,
+			iceServers: this.config.iceServers,
+			e2ee: this.config.e2ee,
+			enableDocSync: false,
+			enableAwarenessSync: false,
+			enableFileTransfer: false,
+			autoConnect: false,
+			WebSocketPolyfill: this.config.WebSocketPolyfill
+		});
+		this.webrtc.on("e2eeEstablished", ({ peerId }) => {
+			this._connectedPeerId = peerId;
+			this.emit("connected");
+		});
+		this.webrtc.on("customMessage", ({ peerId, payload }) => {
+			this.handleMessage(peerId, payload);
+		});
+		this.webrtc.on("peerLeft", () => {
+			if (!this._destroyed) this.emit("error", /* @__PURE__ */ new Error("Peer disconnected"));
+		});
+		this.webrtc.on("signalingError", (err) => {
+			this.emit("error", /* @__PURE__ */ new Error(`Signaling: ${err.message}`));
+		});
+		this.timeoutHandle = setTimeout(() => {
+			if (!this._destroyed) {
+				this.emit("error", /* @__PURE__ */ new Error("Pairing timed out"));
+				this.destroy();
+			}
+		}, PAIRING_TIMEOUT_MS);
+		this.webrtc.connect();
+	}
+	sendMessage(msg) {
+		if (!this.webrtc || !this._connectedPeerId) return;
+		this.webrtc.sendCustomMessage(this._connectedPeerId, JSON.stringify(msg));
+	}
+	handleMessage(peerId, payload) {
+		let msg;
+		try {
+			msg = JSON.parse(payload);
+		} catch {
+			return;
+		}
+		switch (msg.type) {
+			case "pair-request":
+				if (this.role !== "approver") return;
+				this._pendingRequest = {
+					publicKey: msg.publicKey,
+					x25519Key: msg.x25519Key,
+					deviceName: msg.deviceName
+				};
+				this.emit("pairingRequest", this._pendingRequest);
+				break;
+			case "pair-approved":
+				if (this.role !== "requester") return;
+				this.emit("approved");
+				this.emit("pairingComplete", { success: true });
+				break;
+			case "pair-rejected":
+				if (this.role !== "requester") return;
+				this.emit("rejected", msg.reason);
+				this.emit("pairingComplete", {
+					success: false,
+					error: msg.reason
+				});
+				break;
+			case "pair-invite-code":
+				if (this.role !== "requester") return;
+				this.emit("inviteCode", msg.code);
+				break;
+		}
+	}
+};
+
 //#endregion
 //#region packages/provider/src/sync/BroadcastChannelSync.ts
 /**
@@ -10408,5 +10696,304 @@ var BroadcastChannelSync = class BroadcastChannelSync extends EventEmitter {
 };
 
 //#endregion
-export { AbracadabraBaseProvider, AbracadabraClient, AbracadabraProvider, AbracadabraWS, AbracadabraWebRTC, AuthMessageType, AwarenessError, BackgroundSyncManager, BackgroundSyncPersistence, BroadcastChannelSync, CHANNEL_NAMES, ConnectionTimeout, CryptoIdentityKeystore, DEFAULT_FILE_CHUNK_SIZE, DEFAULT_ICE_SERVERS, DataChannelRouter, DocKeyManager, DocumentCache, E2EAbracadabraProvider, E2EEChannel, E2EOfflineStore, EncryptedYMap, EncryptedYText, FileBlobStore, FileTransferChannel, FileTransferHandle, Forbidden, HocuspocusProvider, HocuspocusProviderWebsocket, KEY_EXCHANGE_CHANNEL, ManualSignaling, MessageTooBig, MessageType, OfflineStore, PeerConnection, ResetConnection, SearchIndex, SignalingSocket, SubdocMessage, Unauthorized, WebSocketStatus, WsReadyStates, YjsDataChannel, attachUpdatedAtObserver, awarenessStatesToArray, decryptField, encryptField, makeEncryptedYMap, makeEncryptedYText, readAuthMessage, writeAuthenticated, writeAuthentication, writePermissionDenied, writeTokenSyncRequest };
+//#region packages/provider/src/IdentityDoc.ts
+/**
+* Derives a deterministic UUID from an Ed25519 account-level public key.
+*
+* The result is a valid UUID v5-style string that any device sharing the
+* same identity can independently compute.  The `abracadabra:identity:`
+* prefix prevents collisions with randomly generated doc UUIDs.
+*
+* @param publicKeyB64 Base64url-encoded Ed25519 public key (32 bytes).
+*/
+function deriveIdentityDocId(publicKeyB64) {
+	const hash = sha256(new TextEncoder().encode(`abracadabra:identity:${publicKeyB64}`));
+	const bytes = new Uint8Array(hash.buffer, hash.byteOffset, 16);
+	bytes[6] = bytes[6] & 15 | 80;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+/**
+* Manages a Y.Doc dedicated to user identity that syncs across trusted
+* targets only: a designated sync server, a local Tauri server, and/or
+* WebRTC P2P.
+*
+* The Y.Doc contains cross-device settings (profile, servers, spaces,
+* plugins, preferences).  Each sync target gets its own
+* AbracadabraProvider sharing the same Y.Doc, with `serverAgnostic: true`
+* so they all use one IndexedDB store.
+*/
+var IdentityDocProvider = class extends EventEmitter {
+	constructor(configuration) {
+		super();
+		this.providers = /* @__PURE__ */ new Map();
+		this.websockets = /* @__PURE__ */ new Map();
+		this.webrtc = null;
+		this._destroyed = false;
+		this.config = configuration;
+		this.docId = deriveIdentityDocId(configuration.publicKey);
+		this.document = new Y.Doc({ guid: this.docId });
+		if (configuration.autoConnect !== false) this.connect();
+	}
+	connect() {
+		if (this._destroyed) return;
+		const targets = [];
+		if (this.config.localServerUrl) targets.push({
+			url: this.config.localServerUrl,
+			key: "local"
+		});
+		if (this.config.syncServerUrl) targets.push({
+			url: this.config.syncServerUrl,
+			key: "sync"
+		});
+		for (const { url, key } of targets) {
+			if (this.providers.has(key)) continue;
+			this._connectToServer(key, url);
+		}
+		if (this.config.webrtc && !this.webrtc) this._connectWebRTC();
+	}
+	_connectToServer(key, serverUrl) {
+		const token = this.config.tokens?.[serverUrl] ?? this.config.token ?? "";
+		const ws = new AbracadabraWS({
+			url: serverUrl.replace(/^http/, "ws").replace(/\/$/, "").concat("/ws"),
+			WebSocketPolyfill: void 0
+		});
+		this.websockets.set(key, ws);
+		const provider = new AbracadabraProvider({
+			name: this.docId,
+			document: this.document,
+			websocketProvider: ws,
+			token,
+			serverAgnostic: true,
+			disableOfflineStore: key !== "local" && key !== "sync" ? true : this.config.disableOfflineStore ?? false,
+			...this.config.providerDefaults
+		});
+		provider.on("synced", () => this.emit("synced", { server: key }));
+		provider.on("status", (data) => this.emit("status", {
+			server: key,
+			...data
+		}));
+		this.providers.set(key, provider);
+	}
+	_connectWebRTC() {
+		const rtcConfig = this.config.webrtc;
+		if (!rtcConfig) return;
+		this.webrtc = new AbracadabraWebRTC({
+			docId: this.docId,
+			url: rtcConfig.signalingServerUrl,
+			token: rtcConfig.token,
+			document: this.document,
+			enableDocSync: true,
+			enableAwarenessSync: false,
+			enableFileTransfer: false,
+			e2ee: rtcConfig.e2ee,
+			iceServers: rtcConfig.iceServers
+		});
+	}
+	get profileMap() {
+		return this.document.getMap("profile");
+	}
+	get serversMap() {
+		return this.document.getMap("servers");
+	}
+	get spacesArray() {
+		return this.document.getArray("spaces");
+	}
+	get pluginsMap() {
+		return this.document.getMap("plugins");
+	}
+	get preferencesMap() {
+		return this.document.getMap("preferences");
+	}
+	getProfile() {
+		const m = this.profileMap;
+		return {
+			username: m.get("username"),
+			displayName: m.get("displayName"),
+			colorName: m.get("colorName"),
+			neutralColorName: m.get("neutralColorName"),
+			locale: m.get("locale"),
+			avatarUrl: m.get("avatarUrl")
+		};
+	}
+	setProfile(profile) {
+		const m = this.profileMap;
+		this.document.transact(() => {
+			for (const [key, value] of Object.entries(profile)) if (value !== void 0) m.set(key, value);
+		});
+	}
+	getServer(url) {
+		const entry = this.serversMap.get(url);
+		if (!entry) return void 0;
+		return {
+			label: entry.get("label") ?? url,
+			hubDocId: entry.get("hubDocId"),
+			entryDocId: entry.get("entryDocId"),
+			defaultRole: entry.get("defaultRole"),
+			spacesEnabled: entry.get("spacesEnabled"),
+			addedAt: entry.get("addedAt") ?? 0
+		};
+	}
+	setServer(url, entry) {
+		const m = this.serversMap;
+		this.document.transact(() => {
+			let yEntry = m.get(url);
+			if (!yEntry) {
+				yEntry = new Y.Map();
+				m.set(url, yEntry);
+			}
+			for (const [key, value] of Object.entries(entry)) if (value !== void 0) yEntry.set(key, value);
+		});
+	}
+	removeServer(url) {
+		this.serversMap.delete(url);
+	}
+	getServers() {
+		const result = /* @__PURE__ */ new Map();
+		this.serversMap.forEach((entry, url) => {
+			result.set(url, {
+				label: entry.get("label") ?? url,
+				hubDocId: entry.get("hubDocId"),
+				entryDocId: entry.get("entryDocId"),
+				defaultRole: entry.get("defaultRole"),
+				spacesEnabled: entry.get("spacesEnabled"),
+				addedAt: entry.get("addedAt") ?? 0
+			});
+		});
+		return result;
+	}
+	getSpaces() {
+		const result = [];
+		this.spacesArray.forEach((yMap) => {
+			result.push({
+				id: yMap.get("id"),
+				name: yMap.get("name"),
+				type: yMap.get("type") ?? "remote",
+				serverUrl: yMap.get("serverUrl") ?? null,
+				docId: yMap.get("docId"),
+				remoteSpaceId: yMap.get("remoteSpaceId"),
+				visibility: yMap.get("visibility") ?? "private",
+				isHub: yMap.get("isHub") ?? false,
+				order: yMap.get("order") ?? 0,
+				lastSyncedAt: yMap.get("lastSyncedAt"),
+				createdAt: yMap.get("createdAt") ?? 0
+			});
+		});
+		return result;
+	}
+	addSpace(space) {
+		const yMap = new Y.Map();
+		this.document.transact(() => {
+			for (const [key, value] of Object.entries(space)) if (value !== void 0) yMap.set(key, value);
+			this.spacesArray.push([yMap]);
+		});
+	}
+	removeSpace(spaceId) {
+		const arr = this.spacesArray;
+		for (let i = 0; i < arr.length; i++) if (arr.get(i).get("id") === spaceId) {
+			arr.delete(i, 1);
+			return;
+		}
+	}
+	updateSpace(spaceId, updates) {
+		const arr = this.spacesArray;
+		for (let i = 0; i < arr.length; i++) {
+			const yMap = arr.get(i);
+			if (yMap.get("id") === spaceId) {
+				this.document.transact(() => {
+					for (const [key, value] of Object.entries(updates)) if (value !== void 0) yMap.set(key, value);
+				});
+				return;
+			}
+		}
+	}
+	getExternalPlugins() {
+		let arr = this.pluginsMap.get("external");
+		if (!arr) {
+			arr = new Y.Array();
+			this.pluginsMap.set("external", arr);
+		}
+		return arr;
+	}
+	getDisabledBuiltins() {
+		let arr = this.pluginsMap.get("disabledBuiltins");
+		if (!arr) {
+			arr = new Y.Array();
+			this.pluginsMap.set("disabledBuiltins", arr);
+		}
+		return arr;
+	}
+	getPreference(key) {
+		return this.preferencesMap.get(key);
+	}
+	setPreference(key, value) {
+		this.preferencesMap.set(key, value);
+	}
+	/**
+	* Observe deep changes on a specific top-level map.
+	* Returns an unsubscribe function.
+	*/
+	observe(mapName, callback) {
+		const map = this.document.getMap(mapName);
+		map.observeDeep(callback);
+		return () => map.unobserveDeep(callback);
+	}
+	/**
+	* Observe changes to the spaces array.
+	* Returns an unsubscribe function.
+	*/
+	observeSpaces(callback) {
+		const arr = this.spacesArray;
+		arr.observe(callback);
+		return () => arr.unobserve(callback);
+	}
+	/**
+	* Returns true if the identity doc has no profile data yet (first use).
+	* Call this to decide whether to run migration from localStorage.
+	*/
+	isEmpty() {
+		return this.profileMap.size === 0 && this.serversMap.size === 0;
+	}
+	/**
+	* Update the sync server URL at runtime (e.g. when user changes their
+	* designated sync server in settings).
+	*/
+	setSyncServer(url) {
+		const existing = this.providers.get("sync");
+		if (existing) {
+			existing.destroy();
+			this.providers.delete("sync");
+		}
+		const existingWs = this.websockets.get("sync");
+		if (existingWs) {
+			existingWs.destroy();
+			this.websockets.delete("sync");
+		}
+		if (url) {
+			this.config = {
+				...this.config,
+				syncServerUrl: url
+			};
+			this._connectToServer("sync", url);
+		}
+	}
+	getProvider(key) {
+		return this.providers.get(key);
+	}
+	destroy() {
+		if (this._destroyed) return;
+		this._destroyed = true;
+		for (const [, provider] of this.providers) provider.destroy();
+		for (const [, ws] of this.websockets) ws.destroy();
+		if (this.webrtc) this.webrtc.disconnect?.();
+		this.providers.clear();
+		this.websockets.clear();
+		this.webrtc = null;
+		this.document.destroy();
+	}
+};
+
+//#endregion
+export { AbracadabraBaseProvider, AbracadabraClient, AbracadabraProvider, AbracadabraWS, AbracadabraWebRTC, AuthMessageType, AwarenessError, BackgroundSyncManager, BackgroundSyncPersistence, BroadcastChannelSync, CHANNEL_NAMES, ConnectionTimeout, CryptoIdentityKeystore, DEFAULT_FILE_CHUNK_SIZE, DEFAULT_ICE_SERVERS, DataChannelRouter, DevicePairingChannel, DocKeyManager, DocumentCache, E2EAbracadabraProvider, E2EEChannel, E2EOfflineStore, EncryptedYMap, EncryptedYText, FileBlobStore, FileTransferChannel, FileTransferHandle, Forbidden, HocuspocusProvider, HocuspocusProviderWebsocket, IdentityDocProvider, KEY_EXCHANGE_CHANNEL, ManualSignaling, MessageTooBig, MessageType, OfflineStore, PeerConnection, ResetConnection, SearchIndex, SignalingSocket, SubdocMessage, Unauthorized, WebSocketStatus, WsReadyStates, YjsDataChannel, attachUpdatedAtObserver, awarenessStatesToArray, decryptField, deriveIdentityDocId, encryptField, makeEncryptedYMap, makeEncryptedYText, readAuthMessage, writeAuthenticated, writeAuthentication, writePermissionDenied, writeTokenSyncRequest };
 //# sourceMappingURL=abracadabra-provider.esm.js.map