@abraca/dabra 1.9.1 → 2.0.1

package/src/AbracadabraProvider.ts

@@ -73,6 +73,15 @@ export interface AbracadabraProviderConfiguration
 	 * sharing one local store.  Used for the identity doc.
 	 */
 	serverAgnostic?: boolean;
+
+	/**
+	 * Maximum number of simultaneously cached child providers before LRU
+	 * eviction reclaims the least-recently-used unpinned ones. Default 20.
+	 * Apps that legitimately need more docs alive (e.g. background-sync of
+	 * a working set) should raise this; pin individual children with
+	 * `pinChild()` to make them eviction-immune regardless of cap.
+	 */
+	maxChildren?: number;
 }
 
 /** Validate that a string is a UUID acceptable by the server's DocId parser. */
@@ -114,8 +123,9 @@ export class AbracadabraProvider extends AbracadabraBaseProvider {
 	private childAccessTimes = new Map<string, number>();
 	/** Pinned children that must not be evicted (e.g. actively viewed docs) */
 	private pinnedChildren = new Set<string>();
-	/** Max simultaneously cached child providers before LRU eviction kicks in */
-	private static readonly MAX_CHILDREN = 20;
+	/** Default cap on simultaneously cached child providers; configurable per-instance via `maxChildren`. */
+	private static readonly DEFAULT_MAX_CHILDREN = 20;
+	private readonly maxChildren: number;
 
 	private abracadabraConfig: AbracadabraProviderConfiguration;
 
@@ -143,8 +153,13 @@ export class AbracadabraProvider extends AbracadabraBaseProvider {
 		const client = configuration.client ?? null;
 
 		if (client) {
-			if (!resolved.url && !resolved.websocketProvider) {
-				(resolved as any).url = client.wsUrl;
+			// `url` is no longer part of the base provider config — the URL
+			// rides on `websocketProvider`. Keep the legacy field assignment
+			// for downstream consumers that read it off the merged object,
+			// but cast through `any` since `resolved` doesn't declare it.
+			const r = resolved as { url?: string; websocketProvider?: AbracadabraWS };
+			if (!r.url && !r.websocketProvider) {
+				r.url = client.wsUrl;
 			}
 			if (resolved.token === undefined && !configuration.cryptoIdentity) {
 				resolved.token = () => client.token ?? "";
@@ -155,6 +170,7 @@ export class AbracadabraProvider extends AbracadabraBaseProvider {
 		this._client = client;
 		this.abracadabraConfig = configuration;
 		this.subdocLoading = configuration.subdocLoading ?? "lazy";
+		this.maxChildren = configuration.maxChildren ?? AbracadabraProvider.DEFAULT_MAX_CHILDREN;
 
 		const serverOrigin = configuration.serverAgnostic
 			? undefined
@@ -560,9 +576,8 @@ export class AbracadabraProvider extends AbracadabraBaseProvider {
 	 * at or below MAX_CHILDREN.
 	 */
 	private evictLRU() {
-		if (this.childProviders.size <= AbracadabraProvider.MAX_CHILDREN) return;
+		if (this.childProviders.size <= this.maxChildren) return;
 
-		// Build a list of evictable children sorted by last access (oldest first)
 		const evictable: Array<{ id: string; accessTime: number }> = [];
 		for (const [id] of this.childProviders) {
 			if (this.pinnedChildren.has(id)) continue;
@@ -570,7 +585,7 @@ export class AbracadabraProvider extends AbracadabraBaseProvider {
 		}
 		evictable.sort((a, b) => a.accessTime - b.accessTime);
 
-		let toEvict = this.childProviders.size - AbracadabraProvider.MAX_CHILDREN;
+		let toEvict = this.childProviders.size - this.maxChildren;
 		for (const entry of evictable) {
 			if (toEvict <= 0) break;
 			this.unloadChild(entry.id);

package/src/AbracadabraWS.ts

@@ -542,7 +542,7 @@ export class AbracadabraWS extends EventEmitter {
     // Detect server-side rate-limit close (code 4429).
     // `event` may be a CloseEvent (browser) with `.code`, or a raw number (ws/Node.js).
     // `event` may be a CloseEvent (browser) with `.code`, or a raw number (ws/Node.js).
-    const isRateLimited = (event as any)?.code === 4429 || event === 4429;
+    const isRateLimited = (event as any)?.code === 4429 || (event as unknown) === 4429;
     this.emit("disconnect", { event });
     if (isRateLimited) {
       this.emit("rateLimited");

package/src/ChatClient.ts

@@ -1,17 +1,18 @@
 import EventEmitter from "./EventEmitter.ts";
 import type {
-  ChatChannel,
-  ChatMessage,
-  ChatReadCursor,
-  ChatReadReceipt,
   ChatTypingEvent,
-  GetChatHistoryInput,
-  SendChatMessageInput,
+  SendChatMessageInput as _LegacySendInput,
+  GetChatHistoryInput as _LegacyHistoryInput,
 } from "./types.ts";
 
+// Legacy alias re-exports kept for type-import compat with consumers that
+// import these names from `@abraca/dabra`. The old shapes still describe
+// the wire the dashboard's own reactive layer reads/writes; this client
+// itself no longer uses them as method inputs.
+export type _ReExportedTypes = _LegacySendInput | _LegacyHistoryInput;
+
 /**
  * Minimal provider surface ChatClient needs. Matches `AbracadabraBaseProvider`.
- * Kept as an interface so consumers can pass any compatible transport.
  */
 export interface ChatClientTransport {
   sendStateless(payload: string): void;
@@ -30,38 +31,114 @@ type PendingResolver<T> = {
 const DEFAULT_TIMEOUT_MS = 10_000;
 
 /**
- * Typed client for the Abracadabra chat feature.
+ * Send a chat message into a channel doc.
+ *
+ * `channel_doc_id` is the UUID of the channel/dm doc — `documents.id` for
+ * a row with `kind = "channel"` or `kind = "dm"`. Group channels under a
+ * Space pass the channel doc's id; DMs pass the DM doc's id (callers
+ * resolve "the DM doc between user A and user B" via their own path —
+ * typically `client.listChildren(serverRootId)` filtered by `kind === "dm"`
+ * with both pubkeys in `permissions`).
+ */
+export interface SendMessageInput {
+  channel_doc_id: string;
+  content: string;
+  /** Cleartext recipient pubkeys for server-side mention fan-out. */
+  mentions?: string[];
+  /** Message id this is a reply to. */
+  reply_to?: string;
+  /**
+   * Optional Ed25519 signature over the canonical envelope, base64url. When
+   * server config `[messages].require_client_sig = true`, sends without a
+   * sig are rejected. Default-config servers accept unsigned sends — the
+   * threat model relies on JWT-bound session auth + the server's own
+   * `server_sig` over `(msg_id, period_id, ts, sig)`.
+   */
+  sig?: string;
+  /** Client-side timestamp (ms) for skew-tolerance check. Optional. */
+  ts_hint?: number;
+}
+
+export interface SendMessageResult {
+  message_id: string;
+  period_id: string;
+  ts: number;
+  server_sig: string;
+}
+
+export interface EditMessageInput {
+  channel_doc_id: string;
+  message_id: string;
+  content: string;
+  sig?: string;
+}
+
+export interface DeleteMessageInput {
+  channel_doc_id: string;
+  message_id: string;
+}
+
+export interface MarkReadInput {
+  channel_doc_id: string;
+  period_id: string;
+  message_id: string;
+  /** Unix milliseconds. Defaults to server time. */
+  ts?: number;
+}
+
+/**
+ * Thin façade over the `messages:*` stateless protocol.
  *
- * Wraps a connected provider (or base provider) and translates JSON envelopes
- * on the stateless channel into typed method calls and events.
+ * The unified messages model stores chat history as Y.Array entries on
+ * `kind = "channel-period"` child docs of channel/dm docs (and notifications
+ * as entries on a per-user `kind = "inbox"` doc). Reading history, listing
+ * channels, observing real-time messages, and tracking read cursors are all
+ * Y.Doc-shaped operations that the SDK consumer performs via
+ * `AbracadabraClient` + `AbracadabraProvider` directly — not through this
+ * façade. ChatClient handles only the *write-and-validate* path (sends,
+ * edits, deletes, typing, mark-read), where the server is the sole authority
+ * over the channel-period Y.Array.
  *
  * Events emitted:
- *   - `message`      → ChatMessage       (new message broadcast)
- *   - `typing`       → ChatTypingEvent   (typing indicator broadcast)
- *   - `readReceipt`  → ChatReadReceipt   (mark_read broadcast)
+ *   - `typing` → ChatTypingEvent (typing broadcast on the channel doc)
+ *
+ * For incoming-message observation, the consumer opens an
+ * `AbracadabraProvider` on the active period doc and observes its
+ * `messages` Y.Array directly. The dashboard's `useChat` composable does
+ * this; the integration tests do this; external consumers should mirror
+ * the pattern.
  */
 export class ChatClient extends EventEmitter {
   private readonly provider: ChatClientTransport;
   private readonly responseTimeoutMs: number;
 
-  // FIFO of promises waiting on a particular typed server response. The server
-  // replies on the same socket, one-per-request, so a simple queue per type
-  // matches observed behavior.
+  // FIFO of promises waiting on a typed `messages:ok` reply (keyed by source).
   private readonly pending: Map<string, PendingResolver<any>[]> = new Map();
 
   private readonly boundOnStateless: (data: { payload: string }) => void;
+  private readonly boundOnServerError: (data: {
+    source: string;
+    code: string;
+    message: string;
+    meta?: unknown;
+  }) => void;
 
   constructor(provider: ChatClientTransport, options?: { responseTimeoutMs?: number }) {
     super();
     this.provider = provider;
     this.responseTimeoutMs = options?.responseTimeoutMs ?? DEFAULT_TIMEOUT_MS;
     this.boundOnStateless = (data) => this.handleStateless(data.payload);
+    this.boundOnServerError = (data) => this.handleServerError(data);
     this.provider.on("stateless", this.boundOnStateless);
+    // BaseProvider intercepts `{type:"error",source,code}` frames and emits
+    // them as `serverError`, not `stateless` — so request/response code paths
+    // must listen here to learn about rejections.
+    this.provider.on("serverError", this.boundOnServerError);
   }
 
-  /** Stop listening for chat messages. Does not disconnect the underlying provider. */
   destroy(): void {
     this.provider.off("stateless", this.boundOnStateless);
+    this.provider.off("serverError", this.boundOnServerError);
     for (const queue of this.pending.values()) {
       for (const p of queue) {
         clearTimeout(p.timer);
@@ -74,107 +151,121 @@ export class ChatClient extends EventEmitter {
 
   // ── Outgoing requests ──────────────────────────────────────────────────────
 
-  /** Send a chat message on a channel. Fire-and-forget (the server broadcasts). */
-  sendMessage(input: SendChatMessageInput): void {
+  /** Send a chat message. Resolves with the server-assigned id, ts, and signatures. */
+  send(input: SendMessageInput): Promise<SendMessageResult> {
+    const promise = this.enqueue<SendMessageResult>("messages:send");
     this.provider.sendStateless(
       JSON.stringify({
-        type: "chat:send",
-        channel: input.channel,
+        type: "messages:send",
+        channel_doc_id: input.channel_doc_id,
         content: input.content,
-        ...(input.sender_name !== undefined ? { sender_name: input.sender_name } : {}),
+        mentions: input.mentions ?? [],
+        ...(input.reply_to !== undefined ? { reply_to: input.reply_to } : {}),
+        ...(input.sig !== undefined ? { sig: input.sig } : {}),
+        ...(input.ts_hint !== undefined ? { ts_hint: input.ts_hint } : {}),
       }),
     );
+    return promise;
   }
 
-  /** Fetch historical messages for a channel. Resolves with the server response. */
-  getHistory(input: GetChatHistoryInput): Promise<{ channel: string; messages: ChatMessage[] }> {
-    const promise = this.enqueue<{ channel: string; messages: ChatMessage[] }>("chat:history");
+  /** Edit a previously-sent message. Append-only — server records an `edit` entry. */
+  edit(input: EditMessageInput): Promise<void> {
+    const promise = this.enqueue<void>("messages:edit");
     this.provider.sendStateless(
       JSON.stringify({
-        type: "chat:history",
-        channel: input.channel,
-        ...(input.before !== undefined ? { before: input.before } : {}),
-        ...(input.limit !== undefined ? { limit: input.limit } : {}),
+        type: "messages:edit",
+        channel_doc_id: input.channel_doc_id,
+        message_id: input.message_id,
+        content: input.content,
+        ...(input.sig !== undefined ? { sig: input.sig } : {}),
       }),
     );
     return promise;
   }
 
-  /** Broadcast a typing indicator on a channel. */
-  sendTyping(channel: string): void {
-    this.provider.sendStateless(JSON.stringify({ type: "chat:typing", channel }));
-  }
-
-  /** List the current user's channels (ordered by last activity). */
-  listChannels(): Promise<{ channels: ChatChannel[] }> {
-    const promise = this.enqueue<{ channels: ChatChannel[] }>("chat:channels");
-    this.provider.sendStateless(JSON.stringify({ type: "chat:channels" }));
+  /** Delete a message. Append-only — server records a `tombstone` entry. */
+  delete(input: DeleteMessageInput): Promise<void> {
+    const promise = this.enqueue<void>("messages:delete");
+    this.provider.sendStateless(
+      JSON.stringify({
+        type: "messages:delete",
+        channel_doc_id: input.channel_doc_id,
+        message_id: input.message_id,
+      }),
+    );
     return promise;
   }
 
-  /** Mark a channel read up to `timestamp` (unix ms). */
-  markRead(channel: string, timestamp: number): void {
+  /** Broadcast a typing indicator on a channel. Fire-and-forget. */
+  typing(channel_doc_id: string): void {
     this.provider.sendStateless(
-      JSON.stringify({ type: "chat:mark_read", channel, timestamp }),
+      JSON.stringify({ type: "messages:typing", channel_doc_id }),
     );
   }
 
-  /** Fetch per-user read cursors for a channel. */
-  getReadCursors(channel: string): Promise<{ channel: string; cursors: ChatReadCursor[] }> {
-    const promise = this.enqueue<{ channel: string; cursors: ChatReadCursor[] }>(
-      "chat:read_cursors",
+  /** Mark a (period, message) position as read for the calling user. Fire-and-forget. */
+  markRead(input: MarkReadInput): void {
+    this.provider.sendStateless(
+      JSON.stringify({
+        type: "messages:mark_read",
+        channel_doc_id: input.channel_doc_id,
+        period_id: input.period_id,
+        message_id: input.message_id,
+        ...(input.ts !== undefined ? { ts: input.ts } : {}),
+      }),
     );
-    this.provider.sendStateless(JSON.stringify({ type: "chat:read_cursors", channel }));
-    return promise;
   }
 
-  // ── Typed event subscription helpers (optional sugar over EventEmitter) ───
-
-  onMessage(fn: (m: ChatMessage) => void): this {
-    return this.on("message", fn) as this;
-  }
+  // ── Typed event subscription helpers ──────────────────────────────────────
 
+  /** Observe typing broadcasts. */
   onTyping(fn: (e: ChatTypingEvent) => void): this {
     return this.on("typing", fn) as this;
   }
 
-  onReadReceipt(fn: (e: ChatReadReceipt) => void): this {
-    return this.on("readReceipt", fn) as this;
-  }
-
   // ── Internals ─────────────────────────────────────────────────────────────
 
-  private enqueue<T>(type: string): Promise<T> {
+  private enqueue<T>(source: string): Promise<T> {
     return new Promise<T>((resolve, reject) => {
       const timer = setTimeout(() => {
-        this.removePending(type, entry);
-        reject(new Error(`ChatClient: timeout waiting for ${type} response`));
+        this.removePending(source, entry);
+        reject(new Error(`ChatClient: timeout waiting for ${source} ack`));
       }, this.responseTimeoutMs);
       const entry: PendingResolver<T> = { resolve, reject, timer };
-      const queue = this.pending.get(type) ?? [];
+      const queue = this.pending.get(source) ?? [];
       queue.push(entry);
-      this.pending.set(type, queue);
+      this.pending.set(source, queue);
     });
   }
 
-  private removePending(type: string, entry: PendingResolver<any>): void {
-    const queue = this.pending.get(type);
+  private removePending(source: string, entry: PendingResolver<any>): void {
+    const queue = this.pending.get(source);
     if (!queue) return;
     const idx = queue.indexOf(entry);
     if (idx >= 0) queue.splice(idx, 1);
-    if (queue.length === 0) this.pending.delete(type);
+    if (queue.length === 0) this.pending.delete(source);
   }
 
-  private resolveNext<T>(type: string, value: T): boolean {
-    const queue = this.pending.get(type);
+  private resolveNext<T>(source: string, value: T): boolean {
+    const queue = this.pending.get(source);
     if (!queue || queue.length === 0) return false;
     const next = queue.shift()!;
-    if (queue.length === 0) this.pending.delete(type);
+    if (queue.length === 0) this.pending.delete(source);
     clearTimeout(next.timer);
     next.resolve(value);
     return true;
   }
 
+  private rejectNext(source: string, err: Error): boolean {
+    const queue = this.pending.get(source);
+    if (!queue || queue.length === 0) return false;
+    const next = queue.shift()!;
+    if (queue.length === 0) this.pending.delete(source);
+    clearTimeout(next.timer);
+    next.reject(err);
+    return true;
+  }
+
   private handleStateless(payload: string): void {
     let parsed: any;
     try {
@@ -183,52 +274,41 @@ export class ChatClient extends EventEmitter {
       return;
     }
     const type: unknown = parsed?.type;
-    if (typeof type !== "string" || !type.startsWith("chat:")) return;
-
-    switch (type) {
-      case "chat:message": {
-        // Server flattens the ChatMessage fields at the top level alongside `type`.
-        const { type: _t, ...rest } = parsed;
-        this.emit("message", rest as ChatMessage);
-        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,
-        } as ChatTypingEvent);
-        break;
-      }
-      case "chat:read_receipt": {
-        this.emit("readReceipt", {
-          channel: parsed.channel,
-          user_id: parsed.user_id,
-          last_read_at: parsed.last_read_at,
-        } as ChatReadReceipt);
-        break;
-      }
-      case "chat:read_cursors": {
-        this.resolveNext("chat:read_cursors", {
-          channel: parsed.channel,
-          cursors: parsed.cursors ?? [],
-        });
-        break;
-      }
-      default:
-        // Unknown chat:* subtype — ignore for forward compat.
-        break;
+    if (typeof type !== "string") return;
+
+    // Server emits `messages:ok` acks with a `source` matching the originating
+    // request type. Use that to resolve the matching pending promise.
+    if (type === "messages:ok" && typeof parsed.source === "string") {
+      this.resolveNext(parsed.source, parsed.meta);
+      return;
     }
+    if (type === "messages:typing") {
+      // The server includes channel_doc_id + user_id; the legacy
+      // ChatTypingEvent shape has `channel`, so emit it as the new doc id —
+      // consumers that want the old `group:<id>` form can prefix locally.
+      this.emit("typing", {
+        channel: parsed.channel_doc_id,
+        sender_id: parsed.user_id,
+        sender_name: null,
+      } as ChatTypingEvent);
+      return;
+    }
+  }
+
+  private handleServerError(data: {
+    source: string;
+    code: string;
+    message: string;
+    meta?: unknown;
+  }): void {
+    if (typeof data.source !== "string" || !data.source.startsWith("messages:")) return;
+    if (data.source === "messages:inbox_fetch" || data.source === "messages:inbox_mark_read") {
+      // Inbox traffic belongs to NotificationsClient — let it handle its own errors.
+      return;
+    }
+    this.rejectNext(
+      data.source,
+      new Error(`${data.code ?? "error"}: ${data.message ?? "messages request failed"}`),
+    );
   }
 }

package/src/ContentManager.ts

@@ -10,7 +10,19 @@ import {
 	yjsToMarkdown,
 	populateYDocFromMarkdown,
 	parseFrontmatter,
+	buildHeadingElement,
+	buildParagraphElement,
+	buildBulletListElement,
+	buildOrderedListElement,
+	buildTaskListElement,
+	buildCodeBlockElement,
+	buildBlockquoteElement,
+	buildHorizontalRuleElement,
+	buildBlocksFromMarkdown,
+	readBlocksFromFragment,
+	type DocumentBlock,
 } from "./DocConverters.ts";
+export type { DocumentBlock } from "./DocConverters.ts";
 import type { DocumentManager } from "./DocumentManager.ts";
 
 export interface DocumentContent {
@@ -46,11 +58,12 @@ export class ContentManager {
 		let label = title;
 		let type: string | undefined;
 		let meta: PageMeta | undefined;
-		let children: Array<{
+		const childrenWithOrder: Array<{
 			id: string;
 			label: string;
 			type?: string;
 			meta?: PageMeta;
+			order: number;
 		}> = [];
 
 		if (treeMap) {
@@ -62,23 +75,28 @@ export class ContentManager {
 				meta = entry.meta as PageMeta | undefined;
 			}
 			// Collect immediate children sorted by order
-			treeMap.forEach((value: any, id: string) => {
-				if (value.parentId === docId) {
-					children.push({
+			treeMap.forEach((rawChild: unknown, id: string) => {
+				const value = toPlain(rawChild) as Record<string, unknown>;
+				if (value && value.parentId === docId) {
+					childrenWithOrder.push({
 						id,
-						label: value.label || "Untitled",
-						type: value.type,
-						meta: value.meta,
+						label: (value.label as string) || "Untitled",
+						type: value.type as string | undefined,
+						meta: value.meta as PageMeta | undefined,
+						order: (value.order as number) ?? 0,
 					});
 				}
 			});
-			children.sort((a, b) => {
-				const orderA = treeMap.get(a.id)?.order ?? 0;
-				const orderB = treeMap.get(b.id)?.order ?? 0;
-				return orderA - orderB;
-			});
+			childrenWithOrder.sort((a, b) => a.order - b.order);
 		}
 
+		const children = childrenWithOrder.map(({ id, label, type, meta }) => ({
+			id,
+			label,
+			type,
+			meta,
+		}));
+
 		return { label, type, meta, title, markdown, children };
 	}
 
@@ -141,6 +159,56 @@ export class ContentManager {
 		populateYDocFromMarkdown(fragment, contentToWrite, fallbackTitle);
 	}
 
+	private async _appendElements(docId: string, els: Y.XmlElement[]): Promise<void> {
+		const provider = await this.dm.getChildProvider(docId);
+		const doc = provider.document;
+		const fragment = doc.getXmlFragment("default");
+		doc.transact(() => {
+			fragment.insert(fragment.length, els);
+		});
+	}
+
+	async appendHeading(docId: string, text: string, opts?: { level?: 1|2|3|4|5|6 }): Promise<void> {
+		return this._appendElements(docId, [buildHeadingElement(text, opts?.level)]);
+	}
+
+	async appendParagraph(docId: string, text: string): Promise<void> {
+		return this._appendElements(docId, [buildParagraphElement(text)]);
+	}
+
+	async appendBulletList(docId: string, items: string[]): Promise<void> {
+		return this._appendElements(docId, [buildBulletListElement(items)]);
+	}
+
+	async appendOrderedList(docId: string, items: string[]): Promise<void> {
+		return this._appendElements(docId, [buildOrderedListElement(items)]);
+	}
+
+	async appendTaskList(docId: string, items: Array<{ text: string; checked?: boolean }>): Promise<void> {
+		return this._appendElements(docId, [buildTaskListElement(items)]);
+	}
+
+	async appendCodeBlock(docId: string, code: string, opts?: { language?: string }): Promise<void> {
+		return this._appendElements(docId, [buildCodeBlockElement(code, opts?.language)]);
+	}
+
+	async appendBlockquote(docId: string, text: string): Promise<void> {
+		return this._appendElements(docId, [buildBlockquoteElement(text)]);
+	}
+
+	async appendHorizontalRule(docId: string): Promise<void> {
+		return this._appendElements(docId, [buildHorizontalRuleElement()]);
+	}
+
+	async appendMarkdown(docId: string, markdown: string): Promise<void> {
+		return this._appendElements(docId, buildBlocksFromMarkdown(markdown));
+	}
+
+	async getBlocks(docId: string): Promise<DocumentBlock[]> {
+		const provider = await this.dm.getChildProvider(docId);
+		return readBlocksFromFragment(provider.document.getXmlFragment("default"));
+	}
+
 	/**
 	 * Get the raw Y.XmlFragment for a document (the 'default' fragment
 	 * that TipTap uses for document content).

package/src/CryptoIdentityKeystore.ts

@@ -357,7 +357,7 @@ export class CryptoIdentityKeystore {
 			} else {
 				const all = await dbGetAll(db);
 				if (all.length > 0) {
-					await dbPut(db, all[0].key, { ...all[0].value, username });
+					await dbPut(db, String(all[0].key), { ...all[0].value, username });
 				}
 			}
 		} finally {
@@ -557,7 +557,7 @@ export class CryptoIdentityKeystore {
 					challenge: crypto.getRandomValues(new Uint8Array(32)),
 					rp: { id: rpId, name: rpName },
 					user: {
-						id: fromBase64url(kp.publicKeyB64),
+						id: fromBase64url(kp.publicKeyB64) as BufferSource,
 						name: kp.publicKeyB64.slice(0, 16),
 						displayName: kp.publicKeyB64.slice(0, 16),
 					},
@@ -663,7 +663,7 @@ export class CryptoIdentityKeystore {
 
 		if (credentialIdHint) {
 			allowCredentials.push({
-				id: fromBase64url(credentialIdHint),
+				id: fromBase64url(credentialIdHint) as BufferSource,
 				type: "public-key",
 			});
 		} else {