@mark1russell7/coeval 0.27.2 → 0.29.0

package/build/index.js

@@ -21358,8 +21358,13 @@ function schedule(machine, options = {}) {
 	*/
 	const hostDemand = (id) => {
 		const before = overflowCount();
+		const size = current().values.size;
 		const result = visit(id);
-		return overflowCount() === before && current().walk === void 0 ? result : settle(id, result);
+		if (overflowCount() === before) return current().walk === void 0 ? result : settle(id, result, []);
+		const touched = [];
+		let index = 0;
+		for (const node of current().values.keys()) if (index++ >= size) touched.push(node);
+		return settle(id, result, touched);
 	};
 	/** This function demands one node, with the algorithm of Tarjan over the demands for the cycles of D31. */
 	const visit = (id) => {
@@ -21470,20 +21475,25 @@ function schedule(machine, options = {}) {
 	* Each evaluation enters a new node or finishes a node. Thus the walks of a data epoch do at most `2V` evaluations
 	* for `V` entered nodes. They keep one result and one entry in each list for each such node.
 	*
-	* A walk that reaches no cycle changes nothing, thus a chain keeps its `#DEPTH!`. After a cycle, each entered node
-	* keeps only its error. A node with a value evaluates again at its next demand, because a value can hold the root of
-	* the walk.
+	* After a cycle, each entered node keeps only its error. A result of the overflowed demand depends on the depth of
+	* the stack, thus each such node loses its result too (S2b). A node with a value does not take the value of the walk,
+	* because a value can hold the root of the walk. The schedule demands these nodes again, in the order in which the
+	* walk finished them. Thus each read of such a demand finds a result, and a long chain through lazy reads gives its
+	* value.
 	*
 	* @param id - The node of the demand.
 	* @param given - The result of the demand.
+	* @param touched - The nodes that the overflowed demand gave a result. A demand with no overflow gives none.
 	* @returns The final result of the demand.
 	*/
-	const settle = (id, given) => {
+	const settle = (id, given, touched) => {
 		const epoch = current();
 		const walk = epoch.walk ??= startWalk();
 		const { results } = walk;
-		if (results.has(id) || cache.facts(docs.get(id)).side === "run") return given;
+		if (cache.facts(docs.get(id)).side === "run") return given;
+		if (results.has(id) && touched.length === 0) return given;
 		const entered = [];
+		const finished = [];
 		const starts = [];
 		const enter = (node) => {
 			const mine = count++;
@@ -21516,6 +21526,7 @@ function schedule(machine, options = {}) {
 				const self = looped.delete(node);
 				const onCycle = reached < order.get(node) || close(from) > 1 || self;
 				results.set(node, onCycle ? cycleOf(node) : result);
+				finished.push(node);
 				found ||= onCycle || !result.ok && result.error.code === "#CYCLE!";
 				const reader = stack[stack.length - 1];
 				if (reader !== void 0) lower(reader, reached);
@@ -21527,14 +21538,19 @@ function schedule(machine, options = {}) {
 			looped.clear();
 			close(0);
 		}
-		if (!found) return given;
-		for (const node of entered) {
+		if (!found && touched.length === 0) return given;
+		for (const node of touched) {
+			cache.forget(node);
+			epoch.values.delete(node);
+		}
+		if (found) for (const node of entered) {
 			const result = results.get(node);
 			cache.forget(node);
 			if (result.ok) epoch.values.delete(node);
 			else epoch.values.set(node, result);
 		}
-		return visit(id);
+		for (const node of finished) if (!epoch.values.has(node)) visit(node);
+		return epoch.values.get(id) ?? visit(id);
 	};
 	/** This function gives the record of the derive nodes, for a path that ends at the root `world`. */
 	const record = (get) => {