doxum 0.1.33 → 0.1.35

package/dist/{transform-A9Lx5R2l.js → transform-3mj0eStL.js}

@@ -185,6 +185,12 @@ const readNamedDependencyEntries = (dependencies, label) => {
 };
 /** Creates the durable dependency value exposed to pure derive callbacks. */
 const snapshotDependencyValue = (source) => source.kind === "value" ? source.value : snapshotCollectionView(source.read);
+/** Builds the same readonly named value boundary for scalar and keyed pure computations. */
+const snapshotProjectionValues = (names, sources) => {
+	const values = Object.create(null);
+	for (let index = 0; index < names.length; index++) values[names[index]] = snapshotDependencyValue(sources[index]);
+	return Object.freeze(values);
+};
 /** Compiles the shared named Projection dependency declaration contract. */
 const compileProjectionDependencies = (dependencies, label) => {
 	const names = [];
@@ -261,10 +267,11 @@ const createScheduler = (onError) => {
 	const sources = /* @__PURE__ */ new Set();
 	const processors = /* @__PURE__ */ new Set();
 	const pendingSources = /* @__PURE__ */ new Set();
-	const heap = [];
+	const dirty = /* @__PURE__ */ new Set();
 	const queued = /* @__PURE__ */ new Set();
 	const completed = /* @__PURE__ */ new Set();
 	const emissions = /* @__PURE__ */ new Set();
+	const forced = /* @__PURE__ */ new Set();
 	const errors = [];
 	let reportingFailures = [];
 	const guards = /* @__PURE__ */ new Set();
@@ -276,35 +283,19 @@ const createScheduler = (onError) => {
 		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 markDirty = (producer) => {
+		const pending = [producer];
+		for (let index = 0; index < pending.length; index++) {
+			const current = pending[index];
+			if (current.disposed || dirty.has(current)) continue;
+			dirty.add(current);
+			for (const output of current.outputs) output.forEachConsumer((consumer) => pending.push(consumer));
+		}
+	};
 	const enqueue = (processor) => {
 		if (processor.disposed || queued.has(processor)) return;
 		queued.add(processor);
 		profile.projection("scheduledNodes");
-		let index = heap.length;
-		heap.push(processor);
-		while (index > 0) {
-			const parent = index - 1 >> 1;
-			if (heap[parent].order < processor.order) break;
-			heap[index] = heap[parent];
-			index = parent;
-		}
-		heap[index] = processor;
-	};
-	const pop = () => {
-		const first = heap[0];
-		const last = heap.pop();
-		if (heap.length) {
-			let index = 0;
-			while (index * 2 + 1 < heap.length) {
-				let child = index * 2 + 1;
-				if (child + 1 < heap.length && heap[child + 1].order < heap[child].order) child++;
-				if (last.order < heap[child].order) break;
-				heap[index] = heap[child];
-				index = child;
-			}
-			heap[index] = last;
-		}
-		return first;
 	};
 	const errorFor = (producer, cause, kind = producer.kind === "source" ? "source" : "processor") => new ProjectionError(kind, cause);
 	const capture = (source) => {
@@ -315,6 +306,7 @@ const createScheduler = (onError) => {
 			throw source.fault;
 		}
 		pendingSources.add(source);
+		markDirty(source);
 		profile.projection("sourceEvents");
 		if (source.fault) errors.push(source.fault);
 	};
@@ -325,88 +317,137 @@ const createScheduler = (onError) => {
 			if (cause !== void 0) return cause;
 		}
 	};
-	const settle = () => {
-		if (disposed || depth || phase !== "idle") return;
-		phase = "compute";
-		lock(true);
-		const cause = settleCause();
-		try {
-			for (const source of pendingSources) {
-				if (source.disposed) continue;
-				const wasFaulted = source.fault !== void 0;
-				let changed = false;
-				let force = false;
-				if (!source.fault || source.recovering()) try {
-					const prepared = source.prepare(cause);
-					changed = prepared.changed;
-					force = prepared.force;
-					source.fault = void 0;
-				} catch (failure) {
-					source.fault = errorFor(source, failure, "source");
-					errors.push(source.fault);
-				}
-				const recovered = wasFaulted && !source.fault;
-				if (changed) source.publish();
-				if (source.fault || changed || force || recovered) {
-					const output = source.outputs[0];
-					emissions.add(output);
-					output.forEachConsumer(enqueue);
+	const propagate = (output, force = false) => {
+		emissions.add(output);
+		if (force) forced.add(output);
+		output.forEachConsumer(enqueue);
+	};
+	const advanceSource = (source, cause) => {
+		pendingSources.delete(source);
+		const wasFaulted = source.fault !== void 0;
+		let changed = false;
+		let force = false;
+		if (!source.fault || source.recovering()) try {
+			source.fault = void 0;
+			const prepared = source.prepare(cause);
+			changed = prepared.changed;
+			force = prepared.force;
+			source.fault = void 0;
+		} catch (failure) {
+			source.fault = errorFor(source, failure, "source");
+			errors.push(source.fault);
+		}
+		if (changed || force) source.publish();
+		if (source.fault || changed || force || wasFaulted) propagate(source.outputs[0], force);
+		source.clear();
+	};
+	const advanceProcessor = (processor, cause) => {
+		queued.delete(processor);
+		const wasFaulted = processor.fault !== void 0;
+		profile.projection("processedNodes");
+		let changedOutputs = [];
+		const blocked = processor.dependencies.find((output) => output.owner.fault || output.owner.disposed);
+		if (blocked) processor.fault = errorFor(processor, blocked.owner.fault ?? new ProjectionDisposedError(), "blocked");
+		else {
+			const reset = wasFaulted || processor.dependencies.some((output) => output.reset(processor));
+			try {
+				changedOutputs = processor.evaluate(reset, cause, wasFaulted);
+				const failure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
+				if (failure) throw failure;
+				processor.fault = void 0;
+			} catch (failure) {
+				const error = errorFor(processor, failure);
+				processor.fault = error;
+				if (!reset) try {
+					changedOutputs = processor.evaluate(true, cause, true);
+					const dependencyFailure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
+					if (dependencyFailure) throw dependencyFailure;
+					processor.fault = void 0;
+					errors.push(error);
+				} catch (rebuildFailure) {
+					processor.fault = errorFor(processor, rebuildFailure);
+					errors.push(processor.fault);
 				}
+				else errors.push(error);
 			}
-			while (heap.length) {
-				const processor = pop();
-				if (processor.disposed) continue;
-				const wasFaulted = processor.fault !== void 0;
-				profile.projection("processedNodes");
-				let changedOutputs = Object.freeze([]);
-				const blocked = processor.dependencies.find((output) => output.owner.fault || output.owner.disposed);
-				if (blocked) processor.fault = errorFor(processor, blocked.owner.fault ?? new ProjectionDisposedError(), "blocked");
-				else {
-					const reset = wasFaulted || processor.dependencies.some((output) => output.reset());
-					try {
-						changedOutputs = processor.evaluate(reset, cause, wasFaulted);
-						const dependencyFailure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
-						if (dependencyFailure) throw dependencyFailure;
-						processor.fault = void 0;
-					} catch (failure) {
-						const error = errorFor(processor, failure);
-						processor.fault = error;
-						if (!reset) try {
-							changedOutputs = processor.evaluate(true, cause, true);
-							const dependencyFailure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
-							if (dependencyFailure) throw dependencyFailure;
-							processor.fault = void 0;
-							errors.push(error);
-						} catch (rebuildFailure) {
-							processor.fault = errorFor(processor, rebuildFailure);
-							errors.push(processor.fault);
-						}
-						else errors.push(error);
+		}
+		completed.add(processor);
+		if (processor.fault) processor.outputs.forEach((output) => propagate(output));
+		else {
+			if (changedOutputs.length) processor.publish();
+			(wasFaulted && !processor.fault ? processor.outputs : changedOutputs).forEach((output) => propagate(output));
+		}
+		if (processor.fault || changedOutputs.length) profile.projection("publishedNodes");
+	};
+	const advance = (target, cause) => {
+		const stack = [{
+			producer: target,
+			dependency: 0
+		}];
+		while (stack.length) {
+			const frame = stack[stack.length - 1];
+			const { producer } = frame;
+			if (producer.disposed || !dirty.has(producer)) {
+				dirty.delete(producer);
+				stack.pop();
+				continue;
+			}
+			if (producer.kind === "processor") {
+				let dependency;
+				while (frame.dependency < producer.dependencies.length) {
+					const candidate = producer.dependencies[frame.dependency++].owner;
+					if (dirty.has(candidate)) {
+						dependency = candidate;
+						break;
 					}
 				}
-				completed.add(processor);
-				const recovered = wasFaulted && !processor.fault;
-				if (processor.fault) processor.outputs.forEach((output) => {
-					emissions.add(output);
-					output.forEachConsumer(enqueue);
-				});
-				else {
-					if (changedOutputs.length) {
-						processor.publish();
-						changedOutputs.forEach((output) => emissions.add(output));
-					}
-					(recovered ? processor.outputs : changedOutputs).forEach((output) => output.forEachConsumer(enqueue));
+				if (dependency) {
+					stack.push({
+						producer: dependency,
+						dependency: 0
+					});
+					continue;
 				}
-				if (processor.fault || changedOutputs.length) profile.projection("publishedNodes");
 			}
+			stack.pop();
+			dirty.delete(producer);
+			if (producer.kind === "source") advanceSource(producer, cause);
+			else if (queued.has(producer)) if (producer.fault || producer.dependencies.some((output) => output.owner.fault || output.pending(producer))) advanceProcessor(producer, cause);
+			else {
+				queued.delete(producer);
+				producer.dependencies.forEach((output) => output.acknowledge(producer));
+			}
+		}
+	};
+	const compute = (run) => {
+		phase = "compute";
+		lock(true);
+		try {
+			return run();
 		} finally {
 			lock(false);
 			phase = "idle";
 		}
 	};
+	const settle = () => {
+		if (disposed || depth || phase !== "idle") return;
+		const cause = settleCause();
+		compute(() => {
+			for (const producer of dirty) advance(producer, cause);
+		});
+	};
+	const ensureCurrent = (output) => {
+		assertActive();
+		if (phase === "notify") return;
+		assertIdle();
+		if (dirty.has(output.owner)) {
+			const cause = settleCause();
+			compute(() => advance(output.owner, cause));
+		}
+	};
 	const flush = () => {
 		if (disposed || depth) return [];
-		if (pendingSources.size || completed.size) profile.projection("flushes");
+		if (emissions.size || completed.size) profile.projection("flushes");
 		phase = "notify";
 		lock(true);
 		const reportFailures = [];
@@ -417,7 +458,7 @@ const createScheduler = (onError) => {
 				} catch (cause) {
 					errors.push(errorFor(output.owner, cause, "listener"));
 				}
-			}));
+			}, forced.has(output) || Boolean(output.owner.fault)));
 			for (const error of errors.slice()) try {
 				onError(error);
 			} catch (cause) {
@@ -431,12 +472,13 @@ const createScheduler = (onError) => {
 				error
 			}))]);
 		} finally {
-			pendingSources.forEach((source) => source.clear());
+			emissions.forEach((output) => output.finish());
 			completed.forEach((processor) => processor.clear());
 			pendingSources.clear();
 			queued.clear();
 			completed.clear();
 			emissions.clear();
+			forced.clear();
 			errors.length = 0;
 			reportingFailures = reportFailures;
 			lock(false);
@@ -482,6 +524,7 @@ const createScheduler = (onError) => {
 		assertIdle();
 		if (producer.outputs.some((output) => output.hasConsumers())) throw new Error("Projection producer is still used by another processor.");
 		producer.disposed = true;
+		dirty.delete(producer);
 		if (producer.kind === "processor") {
 			producer.dependencies.forEach((output) => output.detachConsumer(producer));
 			processors.delete(producer);
@@ -510,6 +553,7 @@ const createScheduler = (onError) => {
 		assertIdle,
 		capture,
 		settle,
+		ensureCurrent,
 		flush,
 		run,
 		registerGuard(guard) {
@@ -535,7 +579,7 @@ const createScheduler = (onError) => {
 			processor.dependencies.forEach((output) => output.attachConsumer(processor));
 		},
 		releaseProducer,
-		order: () => sequence++,
+		nextId: () => sequence++,
 		acceptInput(callback) {
 			assertIdle();
 			phase = "input";
@@ -549,14 +593,7 @@ const createScheduler = (onError) => {
 		},
 		initialize(callback) {
 			assertIdle();
-			phase = "compute";
-			lock(true);
-			try {
-				return callback();
-			} finally {
-				lock(false);
-				phase = "idle";
-			}
+			return compute(callback);
 		},
 		batch,
 		batchContext: () => activeBatch,
@@ -584,10 +621,11 @@ const createScheduler = (onError) => {
 			processors.clear();
 			sources.clear();
 			pendingSources.clear();
-			heap.length = 0;
+			dirty.clear();
 			queued.clear();
 			completed.clear();
 			emissions.clear();
+			forced.clear();
 			guards.clear();
 			errors.length = 0;
 			reportingFailures = [];
@@ -921,23 +959,6 @@ const transitionOrderChanged = (before, after, removed, added) => {
 		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({
@@ -961,32 +982,6 @@ const createCollectionChange = (input) => {
 		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;
@@ -1094,6 +1089,6 @@ const createKeyedTransform = (definition) => {
 	return projection;
 };
 //#endregion
-export { isProjection as A, compileProjectionDependencies as C, snapshotCollectionView as D, mapRead as E, producerOf as M, projectionRef as N, defineProcessor as O, profile as P, collectKeyedInvalidation as S, collectionView as T, assertScope as _, collectionChangeTouchesKey as a, ProjectionDisposedError as b, diffCollection as c, createKeyedDependencyRuntime as d, outputKind as f, snapshotArray as g, sameArray as h, collectionChangeIntersects as i, ownProjections as j, defineSource as k, assertKeyedProjection as l, iterableMatchesArray as m, keyedAbsent as n, collectionHasStructuralChange as o, createKeyRelation as p, collectionChange as r, createCollectionChange as s, createKeyedTransform as t, compileKeyedDependencies as u, assertSynchronous as v, snapshotDependencyValue as w, ProjectionError as x, createScheduler as y };
+export { ownProjections as A, snapshotProjectionValues as C, defineProcessor as D, snapshotCollectionView as E, projectionRef as M, profile as N, defineSource as O, compileProjectionDependencies as S, mapRead as T, assertSynchronous as _, collectionChangeTouchesKey as a, ProjectionError as b, assertKeyedProjection as c, outputKind as d, createKeyRelation as f, assertScope as g, snapshotArray as h, collectionChangeIntersects as i, producerOf as j, isProjection as k, compileKeyedDependencies as l, sameArray as m, keyedAbsent as n, collectionHasStructuralChange as o, iterableMatchesArray as p, collectionChange as r, createCollectionChange as s, createKeyedTransform as t, createKeyedDependencyRuntime as u, createScheduler as v, collectionView as w, collectKeyedInvalidation as x, ProjectionDisposedError as y };
 
-//# sourceMappingURL=transform-A9Lx5R2l.js.map
+//# sourceMappingURL=transform-3mj0eStL.js.map