doxum 0.1.32 → 0.1.33

package/dist/{transform-CENhTaVN.cjs → transform-CSPGdBe5.cjs}

@@ -119,22 +119,40 @@ const mapRead = (value) => {
 /** Immutable map-like view over a CollectionRead. */
 const collectionView = (read, knownIds) => {
 	const ids = knownIds ?? read.ids();
-	const entries = function* () {
-		for (const key of ids) yield [key, read.get(key)];
-	};
-	const values = function* () {
-		for (const key of ids) yield read.get(key);
+	const iterate = (select) => {
+		read.ids();
+		let index = 0;
+		return {
+			next() {
+				read.ids();
+				if (index === ids.length) return {
+					done: true,
+					value: void 0
+				};
+				return {
+					done: false,
+					value: select(ids[index++])
+				};
+			},
+			[Symbol.iterator]() {
+				return this;
+			}
+		};
 	};
+	const entries = () => iterate((key) => [key, read.get(key)]);
+	const values = () => iterate((key) => read.get(key));
 	const view = {
 		get: (key) => read.get(key),
 		has: (key) => read.has(key),
 		get size() {
+			read.ids();
 			return ids.length;
 		},
-		keys: () => ids[Symbol.iterator](),
+		keys: () => iterate((key) => key),
 		values,
 		entries,
 		forEach: (callback, thisArg) => {
+			read.ids();
 			for (const key of ids) callback.call(thisArg, read.get(key), key, view);
 		},
 		[Symbol.iterator]: entries
@@ -183,141 +201,36 @@ const compileProjectionDependencies = (dependencies, label) => {
 	});
 };
 //#endregion
-//#region core/src/value/array.ts
-/** Allocation-free strict equality for ordered readonly arrays. */
-const sameArray = (left, right) => {
-	if (left === right) return true;
-	if (left.length !== right.length) return false;
-	for (let index = 0; index < left.length; index++) if (left[index] !== right[index]) return false;
-	return true;
-};
-/** Owns an immutable shallow snapshot while reusing arrays that are already frozen. */
-const snapshotArray = (values) => Object.isFrozen(values) ? values : Object.freeze([...values]);
-/** Compares an iterable with an ordered array without materializing the iterable. */
-const iterableMatchesArray = (values, expected) => {
-	let index = 0;
-	for (const value of values) {
-		if (index >= expected.length || value !== expected[index]) return false;
-		index++;
-	}
-	return index === expected.length;
-};
-//#endregion
-//#region core/src/projection/collection/change.ts
-const transitionContains = (entries, key) => {
-	for (const entry of entries) if (entry.key === key) return true;
-	return false;
-};
-const transitionSet = (entries) => {
-	if (entries.length <= 4) return void 0;
-	const keys = /* @__PURE__ */ new Set();
-	for (const entry of entries) keys.add(entry.key);
-	return keys;
-};
-const nextExcluding = (iterator, excluded, index) => {
-	while (true) {
-		const next = iterator.next();
-		if (next.done || !(index ? index.has(next.value) : transitionContains(excluded, next.value))) return next;
-	}
-};
-/** Compares common-member order from known transitions without materializing common arrays. */
-const transitionOrderChanged = (before, after, removed, added) => {
-	const removedKeys = transitionSet(removed);
-	const addedKeys = transitionSet(added);
-	const beforeIterator = before[Symbol.iterator]();
-	const afterIterator = after[Symbol.iterator]();
-	while (true) {
-		const left = nextExcluding(beforeIterator, removed, removedKeys);
-		const right = nextExcluding(afterIterator, added, addedKeys);
-		if (left.done || right.done) return left.done !== right.done;
-		if (left.value !== right.value) return true;
-	}
-};
-const nextPresentIn = (iterator, membership) => {
-	while (true) {
-		const next = iterator.next();
-		if (next.done || membership.has(next.value)) return next;
-	}
-};
-/** Compares common-member order between two map snapshots without key snapshots or closures. */
-const mapOrderChanged = (before, after) => {
-	const beforeIterator = before.keys();
-	const afterIterator = after.keys();
-	while (true) {
-		const left = nextPresentIn(beforeIterator, after);
-		const right = nextPresentIn(afterIterator, before);
-		if (left.done || right.done) return left.done !== right.done;
-		if (left.value !== right.value) return true;
+//#region core/src/projection/keyed/invalidation.ts
+/** Shared driver/dependency invalidation policy; owns no revisions or member cache. */
+const collectKeyedInvalidation = (driver, sources, dependencies, reset) => {
+	const changed = dependencies.driverChanged(driver);
+	const change = changed ? driver.change : void 0;
+	if (reset || changed && (!change || change.kind === "reset")) return {
+		rebuild: true,
+		keys: driver.read.ids(),
+		removed: [],
+		structural: true
+	};
+	const dirty = /* @__PURE__ */ new Set();
+	let removed = [];
+	let structural = false;
+	if (change?.kind === "incremental") {
+		removed = change.removed;
+		for (const entry of change.added) dirty.add(entry.key);
+		for (const entry of change.updated) dirty.add(entry.key);
+		structural = Boolean(change.added.length || change.removed.length || change.order);
 	}
-};
-const sealIncrementalChange = (added, updated, removed, order) => {
-	if (!added.length && !updated.length && !removed.length && !order) return void 0;
-	return Object.freeze({
-		kind: "incremental",
-		added: Object.freeze(added),
-		updated: Object.freeze(updated),
-		removed: Object.freeze(removed),
-		...order ? { order: Object.freeze({
-			before: snapshotArray(order.before),
-			after: snapshotArray(order.after)
-		}) } : {}
-	});
-};
-/** Builds the canonical incremental CollectionChange from already-known net transitions. */
-const createCollectionChange = (input) => {
-	let orderChanged = false;
-	if (input.beforeOrder !== input.afterOrder) if (!input.added.length && !input.removed.length) orderChanged = !sameArray(input.beforeOrder, input.afterOrder);
-	else orderChanged = transitionOrderChanged(input.beforeOrder, input.afterOrder, input.removed, input.added);
-	return sealIncrementalChange(input.added, input.updated, input.removed, orderChanged ? {
-		before: input.beforeOrder,
-		after: input.afterOrder
-	} : void 0);
-};
-/** Exact fallback diff between two published map-like snapshots. */
-const diffCollection = (previous, current, isEqual = Object.is) => {
-	const added = [];
-	const updated = [];
-	const removed = [];
-	for (const [key, before] of previous) if (!current.has(key)) removed.push({
-		key,
-		before
-	});
-	else {
-		const after = current.get(key);
-		if (!isEqual(before, after)) updated.push({
-			key,
-			before,
-			after
-		});
+	const all = dependencies.collectInvalidated(sources, dirty);
+	if (!all) {
+		for (const key of dirty) if (!driver.read.has(key)) dirty.delete(key);
 	}
-	for (const [key, after] of current) if (!previous.has(key)) added.push({
-		key,
-		after
-	});
-	return sealIncrementalChange(added, updated, removed, mapOrderChanged(previous, current) ? {
-		before: Object.freeze([...previous.keys()]),
-		after: Object.freeze([...current.keys()])
-	} : void 0);
-};
-const changedKeys = function* (change) {
-	if (change.kind !== "incremental") throw new TypeError("collectionChange.keys requires an incremental CollectionChange.");
-	for (const entry of change.added) yield entry.key;
-	for (const entry of change.updated) yield entry.key;
-	for (const entry of change.removed) yield entry.key;
-};
-const collectionChange = Object.freeze({ keys: changedKeys });
-const collectionHasStructuralChange = (change) => change.kind === "reset" || Boolean(change.added.length || change.removed.length || change.order);
-const collectionChangeTouchesKey = (change, key) => {
-	for (const entry of change.added) if (entry.key === key) return true;
-	for (const entry of change.updated) if (entry.key === key) return true;
-	for (const entry of change.removed) if (entry.key === key) return true;
-	return false;
-};
-const collectionChangeIntersects = (change, keys) => {
-	for (const entry of change.added) if (keys.has(entry.key)) return true;
-	for (const entry of change.updated) if (keys.has(entry.key)) return true;
-	for (const entry of change.removed) if (keys.has(entry.key)) return true;
-	return false;
+	return {
+		rebuild: false,
+		keys: all ? driver.read.ids() : dirty,
+		removed,
+		structural
+	};
 };
 //#endregion
 //#region core/src/projection/contract.ts
@@ -360,7 +273,7 @@ const createScheduler = (onError) => {
 	};
 	const assertIdle = () => {
 		assertActive();
-		if (phase !== "idle") throw new Error("Projection cannot be re-entered during processing or notification.");
+		if (phase !== "idle") throw new Error("Projection cannot be re-entered during input callbacks, processing or notification.");
 	};
 	const lock = (value) => guards.forEach((guard) => guard(value));
 	const enqueue = (processor) => {
@@ -623,6 +536,17 @@ const createScheduler = (onError) => {
 		},
 		releaseProducer,
 		order: () => sequence++,
+		acceptInput(callback) {
+			assertIdle();
+			phase = "input";
+			lock(true);
+			try {
+				return callback();
+			} finally {
+				lock(false);
+				phase = "idle";
+			}
+		},
 		initialize(callback) {
 			assertIdle();
 			phase = "compute";
@@ -678,6 +602,26 @@ const assertScope = (active) => {
 	if (!active()) throw new Error("Projection reader or writer is no longer active.");
 };
 //#endregion
+//#region core/src/value/array.ts
+/** Allocation-free strict equality for ordered readonly arrays. */
+const sameArray = (left, right) => {
+	if (left === right) return true;
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index++) if (left[index] !== right[index]) return false;
+	return true;
+};
+/** Owns an immutable shallow snapshot while reusing arrays that are already frozen. */
+const snapshotArray = (values) => Object.isFrozen(values) ? values : Object.freeze([...values]);
+/** Compares an iterable with an ordered array without materializing the iterable. */
+const iterableMatchesArray = (values, expected) => {
+	let index = 0;
+	for (const value of values) {
+		if (index >= expected.length || value !== expected[index]) return false;
+		index++;
+	}
+	return index === expected.length;
+};
+//#endregion
 //#region core/src/projection/keyed/relation.ts
 /** Runtime-local domain-neutral many-to-many keyed relation. */
 const createKeyRelation = () => {
@@ -906,7 +850,6 @@ const createKeyedDependencyRuntime = (compiled) => {
 			for (const state of states) {
 				const source = sources[state.sourceIndex];
 				if (state.revision === source.revision) continue;
-				state.entry;
 				if (state.kind === "global") {
 					all = true;
 					continue;
@@ -948,6 +891,123 @@ const createKeyedDependencyRuntime = (compiled) => {
 	};
 };
 //#endregion
+//#region core/src/projection/collection/change.ts
+const transitionContains = (entries, key) => {
+	for (const entry of entries) if (entry.key === key) return true;
+	return false;
+};
+const transitionSet = (entries) => {
+	if (entries.length <= 4) return void 0;
+	const keys = /* @__PURE__ */ new Set();
+	for (const entry of entries) keys.add(entry.key);
+	return keys;
+};
+const nextExcluding = (iterator, excluded, index) => {
+	while (true) {
+		const next = iterator.next();
+		if (next.done || !(index ? index.has(next.value) : transitionContains(excluded, next.value))) return next;
+	}
+};
+/** Compares common-member order from known transitions without materializing common arrays. */
+const transitionOrderChanged = (before, after, removed, added) => {
+	const removedKeys = transitionSet(removed);
+	const addedKeys = transitionSet(added);
+	const beforeIterator = before[Symbol.iterator]();
+	const afterIterator = after[Symbol.iterator]();
+	while (true) {
+		const left = nextExcluding(beforeIterator, removed, removedKeys);
+		const right = nextExcluding(afterIterator, added, addedKeys);
+		if (left.done || right.done) return left.done !== right.done;
+		if (left.value !== right.value) return true;
+	}
+};
+const nextPresentIn = (iterator, membership) => {
+	while (true) {
+		const next = iterator.next();
+		if (next.done || membership.has(next.value)) return next;
+	}
+};
+/** Compares common-member order between two map snapshots without key snapshots or closures. */
+const mapOrderChanged = (before, after) => {
+	const beforeIterator = before.keys();
+	const afterIterator = after.keys();
+	while (true) {
+		const left = nextPresentIn(beforeIterator, after);
+		const right = nextPresentIn(afterIterator, before);
+		if (left.done || right.done) return left.done !== right.done;
+		if (left.value !== right.value) return true;
+	}
+};
+const sealIncrementalChange = (added, updated, removed, order) => {
+	if (!added.length && !updated.length && !removed.length && !order) return void 0;
+	return Object.freeze({
+		kind: "incremental",
+		added: Object.freeze(added),
+		updated: Object.freeze(updated),
+		removed: Object.freeze(removed),
+		...order ? { order: Object.freeze({
+			before: snapshotArray(order.before),
+			after: snapshotArray(order.after)
+		}) } : {}
+	});
+};
+/** Builds the canonical incremental CollectionChange from already-known net transitions. */
+const createCollectionChange = (input) => {
+	let orderChanged = false;
+	if (input.beforeOrder !== input.afterOrder) if (!input.added.length && !input.removed.length) orderChanged = !sameArray(input.beforeOrder, input.afterOrder);
+	else orderChanged = transitionOrderChanged(input.beforeOrder, input.afterOrder, input.removed, input.added);
+	return sealIncrementalChange(input.added, input.updated, input.removed, orderChanged ? {
+		before: input.beforeOrder,
+		after: input.afterOrder
+	} : void 0);
+};
+/** Exact fallback diff between two published map-like snapshots. */
+const diffCollection = (previous, current, isEqual = Object.is) => {
+	const added = [];
+	const updated = [];
+	const removed = [];
+	for (const [key, before] of previous) if (!current.has(key)) removed.push({
+		key,
+		before
+	});
+	else {
+		const after = current.get(key);
+		if (!isEqual(before, after)) updated.push({
+			key,
+			before,
+			after
+		});
+	}
+	for (const [key, after] of current) if (!previous.has(key)) added.push({
+		key,
+		after
+	});
+	return sealIncrementalChange(added, updated, removed, mapOrderChanged(previous, current) ? {
+		before: Object.freeze([...previous.keys()]),
+		after: Object.freeze([...current.keys()])
+	} : void 0);
+};
+const changedKeys = function* (change) {
+	if (change.kind !== "incremental") throw new TypeError("collectionChange.keys requires an incremental CollectionChange.");
+	for (const entry of change.added) yield entry.key;
+	for (const entry of change.updated) yield entry.key;
+	for (const entry of change.removed) yield entry.key;
+};
+const collectionChange = Object.freeze({ keys: changedKeys });
+const collectionHasStructuralChange = (change) => change.kind === "reset" || Boolean(change.added.length || change.removed.length || change.order);
+const collectionChangeTouchesKey = (change, key) => {
+	for (const entry of change.added) if (entry.key === key) return true;
+	for (const entry of change.updated) if (entry.key === key) return true;
+	for (const entry of change.removed) if (entry.key === key) return true;
+	return false;
+};
+const collectionChangeIntersects = (change, keys) => {
+	for (const entry of change.added) if (keys.has(entry.key)) return true;
+	for (const entry of change.updated) if (keys.has(entry.key)) return true;
+	for (const entry of change.removed) if (keys.has(entry.key)) return true;
+	return false;
+};
+//#endregion
 //#region core/src/projection/keyed/transform.ts
 const keyedAbsent = Symbol("keyed-transform-absent");
 /** Shared driver-keyed lifecycle for pure and retained keyed transforms. */
@@ -972,7 +1032,8 @@ const createKeyedTransform = (definition) => {
 					const driver = evaluation.sources[0];
 					const output = evaluation.outputs[0];
 					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error(`${definition.name} requires collection input and output.`);
-					dependencies.prepare(evaluation.sources, evaluation.reset);
+					const invalidation = collectKeyedInvalidation(driver, evaluation.sources, dependencies, evaluation.reset);
+					dependencies.prepare(evaluation.sources, invalidation.rebuild);
 					const stateFor = (key, value) => {
 						if (states.has(key)) return states.get(key);
 						const state = definition.state ? definition.state(value, key) : void 0;
@@ -997,49 +1058,29 @@ const createKeyedTransform = (definition) => {
 						else output.output.set(key, next);
 						return beforePresent !== output.next.has(key);
 					};
-					if (evaluation.reset) {
+					if (invalidation.rebuild) {
 						dependencies.clearBindings();
 						const ids = driver.read.ids();
 						for (const key of states.keys()) if (!driver.read.has(key)) states.delete(key);
+						if (!evaluation.reset) {
+							for (const key of output.previous.ids()) if (!driver.read.has(key)) output.output.remove(key);
+						}
 						for (const key of ids) project(key);
 						output.output.order(ids.filter((key) => output.next.has(key)));
 						dependencies.remember(evaluation.sources);
 						return;
 					}
-					const dirty = /* @__PURE__ */ new Set();
-					let all = false;
-					let updateOrder = false;
 					let membershipChanged = false;
-					if (dependencies.driverChanged(driver)) {
-						const change = driver.change;
-						if (!change || change.kind === "reset") {
-							all = true;
-							updateOrder = true;
-							for (const key of output.previous.ids()) {
-								if (driver.read.has(key)) continue;
-								output.output.remove(key);
-								dropState(key);
-								membershipChanged = true;
-							}
-						} else {
-							for (const entry of change.removed) {
-								membershipChanged ||= output.previous.has(entry.key);
-								output.output.remove(entry.key);
-								dropState(entry.key);
-								dirty.delete(entry.key);
-							}
-							for (const entry of change.added) dirty.add(entry.key);
-							for (const entry of change.updated) dirty.add(entry.key);
-							updateOrder = Boolean(change.order);
-						}
+					for (const entry of invalidation.removed) {
+						membershipChanged ||= output.previous.has(entry.key);
+						output.output.remove(entry.key);
+						dropState(entry.key);
 					}
-					all ||= dependencies.collectInvalidated(evaluation.sources, dirty);
-					if (all) for (const key of driver.read.ids()) dirty.add(key);
-					for (const key of dirty) {
+					for (const key of invalidation.keys) {
 						const changedMembership = project(key);
 						membershipChanged ||= changedMembership;
 					}
-					if (updateOrder || membershipChanged) output.output.order(driver.read.ids().filter((key) => output.next.has(key)));
+					if (invalidation.structural || membershipChanged) output.output.order(driver.read.ids().filter((key) => output.next.has(key)));
 					dependencies.remember(evaluation.sources);
 				},
 				release: () => {
@@ -1083,6 +1124,12 @@ Object.defineProperty(exports, "assertSynchronous", {
 		return assertSynchronous;
 	}
 });
+Object.defineProperty(exports, "collectKeyedInvalidation", {
+	enumerable: true,
+	get: function() {
+		return collectKeyedInvalidation;
+	}
+});
 Object.defineProperty(exports, "collectionChange", {
 	enumerable: true,
 	get: function() {
@@ -1252,4 +1299,4 @@ Object.defineProperty(exports, "snapshotDependencyValue", {
 	}
 });
 
-//# sourceMappingURL=transform-CENhTaVN.cjs.map
+//# sourceMappingURL=transform-CSPGdBe5.cjs.map