@abraca/dabra 2.0.7 → 2.0.8

package/dist/abracadabra-provider.cjs

@@ -2294,6 +2294,7 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 		this.isSynced = false;
 		this.unsyncedChanges = 0;
 		this.isAuthenticated = false;
+		this._hasEverAuthenticated = false;
 		this.authorizedScope = void 0;
 		this.manageSocket = false;
 		this._isAttached = false;
@@ -2504,6 +2505,7 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 	onClose() {
 		this.isAuthenticated = false;
 		this.synced = false;
+		this._hasEverAuthenticated = false;
 		if (this.awareness) removeAwarenessStates(this.awareness, Array.from(this.awareness.getStates().keys()).filter((client) => client !== this.document.clientID), this);
 	}
 	destroy() {
@@ -2560,12 +2562,13 @@ var AbracadabraBaseProvider = class extends EventEmitter {
 	permissionDeniedHandler(reason) {
 		this.emit("authenticationFailed", { reason });
 		this.isAuthenticated = false;
-		if (this.manageSocket) try {
+		if (this.manageSocket && !this._hasEverAuthenticated) try {
 			this.configuration.websocketProvider.disconnect();
 		} catch {}
 	}
 	authenticatedHandler(scope) {
 		this.isAuthenticated = true;
+		this._hasEverAuthenticated = true;
 		this.authorizedScope = scope;
 		this.emit("authenticated", { scope });
 	}
@@ -2803,7 +2806,7 @@ function isValidDocId(id) {
 */
 var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvider {
 	static {
-		this.DEFAULT_MAX_CHILDREN = 20;
+		this.DEFAULT_MAX_CHILDREN = 64;
 	}
 	constructor(configuration) {
 		const resolved = { ...configuration };
@@ -2819,6 +2822,7 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 		this.pendingLoads = /* @__PURE__ */ new Map();
 		this.childAccessTimes = /* @__PURE__ */ new Map();
 		this.pinnedChildren = /* @__PURE__ */ new Set();
+		this.transientChildren = /* @__PURE__ */ new Set();
 		this.boundHandleYSubdocsChange = this.handleYSubdocsChange.bind(this);
 		this.hasCachedContent = false;
 		this._client = client;
@@ -3016,22 +3020,34 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 	}
 	/**
 	* Create (or return cached) a child AbracadabraProvider for a given
-	* child document id.  Each child opens its own WebSocket connection because
-	* the server is document-scoped (one WebSocket ↔ one document).
+	* child document id.  Each child shares the parent's WebSocket via
+	* multiplexing.
+	*
+	* `evictable` (default `true`) controls whether the child enters the
+	* LRU pool. Pass `evictable: false` for transient loads — typically
+	* batch indexers (search, file extraction) that touch every doc in
+	* the tree and would otherwise blow out the cache, silently evicting
+	* subdocs the UI is actively using. Transient children are excluded
+	* from the LRU budget AND don't trigger eviction of other children.
+	* Callers MUST pair `loadChild(id, { evictable: false })` with an
+	* explicit `unloadChild(id)` once they're done.
 	*/
-	loadChild(childId) {
+	loadChild(childId, options = {}) {
 		if (!isValidDocId(childId)) return Promise.reject(/* @__PURE__ */ new Error(`loadChild: "${childId}" is not a valid document ID (must be a UUID). If this node was created with an older version of the app, delete it and recreate it.`));
+		if (childId === this.configuration.name) return Promise.resolve(this);
+		const evictable = options.evictable !== false;
 		if (this.childProviders.has(childId)) {
 			this.childAccessTimes.set(childId, Date.now());
+			if (evictable) this.transientChildren.delete(childId);
 			return Promise.resolve(this.childProviders.get(childId));
 		}
 		if (this.pendingLoads.has(childId)) return this.pendingLoads.get(childId);
-		const load = this._doLoadChild(childId);
+		const load = this._doLoadChild(childId, evictable);
 		this.pendingLoads.set(childId, load);
 		load.finally(() => this.pendingLoads.delete(childId));
 		return load;
 	}
-	async _doLoadChild(childId) {
+	async _doLoadChild(childId, evictable) {
 		const childDoc = new yjs.Doc({ guid: childId });
 		this.registerSubdoc(childDoc);
 		const childProvider = new AbracadabraProvider({
@@ -3050,7 +3066,8 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 		childProvider.attach();
 		this.childProviders.set(childId, childProvider);
 		this.childAccessTimes.set(childId, Date.now());
-		this.evictLRU();
+		if (!evictable) this.transientChildren.add(childId);
+		if (evictable) this.evictLRU();
 		this.emit("subdocLoaded", {
 			childId,
 			provider: childProvider
@@ -3064,6 +3081,7 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 			this.childProviders.delete(childId);
 			this.childAccessTimes.delete(childId);
 			this.pinnedChildren.delete(childId);
+			this.transientChildren.delete(childId);
 		}
 	}
 	/**
@@ -3081,21 +3099,27 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 		this.evictLRU();
 	}
 	/**
-	* Evict least-recently-used unpinned child providers until the cache is
-	* at or below MAX_CHILDREN.
+	* Evict least-recently-used unpinned, non-transient child providers
+	* until the cache is at or below MAX_CHILDREN. Transient children
+	* (loaded with `{ evictable: false }`) are excluded from both the
+	* budget *and* the eviction list — they're invisible to the LRU and
+	* only go away when their loader explicitly calls `unloadChild`.
 	*/
 	evictLRU() {
-		if (this.childProviders.size <= this.maxChildren) return;
+		let nonTransientCount = 0;
+		for (const id of this.childProviders.keys()) if (!this.transientChildren.has(id)) nonTransientCount++;
+		if (nonTransientCount <= this.maxChildren) return;
 		const evictable = [];
 		for (const [id] of this.childProviders) {
 			if (this.pinnedChildren.has(id)) continue;
+			if (this.transientChildren.has(id)) continue;
 			evictable.push({
 				id,
 				accessTime: this.childAccessTimes.get(id) ?? 0
 			});
 		}
 		evictable.sort((a, b) => a.accessTime - b.accessTime);
-		let toEvict = this.childProviders.size - this.maxChildren;
+		let toEvict = nonTransientCount - this.maxChildren;
 		for (const entry of evictable) {
 			if (toEvict <= 0) break;
 			this.unloadChild(entry.id);