doxum 0.1.40 → 0.1.42

package/dist/index.js

@@ -1,6 +1,6 @@
-import { A as ownProjections, C as snapshotProjectionValues, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as assertSynchronous, a as collectionChangeTouchesKey, b as ProjectionError, c as assertKeyedProjection, d as outputKind, f as createKeyRelation, g as assertScope, h as snapshotArray, i as collectionChangeIntersects, j as producerOf, k as isProjection, l as compileKeyedDependencies, m as sameArray, n as keyedAbsent, o as collectionHasStructuralChange, p as iterableMatchesArray, s as createCollectionChange, t as createKeyedTransform, u as createKeyedDependencyRuntime, v as createScheduler, w as collectionView, x as collectKeyedInvalidation, y as ProjectionDisposedError } from "./transform--WCn6_v0.js";
+import { A as ownProjections, C as snapshotProjectionValues, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as assertSynchronous, a as collectionChangeTouchesKey, b as ProjectionError, c as assertKeyedProjection, d as outputKind, f as createKeyRelation, g as assertScope, h as snapshotArray, i as collectionChangeIntersects, j as producerOf, k as isProjection, l as compileKeyedDependencies, m as sameArray, n as keyedAbsent, o as collectionHasStructuralChange, p as iterableMatchesArray, s as createCollectionChange, t as createKeyedTransform, u as createKeyedDependencyRuntime, v as createScheduler, w as collectionView, x as collectKeyedInvalidation, y as ProjectionDisposedError } from "./transform-BvDYPUMm.js";
 import { n as isPlainObject, r as isRecord, t as installOwn } from "./record-B2yRhYsc.js";
-import { c as AddressIndex, d as invalidValue, f as children, g as validate, h as parent, i as contextOf, l as MutationRejected, m as is, o as decodeChanges, p as contains$1, r as bindContext, s as sealChanges, t as assertRuntimeWritable, u as fail } from "./driver-B7RR-VfX.js";
+import { _ as validate, c as addListener, d as fail, f as invalidValue, g as parent, h as is, i as contextOf, l as AddressIndex, m as contains$1, o as decodeChanges, p as children, r as bindContext, s as sealChanges, t as assertRuntimeWritable, u as MutationRejected } from "./driver-B7Hu6D0u.js";
 //#region core/src/schema/model.ts
 const schemaNodeOf = (schema) => schema;
 const collectionEntryNode = (node) => node.kind === "map" || node.kind === "table" || node.kind === "list" ? node.value : void 0;
@@ -651,7 +651,7 @@ function remove$2(session, container, ids) {
 	for (const id of removed) session.writeMember(container, id, void 0, "remove");
 	table.ids = table.ids.filter((id) => !removed.has(id));
 }
-function replace$3(session, container, id, value) {
+function replace$4(session, container, id, value) {
 	const { at, node, value: tableValue } = container;
 	if (node.kind !== "table") return fail(at, "invalid-collection", "Expected a table.");
 	const table = tableValue;
@@ -674,7 +674,7 @@ function insert$1(session, container, value, position) {
 	insert$2(items, index(keys$1, position), value);
 	session.invalidate();
 }
-function replace$2(session, container, id, value) {
+function replace$3(session, container, id, value) {
 	const { at, node, value: items } = container;
 	if (node.kind !== "list") return fail(at, "invalid-list-key", "Expected a list.");
 	const index = indexedKeys(items, node.keyOf).index(id);
@@ -720,7 +720,7 @@ const insert = (session, container, id, value, position) => {
 	else tree.rootId = id;
 	session.invalidate();
 };
-const replace$1 = (session, container, id, value) => {
+const replace$2 = (session, container, id, value) => {
 	const { at, node: schema, value: tree } = container;
 	const entry = node$1(tree, id);
 	if (!entry) return fail(at, "missing-tree-node", "Tree node does not exist.");
@@ -1179,7 +1179,7 @@ const createAccess = (context, initial = []) => {
 			const [valueOrId, value] = args;
 			if (args.length === 1) return replaceCollection(target, node, valueOrId);
 			const writable = writableCollection(target, node);
-			replace$3(context.session, writable, valueOrId, value);
+			replace$4(context.session, writable, valueOrId, value);
 		};
 		return orderedMethod(target, property, node);
 	};
@@ -1196,7 +1196,7 @@ const createAccess = (context, initial = []) => {
 			const [valueOrId, value] = args;
 			if (args.length === 1) return replaceCollection(target, node, valueOrId);
 			const writable = writableCollection(target, node);
-			replace$2(context.session, writable, valueOrId, value);
+			replace$3(context.session, writable, valueOrId, value);
 		};
 		return orderedMethod(target, property, node);
 	};
@@ -1218,7 +1218,7 @@ const createAccess = (context, initial = []) => {
 			const [valueOrId, value] = args;
 			if (args.length === 1) return replaceCollection(target, node, valueOrId);
 			const writable = writableTree(target, node);
-			replace$1(context.session, writable, valueOrId, value);
+			replace$2(context.session, writable, valueOrId, value);
 		};
 		const current = () => collectionValue(target, node);
 		if (property === "rootId") return () => {
@@ -1622,10 +1622,7 @@ const createHistory = (input) => {
 			revision: () => revision,
 			subscribe: (listener) => {
 				if (disposed) throw new DocumentDisposedError();
-				listeners.add(listener);
-				return () => {
-					listeners.delete(listener);
-				};
+				return addListener(listeners, listener);
 			},
 			undo: () => {
 				input.assertIdle();
@@ -2296,6 +2293,7 @@ const addRoot = (notification, listener) => {
 	};
 	notification.root.add(entry);
 	return () => {
+		if (!entry.active) return;
 		entry.active = false;
 		if (!notification.notifying) notification.root.delete(entry);
 		else notification.cleanups.add(() => {
@@ -2669,7 +2667,9 @@ const select = (document, selector, equality = Object.is) => {
 		};
 	};
 	const installSubscription = () => {
-		unsubscribeDocument?.();
+		const stop = unsubscribeDocument;
+		unsubscribeDocument = void 0;
+		stop?.();
 		unsubscribeDocument = dependencies.length > 0 ? context.notifications.subscribeTargets(dependencies, () => {
 			const result = evaluate();
 			if (result.rebound) installSubscription();
@@ -2689,15 +2689,22 @@ const select = (document, selector, equality = Object.is) => {
 		},
 		subscribe: (listener) => {
 			ensureCurrent();
-			listeners.add(listener);
-			if (listeners.size === 1) installSubscription();
-			return () => {
-				listeners.delete(listener);
+			const unsubscribe = addListener(listeners, listener, () => {
 				if (!listeners.size) {
-					unsubscribeDocument?.();
+					const stop = unsubscribeDocument;
 					unsubscribeDocument = void 0;
+					stop?.();
 				}
-			};
+			});
+			try {
+				if (listeners.size === 1) installSubscription();
+			} catch (error) {
+				try {
+					unsubscribe();
+				} catch {}
+				throw error;
+			}
+			return unsubscribe;
 		}
 	});
 };
@@ -3687,6 +3694,33 @@ function createValueDerive(dependencies, compute, equality = Object.is) {
 }
 const derive = Object.assign(createValueDerive, { keyed: keyedDerive });
 //#endregion
+//#region core/src/projection/cleanup.ts
+/** Owner-local, cancellable LIFO callbacks. Lifecycle admission stays with the owner. */
+const createCleanupStack = () => {
+	const entries = /* @__PURE__ */ new Set();
+	return {
+		add(callback) {
+			const entry = () => {
+				assertSynchronous(callback());
+			};
+			entries.add(entry);
+			return () => {
+				entries.delete(entry);
+			};
+		},
+		drain(failures) {
+			for (const entry of [...entries].reverse()) {
+				if (!entries.delete(entry)) continue;
+				try {
+					entry();
+				} catch (error) {
+					failures.push(error);
+				}
+			}
+		}
+	};
+};
+//#endregion
 //#region core/src/projection/collection/changes.ts
 /** Net transitions for one consumer's unconsumed interval; bounded by touched keys. */
 const createCollectionChanges = () => {
@@ -3797,49 +3831,109 @@ const node = (key, value, left, right) => {
 		height: Math.max(height(left), height(right)) + 1
 	});
 };
-const rotateLeft = (current) => {
-	const right = current.right;
-	return node(right.key, right.value, node(current.key, current.value, current.left, right.left), right.right);
-};
-const rotateRight = (current) => {
-	const left = current.left;
-	return node(left.key, left.value, left.left, node(current.key, current.value, left.right, current.right));
-};
-const rebalance = (current) => {
-	const balance = height(current.left) - height(current.right);
-	if (balance > 1) {
-		if (height(current.left.left) < height(current.left.right)) return rotateRight(node(current.key, current.value, rotateLeft(current.left), current.right));
-		return rotateRight(current);
-	}
-	if (balance < -1) {
-		if (height(current.right.right) < height(current.right.left)) return rotateLeft(node(current.key, current.value, current.left, rotateRight(current.right)));
-		return rotateLeft(current);
-	}
-	return current;
-};
-const setNode = (current, key, value) => {
-	if (!current) return node(key, value);
-	if (key === current.key) return node(key, value, current.left, current.right);
-	if (key < current.key) return rebalance(node(current.key, current.value, setNode(current.left, key, value), current.right));
-	return rebalance(node(current.key, current.value, current.left, setNode(current.right, key, value)));
-};
-const minNode = (current) => current.left ? minNode(current.left) : current;
-const removeNode = (current, key) => {
-	if (!current) return void 0;
-	if (key < current.key) return rebalance(node(current.key, current.value, removeNode(current.left, key), current.right));
-	if (key > current.key) return rebalance(node(current.key, current.value, current.left, removeNode(current.right, key)));
+/** Local repair after a join descent or a single deletion (height difference at most two). */
+const balance = (key, value, left, right) => {
+	if (height(left) > height(right) + 1) {
+		const heavy = left;
+		if (height(heavy.left) >= height(heavy.right)) return node(heavy.key, heavy.value, heavy.left, node(key, value, heavy.right, right));
+		const middle = heavy.right;
+		return node(middle.key, middle.value, node(heavy.key, heavy.value, heavy.left, middle.left), node(key, value, middle.right, right));
+	}
+	if (height(right) > height(left) + 1) {
+		const heavy = right;
+		if (height(heavy.right) >= height(heavy.left)) return node(heavy.key, heavy.value, node(key, value, left, heavy.left), heavy.right);
+		const middle = heavy.left;
+		return node(middle.key, middle.value, node(key, value, left, middle.left), node(heavy.key, heavy.value, middle.right, heavy.right));
+	}
+	return node(key, value, left, right);
+};
+/** All left keys precede key, all right keys follow it; heights may differ arbitrarily. */
+const join = (key, value, left, right) => {
+	if (height(left) > height(right) + 1) {
+		profile.collectionIndex.visit();
+		return balance(left.key, left.value, left.left, join(key, value, left.right, right));
+	}
+	if (height(right) > height(left) + 1) {
+		profile.collectionIndex.visit();
+		return balance(right.key, right.value, join(key, value, left, right.left), right.right);
+	}
+	return node(key, value, left, right);
+};
+const removeMin = (current) => {
+	profile.collectionIndex.visit();
 	if (!current.left) return current.right;
-	if (!current.right) return current.left;
-	const next = minNode(current.right);
-	return rebalance(node(next.key, next.value, current.left, removeNode(current.right, next.key)));
+	return balance(current.key, current.value, removeMin(current.left), current.right);
+};
+const concat = (left, right) => {
+	if (!left) return right;
+	if (!right) return left;
+	let first = right;
+	while (first.left) {
+		profile.collectionIndex.visit();
+		first = first.left;
+	}
+	return join(first.key, first.value, left, removeMin(right));
+};
+const replace$1 = (current, entry, left, right) => {
+	if (entry && !entry.present) return concat(left, right);
+	const value = entry ? entry.value : current.value;
+	if (left === current.left && right === current.right && Object.is(value, current.value)) return current;
+	return join(current.key, value, left, right);
+};
+const edit = (current, key, entry) => {
+	if (!current) return entry.present ? node(key, entry.value) : void 0;
+	profile.collectionIndex.visit();
+	if (key === current.key) return replace$1(current, entry, current.left, current.right);
+	if (key < current.key) {
+		const left = edit(current.left, key, entry);
+		return left === current.left ? current : balance(current.key, current.value, left, current.right);
+	}
+	const right = edit(current.right, key, entry);
+	return right === current.right ? current : balance(current.key, current.value, current.left, right);
+};
+/** Builds a new subtree in linear time, ignoring removals of absent keys. */
+const buildChanges = (keys, changes, start, end) => {
+	let count = 0;
+	for (let i = start; i < end; i++) if (changes.get(keys[i]).present) count++;
+	let cursor = start;
+	const build = (size) => {
+		if (!size) return void 0;
+		const leftSize = size >> 1;
+		const left = build(leftSize);
+		let key;
+		let entry;
+		do {
+			key = keys[cursor++];
+			entry = changes.get(key);
+		} while (!entry.present);
+		return node(key, entry.value, left, build(size - leftSize - 1));
+	};
+	return build(count);
+};
+const applyChanges = (current, keys, changes, start, end) => {
+	if (start === end) return current;
+	if (end - start === 1) return edit(current, keys[start], changes.get(keys[start]));
+	if (!current) return buildChanges(keys, changes, start, end);
+	profile.collectionIndex.visit();
+	let low = start;
+	let high = end;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		if (keys[middle] < current.key) low = middle + 1;
+		else high = middle;
+	}
+	const matched = low < end && keys[low] === current.key;
+	const left = applyChanges(current.left, keys, changes, start, low);
+	const right = applyChanges(current.right, keys, changes, matched ? low + 1 : low, end);
+	return replace$1(current, matched ? changes.get(current.key) : void 0, left, right);
 };
 const fromSorted = (entries, start = 0, end = entries.length) => {
 	if (start >= end) return void 0;
-	const middle = start + end >> 1;
+	const middle = start + end >>> 1;
 	const [key, value] = entries[middle];
 	return node(key, value, fromSorted(entries, start, middle), fromSorted(entries, middle + 1, end));
 };
-/** Immutable keyed lookup used to keep published collection snapshots durable across revisions. */
+/** Immutable keyed lookup used to keep collection snapshots durable across revisions. */
 var PersistentKeyedIndex = class PersistentKeyedIndex {
 	constructor(root) {
 		this.root = root;
@@ -3847,6 +3941,7 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 	static empty() {
 		return new PersistentKeyedIndex();
 	}
+	/** The input must contain unique keys. Formal collection order is owned separately. */
 	static from(entries) {
 		const sorted = [...entries].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
 		profile.collectionIndex.build(sorted.length);
@@ -3867,11 +3962,19 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 		}
 		return false;
 	}
-	set(key, value) {
-		return new PersistentKeyedIndex(setNode(this.root, key, value));
-	}
-	remove(key) {
-		return new PersistentKeyedIndex(removeNode(this.root, key));
+	/** Applies accepted final entry intents together; never calls user equality or changes old roots. */
+	apply(changes) {
+		if (!changes.size) return this;
+		profile.collectionIndex.batch(changes.size > 1 ? changes.size : 0);
+		let root;
+		if (changes.size === 1) {
+			const [key, entry] = changes.entries().next().value;
+			root = edit(this.root, key, entry);
+		} else {
+			const keys = [...changes.keys()].sort();
+			root = applyChanges(this.root, keys, changes, 0, keys.length);
+		}
+		return root === this.root ? this : new PersistentKeyedIndex(root);
 	}
 };
 //#endregion
@@ -3909,10 +4012,11 @@ const createCollectionState = (initial) => {
 				values.clear();
 				for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
 				if (index) index = PersistentKeyedIndex.from(values);
-			} else for (const [key, entry] of staged) {
-				if (index) index = entry.present ? index.set(key, entry.value) : index.remove(key);
-				if (entry.present) values.set(key, entry.value);
+			} else {
+				const nextIndex = index?.apply(staged);
+				for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
 				else values.delete(key);
+				index = nextIndex;
 			}
 			ids = nextIds;
 		},
@@ -4138,8 +4242,7 @@ const createCollectionOutput = (binding) => {
 		},
 		observe: (listener) => {
 			binding.check();
-			observers.add(listener);
-			return () => observers.delete(listener);
+			return addListener(observers, listener);
 		},
 		hasConsumers: () => consumers.size > 0,
 		forEachConsumer: (run) => consumers.forEach((_pending, consumer) => run(consumer)),
@@ -4171,8 +4274,7 @@ const createCollectionOutput = (binding) => {
 		},
 		subscribe: (listener) => {
 			binding.check();
-			listeners.add(listener);
-			return () => listeners.delete(listener);
+			return addListener(listeners, listener);
 		}
 	};
 };
@@ -4287,8 +4389,7 @@ const createValueOutput = (binding) => {
 		},
 		observe: (listener) => {
 			binding.check();
-			observers.add(listener);
-			return () => observers.delete(listener);
+			return addListener(observers, listener);
 		},
 		hasConsumers: () => consumers.size > 0,
 		forEachConsumer: (run) => consumers.forEach((_revision, consumer) => run(consumer)),
@@ -4317,8 +4418,7 @@ const createValueOutput = (binding) => {
 		},
 		subscribe: (listener) => {
 			binding.check();
-			listeners.add(listener);
-			return () => listeners.delete(listener);
+			return addListener(listeners, listener);
 		}
 	};
 };
@@ -4522,7 +4622,7 @@ const selectionAffects = (selection, change) => {
 const createDirectReadable = (source) => Object.freeze({
 	current: source.current,
 	revision: source.revision,
-	subscribe: (listener) => source.subscribe(() => listener())
+	subscribe: source.subscribe
 });
 /** Consumer-side selector tracking; it never mutates processor dependencies. */
 const createSelectorReadable = (source, selector, equality = Object.is) => {
@@ -4626,15 +4726,22 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 		},
 		subscribe: (listener) => {
 			ensureCurrent();
-			listeners.add(listener);
-			installSource();
-			return () => {
-				listeners.delete(listener);
-				if (!listeners.size && unsubscribeSource) {
-					unsubscribeSource();
+			const unsubscribe = addListener(listeners, listener, () => {
+				if (!listeners.size) {
+					const stop = unsubscribeSource;
 					unsubscribeSource = void 0;
+					stop?.();
 				}
-			};
+			});
+			try {
+				installSource();
+			} catch (error) {
+				try {
+					unsubscribe();
+				} catch {}
+				throw error;
+			}
+			return unsubscribe;
 		}
 	});
 };
@@ -5932,7 +6039,7 @@ const createSourceRegistry = (scheduler) => {
 //#endregion
 //#region core/src/projection/readable/keyed.ts
 /** Runtime-owned keyed consumer family over one materialized collection output. */
-const createProjectionItems = (source, checkOwner) => {
+const createProjectionItems = (source, checkOwner, checkSubscription) => {
 	if (source.kind !== "collection") throw new TypeError("Projection items require a keyed collection projection.");
 	let disposed = false;
 	const active = /* @__PURE__ */ new Map();
@@ -6061,12 +6168,12 @@ const createProjectionItems = (source, checkOwner) => {
 			subscribe: (listener) => {
 				check();
 				ensureObserved();
-				state.listeners.add(listener);
-				if (!state.tracked && !state.ended) registerWaiting(state);
-				return () => {
-					state.listeners.delete(listener);
+				checkSubscription();
+				const unsubscribe = addListener(state.listeners, listener, () => {
 					if (!state.listeners.size && !state.tracked) unregisterWaiting(state);
-				};
+				});
+				if (!state.tracked && !state.ended) registerWaiting(state);
+				return unsubscribe;
 			}
 		});
 		return state;
@@ -6123,8 +6230,8 @@ const createProjectionItems = (source, checkOwner) => {
 		},
 		subscribe: (listener) => {
 			check();
-			keyListeners.add(listener);
-			return () => keyListeners.delete(listener);
+			checkSubscription();
+			return addListener(keyListeners, listener);
 		}
 	});
 	return {
@@ -6132,6 +6239,7 @@ const createProjectionItems = (source, checkOwner) => {
 			keys,
 			get: (key) => {
 				check();
+				checkSubscription();
 				const current = source.current();
 				if (source.revision() !== settledRevision) pendingKeys.add(key);
 				const canonical = active.get(key);
@@ -6176,6 +6284,7 @@ const createProjectionRuntime = (options) => {
 	const materialized = /* @__PURE__ */ new WeakMap();
 	const publicViews = /* @__PURE__ */ new WeakMap();
 	const scopes = /* @__PURE__ */ new Set();
+	const cleanups = createCleanupStack();
 	const rootItems = /* @__PURE__ */ new Map();
 	const disposeItemControllers = (registry, failures) => {
 		const controllers = [...registry.values()];
@@ -6205,7 +6314,7 @@ const createProjectionRuntime = (options) => {
 		const owner = definition.owner;
 		if (owner === void 0) return;
 		if (owner !== requester) throw new TypeError("Projection belongs to another scope.");
-		if (!requester?.active) throw new ProjectionDisposedError();
+		if (requester?.status === "disposed") throw new ProjectionDisposedError();
 	};
 	const rememberScoped = (definition, requester) => {
 		if (requester && definition.owner === requester) requester.materialized.push(definition);
@@ -6285,25 +6394,33 @@ const createProjectionRuntime = (options) => {
 				assertOutput(output);
 				return output.revision();
 			},
-			subscribe: output.subscribe,
-			observe: output.observe
+			subscribe: (listener) => {
+				scheduler.assertCommand();
+				return output.subscribe(listener);
+			},
+			observe: (listener) => {
+				scheduler.assertCommand();
+				return output.observe(listener);
+			}
 		});
 	};
 	const projectionItems = (projection, requester) => {
+		scheduler.assertCommand();
 		const output = resolveOutput(projection, requester);
 		if (output.kind !== "collection") throw new TypeError("Projection items require a keyed collection projection.");
 		const registry = requester?.items ?? rootItems;
 		const existing = registry.get(output);
 		if (existing) return existing.items;
 		const controller = createProjectionItems(readableSource(projection, requester), () => {
-			if (requester && !requester.active) throw new ProjectionDisposedError();
+			if (requester?.status === "disposed") throw new ProjectionDisposedError();
 			scheduler.ensureCurrent(output);
 			assertOutput(output);
-		});
+		}, scheduler.assertCommand);
 		registry.set(output, controller);
 		return controller.items;
 	};
 	const makeReadable = (projection, selector, equality, requester) => {
+		scheduler.assertCommand();
 		const source = readableSource(projection, requester);
 		return selector ? createSelectorReadable(source, selector, equality) : createDirectReadable(source);
 	};
@@ -6311,8 +6428,8 @@ const createProjectionRuntime = (options) => {
 		return makeReadable(projection, selector, equality);
 	}
 	const inputAccess = (target, requester) => {
-		scheduler.assertIdle();
-		if (requester && !requester.active) throw new ProjectionDisposedError();
+		scheduler.assertCommand();
+		if (requester?.status === "disposed") throw new ProjectionDisposedError();
 		const ref = projectionRef(target);
 		if (ref.output !== 0 || ref.producer.kind !== "source") throw new TypeError("Projection is not an input.");
 		if (ref.producer.source.kind !== "value-input" && ref.producer.source.kind !== "collection-input") throw new TypeError("Projection is not an input.");
@@ -6333,11 +6450,9 @@ const createProjectionRuntime = (options) => {
 		updateInput(target, valueOrRun);
 	}
 	const batch = (run, options) => scheduler.batch(run, options);
-	const disposeScope = (state) => {
-		if (!state.active) return;
-		scheduler.assertIdle();
-		state.active = false;
-		const failures = [];
+	const releaseScope = (state, failures) => {
+		state.status = "disposed";
+		scopes.delete(state);
 		disposeScopeConsumers(state, failures);
 		for (let index = state.materialized.length - 1; index >= 0; index--) {
 			const definition = state.materialized[index];
@@ -6352,24 +6467,38 @@ const createProjectionRuntime = (options) => {
 			}
 		}
 		state.materialized.length = 0;
-		scopes.delete(state);
+	};
+	const disposeScope = (state) => {
+		if (state.status !== "active") return;
+		scheduler.assertCommand();
+		state.status = "closing";
+		const failures = [];
+		try {
+			scheduler.cleanup(() => state.cleanups.drain(failures));
+		} catch (error) {
+			failures.push(error);
+		} finally {
+			scheduler.releaseOwned(() => releaseScope(state, failures));
+		}
 		throwCleanupFailures(failures, "Projection scope cleanup failed.");
 	};
 	const createScope = () => {
-		scheduler.assertIdle();
+		scheduler.assertCommand();
 		const state = {
-			active: true,
+			status: "active",
+			cleanups: createCleanupStack(),
 			materialized: [],
 			subscriptions: /* @__PURE__ */ new Set(),
 			items: /* @__PURE__ */ new Map()
 		};
 		scopes.add(state);
 		const assertActive = () => {
-			if (!state.active) throw new ProjectionDisposedError();
+			if (state.status === "disposed") throw new ProjectionDisposedError();
 			scheduler.assertActive();
 		};
 		function own(target) {
 			assertActive();
+			scheduler.assertCommand();
 			const projections = [];
 			const collect = (value) => {
 				if (isProjection(value)) {
@@ -6439,6 +6568,11 @@ const createProjectionRuntime = (options) => {
 			},
 			update: scopeUpdate,
 			batch: scopeBatch,
+			onDispose: (callback) => {
+				assertActive();
+				scheduler.assertCommand();
+				return state.cleanups.add(callback);
+			},
 			dispose: () => disposeScope(state)
 		});
 	};
@@ -6449,24 +6583,33 @@ const createProjectionRuntime = (options) => {
 		update,
 		batch,
 		scope: createScope,
+		onDispose: (callback) => {
+			scheduler.assertCommand();
+			return cleanups.add(callback);
+		},
 		dispose: () => {
-			if (!scheduler.active) return;
-			scheduler.assertIdle();
+			if (!scheduler.beginClose()) return;
 			const failures = [];
-			for (const scope of scopes) {
-				scope.active = false;
-				disposeScopeConsumers(scope, failures);
-				scope.materialized.length = 0;
-			}
-			scopes.clear();
-			disposeItemControllers(rootItems, failures);
+			const owned = [...scopes].reverse();
+			for (const scope of owned) scope.status = "closing";
 			try {
-				sources.dispose();
+				scheduler.cleanup(() => {
+					for (const scope of owned) scope.cleanups.drain(failures);
+					cleanups.drain(failures);
+				});
 			} catch (error) {
 				failures.push(error);
 			}
 			try {
-				scheduler.dispose();
+				scheduler.dispose(() => {
+					for (const scope of owned) {
+						scope.status = "disposed";
+						scope.materialized.length = 0;
+						disposeScopeConsumers(scope, failures);
+					}
+					scopes.clear();
+					disposeItemControllers(rootItems, failures);
+				}, sources.dispose);
 			} catch (error) {
 				failures.push(error);
 			}

package/dist/local-sync.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_record = require("./record-ChYUi8PP.cjs");
-const require_driver = require("./driver-CN3dGxQI.cjs");
+const require_driver = require("./driver-i4G4iVX0.cjs");
 //#region core/src/local-sync/error.ts
 var LocalSyncError = class extends Error {
 	code;
@@ -467,10 +467,7 @@ const attachLocalSync = async (input) => {
 				revision: () => stateRevision,
 				subscribe: (listener) => {
 					if (disposed) throw new LocalSyncError("disposed", "Local sync has been disposed.");
-					stateListeners.add(listener);
-					return () => {
-						stateListeners.delete(listener);
-					};
+					return require_driver.addListener(stateListeners, listener);
 				}
 			}),
 			flush: async () => {

package/dist/local-sync.d.cts

@@ -1,4 +1,4 @@
-import { W as ObjectSchema, g as Readable, s as DocumentRuntime } from "./contract-CNR6BS75.cjs";
+import { W as ObjectSchema, g as Readable, s as DocumentRuntime } from "./contract-DovG1Yp-.cjs";
 
 //#region core/src/local-sync/json.d.ts
 type JsonPrimitive = null | boolean | number | string;