@mark1russell7/coeval 0.26.1 → 0.27.0

package/build/index.js

@@ -2410,7 +2410,7 @@ function checkHidden(m, draft) {
 * - A runner hides the evaluator of its name. Thus one part must give both, or the merge gives a conflict.
 * - The hooks `known` compose in the order of the parts. A hook does not answer for a name that a later part replaces.
 *   The hooks `facts` compose the same way, and the first answer that is not `undefined` wins.
-* - Each other field, for example `permits`, `adopt`, `roots`, `plain` or `maxDepth`, is one value. Two different
+* - Each other field, for example `permits`, `adopt`, `roots`, `plain`, `maxDepth` or `maxWork`, is one value. Two different
 *   values are a conflict. An absent field has no value.
 *
 * A conflict stops the merge, unless the later part names its path in `replaces`. A part can be a function of the
@@ -4325,6 +4325,20 @@ function placeText(place) {
 	}
 	return text;
 }
+/**
+* The most work of one evaluation for a machine without its own `maxWork` (WORK.LIMIT, D134). One application of a
+* closure is one point.
+*/
+const WORK_LIMIT = 2e5;
+/**
+* This function gives the error of the limit of work. Each tier gives this error (WORK.AGREES).
+*
+* @param limit - The limit of the machine.
+* @returns The error.
+*/
+function workFailure(limit) {
+	return fail("#WORK!", `The work of one evaluation is more than ${limit} points. The field maxWork of the machine sets the limit.`).error;
+}
 function selfLabel(self) {
 	try {
 		if (isHostThing(self)) return self.label;
@@ -4458,7 +4472,12 @@ var Session = class {
 	running;
 	traced;
 	perform;
-	signal;
+	/**
+	* The runtime of the root, on the runtime of an equation of a tree (WORK.EQUATION). The runtime of a root holds
+	* itself after the end of its evaluation (WORK.AFTER, WORK.KEEPS), thus the end mark adds no field to the object.
+	* Each runtime has this field, thus a tree and its equations have one object shape.
+	*/
+	top;
 	/**
 	* The record of the reads. Without it, a resolution records nothing. A nested evaluation of an equation of a tree
 	* shares the record of the evaluation around it (READS.EQUATION).
@@ -4480,18 +4499,38 @@ var Session = class {
 	* root scope is made at the first effect or `all`, thus an evaluation without effects makes no scope.
 	*/
 	scope;
-	constructor(machine, epoch, running, traced, perform, signal, effects, reading = void 0) {
+	constructor(machine, epoch, running, traced, perform, top, effects, reading = void 0) {
 		this.machine = machine;
 		this.epoch = epoch;
 		this.running = running;
 		this.traced = traced;
 		this.perform = perform;
-		this.signal = signal;
+		this.top = top;
 		this.reading = reading;
 		this.list = effects;
 		this.holder = traced ? holderNode() : void 0;
 		this.current = this.holder;
 	}
+	/** This getter gives `true` for the runtime of an equation of a tree (WORK.NODE). */
+	get nested() {
+		const top = this.top;
+		return top !== void 0 && top !== this;
+	}
+	/**
+	* This function adds work to the count of the evaluation (WORK.LIMIT). One count is on the runtime of the root, thus
+	* each equation of a tree adds to it. After the end of the evaluation, each entry from the host starts a new count
+	* (WORK.AFTER).
+	*
+	* @param points - The work.
+	* @throws {Failure} The error `#WORK!`, when the count is over the limit of the machine.
+	*/
+	spend(points) {
+		const root = this.top ?? this;
+		const work = (root.top === root && (this.applying ?? 0) === 0 ? 0 : root.work ?? 0) + points;
+		root.work = work;
+		const limit = this.machine.maxWork ?? 2e5;
+		if (work > limit) throw new Failure(workFailure(limit));
+	}
 	/** The effects of the evaluation, in their order. */
 	get effects() {
 		return this.list ??= [];
@@ -5104,6 +5143,7 @@ function compileNode(c, value, place, declared, depth, address = false) {
 		...address ? { address: true } : {}
 	};
 	if (runner !== void 0) {
+		c.keeps = true;
 		let inner;
 		try {
 			inner = isCompiledRunner(runner) ? runner.compileRun(input) : interpretRun(runner, input, split.fill, kind?.caps?.some((rule) => rule.rule === "grant") === true);
@@ -5114,6 +5154,7 @@ function compileNode(c, value, place, declared, depth, address = false) {
 		const run = placedRun(guard === void 0 ? inner : guardRun(inner, guard, c.machine.domains), place, name);
 		return finish$2(c, meta, runnerCode(run, place, kindText), run);
 	}
+	if (!isCompiledEvaluator(evaluator) || evaluator.keeps === true) c.keeps = true;
 	let inner;
 	try {
 		inner = isCompiledEvaluator(evaluator) ? evaluator.compile(input) : interpret(evaluator, input, split.fill);
@@ -5187,6 +5228,8 @@ var Probe = class {
 	running = false;
 	/** `true` after the part asked for something that a fold cannot give. */
 	refused = false;
+	/** A node in a fold costs work, thus a tree stops the fold before it evaluates an equation (WORK.PREPARE). */
+	nested = true;
 	/** The count of the names that the part read. */
 	reads = 0;
 	/**
@@ -5254,6 +5297,11 @@ var Probe = class {
 	keepsContext() {
 		this.refused = true;
 	}
+	/** This function stops the fold at the first point of work, thus `prepare` does no such work (WORK.PREPARE). */
+	spend() {
+		this.refused = true;
+		throw new Failure(workFailure(0));
+	}
 };
 /**
 * This function makes a trap for a root of the context of a fold. Each read of a field calls `refuse`. A trap of the
@@ -5585,8 +5633,8 @@ const RUNTIME = /* @__PURE__ */ Symbol("coeval.runtime");
 /**
 * This function evaluates a plan inside the evaluation of another runtime, for example an equation of a tree inside
 * the evaluation of its tree (READS.EQUATION). The plan gets its own runtime, as in `plan.evaluate`. The reads of the
-* plan go in the record of the reads of `outer`. The context at the root of `outer` tells which reads are free
-* (READS.FREE). Without such a record, the function gives `plan.evaluate(context)`.
+* plan go in the record of the reads of `outer`, and its work goes in the count of `outer` (WORK.EQUATION). The context
+* at the root of `outer` tells which reads are free (READS.FREE). Without a session, the function gives `plan.evaluate(context)`.
 *
 * @param plan - The plan.
 * @param context - The context of the plan.
@@ -5594,11 +5642,10 @@ const RUNTIME = /* @__PURE__ */ Symbol("coeval.runtime");
 * @returns The result.
 */
 function evaluateWithin(plan, context, outer) {
-	const reading = outer instanceof Session ? outer.reading : void 0;
-	if (reading === void 0 || !(plan instanceof CompiledPlan)) return plan.evaluate(context);
+	if (!(outer instanceof Session) || !(plan instanceof CompiledPlan)) return plan.evaluate(context);
 	const machine = plan.machine;
 	const ctx = rootContext(machine, context);
-	return plan.code(ctx, new Session(machine, ctx.caps, false, plan.traced, void 0, void 0, void 0, reading));
+	return plan.code(ctx, new Session(machine, ctx.caps, false, plan.traced, void 0, outer.top ?? outer, void 0, outer.reading));
 }
 function interpret(fn, input, fill) {
 	const { kind, typePath, doc, data, place, machine } = input;
@@ -5761,7 +5808,22 @@ function prepare(machine, doc, options = {}) {
 			run: void 0
 		};
 	}
-	return new CompiledPlan(machine, c.traced, root.code, root.run);
+	return new CompiledPlan(machine, c.traced, c.keeps === true ? endingCode(root.code) : root.code, root.run);
+}
+/**
+* This function gives the code of a plan with a document that can use its runtime after the end of the evaluation. The
+* code marks that end (WORK.KEEPS). Each other plan has no such step, thus the count adds nothing to a read.
+*
+* @param code - The code of the root.
+* @returns The code that marks the end.
+*/
+function endingCode(code) {
+	return (ctx, rt) => {
+		const result = code(ctx, rt);
+		const session = rt;
+		session.top ??= session;
+		return result;
+	};
 }
 /**
 * The object of a plan (PLAN.LEAN). The code of `evaluate` and `run` is on the class, thus a plan keeps only its
@@ -5796,8 +5858,10 @@ var CompiledPlan = class {
 	run(context = makeContext(), runOptions = {}) {
 		const machine = this.machine;
 		const ctx = rootContext(machine, context);
-		const s = new Session(machine, ctx.caps, true, this.traced, runOptions.perform, runOptions.signal, void 0, readingOf(runOptions.reads, ctx));
-		return driveWaiting(this.runCode()(ctx, s), runOptions.signal);
+		const s = new Session(machine, ctx.caps, true, this.traced, runOptions.perform, void 0, void 0, readingOf(runOptions.reads, ctx));
+		return driveWaiting(this.runCode()(ctx, s), runOptions.signal).finally(() => {
+			s.top = s;
+		});
 	}
 };
 /**
@@ -5888,8 +5952,10 @@ async function run(machine, doc, context = makeContext(), options = {}) {
 		...options.verb === void 0 ? {} : { verb: options.verb }
 	});
 	const ctx = rootContext(machine, context);
-	const s = new Session(machine, ctx.caps, true, true, options.perform, options.signal, void 0, readingOf(options.reads, ctx));
-	return record(s, await driveWaiting(plan.runCode()(ctx, s), options.signal));
+	const s = new Session(machine, ctx.caps, true, true, options.perform, void 0, void 0, readingOf(options.reads, ctx));
+	const result = await driveWaiting(plan.runCode()(ctx, s), options.signal);
+	s.top = s;
+	return record(s, result);
 }
 /**
 * This function finds a node of a trace by its path.
@@ -6437,9 +6503,13 @@ function allValues(results) {
 	const errors = results.filter((result) => !result.ok);
 	const first = errors[0];
 	if (first !== void 0 && errors.length === 1) return { error: first };
-	if (errors.length > 1) return { error: fail("#ARGS", `${errors.length} parts failed.`) };
+	if (errors.length > 1) return { error: partsFailed(errors) };
 	return { values: results.map((result) => result.ok ? result.value : null) };
 }
+/** This function gives the error of more than one failed part. */
+function partsFailed(errors) {
+	return errors.find((result) => !result.ok && result.error.code === "#WORK!") ?? fail("#ARGS", `${errors.length} parts failed.`);
+}
 function numbers(values, kind) {
 	const bad = values.findIndex((value) => !isNumber(value));
 	if (bad !== -1) return fail("#VALUE!", `Part ${bad} of ${kind} is not a number.`);
@@ -6919,20 +6989,24 @@ function putField(target, key, value) {
 * This function gives a value with the JSON of each node of a tree in it. A list or a plain record is new only when
 * it holds a node. A container that holds itself stays as it is.
 */
-function plainOf(value, path) {
+function plainOf(value, path, runtime) {
+	if (typeof value !== "object" || value === null) return ok(value);
 	const state = stateOf(value);
+	const open = path.get(value);
 	if (state !== void 0) {
-		if (path.has(value)) return fail("#CYCLE!", `The JSON of the node ${state.type} at [${state.place.join(", ")}] holds the node itself.`);
+		if (open === true) return fail("#CYCLE!", `The JSON of the node ${state.type} at [${state.place.join(", ")}] holds the node itself.`);
+		if (open === false) runtime?.spend?.(1);
 		return state.json(path);
 	}
-	if (typeof value !== "object" || value === null || path.has(value) || isHostThing(value)) return ok(value);
+	if (open === true || isHostThing(value)) return ok(value);
 	if (!Array.isArray(value) && !isRecord(value)) return ok(value);
-	path.add(value);
+	if (open === false) runtime?.spend?.(1);
+	path.set(value, true);
 	try {
 		if (Array.isArray(value)) {
 			let list;
 			for (let index = 0; index < value.length; index += 1) {
-				const item = plainOf(value[index], path);
+				const item = plainOf(value[index], path, runtime);
 				if (!item.ok) return item;
 				if (item.value !== value[index]) (list ??= [...value])[index] = item.value;
 			}
@@ -6941,7 +7015,7 @@ function plainOf(value, path) {
 		const record = value;
 		let out;
 		for (const key of Object.keys(record)) {
-			const item = plainOf(record[key], path);
+			const item = plainOf(record[key], path, runtime);
 			if (!item.ok) return item;
 			if (item.value === record[key]) continue;
 			if (out === void 0) {
@@ -6952,7 +7026,7 @@ function plainOf(value, path) {
 		}
 		return ok(out ?? value);
 	} finally {
-		path.delete(value);
+		path.set(value, false);
 	}
 }
 /**
@@ -7404,19 +7478,19 @@ function treeThing(input, place, build, outer, host) {
 			};
 		},
 		json(path) {
-			path.add(node);
+			path.set(node, true);
 			try {
 				const out = {};
 				for (const part of parts) {
 					const result = read(part.key);
 					if (!result.ok) return result;
-					const value = plainOf(result.value, path);
+					const value = plainOf(result.value, path, runtime);
 					if (!value.ok) return value;
 					putField(out, part.key, value.value);
 				}
 				return ok(out);
 			} finally {
-				path.delete(node);
+				path.set(node, false);
 			}
 		}
 	};
@@ -7439,7 +7513,7 @@ function treeThing(input, place, build, outer, host) {
 			return cell !== void 0 && !cell.busy && cell.result !== void 0;
 		},
 		toJson() {
-			const result = state.json(/* @__PURE__ */ new Set());
+			const result = state.json(/* @__PURE__ */ new Map());
 			if (!result.ok) throw new Failure(result.error);
 			return result.value;
 		}
@@ -7479,6 +7553,8 @@ const NO_HOPS = /* @__PURE__ */ Object.freeze({ hops: false });
 * The argument `host` gives the memo cells of the host (TREE.CELL), or `undefined` for the plain memo of each node.
 */
 function treeNode(input, host) {
+	const runtime = input[RUNTIME];
+	if (runtime?.nested === true) runtime.spend?.(8);
 	const found = input.resolve(SELF_PATH, NO_HOPS);
 	const outer = found.ok ? found.thing : void 0;
 	const above = stateOf(outer);
@@ -7488,7 +7564,7 @@ function treeNode(input, host) {
 	build.open = true;
 	const root = treeThing(input, place, build, outer, host);
 	try {
-		return stateOf(root).json(/* @__PURE__ */ new Set());
+		return stateOf(root).json(/* @__PURE__ */ new Map());
 	} finally {
 		build.open = false;
 	}
@@ -11280,8 +11356,11 @@ function setOwn$2(target, key, value) {
 	});
 	else target[key] = value;
 }
-function compiled(compile) {
-	return { compile };
+function compiled(compile, keeps) {
+	return keeps === void 0 ? { compile } : {
+		compile,
+		keeps
+	};
 }
 /** This function evaluates parts in order. It gives the value of each part, or the first error. */
 function valuesOf(parts, ctx, rt) {
@@ -12009,7 +12088,7 @@ function makeEvaluators(profile) {
 		const evaluator = evaluators[name];
 		const type = Object.hasOwn(types, name) ? types[name] : void 0;
 		const made = Object.freeze(type === void 0 ? evaluator : {
-			compile: evaluator.compile,
+			...evaluator,
 			type
 		});
 		if (truth !== void 0 && TRUTH_READERS.includes(name)) truthByCode.set(made, truth);
@@ -12278,6 +12357,7 @@ function formulaCode(profile) {
 				const closure = (...args) => {
 					const level = (clock.applying ?? 0) + 1;
 					if (level > limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+					rt.spend?.(1);
 					clock.applying = level;
 					try {
 						const scope = { ...ctx.names };
@@ -12295,7 +12375,7 @@ function formulaCode(profile) {
 				Object.defineProperty(closure, CLOSURE$3, { value: { params: names } });
 				return ok(closure);
 			};
-		}),
+		}, true),
 		"formula.call": compiled(({ value }) => {
 			const record = partsOf$1(value);
 			const fnPart = record["fn"];
@@ -13081,22 +13161,35 @@ function* together(env, list, options = {}) {
 * @returns The result.
 */
 function reference(machine, doc, context = makeContext(), options = {}) {
-	return evaluateRoot(machine, doc, context, options, void 0);
+	return evaluateRoot(machine, doc, context, options, void 0, void 0);
 }
 /**
-* This function evaluates a document from its root. An equation of a tree gives the record of its tree. Thus the
-* reads of the equation go in the list of the outer evaluation (REF.READS).
+* This function evaluates a document from its root. An equation of a tree gives the record of its tree and the count
+* of its work. Thus its reads go in the list of the outer evaluation (REF.READS), and its work in the outer count
+* (WORK.EQUATION).
 */
-function evaluateRoot(machine, doc, context, options, outer) {
+function evaluateRoot(machine, doc, context, options, outer, meter) {
 	const at = rootAt(machine, doc, context, options);
-	const env = envOf(machine, options, false, at.ctx, outer);
+	const env = envOf(machine, options, false, at.ctx, outer, meter);
 	try {
 		return within(env, () => evaluateAt(env, at));
 	} catch (error) {
 		return placed(thrown(error, "the reference"), []);
+	} finally {
+		if (!env.nested) env.meter.ended = true;
 	}
 }
 /**
+* WORK.LIMIT: this function adds work to the count of an evaluation. After the end of the evaluation, each entry from
+* the host starts a new count (WORK.AFTER). A count over the limit throws `#WORK!`.
+*/
+function spend(env, points) {
+	const meter = env.meter;
+	if (meter.ended && env.applying === 0) meter.spent = 0;
+	meter.spent += points;
+	if (meter.spent > env.maxWork) throw new Failure(workFailure(env.maxWork));
+}
+/**
 * This function starts a run of a document by the rules, without a compilation (REF.RUN). The host does each effect of a runner,
 * and a step waits when the host waits (RUN.SEQ). `all` settles the waits in the order of the host, or in the order
 * of the journal of a replay (RUN.REPLAY). An effect of an evaluator gives `#CALC!` (RUN.NEEDS-RUNNER). A signal that
@@ -13113,14 +13206,16 @@ function evaluateRoot(machine, doc, context, options, outer) {
 */
 function referenceRun(machine, doc, context = makeContext(), options = {}) {
 	const at = rootAt(machine, doc, context, options);
-	const env = envOf(machine, options, true, at.ctx, void 0);
-	return driveRun(env, stepsAt(env, at), options.signal).catch((error) => placed(thrown(error, "the reference"), []));
+	const env = envOf(machine, options, true, at.ctx, void 0, void 0);
+	return driveRun(env, stepsAt(env, at), options.signal).catch((error) => placed(thrown(error, "the reference"), [])).finally(() => {
+		env.meter.ended = true;
+	});
 }
 /**
 * This function makes the state of the reference for one evaluation or one run. The record of the reads comes from
 * the evaluation around it, or from the list of the options.
 */
-function envOf(machine, options, running, root, outer) {
+function envOf(machine, options, running, root, outer, meter) {
 	const perform = options.perform;
 	return {
 		machine,
@@ -13138,6 +13233,12 @@ function envOf(machine, options, running, root, outer) {
 		},
 		held: 0,
 		applying: 0,
+		maxWork: machine.maxWork ?? 2e5,
+		meter: meter ?? {
+			spent: 0,
+			ended: false
+		},
+		nested: meter !== void 0,
 		reading: outer ?? (options.reads === void 0 ? void 0 : {
 			list: options.reads,
 			root
@@ -13231,7 +13332,7 @@ function equationOf(node, term, names) {
 	return evaluateRoot(env.machine, term, ctx, {
 		definitions: env.definitions,
 		...node.of === void 0 ? {} : { declaredType: node.of }
-	}, env.reading);
+	}, env.reading, env.meter);
 }
 function termIn(table, name) {
 	return table === void 0 || !Object.hasOwn(table, name) ? void 0 : table[name];
@@ -13581,42 +13682,55 @@ function instanceOf$1(node, attr, args) {
 	return result;
 }
 /** TREE.RESULT: the JSON of a node. `open` holds the nodes and the containers whose JSON is in progress. */
-function jsonOfNode(node, self, open) {
-	const record = {};
-	for (const part of node.parts) {
-		const result = attributeOf(node, part.key);
-		if (!result.ok) return result;
-		const value = plainValue(result.value, [...open, self]);
-		if (!value.ok) return value;
-		setField$2(record, part.key, value.value);
+function jsonOfNode(node, self, open, seen) {
+	try {
+		const record = {};
+		for (const part of node.parts) {
+			const result = attributeOf(node, part.key);
+			if (!result.ok) return result;
+			const value = plainValue(node, result.value, [...open, self], seen);
+			if (!value.ok) return value;
+			setField$2(record, part.key, value.value);
+		}
+		return ok(record);
+	} finally {
+		seen.add(self);
 	}
-	return ok(record);
 }
-/** This function gives a copy of a value with the JSON of each node in it. */
-function plainValue(value, open) {
+/**
+* This function gives a copy of a value with the JSON of each node in it. The set `seen` holds each node, list and
+* record that the walk left. A second visit of one of them counts one point on the evaluation of `owner` (WORK.SHARED).
+*/
+function plainValue(owner, value, open, seen) {
 	const node = refNodeOf(value);
 	if (node !== void 0) {
 		if (open.includes(value)) return fail("#CYCLE!", `The JSON of the node ${node.kind} at [${node.place.join(", ")}] holds the node itself.`);
-		return jsonOfNode(node, value, open);
+		if (seen.has(value) && owner.env !== void 0) spend(owner.env, 1);
+		return jsonOfNode(node, value, open, seen);
 	}
 	if (typeof value !== "object" || value === null || isHostThing(value) || open.includes(value)) return ok(value);
-	if (Array.isArray(value)) {
-		const items = [];
-		for (const item of value) {
-			const plain = plainValue(item, [...open, value]);
+	if (!Array.isArray(value) && !isRecord(value)) return ok(value);
+	if (seen.has(value) && owner.env !== void 0) spend(owner.env, 1);
+	try {
+		if (Array.isArray(value)) {
+			const items = [];
+			for (const item of value) {
+				const plain = plainValue(owner, item, [...open, value], seen);
+				if (!plain.ok) return plain;
+				items.push(plain.value);
+			}
+			return ok(items);
+		}
+		const copy = {};
+		for (const key of Object.keys(value)) {
+			const plain = plainValue(owner, value[key], [...open, value], seen);
 			if (!plain.ok) return plain;
-			items.push(plain.value);
+			setField$2(copy, key, plain.value);
 		}
-		return ok(items);
-	}
-	if (!isRecord(value)) return ok(value);
-	const copy = {};
-	for (const key of Object.keys(value)) {
-		const plain = plainValue(value[key], [...open, value]);
-		if (!plain.ok) return plain;
-		setField$2(copy, key, plain.value);
+		return ok(copy);
+	} finally {
+		seen.add(value);
 	}
-	return ok(copy);
 }
 /**
 * TREE.LAZY, TREE.PARENT, TREE.SIBLING and TREE.ERROR: a node of an open tree gives its thing, and the root of a new
@@ -13624,6 +13738,8 @@ function plainValue(value, open) {
 * reads `self` only through `resolve` (C4, TREE.SELF).
 */
 const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolve: walk, doc }) => {
+	const maker = activeEnvs[activeEnvs.length - 1];
+	if (maker?.nested === true) spend(maker, 8);
 	const reached = walk(["self"]);
 	const parent = reached.ok ? reached.thing : void 0;
 	const outer = refNodeOf(parent);
@@ -13659,7 +13775,7 @@ const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolv
 		},
 		has: (key) => key === "parent" || key === "type" || parts.some((part) => part.key === String(key)) || node.values.has(String(key)),
 		toJson: () => {
-			const result = jsonOfNode(node, self, []);
+			const result = jsonOfNode(node, self, [], /* @__PURE__ */ new Set());
 			if (result.ok) return result.value;
 			throw new Failure(result.error);
 		}
@@ -13669,7 +13785,7 @@ const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolv
 	AT_READERS.set(self, (attr, args) => instanceOf$1(node, attr, args));
 	if (nested) return ok(self);
 	try {
-		return jsonOfNode(node, self, []);
+		return jsonOfNode(node, self, [], /* @__PURE__ */ new Set());
 	} finally {
 		node.tree.open = false;
 	}
@@ -13808,11 +13924,17 @@ function formulaDefinitions(profile = {}) {
 		const body = partNamed$1(parts, "body");
 		const clock = activeEnvs[activeEnvs.length - 1] ?? {
 			applying: 0,
-			maxDepth: 1e3
+			maxDepth: 1e3,
+			maxWork: 2e5,
+			meter: {
+				spent: 0,
+				ended: false
+			}
 		};
 		const limit = Math.ceil(clock.maxDepth / 4);
 		const closure = (...args) => {
 			if (clock.applying >= limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+			spend(clock, 1);
 			clock.applying += 1;
 			try {
 				const scope = {};
@@ -22434,6 +22556,6 @@ function samplesAt(values, closed, depth) {
 function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
-export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, GENERATION_LIMIT, Held, JOURNAL, MAX_SYNTAX_ISSUES, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, agreeTypes, argsKey, ask, atArgsOf, atRuleOf, attributeGraph, attributeTrace, attributeVertexId, boundariesOf, capKeys, check, checkCycles, checkLatent, checkStep, checkSteps, checkSyntax, checkWorld, circularOf, classify, codecLaws, collectOf, compilePath, components, compose, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, defineLanguage, derefStep, describe, docEquals, documentKey, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, ifRunner, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapDocs, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partGrants, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, resolveCompiled, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stepper, stepperNext, stepperStart, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, GENERATION_LIMIT, Held, JOURNAL, MAX_SYNTAX_ISSUES, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORK_LIMIT, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, agreeTypes, argsKey, ask, atArgsOf, atRuleOf, attributeGraph, attributeTrace, attributeVertexId, boundariesOf, capKeys, check, checkCycles, checkLatent, checkStep, checkSteps, checkSyntax, checkWorld, circularOf, classify, codecLaws, collectOf, compilePath, components, compose, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, defineLanguage, derefStep, describe, docEquals, documentKey, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, ifRunner, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapDocs, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partGrants, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, resolveCompiled, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stepper, stepperNext, stepperStart, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
 
 //# sourceMappingURL=index.js.map