@abraca/dabra 2.4.0 → 2.6.0

package/src/AbracadabraProvider.ts

@@ -712,30 +712,39 @@ export class AbracadabraProvider extends AbracadabraBaseProvider {
 	 * errors across async await boundaries.
 	 */
 	private async flushPendingUpdates() {
-		if (!this.canWrite) return;
 		const store = this.offlineStore;
 		if (!store) return;
 
-		const updates = await store.getPendingUpdates();
-		if (updates.length > 0) {
-			for (const update of updates) {
-				this.send(UpdateMessage, {
-					update,
-					documentName: this.configuration.name,
-				});
+		// Flushing queued *local* writes / subdoc registrations over the wire
+		// is only meaningful for writers — a read-only session has none and
+		// must not send. The snapshot save below is deliberately OUTSIDE this
+		// guard.
+		if (this.canWrite) {
+			const updates = await store.getPendingUpdates();
+			if (updates.length > 0) {
+				for (const update of updates) {
+					this.send(UpdateMessage, {
+						update,
+						documentName: this.configuration.name,
+					});
+				}
+				await store.clearPendingUpdates();
 			}
-			await store.clearPendingUpdates();
-		}
 
-		const pendingSubdocs = await store.getPendingSubdocs();
-		for (const { childId } of pendingSubdocs) {
-			this.send(SubdocMessage, {
-				documentName: this.configuration.name,
-				childDocumentName: childId,
-			} as any);
+			const pendingSubdocs = await store.getPendingSubdocs();
+			for (const { childId } of pendingSubdocs) {
+				this.send(SubdocMessage, {
+					documentName: this.configuration.name,
+					childDocumentName: childId,
+				} as any);
+			}
 		}
 
 		// Snapshot the current merged state so the next offline load sees it.
+		// This is the ONLY path that persists server-delivered content
+		// (documentUpdateHandler skips origin===this), so it MUST run for
+		// read-only roles too — otherwise observers/viewers get a permanently
+		// empty offline cache and every cold start waits for a full re-sync.
 		const snapshot = Y.encodeStateAsUpdate(this.document);
 		await store.saveDocSnapshot(snapshot).catch(() => null);
 	}

package/src/ContentManager.ts

@@ -5,7 +5,7 @@
  */
 import * as Y from "yjs";
 import type { PageMeta } from "./DocTypes.ts";
-import { toPlain } from "./DocUtils.ts";
+import { toPlain, patchEntry } from "./DocUtils.ts";
 import {
 	yjsToMarkdown,
 	populateYDocFromMarkdown,
@@ -51,11 +51,9 @@ export class ContentManager {
 		const provider = await this.dm.getChildProvider(docId);
 		const fragment = provider.document.getXmlFragment("default");
 
-		const { title, markdown } = yjsToMarkdown(fragment);
-
 		// Get tree metadata + immediate children
 		const treeMap = this.dm.getTreeMap();
-		let label = title;
+		let label = "Untitled";
 		let type: string | undefined;
 		let meta: PageMeta | undefined;
 		const childrenWithOrder: Array<{
@@ -70,7 +68,7 @@ export class ContentManager {
 			const raw = treeMap.get(docId);
 			if (raw) {
 				const entry = toPlain(raw) as Record<string, unknown>;
-				label = (entry.label as string) || title;
+				label = (entry.label as string) || label;
 				type = entry.type as string | undefined;
 				meta = entry.meta as PageMeta | undefined;
 			}
@@ -97,6 +95,12 @@ export class ContentManager {
 			meta,
 		}));
 
+		// yjsToMarkdown returns a string and takes the resolved label/meta/type
+		// so frontmatter round-trips. (Older code destructured an object and
+		// passed only the fragment — that silently produced `undefined`.)
+		const markdown = yjsToMarkdown(fragment, label, meta, type);
+		const title = label;
+
 		return { label, type, meta, title, markdown, children };
 	}
 
@@ -127,18 +131,22 @@ export class ContentManager {
 				const entry = treeMap.get(docId);
 				if (entry) {
 					rootDoc.transact(() => {
-						const updates: Record<string, unknown> = {
-							...entry,
+						const cur = toPlain(entry) as Record<
+							string,
+							unknown
+						>;
+						const patch: Record<string, unknown> = {
 							updatedAt: Date.now(),
 						};
-						if (title) updates.label = title;
+						if (title) patch.label = title;
 						if (Object.keys(meta).length > 0) {
-							updates.meta = {
-								...(entry.meta ?? {}),
+							patch.meta = {
+								...((cur.meta as Record<string, unknown>) ??
+									{}),
 								...meta,
 							};
 						}
-						treeMap.set(docId, updates);
+						patchEntry(treeMap, docId, patch);
 					});
 				}
 			}

package/src/DocUtils.ts

@@ -87,3 +87,65 @@ export function normalizeRootId(
 export function toPlain(val: unknown): unknown {
 	return val instanceof Y.Map ? val.toJSON() : val;
 }
+
+/**
+ * Build a tree/trash entry as a nested `Y.Map`. Use for a brand-new or
+ * re-created key (create / duplicate / restore) where no concurrent
+ * writer exists, so a whole-value write is safe. `undefined` fields are
+ * omitted; `null` is kept (a real value, e.g. top-level `parentId`).
+ */
+export function makeEntryMap(
+	fields: Record<string, unknown>,
+): Y.Map<unknown> {
+	const m = new Y.Map<unknown>();
+	for (const [k, v] of Object.entries(fields)) {
+		if (v !== undefined) m.set(k, v);
+	}
+	return m;
+}
+
+/**
+ * Patch an EXISTING entry's fields per-key on its nested `Y.Map`, so a
+ * concurrent edit to a *different* field by a peer is preserved instead
+ * of being clobbered by a whole-entry write — the whole-entry-LWW fix
+ * (audit ⑦), the mirror of the Rust provider's `with_entry_mut`.
+ *
+ * - nested `Y.Map` entry → set/delete only the touched keys in place;
+ * - legacy opaque (plain-object) entry → migrated once to a `Y.Map`;
+ * - missing entry → created from the patch (lenient; matches the prior
+ *   call-site behaviour of spreading `undefined`).
+ *
+ * A patch value of `undefined` deletes the key; `null` is written.
+ * Self-transacting: it batches its writes in one `Y.Doc` transaction
+ * (a safe reentrant no-op join when already inside one), so callers
+ * don't need to pass or own a transaction.
+ */
+export function patchEntry(
+	treeMap: Y.Map<unknown>,
+	id: string,
+	patch: Record<string, unknown>,
+	removeKeys: string[] = [],
+): void {
+	const apply = (): void => {
+		const raw = treeMap.get(id);
+		if (raw instanceof Y.Map) {
+			for (const [k, v] of Object.entries(patch)) {
+				if (v === undefined) raw.delete(k);
+				else raw.set(k, v);
+			}
+			for (const k of removeKeys) raw.delete(k);
+			return;
+		}
+		const base =
+			raw == null ? {} : (toPlain(raw) as Record<string, unknown>);
+		const merged: Record<string, unknown> = { ...base, ...patch };
+		for (const [k, v] of Object.entries(patch)) {
+			if (v === undefined) delete merged[k];
+		}
+		for (const k of removeKeys) delete merged[k];
+		treeMap.set(id, makeEntryMap(merged));
+	};
+	const doc = treeMap.doc;
+	if (doc) doc.transact(apply);
+	else apply();
+}

package/src/DocumentManager.ts

@@ -74,6 +74,16 @@ export interface DocumentManagerConfig {
 	 * the entry-point docId is already known.
 	 */
 	rootDocId?: string;
+	/**
+	 * PROTOTYPE (Path-1 doctree scaling): opt into TreeManager's in-memory
+	 * parent→children index. When `false` (default), every tree walk
+	 * re-scans the whole `doc-tree` Y.Map (O(n) per call, O(n²) recursive
+	 * traversal) — the historical behaviour, byte-for-byte. When `true`,
+	 * walks resolve against a lazily-rebuilt adjacency index (O(k) per
+	 * lookup, O(result) traversal) and `tree.childrenOfPage()` becomes
+	 * usable. Behind a flag so it ships dark until benchmarked.
+	 */
+	treeIndex?: boolean;
 }
 
 interface CachedProvider {
@@ -195,6 +205,14 @@ export class DocumentManager {
 		return this._rootDocId;
 	}
 
+	/**
+	 * Whether the TreeManager in-memory index is enabled (Path-1 prototype).
+	 * Off by default — see {@link DocumentManagerConfig.treeIndex}.
+	 */
+	get treeIndexEnabled(): boolean {
+		return this._config.treeIndex ?? false;
+	}
+
 	get rootDocument(): Y.Doc | null {
 		return this._rootDoc;
 	}

package/src/FileBlobStore.ts

@@ -97,6 +97,17 @@ export class FileBlobStore extends EventEmitter {
 				.catch(() => null)
 				.then((db) => {
 					this.db = db;
+					if (db) {
+						// A browser-initiated close (storage pressure, tab
+						// eviction) leaves the cached handle unusable. Reset so
+						// the next getDb() reopens instead of handing back a
+						// connection that throws "database connection is
+						// closing" on transaction().
+						db.onclose = () => {
+							if (this.db === db) this.db = null;
+							this.dbPromise = null;
+						};
+					}
 					return db;
 				});
 		}
@@ -125,13 +136,34 @@ export class FileBlobStore extends EventEmitter {
 		const existing = this.objectUrls.get(key);
 		if (existing) return existing;
 
-		const db = await this.getDb();
+		let db = await this.getDb();
 		if (db) {
-			const tx = db.transaction("blobs", "readonly");
-			const entry = await txPromise<BlobCacheEntry | undefined>(
-				tx.objectStore("blobs"),
-				tx.objectStore("blobs").get(key),
-			);
+			let entry: BlobCacheEntry | undefined;
+			try {
+				const tx = db.transaction("blobs", "readonly");
+				entry = await txPromise<BlobCacheEntry | undefined>(
+					tx.objectStore("blobs"),
+					tx.objectStore("blobs").get(key),
+				);
+			} catch (err: unknown) {
+				// The cached connection was closed underneath us (space
+				// teardown / destroy() racing this async read). Reopen once
+				// and retry — the blob is still persisted in IDB.
+				if ((err as { name?: string })?.name === "InvalidStateError") {
+					if (this.db === db) this.db = null;
+					this.dbPromise = null;
+					db = await this.getDb();
+					if (db) {
+						const tx = db.transaction("blobs", "readonly");
+						entry = await txPromise<BlobCacheEntry | undefined>(
+							tx.objectStore("blobs"),
+							tx.objectStore("blobs").get(key),
+						);
+					}
+				} else {
+					throw err;
+				}
+			}
 			if (entry) {
 				const url = URL.createObjectURL(entry.blob);
 				this.objectUrls.set(key, url);
@@ -436,6 +468,11 @@ export class FileBlobStore extends EventEmitter {
 
 		this.db?.close();
 		this.db = null;
+		// Drop the cached promise too — otherwise a still-mounted FileNodeView
+		// that calls getBlobUrl() after teardown gets the just-closed handle
+		// and throws InvalidStateError. Nulling it lets getDb() reopen a fresh
+		// connection to read the (still-persisted) cached blob.
+		this.dbPromise = null;
 		this.removeAllListeners();
 	}
 }

package/src/MetaManager.ts

@@ -12,7 +12,7 @@
  * `update`/`set` behave exactly as before (Rule 4).
  */
 import type { PageMeta } from "./DocTypes.ts";
-import { toPlain } from "./DocUtils.ts";
+import { toPlain, patchEntry } from "./DocUtils.ts";
 import type { DocumentManager } from "./DocumentManager.ts";
 
 export interface DocumentMetaInfo {
@@ -124,8 +124,7 @@ export class MetaManager {
 		const entry = toPlain(raw) as Record<string, unknown>;
 		const mergedMeta = { ...((entry.meta as PageMeta) ?? {}), ...meta };
 		this.validateOrThrow(docId, entry, mergedMeta);
-		treeMap.set(docId, {
-			...entry,
+		patchEntry(treeMap, docId, {
 			meta: mergedMeta,
 			updatedAt: Date.now(),
 		});
@@ -147,8 +146,7 @@ export class MetaManager {
 
 		const entry = toPlain(raw) as Record<string, unknown>;
 		this.validateOrThrow(docId, entry, meta);
-		treeMap.set(docId, {
-			...entry,
+		patchEntry(treeMap, docId, {
 			meta,
 			updatedAt: Date.now(),
 		});
@@ -174,8 +172,7 @@ export class MetaManager {
 			delete updated[key];
 		}
 		this.validateOrThrow(docId, entry, updated as PageMeta);
-		treeMap.set(docId, {
-			...entry,
+		patchEntry(treeMap, docId, {
 			meta: updated,
 			updatedAt: Date.now(),
 		});