@mark1russell7/coeval 0.26.1 → 0.27.1

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
@@ -2579,483 +2579,578 @@ 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;
+// src/parts.ts
+var Bad$1 = class {
+	reason;
+	at;
+	constructor(reason, at) {
+		this.reason = reason;
+		this.at = at;
 	}
-	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
+};
+/** This function sets an own data property. Only the key `__proto__` needs `defineProperty`. */
+function setOwn$4(target, key, value) {
+	if (key === "__proto__") Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
 	});
+	else target[key] = value;
 }
-function partOf(language) {
-	const { code, world } = language;
-	return typeof code === "function" ? (prev) => ({
-		...code(prev),
-		world
-	}) : {
-		...code,
-		world
-	};
+const NO_SLOTS = /* @__PURE__ */ Object.freeze([]);
+function hasSlots(template) {
+	return template.t !== "data";
 }
-/**
-* 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);
+/** This function gives the shape of a part with the default type `of` and the value type `expect` of its container. */
+function termOf$1(of, expect) {
+	return {
+		shape: "term",
+		...of === void 0 ? {} : { of },
+		...expect === void 0 ? {} : { expect }
+	};
 }
-// src/ladder.ts
-/** The rungs of the ladder, in the order that a question visits them. */
-const RUNGS = [
-	"own",
-	"kind",
-	"default"
-];
-function entryOf$1(verbs, verb) {
-	return verbs !== void 0 && Object.hasOwn(verbs, verb) ? verbs[verb] : void 0;
+/** This function tells if a shape holds only data: no value of the shape can hold a part. */
+function isData(shape) {
+	return shape.shape === "none" || shape.shape === "text" || shape.shape === "number" || shape.shape === "one";
 }
-/**
-* This function finds the kind that a type names, and follows each alias. It gives `undefined` for an unknown
-* type.
-*
-* @param world - The world.
-* @param type - The reference to the type.
-* @returns The kind, or `undefined`.
-*/
-function kindOf(world, type) {
-	const found = lookupKind(world, type);
-	return found.ok ? found.kind : void 0;
+/** This function gives the reason why a value is not data of a shape, or `undefined` when it is. */
+function dataFault(spec, item) {
+	if (spec.shape === "text") return typeof item === "string" ? void 0 : "The value must be a text.";
+	if (spec.shape === "one") return spec.values.some((value) => docEquals(value, item)) ? void 0 : `The value must be one of ${JSON.stringify(spec.values)}.`;
+	if (typeof item !== "number") return "The value must be a number.";
+	if (spec.whole === true && !Number.isInteger(item)) return "The value must be a whole number.";
+	if (spec.min !== void 0 && !(item >= spec.min)) return `The value must be ${String(spec.min)} or more.`;
+	if (spec.max !== void 0 && !(item <= spec.max)) return `The value must be ${String(spec.max)} or less.`;
 }
-/**
-* This function finds a kind by a text type. It is the same as `kindOf` for a one-key reference.
-*
-* @param world - The world.
-* @param name - The text of the type.
-* @returns The kind, or `undefined`.
-*/
-function kindNamed(world, name) {
-	return kindOf(world, name);
+/** This function stops a split when a part has a type that its position does not permit. */
+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$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);
 }
-/** A test that passes each name. A rung of `answerOf` then answers with each entry that it has. */
-const EACH_NAME = () => true;
 /**
-* This function finds the evaluator of a verb without the record of the rungs. It visits the rungs of `ask` in the
-* same order: the own entry, then the kind, then the default of the world (VERB.LADDER). A plan without a trace,
-* `deref` and the walkers of steps use it, thus each verb has one ladder.
+* This function splits a value into its parts, by the shape that its kind declares. The evaluator, the view and
+* the static kit use the same split, thus each one sees the same parts.
 *
-* @param world - The world, for its defaults.
-* @param own - The own entries of the document, when it has some.
-* @param kind - The kind of the document. `undefined` skips the kind rung, as for a value without a type. `null` is
-*   a kind that the world does not have: the question stops there, as in `ask`.
-* @param verb - The verb, for example `eval`, `format`, `deref` or `step`.
-* @param has - The test of a name. A rung answers only with a name that passes it. The default passes each name.
-* @returns The evaluator name and its rung, or `undefined` when no rung answers.
+* @param shape - The shape of the value. The default is data.
+* @param value - The value of the document.
+* @returns The parts and a way to fill their places, or the reason why the value does not have the shape.
 */
-function answerOf(world, own, kind, verb, has = EACH_NAME) {
-	const ownName = entryOf$1(own, verb);
-	if (ownName !== void 0 && has(ownName)) return {
-		name: ownName,
-		rung: "own"
+function splitParts(shape, value) {
+	if (shape === void 0 || shape.shape === "none") return {
+		ok: true,
+		parts: NO_SLOTS,
+		data: value,
+		fill: () => value
 	};
-	if (kind === null) return void 0;
-	const kindName = kind === void 0 ? void 0 : entryOf$1(kind.verbs, verb);
-	if (kindName !== void 0 && has(kindName)) return {
-		name: kindName,
-		rung: "kind"
+	const parts = [];
+	const slot = (item, path, of, address = false, expect) => {
+		parts.push({
+			path,
+			key: path.join("."),
+			item,
+			...of === void 0 ? {} : { of },
+			...address ? { address: true } : {},
+			...expect === void 0 ? {} : { expect }
+		});
+		return {
+			t: "slot",
+			index: parts.length - 1
+		};
 	};
-	const fallback = entryOf$1(world.defaults, verb);
-	return fallback !== void 0 && has(fallback) ? {
-		name: fallback,
-		rung: "default"
-	} : void 0;
-}
-/**
-* This function asks a document a question, and gives the evaluator that answers it.
-*
-* The question visits the rungs in order: the own entry of the envelope, then its kind, then the default of the
-* world. The type comes from the envelope, or else from the type that the position declares. The type is a
-* reference into the world. The ladder does not guess a type from the shape of a value. Each verb has this ladder:
-* `eval`, `deref`, `step` and each verb of a language (VERB.LADDER).
-*
-* @param world - The kinds and the defaults.
-* @param doc - The header of the document: an envelope, or `{}` for a bare value.
-* @param verb - The verb of the question, for example `eval` or `view`.
-* @param options - The type that the position declares.
-* @returns The answer, with the record of each rung that the question visited.
-*/
-function ask(world, doc, verb, options = {}) {
-	const steps = [];
-	const own = entryOf$1(doc.own, verb);
-	if (own !== void 0) {
-		steps.push({
-			rung: "own",
-			outcome: "answers",
-			evaluator: own
-		});
+	const deep = (item, path, of, expect) => {
+		if (isEnvelope(item)) return slot(item, path, of, false, expect);
+		if (Array.isArray(item)) {
+			const items = item.map((child, index) => deep(child, [...path, index], of, expect));
+			return items.some(hasSlots) ? {
+				t: "list",
+				items
+			} : {
+				t: "data",
+				value: item
+			};
+		}
+		if (isRecord(item)) {
+			const fields = Object.keys(item).map((key) => [key, deep(item[key], [...path, key], of, expect)]);
+			return fields.some(([, child]) => hasSlots(child)) ? {
+				t: "record",
+				fields
+			} : {
+				t: "data",
+				value: item
+			};
+		}
 		return {
-			verb,
-			evaluator: own,
-			rung: "own",
-			steps
+			t: "data",
+			value: item
 		};
-	}
-	steps.push({
-		rung: "own",
-		outcome: "no-entry"
-	});
-	const type = doc.type ?? options.declaredType;
-	if (type === void 0) steps.push({
-		rung: "kind",
-		outcome: "skipped"
-	});
-	else {
-		const source = doc.type === void 0 ? "container" : "document";
-		const name = typeName(type);
-		const kind = kindOf(world, type);
-		if (kind === void 0) {
-			steps.push({
-				rung: "kind",
-				outcome: "unknown-kind",
-				kind: name,
-				source
-			});
+	};
+	const walk = (spec, item, path) => {
+		if (spec === void 0 || spec.shape === "none") return {
+			t: "data",
+			value: item
+		};
+		if (spec.shape === "text" || spec.shape === "number" || spec.shape === "one") {
+			const reason = dataFault(spec, item);
+			if (reason !== void 0) throw new Bad$1(reason, path);
 			return {
-				verb,
-				error: "unknown-kind",
-				steps
+				t: "data",
+				value: item
 			};
 		}
-		const entry = entryOf$1(kind.verbs, verb);
-		if (entry !== void 0) {
-			steps.push({
-				rung: "kind",
-				outcome: "answers",
-				evaluator: entry,
-				kind: name,
-				source
-			});
+		if (spec.shape === "term") {
+			if (spec.kinds !== void 0) kindFault(spec.kinds, item, spec.of, path);
+			return slot(item, path, spec.of, spec.address === true, spec.expect);
+		}
+		if (spec.shape === "deep") return deep(item, path, spec.of, spec.expect);
+		if (spec.shape === "list") {
+			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$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]));
+			return isData(each) ? {
+				t: "data",
+				value: item
+			} : {
+				t: "list",
+				items
+			};
+		}
+		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 {
-				verb,
-				evaluator: entry,
-				rung: "kind",
-				steps
+				t: "record",
+				fields: Object.keys(item).map((key) => [key, walk(each, item[key], [...path, key])])
 			};
 		}
-		steps.push({
-			rung: "kind",
-			outcome: "no-entry",
-			kind: name,
-			source
-		});
-	}
-	const fallback = entryOf$1(world.defaults, verb);
-	if (fallback !== void 0) {
-		steps.push({
-			rung: "default",
-			outcome: "answers",
-			evaluator: fallback
-		});
+		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$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])]);
+		}
 		return {
-			verb,
-			evaluator: fallback,
-			rung: "default",
-			steps
+			t: "record",
+			fields
+		};
+	};
+	let template;
+	try {
+		template = walk(shape, value, []);
+	} catch (error) {
+		if (error instanceof Bad$1) return {
+			ok: false,
+			reason: error.reason,
+			at: error.at
 		};
+		throw error;
 	}
-	steps.push({
-		rung: "default",
-		outcome: "no-entry"
-	});
+	const strip = (node) => {
+		if (node.t === "data") return node.value;
+		if (node.t === "slot") return void 0;
+		if (node.t === "list") return node.items.every((child) => child.t === "slot") ? null : node.items.map((child) => strip(child) ?? null);
+		const out = {};
+		for (const [key, child] of node.fields) {
+			const kept = strip(child);
+			if (kept !== void 0) setOwn$4(out, key, kept);
+		}
+		return out;
+	};
+	const fillWith = (node, handles) => {
+		if (node.t === "data") return node.value;
+		if (node.t === "slot") return handles[node.index];
+		if (node.t === "list") return node.items.map((child) => fillWith(child, handles));
+		const out = {};
+		for (const [key, child] of node.fields) setOwn$4(out, key, fillWith(child, handles));
+		return out;
+	};
 	return {
-		verb,
-		error: "no-answer",
-		steps
+		ok: true,
+		parts,
+		data: strip(template) ?? null,
+		fill: (handles) => fillWith(template, handles)
 	};
 }
-// src/steps.ts
 /**
-* This function makes a ladder of steps, and it checks the declaration (STEPS.LADDER). The list of steps must have one
-* step or more, with no name two times. The step of each construct must be a step of the list.
+* This function reads one document by the contracts of the world. It finds the kind of the type. A bare value gets
+* the type that its position declares. Then the function splits the value by the shape of the kind. The plan, the
+* reference interpreter and the static kit read each document with this function. Thus they see the same parts.
 *
-* @param steps - The names of the steps, from the lowest to the highest.
-* @param constructs - The step that each construct needs.
-* @returns The ladder, frozen.
-* @throws TypeError for a declaration that is not valid, because it is a defect of the language.
+* @param world - The world of the kinds.
+* @param value - The document, or a bare value.
+* @param declaredType - The type that the position of a bare value declares.
+* @returns The document, its kind and its parts, or the reason why the value is not a document.
 */
-function stepLadder(steps, constructs) {
-	if (steps.length === 0) throw new TypeError("a ladder of steps needs one step or more");
-	const seen = /* @__PURE__ */ new Set();
-	for (const step of steps) {
-		if (typeof step !== "string") throw new TypeError(`the step ${String(step)} is not a name`);
-		if (seen.has(step)) throw new TypeError(`the step "${step}" is in the ladder two times`);
-		seen.add(step);
-	}
-	for (const [construct, step] of Object.entries(constructs)) if (!seen.has(step)) throw new TypeError(`the construct "${construct}" needs the step "${String(step)}", which is not a step of the ladder`);
-	return Object.freeze({
-		steps: Object.freeze([...steps]),
-		constructs: Object.freeze({ ...constructs })
-	});
+function partsOf(world, value, declaredType) {
+	const envelope = isEnvelope(value) ? value : void 0;
+	if (envelope === void 0 && declaredType === void 0) return {
+		ok: false,
+		code: "#PART?",
+		reason: "The value has no envelope, and its position declares no type."
+	};
+	const doc = envelope ?? {
+		type: declaredType,
+		value
+	};
+	const found = lookupKind(world, doc.type);
+	const kind = found.ok ? found.kind : void 0;
+	const split = splitParts(kind?.parts, doc.value);
+	const typePath = found.ok ? found.path : void 0;
+	if (split.ok) return {
+		ok: true,
+		doc,
+		declared: envelope === void 0,
+		kind,
+		typePath,
+		split
+	};
+	const where = split.at.length === 0 ? "" : ` (at ${split.at.join(".")})`;
+	const reason = `${split.reason}${where} The kind is ${typeName(doc.type)}.`;
+	return {
+		ok: true,
+		doc,
+		declared: envelope === void 0,
+		kind,
+		typePath,
+		split: {
+			ok: false,
+			reason,
+			at: split.at
+		}
+	};
 }
 /**
-* This function tells if a value is a step of a ladder. A host uses it to check its option for the highest step.
+* This function tells if the path of a part matches a pattern of a scope rule. The key `"*"` of a pattern matches
+* each key.
 *
-* @param ladder - The ladder.
-* @param value - The value.
-* @returns `true` when the value is the name of a step of the ladder.
+* @param path - The path of the part.
+* @param pattern - The pattern.
+* @returns `true` when the path matches.
 */
-function isStep(ladder, value) {
-	return typeof value === "string" && ladder.steps.includes(value);
+function pathMatches(path, pattern) {
+	if (path.length !== pattern.length) return false;
+	for (let index = 0; index < path.length; index += 1) {
+		const want = pattern[index];
+		if (want !== "*" && String(want) !== String(path[index])) return false;
+	}
+	return true;
 }
 /**
-* This function gives the position of a step in its ladder. The lowest step has the position 0.
+* This function tells if a list of rules in the form of the lazy rules covers a part (D24, D119). A rule without
+* `in` covers each part. With `after: n`, a rule covers only the parts after the first `n` parts that it matches.
 *
-* @param ladder - The ladder.
-* @param step - The step.
-* @returns The position.
-* @throws TypeError for a name that is not a step of the ladder.
+* @param rules - The rules.
+* @param shape - The shape of the parts of the parent.
+* @param value - The value of the parent.
+* @param slot - The path of the part in the value.
+* @returns `true` when a rule covers the part.
 */
-function stepRank(ladder, step) {
-	const rank = ladder.steps.indexOf(step);
-	if (rank < 0) throw new TypeError(`"${String(step)}" is not a step of the ladder. The steps are ${ladder.steps.join(", ")}`);
-	return rank;
+function rulesCover(rules, shape, value, slot) {
+	for (const rule of rules) {
+		if (rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(slot, pattern))) continue;
+		const after = rule.after ?? 0;
+		if (after <= 0) return true;
+		const split = splitParts(shape, value);
+		let count = 0;
+		for (const part of split.ok ? split.parts : []) {
+			if (rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(part.path, pattern))) continue;
+			if (part.path.length === slot.length && pathMatches(part.path, slot)) {
+				if (count >= after) return true;
+				break;
+			}
+			count += 1;
+		}
+	}
+	return false;
 }
-function pathOf(visit) {
-	const path = [];
-	for (let v = visit; v?.key !== void 0; v = v.parent) path.push(v.key);
-	return path.reverse();
+function valueAt(value, path) {
+	let here = value;
+	for (const key of path) if (Array.isArray(here)) here = here[Number(key)];
+	else if (isRecord(here) && Object.hasOwn(here, String(key))) here = here[String(key)];
+	else return void 0;
+	return here;
+}
+function headerName(item) {
+	return isEnvelope(item) && typeof item.name === "string" ? item.name : void 0;
+}
+function namesOf(source, value, covered) {
+	if ("fixed" in source) return source.fixed;
+	if ("keysAt" in source) {
+		const at = valueAt(value, source.keysAt);
+		return isRecord(at) ? Object.keys(at) : [];
+	}
+	if ("listAt" in source) {
+		const at = valueAt(value, source.listAt);
+		return Array.isArray(at) ? at.filter((item) => typeof item === "string") : [];
+	}
+	if ("textAt" in source) {
+		const at = valueAt(value, source.textAt);
+		if (typeof at === "string") return [at];
+		return source.otherwise === void 0 ? [] : [source.otherwise];
+	}
+	return covered.map((slot) => headerName(slot.item)).filter((name) => name !== void 0);
 }
 /**
-* This function gives the lowest step that a document needs, with the reason (STEPS.LOWEST, STEPS.REASON). The step is
-* the highest step of the constructs of its nodes. The reason is the first node in document order with that step. The
-* walk uses its own stack, thus a deep document does not overflow (STEPS.LINEAR). It visits a shared node one time,
-* and it stops at the first node with the highest step of the ladder.
+* This function gives the names that the scope rules of a kind give each part, and the names that only later parts
+* see. `check`, `conforms` and the plan read the scope rules with it.
 *
-* @param ladder - The ladder of the language.
-* @param walk - The construct and the child nodes of a node.
-* @param root - The root node of the document.
-* @returns The step, and the reason when the step is not the lowest step.
+* @param rules - The scope rules of the kind.
+* @param value - The value of the document.
+* @param slots - The parts of the value, in order.
+* @returns The names that each part sees, and the names that only the later parts see, by the index of the part.
 */
-function stepOf(ladder, walk, root) {
-	const top = ladder.steps.length - 1;
-	let best = 0;
-	let reason;
-	const seen = /* @__PURE__ */ new Set();
-	const todo = [{
-		node: root,
-		key: void 0,
-		parent: void 0
-	}];
-	for (let visit = todo.pop(); visit !== void 0; visit = todo.pop()) {
-		const { node } = visit;
-		if (typeof node === "object" && node !== null) {
-			if (seen.has(node)) continue;
-			seen.add(node);
-		}
-		const construct = walk.construct(node);
-		const step = construct === void 0 || !Object.hasOwn(ladder.constructs, construct) ? void 0 : ladder.constructs[construct];
-		const rank = step === void 0 ? 0 : ladder.steps.indexOf(step);
-		if (rank > best) {
-			best = rank;
-			reason = {
-				construct,
-				step,
-				path: pathOf(visit),
-				node
-			};
-			if (best === top) break;
+function scopesOf(rules, value, slots) {
+	const sees = slots.map(() => []);
+	const later = slots.map(() => []);
+	for (const rule of rules ?? []) {
+		const covered = slots.map((slot, index) => ({
+			slot,
+			index
+		})).filter(({ slot }) => rule.in.some((pattern) => pathMatches(slot.path, pattern)));
+		if (rule.sequential !== true) {
+			const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
+			for (const { index } of covered) sees[index]?.push(...names);
+			continue;
 		}
-		const kids = [...walk.children(node)];
-		for (let i = kids.length - 1; i >= 0; i--) {
-			const [key, child] = kids[i];
-			todo.push({
-				node: child,
-				key,
-				parent: visit
+		if ("headers" in rule.names) {
+			covered.forEach(({ index }, position) => {
+				const before = covered.slice(0, position).map(({ slot }) => headerName(slot.item)).filter((name) => name !== void 0);
+				const after = covered.slice(position).map(({ slot }) => headerName(slot.item)).filter((name) => name !== void 0);
+				sees[index]?.push(...before);
+				later[index]?.push(...after);
 			});
+			continue;
 		}
+		const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
+		covered.forEach(({ index }, position) => {
+			if (position > 0) sees[index]?.push(...names);
+			else later[index]?.push(...names);
+		});
 	}
-	const step = ladder.steps[best];
-	return reason === void 0 ? { step } : {
-		step,
-		reason
+	return {
+		sees,
+		later
 	};
 }
+// src/ladder.ts
+/** The rungs of the ladder, in the order that a question visits them. */
+const RUNGS = [
+	"own",
+	"kind",
+	"default"
+];
+function entryOf$1(verbs, verb) {
+	return verbs !== void 0 && Object.hasOwn(verbs, verb) ? verbs[verb] : void 0;
+}
 /**
-* This function compares the step of a document with the highest step that the host accepts (STEPS.MAX). The limit
-* changes only which documents the host accepts. The language evaluates an accepted document as before, thus a limit
-* does not change a value.
+* This function finds the kind that a type names, and follows each alias. It gives `undefined` for an unknown
+* type.
 *
-* @param ladder - The ladder of the language.
-* @param need - The step of the document, from `stepOf`.
-* @param maxStep - The highest step that the host accepts.
-* @returns `undefined` when the host accepts the document, or the refusal that names the needed step.
-* @throws TypeError when `maxStep` or the step of `need` is not a step of the ladder.
+* @param world - The world.
+* @param type - The reference to the type.
+* @returns The kind, or `undefined`.
 */
-function checkStep(ladder, need, maxStep) {
-	const limit = stepRank(ladder, maxStep);
-	if (stepRank(ladder, need.step) <= limit) return void 0;
-	const head = `the document needs the step ${need.step}, and the host accepts the steps up to ${maxStep}`;
-	const reason = need.reason;
-	if (reason === void 0) return {
-		needed: need.step,
-		maxStep,
-		message: head
-	};
-	const where = reason.path.length === 0 ? "at the root" : `at the path ${JSON.stringify(reason.path)}`;
-	return {
-		needed: need.step,
-		maxStep,
-		reason,
-		message: `${head}. The construct "${reason.construct}" ${where} needs the step ${reason.step}`
-	};
+function kindOf(world, type) {
+	const found = lookupKind(world, type);
+	return found.ok ? found.kind : void 0;
 }
-// src/deref.ts
-/**
-* The brand of a host thing: an object of the host that answers the steps of a path itself. The brand is a
-* global symbol, thus two copies of the kernel in one program know the things of each other.
-*/
-const THING = /* @__PURE__ */ Symbol.for("coeval.thing");
 /**
-* This function tells if a thing is a host thing.
+* This function finds a kind by a text type. It is the same as `kindOf` for a one-key reference.
 *
-* @param thing - The thing.
-* @returns `true` for a host thing.
+* @param world - The world.
+* @param name - The text of the type.
+* @returns The kind, or `undefined`.
 */
-function isHostThing(thing) {
-	return typeof thing === "object" && thing !== null && thing[THING] === true;
-}
-/** The roots of a context. Each path starts with one of them. */
-const ROOTS = [
-	"self",
-	"names",
-	"world",
-	"event",
-	"caps"
-];
-/** This function gives the own entries of an envelope, when it has a record of them. */
-function ownEntries(envelope) {
-	const own = field(envelope, "own");
-	return isRecord(own) ? own : void 0;
+function kindNamed(world, name) {
+	return kindOf(world, name);
 }
-/** The most kinds in the memo of one world. A larger memo starts again, thus the types of the data cannot fill the memory. */
-const MAX_KINDS = 1e3;
-const kindMemos = /* @__PURE__ */ new WeakMap();
+/** A test that passes each name. A rung of `answerOf` then answers with each entry that it has. */
+const EACH_NAME = () => true;
 /**
-* This function gives the kind of a type for the ladder: `null` when the world does not have the kind. The result
-* depends only on the world and on the keys of the type, thus a memo for each world keeps it (PLAN.KIND-MEMO). A
-* world does not change after a plan or a resolution uses it, as for `worldThing`.
+* This function finds the evaluator of a verb without the record of the rungs. It visits the rungs of `ask` in the
+* same order: the own entry, then the kind, then the default of the world (VERB.LADDER). A plan without a trace,
+* `deref` and the walkers of steps use it, thus each verb has one ladder.
+*
+* @param world - The world, for its defaults.
+* @param own - The own entries of the document, when it has some.
+* @param kind - The kind of the document. `undefined` skips the kind rung, as for a value without a type. `null` is
+*   a kind that the world does not have: the question stops there, as in `ask`.
+* @param verb - The verb, for example `eval`, `format`, `deref` or `step`.
+* @param has - The test of a name. A rung answers only with a name that passes it. The default passes each name.
+* @returns The evaluator name and its rung, or `undefined` when no rung answers.
 */
-function kindFor(world, type) {
-	const keys = typeof type === "string" ? void 0 : typePath(type);
-	if (typeof type !== "string" && (keys === void 0 || keys.length === 0)) {
-		const found = lookupKind(world, type);
-		return found.ok ? found.kind : null;
-	}
+function answerOf(world, own, kind, verb, has = EACH_NAME) {
+	const ownName = entryOf$1(own, verb);
+	if (ownName !== void 0 && has(ownName)) return {
+		name: ownName,
+		rung: "own"
+	};
+	if (kind === null) return void 0;
+	const kindName = kind === void 0 ? void 0 : entryOf$1(kind.verbs, verb);
+	if (kindName !== void 0 && has(kindName)) return {
+		name: kindName,
+		rung: "kind"
+	};
+	const fallback = entryOf$1(world.defaults, verb);
+	return fallback !== void 0 && has(fallback) ? {
+		name: fallback,
+		rung: "default"
+	} : void 0;
+}
+/**
+* This function asks a document a question, and gives the evaluator that answers it.
+*
+* The question visits the rungs in order: the own entry of the envelope, then its kind, then the default of the
+* world. The type comes from the envelope, or else from the type that the position declares. The type is a
+* reference into the world. The ladder does not guess a type from the shape of a value. Each verb has this ladder:
+* `eval`, `deref`, `step` and each verb of a language (VERB.LADDER).
+*
+* @param world - The kinds and the defaults.
+* @param doc - The header of the document: an envelope, or `{}` for a bare value.
+* @param verb - The verb of the question, for example `eval` or `view`.
+* @param options - The type that the position declares.
+* @returns The answer, with the record of each rung that the question visited.
+*/
+function ask(world, doc, verb, options = {}) {
+	const steps = [];
+	const own = entryOf$1(doc.own, verb);
+	if (own !== void 0) {
+		steps.push({
+			rung: "own",
+			outcome: "answers",
+			evaluator: own
+		});
+		return {
+			verb,
+			evaluator: own,
+			rung: "own",
+			steps
+		};
+	}
+	steps.push({
+		rung: "own",
+		outcome: "no-entry"
+	});
+	const type = doc.type ?? options.declaredType;
+	if (type === void 0) steps.push({
+		rung: "kind",
+		outcome: "skipped"
+	});
+	else {
+		const source = doc.type === void 0 ? "container" : "document";
+		const name = typeName(type);
+		const kind = kindOf(world, type);
+		if (kind === void 0) {
+			steps.push({
+				rung: "kind",
+				outcome: "unknown-kind",
+				kind: name,
+				source
+			});
+			return {
+				verb,
+				error: "unknown-kind",
+				steps
+			};
+		}
+		const entry = entryOf$1(kind.verbs, verb);
+		if (entry !== void 0) {
+			steps.push({
+				rung: "kind",
+				outcome: "answers",
+				evaluator: entry,
+				kind: name,
+				source
+			});
+			return {
+				verb,
+				evaluator: entry,
+				rung: "kind",
+				steps
+			};
+		}
+		steps.push({
+			rung: "kind",
+			outcome: "no-entry",
+			kind: name,
+			source
+		});
+	}
+	const fallback = entryOf$1(world.defaults, verb);
+	if (fallback !== void 0) {
+		steps.push({
+			rung: "default",
+			outcome: "answers",
+			evaluator: fallback
+		});
+		return {
+			verb,
+			evaluator: fallback,
+			rung: "default",
+			steps
+		};
+	}
+	steps.push({
+		rung: "default",
+		outcome: "no-entry"
+	});
+	return {
+		verb,
+		error: "no-answer",
+		steps
+	};
+}
+// src/deref.ts
+/**
+* The brand of a host thing: an object of the host that answers the steps of a path itself. The brand is a
+* global symbol, thus two copies of the kernel in one program know the things of each other.
+*/
+const THING = /* @__PURE__ */ Symbol.for("coeval.thing");
+/**
+* This function tells if a thing is a host thing.
+*
+* @param thing - The thing.
+* @returns `true` for a host thing.
+*/
+function isHostThing(thing) {
+	return typeof thing === "object" && thing !== null && thing[THING] === true;
+}
+/** The roots of a context. Each path starts with one of them. */
+const ROOTS = [
+	"self",
+	"names",
+	"world",
+	"event",
+	"caps"
+];
+/** This function gives the own entries of an envelope, when it has a record of them. */
+function ownEntries(envelope) {
+	const own = field(envelope, "own");
+	return isRecord(own) ? own : void 0;
+}
+/** The most kinds in the memo of one world. A larger memo starts again, thus the types of the data cannot fill the memory. */
+const MAX_KINDS = 1e3;
+const kindMemos = /* @__PURE__ */ new WeakMap();
+/**
+* This function gives the kind of a type for the ladder: `null` when the world does not have the kind. The result
+* depends only on the world and on the keys of the type, thus a memo for each world keeps it (PLAN.KIND-MEMO). A
+* world does not change after a plan or a resolution uses it, as for `worldThing`.
+*/
+function kindFor(world, type) {
+	const keys = typeof type === "string" ? void 0 : typePath(type);
+	if (typeof type !== "string" && (keys === void 0 || keys.length === 0)) {
+		const found = lookupKind(world, type);
+		return found.ok ? found.kind : null;
+	}
 	let memo = kindMemos.get(world);
 	if (memo === void 0 || memo.size >= MAX_KINDS) {
 		memo = {
@@ -3119,847 +3214,447 @@ function plainStep(thing, key) {
 		const name = String(key);
 		return Object.hasOwn(thing, name) ? thing[name] : NOTHING;
 	}
-	return NOTHING;
-}
-/**
-* This function tells if a value can be an envelope by its field `type`. An envelope has its own field `type`, thus
-* a value without that field is not an envelope, and the full test is not necessary.
-*/
-function mayBeEnvelope(thing) {
-	return typeof thing === "object" && thing !== null && thing.type !== void 0;
-}
-/**
-* This function answers one step of a path on a thing, through the ladder of the verb `deref`. A host thing
-* answers for itself (own). A document asks its own entry, then its kind, then the default of the world
-* (VERB.LADDER). A rung answers only with a `deref` that the navigator has. When no rung answers, the step goes into
-* the value: an own field of an object, or an item of a list. A value without a type is data, thus the step goes
-* into it at once.
-*
-* @param nav - The world and the code of the evaluators.
-* @param thing - The thing that the path reached.
-* @param key - The key of the step.
-* @returns What the step reaches and the rung that answered, or `undefined` when it reaches nothing.
-*/
-function derefStep(nav, thing, key) {
-	if (isHostThing(thing)) {
-		const reached = thing.deref(key);
-		return reached !== void 0 || thing.has?.(key) === true ? {
-			thing: reached,
-			by: "own"
-		} : void 0;
-	}
-	if (nav.plain !== true && mayBeEnvelope(thing) && isEnvelope(thing)) {
-		const envelope = thing;
-		const derefs = nav.derefs;
-		const answer = derefs === void 0 ? void 0 : answerOf(nav.world, ownEntries(envelope), kindFor(nav.world, envelope.type), "deref", (name) => codeIn(derefs, name));
-		if (answer !== void 0) {
-			const code = derefs[answer.name];
-			const reached = code?.(envelope, key);
-			return reached !== void 0 || code?.has?.(envelope, key) === true ? {
-				thing: reached,
-				by: answer.rung
-			} : void 0;
-		}
-		const reached = plainStep(envelope.value, key);
-		return reached === NOTHING ? void 0 : {
-			thing: reached,
-			by: "default"
-		};
-	}
-	const reached = plainStep(thing, key);
-	return reached === NOTHING ? void 0 : {
-		thing: reached,
-		by: "default"
-	};
-}
-/**
-* This function tells if a thing is a reference document: an envelope of the type `ref` with a list for its path.
-*
-* @param thing - The thing.
-* @returns `true` for a reference document.
-*/
-function isRef(thing) {
-	if (typeof thing !== "object" || thing === null) return false;
-	const type = thing.type;
-	if (type === void 0 || typeof type === "string" && type !== "ref") return false;
-	if (!isEnvelope(thing) || !Array.isArray(thing.value)) return false;
-	const path = typePath(thing.type);
-	return path !== void 0 && path.length === 1 && path[0] === "ref";
-}
-const worlds = /* @__PURE__ */ new WeakMap();
-/**
-* This function makes the thing of the root `world`: the entries of the world as JSON. An alias is a reference
-* document in it, thus a walk through the world follows each alias (collapse). The thing of a world is made one
-* time.
-*
-* @param world - The world.
-* @returns The thing.
-*/
-function worldThing(world) {
-	let thing = worlds.get(world);
-	if (thing === void 0) {
-		thing = entriesAsJson(world.kinds);
-		worlds.set(world, thing);
-	}
-	return thing;
-}
-/**
-* This function makes a context. The world comes from the navigator when the call gives none.
-*
-* @param parts - The roots to set.
-* @returns The context.
-*/
-function context(parts = {}) {
-	return {
-		self: parts.self ?? null,
-		names: parts.names ?? {},
-		world: parts.world ?? null,
-		event: parts.event ?? null,
-		caps: parts.caps ?? []
-	};
-}
-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([]);
-/** A value that can be a reference document: a record with the type `ref`. The full check comes after. */
-function mayBeRef(thing) {
-	return typeof thing === "object" && thing !== null && thing.type === "ref";
-}
-/** This function tells if each step of a path from an index is a key. */
-function keysFrom(path, start) {
-	for (let index = start; index < path.length; index += 1) if (!isKey(path[index])) return false;
-	return true;
-}
-/** This function tells if a root has a value of its own for the short path: each root except `caps`. */
-function quickRoot(root) {
-	return root === "names" || root === "self" || root === "event" || root === "world";
-}
-/**
-* This function resolves the common path without a record of hops: a root, then keys. Plain values answer the
-* keys, or a host thing answers all of them in one call. It gives `undefined` when the path needs the full
-* algorithm. Examples are a host thing without `resolve`, an envelope, a reference to follow, a step document and a
-* failure of a step (for its exact reason).
-*/
-function resolveQuick(nav, ctx, path) {
-	const root = path[0];
-	if (!quickRoot(root)) return void 0;
-	if (nav.roots !== void 0 && !nav.roots.includes(root)) return void 0;
-	if (nav.adopt !== void 0) return void 0;
-	return walkQuick(ctx[root], path, nav.plain === true, false);
-}
-/**
-* This function walks the steps of the short path from the value of the root (DEREF.QUICK). `resolveQuick` and each
-* compiled path use it, thus the two cannot disagree. It gives `undefined` when the path needs the full algorithm.
-*
-* @param start - The value of the root.
-* @param path - The steps. The walk starts at the index 1.
-* @param plain - `true` for a plain navigation.
-* @param keyed - `true` when each step after the root is a key. The walk then does not test the steps again.
-*/
-function walkQuick(start, path, plain, keyed) {
-	let here = start;
-	for (let index = 1; index < path.length; index += 1) {
-		if (typeof here !== "object" || here === null) return void 0;
-		const type = plain ? void 0 : here.type;
-		if (type === "ref") return void 0;
-		if (here[THING] === true) {
-			const thing = here;
-			if (thing.resolve === void 0 || !(keyed || keysFrom(path, index))) return void 0;
-			const keys = path.slice(index);
-			const reached = thing.resolve(keys);
-			if (reached === void 0) return {
-				ok: false,
-				code: "#N/A",
-				reason: `The path ${keys.join(".")} reaches nothing.`,
-				hops: NO_HOPS$1
-			};
-			if (!plain && mayBeRef(reached.thing)) return void 0;
-			return {
-				ok: true,
-				thing: reached.thing,
-				hops: NO_HOPS$1
-			};
-		}
-		const step = path[index];
-		if (Array.isArray(here)) {
-			if (typeof step !== "number" || !Number.isInteger(step) || step < 0 || step >= here.length) return void 0;
-			here = here[step];
-			continue;
-		}
-		if (typeof step !== "string" || !Object.hasOwn(here, step)) return void 0;
-		if (type !== void 0 && isEnvelope(here)) return void 0;
-		here = here[step];
-	}
-	if (!plain && mayBeRef(here)) return void 0;
-	return {
-		ok: true,
-		thing: here,
-		hops: NO_HOPS$1
-	};
-}
-/** The root whose value starts the short path of a compiled path. `FULL` takes the full algorithm at once. */
-const FULL = 0;
-const FROM_NAMES = 1;
-const FROM_SELF = 2;
-const FROM_EVENT = 3;
-const FROM_WORLD = 4;
-/**
-* A compiled path as an object with fields (PLAN.LEAN). The code of `resolve` is on the class, thus each compiled path
-* keeps only its fields and makes no closure.
-*/
-var StaticPath = class {
-	constructor(path, nav, known, from, plain) {
-		this.path = path;
-		this.nav = nav;
-		this.known = known;
-		this.from = from;
-		this.plain = plain;
-	}
-	resolve(ctx) {
-		const from = this.from;
-		if (from !== FULL) {
-			const quick = walkQuick(from === FROM_NAMES ? ctx.names : from === FROM_WORLD ? ctx.world : from === FROM_SELF ? ctx.self : ctx.event, this.path, this.plain, true);
-			if (quick !== void 0) return quick;
-		}
-		return resolveFully$1(this.nav, ctx, this.path, void 0, this.known);
-	}
-};
-/**
-* This function compiles one static path for one navigator. The resolver gives the same thing, error and reason as
-* `resolve` without hops (PLAN.PATH-SAME). It keeps no value of a context.
-*
-* - Some paths take the full algorithm at once, because the short path cannot answer them. A path from `caps` or from
-*   a closed root is one. A path with a step document and each path of a navigator with `adopt` are others.
-* - Each other path walks the short path from its root, and it takes the full algorithm when the values need it.
-* - The walker of each step document comes from the ladder one time, here. The navigator and the step document do
-*   not change, thus the answer does not change either.
-*
-* An evaluator of a language calls this function in its `compile`, with the field `machine` of the input, and reads the
-* result with `resolveCompiled` (PLAN.PATH-EXPORT).
-*
-* @param nav - The navigator. A plan compiles its paths for its machine.
-* @param path - The steps. The first step is a root. The compiled path keeps this list, thus the host must not change it.
-* @returns The compiled path.
-*/
-function compilePath(nav, path) {
-	const keyed = keysFrom(path, 1);
-	return new StaticPath(path, nav, keyed ? void 0 : walkersOf(nav, path), startOf(nav, path, keyed), nav.plain === true);
-}
-/** This function gives the root that starts the short path of a compiled path, or `FULL`. */
-function startOf(nav, path, keyed) {
-	const root = path[0];
-	if (!keyed || !quickRoot(root) || nav.adopt !== void 0) return FULL;
-	if (nav.roots !== void 0 && !nav.roots.includes(root)) return FULL;
-	return root === "names" ? FROM_NAMES : root === "self" ? FROM_SELF : root === "event" ? FROM_EVENT : FROM_WORLD;
-}
-/**
-* This function asks the ladder of the verb `step` for each step document of a path. A step whose lookup throws
-* stays unknown, thus the full algorithm asks the ladder again for it.
-*/
-function walkersOf(nav, path) {
-	if (nav.walkers === void 0) return void 0;
-	const out = new Array(path.length);
-	for (let index = 1; index < path.length; index += 1) {
-		const step = path[index];
-		if (isKey(step)) continue;
-		try {
-			out[index] = walkerOf(nav, step) ?? null;
-		} catch {}
-	}
-	return out;
-}
-/**
-* This function resolves a path from a context, and records each hop.
-*
-* The first step is a root of the context. Each later step is a key or a step document. A key goes up the ladder
-* of the verb `deref` on the thing that the path reached. A step document is evaluated by the walker that the
-* ladder of the verb `step` gives, with the thing that the path reached. After each hop, a reference document is
-* followed until the path reaches something else (collapse), except in a plain navigation.
-*
-* The codes of a failure:
-*
-* - `#REF!`: the path has no root, or a root that is not open here.
-* - `#NAME?`: the root `names` has no such name.
-* - `#N/A`: a step reaches nothing.
-* - `#STEP?`: a step is not a key and not a step document.
-* - `#CYCLE!`: the references form a cycle, or the resolution follows more than 64 references. The reason tells
-*   which (DEREF.CHAIN-REASON).
-*
-* @param nav - The world and the code of the evaluators.
-* @param ctx - The context.
-* @param path - The steps.
-* @param options - `hops: false` does not record the hops.
-* @returns What the path reached and each hop, or an error.
-*/
-function resolve(nav, ctx, path, options = {}) {
-	if (options.hops === false) {
-		const quick = resolveQuick(nav, ctx, path);
-		if (quick !== void 0) return quick;
-	}
-	return resolveFully$1(nav, ctx, path, options.hops === false ? void 0 : [], void 0);
-}
-/** The functions of the last navigator that gave a walker its input. A walk with the same navigator makes no new functions. */
-let lastSteps;
-/**
-* This function gives the functions `deref` and `has` of the input of a walker. They depend only on the navigator,
-* thus the function keeps the functions of the last navigator (K170).
-*/
-function walkSteps(nav) {
-	if (lastSteps !== void 0 && lastSteps.nav === nav) return lastSteps;
-	const adopt = nav.adopt;
-	lastSteps = {
-		nav,
-		deref: adopt === void 0 ? (thing, key) => derefStep(nav, thing, key)?.thing : (thing, key) => {
-			const reached = derefStep(nav, thing, key);
-			return reached === void 0 ? void 0 : adopt(reached.thing);
-		},
-		has: (thing, key) => derefStep(nav, thing, key) !== void 0
-	};
-	return lastSteps;
-}
-/**
-* This function resolves a path with the full algorithm of `resolve`.
-*
-* @param nav - The world and the code of the evaluators.
-* @param ctx - The context.
-* @param path - The steps.
-* @param hops - The list that gets each hop, or `undefined` for no record.
-* @param known - The walker of each step document of the path, from `compilePath`. A reference that a step reaches has its own steps, and the ladder answers them.
-* @returns What the path reached and each hop, or an error.
-*/
-function resolveFully$1(nav, ctx, path, hops, known) {
-	const done = hops ?? NO_HOPS$1;
-	const failed = (code, reason) => ({
-		ok: false,
-		code,
-		reason,
-		hops: done
-	});
-	let collapses = 0;
-	let open;
-	const adopt = nav.adopt ?? ((value) => value);
-	const collapse = (thing) => {
-		let here = thing;
-		if (nav.plain === true) return {
-			ok: true,
-			thing: here,
-			hops: done
-		};
-		while (isRef(here)) {
-			if (open?.includes(here) === true) return failed("#CYCLE!", "The references form a cycle.");
-			collapses += 1;
-			if (collapses > MAX_COLLAPSE$1) return failed("#CYCLE!", CHAIN_REASON);
-			open ??= [];
-			open.push(here);
-			const inner = walk(here.value, void 0);
-			open.pop();
-			if (!inner.ok) return inner;
-			here = adopt(inner.thing);
-			hops?.push({
-				step: "collapse",
-				thing: here,
-				by: "collapse"
-			});
-		}
-		return {
-			ok: true,
-			thing: here,
-			hops: done
-		};
-	};
-	const walk = (steps, walkers) => {
-		const root = steps[0];
-		if (typeof root !== "string" || !ROOTS.includes(root)) return failed("#REF!", `A path starts with a root: ${ROOTS.join(", ")}.`);
-		if (nav.roots !== void 0 && !nav.roots.includes(root)) return failed("#REF!", `The root ${root} is not open here. The open roots are ${nav.roots.join(", ")}.`);
-		let here = adopt(ctx[root]);
-		hops?.push({
-			step: root,
-			thing: here,
-			by: "root"
-		});
-		const first = collapse(here);
-		if (!first.ok) return first;
-		here = first.thing;
-		for (let index = 1; index < steps.length; index += 1) {
-			const step = steps[index];
-			if (isHostThing(here) && here.resolve !== void 0 && keysFrom(steps, index)) {
-				const keys = steps.slice(index);
-				const reached = here.resolve(keys);
-				if (reached === void 0) return failed("#N/A", `The path ${keys.join(".")} reaches nothing.`);
-				const thing = adopt(reached.thing);
-				hops?.push({
-					step: keys,
-					thing,
-					by: "own"
-				});
-				return collapse(thing);
-			}
-			if (isKey(step)) {
-				const reached = derefStep(nav, here, step);
-				if (reached === 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(reached.thing);
-				hops?.push({
-					step,
-					thing: here,
-					by: reached.by
-				});
-			} else {
-				const given = walkers?.[index];
-				const walker = given === void 0 ? walkerOf(nav, step) : given ?? void 0;
-				if (walker === void 0) return failed("#STEP?", "A step is a key, or a document of a kind with the verb step.");
-				const envelope = step;
-				const { deref, has } = walkSteps(nav);
-				const result = walker(hops === void 0 ? {
-					data: envelope.value,
-					here,
-					context: ctx,
-					deref,
-					has
-				} : {
-					data: envelope.value,
-					here,
-					context: ctx,
-					deref,
-					has,
-					visit: (key, thing) => hops.push({
-						step: key,
-						thing,
-						by: "step"
-					})
-				});
-				if (!result.ok) return failed(result.code ?? "#N/A", result.reason);
-				here = adopt(result.thing);
-				hops?.push({
-					step: envelope,
-					thing: here,
-					by: "step"
-				});
-			}
-			const next = collapse(here);
-			if (!next.ok) return next;
-			here = next.thing;
-		}
-		return {
-			ok: true,
-			thing: here,
-			hops: done
-		};
-	};
-	if (path.length === 0) return failed("#REF!", "A path has at least one step: its root.");
-	return walk(path, known);
+	return NOTHING;
 }
 /**
-* This function gives the value of a thing: the value that a host thing gives, or else the thing itself.
-*
-* @param thing - The thing.
-* @returns The value.
+* This function tells if a value can be an envelope by its field `type`. An envelope has its own field `type`, thus
+* a value without that field is not an envelope, and the full test is not necessary.
 */
-function valueOfThing(thing) {
-	return isHostThing(thing) ? thing.toJson() : thing;
-}
-// src/classify.ts
-function isStrictSuperset(larger, smaller) {
-	return larger.length > smaller.length && smaller.every((name) => larger.includes(name));
+function mayBeEnvelope(thing) {
+	return typeof thing === "object" && thing !== null && thing.type !== void 0;
 }
 /**
-* This function proposes a kind for a value without a type, from the fields that the value has.
-* A shape applies when the value has each field of the shape. The most specific shapes are the ones that
-* no other applicable shape contains. A host uses a classifier when data comes in, and then tags the data.
-* The ladder does not call a classifier.
+* This function answers one step of a path on a thing, through the ladder of the verb `deref`. A host thing
+* answers for itself (own). A document asks its own entry, then its kind, then the default of the world
+* (VERB.LADDER). A rung answers only with a `deref` that the navigator has. When no rung answers, the step goes into
+* the value: an own field of an object, or an item of a list. A value without a type is data, thus the step goes
+* into it at once.
 *
-* @param shapes - The shapes to examine.
-* @param value - The value without a type.
-* @returns The proposed kind, or an error with the candidates.
+* @param nav - The world and the code of the evaluators.
+* @param thing - The thing that the path reached.
+* @param key - The key of the step.
+* @returns What the step reaches and the rung that answered, or `undefined` when it reaches nothing.
 */
-function classify(shapes, value) {
-	const applicable = isRecord(value) ? shapes.filter((shape) => shape.fields.every((name) => field(value, name) !== void 0)) : [];
-	const best = applicable.filter((shape) => !applicable.some((other) => isStrictSuperset(other.fields, shape.fields)));
-	const candidates = best.map((shape) => shape.name);
-	const only = best.length === 1 ? best[0] : void 0;
-	if (only !== void 0) return {
-		kind: only.kind,
-		candidates
-	};
-	return {
-		candidates,
-		error: best.length === 0 ? "no-match" : "ambiguous"
+function derefStep(nav, thing, key) {
+	if (isHostThing(thing)) {
+		const reached = thing.deref(key);
+		return reached !== void 0 || thing.has?.(key) === true ? {
+			thing: reached,
+			by: "own"
+		} : void 0;
+	}
+	if (nav.plain !== true && mayBeEnvelope(thing) && isEnvelope(thing)) {
+		const envelope = thing;
+		const derefs = nav.derefs;
+		const answer = derefs === void 0 ? void 0 : answerOf(nav.world, ownEntries(envelope), kindFor(nav.world, envelope.type), "deref", (name) => codeIn(derefs, name));
+		if (answer !== void 0) {
+			const code = derefs[answer.name];
+			const reached = code?.(envelope, key);
+			return reached !== void 0 || code?.has?.(envelope, key) === true ? {
+				thing: reached,
+				by: answer.rung
+			} : void 0;
+		}
+		const reached = plainStep(envelope.value, key);
+		return reached === NOTHING ? void 0 : {
+			thing: reached,
+			by: "default"
+		};
+	}
+	const reached = plainStep(thing, key);
+	return reached === NOTHING ? void 0 : {
+		thing: reached,
+		by: "default"
 	};
 }
 /**
-* This function puts a value in an envelope with a type. The value does not change.
+* This function tells if a thing is a reference document: an envelope of the type `ref` with a list for its path.
 *
-* @param value - The value.
-* @param kind - The name of the kind.
-* @returns The envelope.
+* @param thing - The thing.
+* @returns `true` for a reference document.
 */
-function tag(value, kind) {
-	return typed(kind, value);
+function isRef(thing) {
+	if (typeof thing !== "object" || thing === null) return false;
+	const type = thing.type;
+	if (type === void 0 || typeof type === "string" && type !== "ref") return false;
+	if (!isEnvelope(thing) || !Array.isArray(thing.value)) return false;
+	const path = typePath(thing.type);
+	return path !== void 0 && path.length === 1 && path[0] === "ref";
 }
-// src/parts.ts
-var Bad$1 = class {
-	reason;
-	at;
-	constructor(reason, at) {
-		this.reason = reason;
-		this.at = at;
+const worlds = /* @__PURE__ */ new WeakMap();
+/**
+* This function makes the thing of the root `world`: the entries of the world as JSON. An alias is a reference
+* document in it, thus a walk through the world follows each alias (collapse). The thing of a world is made one
+* time.
+*
+* @param world - The world.
+* @returns The thing.
+*/
+function worldThing(world) {
+	let thing = worlds.get(world);
+	if (thing === void 0) {
+		thing = entriesAsJson(world.kinds);
+		worlds.set(world, thing);
 	}
-};
-/** This function sets an own data property. Only the key `__proto__` needs `defineProperty`. */
-function setOwn$4(target, key, value) {
-	if (key === "__proto__") Object.defineProperty(target, key, {
-		value,
-		enumerable: true,
-		writable: true,
-		configurable: true
-	});
-	else target[key] = value;
-}
-const NO_SLOTS = /* @__PURE__ */ Object.freeze([]);
-function hasSlots(template) {
-	return template.t !== "data";
-}
-/** This function gives the shape of a part with the default type `of` and the value type `expect` of its container. */
-function termOf$1(of, expect) {
-	return {
-		shape: "term",
-		...of === void 0 ? {} : { of },
-		...expect === void 0 ? {} : { expect }
-	};
-}
-/** This function tells if a shape holds only data: no value of the shape can hold a part. */
-function isData(shape) {
-	return shape.shape === "none" || shape.shape === "text" || shape.shape === "number" || shape.shape === "one";
-}
-/** This function gives the reason why a value is not data of a shape, or `undefined` when it is. */
-function dataFault(spec, item) {
-	if (spec.shape === "text") return typeof item === "string" ? void 0 : "The value must be a text.";
-	if (spec.shape === "one") return spec.values.some((value) => docEquals(value, item)) ? void 0 : `The value must be one of ${JSON.stringify(spec.values)}.`;
-	if (typeof item !== "number") return "The value must be a number.";
-	if (spec.whole === true && !Number.isInteger(item)) return "The value must be a whole number.";
-	if (spec.min !== void 0 && !(item >= spec.min)) return `The value must be ${String(spec.min)} or more.`;
-	if (spec.max !== void 0 && !(item <= spec.max)) return `The value must be ${String(spec.max)} or less.`;
-}
-/** This function stops a split when a part has a type that its position does not permit. */
-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$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);
+	return thing;
 }
 /**
-* This function splits a value into its parts, by the shape that its kind declares. The evaluator, the view and
-* the static kit use the same split, thus each one sees the same parts.
+* This function makes a context. The world comes from the navigator when the call gives none.
 *
-* @param shape - The shape of the value. The default is data.
-* @param value - The value of the document.
-* @returns The parts and a way to fill their places, or the reason why the value does not have the shape.
+* @param parts - The roots to set.
+* @returns The context.
 */
-function splitParts(shape, value) {
-	if (shape === void 0 || shape.shape === "none") return {
-		ok: true,
-		parts: NO_SLOTS,
-		data: value,
-		fill: () => value
-	};
-	const parts = [];
-	const slot = (item, path, of, address = false, expect) => {
-		parts.push({
-			path,
-			key: path.join("."),
-			item,
-			...of === void 0 ? {} : { of },
-			...address ? { address: true } : {},
-			...expect === void 0 ? {} : { expect }
-		});
-		return {
-			t: "slot",
-			index: parts.length - 1
-		};
-	};
-	const deep = (item, path, of, expect) => {
-		if (isEnvelope(item)) return slot(item, path, of, false, expect);
-		if (Array.isArray(item)) {
-			const items = item.map((child, index) => deep(child, [...path, index], of, expect));
-			return items.some(hasSlots) ? {
-				t: "list",
-				items
-			} : {
-				t: "data",
-				value: item
-			};
-		}
-		if (isRecord(item)) {
-			const fields = Object.keys(item).map((key) => [key, deep(item[key], [...path, key], of, expect)]);
-			return fields.some(([, child]) => hasSlots(child)) ? {
-				t: "record",
-				fields
-			} : {
-				t: "data",
-				value: item
-			};
-		}
-		return {
-			t: "data",
-			value: item
-		};
+function context(parts = {}) {
+	return {
+		self: parts.self ?? null,
+		names: parts.names ?? {},
+		world: parts.world ?? null,
+		event: parts.event ?? null,
+		caps: parts.caps ?? []
 	};
-	const walk = (spec, item, path) => {
-		if (spec === void 0 || spec.shape === "none") return {
-			t: "data",
-			value: item
-		};
-		if (spec.shape === "text" || spec.shape === "number" || spec.shape === "one") {
-			const reason = dataFault(spec, item);
-			if (reason !== void 0) throw new Bad$1(reason, path);
-			return {
-				t: "data",
-				value: item
-			};
-		}
-		if (spec.shape === "term") {
-			if (spec.kinds !== void 0) kindFault(spec.kinds, item, spec.of, path);
-			return slot(item, path, spec.of, spec.address === true, spec.expect);
-		}
-		if (spec.shape === "deep") return deep(item, path, spec.of, spec.expect);
-		if (spec.shape === "list") {
-			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$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]));
-			return isData(each) ? {
-				t: "data",
-				value: item
-			} : {
-				t: "list",
-				items
+}
+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([]);
+/** A value that can be a reference document: a record with the type `ref`. The full check comes after. */
+function mayBeRef(thing) {
+	return typeof thing === "object" && thing !== null && thing.type === "ref";
+}
+/** This function tells if each step of a path from an index is a key. */
+function keysFrom(path, start) {
+	for (let index = start; index < path.length; index += 1) if (!isKey(path[index])) return false;
+	return true;
+}
+/** This function tells if a root has a value of its own for the short path: each root except `caps`. */
+function quickRoot(root) {
+	return root === "names" || root === "self" || root === "event" || root === "world";
+}
+/**
+* This function resolves the common path without a record of hops: a root, then keys. Plain values answer the
+* keys, or a host thing answers all of them in one call. It gives `undefined` when the path needs the full
+* algorithm. Examples are a host thing without `resolve`, an envelope, a reference to follow, a step document and a
+* failure of a step (for its exact reason).
+*/
+function resolveQuick(nav, ctx, path) {
+	const root = path[0];
+	if (!quickRoot(root)) return void 0;
+	if (nav.roots !== void 0 && !nav.roots.includes(root)) return void 0;
+	if (nav.adopt !== void 0) return void 0;
+	return walkQuick(ctx[root], path, nav.plain === true, false);
+}
+/**
+* This function walks the steps of the short path from the value of the root (DEREF.QUICK). `resolveQuick` and each
+* compiled path use it, thus the two cannot disagree. It gives `undefined` when the path needs the full algorithm.
+*
+* @param start - The value of the root.
+* @param path - The steps. The walk starts at the index 1.
+* @param plain - `true` for a plain navigation.
+* @param keyed - `true` when each step after the root is a key. The walk then does not test the steps again.
+*/
+function walkQuick(start, path, plain, keyed) {
+	let here = start;
+	for (let index = 1; index < path.length; index += 1) {
+		if (typeof here !== "object" || here === null) return void 0;
+		const type = plain ? void 0 : here.type;
+		if (type === "ref") return void 0;
+		if (here[THING] === true) {
+			const thing = here;
+			if (thing.resolve === void 0 || !(keyed || keysFrom(path, index))) return void 0;
+			const keys = path.slice(index);
+			const reached = thing.resolve(keys);
+			if (reached === void 0) return {
+				ok: false,
+				code: "#N/A",
+				reason: `The path ${keys.join(".")} reaches nothing.`,
+				hops: NO_HOPS$1
 			};
-		}
-		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);
+			if (!plain && mayBeRef(reached.thing)) return void 0;
 			return {
-				t: "record",
-				fields: Object.keys(item).map((key) => [key, walk(each, item[key], [...path, key])])
+				ok: true,
+				thing: reached.thing,
+				hops: NO_HOPS$1
 			};
 		}
-		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$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])]);
+		const step = path[index];
+		if (Array.isArray(here)) {
+			if (typeof step !== "number" || !Number.isInteger(step) || step < 0 || step >= here.length) return void 0;
+			here = here[step];
+			continue;
 		}
-		return {
-			t: "record",
-			fields
-		};
-	};
-	let template;
-	try {
-		template = walk(shape, value, []);
-	} catch (error) {
-		if (error instanceof Bad$1) return {
-			ok: false,
-			reason: error.reason,
-			at: error.at
-		};
-		throw error;
+		if (typeof step !== "string" || !Object.hasOwn(here, step)) return void 0;
+		if (type !== void 0 && isEnvelope(here)) return void 0;
+		here = here[step];
 	}
-	const strip = (node) => {
-		if (node.t === "data") return node.value;
-		if (node.t === "slot") return void 0;
-		if (node.t === "list") return node.items.every((child) => child.t === "slot") ? null : node.items.map((child) => strip(child) ?? null);
-		const out = {};
-		for (const [key, child] of node.fields) {
-			const kept = strip(child);
-			if (kept !== void 0) setOwn$4(out, key, kept);
-		}
-		return out;
-	};
-	const fillWith = (node, handles) => {
-		if (node.t === "data") return node.value;
-		if (node.t === "slot") return handles[node.index];
-		if (node.t === "list") return node.items.map((child) => fillWith(child, handles));
-		const out = {};
-		for (const [key, child] of node.fields) setOwn$4(out, key, fillWith(child, handles));
-		return out;
-	};
+	if (!plain && mayBeRef(here)) return void 0;
 	return {
 		ok: true,
-		parts,
-		data: strip(template) ?? null,
-		fill: (handles) => fillWith(template, handles)
+		thing: here,
+		hops: NO_HOPS$1
 	};
 }
+/** The root whose value starts the short path of a compiled path. `FULL` takes the full algorithm at once. */
+const FULL = 0;
+const FROM_NAMES = 1;
+const FROM_SELF = 2;
+const FROM_EVENT = 3;
+const FROM_WORLD = 4;
 /**
-* This function reads one document by the contracts of the world. It finds the kind of the type. A bare value gets
-* the type that its position declares. Then the function splits the value by the shape of the kind. The plan, the
-* reference interpreter and the static kit read each document with this function. Thus they see the same parts.
-*
-* @param world - The world of the kinds.
-* @param value - The document, or a bare value.
-* @param declaredType - The type that the position of a bare value declares.
-* @returns The document, its kind and its parts, or the reason why the value is not a document.
+* A compiled path as an object with fields (PLAN.LEAN). The code of `resolve` is on the class, thus each compiled path
+* keeps only its fields and makes no closure.
 */
-function partsOf(world, value, declaredType) {
-	const envelope = isEnvelope(value) ? value : void 0;
-	if (envelope === void 0 && declaredType === void 0) return {
-		ok: false,
-		code: "#PART?",
-		reason: "The value has no envelope, and its position declares no type."
-	};
-	const doc = envelope ?? {
-		type: declaredType,
-		value
-	};
-	const found = lookupKind(world, doc.type);
-	const kind = found.ok ? found.kind : void 0;
-	const split = splitParts(kind?.parts, doc.value);
-	const typePath = found.ok ? found.path : void 0;
-	if (split.ok) return {
-		ok: true,
-		doc,
-		declared: envelope === void 0,
-		kind,
-		typePath,
-		split
-	};
-	const where = split.at.length === 0 ? "" : ` (at ${split.at.join(".")})`;
-	const reason = `${split.reason}${where} The kind is ${typeName(doc.type)}.`;
-	return {
-		ok: true,
-		doc,
-		declared: envelope === void 0,
-		kind,
-		typePath,
-		split: {
-			ok: false,
-			reason,
-			at: split.at
+var StaticPath = class {
+	constructor(path, nav, known, from, plain) {
+		this.path = path;
+		this.nav = nav;
+		this.known = known;
+		this.from = from;
+		this.plain = plain;
+	}
+	resolve(ctx) {
+		const from = this.from;
+		if (from !== FULL) {
+			const quick = walkQuick(from === FROM_NAMES ? ctx.names : from === FROM_WORLD ? ctx.world : from === FROM_SELF ? ctx.self : ctx.event, this.path, this.plain, true);
+			if (quick !== void 0) return quick;
 		}
-	};
-}
+		return resolveFully$1(this.nav, ctx, this.path, void 0, this.known);
+	}
+};
 /**
-* This function tells if the path of a part matches a pattern of a scope rule. The key `"*"` of a pattern matches
-* each key.
+* This function compiles one static path for one navigator. The resolver gives the same thing, error and reason as
+* `resolve` without hops (PLAN.PATH-SAME). It keeps no value of a context.
 *
-* @param path - The path of the part.
-* @param pattern - The pattern.
-* @returns `true` when the path matches.
+* - Some paths take the full algorithm at once, because the short path cannot answer them. A path from `caps` or from
+*   a closed root is one. A path with a step document and each path of a navigator with `adopt` are others.
+* - Each other path walks the short path from its root, and it takes the full algorithm when the values need it.
+* - The walker of each step document comes from the ladder one time, here. The navigator and the step document do
+*   not change, thus the answer does not change either.
+*
+* An evaluator of a language calls this function in its `compile`, with the field `machine` of the input, and reads the
+* result with `resolveCompiled` (PLAN.PATH-EXPORT).
+*
+* @param nav - The navigator. A plan compiles its paths for its machine.
+* @param path - The steps. The first step is a root. The compiled path keeps this list, thus the host must not change it.
+* @returns The compiled path.
 */
-function pathMatches(path, pattern) {
-	if (path.length !== pattern.length) return false;
-	for (let index = 0; index < path.length; index += 1) {
-		const want = pattern[index];
-		if (want !== "*" && String(want) !== String(path[index])) return false;
+function compilePath(nav, path) {
+	const keyed = keysFrom(path, 1);
+	return new StaticPath(path, nav, keyed ? void 0 : walkersOf(nav, path), startOf(nav, path, keyed), nav.plain === true);
+}
+/** This function gives the root that starts the short path of a compiled path, or `FULL`. */
+function startOf(nav, path, keyed) {
+	const root = path[0];
+	if (!keyed || !quickRoot(root) || nav.adopt !== void 0) return FULL;
+	if (nav.roots !== void 0 && !nav.roots.includes(root)) return FULL;
+	return root === "names" ? FROM_NAMES : root === "self" ? FROM_SELF : root === "event" ? FROM_EVENT : FROM_WORLD;
+}
+/**
+* This function asks the ladder of the verb `step` for each step document of a path. A step whose lookup throws
+* stays unknown, thus the full algorithm asks the ladder again for it.
+*/
+function walkersOf(nav, path) {
+	if (nav.walkers === void 0) return void 0;
+	const out = new Array(path.length);
+	for (let index = 1; index < path.length; index += 1) {
+		const step = path[index];
+		if (isKey(step)) continue;
+		try {
+			out[index] = walkerOf(nav, step) ?? null;
+		} catch {}
 	}
-	return true;
+	return out;
 }
 /**
-* This function tells if a list of rules in the form of the lazy rules covers a part (D24, D119). A rule without
-* `in` covers each part. With `after: n`, a rule covers only the parts after the first `n` parts that it matches.
+* This function resolves a path from a context, and records each hop.
 *
-* @param rules - The rules.
-* @param shape - The shape of the parts of the parent.
-* @param value - The value of the parent.
-* @param slot - The path of the part in the value.
-* @returns `true` when a rule covers the part.
+* The first step is a root of the context. Each later step is a key or a step document. A key goes up the ladder
+* of the verb `deref` on the thing that the path reached. A step document is evaluated by the walker that the
+* ladder of the verb `step` gives, with the thing that the path reached. After each hop, a reference document is
+* followed until the path reaches something else (collapse), except in a plain navigation.
+*
+* The codes of a failure:
+*
+* - `#REF!`: the path has no root, or a root that is not open here.
+* - `#NAME?`: the root `names` has no such name.
+* - `#N/A`: a step reaches nothing.
+* - `#STEP?`: a step is not a key and not a step document.
+* - `#CYCLE!`: the references form a cycle, or the resolution follows more than 64 references. The reason tells
+*   which (DEREF.CHAIN-REASON).
+*
+* @param nav - The world and the code of the evaluators.
+* @param ctx - The context.
+* @param path - The steps.
+* @param options - `hops: false` does not record the hops.
+* @returns What the path reached and each hop, or an error.
 */
-function rulesCover(rules, shape, value, slot) {
-	for (const rule of rules) {
-		if (rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(slot, pattern))) continue;
-		const after = rule.after ?? 0;
-		if (after <= 0) return true;
-		const split = splitParts(shape, value);
-		let count = 0;
-		for (const part of split.ok ? split.parts : []) {
-			if (rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(part.path, pattern))) continue;
-			if (part.path.length === slot.length && pathMatches(part.path, slot)) {
-				if (count >= after) return true;
-				break;
-			}
-			count += 1;
-		}
+function resolve(nav, ctx, path, options = {}) {
+	if (options.hops === false) {
+		const quick = resolveQuick(nav, ctx, path);
+		if (quick !== void 0) return quick;
 	}
-	return false;
-}
-function valueAt(value, path) {
-	let here = value;
-	for (const key of path) if (Array.isArray(here)) here = here[Number(key)];
-	else if (isRecord(here) && Object.hasOwn(here, String(key))) here = here[String(key)];
-	else return void 0;
-	return here;
-}
-function headerName(item) {
-	return isEnvelope(item) && typeof item.name === "string" ? item.name : void 0;
+	return resolveFully$1(nav, ctx, path, options.hops === false ? void 0 : [], void 0);
 }
-function namesOf(source, value, covered) {
-	if ("fixed" in source) return source.fixed;
-	if ("keysAt" in source) {
-		const at = valueAt(value, source.keysAt);
-		return isRecord(at) ? Object.keys(at) : [];
-	}
-	if ("listAt" in source) {
-		const at = valueAt(value, source.listAt);
-		return Array.isArray(at) ? at.filter((item) => typeof item === "string") : [];
-	}
-	if ("textAt" in source) {
-		const at = valueAt(value, source.textAt);
-		if (typeof at === "string") return [at];
-		return source.otherwise === void 0 ? [] : [source.otherwise];
-	}
-	return covered.map((slot) => headerName(slot.item)).filter((name) => name !== void 0);
+/** The functions of the last navigator that gave a walker its input. A walk with the same navigator makes no new functions. */
+let lastSteps;
+/**
+* This function gives the functions `deref` and `has` of the input of a walker. They depend only on the navigator,
+* thus the function keeps the functions of the last navigator (K170).
+*/
+function walkSteps(nav) {
+	if (lastSteps !== void 0 && lastSteps.nav === nav) return lastSteps;
+	const adopt = nav.adopt;
+	lastSteps = {
+		nav,
+		deref: adopt === void 0 ? (thing, key) => derefStep(nav, thing, key)?.thing : (thing, key) => {
+			const reached = derefStep(nav, thing, key);
+			return reached === void 0 ? void 0 : adopt(reached.thing);
+		},
+		has: (thing, key) => derefStep(nav, thing, key) !== void 0
+	};
+	return lastSteps;
 }
 /**
-* This function gives the names that the scope rules of a kind give each part, and the names that only later parts
-* see. `check`, `conforms` and the plan read the scope rules with it.
+* This function resolves a path with the full algorithm of `resolve`.
 *
-* @param rules - The scope rules of the kind.
-* @param value - The value of the document.
-* @param slots - The parts of the value, in order.
-* @returns The names that each part sees, and the names that only the later parts see, by the index of the part.
+* @param nav - The world and the code of the evaluators.
+* @param ctx - The context.
+* @param path - The steps.
+* @param hops - The list that gets each hop, or `undefined` for no record.
+* @param known - The walker of each step document of the path, from `compilePath`. A reference that a step reaches has its own steps, and the ladder answers them.
+* @returns What the path reached and each hop, or an error.
 */
-function scopesOf(rules, value, slots) {
-	const sees = slots.map(() => []);
-	const later = slots.map(() => []);
-	for (const rule of rules ?? []) {
-		const covered = slots.map((slot, index) => ({
-			slot,
-			index
-		})).filter(({ slot }) => rule.in.some((pattern) => pathMatches(slot.path, pattern)));
-		if (rule.sequential !== true) {
-			const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
-			for (const { index } of covered) sees[index]?.push(...names);
-			continue;
-		}
-		if ("headers" in rule.names) {
-			covered.forEach(({ index }, position) => {
-				const before = covered.slice(0, position).map(({ slot }) => headerName(slot.item)).filter((name) => name !== void 0);
-				const after = covered.slice(position).map(({ slot }) => headerName(slot.item)).filter((name) => name !== void 0);
-				sees[index]?.push(...before);
-				later[index]?.push(...after);
+function resolveFully$1(nav, ctx, path, hops, known) {
+	const done = hops ?? NO_HOPS$1;
+	const failed = (code, reason) => ({
+		ok: false,
+		code,
+		reason,
+		hops: done
+	});
+	let collapses = 0;
+	let open;
+	const adopt = nav.adopt ?? ((value) => value);
+	const collapse = (thing) => {
+		let here = thing;
+		if (nav.plain === true) return {
+			ok: true,
+			thing: here,
+			hops: done
+		};
+		while (isRef(here)) {
+			if (open?.includes(here) === true) return failed("#CYCLE!", "The references form a cycle.");
+			collapses += 1;
+			if (collapses > MAX_COLLAPSE$1) return failed("#CYCLE!", CHAIN_REASON);
+			open ??= [];
+			open.push(here);
+			const inner = walk(here.value, void 0);
+			open.pop();
+			if (!inner.ok) return inner;
+			here = adopt(inner.thing);
+			hops?.push({
+				step: "collapse",
+				thing: here,
+				by: "collapse"
 			});
-			continue;
 		}
-		const names = namesOf(rule.names, value, covered.map(({ slot }) => slot));
-		covered.forEach(({ index }, position) => {
-			if (position > 0) sees[index]?.push(...names);
-			else later[index]?.push(...names);
+		return {
+			ok: true,
+			thing: here,
+			hops: done
+		};
+	};
+	const walk = (steps, walkers) => {
+		const root = steps[0];
+		if (typeof root !== "string" || !ROOTS.includes(root)) return failed("#REF!", `A path starts with a root: ${ROOTS.join(", ")}.`);
+		if (nav.roots !== void 0 && !nav.roots.includes(root)) return failed("#REF!", `The root ${root} is not open here. The open roots are ${nav.roots.join(", ")}.`);
+		let here = adopt(ctx[root]);
+		hops?.push({
+			step: root,
+			thing: here,
+			by: "root"
 		});
-	}
-	return {
-		sees,
-		later
+		const first = collapse(here);
+		if (!first.ok) return first;
+		here = first.thing;
+		for (let index = 1; index < steps.length; index += 1) {
+			const step = steps[index];
+			if (isHostThing(here) && here.resolve !== void 0 && keysFrom(steps, index)) {
+				const keys = steps.slice(index);
+				const reached = here.resolve(keys);
+				if (reached === void 0) return failed("#N/A", `The path ${keys.join(".")} reaches nothing.`);
+				const thing = adopt(reached.thing);
+				hops?.push({
+					step: keys,
+					thing,
+					by: "own"
+				});
+				return collapse(thing);
+			}
+			if (isKey(step)) {
+				const reached = derefStep(nav, here, step);
+				if (reached === 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(reached.thing);
+				hops?.push({
+					step,
+					thing: here,
+					by: reached.by
+				});
+			} else {
+				const given = walkers?.[index];
+				const walker = given === void 0 ? walkerOf(nav, step) : given ?? void 0;
+				if (walker === void 0) return failed("#STEP?", "A step is a key, or a document of a kind with the verb step.");
+				const envelope = step;
+				const { deref, has } = walkSteps(nav);
+				const result = walker(hops === void 0 ? {
+					data: envelope.value,
+					here,
+					context: ctx,
+					deref,
+					has
+				} : {
+					data: envelope.value,
+					here,
+					context: ctx,
+					deref,
+					has,
+					visit: (key, thing) => hops.push({
+						step: key,
+						thing,
+						by: "step"
+					})
+				});
+				if (!result.ok) return failed(result.code ?? "#N/A", result.reason);
+				here = adopt(result.thing);
+				hops?.push({
+					step: envelope,
+					thing: here,
+					by: "step"
+				});
+			}
+			const next = collapse(here);
+			if (!next.ok) return next;
+			here = next.thing;
+		}
+		return {
+			ok: true,
+			thing: here,
+			hops: done
+		};
 	};
+	if (path.length === 0) return failed("#REF!", "A path has at least one step: its root.");
+	return walk(path, known);
+}
+/**
+* This function gives the value of a thing: the value that a host thing gives, or else the thing itself.
+*
+* @param thing - The thing.
+* @returns The value.
+*/
+function valueOfThing(thing) {
+	return isHostThing(thing) ? thing.toJson() : thing;
 }
 // src/evaluate.ts
 /**
@@ -4325,6 +4020,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 +4167,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 +4194,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). An entry is a point with no application of a closure that runs, on any runtime of the evaluation.
+	*
+	* @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 && (root.active ?? 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 +4838,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 +4849,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 +4923,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 +4992,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 +5328,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 +5337,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 +5503,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 +5553,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;
+		});
 	}
 };
 /**
@@ -5841,102 +5600,447 @@ function record(s, result) {
 	};
 }
 /**
-* This function evaluates a document, and records each evaluation in a trace.
-*
-* The verb of the options goes up the ladder for each document. The default verb is `eval`. The kind of the document
-* tells where its parts are. The evaluator gets each part sealed: it can evaluate the part, and it cannot read its
-* value.
-*
-* A failure gives an error value, and the function does not throw. The function records each effect in its order,
-* and the host does not do it. A mock can answer each effect at once (RUN.MOCK).
+* This function evaluates a document, and records each evaluation in a trace.
+*
+* The verb of the options goes up the ladder for each document. The default verb is `eval`. The kind of the document
+* tells where its parts are. The evaluator gets each part sealed: it can evaluate the part, and it cannot read its
+* value.
+*
+* A failure gives an error value, and the function does not throw. The function records each effect in its order,
+* and the host does not do it. A mock can answer each effect at once (RUN.MOCK).
+*
+* @param machine - The world and the code of the evaluators.
+* @param doc - The document, as JSON.
+* @param context - The names and the capabilities at the root.
+* @param options - The type of a bare root value, or the options: that type, the mock of the host, the verb and a list for the reads.
+* @returns The result, the trace and the effects in their order.
+*/
+function evaluate(machine, doc, context = makeContext(), options) {
+	const given = typeof options === "string" ? { declaredType: options } : options ?? {};
+	const declaredType = given.declaredType;
+	const plan = prepare(machine, doc, {
+		trace: true,
+		...declaredType === void 0 ? {} : { declaredType },
+		...given.verb === void 0 ? {} : { verb: given.verb },
+		...given.guards === void 0 ? {} : { guards: given.guards }
+	});
+	const ctx = rootContext(machine, context);
+	const s = new Session(machine, ctx.caps, false, true, given.perform, void 0, void 0, readingOf(given.reads, ctx));
+	return record(s, plan.code(ctx, s));
+}
+/**
+* This function runs a document: an evaluation in which the host does each effect. A runner waits for its
+* parts and for its effects, thus a step can read the result of the step before. The part of the run before the
+* first wait happens at once, in the call. The run records a trace.
+*
+* @param machine - The world, the evaluators and the runners.
+* @param doc - The document, as JSON.
+* @param context - The names and the capabilities at the root.
+* @param options - The host code that does the effects, the type of a bare root value, a signal, the verb and a list for the reads.
+* @returns The result, the trace and the effects in their order, when the run ends.
+*/
+async function run(machine, doc, context = makeContext(), options = {}) {
+	const plan = prepare(machine, doc, {
+		trace: true,
+		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType },
+		...options.guards === void 0 ? {} : { guards: options.guards },
+		...options.verb === void 0 ? {} : { verb: options.verb }
+	});
+	const ctx = rootContext(machine, context);
+	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.
+*
+* @param trace - The root of the trace.
+* @param path - The keys from the root.
+* @returns The first evaluation at that path, or `undefined` when the document did not evaluate.
+*/
+function nodeAt(trace, path) {
+	const want = path.map(String);
+	let node = trace;
+	let at = 0;
+	while (node !== void 0 && at < want.length) {
+		const here = node;
+		node = here.children.find((child) => {
+			const tail = child.path.slice(here.path.length);
+			return tail.length > 0 && tail.every((key, index) => key === want[at + index]);
+		});
+		if (node !== void 0) at += node.path.length - here.path.length;
+	}
+	return node;
+}
+/**
+* This function lists the nodes of a trace in the order of their start.
+*
+* @param trace - The root of the trace.
+* @returns Each node, the root first.
+*/
+function flatten(trace) {
+	const out = [];
+	const stack = [trace];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		out.push(node);
+		for (let index = node.children.length - 1; index >= 0; index -= 1) stack.push(node.children[index]);
+	}
+	return out.sort((a, b) => a.enter - b.enter);
+}
+/**
+* This function lists the errors of a trace: each node whose result is an error and whose parts did not fail
+* the same way. These nodes are where each error started.
+*
+* @param trace - The root of the trace.
+* @returns The errors, in the order of their start.
+*/
+function failures(trace) {
+	return flatten(trace).filter((node) => !node.result.ok && !node.children.some((child) => !child.result.ok && child.result.error === node.result.error)).map((node) => node.result.error);
+}
+// 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);
+}
+/**
+* This function makes the language of the boundary kind `lang` (K38, D193). A document of the kind holds the name of a
+* language and a document in that language: `{ type: "lang", value: { language, doc } }`. The machine of the named
+* language prepares and evaluates the inner document, as a module of another language (COMPOSE.BOUNDARY).
+*
+* The boundary is closed. The inner document gets no names, no capabilities and no node as `self`. Only its result
+* crosses the boundary. Thus an effect in the inner document fails with `#CAP!`, and the inner machine cannot read the
+* names of the outer document.
+*
+* @param machines - The machine of each language, by the name that a document gives.
+* @returns The language, for `compose`.
+*/
+function boundary(machines) {
+	const plans = /* @__PURE__ */ new Map();
+	const planOf = (name) => {
+		let found = plans.get(name);
+		if (found === void 0 && Object.hasOwn(machines, name)) {
+			found = planner(machines[name]);
+			plans.set(name, found);
+		}
+		return found;
+	};
+	return defineLanguage({
+		name: "boundary",
+		version: "1.0.0",
+		world: { kinds: { lang: {
+			verbs: { eval: "boundary.lang" },
+			summary: "A document in another language. The machine of that language evaluates it, with no names and no capabilities."
+		} } },
+		code: { evaluators: { "boundary.lang": (input) => {
+			const { data, place } = input;
+			if (!isRecord(data) || typeof data["language"] !== "string" || !("doc" in data)) return fail("#VALUE!", "A document of the kind lang has the value { language, doc }.", { place });
+			const plans = planOf(data["language"]);
+			if (plans === void 0) return fail("#NAME?", `The boundary knows no language ${JSON.stringify(data["language"])}.`, { place });
+			return evaluateWithin(plans(data["doc"]), makeContext(), input[RUNTIME]);
+		} } }
+	});
+}
+// src/steps.ts
+/**
+* This function makes a ladder of steps, and it checks the declaration (STEPS.LADDER). The list of steps must have one
+* step or more, with no name two times. The step of each construct must be a step of the list.
+*
+* @param steps - The names of the steps, from the lowest to the highest.
+* @param constructs - The step that each construct needs.
+* @returns The ladder, frozen.
+* @throws TypeError for a declaration that is not valid, because it is a defect of the language.
+*/
+function stepLadder(steps, constructs) {
+	if (steps.length === 0) throw new TypeError("a ladder of steps needs one step or more");
+	const seen = /* @__PURE__ */ new Set();
+	for (const step of steps) {
+		if (typeof step !== "string") throw new TypeError(`the step ${String(step)} is not a name`);
+		if (seen.has(step)) throw new TypeError(`the step "${step}" is in the ladder two times`);
+		seen.add(step);
+	}
+	for (const [construct, step] of Object.entries(constructs)) if (!seen.has(step)) throw new TypeError(`the construct "${construct}" needs the step "${String(step)}", which is not a step of the ladder`);
+	return Object.freeze({
+		steps: Object.freeze([...steps]),
+		constructs: Object.freeze({ ...constructs })
+	});
+}
+/**
+* This function tells if a value is a step of a ladder. A host uses it to check its option for the highest step.
 *
-* @param machine - The world and the code of the evaluators.
-* @param doc - The document, as JSON.
-* @param context - The names and the capabilities at the root.
-* @param options - The type of a bare root value, or the options: that type, the mock of the host, the verb and a list for the reads.
-* @returns The result, the trace and the effects in their order.
+* @param ladder - The ladder.
+* @param value - The value.
+* @returns `true` when the value is the name of a step of the ladder.
 */
-function evaluate(machine, doc, context = makeContext(), options) {
-	const given = typeof options === "string" ? { declaredType: options } : options ?? {};
-	const declaredType = given.declaredType;
-	const plan = prepare(machine, doc, {
-		trace: true,
-		...declaredType === void 0 ? {} : { declaredType },
-		...given.verb === void 0 ? {} : { verb: given.verb },
-		...given.guards === void 0 ? {} : { guards: given.guards }
-	});
-	const ctx = rootContext(machine, context);
-	const s = new Session(machine, ctx.caps, false, true, given.perform, void 0, void 0, readingOf(given.reads, ctx));
-	return record(s, plan.code(ctx, s));
+function isStep(ladder, value) {
+	return typeof value === "string" && ladder.steps.includes(value);
 }
 /**
-* This function runs a document: an evaluation in which the host does each effect. A runner waits for its
-* parts and for its effects, thus a step can read the result of the step before. The part of the run before the
-* first wait happens at once, in the call. The run records a trace.
+* This function gives the position of a step in its ladder. The lowest step has the position 0.
 *
-* @param machine - The world, the evaluators and the runners.
-* @param doc - The document, as JSON.
-* @param context - The names and the capabilities at the root.
-* @param options - The host code that does the effects, the type of a bare root value, a signal, the verb and a list for the reads.
-* @returns The result, the trace and the effects in their order, when the run ends.
+* @param ladder - The ladder.
+* @param step - The step.
+* @returns The position.
+* @throws TypeError for a name that is not a step of the ladder.
 */
-async function run(machine, doc, context = makeContext(), options = {}) {
-	const plan = prepare(machine, doc, {
-		trace: true,
-		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType },
-		...options.guards === void 0 ? {} : { guards: options.guards },
-		...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));
+function stepRank(ladder, step) {
+	const rank = ladder.steps.indexOf(step);
+	if (rank < 0) throw new TypeError(`"${String(step)}" is not a step of the ladder. The steps are ${ladder.steps.join(", ")}`);
+	return rank;
+}
+function pathOf(visit) {
+	const path = [];
+	for (let v = visit; v?.key !== void 0; v = v.parent) path.push(v.key);
+	return path.reverse();
 }
 /**
-* This function finds a node of a trace by its path.
+* This function gives the lowest step that a document needs, with the reason (STEPS.LOWEST, STEPS.REASON). The step is
+* the highest step of the constructs of its nodes. The reason is the first node in document order with that step. The
+* walk uses its own stack, thus a deep document does not overflow (STEPS.LINEAR). It visits a shared node one time,
+* and it stops at the first node with the highest step of the ladder.
 *
-* @param trace - The root of the trace.
-* @param path - The keys from the root.
-* @returns The first evaluation at that path, or `undefined` when the document did not evaluate.
+* @param ladder - The ladder of the language.
+* @param walk - The construct and the child nodes of a node.
+* @param root - The root node of the document.
+* @returns The step, and the reason when the step is not the lowest step.
 */
-function nodeAt(trace, path) {
-	const want = path.map(String);
-	let node = trace;
-	let at = 0;
-	while (node !== void 0 && at < want.length) {
-		const here = node;
-		node = here.children.find((child) => {
-			const tail = child.path.slice(here.path.length);
-			return tail.length > 0 && tail.every((key, index) => key === want[at + index]);
-		});
-		if (node !== void 0) at += node.path.length - here.path.length;
+function stepOf(ladder, walk, root) {
+	const top = ladder.steps.length - 1;
+	let best = 0;
+	let reason;
+	const seen = /* @__PURE__ */ new Set();
+	const todo = [{
+		node: root,
+		key: void 0,
+		parent: void 0
+	}];
+	for (let visit = todo.pop(); visit !== void 0; visit = todo.pop()) {
+		const { node } = visit;
+		if (typeof node === "object" && node !== null) {
+			if (seen.has(node)) continue;
+			seen.add(node);
+		}
+		const construct = walk.construct(node);
+		const step = construct === void 0 || !Object.hasOwn(ladder.constructs, construct) ? void 0 : ladder.constructs[construct];
+		const rank = step === void 0 ? 0 : ladder.steps.indexOf(step);
+		if (rank > best) {
+			best = rank;
+			reason = {
+				construct,
+				step,
+				path: pathOf(visit),
+				node
+			};
+			if (best === top) break;
+		}
+		const kids = [...walk.children(node)];
+		for (let i = kids.length - 1; i >= 0; i--) {
+			const [key, child] = kids[i];
+			todo.push({
+				node: child,
+				key,
+				parent: visit
+			});
+		}
 	}
-	return node;
+	const step = ladder.steps[best];
+	return reason === void 0 ? { step } : {
+		step,
+		reason
+	};
 }
 /**
-* This function lists the nodes of a trace in the order of their start.
+* This function compares the step of a document with the highest step that the host accepts (STEPS.MAX). The limit
+* changes only which documents the host accepts. The language evaluates an accepted document as before, thus a limit
+* does not change a value.
 *
-* @param trace - The root of the trace.
-* @returns Each node, the root first.
+* @param ladder - The ladder of the language.
+* @param need - The step of the document, from `stepOf`.
+* @param maxStep - The highest step that the host accepts.
+* @returns `undefined` when the host accepts the document, or the refusal that names the needed step.
+* @throws TypeError when `maxStep` or the step of `need` is not a step of the ladder.
 */
-function flatten(trace) {
-	const out = [];
-	const stack = [trace];
-	while (stack.length > 0) {
-		const node = stack.pop();
-		out.push(node);
-		for (let index = node.children.length - 1; index >= 0; index -= 1) stack.push(node.children[index]);
-	}
-	return out.sort((a, b) => a.enter - b.enter);
+function checkStep(ladder, need, maxStep) {
+	const limit = stepRank(ladder, maxStep);
+	if (stepRank(ladder, need.step) <= limit) return void 0;
+	const head = `the document needs the step ${need.step}, and the host accepts the steps up to ${maxStep}`;
+	const reason = need.reason;
+	if (reason === void 0) return {
+		needed: need.step,
+		maxStep,
+		message: head
+	};
+	const where = reason.path.length === 0 ? "at the root" : `at the path ${JSON.stringify(reason.path)}`;
+	return {
+		needed: need.step,
+		maxStep,
+		reason,
+		message: `${head}. The construct "${reason.construct}" ${where} needs the step ${reason.step}`
+	};
+}
+// src/classify.ts
+function isStrictSuperset(larger, smaller) {
+	return larger.length > smaller.length && smaller.every((name) => larger.includes(name));
 }
 /**
-* This function lists the errors of a trace: each node whose result is an error and whose parts did not fail
-* the same way. These nodes are where each error started.
+* This function proposes a kind for a value without a type, from the fields that the value has.
+* A shape applies when the value has each field of the shape. The most specific shapes are the ones that
+* no other applicable shape contains. A host uses a classifier when data comes in, and then tags the data.
+* The ladder does not call a classifier.
 *
-* @param trace - The root of the trace.
-* @returns The errors, in the order of their start.
+* @param shapes - The shapes to examine.
+* @param value - The value without a type.
+* @returns The proposed kind, or an error with the candidates.
 */
-function failures(trace) {
-	return flatten(trace).filter((node) => !node.result.ok && !node.children.some((child) => !child.result.ok && child.result.error === node.result.error)).map((node) => node.result.error);
+function classify(shapes, value) {
+	const applicable = isRecord(value) ? shapes.filter((shape) => shape.fields.every((name) => field(value, name) !== void 0)) : [];
+	const best = applicable.filter((shape) => !applicable.some((other) => isStrictSuperset(other.fields, shape.fields)));
+	const candidates = best.map((shape) => shape.name);
+	const only = best.length === 1 ? best[0] : void 0;
+	if (only !== void 0) return {
+		kind: only.kind,
+		candidates
+	};
+	return {
+		candidates,
+		error: best.length === 0 ? "no-match" : "ambiguous"
+	};
+}
+/**
+* This function puts a value in an envelope with a type. The value does not change.
+*
+* @param value - The value.
+* @param kind - The name of the kind.
+* @returns The envelope.
+*/
+function tag(value, kind) {
+	return typed(kind, value);
 }
 // src/stdlib.ts
 /**
@@ -6437,9 +6541,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 +7027,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 +7053,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 +7064,7 @@ function plainOf(value, path) {
 		}
 		return ok(out ?? value);
 	} finally {
-		path.delete(value);
+		path.set(value, false);
 	}
 }
 /**
@@ -7404,19 +7516,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 +7551,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 +7591,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 +7602,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 +11394,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 +12126,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,7 +12395,10 @@ 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);
+					const root = clock.top ?? clock;
 					clock.applying = level;
+					root.active = (root.active ?? 0) + 1;
 					try {
 						const scope = { ...ctx.names };
 						names.forEach((name, index) => setOwn$2(scope, name, args[index]));
@@ -12290,12 +12410,13 @@ function formulaCode(profile) {
 						return result.value;
 					} finally {
 						clock.applying = level - 1;
+						root.active = (root.active ?? 1) - 1;
 					}
 				};
 				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 +13202,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 && meter.active === 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 +13247,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 +13274,13 @@ function envOf(machine, options, running, root, outer) {
 		},
 		held: 0,
 		applying: 0,
+		maxWork: machine.maxWork ?? 2e5,
+		meter: meter ?? {
+			spent: 0,
+			ended: false,
+			active: 0
+		},
+		nested: meter !== void 0,
 		reading: outer ?? (options.reads === void 0 ? void 0 : {
 			list: options.reads,
 			root
@@ -13231,7 +13374,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 +13724,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 +13780,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 +13817,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 +13827,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;
 	}
@@ -13806,26 +13964,37 @@ function formulaDefinitions(profile = {}) {
 		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$1(parts, "body");
-		const clock = activeEnvs[activeEnvs.length - 1] ?? {
+		const maker = activeEnvs[activeEnvs.length - 1];
+		const clock = maker ?? {
 			applying: 0,
-			maxDepth: 1e3
+			maxDepth: 1e3,
+			maxWork: 2e5,
+			meter: {
+				spent: 0,
+				ended: false,
+				active: 0
+			}
 		};
 		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;
+			clock.meter.active += 1;
 			try {
 				const scope = {};
 				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({
+				const scoped = {
 					...context,
 					names: scope
-				});
+				};
+				const result = maker === void 0 ? body.evaluate(scoped) : within(maker, () => body.evaluate(scoped));
 				if (!result.ok) throw new Failure(result.error);
 				return result.value;
 			} finally {
 				clock.applying -= 1;
+				clock.meter.active -= 1;
 			}
 		};
 		Object.defineProperty(closure, CLOSURE$2, { value: { params: names } });
@@ -14322,6 +14491,11 @@ function apply(p, c, target, args) {
 	}
 	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.`));
+	p.work += 1;
+	if (p.work > p.maxWork) return back(c, {
+		ok: false,
+		error: workFailure(p.maxWork)
+	});
 	pushed(c, {
 		f: "return",
 		place: closure.place.concat(closure.body.path)
@@ -14348,6 +14522,9 @@ function hostClosure(p, value, closure) {
 	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.work = (p.ended && p.applying === 0 ? 0 : p.work) + 1;
+		if (p.work > p.maxWork) throw new Failure(workFailure(p.maxWork));
+		const before = p.applying;
 		p.applying += 1;
 		try {
 			const place = closure.place.concat(closure.body.path);
@@ -14364,7 +14541,7 @@ function hostClosure(p, value, closure) {
 			if (!end.result.ok) throw new Failure(end.result.error);
 			return forHost(p, end, end.result.value);
 		} finally {
-			p.applying -= 1;
+			p.applying = before;
 		}
 	};
 	Object.defineProperty(fn, CLOSURE$1, { value: { params: closure.params } });
@@ -14695,7 +14872,7 @@ function cause(p, ctx, kind, payload, place) {
 	const count = counts.get(at) ?? 0;
 	counts.set(at, count + 1);
 	const effect = {
-		index: effects.length,
+		index: p.before + effects.length,
 		kind: text,
 		path: keys,
 		payload,
@@ -14801,7 +14978,8 @@ function evaluateDoc(p, c) {
 	} catch (error) {
 		return back(c, thrown(error, `the evaluator ${name}`));
 	}
-	const defined = own$1(p.definitions.evaluators, name);
+	const standard = code === own$1(STD_EVALUATORS, name) ? own$1(STD_DEFINITIONS.evaluators, name) : void 0;
+	const defined = own$1(p.definitions.evaluators, name) ?? standard;
 	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}.`));
 }
@@ -14958,7 +15136,11 @@ function programOf(machine, options) {
 		effects: options.effects ?? [],
 		perform: options.perform,
 		counts: /* @__PURE__ */ new Map(),
-		applying: 0
+		before: 0,
+		applying: 0,
+		maxWork: machine.maxWork ?? 2e5,
+		work: 0,
+		ended: false
 	};
 }
 /**
@@ -15014,10 +15196,21 @@ function stepperNext(machine, configuration, options = {}) {
 		};
 		else stack[stack.length - 1] = { ...top };
 	}
-	return advance(programOf(machine, options), {
+	const p = programOf(machine, options);
+	p.work = configuration.work ?? 0;
+	for (const [at, count] of Object.entries(configuration.counts ?? {})) p.counts.set(at, count);
+	p.before = options.effects === void 0 ? configuration.effected ?? 0 : 0;
+	const next = advance(p, {
 		...configuration,
 		stack
 	});
+	const effected = p.before + p.effects.length;
+	return {
+		...next,
+		...p.work === 0 ? {} : { work: p.work },
+		...p.counts.size === 0 ? {} : { counts: Object.fromEntries(p.counts) },
+		...effected === 0 ? {} : { effected }
+	};
 }
 /**
 * This function evaluates a document with an explicit stack (K95, D158). It gives the result of `reference` for each
@@ -15035,6 +15228,7 @@ function stepper(machine, doc, context = makeContext(), options = {}) {
 	const p = programOf(machine, options);
 	try {
 		const end = drive$1(p, stepperStart(machine, doc, context, options));
+		p.ended = true;
 		return end.result.ok ? ok(forHost(p, end, end.result.value)) : end.result;
 	} catch (error) {
 		return placed(thrown(error, "the stepper"), []);
@@ -18786,7 +18980,10 @@ function generate(world, options) {
 			value
 		};
 		if (header !== void 0) out["name"] = header;
-		if (options.own !== void 0 && options.own.length > 0 && rng.chance(.03)) out["own"] = { eval: rng.pick(options.own) };
+		if (options.own !== void 0 && options.own.length > 0 && rng.chance(.03)) {
+			const code = rng.pick(options.own);
+			if ((kindOf(type)?.scope ?? []).length === 0) out["own"] = { eval: code };
+		}
 		return out;
 	};
 	/**
@@ -22434,6 +22631,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, boundary, 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