@mark1russell7/coeval 0.27.0 → 0.27.2

package/build/index.js

@@ -1,3 +1,4 @@
+import { strongComponentsCompact } from "@mark1russell7/collections/graph";
 import { mulberry32 } from "@mark1russell7/rigor-generators";
 // src/doc.ts
 /** The keys that an envelope can have. */
@@ -2579,483 +2580,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 = {
@@ -3089,877 +3185,477 @@ function nodeOf(first, keys) {
 }
 /** This function tells if a table of code has the name. An entry of a document can hold another value than a text. */
 function codeIn(table, name) {
-	return typeof name === "string" && Object.hasOwn(table, name);
-}
-/**
-* This function finds the walker of a step document through the ladder of the verb `step` (VERB.LADDER). The rungs
-* are the own entry, then the kind, then the default of the world. A rung answers only with a walker that the
-* navigator has. A resolution and `check` use this function, thus they agree on `#STEP?`.
-*
-* @param nav - The world and the walkers.
-* @param step - A step of a path that is not a key.
-* @returns The walker, or `undefined` when no rung answers.
-*/
-function walkerOf(nav, step) {
-	const walkers = nav.walkers;
-	if (walkers === void 0 || !isEnvelope(step)) return void 0;
-	const answer = answerOf(nav.world, ownEntries(step), kindFor(nav.world, step.type), "step", (name) => codeIn(walkers, name));
-	return answer === void 0 ? void 0 : walkers[answer.name];
-}
-/** The answer of `plainStep` for a field that the value does not have. A field can hold `undefined`. */
-const NOTHING = /* @__PURE__ */ Symbol("nothing");
-/** The own fields of a value: the items and the length of a list, and the own properties of an object. */
-function plainStep(thing, key) {
-	if (Array.isArray(thing)) {
-		if (key === "length") return thing.length;
-		const index = typeof key === "number" ? key : /^\d+$/.test(key) ? Number(key) : -1;
-		return index >= 0 && index < thing.length ? thing[index] : NOTHING;
-	}
-	if (typeof thing === "object" && thing !== null) {
-		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 typeof name === "string" && Object.hasOwn(table, name);
 }
 /**
-* This function gives the value of a thing: the value that a host thing gives, or else the thing itself.
+* This function finds the walker of a step document through the ladder of the verb `step` (VERB.LADDER). The rungs
+* are the own entry, then the kind, then the default of the world. A rung answers only with a walker that the
+* navigator has. A resolution and `check` use this function, thus they agree on `#STEP?`.
 *
-* @param thing - The thing.
-* @returns The value.
+* @param nav - The world and the walkers.
+* @param step - A step of a path that is not a key.
+* @returns The walker, or `undefined` when no rung answers.
 */
-function valueOfThing(thing) {
-	return isHostThing(thing) ? thing.toJson() : thing;
+function walkerOf(nav, step) {
+	const walkers = nav.walkers;
+	if (walkers === void 0 || !isEnvelope(step)) return void 0;
+	const answer = answerOf(nav.world, ownEntries(step), kindFor(nav.world, step.type), "step", (name) => codeIn(walkers, name));
+	return answer === void 0 ? void 0 : walkers[answer.name];
 }
-// src/classify.ts
-function isStrictSuperset(larger, smaller) {
-	return larger.length > smaller.length && smaller.every((name) => larger.includes(name));
+/** The answer of `plainStep` for a field that the value does not have. A field can hold `undefined`. */
+const NOTHING = /* @__PURE__ */ Symbol("nothing");
+/** The own fields of a value: the items and the length of a list, and the own properties of an object. */
+function plainStep(thing, key) {
+	if (Array.isArray(thing)) {
+		if (key === "length") return thing.length;
+		const index = typeof key === "number" ? key : /^\d+$/.test(key) ? Number(key) : -1;
+		return index >= 0 && index < thing.length ? thing[index] : NOTHING;
+	}
+	if (typeof thing === "object" && thing !== null) {
+		const name = String(key);
+		return Object.hasOwn(thing, name) ? thing[name] : NOTHING;
+	}
+	return NOTHING;
 }
 /**
-* 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 shapes - The shapes to examine.
-* @param value - The value without a type.
-* @returns The proposed kind, or an error with the candidates.
+* 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 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 mayBeEnvelope(thing) {
+	return typeof thing === "object" && thing !== null && thing.type !== void 0;
 }
 /**
-* This function puts a value in an envelope with a type. The value does not change.
+* 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 value - The value.
-* @param kind - The name of the kind.
-* @returns The envelope.
+* @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 tag(value, kind) {
-	return typed(kind, value);
-}
-// src/parts.ts
-var Bad$1 = class {
-	reason;
-	at;
-	constructor(reason, at) {
-		this.reason = reason;
-		this.at = at;
+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;
 	}
-};
-/** 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 }
+	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 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);
-}
 /**
-* 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 tells if a thing is a reference document: an envelope of the type `ref` with a list for its path.
 *
-* @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 thing - The thing.
+* @returns `true` for a reference document.
 */
-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
-		};
-	};
-	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
+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 (!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 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 tells if the path of a part matches a pattern of a scope rule. The key `"*"` of a pattern matches
-* each key.
+* This function resolves a path from a context, and records each hop.
 *
-* @param path - The path of the part.
-* @param pattern - The pattern.
-* @returns `true` when the path matches.
+* 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 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 resolve(nav, ctx, path, options = {}) {
+	if (options.hops === false) {
+		const quick = resolveQuick(nav, ctx, path);
+		if (quick !== void 0) return quick;
 	}
-	return true;
+	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 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 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.
+* 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 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 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);
+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
 /**
@@ -4519,14 +4215,14 @@ var Session = class {
 	/**
 	* 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).
+	* (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 && (this.applying ?? 0) === 0 ? 0 : root.work ?? 0) + points;
+		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));
@@ -5905,104 +5601,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 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 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 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 }
+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 })
 	});
-	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.
+* 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, 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 value - The value.
+* @returns `true` when the value is the name of 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, 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);
+function isStep(ladder, value) {
+	return typeof value === "string" && ladder.steps.includes(value);
 }
 /**
-* This function finds a node of a trace by its path.
+* This function gives the position of a step in its ladder. The lowest step has the position 0.
 *
-* @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.
+* @param step - The step.
+* @returns The position.
+* @throws TypeError for a name that is not a step of the ladder.
 */
-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;
+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 lists the nodes of a trace in the order of their start.
+* 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.
-* @returns Each node, the root first.
+* @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 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]);
+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 out.sort((a, b) => a.enter - b.enter);
+	const step = ladder.steps[best];
+	return reason === void 0 ? { step } : {
+		step,
+		reason
+	};
 }
 /**
-* 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 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 The errors, in the order of their start.
+* @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 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 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 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 shapes - The shapes to examine.
+* @param value - The value without a type.
+* @returns The proposed kind, or an error with the candidates.
+*/
+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
 /**
@@ -8922,71 +8961,12 @@ function indexed(graph, options) {
 	};
 }
 /**
-* This function finds the strongly connected components with the algorithm of Tarjan. It keeps its own stack of
-* calls in two arrays, thus a long chain does not overflow the stack of the host. Each component comes after each
-* component that its nodes reach: the deepest component comes first.
+* This function finds the strongly connected components with `strongComponentsCompact` of
+* `@mark1russell7/collections` (K249). The search keeps its own stack, thus a long chain does not overflow the stack
+* of the host. Each component comes after each component that its nodes reach: the deepest component comes first.
 */
 function strong(graph) {
-	const { size, start, targets } = graph;
-	const order = new Int32Array(size).fill(-1);
-	const low = new Int32Array(size);
-	const of = new Int32Array(size).fill(-1);
-	const open = new Int32Array(size);
-	const onOpen = new Uint8Array(size);
-	const calls = new Int32Array(size);
-	const next = new Int32Array(size);
-	const list = [];
-	let top = 0;
-	let count = 0;
-	const enter = (node, depth) => {
-		order[node] = count;
-		low[node] = count;
-		count += 1;
-		open[top] = node;
-		top += 1;
-		onOpen[node] = 1;
-		calls[depth] = node;
-		next[depth] = start[node];
-	};
-	for (let root = 0; root < size; root += 1) {
-		if (order[root] !== -1) continue;
-		enter(root, 0);
-		let depth = 1;
-		while (depth > 0) {
-			const node = calls[depth - 1];
-			const edge = next[depth - 1];
-			if (edge < start[node + 1]) {
-				next[depth - 1] = edge + 1;
-				const to = targets[edge];
-				if (order[to] === -1) {
-					enter(to, depth);
-					depth += 1;
-				} else if (onOpen[to] === 1 && order[to] < low[node]) low[node] = order[to];
-				continue;
-			}
-			depth -= 1;
-			if (low[node] === order[node]) {
-				const members = [];
-				let member;
-				do {
-					top -= 1;
-					member = open[top];
-					onOpen[member] = 0;
-					of[member] = list.length;
-					members.push(member);
-				} while (member !== node);
-				list.push(members.sort((a, b) => a - b));
-			}
-			if (depth > 0) {
-				const reader = calls[depth - 1];
-				if (low[node] < low[reader]) low[reader] = low[node];
-			}
-		}
-	}
-	return {
-		of,
-		list
-	};
+	return strongComponentsCompact(graph.size, graph.start, graph.targets);
 }
 /** This function tells if a component has a cycle: two or more nodes, or one node with an edge to itself. */
 function cyclic(graph, members) {
@@ -12358,7 +12338,9 @@ function formulaCode(profile) {
 					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]));
@@ -12370,6 +12352,7 @@ 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 } });
@@ -13185,7 +13168,7 @@ function evaluateRoot(machine, doc, context, options, outer, meter) {
 */
 function spend(env, points) {
 	const meter = env.meter;
-	if (meter.ended && env.applying === 0) meter.spent = 0;
+	if (meter.ended && meter.active === 0) meter.spent = 0;
 	meter.spent += points;
 	if (meter.spent > env.maxWork) throw new Failure(workFailure(env.maxWork));
 }
@@ -13236,7 +13219,8 @@ function envOf(machine, options, running, root, outer, meter) {
 		maxWork: machine.maxWork ?? 2e5,
 		meter: meter ?? {
 			spent: 0,
-			ended: false
+			ended: false,
+			active: 0
 		},
 		nested: meter !== void 0,
 		reading: outer ?? (options.reads === void 0 ? void 0 : {
@@ -13922,13 +13906,15 @@ 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,
 			maxWork: 2e5,
 			meter: {
 				spent: 0,
-				ended: false
+				ended: false,
+				active: 0
 			}
 		};
 		const limit = Math.ceil(clock.maxDepth / 4);
@@ -13936,18 +13922,21 @@ function formulaDefinitions(profile = {}) {
 			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 } });
@@ -14444,6 +14433,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)
@@ -14470,6 +14464,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);
@@ -14486,7 +14483,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 } });
@@ -14817,7 +14814,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,
@@ -14923,7 +14920,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}.`));
 }
@@ -15080,7 +15078,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
 	};
 }
 /**
@@ -15136,10 +15138,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
@@ -15157,6 +15170,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"), []);
@@ -18908,7 +18922,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;
 	};
 	/**
@@ -22556,6 +22573,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, WORK_LIMIT, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, agreeTypes, argsKey, ask, atArgsOf, atRuleOf, attributeGraph, attributeTrace, attributeVertexId, boundariesOf, capKeys, check, checkCycles, checkLatent, checkStep, checkSteps, checkSyntax, checkWorld, circularOf, classify, codecLaws, collectOf, compilePath, components, compose, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, defineLanguage, derefStep, describe, docEquals, documentKey, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, ifRunner, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapDocs, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partGrants, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, resolveCompiled, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stepper, stepperNext, stepperStart, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+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