@mark1russell7/coeval 0.25.0 → 0.26.0

package/build/index.js

@@ -567,7 +567,7 @@ function effectsOfVerb(kind, verb) {
 	return table !== void 0 && Object.hasOwn(table, verb) ? table[verb] : void 0;
 }
 /** The most aliases that one lookup follows (WORLD.ALIAS-LIMIT). */
-const MAX_ALIASES = 32;
+const MAX_ALIASES$1 = 32;
 /** This function tells if two paths of a lookup have the same keys. */
 function samePath(a, b) {
 	if (a.length !== b.length) return false;
@@ -695,7 +695,7 @@ function lookupKind(world, type) {
 			}
 			if (isAlias(entry)) {
 				aliases += 1;
-				if (aliases > MAX_ALIASES) return {
+				if (aliases > MAX_ALIASES$1) return {
 					ok: false,
 					reason: "too-long",
 					path
@@ -1689,7 +1689,7 @@ function itemOf(type, domains) {
 	return form.t === "list" ? form.item : void 0;
 }
 /** This function gives the type of a field of a record type, or `undefined` when the type is not a record with the field. */
-function fieldOf(type, key, domains) {
+function fieldOf$1(type, key, domains) {
 	const form = formOf(type, domains);
 	return form.t === "record" && Object.hasOwn(form.fields, key) ? form.fields[key] : void 0;
 }
@@ -1956,7 +1956,7 @@ function setOwn$5(target, key, value) {
 	});
 	else target[key] = value;
 }
-function own$2(table, key) {
+function own$3(table, key) {
 	return table !== void 0 && Object.hasOwn(table, key) ? table[key] : void 0;
 }
 /** This function gives a copy of a JSON value without the fields whose value is `undefined`, as JSON writes it. */
@@ -2010,7 +2010,7 @@ function sameDomain(a, b) {
 */
 function extendDomain(name, more) {
 	return (prev) => {
-		const found = own$2(prev.domains, name) ?? own$2(STD_DOMAINS, name);
+		const found = own$3(prev.domains, name) ?? own$3(STD_DOMAINS, name);
 		if (typeof found !== "object" || found === null || typeof found.is !== "function") return {};
 		const under = [...found.under ?? []];
 		for (const parent of more.under ?? []) if (parent !== name && !under.includes(parent)) under.push(parent);
@@ -2081,7 +2081,7 @@ var Merger = class {
 */
 function mergeLeaf(m, table, key, later, path, part, replaces, equal, reason) {
 	if (later === void 0) return;
-	const earlier = own$2(table, key);
+	const earlier = own$3(table, key);
 	if (earlier === void 0) {
 		setOwn$5(table, key, later);
 		m.give(path, part);
@@ -2105,7 +2105,7 @@ function mergeEntries(m, into, from, path, part, replaces) {
 		const later = from[key];
 		if (later === void 0) continue;
 		const at = [...path, key];
-		const earlier = own$2(into, key);
+		const earlier = own$3(into, key);
 		if (earlier === void 0) {
 			setOwn$5(into, key, later);
 			m.give(at, part);
@@ -2152,7 +2152,7 @@ function changeKind(table, path, change) {
 		fallback: change(table.fallback)
 	};
 	if (String(first) !== "kinds" || key === void 0) return void 0;
-	const entry = own$2(table.kinds, String(key));
+	const entry = own$3(table.kinds, String(key));
 	const next = rest.length === 0 ? isKind(entry) ? change(entry) : void 0 : isNamespace(entry) ? changeKind(entry, rest, change) : void 0;
 	if (next === void 0) return void 0;
 	const kinds = { ...table.kinds };
@@ -2178,7 +2178,7 @@ function addVerbs(draft, m) {
 		}
 		const next = changeKind(table, entry.kind, (kind) => {
 			const verbs = { ...kind.verbs };
-			const earlier = own$2(verbs, entry.verb);
+			const earlier = own$3(verbs, entry.verb);
 			if (earlier === void 0) m?.give(entry.path, entry.part);
 			else if (entry.replaced) m?.replace(entry.path, entry.part);
 			else if (earlier !== entry.code) m?.clash(entry.path, entry.part, "Two parts give two different evaluators for this verb of this kind.");
@@ -2363,8 +2363,8 @@ function mergeCode(m, draft, part, index, replaces) {
 	if (part.runners !== void 0) draft.runners ??= {};
 	const names = /* @__PURE__ */ new Set([...Object.keys(part.evaluators ?? {}), ...Object.keys(part.runners ?? {})]);
 	for (const name of names) {
-		const evaluator = own$2(part.evaluators, name);
-		const runner = own$2(part.runners, name);
+		const evaluator = own$3(part.evaluators, name);
+		const runner = own$3(part.runners, name);
 		if (evaluator === void 0 && runner === void 0) continue;
 		const evaluatorPath = ["evaluators", name];
 		const runnerPath = ["runners", name];
@@ -2387,9 +2387,9 @@ function checkHidden(m, draft) {
 	const runners = draft.runners ?? {};
 	for (const name of Object.keys(runners)) {
 		const runner = runners[name];
-		const evaluator = own$2(draft.evaluators, name);
+		const evaluator = own$3(draft.evaluators, name);
 		if (runner === void 0 || evaluator === void 0) continue;
-		if (draft.parts.some((part) => own$2(part.evaluators, name) === evaluator && own$2(part.runners, name) === runner)) continue;
+		if (draft.parts.some((part) => own$3(part.evaluators, name) === evaluator && own$3(part.runners, name) === runner)) continue;
 		const a = m.sourceOf(["evaluators", name]);
 		const b = m.sourceOf(["runners", name]);
 		m.conflicts.push({
@@ -2472,7 +2472,7 @@ function removeEntry(entries, path) {
 	const [first, ...rest] = path;
 	if (first === void 0) return entries;
 	const key = String(first);
-	const entry = own$2(entries, key);
+	const entry = own$3(entries, key);
 	if (entry === void 0) return entries;
 	let next;
 	if (rest.length > 0) {
@@ -2578,6 +2578,136 @@ function restrictMachine(machine, paths) {
 		...tables.domains === void 0 ? {} : { domains: tables.domains }
 	};
 }
+// src/language.ts
+const VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+function numbers$1(version) {
+	const found = VERSION.exec(version);
+	if (found === null) throw new TypeError(`A language version has the form MAJOR.MINOR.PATCH. The text ${JSON.stringify(version)} does not.`);
+	return [
+		Number(found[1]),
+		Number(found[2]),
+		Number(found[3])
+	];
+}
+/**
+* This function tells if a version satisfies a lowest version, by the rules of a caret range of SemVer. The first
+* number that is not zero stays the same, and the version is not lower.
+*/
+function compatible(version, lowest) {
+	const have = numbers$1(version);
+	const want = numbers$1(lowest);
+	const stable = want.findIndex((part) => part !== 0);
+	const fixed = stable < 0 ? 3 : stable + 1;
+	for (let index = 0; index < 3; index += 1) {
+		const [a, b] = [have[index], want[index]];
+		if (a !== b) return index >= fixed && a > b;
+	}
+	return true;
+}
+/** This function gives the JSON text of a value with its keys in order. A value that is not JSON is an error. */
+function canonical(value, path) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+	if (typeof value === "number" && Number.isFinite(value)) return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map((item, index) => canonical(item, [...path, index])).join(",")}]`;
+	if (!isRecord(value)) throw new TypeError(`The data half of a language is JSON. The value at ${JSON.stringify(path)} is not.`);
+	return `{${Object.keys(value).filter((key) => value[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key], [...path, key])}`).join(",")}}`;
+}
+function frozen(value) {
+	if (typeof value !== "object" || value === null) return value;
+	for (const item of Object.values(value)) frozen(item);
+	return Object.freeze(value);
+}
+/**
+* This function makes one value of a language. The data half is JSON, thus a host can store it and compare it. The
+* code half binds the evaluator names of the world.
+*
+* The language keeps a frozen copy of its data half, thus a later change to the input changes nothing.
+*
+* @param definition - The name, the version, the world, the needed languages and the code.
+* @returns The language.
+* @throws {TypeError} A version in the definition is not `MAJOR.MINOR.PATCH`, the name is empty, or the
+*   data half is not JSON.
+*/
+function defineLanguage(definition) {
+	if (definition.name === "") throw new TypeError("A language has a name.");
+	numbers$1(definition.version);
+	const requires = definition.requires ?? {};
+	for (const name of Object.keys(requires)) numbers$1(requires[name]);
+	const data = canonical({
+		requires,
+		world: definition.world ?? {}
+	}, []);
+	const copy = frozen(JSON.parse(data));
+	const language = {
+		name: definition.name,
+		version: definition.version,
+		world: copy.world,
+		requires: copy.requires,
+		data
+	};
+	return Object.freeze(definition.code === void 0 ? language : {
+		...language,
+		code: definition.code
+	});
+}
+function partOf(language) {
+	const { code, world } = language;
+	return typeof code === "function" ? (prev) => ({
+		...code(prev),
+		world
+	}) : {
+		...code,
+		world
+	};
+}
+/**
+* This function merges languages into one machine, in the order of the arguments, with `mergeMachines`.
+*
+* - A language comes after each language that it names in `requires`, at a compatible version (LANG.REQUIRES).
+* - One language that comes twice counts once. Thus two languages can share a base.
+* - Two versions of one name, or two data halves under one name and one version, are conflicts (LANG.COMPOSE).
+*
+* @param languages - The languages.
+* @returns The machine.
+* @throws {MergeError} The languages do not fit, or their merge has a conflict. The error lists each conflict.
+*/
+function compose(...languages) {
+	const conflicts = [];
+	const parts = [];
+	const seen = /* @__PURE__ */ new Map();
+	languages.forEach((language, index) => {
+		const earlier = seen.get(language.name);
+		const conflict = (name, other, reason) => {
+			conflicts.push({
+				path: ["languages", name],
+				parts: [Math.min(other, index), Math.max(other, index)],
+				reason
+			});
+		};
+		if (earlier !== void 0) {
+			if (earlier.language.version !== language.version) conflict(language.name, earlier.index, "Two versions of one language.");
+			else if (earlier.language.data !== language.data) conflict(language.name, earlier.index, "Two languages with one name and one version differ.");
+			else if (earlier.language.code !== language.code) parts.push(partOf(language));
+			return;
+		}
+		for (const name of Object.keys(language.requires)) {
+			const needed = language.requires[name];
+			const found = seen.get(name);
+			if (found === void 0) {
+				const later = languages.findIndex((other) => other.name === name);
+				if (later < 0) conflict(name, index, `A language requires ${name}, and the composition does not have it.`);
+				else conflict(name, later, `A language requires ${name}, and ${name} comes after it.`);
+			} else if (!compatible(found.language.version, needed)) conflict(name, found.index, `A language requires ${name} ${needed}, and the composition has ${found.language.version}.`);
+		}
+		seen.set(language.name, {
+			language,
+			index
+		});
+		parts.push(partOf(language));
+	});
+	if (conflicts.length > 0) throw new MergeError(conflicts);
+	return mergeMachines(...parts);
+}
 // src/ladder.ts
 /** The rungs of the ladder, in the order that a question visits them. */
 const RUNGS = [
@@ -3087,7 +3217,7 @@ function context(parts = {}) {
 		caps: parts.caps ?? []
 	};
 }
-const MAX_COLLAPSE = 64;
+const MAX_COLLAPSE$1 = 64;
 /** The reason of a resolution that reaches the bound of collapses without a cycle that it found (DEREF.CHAIN-REASON). It is a plain string, thus a bundle drops it (PKG.PURE). */
 const CHAIN_REASON = "The path follows more than 64 references. One resolution follows at most 64.";
 const NO_HOPS$1 = /* @__PURE__ */ Object.freeze([]);
@@ -3318,7 +3448,7 @@ function resolveFully$1(nav, ctx, path, hops, known) {
 		while (isRef(here)) {
 			if (open?.includes(here) === true) return failed("#CYCLE!", "The references form a cycle.");
 			collapses += 1;
-			if (collapses > MAX_COLLAPSE) return failed("#CYCLE!", CHAIN_REASON);
+			if (collapses > MAX_COLLAPSE$1) return failed("#CYCLE!", CHAIN_REASON);
 			open ??= [];
 			open.push(here);
 			const inner = walk(here.value, void 0);
@@ -3469,7 +3599,7 @@ function tag(value, kind) {
 	return typed(kind, value);
 }
 // src/parts.ts
-var Bad = class {
+var Bad$1 = class {
 	reason;
 	at;
 	constructor(reason, at) {
@@ -3517,7 +3647,7 @@ function kindFault(kinds, item, of, path) {
 	const type = isEnvelope(item) ? typePath(item.type) : of === void 0 ? void 0 : [of];
 	if (type !== void 0 && kinds.some((kind) => kind.length <= type.length && kind.every((key, index) => String(key) === String(type[index])))) return;
 	const names = kinds.map((kind) => kind.join(".")).join(", ");
-	throw new Bad(`${isEnvelope(item) ? `The kind ${typeName(item.type)} is not permitted here.` : "A value without an envelope is not permitted here."} The permitted kinds are ${names}.`, path);
+	throw new Bad$1(`${isEnvelope(item) ? `The kind ${typeName(item.type)} is not permitted here.` : "A value without an envelope is not permitted here."} The permitted kinds are ${names}.`, path);
 }
 /**
 * This function splits a value into its parts, by the shape that its kind declares. The evaluator, the view and
@@ -3583,7 +3713,7 @@ function splitParts(shape, value) {
 		};
 		if (spec.shape === "text" || spec.shape === "number" || spec.shape === "one") {
 			const reason = dataFault(spec, item);
-			if (reason !== void 0) throw new Bad(reason, path);
+			if (reason !== void 0) throw new Bad$1(reason, path);
 			return {
 				t: "data",
 				value: item
@@ -3595,11 +3725,11 @@ function splitParts(shape, value) {
 		}
 		if (spec.shape === "deep") return deep(item, path, spec.of, spec.expect);
 		if (spec.shape === "list") {
-			if (!Array.isArray(item)) throw new Bad("The value must be a list.", path);
+			if (!Array.isArray(item)) throw new Bad$1("The value must be a list.", path);
 			const list = item;
 			if (spec.distinct === true) {
 				const twice = list.findIndex((child, index) => list.slice(0, index).some((before) => docEquals(before, child)));
-				if (twice !== -1) throw new Bad("The items of the list must be different.", [...path, twice]);
+				if (twice !== -1) throw new Bad$1("The items of the list must be different.", [...path, twice]);
 			}
 			const each = spec.item ?? termOf$1(spec.of, spec.expect);
 			const items = list.map((child, index) => walk(each, child, [...path, index]));
@@ -3611,7 +3741,7 @@ function splitParts(shape, value) {
 				items
 			};
 		}
-		if (!isRecord(item)) throw new Bad("The value must be a record.", path);
+		if (!isRecord(item)) throw new Bad$1("The value must be a record.", path);
 		if (spec.shape === "map") {
 			const each = spec.item ?? termOf$1(spec.of, spec.expect);
 			return {
@@ -3619,11 +3749,11 @@ function splitParts(shape, value) {
 				fields: Object.keys(item).map((key) => [key, walk(each, item[key], [...path, key])])
 			};
 		}
-		for (const name of spec.required ?? []) if (!Object.hasOwn(item, name)) throw new Bad(`The field ${name} is missing.`, path);
+		for (const name of spec.required ?? []) if (!Object.hasOwn(item, name)) throw new Bad$1(`The field ${name} is missing.`, path);
 		const named = Array.isArray(spec.fields) ? Object.fromEntries(spec.fields.map((name) => [name, termOf$1(spec.of, spec.expect)])) : spec.fields;
 		const fields = [];
 		for (const key of Object.keys(item)) {
-			if (spec.closed === true && !Object.hasOwn(named, key)) throw new Bad(`The field ${key} is not a field of this kind.`, [...path, key]);
+			if (spec.closed === true && !Object.hasOwn(named, key)) throw new Bad$1(`The field ${key} is not a field of this kind.`, [...path, key]);
 			const fieldShape = Object.hasOwn(named, key) ? named[key] : spec.rest;
 			fields.push([key, walk(fieldShape, item[key], [...path, key])]);
 		}
@@ -3636,7 +3766,7 @@ function splitParts(shape, value) {
 	try {
 		template = walk(shape, value, []);
 	} catch (error) {
-		if (error instanceof Bad) return {
+		if (error instanceof Bad$1) return {
 			ok: false,
 			reason: error.reason,
 			at: error.at
@@ -4557,7 +4687,7 @@ var Session = class {
 		if (this.running) return fail("#CALC!", `The effect ${text} needs a runner: in a run, the host does each effect.`, { place });
 		const frame = frameOf(ctx);
 		const clause = frame === void 0 ? void 0 : this.clauseOf(ctx, frame, kind, place);
-		if (clause !== void 0) return "ok" in clause ? clause : drive$2(clause.answer(payload), text);
+		if (clause !== void 0) return "ok" in clause ? clause : drive$3(clause.answer(payload), text);
 		const made = this.record(ctx, kind, payload, place);
 		return "ok" in made ? made : this.answer(made, place);
 	}
@@ -4768,7 +4898,7 @@ function heldReason(kind) {
 /** The wait of an effect that a run does not give to the host. A drive without a wait stops at it (RUN.HELD). */
 const HELD = /* @__PURE__ */ Promise.resolve(void 0);
 /** This function drives steps that cannot wait. A step that waits stops the steps, and gives `#CALC!`. */
-function drive$2(steps, kindText) {
+function drive$3(steps, kindText) {
 	const step = steps.next();
 	if (step.done === true) return step.value;
 	step.value.catch(() => void 0);
@@ -4817,13 +4947,13 @@ function failing(c, meta, place, code, reason) {
 /** This function gives the code of a document that fails with one result at each evaluation. */
 function failingWith(c, meta, result) {
 	const plain = () => result;
-	return finish$1(c, meta, plain, void 0);
+	return finish$2(c, meta, plain, void 0);
 }
 /**
 * This function gives the code of a document in a trace. Each node records the context that its grant permits
 * (CAP.NARROW-CODE), as the code of the document gets it.
 */
-function finish$1(c, meta, code, steps) {
+function finish$2(c, meta, code, steps) {
 	if (!c.traced) return {
 		code,
 		run: steps
@@ -4981,7 +5111,7 @@ function compileNode(c, value, place, declared, depth, address = false) {
 		}
 		const guard = guardOf(c, place);
 		const run = placedRun(guard === void 0 ? inner : guardRun(inner, guard, c.machine.domains), place, name);
-		return finish$1(c, meta, runnerCode(run, place, kindText), run);
+		return finish$2(c, meta, runnerCode(run, place, kindText), run);
 	}
 	let inner;
 	try {
@@ -4990,7 +5120,7 @@ function compileNode(c, value, place, declared, depth, address = false) {
 		return failingWith(c, meta, placed(thrown(error, `the evaluator ${name}`), place));
 	}
 	const guard = guardOf(c, place);
-	const done = finish$1(c, meta, guard !== void 0 ? placedCode(guardCode(inner, guard, c.machine.domains), place, name) : TOTAL.has(inner) ? inner : placedCode(inner, place, name), void 0);
+	const done = finish$2(c, meta, guard !== void 0 ? placedCode(guardCode(inner, guard, c.machine.domains), place, name) : TOTAL.has(inner) ? inner : placedCode(inner, place, name), void 0);
 	if (frees === void 0 || kind === void 0 || !pureCode(c, envelope, kind, typePath, name, quick)) return done;
 	const free = freeOf(doc, kind, split.parts, frees);
 	if (free === void 0) return done;
@@ -5426,10 +5556,10 @@ function placedRun(inner, place, name) {
 */
 function runnerCode(run, place, kindText) {
 	return (ctx, rt) => {
-		if (!rt.running || !(rt instanceof Session)) return placed(drive$2(run(ctx, rt), kindText), place);
+		if (!rt.running || !(rt instanceof Session)) return placed(drive$3(run(ctx, rt), kindText), place);
 		rt.held += 1;
 		try {
-			return placed(drive$2(run(ctx, rt), kindText), place);
+			return placed(drive$3(run(ctx, rt), kindText), place);
 		} finally {
 			rt.held -= 1;
 		}
@@ -8500,7 +8630,8 @@ function codeFactsOf(machine, v, kind, verb) {
 *
 * - `reads`: each free reference, with the root and the keys of its path. A read under a lazy part has the mark
 *   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`. A kind that
-*   declares `reads` adds a read of each of its roots at each document of the kind. The first document of a tree
+*   declares `reads` adds a read of each of its roots at each document of the kind. A reference with a step document
+*   of the kind also has these reads (FACTS.STEP-READS). The first document of a tree
 *   kind also gets the lazy reads of the equations of its kind (FACTS.EQUATIONS). A read from `self` or from a name
 *   of a rung is not one of them, because it is not free (READS.EQUATION).
 * - `side` and `effects`: from the contract of each kind, for the verb of the facts.
@@ -8547,6 +8678,26 @@ function factsOf(machine, doc, options = {}) {
 		if (options.volatile?.(read) === true) volatile = true;
 	};
 	/**
+	* This function adds a read of each declared root at the place of a document (FACTS.KIND-READS, FACTS.STEP-READS).
+	* It is one function for the facts, thus a visit makes no new function.
+	*/
+	const declare = (list, node, lazy, place) => {
+		if (list === void 0) return;
+		for (const root of list) {
+			if (node !== void 0 && root === "self") continue;
+			add({
+				root,
+				keys: NONE,
+				exact: true,
+				lazy,
+				address: false,
+				path: [root],
+				place: tight(place.place),
+				at: tight(place.at)
+			});
+		}
+	};
+	/**
 	* This function walks a document. Without `node`, it walks the document of the facts. With `node`, it walks an
 	* equation of a tree kind, and each read gets the place of that node: the first document of the kind.
 	*/
@@ -8578,19 +8729,7 @@ function factsOf(machine, doc, options = {}) {
 				note(answer?.pure, answer?.volatile);
 				roots = answer?.reads;
 			}
-			for (const root of roots ?? NONE) {
-				if (node !== void 0 && root === "self") continue;
-				add({
-					root,
-					keys: NONE,
-					exact: true,
-					lazy,
-					address: false,
-					path: [root],
-					place: tight(place.place),
-					at: tight(place.at)
-				});
-			}
+			declare(roots, node, lazy, place);
 			const declared = verb === "eval" && answer?.effects !== void 0 ? effectKeys(v, answer.effects) : declaredEffects(v, verb);
 			if (verb === "eval" ? kind.side === "run" : declared.length > 0) {
 				if (node === void 0) side = "run";
@@ -8635,6 +8774,7 @@ function factsOf(machine, doc, options = {}) {
 				const stepAnswer = walker.name === void 0 ? void 0 : hook?.(found.path, walker.name);
 				if (walker.described) note(stepAnswer?.pure ?? found.kind.pure, stepAnswer?.volatile ?? found.kind.volatile);
 				else note(stepAnswer?.pure, stepAnswer?.volatile);
+				declare(stepAnswer?.reads ?? (walker.described ? found.kind.reads : void 0), node, lazy, place);
 			}
 			const first = path[1];
 			if (root === "names" && isKey(first) && v.names.has(String(first))) return void 0;
@@ -9667,7 +9807,7 @@ function withoutNames(options) {
 	return rest;
 }
 /** This function gives the keys of a trail, from its start. It keeps the result in the trail. */
-function keysOf(trail) {
+function keysOf$1(trail) {
 	if (trail === void 0) return [];
 	if (trail.full !== void 0) return trail.full;
 	const steps = [];
@@ -9726,10 +9866,10 @@ var Visit = class {
 		return this.#expect;
 	}
 	get place() {
-		return keysOf(this.#place);
+		return keysOf$1(this.#place);
 	}
 	get at() {
-		return keysOf(this.#at);
+		return keysOf$1(this.#at);
 	}
 };
 /**
@@ -9766,8 +9906,8 @@ function walk(world, doc, visit, options = {}) {
 		const read = partsOf(world, item.value, item.declared);
 		if (!read.ok) {
 			options.problem?.({
-				place: keysOf(item.place),
-				at: keysOf(item.at),
+				place: keysOf$1(item.place),
+				at: keysOf$1(item.at),
 				code: read.code,
 				reason: read.reason
 			});
@@ -9782,8 +9922,8 @@ function walk(world, doc, visit, options = {}) {
 		};
 		if (!split.ok) {
 			options.problem?.({
-				place: keysOf(item.place),
-				at: keysOf({
+				place: keysOf$1(item.place),
+				at: keysOf$1({
 					up: base,
 					keys: split.at
 				}),
@@ -11094,7 +11234,7 @@ var Held = class {
 		this.error = error;
 	}
 };
-const CLOSURE$2 = /* @__PURE__ */ Symbol.for("coeval.closure");
+const CLOSURE$3 = /* @__PURE__ */ Symbol.for("coeval.closure");
 /**
 * This function tells if a value is a function that the construct `fn` made.
 *
@@ -11102,7 +11242,7 @@ const CLOSURE$2 = /* @__PURE__ */ Symbol.for("coeval.closure");
 * @returns `true` for a closure.
 */
 function isClosure(value) {
-	return typeof value === "function" && value[CLOSURE$2] !== void 0;
+	return typeof value === "function" && value[CLOSURE$3] !== void 0;
 }
 /**
 * The standard extensions: the values that JSON cannot write. `ext.domain` reads a member of a domain through the
@@ -11575,7 +11715,7 @@ function formulaTypes(profile) {
 		},
 		"formula.record": {
 			part: (input, path) => {
-				const want = fieldOf(input.expected, String(path[0]), input.machine.domains);
+				const want = fieldOf$1(input.expected, String(path[0]), input.machine.domains);
 				return want === void 0 ? {} : {
 					expect: want,
 					what: `field ${String(path[0])} of the record`
@@ -11896,6 +12036,7 @@ const PROFILE_KEYS = /* @__PURE__ */ Object.freeze([
 	"combine",
 	"pure",
 	"pureExt",
+	"extReads",
 	"volatile",
 	"sigs"
 ]);
@@ -12150,7 +12291,7 @@ function formulaCode(profile) {
 						clock.applying = level - 1;
 					}
 				};
-				Object.defineProperty(closure, CLOSURE$2, { value: { params: names } });
+				Object.defineProperty(closure, CLOSURE$3, { value: { params: names } });
 				return ok(closure);
 			};
 		}),
@@ -12365,7 +12506,14 @@ function makeFacts(profile, known) {
 		if (code !== "formula.op" && code !== "formula.ext") return void 0;
 		const name = path.slice(1).join(".");
 		if (code === "formula.ext") {
-			if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) return pureExt.has(name) ? PURE : NOT_PURE;
+			if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) {
+				const facts = pureExt.has(name) ? PURE : NOT_PURE;
+				const reads = profile.extReads !== void 0 && Object.hasOwn(profile.extReads, name) ? profile.extReads[name] : void 0;
+				return reads === void 0 ? facts : {
+					...facts,
+					reads
+				};
+			}
 			return Object.hasOwn(STD_EXT, name) ? PURE : void 0;
 		}
 		if (known(path, code) !== true) return void 0;
@@ -12411,7 +12559,7 @@ function formulaMachine(profile = {}, more = {}) {
 	}, more);
 }
 // src/reference.ts
-function own$1(table, name) {
+function own$2(table, name) {
 	return table !== void 0 && Object.hasOwn(table, name) ? table[name] : void 0;
 }
 /**
@@ -12419,16 +12567,16 @@ function own$1(table, name) {
 * evaluator gets the definition of the reference, unless the options give another definition (REF.TREE).
 */
 function choose(env, name) {
-	const runner = own$1(env.machine.runners, name);
+	const runner = own$2(env.machine.runners, name);
 	if (runner !== void 0) {
-		const defined = own$1(env.definitions.runners, name);
+		const defined = own$2(env.definitions.runners, name);
 		if (defined !== void 0) return { runner: defined };
 		return typeof runner === "function" ? { runner } : { gap: `The reference has no definition of the compiled runner ${name}.` };
 	}
-	const evaluator = own$1(env.machine.evaluators, name);
+	const evaluator = own$2(env.machine.evaluators, name);
 	if (evaluator === void 0) return void 0;
-	const standard = evaluator === own$1(STD_EVALUATORS, name) ? own$1(STD_DEFINITIONS.evaluators, name) : void 0;
-	const defined = own$1(env.definitions.evaluators, name) ?? standard;
+	const standard = evaluator === own$2(STD_EVALUATORS, name) ? own$2(STD_DEFINITIONS.evaluators, name) : void 0;
+	const defined = own$2(env.definitions.evaluators, name) ?? standard;
 	if (defined !== void 0) return { evaluator: defined };
 	return typeof evaluator === "function" ? { evaluator } : { gap: `The reference has no definition of the compiled evaluator ${name}.` };
 }
@@ -12592,10 +12740,10 @@ function clauseAt(env, ctx, kind, place) {
 * address (RUN.ADDRESS) and its outcome (RUN.OUTCOME). The mock answers the effect at once (RUN.MOCK). Without a
 * mock, the effect gives its payload (RUN.EVAL).
 */
-function cause(env, ctx, kind, payload, place) {
+function cause$1(env, ctx, kind, payload, place) {
 	const effect = recordEffect(env, ctx, kind, payload, place);
 	if ("ok" in effect) return effect;
-	effect.outcome = answer(env.perform, effect, place);
+	effect.outcome = answer$1(env.perform, effect, place);
 	return effect.outcome;
 }
 /**
@@ -12606,8 +12754,8 @@ function causeFromEvaluator(env, ctx, kind, payload, place) {
 	const text = typeof kind === "string" ? kind : kind.join(".");
 	if (env.running) return fail("#CALC!", `The effect ${text} needs a runner: in a run, the host does each effect.`, { place });
 	const clause = clauseAt(env, ctx, kind, place);
-	if (clause !== void 0) return "ok" in clause ? clause : drive$1(clause.answer(payload), place, text);
-	return cause(env, ctx, kind, payload, place);
+	if (clause !== void 0) return "ok" in clause ? clause : drive$2(clause.answer(payload), place, text);
+	return cause$1(env, ctx, kind, payload, place);
 }
 /**
 * This function causes the effect of a runner. In an evaluation, the mock answers it at once. In a run, the host does
@@ -12617,7 +12765,7 @@ function causeFromEvaluator(env, ctx, kind, payload, place) {
 function* causeAndWait(env, ctx, kind, payload, place) {
 	const clause = clauseAt(env, ctx, kind, place);
 	if (clause !== void 0) return "ok" in clause ? clause : yield* clause.answer(payload);
-	if (!env.running) return cause(env, ctx, kind, payload, place);
+	if (!env.running) return cause$1(env, ctx, kind, payload, place);
 	const effect = recordEffect(env, ctx, kind, payload, place);
 	if ("ok" in effect) return effect;
 	const perform = env.perform;
@@ -12674,7 +12822,7 @@ function hostError(effect, place, error) {
 * This function gives the answer of the mock to an effect. A throw gives `#CALC!` with the cause, and a `Failure`
 * gives its own error value. A promise gives `#CALC!`, because an evaluation does not wait.
 */
-function answer(perform, effect, place) {
+function answer$1(perform, effect, place) {
 	if (perform === void 0) return ok(effect.payload);
 	let given;
 	try {
@@ -12697,10 +12845,10 @@ function evaluateSeen(env, seen, at) {
 	const { place } = at;
 	if ("gap" in chosen) return fail("#NOEVAL", chosen.gap, { place });
 	if ("runner" in chosen) {
-		if (!env.running) return drive$1(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
+		if (!env.running) return drive$2(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
 		env.held += 1;
 		try {
-			return drive$1(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
+			return drive$2(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
 		} finally {
 			env.held -= 1;
 		}
@@ -12727,7 +12875,7 @@ function* runSeen(env, seen, at, runner) {
 	}
 }
 /** This function drives steps that cannot wait. A step that waits gives `#CALC!` at the document (RUN.WAIT). */
-function drive$1(steps, place, kindText) {
+function drive$2(steps, place, kindText) {
 	const step = steps.next();
 	if (step.done === true) return step.value;
 	step.value.catch(() => void 0);
@@ -13439,7 +13587,7 @@ function jsonOfNode(node, self, open) {
 		if (!result.ok) return result;
 		const value = plainValue(result.value, [...open, self]);
 		if (!value.ok) return value;
-		setField$1(record, part.key, value.value);
+		setField$2(record, part.key, value.value);
 	}
 	return ok(record);
 }
@@ -13465,7 +13613,7 @@ function plainValue(value, open) {
 	for (const key of Object.keys(value)) {
 		const plain = plainValue(value[key], [...open, value]);
 		if (!plain.ok) return plain;
-		setField$1(copy, key, plain.value);
+		setField$2(copy, key, plain.value);
 	}
 	return ok(copy);
 }
@@ -13543,9 +13691,9 @@ const STD_DEFINITIONS = { evaluators: {
 	"tree.node": treeDefinition,
 	"ref.resolve": refDefinition
 } };
-const CLOSURE$1 = /* @__PURE__ */ Symbol.for("coeval.closure");
+const CLOSURE$2 = /* @__PURE__ */ Symbol.for("coeval.closure");
 /** This function sets an own field, also the field `__proto__` (SHAPE.PROTO). */
-function setField$1(target, key, value) {
+function setField$2(target, key, value) {
 	Object.defineProperty(target, key, {
 		value,
 		enumerable: true,
@@ -13553,10 +13701,10 @@ function setField$1(target, key, value) {
 		configurable: true
 	});
 }
-function partNamed(parts, key) {
+function partNamed$1(parts, key) {
 	return parts.find((part) => part.path.length === 1 && part.path[0] === key);
 }
-function partsUnder(parts, key) {
+function partsUnder$1(parts, key) {
 	return parts.filter((part) => part.path.length === 2 && part.path[0] === key);
 }
 /**
@@ -13569,7 +13717,7 @@ function partsUnder(parts, key) {
 */
 function formulaDefinitions(profile = {}) {
 	const truthy = profile.truthy ?? ((value) => typeof value === "boolean" ? value : void 0);
-	const opOf = (name) => typeof profile.ops === "function" ? profile.ops(name) : own$1(profile.ops, name);
+	const opOf = (name) => typeof profile.ops === "function" ? profile.ops(name) : own$2(profile.ops, name);
 	const noTruth = (what) => fail("#VALUE!", `The ${what} must give a truth value.`);
 	/** FORMULA.LIST, FORMULA.OPS and FORMULA.COMBINE: the values of parts in order, or the error. */
 	const valuesOf = (parts, skip) => {
@@ -13599,7 +13747,7 @@ function formulaDefinitions(profile = {}) {
 			steps = fill(all.values);
 		}
 		const head = path[0] === "names" && typeof path[1] === "string" ? path[1] : void 0;
-		const bound = head === void 0 ? void 0 : own$1(context.names, head);
+		const bound = head === void 0 ? void 0 : own$2(context.names, head);
 		if (bound instanceof Held) {
 			walk(["names", head]);
 			return {
@@ -13632,7 +13780,7 @@ function formulaDefinitions(profile = {}) {
 		const out = {};
 		parts.forEach((part, index) => {
 			const value = all.values[index];
-			if (value !== SKIP) setField$1(out, String(part.path[0]), value);
+			if (value !== SKIP) setField$2(out, String(part.path[0]), value);
 		});
 		return ok(out);
 	};
@@ -13642,12 +13790,12 @@ function formulaDefinitions(profile = {}) {
 	};
 	const letIn = ({ parts, context }) => {
 		const names = {};
-		for (const key of Object.keys(context.names)) setField$1(names, key, context.names[key]);
-		for (const binding of partsUnder(parts, "bind")) {
+		for (const key of Object.keys(context.names)) setField$2(names, key, context.names[key]);
+		for (const binding of partsUnder$1(parts, "bind")) {
 			const result = binding.evaluate();
-			setField$1(names, String(binding.path[1]), result.ok ? result.value : new Held(result.error));
+			setField$2(names, String(binding.path[1]), result.ok ? result.value : new Held(result.error));
 		}
-		return partNamed(parts, "body").evaluate({
+		return partNamed$1(parts, "body").evaluate({
 			...context,
 			names
 		});
@@ -13656,7 +13804,7 @@ function formulaDefinitions(profile = {}) {
 		const params = isRecord(data) ? data["params"] : void 0;
 		if (!Array.isArray(params) || !params.every((param) => typeof param === "string") || new Set(params).size !== params.length) return fail("#VALUE!", "The params of fn are a list of different texts.");
 		const names = params;
-		const body = partNamed(parts, "body");
+		const body = partNamed$1(parts, "body");
 		const clock = activeEnvs[activeEnvs.length - 1] ?? {
 			applying: 0,
 			maxDepth: 1e3
@@ -13667,8 +13815,8 @@ function formulaDefinitions(profile = {}) {
 			clock.applying += 1;
 			try {
 				const scope = {};
-				for (const key of Object.keys(context.names)) setField$1(scope, key, context.names[key]);
-				names.forEach((name, index) => setField$1(scope, name, args[index]));
+				for (const key of Object.keys(context.names)) setField$2(scope, key, context.names[key]);
+				names.forEach((name, index) => setField$2(scope, name, args[index]));
 				const result = body.evaluate({
 					...context,
 					names: scope
@@ -13679,14 +13827,14 @@ function formulaDefinitions(profile = {}) {
 				clock.applying -= 1;
 			}
 		};
-		Object.defineProperty(closure, CLOSURE$1, { value: { params: names } });
+		Object.defineProperty(closure, CLOSURE$2, { value: { params: names } });
 		return ok(closure);
 	};
 	const call = ({ parts }) => {
-		const target = partNamed(parts, "fn").evaluate();
+		const target = partNamed$1(parts, "fn").evaluate();
 		if (!target.ok) return target;
 		if (typeof target.value !== "function") return fail("#VALUE!", "The fn of call must give a function.");
-		const all = valuesOfStrict(partsUnder(parts, "args"));
+		const all = valuesOfStrict(partsUnder$1(parts, "args"));
 		if (!("values" in all)) return all;
 		try {
 			return ok(target.value(...all.values));
@@ -13695,12 +13843,12 @@ function formulaDefinitions(profile = {}) {
 		}
 	};
 	const choice = ({ parts }) => {
-		const test = partNamed(parts, "test").evaluate();
+		const test = partNamed$1(parts, "test").evaluate();
 		if (!test.ok) return test;
 		const truth = truthy(test.value);
 		if (truth === void 0) return noTruth("test of if");
-		if (truth) return partNamed(parts, "then").evaluate();
-		const other = partNamed(parts, "else");
+		if (truth) return partNamed$1(parts, "then").evaluate();
+		const other = partNamed$1(parts, "else");
 		if (other !== void 0) return other.evaluate();
 		return ok(Object.hasOwn(profile, "otherwise") ? profile.otherwise : null);
 	};
@@ -13718,7 +13866,7 @@ function formulaDefinitions(profile = {}) {
 	};
 	const op = ({ typePath, parts }) => {
 		const name = typePath.slice(1).join(".");
-		const lazy = own$1(profile.lazy, name);
+		const lazy = own$2(profile.lazy, name);
 		if (lazy !== void 0) try {
 			return lazy(parts.map((part) => () => part.evaluate()));
 		} catch (error) {
@@ -13737,7 +13885,7 @@ function formulaDefinitions(profile = {}) {
 	};
 	const ext = ({ typePath, doc, context, machine }) => {
 		const name = typePath.slice(1).join(".");
-		const handler = own$1(profile.ext, name) ?? own$1(STD_EXT, name);
+		const handler = own$2(profile.ext, name) ?? own$2(STD_EXT, name);
 		if (handler === void 0) return fail("#NAME?", `The language has no extension ${name}.`);
 		try {
 			return handler(doc.value, context, machine?.domains);
@@ -13773,6 +13921,1124 @@ function valuesOfStrict(parts) {
 	}
 	return { values };
 }
+// src/stepper.ts
+const CLOSURE_MARK = "coeval.closure";
+const HELD_MARK = "coeval.held";
+const CLOSURE$1 = /* @__PURE__ */ Symbol.for("coeval.closure");
+const MAX_ALIASES = 32;
+const MAX_COLLAPSE = 64;
+const ROOTS$1 = /* @__PURE__ */ Object.freeze([
+	"self",
+	"names",
+	"world",
+	"event",
+	"caps"
+]);
+const NO_KEYS$1 = /* @__PURE__ */ Object.freeze([]);
+function own$1(table, name) {
+	return table !== void 0 && Object.hasOwn(table, name) ? table[name] : void 0;
+}
+function setField$1(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+}
+function closureOf(value) {
+	return isRecord(value) && Object.hasOwn(value, CLOSURE_MARK) ? value[CLOSURE_MARK] : void 0;
+}
+function heldOf(value) {
+	if (value instanceof Held) return value.error;
+	return isRecord(value) && Object.hasOwn(value, HELD_MARK) ? value[HELD_MARK] : void 0;
+}
+/** The judgment 2: K-START and K-COMPUTED. */
+function keysOf(type) {
+	if (typeof type === "string") return [type];
+	if (Array.isArray(type)) return type;
+	const steps = type.value.slice(1);
+	return steps.every(isKey$1) ? steps : void 0;
+}
+/** A key is a text, or a whole number from 0. */
+function isKey$1(step) {
+	return typeof step === "string" || typeof step === "number" && Number.isInteger(step) && step >= 0;
+}
+/** The judgment 2: the lookup of a kind, with the rules K-FALLBACK to K-NOT-A-KIND. */
+function lookup(world, type) {
+	const start = keysOf(type);
+	if (start === void 0) return void 0;
+	let keys = start;
+	let aliases = 0;
+	for (;;) {
+		let entries = world.kinds;
+		let fallback = world.fallback;
+		let followed = false;
+		if (keys.length === 0) return void 0;
+		for (let index = 0; index < keys.length; index += 1) {
+			const key = String(keys[index]);
+			const entry = own$1(entries, key);
+			if (entry === void 0) return fallback === void 0 ? void 0 : {
+				kind: fallback,
+				path: keys
+			};
+			if (isAlias(entry)) {
+				aliases += 1;
+				const target = entry.value.slice(1);
+				if (aliases > MAX_ALIASES || entry.value[0] !== "world" || !target.every(isKey$1)) return void 0;
+				keys = [...target, ...keys.slice(index + 1)];
+				followed = true;
+				break;
+			}
+			if (index === keys.length - 1) return isKind(entry) ? {
+				kind: entry,
+				path: keys
+			} : void 0;
+			if (!isNamespace(entry)) return void 0;
+			entries = entry.kinds;
+			fallback = entry.fallback;
+		}
+		if (!followed) return void 0;
+	}
+}
+/** The result of the ladder for each rung: a name, `null` for L-STOP, or `undefined` for L-NONE. */
+function ladder(world, entries, kind, known, verb, has) {
+	const mine = isRecord(entries) ? own$1(entries, verb) : void 0;
+	if (mine !== void 0 && has(mine)) return mine;
+	if (!known) return null;
+	const named = own$1(kind?.verbs, verb);
+	if (named !== void 0 && has(named)) return named;
+	const fallback = own$1(world.defaults, verb);
+	return fallback !== void 0 && has(fallback) ? fallback : void 0;
+}
+var Bad = class {
+	reason;
+	at;
+	constructor(reason, at) {
+		this.reason = reason;
+		this.at = at;
+	}
+};
+/** The result of the walk for a part: the field is absent from the data (SPLIT-FILL). */
+const PART = /* @__PURE__ */ Symbol("part");
+function isDataShape(shape) {
+	return shape.shape === "none" || shape.shape === "text" || shape.shape === "number" || shape.shape === "one";
+}
+/** SPLIT-DATA: the reason why a value is not a member of a data shape. */
+function notMember(shape, value) {
+	if (shape.shape === "text") return typeof value === "string" ? void 0 : "The value must be a text.";
+	if (shape.shape === "one") return shape.values.some((item) => docEquals(item, value)) ? void 0 : `The value must be one of ${JSON.stringify(shape.values)}.`;
+	if (typeof value !== "number") return "The value must be a number.";
+	if (shape.whole === true && !Number.isInteger(value)) return "The value must be a whole number.";
+	if (shape.min !== void 0 && !(value >= shape.min)) return `The value must be ${String(shape.min)} or more.`;
+	if (shape.max !== void 0 && !(value <= shape.max)) return `The value must be ${String(shape.max)} or less.`;
+}
+function checkKinds(kinds, item, of, path) {
+	const type = isEnvelope(item) ? keysOf(item.type) : of === void 0 ? void 0 : [of];
+	if (type !== void 0 && kinds.some((kind) => kind.length <= type.length && kind.every((key, index) => String(key) === String(type[index])))) return;
+	throw new Bad(`${isEnvelope(item) ? `The kind ${typeName(item.type)} is not permitted here.` : "A value without an envelope is not permitted here."} The permitted kinds are ${kinds.map((kind) => kind.join(".")).join(", ")}.`, path);
+}
+/** The judgment 1: the rules SPLIT-NONE to SPLIT-DEEP. The result holds the parts and the data of SPLIT-FILL. */
+function split(shape, value) {
+	const slots = [];
+	const slot = (item, path, of, address) => {
+		slots.push({
+			path,
+			key: path.join("."),
+			item,
+			...of === void 0 ? {} : { of },
+			...address ? { address: true } : {}
+		});
+		return PART;
+	};
+	const term = (of) => of === void 0 ? { shape: "term" } : {
+		shape: "term",
+		of
+	};
+	const listData = (items) => items.every((item) => item === PART) ? null : items.map((item) => item === PART ? null : item);
+	const deep = (item, path, of) => {
+		if (isEnvelope(item)) return slot(item, path, of, false);
+		const before = slots.length;
+		if (Array.isArray(item)) {
+			const items = item.map((child, index) => deep(child, [...path, index], of));
+			return slots.length === before ? item : listData(items);
+		}
+		if (!isRecord(item)) return item;
+		const out = {};
+		for (const key of Object.keys(item)) {
+			const kept = deep(item[key], [...path, key], of);
+			if (kept !== PART) setField$1(out, key, kept);
+		}
+		return slots.length === before ? item : out;
+	};
+	const walk = (spec, item, path) => {
+		if (spec === void 0 || spec.shape === "none") return item;
+		if (spec.shape === "text" || spec.shape === "number" || spec.shape === "one") {
+			const reason = notMember(spec, item);
+			if (reason !== void 0) throw new Bad(reason, path);
+			return item;
+		}
+		if (spec.shape === "term") {
+			if (spec.kinds !== void 0) checkKinds(spec.kinds, item, spec.of, path);
+			return slot(item, path, spec.of, spec.address === true);
+		}
+		if (spec.shape === "deep") return deep(item, path, spec.of);
+		if (spec.shape === "list") {
+			if (!Array.isArray(item)) throw new Bad("The value must be a list.", path);
+			const list = item;
+			if (spec.distinct === true) {
+				const twice = list.findIndex((child, index) => list.slice(0, index).some((before) => docEquals(before, child)));
+				if (twice !== -1) throw new Bad("The items of the list must be different.", [...path, twice]);
+			}
+			const each = spec.item ?? term(spec.of);
+			const items = list.map((child, index) => walk(each, child, [...path, index]));
+			return isDataShape(each) ? item : listData(items);
+		}
+		if (!isRecord(item)) throw new Bad("The value must be a record.", path);
+		const out = {};
+		const keep = (key, kept) => {
+			if (kept !== PART) setField$1(out, key, kept);
+		};
+		if (spec.shape === "map") {
+			for (const key of Object.keys(item)) keep(key, walk(spec.item ?? term(spec.of), item[key], [...path, key]));
+			return out;
+		}
+		for (const name of spec.required ?? []) if (!Object.hasOwn(item, name)) throw new Bad(`The field ${name} is missing.`, path);
+		for (const key of Object.keys(item)) {
+			const named = Array.isArray(spec.fields) ? spec.fields.includes(key) : Object.hasOwn(spec.fields, key);
+			if (spec.closed === true && !named) throw new Bad(`The field ${key} is not a field of this kind.`, [...path, key]);
+			const fieldShape = !named ? spec.rest : Array.isArray(spec.fields) ? term(spec.of) : spec.fields[key];
+			keep(key, walk(fieldShape, item[key], [...path, key]));
+		}
+		return out;
+	};
+	try {
+		const data = walk(shape, value, []);
+		return {
+			slots,
+			data: data === PART ? null : data
+		};
+	} catch (error) {
+		if (error instanceof Bad) return error;
+		throw error;
+	}
+}
+function copyOf(container) {
+	if (Array.isArray(container)) return [...container];
+	const out = {};
+	for (const key of Object.keys(container)) setField$1(out, key, container[key]);
+	return out;
+}
+/** SPLIT-FILL: the value with the item `i` at the path of the slot `i`. The containers on the way are new. */
+function fillIn(value, slots, items) {
+	const first = slots[0];
+	if (first === void 0) return value;
+	if (first.path.length === 0) return items[0];
+	const root = copyOf(value);
+	const fresh = /* @__PURE__ */ new Set([root]);
+	slots.forEach((part, index) => {
+		let here = root;
+		for (let step = 0; step < part.path.length - 1; step += 1) {
+			const key = part.path[step];
+			let next = here[key];
+			if (!fresh.has(next)) {
+				next = copyOf(next);
+				fresh.add(next);
+				setField$1(here, String(key), next);
+			}
+			here = next;
+		}
+		setField$1(here, String(part.path[part.path.length - 1]), items[index]);
+	});
+	return root;
+}
+/** H-CONTEXT: the capabilities of a rule list for one part. */
+function capsOf(rules, path, caps) {
+	let out = caps;
+	for (const rule of rules ?? []) {
+		if (rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(path, pattern))) continue;
+		if (rule.rule === "mask") return [];
+		if (rule.rule === "only") out = intersectCaps(out, rule.caps);
+	}
+	return out;
+}
+/** H-CONTEXT: the context of a part. */
+function contextOf(site, slot, given) {
+	const parent = site.ctx;
+	const narrow = (context) => context.caps.every((cap) => permits(parent.caps, cap)) ? context : {
+		...context,
+		caps: intersectCaps(parent.caps, context.caps)
+	};
+	const base = given === void 0 || given === parent ? parent : narrow(given);
+	const caps = capsOf(site.rules, slot.path, base.caps);
+	return caps === base.caps ? base : {
+		...base,
+		caps
+	};
+}
+/** H-PLACE: the place of the document on top of the stack. */
+function placeOf$1(stack) {
+	const pieces = [];
+	let base = NO_KEYS$1;
+	for (let index = stack.length - 1; index >= 0; index -= 1) {
+		const frame = stack[index];
+		if (frame.f === "base" || frame.f === "return") {
+			base = frame.place;
+			break;
+		}
+		pieces.push(frame.at);
+	}
+	const out = [...base];
+	for (let index = pieces.length - 1; index >= 0; index -= 1) out.push(...pieces[index]);
+	return out;
+}
+function back(c, result) {
+	return {
+		mode: "resume",
+		result: result.ok || result.error.place !== void 0 ? result : placed(result, placeOf$1(c.stack)),
+		stack: c.stack,
+		applying: c.applying,
+		marked: c.marked
+	};
+}
+function pushed(c, frame) {
+	c.stack.push(frame);
+}
+function popped(c) {
+	c.stack.pop();
+}
+/** H-SEAL: the evaluation of a part, with the frame that waits for it on top of the stack. */
+function enter(c, frame, site, slot, given, marked = c.marked) {
+	frame.at = slot.path;
+	return {
+		mode: "evaluate",
+		value: slot.item,
+		declared: slot.of,
+		depth: site.depth + 1,
+		address: slot.address === true,
+		ctx: contextOf(site, slot, given),
+		stack: c.stack,
+		applying: c.applying,
+		marked
+	};
+}
+function partNamed(slots, key) {
+	return slots.find((slot) => slot.path.length === 1 && slot.path[0] === key);
+}
+function partsUnder(slots, key) {
+	return slots.filter((slot) => slot.path.length === 2 && slot.path[0] === key);
+}
+function truthOf(p, c, value) {
+	const given = forHost(p, c, value);
+	return p.profile.truthy === void 0 ? typeof given === "boolean" ? given : void 0 : p.profile.truthy(given);
+}
+function opOf(p, name) {
+	const { ops } = p.profile;
+	return typeof ops === "function" ? ops(name) : own$1(ops, name);
+}
+function startValues(p, c, site, then, slots, strict, more = {}) {
+	const frame = {
+		f: "values",
+		at: NO_KEYS$1,
+		site,
+		then,
+		slots,
+		strict,
+		next: 1,
+		values: [],
+		errors: [],
+		skipped: [],
+		...more
+	};
+	const first = slots[0];
+	if (first === void 0) return finish$1(p, c, frame);
+	pushed(c, frame);
+	return enter(c, frame, site, first);
+}
+/** F-REF, after the values of the steps. */
+function finishRef(p, c, doc, steps, site, address) {
+	const path = doc.value;
+	const head = path[0] === "names" && typeof path[1] === "string" ? path[1] : void 0;
+	const bound = head === void 0 ? void 0 : heldOf(own$1(site.ctx.names, head));
+	if (bound !== void 0) return back(c, {
+		ok: false,
+		error: bound
+	});
+	const found = walkPath(p, site.ctx, steps);
+	if (!found.ok) return back(c, fail(found.code, found.reason));
+	if (address) return back(c, ok(found.thing));
+	const reached = isHostThing(found.thing) ? found.thing.toJson() : found.thing;
+	const held = heldOf(reached);
+	if (held !== void 0) return back(c, {
+		ok: false,
+		error: held
+	});
+	if (p.profile.missing?.(forHost(p, c, reached)) === true) return back(c, fail("#N/A", "The path reaches no value."));
+	return back(c, ok(reached));
+}
+/** The work of a construct after the values of its parts. */
+function finish$1(p, c, frame) {
+	const { values, slots } = frame;
+	switch (frame.then) {
+		case "list": return back(c, ok(values));
+		case "record": {
+			const out = {};
+			slots.forEach((slot, index) => {
+				if (!frame.skipped.includes(index)) setField$1(out, String(slot.path[0]), values[index]);
+			});
+			return back(c, ok(out));
+		}
+		case "op": {
+			const name = frame.name;
+			try {
+				const out = opOf(p, name)(...forHost(p, c, values));
+				return back(c, p.profile.check?.(out, name) ?? ok(out));
+			} catch (error) {
+				return back(c, thrown(error, `the operation ${name}`));
+			}
+		}
+		case "step": {
+			const doc = frame.doc;
+			return back(c, ok(slots.length === 0 ? doc : {
+				...doc,
+				value: fillIn(doc.value, slots, values)
+			}));
+		}
+		case "ref": {
+			const doc = frame.doc;
+			return finishRef(p, c, doc, fillIn(doc.value, slots, values), frame.site, frame.address === true);
+		}
+		case "args": return apply(p, c, frame.target, values);
+	}
+}
+/** F-CALL and F-FN: an application of a function. */
+function apply(p, c, target, args) {
+	const closure = closureOf(target);
+	if (closure === void 0) try {
+		return back(c, ok(target(...forHost(p, c, args))));
+	} catch (error) {
+		return back(c, thrown(error, "the function of call"));
+	}
+	const limit = Math.ceil(p.maxDepth / 4);
+	if (c.applying >= limit) return back(c, fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`));
+	pushed(c, {
+		f: "return",
+		place: closure.place.concat(closure.body.path)
+	});
+	return {
+		...enter(c, { at: NO_KEYS$1 }, closure.site, closure.body, scopeOf(closure, args)),
+		applying: c.applying + 1
+	};
+}
+function scopeOf(closure, args) {
+	const { ctx } = closure.site;
+	const scope = {};
+	for (const key of Object.keys(ctx.names)) setField$1(scope, key, ctx.names[key]);
+	closure.params.forEach((name, index) => setField$1(scope, name, args[index]));
+	return {
+		...ctx,
+		names: scope
+	};
+}
+/** This function makes the host function of a closure. A host calls it, thus it runs a nested stepper. */
+function hostClosure(p, value, closure) {
+	const known = p.hosts.get(value);
+	if (known !== void 0) return known;
+	const fn = (...args) => {
+		const limit = Math.ceil(p.maxDepth / 4);
+		if (p.applying >= limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+		p.applying += 1;
+		try {
+			const place = closure.place.concat(closure.body.path);
+			const end = drive$1(p, enter({
+				mode: "resume",
+				result: ok(null),
+				stack: [{
+					f: "base",
+					place
+				}],
+				applying: p.applying,
+				marked: true
+			}, { at: NO_KEYS$1 }, closure.site, closure.body, scopeOf(closure, args)));
+			if (!end.result.ok) throw new Failure(end.result.error);
+			return forHost(p, end, end.result.value);
+		} finally {
+			p.applying -= 1;
+		}
+	};
+	Object.defineProperty(fn, CLOSURE$1, { value: { params: closure.params } });
+	p.hosts.set(value, fn);
+	return fn;
+}
+/** This function gives a value to host code: a closure is a function, and a held error is a `Held`. */
+function forHost(p, c, value) {
+	p.applying = c.applying;
+	return c.marked ? hostValue(p, value) : value;
+}
+function hostValue(p, value) {
+	if (Array.isArray(value)) {
+		const items = value.map((item) => hostValue(p, item));
+		return items.some((item, index) => item !== value[index]) ? items : value;
+	}
+	if (!isRecord(value)) return value;
+	const closure = closureOf(value);
+	if (closure !== void 0) return hostClosure(p, value, closure);
+	const held = heldOf(value);
+	if (held !== void 0) return new Held(held);
+	let out;
+	for (const key of Object.keys(value)) {
+		const item = hostValue(p, value[key]);
+		if (item !== value[key]) {
+			out ??= copyOf(value);
+			setField$1(out, key, item);
+		}
+	}
+	return out ?? value;
+}
+function hostContext(p, c, ctx) {
+	const names = forHost(p, c, ctx.names);
+	return names === ctx.names ? ctx : {
+		...ctx,
+		names
+	};
+}
+/** The judgment 3: the steps of a path, with R-NO-ROOT to C-DONE. A failure holds a code and a reason. */
+function walkPath(p, ctx, path) {
+	const { machine } = p;
+	const adopt = machine.adopt ?? ((value) => value);
+	const failed = (code, reason) => ({
+		ok: false,
+		code,
+		reason,
+		hops: []
+	});
+	const open = [];
+	let collapses = 0;
+	const collapse = (thing) => {
+		let here = thing;
+		if (machine.plain === true) return {
+			ok: true,
+			thing: here,
+			hops: []
+		};
+		while (isReference(here)) {
+			if (open.includes(here)) return failed("#CYCLE!", "The references form a cycle.");
+			collapses += 1;
+			if (collapses > MAX_COLLAPSE) return failed("#CYCLE!", "The path follows more than 64 references. One resolution follows at most 64.");
+			open.push(here);
+			const inner = walk(here.value);
+			open.pop();
+			if (!inner.ok) return inner;
+			here = adopt(inner.thing);
+		}
+		return {
+			ok: true,
+			thing: here,
+			hops: []
+		};
+	};
+	const walk = (steps) => {
+		const root = steps[0];
+		if (typeof root !== "string" || !ROOTS$1.includes(root)) return failed("#REF!", `A path starts with a root: ${ROOTS$1.join(", ")}.`);
+		if (machine.roots !== void 0 && !machine.roots.includes(root)) return failed("#REF!", `The root ${root} is not open here. The open roots are ${machine.roots.join(", ")}.`);
+		const first = collapse(adopt(ctx[root]));
+		if (!first.ok) return first;
+		let here = first.thing;
+		for (let index = 1; index < steps.length; index += 1) {
+			const step = steps[index];
+			const rest = steps.slice(index);
+			if (isHostThing(here) && here.resolve !== void 0 && rest.every(isKey$1)) {
+				const reached = here.resolve(rest);
+				if (reached === void 0) return failed("#N/A", `The path ${rest.join(".")} reaches nothing.`);
+				return collapse(adopt(reached.thing));
+			}
+			const hop = isKey$1(step) ? keyStep(p, here, step) : void 0;
+			if (isKey$1(step)) {
+				if (hop === void 0) {
+					if (root === "names" && index === 1) return failed("#NAME?", `The context has no name ${String(step)}.`);
+					return failed("#N/A", `The step ${String(step)} reaches nothing.`);
+				}
+				here = adopt(hop.thing);
+			} else {
+				const walker = walkerFor(p, step);
+				if (walker === void 0) return failed("#STEP?", "A step is a key, or a document of a kind with the verb step.");
+				const deref = (thing, key) => {
+					const reached = keyStep(p, thing, key);
+					return reached === void 0 ? void 0 : adopt(reached.thing);
+				};
+				const has = (thing, key) => keyStep(p, thing, key) !== void 0;
+				const result = walker({
+					data: step.value,
+					here,
+					context: ctx,
+					deref,
+					has
+				});
+				if (!result.ok) return failed(result.code ?? "#N/A", result.reason);
+				here = adopt(result.thing);
+			}
+			const next = collapse(here);
+			if (!next.ok) return next;
+			here = next.thing;
+		}
+		return {
+			ok: true,
+			thing: here,
+			hops: []
+		};
+	};
+	return path.length === 0 ? failed("#REF!", "A path has at least one step: its root.") : walk(path);
+}
+function isReference(thing) {
+	if (!isEnvelope(thing) || !Array.isArray(thing.value)) return false;
+	const keys = keysOf(thing.type);
+	return keys !== void 0 && keys.length === 1 && keys[0] === "ref";
+}
+/** R-WALKER: the code of a step document. */
+function walkerFor(p, step) {
+	const { walkers, world } = p.machine;
+	if (walkers === void 0 || !isEnvelope(step)) return void 0;
+	const found = lookup(world, step.type);
+	const name = ladder(world, field(step, "own"), found?.kind, found !== void 0, "step", (item) => own$1(walkers, item) !== void 0);
+	return typeof name === "string" ? own$1(walkers, name) : void 0;
+}
+/** FIELD: the rule of a step in a value. */
+function fieldOf(value, key) {
+	if (Array.isArray(value)) {
+		if (key === "length") return { thing: value.length };
+		const index = typeof key === "number" ? key : /^\d+$/.test(key) ? Number(key) : -1;
+		return index >= 0 && index < value.length ? { thing: value[index] } : void 0;
+	}
+	if (typeof value !== "object" || value === null || !Object.hasOwn(value, String(key))) return void 0;
+	return { thing: value[String(key)] };
+}
+/** The rules S-HOST to S-FIELD: a step with a key. The result is `undefined` for `miss`. */
+function keyStep(p, thing, key) {
+	const { machine } = p;
+	if (isHostThing(thing)) {
+		const reached = thing.deref(key);
+		return reached !== void 0 || thing.has?.(key) === true ? { thing: reached } : void 0;
+	}
+	if (machine.plain === true || !isEnvelope(thing)) return fieldOf(thing, key);
+	const { derefs, world } = machine;
+	const found = lookup(world, thing.type);
+	const name = derefs === void 0 ? void 0 : ladder(world, field(thing, "own"), found?.kind, found !== void 0, "deref", (item) => own$1(derefs, item) !== void 0);
+	const code = typeof name === "string" ? own$1(derefs, name) : void 0;
+	if (code === void 0) return fieldOf(thing.value, key);
+	const reached = code(thing, key);
+	return reached !== void 0 || code.has?.(thing, key) === true ? { thing: reached } : void 0;
+}
+/** A construct of the formula kit, with its compiled evaluator in the machine. */
+const CONSTRUCTS$2 = {
+	"formula.lit": true,
+	"formula.ref": true,
+	"formula.step": true,
+	"formula.record": true,
+	"formula.list": true,
+	"formula.let": true,
+	"formula.fn": true,
+	"formula.call": true,
+	"formula.if": true,
+	"formula.and": true,
+	"formula.or": true,
+	"formula.op": true,
+	"formula.ext": true
+};
+/** The rules F-LIT to F-EXT: the start of a construct. */
+function construct(p, c, name, doc, keys, slots, site) {
+	const { profile, machine } = p;
+	switch (name) {
+		case "formula.lit": return back(c, ok(doc.value));
+		case "formula.ref": {
+			const path = doc.value;
+			if (!Array.isArray(path) || path.length === 0) return back(c, fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"]."));
+			if (slots.length === 0) return finishRef(p, c, doc, path, site, c.address);
+			return startValues(p, c, site, "ref", slots, true, {
+				doc,
+				address: c.address
+			});
+		}
+		case "formula.step": return startValues(p, c, site, "step", slots, true, { doc });
+		case "formula.record": return startValues(p, c, site, "record", slots, false);
+		case "formula.list": return startValues(p, c, site, "list", slots, false);
+		case "formula.let": {
+			const bindings = partsUnder(slots, "bind");
+			const body = partNamed(slots, "body");
+			const names = {};
+			for (const key of Object.keys(site.ctx.names)) setField$1(names, key, site.ctx.names[key]);
+			const first = bindings[0];
+			if (first === void 0) {
+				const tail = {
+					f: "tail",
+					at: NO_KEYS$1
+				};
+				pushed(c, tail);
+				return enter(c, tail, site, body, {
+					...site.ctx,
+					names
+				});
+			}
+			const frame = {
+				f: "let",
+				at: NO_KEYS$1,
+				site,
+				slots: bindings,
+				body,
+				next: 1,
+				names
+			};
+			pushed(c, frame);
+			return enter(c, frame, site, first);
+		}
+		case "formula.fn": {
+			const params = isRecord(doc.value) ? doc.value["params"] : void 0;
+			if (!Array.isArray(params) || !params.every((item) => typeof item === "string") || new Set(params).size !== params.length) return back(c, fail("#VALUE!", "The params of fn are a list of different texts."));
+			const closure = {
+				params,
+				body: partNamed(slots, "body"),
+				site,
+				place: placeOf$1(c.stack)
+			};
+			return back({
+				...c,
+				marked: true
+			}, ok({ [CLOSURE_MARK]: closure }));
+		}
+		case "formula.call": {
+			const frame = {
+				f: "call",
+				at: NO_KEYS$1,
+				site,
+				args: partsUnder(slots, "args")
+			};
+			pushed(c, frame);
+			return enter(c, frame, site, partNamed(slots, "fn"));
+		}
+		case "formula.if": {
+			const no = partNamed(slots, "else");
+			const frame = {
+				f: "if",
+				at: NO_KEYS$1,
+				site,
+				yes: partNamed(slots, "then"),
+				...no === void 0 ? {} : { no }
+			};
+			pushed(c, frame);
+			return enter(c, frame, site, partNamed(slots, "test"));
+		}
+		case "formula.and":
+		case "formula.or": {
+			const stop = name === "formula.or";
+			const first = slots[0];
+			if (first === void 0) return back(c, ok(!stop));
+			const frame = {
+				f: "logic",
+				at: NO_KEYS$1,
+				site,
+				stop,
+				what: stop ? "term of or" : "term of and",
+				slots,
+				next: 1
+			};
+			pushed(c, frame);
+			return enter(c, frame, site, first);
+		}
+		case "formula.op": {
+			const op = keys.slice(1).join(".");
+			const lazy = own$1(profile.lazy, op);
+			if (lazy !== void 0) {
+				p.applying = c.applying;
+				try {
+					return back(c, lazy(slots.map((slot) => () => nested(p, c, site, slot))));
+				} catch (error) {
+					return back(c, thrown(error, `the operation ${op}`));
+				}
+			}
+			if (opOf(p, op) === void 0) return back(c, fail("#NAME?", `The language has no operation ${op}.`));
+			return startValues(p, c, site, "op", slots, false, { name: op });
+		}
+		default: {
+			const ext = keys.slice(1).join(".");
+			const handler = own$1(profile.ext, ext) ?? own$1(STD_EXT, ext);
+			if (handler === void 0) return back(c, fail("#NAME?", `The language has no extension ${ext}.`));
+			try {
+				return back(c, handler(doc.value, hostContext(p, c, site.ctx), machine.domains));
+			} catch (error) {
+				return back(c, thrown(error, `the extension ${ext}`));
+			}
+		}
+	}
+}
+/** H-SEAL for host code: a handle starts a nested stepper, on the stack of the host. */
+function nested(p, c, site, slot, given) {
+	const stack = [{
+		f: "base",
+		place: placeOf$1(c.stack).concat(slot.path)
+	}];
+	const end = drive$1(p, enter({
+		mode: "resume",
+		result: ok(null),
+		stack,
+		applying: p.applying,
+		marked: c.marked
+	}, { at: NO_KEYS$1 }, site, slot, given));
+	return end.result.ok ? ok(forHost(p, end, end.result.value)) : end.result;
+}
+/** RUN.EVAL: an effect of a host evaluator, with RUN.CAP, RUN.ADDRESS and RUN.MOCK. */
+function cause(p, ctx, kind, payload, place) {
+	const keys = typeof kind === "string" ? kind.split(".") : kind;
+	const text = keys.join(".");
+	const { machine, perform, counts, effects } = p;
+	if (!(machine.permits === void 0 ? permits(ctx.caps, keys) : machine.permits(ctx.caps, keys, ctx))) return fail("#CAP!", `The context has no capability for the effect ${text}.`, { place });
+	const at = placeText(place);
+	const count = counts.get(at) ?? 0;
+	counts.set(at, count + 1);
+	const effect = {
+		index: effects.length,
+		kind: text,
+		path: keys,
+		payload,
+		node: -1,
+		at: 0,
+		place,
+		context: ctx,
+		address: `${at}#${count}`
+	};
+	effects.push(effect);
+	effect.outcome = answer(perform, effect, place);
+	return effect.outcome;
+}
+function answer(perform, effect, place) {
+	if (perform === void 0) return ok(effect.payload);
+	let given;
+	try {
+		given = perform(effect);
+	} catch (error) {
+		if (error instanceof Failure) return placed({
+			ok: false,
+			error: error.error
+		}, place);
+		return fail("#CALC!", `The host failed the effect ${effect.kind}: ${describe(error)}`, {
+			place,
+			cause: error
+		});
+	}
+	if (!(given instanceof Promise)) return ok(given);
+	given.catch(() => void 0);
+	return fail("#CALC!", `The mock gave a promise for the effect ${effect.kind}, and an evaluation does not wait.`, { place });
+}
+/** E-APPLY for host code: one step of the stepper starts the evaluator. */
+function hostEvaluator(p, c, name, evaluator, doc, keys, data, slots, site) {
+	const place = placeOf$1(c.stack);
+	const parts = slots.map((slot) => {
+		const header = isEnvelope(slot.item) ? field(slot.item, "name") : void 0;
+		return {
+			key: slot.key,
+			path: slot.path,
+			...typeof header === "string" ? { name: header } : {},
+			evaluate: (given) => nested(p, c, site, slot, given)
+		};
+	});
+	const fill = (items) => fillIn(doc.value, slots, items);
+	p.applying = c.applying;
+	const input = {
+		kind: typeName(doc.type),
+		typePath: keys,
+		doc,
+		value: fill(parts),
+		data,
+		parts,
+		context: hostContext(p, c, site.ctx),
+		place,
+		machine: p.machine,
+		...c.address ? { address: true } : {},
+		resolve: (path, _options) => walkPath(p, site.ctx, path),
+		effect: (kind, payload) => cause(p, site.ctx, kind, payload, place),
+		fill
+	};
+	try {
+		return back(c, evaluator(input));
+	} catch (error) {
+		return back(c, thrown(error, `the evaluator ${name}`));
+	}
+}
+/** The judgment 4: the rules E-PART to E-APPLY for one document, in their order. */
+function evaluateDoc(p, c) {
+	const { value, declared, depth } = c;
+	const { machine, verb } = p;
+	const { world } = machine;
+	const envelope = isEnvelope(value) ? value : void 0;
+	if (envelope === void 0 && declared === void 0) return back(c, fail("#PART?", "The value has no envelope, and its position declares no type."));
+	const doc = envelope ?? {
+		type: declared,
+		value
+	};
+	const found = lookup(world, doc.type);
+	if (depth > p.maxDepth) return back(c, fail("#DEPTH!", `The nesting is deeper than ${p.maxDepth} documents.`));
+	const kindText = typeName(doc.type);
+	const name = ladder(world, envelope === void 0 ? void 0 : field(envelope, "own"), found?.kind, found !== void 0, verb, () => true);
+	if (name === null) return back(c, fail("#KIND?", `The world has no kind ${kindText}.`));
+	const code = typeof name === "string" ? own$1(machine.runners, name) ?? own$1(machine.evaluators, name) : void 0;
+	if (name === void 0 || code === void 0) return back(c, fail("#NOEVAL", `No rung gives an evaluator for ${kindText}.`));
+	const read = split(found?.kind.parts, doc.value);
+	if (read instanceof Bad) {
+		const where = read.at.length === 0 ? "" : ` (at ${read.at.join(".")})`;
+		return back(c, fail("#VALUE!", `${read.reason}${where} The kind is ${kindText}.`));
+	}
+	if (own$1(machine.runners, name) !== void 0) return back(c, fail("#NOEVAL", `The stepper has no runner ${name}.`));
+	const rules = found?.kind.caps;
+	const site = {
+		name,
+		depth,
+		ctx: c.ctx,
+		...rules === void 0 ? {} : { rules }
+	};
+	const keys = found?.path ?? [];
+	if (typeof code === "function") return hostEvaluator(p, c, name, code, doc, keys, read.data, read.slots, site);
+	if (own$1(CONSTRUCTS$2, name) === true) try {
+		return construct(p, c, name, doc, keys, read.slots, site);
+	} catch (error) {
+		return back(c, thrown(error, `the evaluator ${name}`));
+	}
+	const defined = own$1(p.definitions.evaluators, name);
+	if (defined !== void 0) return hostEvaluator(p, c, name, defined, doc, keys, read.data, read.slots, site);
+	return back(c, fail("#NOEVAL", `The stepper has no definition of the compiled evaluator ${name}.`));
+}
+/** The next part of a frame with a list of parts. */
+function nextOf(frame) {
+	const slot = frame.slots[frame.next];
+	if (slot !== void 0) frame.next += 1;
+	return slot;
+}
+function resumeValues(p, c, frame) {
+	const { result } = c;
+	const { combine, omit } = p.profile;
+	if (result.ok) frame.values.push(result.value);
+	else if (frame.then === "record" && omit?.(result.error) === true) {
+		frame.skipped.push(frame.values.length);
+		frame.values.push(null);
+	} else if (frame.strict || combine === void 0) {
+		popped(c);
+		return c;
+	} else frame.errors.push(result.error);
+	const slot = nextOf(frame);
+	if (slot !== void 0) return enter(c, frame, frame.site, slot);
+	popped(c);
+	const first = frame.errors[0];
+	if (first === void 0) return finish$1(p, c, frame);
+	return back(c, {
+		ok: false,
+		error: frame.errors.length === 1 ? first : combine(frame.errors)
+	});
+}
+/** The rule `resume(k, r)`: the top frame takes a result. An exception of a rule of the profile ends its document. */
+function resume(p, c) {
+	const stack = c.stack;
+	const frame = stack[stack.length - 1];
+	if (frame === void 0) return {
+		mode: "done",
+		result: c.result,
+		stack,
+		applying: c.applying,
+		marked: c.marked
+	};
+	try {
+		return take(p, c, frame);
+	} catch (error) {
+		if (stack[stack.length - 1] === frame) popped(c);
+		return back(c, thrown(error, `the evaluator ${"site" in frame ? frame.site.name : "of the part"}`));
+	}
+}
+function take(p, c, frame) {
+	const stack = c.stack;
+	const { result } = c;
+	switch (frame.f) {
+		case "base":
+			popped(c);
+			return {
+				mode: "done",
+				result,
+				stack,
+				applying: c.applying,
+				marked: c.marked
+			};
+		case "tail":
+			popped(c);
+			return c;
+		case "return":
+			popped(c);
+			return {
+				...c,
+				applying: c.applying - 1
+			};
+		case "values": return resumeValues(p, c, frame);
+		case "let": {
+			const key = String(frame.slots[frame.next - 1].path[1]);
+			setField$1(frame.names, key, result.ok ? result.value : { [HELD_MARK]: result.error });
+			const marked = c.marked || !result.ok;
+			const slot = nextOf(frame);
+			if (slot !== void 0) return enter(c, frame, frame.site, slot, void 0, marked);
+			const tail = {
+				f: "tail",
+				at: NO_KEYS$1
+			};
+			stack[stack.length - 1] = tail;
+			return enter(c, tail, frame.site, frame.body, {
+				...frame.site.ctx,
+				names: frame.names
+			}, marked);
+		}
+		case "call":
+			popped(c);
+			if (!result.ok) return c;
+			if (closureOf(result.value) === void 0 && typeof result.value !== "function") return back(c, fail("#VALUE!", "The fn of call must give a function."));
+			return startValues(p, c, frame.site, "args", frame.args, true, { target: result.value });
+		case "if": {
+			if (!result.ok) {
+				popped(c);
+				return c;
+			}
+			const truth = truthOf(p, c, result.value);
+			if (truth === void 0) {
+				popped(c);
+				return back(c, fail("#VALUE!", "The test of if must give a truth value."));
+			}
+			const branch = truth ? frame.yes : frame.no;
+			if (branch === void 0) {
+				popped(c);
+				return back(c, ok(Object.hasOwn(p.profile, "otherwise") ? p.profile.otherwise : null));
+			}
+			const tail = {
+				f: "tail",
+				at: NO_KEYS$1
+			};
+			stack[stack.length - 1] = tail;
+			return enter(c, tail, frame.site, branch);
+		}
+		case "logic": {
+			if (!result.ok) {
+				popped(c);
+				return c;
+			}
+			const truth = truthOf(p, c, result.value);
+			const value = p.profile.logic === "value";
+			if (truth === void 0) {
+				popped(c);
+				return back(c, fail("#VALUE!", `The ${frame.what} must give a truth value.`));
+			}
+			if (truth === frame.stop) {
+				popped(c);
+				return back(c, value ? result : ok(frame.stop));
+			}
+			const slot = nextOf(frame);
+			if (slot !== void 0) return enter(c, frame, frame.site, slot);
+			popped(c);
+			return back(c, value ? result : ok(!frame.stop));
+		}
+	}
+}
+function advance(p, c) {
+	if (c.mode === "evaluate") return evaluateDoc(p, c);
+	return c.mode === "resume" ? resume(p, c) : c;
+}
+function drive$1(p, start) {
+	let now = start;
+	while (now.mode !== "done") now = advance(p, now);
+	return now;
+}
+function programOf(machine, options) {
+	return {
+		machine,
+		profile: options.profile ?? {},
+		definitions: options.definitions ?? {},
+		verb: options.verb ?? "eval",
+		maxDepth: machine.maxDepth ?? 1e3,
+		hosts: /* @__PURE__ */ new WeakMap(),
+		effects: options.effects ?? [],
+		perform: options.perform,
+		counts: /* @__PURE__ */ new Map(),
+		applying: 0
+	};
+}
+/**
+* This function gives the first configuration of a document: `evaluate(d, Γ, [], [])`.
+*
+* @param machine - The world, the evaluators and the other code.
+* @param doc - The document.
+* @param context - The names and the capabilities at the root. A context without a world gets the world of the machine.
+* @param options - The type of a bare root value.
+* @returns The configuration.
+*/
+function stepperStart(machine, doc, context = makeContext(), options = {}) {
+	const ctx = context.world === null ? {
+		...context,
+		world: worldThing(machine.world)
+	} : context;
+	return {
+		mode: "evaluate",
+		value: doc,
+		declared: options.declaredType,
+		depth: 0,
+		address: false,
+		ctx,
+		stack: [],
+		applying: 0,
+		marked: false
+	};
+}
+/**
+* This function does one step. It is pure: the configuration stays as it is, and a host can keep it, store it as JSON and
+* step it again (STEPPER.DATA). The result of `done` holds a closure as data. The function `stepper` gives a host
+* function.
+*
+* @param machine - The machine of the configuration.
+* @param configuration - The configuration.
+* @param options - The profile and the verb of the configuration.
+* @returns The next configuration, or the same configuration at `done`.
+*/
+function stepperNext(machine, configuration, options = {}) {
+	const stack = [...configuration.stack];
+	const top = stack[stack.length - 1];
+	if (top !== void 0) {
+		const { f } = top;
+		if (f === "values") stack[stack.length - 1] = {
+			...top,
+			values: [...top.values],
+			errors: [...top.errors],
+			skipped: [...top.skipped]
+		};
+		else if (f === "let") stack[stack.length - 1] = {
+			...top,
+			names: { ...top.names }
+		};
+		else stack[stack.length - 1] = { ...top };
+	}
+	return advance(programOf(machine, options), {
+		...configuration,
+		stack
+	});
+}
+/**
+* This function evaluates a document with an explicit stack (K95, D158). It gives the result of `reference` for each
+* document of the kernel and the formula kit (AGREE.STEPPER). The nesting of a document does not use the stack of the
+* host (STEPPER.DEEP). A host evaluator is opaque: one step starts it, and each of its handles starts a nested
+* stepper. The stepper does no effects and no runs.
+*
+* @param machine - The world, the evaluators and the other code.
+* @param doc - The document.
+* @param context - The names and the capabilities at the root.
+* @param options - The profile of the formula kit, the verb and the type of a bare root value.
+* @returns The result.
+*/
+function stepper(machine, doc, context = makeContext(), options = {}) {
+	const p = programOf(machine, options);
+	try {
+		const end = drive$1(p, stepperStart(machine, doc, context, options));
+		return end.result.ok ? ok(forHost(p, end, end.result.value)) : end.result;
+	} catch (error) {
+		return placed(thrown(error, "the stepper"), []);
+	}
+}
 // src/replay.ts
 /**
 * This function makes a recorder (RUN.RECORD). The recorder gives each effect to the function `perform` of the host.
@@ -15002,6 +16268,13 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 			effects: otherEffects,
 			...options.definitions === void 0 ? {} : { definitions: options.definitions }
 		});
+		else if (tier === "stepper") other = stepper(machine, doc, context, {
+			...declared,
+			...mock,
+			effects: otherEffects,
+			...options.profile === void 0 ? {} : { profile: options.profile },
+			...options.definitions === void 0 ? {} : { definitions: options.definitions }
+		});
 		else if (tier === "traced") {
 			const traced = evaluate(machine, doc, context, {
 				...declared,
@@ -15239,7 +16512,7 @@ async function agreeRun(machine, doc, context = makeContext(), options = {}) {
 	let compared;
 	const replay = replayer(log);
 	for (const tier of options.tiers ?? DEFAULT_TIERS) {
-		if (tier === "fixed") continue;
+		if (tier === "fixed" || tier === "stepper") continue;
 		const tierReplay = watched(replay);
 		const host = { perform: tierReplay.perform };
 		let other;
@@ -21166,6 +22439,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, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, 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, 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, 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