@mark1russell7/coeval 0.1.0 → 0.2.0

package/build/index.js

@@ -7,13 +7,16 @@ const ENVELOPE_KEYS = [
 	"own"
 ];
 /**
-* This function tells if a value is a JSON record (not an array and not null).
+* This function tells if a value is a plain record: an object with the prototype of a plain object, or with no
+* prototype. A list, `null`, a date, a map and an instance of a class are not plain records.
 *
 * @param value - The value to examine.
-* @returns `true` for a record.
+* @returns `true` for a plain record.
 */
 function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
 }
 /**
 * This function reads a field of a record. It reads only the own fields, thus `constructor` is not a field.
@@ -69,6 +72,13 @@ function typePath(type) {
 function typeName(type) {
 	return typePath(type)?.join(".") ?? "(computed)";
 }
+function headerFits(value) {
+	if (!isTypeRef(field(value, "type")) || !Object.hasOwn(value, "value")) return false;
+	const name = field(value, "name");
+	if (name !== void 0 && typeof name !== "string") return false;
+	const own = field(value, "own");
+	return own === void 0 || isRecord(own);
+}
 /**
 * This function tells if a value has the form of an envelope. That form is a record with a reference to a type
 * and a `value`. It has no other keys than the keys of an envelope. A contract decides where an envelope is
@@ -78,13 +88,32 @@ function typeName(type) {
 * @returns `true` when the value has the form of an envelope.
 */
 function isEnvelope(value) {
-	if (!isRecord(value)) return false;
-	if (!isTypeRef(field(value, "type")) || !Object.hasOwn(value, "value")) return false;
-	const name = field(value, "name");
-	if (name !== void 0 && typeof name !== "string") return false;
-	const own = field(value, "own");
-	if (own !== void 0 && !isRecord(own)) return false;
-	return Object.keys(value).every((key) => ENVELOPE_KEYS.includes(key));
+	if (!isRecord(value) || !headerFits(value)) return false;
+	for (const key in value) if (Object.hasOwn(value, key) && !ENVELOPE_KEYS.includes(key)) return false;
+	return true;
+}
+/**
+* This function reads a stored document: an envelope that also has the keys of a store, for example `{ _id, type,
+* value }`. Only the keys in the list can be beside the keys of the envelope.
+*
+* @param value - The value to examine.
+* @param header - The keys of the store that the document can have.
+* @returns The envelope and the keys of the store, or `undefined` when the value has another form.
+*/
+function stored(value, header) {
+	if (!isRecord(value) || !headerFits(value)) return void 0;
+	const keys = {};
+	const own = {};
+	for (const key in value) {
+		if (!Object.hasOwn(value, key)) continue;
+		if (ENVELOPE_KEYS.includes(key)) own[key] = value[key];
+		else if (header.includes(key)) keys[key] = value[key];
+		else return void 0;
+	}
+	return {
+		envelope: fromJson(own),
+		header: keys
+	};
 }
 /**
 * This function makes an envelope.
@@ -144,6 +173,149 @@ function fromJson(value) {
 		...isRecord(own) ? { own: ownEntries } : {}
 	});
 }
+/**
+* This function tells if two JSON values are equal. Equal values have the same texts, numbers and truth values,
+* the same items in the same order, and the same fields. The order of the fields does not matter. It does not use the stack for the
+* depth, thus a deep document cannot overflow it.
+*
+* @param a - The first value.
+* @param b - The second value.
+* @returns `true` when the values are equal.
+*/
+function docEquals(a, b) {
+	const stack = [[a, b]];
+	while (stack.length > 0) {
+		const [x, y] = stack.pop();
+		if (Object.is(x, y)) continue;
+		if (typeof x !== "object" || typeof y !== "object" || x === null || y === null) return false;
+		if (Array.isArray(x) !== Array.isArray(y)) return false;
+		if (Array.isArray(x)) {
+			const ys = y;
+			if (x.length !== ys.length) return false;
+			for (let index = 0; index < x.length; index += 1) stack.push([x[index], ys[index]]);
+			continue;
+		}
+		const xr = x;
+		const yr = y;
+		const keys = Object.keys(xr);
+		if (keys.length !== Object.keys(yr).length) return false;
+		for (const key of keys) {
+			if (!Object.hasOwn(yr, key)) return false;
+			stack.push([xr[key], yr[key]]);
+		}
+	}
+	return true;
+}
+//#endregion
+//#region src/errors.ts
+/**
+* This function makes a result with a value.
+*
+* @param value - The value.
+* @returns The result.
+*/
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+/**
+* This function makes a result with an error value.
+*
+* @param code - The code of the error.
+* @param reason - One sentence that tells the cause.
+* @param more - The place and the cause of the error, when they are known.
+* @returns The result.
+*/
+function fail(code, reason, more = {}) {
+	return {
+		ok: false,
+		error: {
+			code,
+			reason,
+			...more.place === void 0 ? {} : { place: more.place },
+			...more.cause === void 0 ? {} : { cause: more.cause }
+		}
+	};
+}
+/**
+* This function gives a failed result its place, when it has none. A result with a value, or an error with a
+* place, stays the same object.
+*
+* @param result - The result.
+* @param place - The keys from the root document to the document that failed.
+* @returns The result with a place.
+*/
+function placed(result, place) {
+	if (result.ok || result.error.place !== void 0) return result;
+	return {
+		ok: false,
+		error: {
+			...result.error,
+			place
+		}
+	};
+}
+/**
+* An exception that carries an error value through code of the host. A closure of a formula throws it when the
+* host calls the closure and the closure fails. The kernel catches it and gives its error value again.
+*/
+var Failure = class extends Error {
+	error;
+	/**
+	* This constructor makes the exception.
+	*
+	* @param error - The error value that the exception carries.
+	*/
+	constructor(error) {
+		super(`${error.code} ${error.reason}`);
+		this.name = "Failure";
+		this.error = error;
+	}
+};
+/**
+* This function tells if an exception is the overflow of the stack of the host.
+*
+* @param error - The exception.
+* @returns `true` for a stack overflow.
+*/
+function isStackOverflow(error) {
+	return error instanceof RangeError && /call stack/i.test(error.message);
+}
+/**
+* This function changes an exception into an error value. A `Failure` gives its error value. A stack overflow
+* gives `#DEPTH!`. Each other exception gives `#CALC!`, with the exception as the cause.
+*
+* @param error - The exception.
+* @param who - A short text that names the code that threw, for example `the evaluator math.add`.
+* @returns The failed result.
+*/
+function thrown(error, who) {
+	if (error instanceof Failure) return {
+		ok: false,
+		error: error.error
+	};
+	if (isStackOverflow(error)) return fail("#DEPTH!", `The nesting of ${who} is too deep for the stack of the host.`, { cause: error });
+	return fail("#CALC!", `${upper(who)} threw: ${describe(error)}`, { cause: error });
+}
+function upper(text) {
+	return text.length === 0 ? text : `${text[0]?.toUpperCase() ?? ""}${text.slice(1)}`;
+}
+/**
+* This function gives a short text for an exception or any value. It does not throw.
+*
+* @param value - The value.
+* @returns The text.
+*/
+function describe(value) {
+	try {
+		if (value instanceof Error) return `${value.name}: ${value.message}`;
+		return String(value);
+	} catch {
+		return "(a value without a text)";
+	}
+}
 //#endregion
 //#region src/world.ts
 /**
@@ -164,13 +336,23 @@ function isKind(entry) {
 function isAlias(entry) {
 	return entry !== void 0 && entry.type === "ref" && Array.isArray(entry.value);
 }
+/**
+* This function tells if an entry of the world is a namespace.
+*
+* @param entry - The entry.
+* @returns `true` for a namespace.
+*/
+function isNamespace(entry) {
+	return entry !== void 0 && !isKind(entry) && !isAlias(entry) && Object.hasOwn(entry, "kinds");
+}
 function entryAt(entries, key) {
 	const name = String(key);
 	return Object.hasOwn(entries, name) ? entries[name] : void 0;
 }
 /**
 * This function finds the kind that a type names. It walks the path from the root of the world, one key at a
-* time. An alias on the way is followed until a kind answers (collapse). A cycle of aliases stops the lookup.
+* time. An alias on the way is followed until a kind answers (collapse). A cycle of aliases stops the lookup. In a
+* namespace with a fallback, a key that the namespace does not have gets the fallback kind.
 *
 * @param world - The world.
 * @param type - The reference to the type.
@@ -187,16 +369,25 @@ function lookupKind(world, type) {
 	let aliases = 0;
 	for (;;) {
 		let entries = world.kinds;
+		let fallback;
 		let entry;
 		let followed = false;
 		for (let index = 0; index < path.length; index += 1) {
 			const key = path[index];
 			entry = entryAt(entries, key);
-			if (entry === void 0) return {
-				ok: false,
-				reason: "unknown",
-				path
-			};
+			if (entry === void 0) {
+				if (fallback !== void 0) return {
+					ok: true,
+					kind: fallback,
+					path,
+					aliases
+				};
+				return {
+					ok: false,
+					reason: "unknown",
+					path
+				};
+			}
 			if (isAlias(entry)) {
 				aliases += 1;
 				if (aliases > 32) return {
@@ -215,12 +406,13 @@ function lookupKind(world, type) {
 				break;
 			}
 			if (index < path.length - 1) {
-				if (isKind(entry)) return {
+				if (!isNamespace(entry)) return {
 					ok: false,
 					reason: "not-a-kind",
 					path
 				};
 				entries = entry.kinds;
+				fallback = entry.fallback;
 			}
 		}
 		if (followed) continue;
@@ -254,6 +446,14 @@ function entriesAsJson(entries) {
 	else out[key] = entriesAsJson(entry.kinds);
 	return out;
 }
+function describeShape(shape) {
+	if (shape === void 0 || shape.shape === "none") return "none";
+	if (shape.shape === "term") return `a part${shape.of === void 0 ? "" : ` of ${shape.of}`}`;
+	if (shape.shape === "deep") return "each document in the value";
+	if (shape.shape === "list") return `a list${shape.of === void 0 ? "" : ` of ${shape.of}`}`;
+	if (shape.shape === "map") return `a record of parts${shape.of === void 0 ? "" : ` of ${shape.of}`}`;
+	return `the fields ${(Array.isArray(shape.fields) ? shape.fields : Object.keys(shape.fields)).join(", ")}`;
+}
 /**
 * This function makes the document of a kind, so that a view can draw it as each other document.
 *
@@ -262,18 +462,26 @@ function entriesAsJson(entries) {
 * @returns The document of type `kind`.
 */
 function kindDocument(name, kind) {
-	const parts = kind.parts === void 0 || kind.parts.shape === "none" ? "none" : kind.parts.shape === "list" ? `a list${kind.parts.of === void 0 ? "" : ` of ${kind.parts.of}`}` : `the fields ${kind.parts.fields.join(", ")}`;
 	return {
 		type: "kind",
 		value: {
 			name,
 			verbs: { ...kind.verbs },
-			parts,
+			parts: describeShape(kind.parts),
 			side: kind.side ?? "derive",
 			summary: kind.summary ?? ""
 		}
 	};
 }
+/**
+* This function tells if a JSON value is the record of a kind.
+*
+* @param value - The value.
+* @returns `true` when the value has verbs.
+*/
+function looksLikeKind(value) {
+	return isRecord(value) && isRecord(field(value, "verbs"));
+}
 //#endregion
 //#region src/ladder.ts
 /** The rungs of the ladder, in the order that a question visits them. */
@@ -411,8 +619,11 @@ function ask(world, doc, verb, options = {}) {
 }
 //#endregion
 //#region src/deref.ts
-/** The brand of a host thing: an object of the host that answers the steps of a path itself. */
-const THING = Symbol("coeval.thing");
+/**
+* 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 = Symbol.for("coeval.thing");
 /**
 * This function tells if a thing is a host thing.
 *
@@ -420,7 +631,7 @@ const THING = Symbol("coeval.thing");
 * @returns `true` for a host thing.
 */
 function isHostThing(thing) {
-	return typeof thing === "object" && thing !== null && !Array.isArray(thing) && thing[THING] === true;
+	return typeof thing === "object" && thing !== null && thing[THING] === true;
 }
 /** The roots of a context. Each path starts with one of them. */
 const ROOTS = [
@@ -433,22 +644,36 @@ const ROOTS = [
 function entryOf(verbs, verb) {
 	return verbs !== void 0 && Object.hasOwn(verbs, verb) ? verbs[verb] : void 0;
 }
+/** 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 {
+			found: true,
+			value: thing.length
+		};
 		const index = typeof key === "number" ? key : /^\d+$/.test(key) ? Number(key) : -1;
-		return index >= 0 ? thing[index] : void 0;
+		return index >= 0 && index < thing.length ? {
+			found: true,
+			value: thing[index]
+		} : void 0;
+	}
+	if (typeof thing === "object" && thing !== null) {
+		const name = String(key);
+		return Object.hasOwn(thing, name) ? {
+			found: true,
+			value: thing[name]
+		} : void 0;
 	}
-	if (isRecord(thing) && typeof key === "string") return field(thing, key);
 }
 /**
 * 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. The default goes into the value: a field
-* of a record, or an item of a list.
+* answers for itself (own). A document asks its own entry, then its kind. The default goes into the value: an own
+* field of an object, or an item of a list.
 *
 * @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`.
+* @returns What the step reaches and the rung that answered, or `undefined` when it reaches nothing.
 */
 function derefStep(nav, thing, key) {
 	if (isHostThing(thing)) {
@@ -458,9 +683,10 @@ function derefStep(nav, thing, key) {
 			by: "own"
 		};
 	}
-	const envelope = fromJson(thing);
-	if (envelope !== void 0) {
-		const own = entryOf(envelope.own, "deref");
+	if (nav.plain !== true && isEnvelope(thing)) {
+		const envelope = thing;
+		const ownEntries = field(envelope, "own");
+		const own = isRecord(ownEntries) ? entryOf(ownEntries, "deref") : void 0;
 		const ownCode = own === void 0 ? void 0 : nav.derefs?.[own];
 		if (ownCode !== void 0) {
 			const reached = ownCode(envelope, key);
@@ -481,38 +707,43 @@ function derefStep(nav, thing, key) {
 		}
 		const reached = plainStep(envelope.value, key);
 		return reached === void 0 ? void 0 : {
-			thing: reached,
+			thing: reached.value,
 			by: "default"
 		};
 	}
 	const reached = plainStep(thing, key);
 	return reached === void 0 ? void 0 : {
-		thing: reached,
+		thing: reached.value,
 		by: "default"
 	};
 }
 /**
-* This function tells if a thing is a reference document: an envelope of the type `ref`.
+* 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 (thing === void 0 || isHostThing(thing)) return false;
-	const envelope = fromJson(thing);
-	if (envelope === void 0 || !Array.isArray(envelope.value)) return false;
-	const path = typePath(envelope.type);
+	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).
+* 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) {
-	return entriesAsJson(world.kinds);
+	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.
@@ -530,37 +761,94 @@ function context(parts = {}) {
 	};
 }
 const MAX_COLLAPSE = 64;
+const NO_HOPS = 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 resolves the common path without a record of hops: a root, then keys, through plain values. It
+* gives `undefined` when the path needs the full algorithm. Examples are a host thing, an envelope, a reference to
+* follow, a step document and a failure (for its exact reason).
+*/
+function resolveQuick(nav, ctx, path) {
+	const root = path[0];
+	if (root !== "names" && root !== "self" && root !== "event") return void 0;
+	if (nav.roots !== void 0 && !nav.roots.includes(root)) return void 0;
+	let here = ctx[root];
+	const plain = nav.plain === true;
+	for (let index = 1; index < path.length; index += 1) {
+		if (typeof here !== "object" || here === null) return void 0;
+		if (!plain && mayBeRef(here)) return void 0;
+		if (here[THING] === true) return void 0;
+		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 (!plain && isEnvelope(here)) return void 0;
+		here = here[step];
+	}
+	if (!plain && mayBeRef(here)) return void 0;
+	return {
+		ok: true,
+		thing: here,
+		hops: NO_HOPS
+	};
+}
 /**
 * 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 of its kind,
 * with the thing that the path reached. After each hop, a reference document is followed until the path reaches
-* something else (collapse).
+* 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.
 *
 * @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) {
-	const hops = [];
+function resolve(nav, ctx, path, options = {}) {
+	if (options.hops === false) {
+		const quick = resolveQuick(nav, ctx, path);
+		if (quick !== void 0) return quick;
+	}
+	const hops = options.hops === false ? void 0 : [];
+	const done = hops ?? NO_HOPS;
+	const failed = (code, reason) => ({
+		ok: false,
+		code,
+		reason,
+		hops: done
+	});
 	let collapses = 0;
 	const collapse = (thing) => {
 		let here = thing;
+		if (nav.plain === true) return {
+			ok: true,
+			thing: here,
+			hops: done
+		};
 		while (isRef(here)) {
 			collapses += 1;
-			if (collapses > MAX_COLLAPSE) return {
-				ok: false,
-				code: "#CYCLE!",
-				reason: "The references form a cycle.",
-				hops
-			};
+			if (collapses > MAX_COLLAPSE) return failed("#CYCLE!", "The references form a cycle.");
 			const inner = walk(here.value);
 			if (!inner.ok) return inner;
 			here = inner.thing;
-			hops.push({
-				step: here === null ? null : "collapse",
+			hops?.push({
+				step: "collapse",
 				thing: here,
 				by: "collapse"
 			});
@@ -568,19 +856,15 @@ function resolve(nav, ctx, path) {
 		return {
 			ok: true,
 			thing: here,
-			hops
+			hops: done
 		};
 	};
 	const walk = (steps) => {
-		const [root, ...rest] = steps;
-		if (typeof root !== "string" || !ROOTS.includes(root)) return {
-			ok: false,
-			code: "#REF!",
-			reason: `A path starts with a root: ${ROOTS.join(", ")}.`,
-			hops
-		};
+		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 = ctx[root];
-		hops.push({
+		hops?.push({
 			step: root,
 			thing: here,
 			by: "root"
@@ -588,46 +872,46 @@ function resolve(nav, ctx, path) {
 		const first = collapse(here);
 		if (!first.ok) return first;
 		here = first.thing;
-		for (const step of rest) {
+		for (let index = 1; index < steps.length; index += 1) {
+			const step = steps[index];
+			if (isHostThing(here) && here.resolve !== void 0 && steps.slice(index).every(isKey)) {
+				const keys = steps.slice(index);
+				const reached = here.resolve(keys);
+				if (reached === void 0) return failed("#N/A", `The path ${keys.join(".")} reaches nothing.`);
+				hops?.push({
+					step: keys,
+					thing: reached.thing,
+					by: "own"
+				});
+				return collapse(reached.thing);
+			}
 			if (isKey(step)) {
 				const reached = derefStep(nav, here, step);
-				if (reached === void 0) return {
-					ok: false,
-					code: "#REF!",
-					reason: `The step ${String(step)} reaches nothing.`,
-					hops
-				};
-				hops.push({
+				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.`);
+				}
+				hops?.push({
 					step,
 					thing: reached.thing,
 					by: reached.by
 				});
 				here = reached.thing;
 			} else {
-				const envelope = fromJson(step);
+				const envelope = isEnvelope(step) ? step : void 0;
 				const found = envelope === void 0 ? void 0 : lookupKind(nav.world, envelope.type);
 				const name = found?.ok === true ? entryOf(found.kind.verbs, "step") : void 0;
 				const walker = name === void 0 ? void 0 : nav.walkers?.[name];
-				if (envelope === void 0 || walker === void 0) return {
-					ok: false,
-					code: "#STEP?",
-					reason: "A step is a key, or a document of a kind with the verb step.",
-					hops
-				};
+				if (envelope === void 0 || walker === void 0) return failed("#STEP?", "A step is a key, or a document of a kind with the verb step.");
 				const result = walker({
 					data: envelope.value,
 					here,
 					context: ctx,
 					deref: (thing, key) => derefStep(nav, thing, key)?.thing
 				});
-				if (!result.ok) return {
-					ok: false,
-					code: "#REF!",
-					reason: result.reason,
-					hops
-				};
-				hops.push({
-					step,
+				if (!result.ok) return failed("#N/A", result.reason);
+				hops?.push({
+					step: envelope,
 					thing: result.thing,
 					by: "step"
 				});
@@ -640,19 +924,14 @@ function resolve(nav, ctx, path) {
 		return {
 			ok: true,
 			thing: here,
-			hops
+			hops: done
 		};
 	};
-	if (path.length === 0) return {
-		ok: false,
-		code: "#REF!",
-		reason: "A path has at least one step: its root.",
-		hops
-	};
+	if (path.length === 0) return failed("#REF!", "A path has at least one step: its root.");
 	return walk(path);
 }
 /**
-* This function gives the value of a thing: the thing itself for JSON, or the value that a host thing gives.
+* 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.
@@ -701,89 +980,173 @@ function tag(value, kind) {
 }
 //#endregion
 //#region src/parts.ts
+var Bad = class {
+	reason;
+	at;
+	constructor(reason, at) {
+		this.reason = reason;
+		this.at = at;
+	}
+};
+function setOwn$1(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+}
+function hasSlots(template) {
+	return template.t !== "data";
+}
 /**
-* This function splits a value into its data and its parts, by the contract of its kind. The evaluator and the
-* view use the same split, thus a picture shows the parts that the evaluation gets.
+* 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 spec - The contract of the parts.
+* @param shape - The shape of the value. The default is data.
 * @param value - The value of the document.
-* @returns The data and the parts, or the reason why the value does not obey the contract.
+* @returns The parts and a way to fill their places, or the reason why the value does not have the shape.
 */
-function splitParts(spec, value) {
-	const of = (slot, declared) => declared === void 0 ? slot : {
-		...slot,
-		of: declared
+function splitParts(shape, value) {
+	const parts = [];
+	const slot = (item, path, of) => {
+		parts.push({
+			path,
+			key: path.join("."),
+			item,
+			...of === void 0 ? {} : { of }
+		});
+		return {
+			t: "slot",
+			index: parts.length - 1
+		};
 	};
-	if (spec === void 0 || spec.shape === "none") return {
-		ok: true,
-		data: value,
-		parts: []
+	const deep = (item, path, of) => {
+		if (isEnvelope(item)) return slot(item, path, of);
+		if (Array.isArray(item)) {
+			const items = item.map((child, index) => deep(child, [...path, index], of));
+			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)]);
+			return fields.some(([, child]) => hasSlots(child)) ? {
+				t: "record",
+				fields
+			} : {
+				t: "data",
+				value: item
+			};
+		}
+		return {
+			t: "data",
+			value: item
+		};
 	};
-	if (spec.shape === "list") {
-		if (!Array.isArray(value)) return {
-			ok: false,
-			reason: "The value must be a list."
+	const walk = (spec, item, path) => {
+		if (spec === void 0 || spec.shape === "none") return {
+			t: "data",
+			value: item
 		};
+		if (spec.shape === "term") return slot(item, path, spec.of);
+		if (spec.shape === "deep") return deep(item, path, spec.of);
+		if (spec.shape === "list") {
+			if (!Array.isArray(item)) throw new Bad("The value must be a list.", path);
+			const each = spec.item ?? {
+				shape: "term",
+				...spec.of === void 0 ? {} : { of: spec.of }
+			};
+			return {
+				t: "list",
+				items: item.map((child, index) => walk(each, child, [...path, index]))
+			};
+		}
+		if (!isRecord(item)) throw new Bad("The value must be a record.", path);
+		if (spec.shape === "map") {
+			const each = spec.item ?? {
+				shape: "term",
+				...spec.of === void 0 ? {} : { of: spec.of }
+			};
+			return {
+				t: "record",
+				fields: Object.keys(item).map((key) => [key, walk(each, item[key], [...path, key])])
+			};
+		}
+		for (const name of spec.required ?? []) if (!Object.hasOwn(item, name)) throw new Bad(`The field ${name} is missing.`, path);
+		const named = Array.isArray(spec.fields) ? Object.fromEntries(spec.fields.map((name) => [name, {
+			shape: "term",
+			...spec.of === void 0 ? {} : { of: spec.of }
+		}])) : spec.fields;
+		const fields = [];
+		for (const key of Object.keys(item)) {
+			const fieldShape = Object.hasOwn(named, key) ? named[key] : spec.rest;
+			fields.push([key, walk(fieldShape, item[key], [...path, key])]);
+		}
 		return {
-			ok: true,
-			data: null,
-			parts: value.map((item, index) => of({
-				key: String(index),
-				item
-			}, spec.of))
+			t: "record",
+			fields
 		};
-	}
-	if (!isRecord(value)) return {
-		ok: false,
-		reason: "The value must be a record."
 	};
-	const record = value;
-	const rest = {};
-	for (const [key, item] of Object.entries(record)) if (!spec.fields.includes(key)) rest[key] = item;
-	const parts = [];
-	for (const key of spec.fields) {
-		const item = field(record, key);
-		if (item !== void 0) parts.push(of({
-			key,
-			item
-		}, spec.of));
+	let template;
+	try {
+		template = walk(shape, value, []);
+	} catch (error) {
+		if (error instanceof Bad) return {
+			ok: false,
+			reason: error.reason,
+			at: error.at
+		};
+		throw error;
 	}
-	return {
-		ok: true,
-		data: rest,
-		parts
+	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$1(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$1(out, key, fillWith(child, handles));
+		return out;
 	};
-}
-//#endregion
-//#region src/evaluate.ts
-/**
-* This function makes a result with a value.
-*
-* @param value - The value.
-* @returns The result.
-*/
-function ok(value) {
 	return {
 		ok: true,
-		value
+		parts,
+		data: strip(template) ?? null,
+		fill: (handles) => fillWith(template, handles)
 	};
 }
 /**
-* This function makes a result with an error value.
+* 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 code - The code of the error.
-* @param reason - One sentence that tells the cause.
-* @returns The result.
+* @param path - The path of the part.
+* @param pattern - The pattern.
+* @returns `true` when the path matches.
 */
-function fail(code, reason) {
-	return {
-		ok: false,
-		error: {
-			code,
-			reason
-		}
-	};
+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;
 }
+//#endregion
+//#region src/evaluate.ts
 /**
 * This function makes a context with names and capabilities. The other roots are empty, and an evaluation sets
 * the world.
@@ -801,194 +1164,557 @@ function makeContext(names = {}, caps = [], self = null) {
 	});
 }
 /**
+* This function gives the keys of a capability or of a kind of effect: a text is split at its dots.
+*
+* @param kind - The text or the keys.
+* @returns The keys, as texts.
+*/
+function capKeys(kind) {
+	return typeof kind === "string" ? kind.split(".") : kind.map(String);
+}
+/**
 * This function tells if the capabilities permit an effect. A capability permits the kind of its name, and each kind
-* in its namespace: `store` permits `store.update`.
+* under it: `store` permits `store.update`. The comparison is key by key, thus `fs.read` does not permit the
+* kind with the keys `fs` and `read.json`.
 *
 * @param caps - The capabilities of the context.
-* @param kind - The kind of the effect.
+* @param kind - The kind of the effect: a text with dots, or its keys.
 * @returns `true` when one capability permits it.
 */
 function permits(caps, kind) {
-	return caps.some((cap) => cap === kind || kind.startsWith(`${cap}.`));
+	const want = capKeys(kind);
+	return caps.some((cap) => {
+		const have = capKeys(cap);
+		return have.length <= want.length && have.every((key, index) => key === want[index]);
+	});
+}
+/**
+* This function narrows a context for a part: the part keeps only the capabilities that the context of its parent
+* permits. Thus an evaluator cannot give a part more effects than it has.
+*
+* @param parent - The context of the parent.
+* @param next - The context that the evaluator gives the part.
+* @returns The context of the part.
+*/
+function narrow(parent, next) {
+	if (next === parent || next.caps === parent.caps) return next;
+	const caps = next.caps.filter((cap) => permits(parent.caps, cap));
+	return caps.length === next.caps.length ? next : {
+		...next,
+		caps
+	};
 }
 function selfLabel(self) {
-	if (isHostThing(self)) return self.label;
-	return self === null ? "none" : JSON.stringify(self).slice(0, 40);
+	try {
+		if (isHostThing(self)) return self.label;
+		if (self === null || self === void 0) return "none";
+		return (JSON.stringify(self) ?? describe(self)).slice(0, 40);
+	} catch {
+		return describe(self).slice(0, 40);
+	}
 }
 const NO_ANSWER = {
 	verb: "eval",
 	error: "no-answer",
 	steps: []
 };
+/** This class holds the state of one evaluation or run: the machine, the effects, the clock and the trace. */
+var Session = class {
+	machine;
+	running;
+	traced;
+	perform;
+	signal;
+	effects;
+	tick = 0;
+	nextId = 0;
+	current;
+	holder;
+	constructor(machine, running, traced, perform, signal, effects) {
+		this.machine = machine;
+		this.running = running;
+		this.traced = traced;
+		this.perform = perform;
+		this.signal = signal;
+		this.effects = effects ?? [];
+		this.holder = traced ? holderNode() : void 0;
+		this.current = this.holder;
+	}
+	resolve(ctx, path, options) {
+		return resolve(this.machine, ctx, path, { hops: options?.hops ?? this.traced });
+	}
+	permitted(ctx, keys) {
+		return this.machine.permits === void 0 ? permits(ctx.caps, keys) : this.machine.permits(ctx.caps, keys, ctx);
+	}
+	record(ctx, kind, payload, place) {
+		const keys = typeof kind === "string" ? kind.split(".") : kind;
+		const text = keys.join(".");
+		if (!this.permitted(ctx, keys)) return fail("#CAP!", `The context has no capability for the effect ${text}.`, { place });
+		const node = this.current;
+		const effect = {
+			index: this.effects.length,
+			kind: text,
+			path: keys,
+			payload,
+			node: node?.id ?? -1,
+			at: this.tick,
+			place,
+			context: ctx
+		};
+		this.effects.push(effect);
+		if (node !== void 0) node.effects.push(effect.index);
+		return effect;
+	}
+	effect(ctx, kind, payload, place) {
+		const text = typeof kind === "string" ? kind : kind.join(".");
+		if (this.running) return fail("#CALC!", `The effect ${text} needs a runner: in a run, the host does each effect.`, { place });
+		const made = this.record(ctx, kind, payload, place);
+		return "ok" in made ? made : ok(payload);
+	}
+	*runEffect(ctx, kind, payload, place) {
+		const made = this.record(ctx, kind, payload, place);
+		if ("ok" in made) return made;
+		const perform = this.perform;
+		if (!this.running || perform === void 0) return ok(payload);
+		const failed = (error) => fail("#CALC!", `The host failed the effect ${made.kind}: ${describe(error)}`, {
+			place,
+			cause: error
+		});
+		let done;
+		try {
+			done = perform(made);
+		} catch (error) {
+			return failed(error);
+		}
+		if (!(done instanceof Promise)) return ok(done);
+		return yield done.then((value) => ok(value), failed);
+	}
+	*all(list, options = {}) {
+		const results = new Array(list.length);
+		const limit = Math.max(1, options.concurrency ?? list.length);
+		const active = [];
+		let next = 0;
+		const advance = (index, steps, input) => {
+			let step;
+			try {
+				step = input.threw ? steps.throw(input.error) : steps.next(input.value);
+			} catch (error) {
+				results[index] = thrown(error, "a part");
+				return;
+			}
+			if (step.done === true) {
+				results[index] = step.value;
+				return;
+			}
+			const item = {
+				index,
+				steps,
+				pending: Promise.resolve()
+			};
+			item.pending = step.value.then((value) => ({
+				item,
+				value,
+				threw: false
+			}), (error) => ({
+				item,
+				error,
+				threw: true
+			}));
+			active.push(item);
+		};
+		const start = () => {
+			while (active.length < limit && next < list.length) {
+				const index = next;
+				next += 1;
+				const begin = list[index];
+				let steps;
+				try {
+					steps = begin();
+				} catch (error) {
+					results[index] = thrown(error, "a part");
+					continue;
+				}
+				advance(index, steps, { threw: false });
+			}
+		};
+		start();
+		while (active.length > 0) {
+			const settled = yield Promise.race(active.map((item) => item.pending));
+			active.splice(active.indexOf(settled.item), 1);
+			advance(settled.item.index, settled.item.steps, settled);
+			start();
+		}
+		return results;
+	}
+	enter(meta, ctx) {
+		const node = {
+			id: this.nextId,
+			path: meta.path,
+			doc: meta.doc,
+			declared: meta.declared,
+			answer: meta.answer,
+			side: meta.side,
+			names: Object.keys(ctx.names),
+			scope: ctx.names,
+			caps: ctx.caps,
+			self: selfLabel(ctx.self),
+			enter: this.tick,
+			exit: this.tick,
+			result: fail("#NOEVAL", "The evaluation did not end."),
+			children: [],
+			effects: []
+		};
+		this.nextId += 1;
+		this.tick += 1;
+		(this.current ?? this.holder).children.push(node);
+		return node;
+	}
+	exit(node, result) {
+		node.result = result;
+		node.exit = this.tick;
+		this.tick += 1;
+	}
+};
+function holderNode() {
+	return {
+		id: -1,
+		path: [],
+		doc: {
+			type: "?",
+			value: null
+		},
+		declared: false,
+		answer: NO_ANSWER,
+		side: "derive",
+		names: [],
+		scope: {},
+		caps: [],
+		self: "none",
+		enter: 0,
+		exit: 0,
+		result: ok(null),
+		children: [],
+		effects: []
+	};
+}
 /** This function drives steps that cannot wait. */
 function drive(steps) {
 	const step = steps.next();
 	if (step.done === true) return step.value;
 	step.value.catch(() => void 0);
+	steps.return(fail("#CALC!", "A part waited, and its parent cannot wait."));
 	return fail("#CALC!", "A part waited, and its parent cannot wait.");
 }
+const ABORTED = Symbol("aborted");
 /** This function drives steps that can wait. The steps before the first wait happen at once, in the call. */
-async function driveWaiting(steps) {
+async function driveWaiting(steps, signal) {
+	const abort = () => {
+		const reason = fail("#ABORT", `The host stopped the run: ${describe(signal?.reason ?? "no reason")}`, { cause: signal?.reason });
+		try {
+			steps.return(reason);
+		} catch {}
+		return reason;
+	};
+	const aborted = signal === void 0 ? void 0 : new Promise((resolve) => {
+		if (signal.aborted) resolve(ABORTED);
+		else signal.addEventListener("abort", () => resolve(ABORTED), { once: true });
+	});
+	if (signal?.aborted === true) return abort();
 	let step = steps.next();
 	while (step.done !== true) {
 		let value;
 		try {
-			value = await step.value;
+			value = aborted === void 0 ? await step.value : await Promise.race([step.value, aborted]);
 		} catch (error) {
 			step = steps.throw(error);
 			continue;
 		}
+		if (value === ABORTED) return abort();
 		step = steps.next(value);
 	}
 	return step.value;
 }
-function* visit(s, value, path, declared, ctx, parent, canWait) {
-	const envelope = fromJson(value);
-	const doc = envelope ?? typed(declared ?? "?", value);
-	const node = {
-		id: s.nextId,
-		path,
+function isCompiledEvaluator(evaluator) {
+	return typeof evaluator === "object" && evaluator !== null && typeof evaluator.compile === "function";
+}
+function isCompiledRunner(runner) {
+	return typeof runner === "object" && runner !== null && typeof runner.compileRun === "function";
+}
+function failing(c, meta, place, code, reason) {
+	const result = fail(code, reason, { place });
+	const plain = () => result;
+	return finish(c, meta, plain, function* () {
+		return result;
+	});
+}
+function finish(c, meta, code, run) {
+	if (!c.traced) return {
+		code,
+		run
+	};
+	const tracedCode = (ctx, rt) => {
+		const s = rt;
+		const node = s.enter(meta, ctx);
+		const before = s.current;
+		s.current = node;
+		let result;
+		try {
+			result = code(ctx, rt);
+		} finally {
+			s.current = before;
+		}
+		s.exit(node, result);
+		return result;
+	};
+	const tracedRun = function* (ctx, rt) {
+		const s = rt;
+		const node = s.enter(meta, ctx);
+		const steps = run(ctx, rt);
+		let input;
+		let threw = false;
+		for (;;) {
+			const before = s.current;
+			s.current = node;
+			let step;
+			try {
+				step = threw ? steps.throw(input) : steps.next(input);
+			} finally {
+				s.current = before;
+			}
+			if (step.done === true) {
+				s.exit(node, step.value);
+				return step.value;
+			}
+			try {
+				input = yield step.value;
+				threw = false;
+			} catch (error) {
+				input = error;
+				threw = true;
+			}
+		}
+	};
+	return {
+		code: tracedCode,
+		run: tracedRun
+	};
+}
+function compileNode(c, value, place, declared, depth) {
+	const envelope = isEnvelope(value) ? value : void 0;
+	const doc = envelope ?? {
+		type: declared ?? "?",
+		value
+	};
+	const meta0 = {
+		path: place.map(String),
 		doc,
 		declared: envelope === void 0,
 		answer: NO_ANSWER,
-		side: "derive",
-		names: Object.keys(ctx.names),
-		scope: ctx.names,
-		caps: ctx.caps,
-		self: selfLabel(ctx.self),
-		enter: s.tick,
-		exit: s.tick,
-		result: fail("#NOEVAL", "The evaluation did not end."),
-		children: [],
-		effects: []
+		side: "derive"
 	};
-	s.nextId += 1;
-	s.tick += 1;
-	parent.children.push(node);
-	const finish = (result) => {
-		node.result = result;
-		node.exit = s.tick;
-		s.tick += 1;
-		return result;
+	if (envelope === void 0 && declared === void 0) return failing(c, meta0, place, "#PART?", "The value has no envelope, and its position declares no type.");
+	if (depth > c.maxDepth) return failing(c, meta0, place, "#DEPTH!", `The nesting is deeper than ${c.maxDepth} documents.`);
+	const answer = ask(c.machine.world, envelope ?? {}, "eval", declared === void 0 ? {} : { declaredType: declared });
+	const found = lookupKind(c.machine.world, doc.type);
+	const kind = found.ok ? found.kind : void 0;
+	const meta = {
+		...meta0,
+		answer,
+		side: kind?.side ?? "derive"
 	};
-	if (envelope === void 0 && declared === void 0) return finish(fail("#PART?", "The value has no envelope, and its position declares no type."));
-	const maxDepth = s.machine.maxDepth ?? 200;
-	if (path.length > maxDepth) return finish(fail("#DEPTH!", `The nesting is deeper than ${maxDepth} documents.`));
-	const answer = ask(s.machine.world, envelope ?? {}, "eval", declared === void 0 ? {} : { declaredType: declared });
-	node.answer = answer;
-	const kind = kindOf(s.machine.world, doc.type);
-	node.side = kind?.side ?? "derive";
-	if (answer.error === "unknown-kind") return finish(fail("#KIND?", `The world has no kind ${typeName(doc.type)}.`));
+	const kindText = typeName(doc.type);
+	if (answer.error === "unknown-kind") return failing(c, meta, place, "#KIND?", `The world has no kind ${kindText}.`);
 	const name = answer.evaluator;
-	const runners = s.machine.runners ?? {};
+	const runners = c.machine.runners ?? {};
 	const runner = name !== void 0 && Object.hasOwn(runners, name) ? runners[name] : void 0;
-	const code = name !== void 0 && Object.hasOwn(s.machine.evaluators, name) ? s.machine.evaluators[name] : void 0;
-	if (name === void 0 || runner === void 0 && code === void 0) return finish(fail("#NOEVAL", `No rung gives an evaluator for ${typeName(doc.type)}.`));
-	if (runner !== void 0 && s.running && !canWait) return finish(fail("#CALC!", `${typeName(doc.type)} waits for effects, and its parent cannot wait. Give the parent a runner.`));
+	const evaluator = name !== void 0 && Object.hasOwn(c.machine.evaluators, name) ? c.machine.evaluators[name] : void 0;
+	if (name === void 0 || runner === void 0 && evaluator === void 0) return failing(c, meta, place, "#NOEVAL", `No rung gives an evaluator for ${kindText}.`);
 	const split = splitParts(kind?.parts, doc.value);
-	if (!split.ok) return finish(fail("#VALUE!", `${split.reason} The kind is ${typeName(doc.type)}.`));
-	const slots = split.parts.map((slot) => ({
-		slot,
-		header: fromJson(slot.item)
-	}));
-	const record = (effectKind, payload) => {
-		if (!permits(ctx.caps, effectKind)) return fail("#CAP!", `The context has no capability for the effect ${effectKind}.`);
-		const effect = {
-			index: s.effects.length,
-			kind: effectKind,
-			payload,
-			node: node.id,
-			at: s.tick
+	if (!split.ok) {
+		const at = split.at.length === 0 ? "" : ` (at ${split.at.join(".")})`;
+		return failing(c, meta, place, "#VALUE!", `${split.reason}${at} The kind is ${kindText}.`);
+	}
+	const parts = split.parts.map((slot) => {
+		const compiled = compileNode(c, slot.item, [...place, ...slot.path], slot.of, depth + 1);
+		const header = isEnvelope(slot.item) && isRecord(slot.item) && typeof slot.item["name"] === "string" ? slot.item["name"] : void 0;
+		return {
+			key: slot.key,
+			path: slot.path,
+			...header === void 0 ? {} : { name: header },
+			code: compiled.code,
+			run: compiled.run
 		};
-		s.effects.push(effect);
-		node.effects.push(effect.index);
-		return effect;
+	});
+	const input = {
+		kind: kindText,
+		typePath: found.ok ? found.path : [],
+		doc,
+		value: split.parts.length === 0 ? doc.value : split.fill(parts),
+		data: split.data,
+		parts,
+		place,
+		machine: c.machine
 	};
-	const kindText = typeName(doc.type);
-	const resolveHere = (steps) => resolve(s.machine, ctx, steps);
+	const who = `the evaluator ${name}`;
 	if (runner !== void 0) {
-		const parts = slots.map(({ slot, header }) => ({
-			key: slot.key,
-			...header?.name === void 0 ? {} : { name: header.name },
-			evaluate: (override) => visit(s, slot.item, [...path, slot.key], slot.of, override ?? ctx, node, true)
-		}));
-		const input = {
-			kind: kindText,
-			data: split.data,
-			parts,
-			context: ctx,
-			resolve: resolveHere,
-			effect: function* (effectKind, payload) {
-				const made = record(effectKind, payload);
-				if ("ok" in made) return made;
-				if (!s.running || s.perform === void 0) return ok(payload);
-				const failed = (error) => fail("#CALC!", `The host failed the effect ${effectKind}: ${String(error)}`);
-				let done;
-				try {
-					done = s.perform(made);
-				} catch (error) {
-					return failed(error);
-				}
-				if (!(done instanceof Promise)) return ok(done ?? null);
-				return yield done.then((result) => ok(result ?? null), failed);
+		const inner = isCompiledRunner(runner) ? runner.compileRun(input) : interpretRun(runner, input, split.fill);
+		const run = function* (ctx, rt) {
+			try {
+				return placed(yield* inner(ctx, rt), place);
+			} catch (error) {
+				return placed(thrown(error, `the runner ${name}`), place);
 			}
 		};
+		const code = (ctx, rt) => rt.running ? fail("#CALC!", `${kindText} waits for effects, and its parent cannot wait. Give the parent a runner.`, { place }) : drive(run(ctx, rt));
+		return finish(c, meta, code, run);
+	}
+	const inner = isCompiledEvaluator(evaluator) ? evaluator.compile(input) : interpret(evaluator, input, split.fill);
+	const code = (ctx, rt) => {
 		try {
-			return finish(yield* runner(input));
+			return placed(inner(ctx, rt), place);
 		} catch (error) {
-			return finish(fail("#CALC!", `The runner ${name} threw: ${String(error)}`));
-		}
-	}
-	const parts = slots.map(({ slot, header }) => ({
-		key: slot.key,
-		...header?.name === void 0 ? {} : { name: header.name },
-		evaluate: (override) => drive(visit(s, slot.item, [...path, slot.key], slot.of, override ?? ctx, node, false))
-	}));
-	const input = {
-		kind: kindText,
-		data: split.data,
-		parts,
-		context: ctx,
-		resolve: resolveHere,
-		effect: (effectKind, payload) => {
-			if (s.running) return fail("#CALC!", `The effect ${effectKind} needs a runner: in a run, the host does each effect.`);
-			const made = record(effectKind, payload);
-			return "ok" in made ? made : ok(payload);
+			return placed(thrown(error, who), place);
 		}
 	};
+	return finish(c, meta, code, function* (ctx, rt) {
+		return code(ctx, rt);
+	});
+}
+function interpret(fn, input, fill) {
+	const { kind, typePath, doc, data, place } = input;
+	const compiled = input.parts;
+	const hasParts = compiled.length > 0;
+	return (ctx, rt) => {
+		const parts = compiled.map((part) => ({
+			key: part.key,
+			path: part.path,
+			...part.name === void 0 ? {} : { name: part.name },
+			evaluate: (override) => part.code(override === void 0 ? ctx : narrow(ctx, override), rt)
+		}));
+		return fn({
+			kind,
+			typePath,
+			doc,
+			value: hasParts ? fill(parts) : doc.value,
+			data,
+			parts,
+			context: ctx,
+			place,
+			resolve: (path, options) => rt.resolve(ctx, path, options),
+			effect: (effectKind, payload) => rt.effect(ctx, effectKind, payload, place)
+		});
+	};
+}
+function interpretRun(fn, input, fill) {
+	const { kind, typePath, doc, data, place } = input;
+	const compiled = input.parts;
+	const hasParts = compiled.length > 0;
+	return (ctx, rt) => {
+		const parts = compiled.map((part) => ({
+			key: part.key,
+			path: part.path,
+			...part.name === void 0 ? {} : { name: part.name },
+			evaluate: (override) => part.run(override === void 0 ? ctx : narrow(ctx, override), rt)
+		}));
+		return fn({
+			kind,
+			typePath,
+			doc,
+			value: hasParts ? fill(parts) : doc.value,
+			data,
+			parts,
+			context: ctx,
+			place,
+			resolve: (path, options) => rt.resolve(ctx, path, options),
+			effect: (effectKind, payload) => rt.runEffect(ctx, effectKind, payload, place),
+			all: (list, options) => rt.all(list.map((part) => () => part.evaluate()), options)
+		});
+	};
+}
+function rootContext(machine, ctx) {
+	return ctx.world === null ? {
+		...ctx,
+		world: worldThing(machine.world)
+	} : ctx;
+}
+/**
+* This function compiles a document into a plan. The ladder, the kinds and the parts are known after it. A plan
+* evaluates many times. A document that does not compile gives a plan that fails with the reason, when it evaluates.
+*
+* @param machine - The world and the code of the evaluators.
+* @param doc - The document, as JSON.
+* @param options - The type of a bare root value, and a trace.
+* @returns The plan.
+*/
+function prepare(machine, doc, options = {}) {
+	const c = {
+		machine,
+		traced: options.trace === true,
+		maxDepth: machine.maxDepth ?? 1e3
+	};
+	let root;
 	try {
-		return finish(code(input));
+		root = compileNode(c, doc, [], options.declaredType, 0);
 	} catch (error) {
-		return finish(fail("#CALC!", `The evaluator ${name} threw: ${String(error)}`));
-	}
-}
-function holderNode() {
-	return {
-		id: -1,
-		path: [],
-		doc: typed("?", null),
-		declared: false,
-		answer: NO_ANSWER,
-		side: "derive",
-		names: [],
-		scope: {},
-		caps: [],
-		self: "none",
-		enter: 0,
-		exit: 0,
-		result: ok(null),
-		children: [],
-		effects: []
+		const result = thrown(error, "the compilation");
+		root = {
+			code: () => result,
+			run: function* () {
+				return result;
+			}
+		};
+	}
+	const compiled = {
+		key: "",
+		path: [],
+		code: root.code,
+		run: root.run
+	};
+	return {
+		machine,
+		traced: c.traced,
+		root: compiled,
+		evaluate(context = makeContext(), evalOptions = {}) {
+			const s = new Session(machine, false, c.traced, void 0, void 0, evalOptions.effects);
+			return root.code(rootContext(machine, context), s);
+		},
+		run(context = makeContext(), runOptions = {}) {
+			const s = new Session(machine, true, c.traced, runOptions.perform, runOptions.signal, void 0);
+			return driveWaiting(root.run(rootContext(machine, context), s), runOptions.signal);
+		}
 	};
 }
-function rootContext(machine, context) {
-	return context.world === null ? {
-		...context,
-		world: worldThing(machine.world)
-	} : context;
+/**
+* This function makes a cache of plans for one machine. A document object compiles one time. Use it only for
+* documents that do not change after they are made.
+*
+* @param machine - The machine.
+* @param options - The options of each compilation.
+* @returns A function that gives the plan of a document.
+*/
+function planner(machine, options = {}) {
+	const objects = /* @__PURE__ */ new WeakMap();
+	const values = /* @__PURE__ */ new Map();
+	return (doc) => {
+		if (typeof doc === "object" && doc !== null) {
+			let plan = objects.get(doc);
+			if (plan === void 0) {
+				plan = prepare(machine, doc, options);
+				objects.set(doc, plan);
+			}
+			return plan;
+		}
+		let plan = values.get(doc);
+		if (plan === void 0) {
+			plan = prepare(machine, doc, options);
+			if (values.size > 1e3) values.clear();
+			values.set(doc, plan);
+		}
+		return plan;
+	};
 }
-function record(s, holder, result) {
-	const root = holder.children[0];
+function record(s, result) {
+	const root = s.holder?.children[0];
 	if (root === void 0) throw new Error("The evaluation made no trace.");
 	return {
 		result,
@@ -1011,39 +1737,31 @@ function record(s, holder, result) {
 * @returns The result, the trace and the effects in their order.
 */
 function evaluate(machine, doc, context = makeContext(), declaredType) {
-	const s = {
-		machine,
-		running: false,
-		perform: void 0,
-		effects: [],
-		tick: 0,
-		nextId: 0
-	};
-	const holder = holderNode();
-	return record(s, holder, drive(visit(s, doc, [], declaredType, rootContext(machine, context), holder, false)));
+	const plan = prepare(machine, doc, {
+		trace: true,
+		...declaredType === void 0 ? {} : { declaredType }
+	});
+	const s = new Session(machine, false, true, void 0, void 0, void 0);
+	return record(s, plan.root.code(rootContext(machine, context), 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.
+* 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, and the type of a bare root value.
+* @param options - The host code that does the effects, the type of a bare root value, and a signal.
 * @returns The result, the trace and the effects in their order, when the run ends.
 */
 async function run(machine, doc, context = makeContext(), options = {}) {
-	const s = {
-		machine,
-		running: true,
-		perform: options.perform,
-		effects: [],
-		tick: 0,
-		nextId: 0
-	};
-	const holder = holderNode();
-	return record(s, holder, await driveWaiting(visit(s, doc, [], options.declaredType, rootContext(machine, context), holder, true)));
+	const plan = prepare(machine, doc, {
+		trace: true,
+		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType }
+	});
+	const s = new Session(machine, true, true, options.perform, options.signal, void 0);
+	return record(s, await driveWaiting(plan.root.run(rootContext(machine, context), s), options.signal));
 }
 /**
 * This function finds a node of a trace by its path.
@@ -1053,10 +1771,16 @@ async function run(machine, doc, context = makeContext(), options = {}) {
 * @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;
-	for (const key of path) {
-		node = node?.children.find((child) => child.path[child.path.length - 1] === key);
-		if (node === void 0) return void 0;
+	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;
 }
@@ -1068,13 +1792,24 @@ function nodeAt(trace, path) {
 */
 function flatten(trace) {
 	const out = [];
-	const walk = (node) => {
+	const stack = [trace];
+	while (stack.length > 0) {
+		const node = stack.pop();
 		out.push(node);
-		node.children.forEach(walk);
-	};
-	walk(trace);
+		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);
+}
 //#endregion
 //#region src/stdlib.ts
 /**
@@ -1222,6 +1957,15 @@ const STD_WORLD = {
 				view: "view.seq"
 			},
 			parts: { shape: "list" },
+			scope: [{
+				names: { headers: true },
+				in: [["*"]],
+				sequential: true
+			}, {
+				names: { fixed: ["last"] },
+				in: [["*"]],
+				sequential: true
+			}],
 			summary: "Its steps, in order. The result of a named step is a name for the later steps."
 		},
 		pure: {
@@ -1306,11 +2050,8 @@ const STD_EVALUATORS = {
 	},
 	"ref.resolve": ({ data, resolve }) => {
 		if (!Array.isArray(data) || data.length === 0) return fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
-		const path = data;
-		const found = resolve(path);
-		if (found.ok) return ok(valueOfThing(found.thing));
-		if (path[0] === "names" && found.hops.length === 1) return fail("#NAME?", `The context has no name ${String(path[1])}.`);
-		return fail(found.code, found.reason);
+		const found = resolve(data);
+		return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
 	},
 	"tree.node": (input) => treeNode(input.parts, input.context, input.kind)
 };
@@ -1360,34 +2101,44 @@ function treeNode(parts, context, type) {
 	}
 	return ok(out);
 }
+function hostType(node, wanted) {
+	return isHostThing(node) && node.type === wanted;
+}
 /**
-* The walker of `nearest`: it follows a key (the default is `parent`) until the node that it reaches has the
-* wanted type. With `self: true`, the node where the walk starts is the first candidate. A node without that key
-* ends the walk with an error.
+* This function makes a walker `nearest`. The walker follows a key (the default is `parent`) until the node that it
+* reaches has the wanted type. With `self: true`, the node where the walk starts is the first candidate. A node
+* without that key ends the walk with an error.
+*
+* @param options - The test of a type and the most hops.
+* @returns The walker.
 */
-const nearest = ({ data, here, deref }) => {
-	const follow = isRecord(data) && typeof field(data, "follow") === "string" ? String(field(data, "follow")) : "parent";
-	const wanted = isRecord(data) ? field(data, "type") : void 0;
-	const fromSelf = isRecord(data) && field(data, "self") === true;
-	let at = here;
-	for (let hops = 0; hops < 256; hops += 1) {
-		if (hops > 0 || !fromSelf) at = at === void 0 || at === null ? void 0 : deref(at, follow);
-		if (at === void 0 || at === null) return {
+function nearestWalker(options = {}) {
+	const matches = options.matches ?? hostType;
+	const maxHops = options.maxHops ?? 256;
+	return ({ data, here, deref }) => {
+		const follow = isRecord(data) && typeof field(data, "follow") === "string" ? String(field(data, "follow")) : "parent";
+		const wanted = isRecord(data) ? field(data, "type") : void 0;
+		const fromSelf = isRecord(data) && field(data, "self") === true;
+		let at = here;
+		for (let hops = 0; hops < maxHops; hops += 1) {
+			if (hops > 0 || !fromSelf) at = at === void 0 || at === null ? void 0 : deref(at, follow);
+			if (at === void 0 || at === null) return {
+				ok: false,
+				reason: `No node of the type ${String(wanted)} is on the way.`
+			};
+			if (matches(at, wanted)) return {
+				ok: true,
+				thing: at
+			};
+		}
+		return {
 			ok: false,
-			reason: `No node of the type ${String(wanted)} is on the way.`
-		};
-		if ((isHostThing(at) ? at.type : void 0) === wanted) return {
-			ok: true,
-			thing: at
+			reason: "The walk is too long."
 		};
-	}
-	return {
-		ok: false,
-		reason: "The walk is too long."
 	};
-};
+}
 /** The walkers of the standard world, by name. */
-const STD_WALKERS = { "walk.nearest": nearest };
+const STD_WALKERS = { "walk.nearest": nearestWalker() };
 /** This function evaluates parts one after the other, and stops at the first error. */
 function* inOrder(parts) {
 	const values = [];
@@ -1573,26 +2324,26 @@ function layers(steps) {
 //#region src/context.ts
 /** The parts of a context. A term can reach outside itself only through these parts. */
 const PARTS = [
+	"self",
 	"names",
-	"focus",
 	"world",
 	"event",
 	"caps"
 ];
 /** The descriptions of the parts, in the order of `PARTS`. */
 const PART_INFO = [
+	{
+		part: "self",
+		title: "Self",
+		reaches: "A position in a structure: the node itself, its parent, its children or its siblings.",
+		direction: "Any direction that a move permits: up, down or to the side."
+	},
 	{
 		part: "names",
 		title: "Names",
 		reaches: "The values that a binding gives: a let, a parameter, or the result of an earlier step.",
 		direction: "Back, to the place where the program binds the name."
 	},
-	{
-		part: "focus",
-		title: "Focus",
-		reaches: "A position in a structure: the node itself, its parent, its children or its siblings.",
-		direction: "Any direction that a move permits: up, down or to the side."
-	},
 	{
 		part: "world",
 		title: "World",
@@ -1625,15 +2376,22 @@ const CONSTRUCTS = [
 		side: "derive",
 		summary: "A pure formula that gives a value at one position of a structure.",
 		example: {
-			type: "formula",
+			type: "let",
 			value: {
-				let: { gap: 8 },
+				bind: { gap: 8 },
 				body: {
-					op: "add",
-					args: [{
-						ref: "width",
-						at: "parent"
-					}, { var: "gap" }]
+					type: ["ops", "add"],
+					value: [{
+						type: "ref",
+						value: [
+							"self",
+							"parent",
+							"width"
+						]
+					}, {
+						type: "ref",
+						value: ["names", "gap"]
+					}]
 				}
 			}
 		},
@@ -1643,10 +2401,10 @@ const CONSTRUCTS = [
 				gives: "extends",
 				note: "A let binds names for its body."
 			},
-			focus: {
+			self: {
 				reads: true,
 				gives: "moves",
-				note: "A move reads the parent. An axis moves the focus to each target."
+				note: "A move reads the parent. An axis moves self to each target."
 			},
 			world: NONE,
 			event: NONE,
@@ -1665,15 +2423,19 @@ const CONSTRUCTS = [
 		example: {
 			type: "seq",
 			value: [{
-				type: "store.find",
+				type: ["store", "find"],
 				value: { match: { board: "b1" } },
 				name: "cards"
 			}, {
-				type: "store.patch",
+				type: ["store", "patch"],
 				value: {
 					ids: {
 						type: "ref",
-						value: "cards.ids"
+						value: [
+							"names",
+							"cards",
+							"ids"
+						]
 					},
 					set: { done: true }
 				}
@@ -1685,7 +2447,7 @@ const CONSTRUCTS = [
 				gives: "extends",
 				note: "The result of each step is a name for the later steps."
 			},
-			focus: NONE,
+			self: NONE,
 			world: {
 				reads: true,
 				gives: "same",
@@ -1716,7 +2478,7 @@ const CONSTRUCTS = [
 					type: "text",
 					value: {
 						type: "ref",
-						value: "title"
+						value: ["names", "title"]
 					}
 				}]
 			}
@@ -1727,10 +2489,10 @@ const CONSTRUCTS = [
 				gives: "extends",
 				note: "The data of the node becomes a name for its children."
 			},
-			focus: {
+			self: {
 				reads: true,
 				gives: "moves",
-				note: "Each child becomes the focus of its own part."
+				note: "Each child becomes self for its own part."
 			},
 			world: {
 				reads: true,
@@ -1747,11 +2509,8 @@ const CONSTRUCTS = [
 		side: "derive",
 		summary: "A rule that gives the box of a child from the box of its parent.",
 		example: {
-			type: "rule",
-			value: {
-				use: "stack",
-				with: { gap: 8 }
-			}
+			type: ["layouts", "stack"],
+			value: { gap: 8 }
 		},
 		uses: {
 			names: {
@@ -1759,7 +2518,7 @@ const CONSTRUCTS = [
 				gives: "none",
 				note: "The rule reads its parameters."
 			},
-			focus: {
+			self: {
 				reads: true,
 				gives: "none",
 				note: "The rule reads the box of the parent and the key of the child."
@@ -1781,10 +2540,10 @@ const CONSTRUCTS = [
 				run: {
 					type: "seq",
 					value: [{
-						type: "card.toggle",
+						type: ["card", "toggle"],
 						value: { id: {
 							type: "ref",
-							value: "event.target"
+							value: ["event", "target"]
 						} }
 					}]
 				}
@@ -1796,7 +2555,7 @@ const CONSTRUCTS = [
 				gives: "same",
 				note: "The handler reads the names of its place."
 			},
-			focus: {
+			self: {
 				reads: true,
 				gives: "same",
 				note: "The handler knows the node that got the event."
@@ -1829,7 +2588,7 @@ const CONSTRUCTS = [
 				collection: "cards",
 				match: { board: {
 					type: "ref",
-					value: "board"
+					value: ["names", "board"]
 				} }
 			}
 		},
@@ -1839,7 +2598,7 @@ const CONSTRUCTS = [
 				gives: "none",
 				note: "The query reads its parameters."
 			},
-			focus: NONE,
+			self: NONE,
 			world: {
 				reads: true,
 				gives: "none",
@@ -1851,6 +2610,769 @@ const CONSTRUCTS = [
 	}
 ];
 //#endregion
-export { CONSTRUCTS, ENVELOPE_KEYS, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_EVALUATORS, STD_MACHINE, STD_RUNNERS, STD_WALKERS, STD_WORLD, THING, ask, checkSteps, classify, context, dataEdges, derefStep, effectEdges, entriesAsJson, evaluate, fail, field, flatten, fromJson, isAlias, isAllowedOrder, isEnvelope, isHostThing, isKey, isKind, isRecord, isRef, isTypeRef, kindDocument, kindNamed, kindOf, layers, lookupKind, makeContext, nodeAt, ok, permits, ref, resolve, run, splitParts, tag, toJson, typeName, typePath, typed, valueOfThing, worldThing };
+//#region src/static.ts
+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);
+}
+/** The names that the scope rules of a kind give each part, and the names that only later parts see. */
+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);
+			});
+			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 {
+		sees,
+		later
+	};
+}
+/**
+* This function visits each document of a document: the root and each part at each depth, by the contracts of the
+* kinds. A part of a kind that the world does not have is not visited. The walk uses no stack of the host for the
+* depth, thus a deep document cannot overflow it.
+*
+* @param world - The world of the kinds.
+* @param doc - The document, as JSON.
+* @param visit - The function that gets each document. It gives `"skip"` to not visit the parts of a document.
+* @param options - The type of a bare root value, the names of the host, and a function for the problems.
+*/
+function walk(world, doc, visit, options = {}) {
+	const stack = [{
+		value: doc,
+		place: [],
+		at: [],
+		declared: options.declaredType,
+		depth: 0,
+		names: new Set(options.names ?? []),
+		later: /* @__PURE__ */ new Set()
+	}];
+	while (stack.length > 0) {
+		const item = stack.pop();
+		const envelope = isEnvelope(item.value) ? item.value : void 0;
+		if (envelope === void 0 && item.declared === void 0) {
+			options.problem?.({
+				place: item.place,
+				at: item.at,
+				code: "#PART?",
+				reason: "The value has no envelope, and its position declares no type."
+			});
+			continue;
+		}
+		const doc = envelope ?? {
+			type: item.declared ?? "?",
+			value: item.value
+		};
+		const found = lookupKind(world, doc.type);
+		const kind = found.ok ? found.kind : void 0;
+		if (visit({
+			place: item.place,
+			at: item.at,
+			doc,
+			declared: envelope === void 0,
+			...kind === void 0 ? {} : {
+				kind,
+				typePath: found.ok ? found.path : []
+			},
+			depth: item.depth,
+			names: item.names,
+			later: item.later
+		}) === "skip" || kind === void 0) continue;
+		const split = splitParts(kind.parts, doc.value);
+		if (!split.ok) {
+			const at = split.at.length === 0 ? "" : ` (at ${split.at.join(".")})`;
+			options.problem?.({
+				place: item.place,
+				at: item.at,
+				code: "#VALUE!",
+				reason: `${split.reason}${at} The kind is ${typeName(doc.type)}.`
+			});
+			continue;
+		}
+		const { sees, later } = scopesOf(kind.scope, doc.value, split.parts);
+		const base = envelope === void 0 ? item.at : [...item.at, "value"];
+		for (let index = split.parts.length - 1; index >= 0; index -= 1) {
+			const slot = split.parts[index];
+			const extra = sees[index] ?? [];
+			const hidden = later[index] ?? [];
+			stack.push({
+				value: slot.item,
+				place: [...item.place, ...slot.path],
+				at: [...base, ...slot.path],
+				declared: slot.of,
+				depth: item.depth + 1,
+				names: extra.length === 0 ? item.names : /* @__PURE__ */ new Set([...item.names, ...extra]),
+				later: hidden.length === 0 ? item.later : /* @__PURE__ */ new Set([...item.later, ...hidden])
+			});
+		}
+	}
+}
+/**
+* This function finds each reference of a document: each document of the type `ref` that a walk reaches. A
+* reference to a name that a kind around it binds is not free. The others are what the document reads from
+* outside: its dependencies.
+*
+* @param world - The world of the kinds.
+* @param doc - The document, as JSON.
+* @param options - The type of a bare root value. The names of the host do not change the result.
+* @returns The references, in the order of the document.
+*/
+function refsOf(world, doc, options = {}) {
+	const out = [];
+	const { names: _host, ...rest } = options;
+	walk(world, doc, (v) => {
+		if (!isRef(v.doc)) return void 0;
+		const path = v.doc.value;
+		const root = typeof path[0] === "string" ? path[0] : "";
+		const first = path[1];
+		const bound = root === "names" && isKey(first) && v.names.has(String(first));
+		out.push({
+			place: v.place,
+			at: v.at,
+			path,
+			root,
+			free: !bound
+		});
+		return "skip";
+	}, rest);
+	return out;
+}
+function setAt(value, path, next) {
+	if (path.length === 0) return next;
+	const [key, ...rest] = path;
+	if (Array.isArray(value)) {
+		const copy = [...value];
+		copy[Number(key)] = setAt(value[Number(key)], rest, next);
+		return copy;
+	}
+	const record = isRecord(value) ? value : {};
+	const copy = {};
+	for (const name of Object.keys(record)) Object.defineProperty(copy, name, {
+		value: record[name],
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	Object.defineProperty(copy, String(key), {
+		value: setAt(record[String(key)], rest, next),
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	return copy;
+}
+/**
+* This function changes the free references of a document. The document is not changed: the function gives a new
+* document that shares each part without a change.
+*
+* @param world - The world of the kinds.
+* @param doc - The document, as JSON.
+* @param change - The function that gives the new document of a reference, or `undefined` to keep it.
+* @param options - The type of a bare root value, and the names that the host binds at the root.
+* @returns The new document.
+*/
+function mapRefs(world, doc, change, options = {}) {
+	let out = doc;
+	for (const use of refsOf(world, doc, options)) {
+		if (!use.free) continue;
+		const next = change(use);
+		if (next !== void 0) out = setAt(out, use.at, next);
+	}
+	return out;
+}
+/**
+* This function checks a document before an evaluation, by the contracts of its kinds. It finds the problems
+* that an evaluation finds when it reaches them:
+*
+* - `#KIND?`: a kind that the world does not have.
+* - `#NOEVAL`: no evaluator.
+* - `#VALUE!`: a value without the shape of its kind.
+* - `#PART?`: a value without a type.
+* - `#DEPTH!`: too much nesting.
+* - `#REF!` and `#STEP?`: a bad path.
+* - `#NAME?`: a name that nothing binds.
+* - `#CAP!`: an effect that the capabilities do not permit.
+*
+* @param machine - The world and the code of the evaluators.
+* @param doc - The document, as JSON.
+* @param options - The type of a bare root value, the names of the host and the capabilities.
+* @returns The problems, in the order of the document.
+*/
+function check(machine, doc, options = {}) {
+	const issues = [];
+	const maxDepth = machine.maxDepth ?? 1e3;
+	const anyName = options.names === "any";
+	const roots = machine.roots ?? ROOTS;
+	const has = (table, name) => table !== void 0 && Object.hasOwn(table, name);
+	walk(machine.world, doc, (v) => {
+		if (v.depth > maxDepth) {
+			issues.push({
+				code: "#DEPTH!",
+				place: v.place,
+				reason: `The nesting is deeper than ${maxDepth} documents.`
+			});
+			return "skip";
+		}
+		const header = v.declared ? {} : v.doc;
+		const answer = ask(machine.world, header, "eval", v.declared ? { declaredType: typeName(v.doc.type) } : {});
+		if (answer.error === "unknown-kind") {
+			issues.push({
+				code: "#KIND?",
+				place: v.place,
+				reason: `The world has no kind ${typeName(v.doc.type)}.`
+			});
+			return "skip";
+		}
+		const name = answer.evaluator;
+		if (name === void 0 || !has(machine.evaluators, name) && !has(machine.runners, name)) issues.push({
+			code: "#NOEVAL",
+			place: v.place,
+			reason: `No rung gives an evaluator for ${typeName(v.doc.type)}.`
+		});
+		if (options.caps !== void 0 && v.kind?.effects !== void 0) {
+			const kinds = v.kind.effects === "type" ? [v.typePath ?? []] : v.kind.effects.map((kind) => kind.split("."));
+			for (const kind of kinds) if (!permits(options.caps, kind)) issues.push({
+				code: "#CAP!",
+				place: v.place,
+				reason: `The capabilities do not permit the effect ${kind.join(".")}.`
+			});
+		}
+		if (!isRef(v.doc)) return void 0;
+		const path = v.doc.value;
+		const root = path[0];
+		if (typeof root !== "string" || !ROOTS.includes(root)) {
+			issues.push({
+				code: "#REF!",
+				place: v.place,
+				reason: `A path starts with a root: ${ROOTS.join(", ")}.`
+			});
+			return "skip";
+		}
+		if (!roots.includes(root)) issues.push({
+			code: "#REF!",
+			place: v.place,
+			reason: `The root ${root} is not open here. The open roots are ${roots.join(", ")}.`
+		});
+		const first = path[1];
+		if (root === "names" && !anyName && isKey(first) && !v.names.has(String(first))) {
+			const later = v.later.has(String(first));
+			issues.push({
+				code: "#NAME?",
+				place: v.place,
+				reason: later ? `The name ${String(first)} is bound by a later step.` : `Nothing binds the name ${String(first)}.`
+			});
+		}
+		path.slice(1).forEach((step) => {
+			if (isKey(step)) return;
+			const found = isEnvelope(step) ? lookupKind(machine.world, step.type) : void 0;
+			const walker = found?.ok === true && Object.hasOwn(found.kind.verbs, "step") ? found.kind.verbs["step"] : void 0;
+			if (walker === void 0 || !has(machine.walkers, walker)) issues.push({
+				code: "#STEP?",
+				place: v.place,
+				reason: "A step is a key, or a document of a kind with the verb step."
+			});
+		});
+		return "skip";
+	}, {
+		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType },
+		...Array.isArray(options.names) ? { names: options.names } : {},
+		problem: (problem) => issues.push({
+			code: problem.code,
+			place: problem.place,
+			reason: problem.reason
+		})
+	});
+	return issues;
+}
+//#endregion
+//#region src/formula.ts
+/** The value of a name whose binding failed. A reference to the name gives the error. */
+var Held = class {
+	error;
+	constructor(error) {
+		this.error = error;
+	}
+};
+const CLOSURE = Symbol.for("coeval.closure");
+/**
+* This function tells if a value is a function that the construct `fn` made.
+*
+* @param value - The value.
+* @returns `true` for a closure.
+*/
+function isClosure(value) {
+	return typeof value === "function" && value[CLOSURE] !== void 0;
+}
+/** The standard extensions: the values that JSON cannot write. */
+const STD_EXT = {
+	undefined: () => ok(void 0),
+	number: (data) => {
+		if (data === "NaN") return ok(NaN);
+		if (data === "Infinity") return ok(Number.POSITIVE_INFINITY);
+		if (data === "-Infinity") return ok(Number.NEGATIVE_INFINITY);
+		if (data === "-0") return ok(-0);
+		return fail("#VALUE!", "The value of ext.number is NaN, Infinity, -Infinity or -0.");
+	}
+};
+/** The truth of a value in the rules of JavaScript: `0`, `""`, `null`, `undefined` and `NaN` are false. */
+function jsTruthy(value) {
+	return Boolean(value);
+}
+function strictTruthy(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function setOwn(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+}
+function compiled(compile) {
+	return { compile };
+}
+function partsOf(value) {
+	return isRecord(value) ? value : {};
+}
+const LIT_SUMMARY = "A literal: its value is the result.";
+/**
+* This function makes the kinds of the formula kit, for a world. The kinds are the shared constructs of D13 and
+* the namespaces `ops` and `ext`. A bare value in a position of a term is a literal.
+*
+* @returns The entries of the world, by their key.
+*/
+function formulaKinds() {
+	const term = {
+		shape: "term",
+		of: "lit"
+	};
+	const terms = {
+		shape: "list",
+		of: "lit"
+	};
+	return {
+		lit: {
+			verbs: { eval: "formula.lit" },
+			summary: LIT_SUMMARY
+		},
+		ref: {
+			verbs: { eval: "formula.ref" },
+			summary: "A path from a root of the context. Its result is what the path reaches."
+		},
+		record: {
+			verbs: { eval: "formula.record" },
+			parts: {
+				shape: "map",
+				of: "lit"
+			},
+			summary: "A record: each field is a term."
+		},
+		list: {
+			verbs: { eval: "formula.list" },
+			parts: terms,
+			summary: "A list: each item is a term."
+		},
+		let: {
+			verbs: { eval: "formula.let" },
+			parts: {
+				shape: "record",
+				fields: {
+					bind: {
+						shape: "map",
+						of: "lit"
+					},
+					body: term
+				},
+				required: ["bind", "body"]
+			},
+			scope: [{
+				names: { keysAt: ["bind"] },
+				in: [["body"]]
+			}],
+			summary: "Names for the body. Each binding sees the names around the let, not the other bindings."
+		},
+		fn: {
+			verbs: { eval: "formula.fn" },
+			parts: {
+				shape: "record",
+				fields: { body: term },
+				required: ["params", "body"]
+			},
+			scope: [{
+				names: { listAt: ["params"] },
+				in: [["body"]]
+			}],
+			summary: "A function: its parameters are names for its body."
+		},
+		call: {
+			verbs: { eval: "formula.call" },
+			parts: {
+				shape: "record",
+				fields: {
+					fn: term,
+					args: terms
+				},
+				required: ["fn"]
+			},
+			summary: "It calls a function with the values of its arguments."
+		},
+		if: {
+			verbs: { eval: "formula.if" },
+			parts: {
+				shape: "record",
+				fields: {
+					test: term,
+					then: term,
+					else: term
+				},
+				required: ["test", "then"]
+			},
+			summary: "It evaluates the test, then only the branch that the test selects."
+		},
+		and: {
+			verbs: { eval: "formula.and" },
+			parts: terms,
+			summary: "True when each term is true. It stops at the first false term."
+		},
+		or: {
+			verbs: { eval: "formula.or" },
+			parts: terms,
+			summary: "True when one term is true. It stops at the first true term."
+		},
+		ops: {
+			kinds: {},
+			fallback: {
+				verbs: { eval: "formula.op" },
+				parts: terms,
+				summary: "An operation of the language, applied to the values of its terms."
+			}
+		},
+		ext: {
+			kinds: {},
+			fallback: {
+				verbs: { eval: "formula.ext" },
+				summary: "An extension of the language. Its value is data."
+			}
+		}
+	};
+}
+/**
+* This function makes the evaluators of the formula kit for one language. Each evaluator compiles its document
+* one time into code.
+*
+* @param profile - The operations and the rules of the language.
+* @returns The evaluators, by their name.
+*/
+function formulaEvaluators(profile = {}) {
+	const truthy = profile.truthy ?? strictTruthy;
+	const otherwise = ok(profile.otherwise ?? null);
+	const logicValue = profile.logic === "value";
+	const omit = profile.omit;
+	const missing = profile.missing;
+	const check = profile.check;
+	const lookup = (name) => {
+		const ops = profile.ops;
+		if (ops === void 0) return void 0;
+		if (typeof ops === "function") return ops(name);
+		return Object.hasOwn(ops, name) ? ops[name] : void 0;
+	};
+	const notTruth = (what) => fail("#VALUE!", `The ${what} must give a truth value.`);
+	return {
+		"formula.lit": compiled(({ doc }) => {
+			const result = ok(doc.value);
+			return () => result;
+		}),
+		"formula.ref": compiled(({ doc }) => {
+			const path = doc.value;
+			if (!Array.isArray(path) || path.length === 0) {
+				const bad = fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
+				return () => bad;
+			}
+			const head = path[0] === "names" && typeof path[1] === "string" ? path[1] : void 0;
+			return (ctx, rt) => {
+				if (head !== void 0 && Object.hasOwn(ctx.names, head)) {
+					const bound = ctx.names[head];
+					if (bound instanceof Held) return {
+						ok: false,
+						error: bound.error
+					};
+				}
+				const found = rt.resolve(ctx, path);
+				if (!found.ok) return fail(found.code, found.reason);
+				const value = valueOfThing(found.thing);
+				if (value instanceof Held) return {
+					ok: false,
+					error: value.error
+				};
+				if (missing !== void 0 && missing(value)) return fail("#N/A", "The path reaches no value.");
+				return ok(value);
+			};
+		}),
+		"formula.record": compiled(({ value }) => {
+			const fields = Object.entries(partsOf(value));
+			return (ctx, rt) => {
+				const out = {};
+				for (const [key, part] of fields) {
+					const result = part.code(ctx, rt);
+					if (!result.ok) {
+						if (omit !== void 0 && omit(result.error)) continue;
+						return result;
+					}
+					setOwn(out, key, result.value);
+				}
+				return ok(out);
+			};
+		}),
+		"formula.list": compiled(({ parts }) => (ctx, rt) => {
+			const out = new Array(parts.length);
+			for (let index = 0; index < parts.length; index += 1) {
+				const result = parts[index].code(ctx, rt);
+				if (!result.ok) return result;
+				out[index] = result.value;
+			}
+			return ok(out);
+		}),
+		"formula.let": compiled(({ value }) => {
+			const record = partsOf(value);
+			const bindings = Object.entries(partsOf(record["bind"]));
+			const body = record["body"];
+			return (ctx, rt) => {
+				const names = { ...ctx.names };
+				for (const [name, part] of bindings) {
+					const result = part.code(ctx, rt);
+					setOwn(names, name, result.ok ? result.value : new Held(result.error));
+				}
+				return body.code({
+					...ctx,
+					names
+				}, rt);
+			};
+		}),
+		"formula.fn": compiled(({ value, data }) => {
+			const params = isRecord(data) ? data["params"] : void 0;
+			if (!Array.isArray(params) || !params.every((param) => typeof param === "string") || new Set(params).size !== params.length) {
+				const bad = fail("#VALUE!", "The params of fn are a list of different texts.");
+				return () => bad;
+			}
+			const names = params;
+			const body = partsOf(value)["body"];
+			return (ctx, rt) => {
+				const closure = (...args) => {
+					const scope = { ...ctx.names };
+					names.forEach((name, index) => setOwn(scope, name, args[index]));
+					const result = body.code({
+						...ctx,
+						names: scope
+					}, rt);
+					if (!result.ok) throw new Failure(result.error);
+					return result.value;
+				};
+				Object.defineProperty(closure, CLOSURE, { value: { params: names } });
+				return ok(closure);
+			};
+		}),
+		"formula.call": compiled(({ value }) => {
+			const record = partsOf(value);
+			const fnPart = record["fn"];
+			const args = Array.isArray(record["args"]) ? record["args"] : [];
+			return (ctx, rt) => {
+				const fn = fnPart.code(ctx, rt);
+				if (!fn.ok) return fn;
+				if (typeof fn.value !== "function") return fail("#VALUE!", "The fn of call must give a function.");
+				const values = new Array(args.length);
+				for (let index = 0; index < args.length; index += 1) {
+					const result = args[index].code(ctx, rt);
+					if (!result.ok) return result;
+					values[index] = result.value;
+				}
+				try {
+					return ok(fn.value(...values));
+				} catch (error) {
+					return thrown(error, "the function of call");
+				}
+			};
+		}),
+		"formula.if": compiled(({ value }) => {
+			const record = partsOf(value);
+			const test = record["test"];
+			const then = record["then"];
+			const other = record["else"];
+			return (ctx, rt) => {
+				const chosen = test.code(ctx, rt);
+				if (!chosen.ok) return chosen;
+				const truth = truthy(chosen.value);
+				if (truth === void 0) return notTruth("test of if");
+				if (truth) return then.code(ctx, rt);
+				return other === void 0 ? otherwise : other.code(ctx, rt);
+			};
+		}),
+		"formula.and": compiled(({ parts }) => (ctx, rt) => {
+			let last = ok(true);
+			for (const part of parts) {
+				last = part.code(ctx, rt);
+				if (!last.ok) return last;
+				const truth = truthy(last.value);
+				if (truth === void 0) return notTruth("term of and");
+				if (!truth) return logicValue ? last : ok(false);
+			}
+			return logicValue ? last : ok(true);
+		}),
+		"formula.or": compiled(({ parts }) => (ctx, rt) => {
+			let last = ok(false);
+			for (const part of parts) {
+				last = part.code(ctx, rt);
+				if (!last.ok) return last;
+				const truth = truthy(last.value);
+				if (truth === void 0) return notTruth("term of or");
+				if (truth) return logicValue ? last : ok(true);
+			}
+			return logicValue ? last : ok(false);
+		}),
+		"formula.op": compiled(({ typePath, parts }) => {
+			const name = typePath.slice(1).join(".");
+			const lazy = profile.lazy !== void 0 && Object.hasOwn(profile.lazy, name) ? profile.lazy[name] : void 0;
+			if (lazy !== void 0) return (ctx, rt) => {
+				try {
+					return lazy(parts.map((part) => () => part.code(ctx, rt)));
+				} catch (error) {
+					return thrown(error, `the operation ${name}`);
+				}
+			};
+			const fn = lookup(name);
+			if (fn === void 0) {
+				const unknown = fail("#NAME?", `The language has no operation ${name}.`);
+				return () => unknown;
+			}
+			const done = (out) => check === void 0 ? ok(out) : check(out, name) ?? ok(out);
+			const failed = (error) => thrown(error, `the operation ${name}`);
+			if (parts.length === 1) {
+				const [a] = parts;
+				return (ctx, rt) => {
+					const x = a.code(ctx, rt);
+					if (!x.ok) return x;
+					try {
+						return done(fn(x.value));
+					} catch (error) {
+						return failed(error);
+					}
+				};
+			}
+			if (parts.length === 2) {
+				const [a, b] = parts;
+				return (ctx, rt) => {
+					const x = a.code(ctx, rt);
+					if (!x.ok) return x;
+					const y = b.code(ctx, rt);
+					if (!y.ok) return y;
+					try {
+						return done(fn(x.value, y.value));
+					} catch (error) {
+						return failed(error);
+					}
+				};
+			}
+			return (ctx, rt) => {
+				const values = new Array(parts.length);
+				for (let index = 0; index < parts.length; index += 1) {
+					const result = parts[index].code(ctx, rt);
+					if (!result.ok) return result;
+					values[index] = result.value;
+				}
+				try {
+					return done(fn(...values));
+				} catch (error) {
+					return failed(error);
+				}
+			};
+		}),
+		"formula.ext": compiled(({ typePath, doc }) => {
+			const name = typePath.slice(1).join(".");
+			const handler = (profile.ext !== void 0 && Object.hasOwn(profile.ext, name) ? profile.ext[name] : void 0) ?? (Object.hasOwn(STD_EXT, name) ? STD_EXT[name] : void 0);
+			if (handler === void 0) {
+				const unknown = fail("#NAME?", `The language has no extension ${name}.`);
+				return () => unknown;
+			}
+			return () => {
+				try {
+					return handler(doc.value);
+				} catch (error) {
+					return thrown(error, `the extension ${name}`);
+				}
+			};
+		})
+	};
+}
+/**
+* This function makes a machine for a formula language. The machine has the kinds and the evaluators of the
+* formula kit. It also has the kinds, the evaluators and the walkers that the language adds.
+*
+* @param profile - The operations and the rules of the language.
+* @param more - The parts of a machine that the language adds. Its kinds win over the kinds of the kit.
+* @returns The machine.
+*/
+function formulaMachine(profile = {}, more = {}) {
+	return {
+		...more,
+		world: {
+			kinds: {
+				...formulaKinds(),
+				...more.world?.kinds
+			},
+			defaults: { ...more.world?.defaults }
+		},
+		evaluators: {
+			...formulaEvaluators(profile),
+			...more.evaluators
+		}
+	};
+}
+//#endregion
+export { CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_WALKERS, STD_WORLD, THING, ask, capKeys, check, checkSteps, classify, context, dataEdges, derefStep, describe, docEquals, effectEdges, entriesAsJson, evaluate, fail, failures, field, flatten, formulaEvaluators, formulaKinds, formulaMachine, fromJson, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isTypeRef, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, narrow, nearestWalker, nodeAt, ok, pathMatches, permits, placed, planner, prepare, ref, refsOf, resolve, run, splitParts, stored, tag, thrown, toJson, typeName, typePath, typed, valueOfThing, walk, worldThing };
 
 //# sourceMappingURL=index.js.map