@abraca/dabra 2.3.0 → 2.5.0

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(),
 		});