@mark1russell7/coeval 0.0.0-stage → 0.2.0

package/build/index.js

@@ -0,0 +1,3378 @@
+//#region src/doc.ts
+/** The keys that an envelope can have. */
+const ENVELOPE_KEYS = [
+	"type",
+	"value",
+	"name",
+	"own"
+];
+/**
+* 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 plain record.
+*/
+function isRecord(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.
+*
+* @param record - The record.
+* @param key - The name of the field.
+* @returns The value of the field, or `undefined` when the record has no such field.
+*/
+function field(record, key) {
+	return Object.hasOwn(record, key) ? record[key] : void 0;
+}
+/**
+* This function tells if a value is a key of a path: a text, or a whole number from 0.
+*
+* @param value - The value to examine.
+* @returns `true` for a key.
+*/
+function isKey(value) {
+	return typeof value === "string" || typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+/**
+* This function tells if a value is a reference to a type. The reference is a text, a list of keys, or a document
+* of type `ref` whose path starts at the root `world`.
+*
+* @param value - The value to examine.
+* @returns `true` for a reference to a type.
+*/
+function isTypeRef(value) {
+	if (typeof value === "string") return value !== "";
+	if (Array.isArray(value)) return value.length > 0 && value.every(isKey);
+	if (!isRecord(value)) return false;
+	const path = field(value, "value");
+	return field(value, "type") === "ref" && Array.isArray(path) && path[0] === "world";
+}
+/**
+* This function gives the path of a reference to a type, from the root of the world.
+*
+* @param type - The reference.
+* @returns The keys from the root of the world, or `undefined` for a computed step that has no fixed key.
+*/
+function typePath(type) {
+	if (typeof type === "string") return [type];
+	if (Array.isArray(type)) return type;
+	const steps = type.value.slice(1);
+	return steps.every(isKey) ? steps : void 0;
+}
+/**
+* This function gives the text of a type for a reader: its keys, joined with a dot.
+*
+* @param type - The reference to the type.
+* @returns The text, for example `git.push`.
+*/
+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
+* expected. This function only checks the form.
+*
+* @param value - The value to examine.
+* @returns `true` when the value has the form of an envelope.
+*/
+function isEnvelope(value) {
+	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.
+*
+* @param type - The reference to the kind.
+* @param value - The value.
+* @param header - The optional name and own entries.
+* @returns The envelope.
+*/
+function typed(type, value, header = {}) {
+	return {
+		type,
+		value,
+		...header.name === void 0 ? {} : { name: header.name },
+		...header.own === void 0 ? {} : { own: header.own }
+	};
+}
+/**
+* This function makes a reference document: a path from a root of the context.
+*
+* @param path - The steps. The first step is a root: `self`, `names`, `world`, `event` or `caps`.
+* @returns The document of type `ref`.
+*/
+function ref(...path) {
+	return typed("ref", path);
+}
+/**
+* This function gives an envelope as a JSON record, for a store or for a view.
+*
+* @param doc - The envelope.
+* @returns The same envelope as JSON.
+*/
+function toJson(doc) {
+	return {
+		type: doc.type,
+		value: doc.value,
+		...doc.name === void 0 ? {} : { name: doc.name },
+		...doc.own === void 0 ? {} : { own: doc.own }
+	};
+}
+/**
+* This function reads an envelope from JSON. A value without the form of an envelope gives `undefined`.
+*
+* @param value - The JSON value.
+* @returns The envelope, or `undefined`.
+*/
+function fromJson(value) {
+	if (!isEnvelope(value)) return void 0;
+	const own = field(value, "own");
+	const ownEntries = {};
+	if (isRecord(own)) {
+		for (const [verb, name] of Object.entries(own)) if (typeof name === "string") ownEntries[verb] = name;
+	}
+	const name = field(value, "name");
+	return typed(field(value, "type"), field(value, "value") ?? null, {
+		...typeof name === "string" ? { name } : {},
+		...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
+/**
+* This function tells if an entry of the world is a kind.
+*
+* @param entry - The entry.
+* @returns `true` for a kind.
+*/
+function isKind(entry) {
+	return entry !== void 0 && Object.hasOwn(entry, "verbs");
+}
+/**
+* This function tells if an entry of the world is an alias.
+*
+* @param entry - The entry.
+* @returns `true` for an alias.
+*/
+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. 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.
+* @returns The kind and the path of the kind after each alias, or the reason of a failure.
+*/
+function lookupKind(world, type) {
+	const start = typePath(type);
+	if (start === void 0) return {
+		ok: false,
+		reason: "computed",
+		path: []
+	};
+	let path = start;
+	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) {
+				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 {
+					ok: false,
+					reason: "cycle",
+					path
+				};
+				const target = entry.value.slice(1);
+				if (entry.value[0] !== "world" || !target.every((item) => typeof item === "string" || typeof item === "number")) return {
+					ok: false,
+					reason: "not-a-kind",
+					path
+				};
+				path = [...target, ...path.slice(index + 1)];
+				followed = true;
+				break;
+			}
+			if (index < path.length - 1) {
+				if (!isNamespace(entry)) return {
+					ok: false,
+					reason: "not-a-kind",
+					path
+				};
+				entries = entry.kinds;
+				fallback = entry.fallback;
+			}
+		}
+		if (followed) continue;
+		if (!isKind(entry)) return {
+			ok: false,
+			reason: "not-a-kind",
+			path
+		};
+		return {
+			ok: true,
+			kind: entry,
+			path,
+			aliases
+		};
+	}
+}
+/**
+* This function gives the entries of a world as a JSON record, so that a reference can walk it. A kind is a
+* record with its verbs, an alias is a reference document, and a namespace is a record of its entries.
+*
+* @param entries - The entries.
+* @returns The JSON form.
+*/
+function entriesAsJson(entries) {
+	const out = {};
+	for (const [key, entry] of Object.entries(entries)) if (isAlias(entry)) out[key] = {
+		type: "ref",
+		value: entry.value
+	};
+	else if (isKind(entry)) out[key] = JSON.parse(JSON.stringify(entry));
+	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.
+*
+* @param name - The name of the kind.
+* @param kind - The kind.
+* @returns The document of type `kind`.
+*/
+function kindDocument(name, kind) {
+	return {
+		type: "kind",
+		value: {
+			name,
+			verbs: { ...kind.verbs },
+			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. */
+const RUNGS = [
+	"own",
+	"kind",
+	"default"
+];
+function entryOf$1(verbs, verb) {
+	return verbs !== void 0 && Object.hasOwn(verbs, verb) ? verbs[verb] : void 0;
+}
+/**
+* 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 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 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.
+*
+* @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
+	};
+}
+//#endregion
+//#region 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 = 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"
+];
+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 && 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;
+	}
+}
+/**
+* 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: 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` when it reaches nothing.
+*/
+function derefStep(nav, thing, key) {
+	if (isHostThing(thing)) {
+		const reached = thing.deref(key);
+		return reached === void 0 ? void 0 : {
+			thing: reached,
+			by: "own"
+		};
+	}
+	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);
+			return reached === void 0 ? void 0 : {
+				thing: reached,
+				by: "own"
+			};
+		}
+		const found = lookupKind(nav.world, envelope.type);
+		const name = found.ok ? entryOf(found.kind.verbs, "deref") : void 0;
+		const code = name === void 0 ? void 0 : nav.derefs?.[name];
+		if (code !== void 0) {
+			const reached = code(envelope, key);
+			return reached === void 0 ? void 0 : {
+				thing: reached,
+				by: "kind"
+			};
+		}
+		const reached = plainStep(envelope.value, key);
+		return reached === void 0 ? void 0 : {
+			thing: reached.value,
+			by: "default"
+		};
+	}
+	const reached = plainStep(thing, key);
+	return reached === void 0 ? void 0 : {
+		thing: reached.value,
+		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 (!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 = 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), 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, 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 failed("#CYCLE!", "The references form a cycle.");
+			const inner = walk(here.value);
+			if (!inner.ok) return inner;
+			here = inner.thing;
+			hops?.push({
+				step: "collapse",
+				thing: here,
+				by: "collapse"
+			});
+		}
+		return {
+			ok: true,
+			thing: here,
+			hops: done
+		};
+	};
+	const walk = (steps) => {
+		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({
+			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 && 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) {
+					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 = 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 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 failed("#N/A", result.reason);
+				hops?.push({
+					step: envelope,
+					thing: result.thing,
+					by: "step"
+				});
+				here = result.thing;
+			}
+			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);
+}
+/**
+* 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;
+}
+//#endregion
+//#region 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);
+}
+//#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 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 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 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
+		};
+	};
+	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
+		};
+	};
+	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 {
+			t: "record",
+			fields
+		};
+	};
+	let template;
+	try {
+		template = walk(shape, value, []);
+	} catch (error) {
+		if (error instanceof Bad) return {
+			ok: false,
+			reason: error.reason,
+			at: error.at
+		};
+		throw error;
+	}
+	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;
+	};
+	return {
+		ok: true,
+		parts,
+		data: strip(template) ?? null,
+		fill: (handles) => fillWith(template, handles)
+	};
+}
+/**
+* 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 path - The path of the part.
+* @param pattern - The pattern.
+* @returns `true` when the path matches.
+*/
+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.
+*
+* @param names - The names and their values.
+* @param caps - The effects that the term can cause.
+* @param self - The node of the term, if it has one.
+* @returns The context.
+*/
+function makeContext(names = {}, caps = [], self = null) {
+	return context({
+		names,
+		caps,
+		self
+	});
+}
+/**
+* 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
+* 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: a text with dots, or its keys.
+* @returns `true` when one capability permits it.
+*/
+function permits(caps, kind) {
+	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) {
+	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, 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 = 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 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"
+	};
+	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"
+	};
+	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 = c.machine.runners ?? {};
+	const runner = name !== void 0 && Object.hasOwn(runners, name) ? runners[name] : void 0;
+	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) {
+		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
+		};
+	});
+	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 who = `the evaluator ${name}`;
+	if (runner !== void 0) {
+		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 placed(inner(ctx, rt), place);
+		} catch (error) {
+			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 {
+		root = compileNode(c, doc, [], options.declaredType, 0);
+	} catch (error) {
+		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);
+		}
+	};
+}
+/**
+* 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, result) {
+	const root = s.holder?.children[0];
+	if (root === void 0) throw new Error("The evaluation made no trace.");
+	return {
+		result,
+		trace: root,
+		effects: s.effects,
+		time: s.tick
+	};
+}
+/**
+* This function evaluates a document, and records each evaluation in a trace.
+*
+* The verb `eval` goes up the ladder for each document. 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. An effect is recorded in its order, and nothing does it.
+*
+* @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 declaredType - The type of a bare root value.
+* @returns The result, the trace and the effects in their order.
+*/
+function evaluate(machine, doc, context = makeContext(), declaredType) {
+	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. 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, 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 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.
+*
+* @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);
+}
+//#endregion
+//#region src/stdlib.ts
+/**
+* The world of the examples: small kinds for numbers, lists, conditions, names, sequences and effects.
+* Each kind names an evaluator for `eval` and a view for `view`. The site draws each document with its view.
+*/
+const STD_WORLD = {
+	kinds: {
+		number: {
+			verbs: {
+				eval: "data.number",
+				view: "view.value"
+			},
+			summary: "A number. Its value is the result."
+		},
+		text: {
+			verbs: {
+				eval: "data.text",
+				view: "view.value"
+			},
+			summary: "A text. Its value is the result."
+		},
+		bool: {
+			verbs: {
+				eval: "data.bool",
+				view: "view.value"
+			},
+			summary: "A truth value. Its value is the result."
+		},
+		add: {
+			verbs: {
+				eval: "math.add",
+				view: "view.op"
+			},
+			parts: {
+				shape: "list",
+				of: "number"
+			},
+			summary: "The sum of its parts. A bare number in its list gets the type number."
+		},
+		multiply: {
+			verbs: {
+				eval: "math.multiply",
+				view: "view.op"
+			},
+			parts: {
+				shape: "list",
+				of: "number"
+			},
+			summary: "The product of its parts."
+		},
+		greater: {
+			verbs: {
+				eval: "math.greater",
+				view: "view.op"
+			},
+			parts: {
+				shape: "list",
+				of: "number"
+			},
+			summary: "True when the first part is greater than the second part."
+		},
+		list: {
+			verbs: {
+				eval: "list.all",
+				view: "view.op"
+			},
+			parts: { shape: "list" },
+			summary: "The results of its parts, as a list."
+		},
+		if: {
+			verbs: {
+				eval: "control.if",
+				view: "view.op"
+			},
+			parts: {
+				shape: "record",
+				fields: [
+					"test",
+					"then",
+					"else"
+				]
+			},
+			summary: "It evaluates the test, then only the branch that the test selects."
+		},
+		ref: {
+			verbs: {
+				eval: "ref.resolve",
+				view: "view.ref"
+			},
+			summary: "A path from a root of the context. Each step goes up the ladder of the verb deref."
+		},
+		nearest: {
+			verbs: {
+				step: "walk.nearest",
+				view: "view.card"
+			},
+			summary: "A step of a path: it follows a key again and again, until it reaches a node of a type."
+		},
+		panel: {
+			verbs: {
+				eval: "tree.node",
+				view: "view.op"
+			},
+			parts: {
+				shape: "record",
+				fields: [
+					"width",
+					"height",
+					"children"
+				],
+				of: "number"
+			},
+			summary: "A node of a tree. Its parts see it as self, and each node links to its parent."
+		},
+		box: {
+			verbs: {
+				eval: "tree.node",
+				view: "view.op"
+			},
+			parts: {
+				shape: "record",
+				fields: [
+					"width",
+					"height",
+					"children"
+				],
+				of: "number"
+			},
+			summary: "A node of a tree, as panel. A formula in a box can read the parent of the box."
+		},
+		math: { kinds: {
+			sum: {
+				type: "ref",
+				value: ["world", "add"]
+			},
+			product: {
+				type: "ref",
+				value: ["world", "multiply"]
+			}
+		} },
+		seq: {
+			verbs: {
+				eval: "control.seq",
+				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: {
+			verbs: {
+				eval: "control.pure",
+				view: "view.op"
+			},
+			parts: { shape: "list" },
+			summary: "It evaluates its part without capabilities, thus an effect in it fails."
+		},
+		log: {
+			verbs: {
+				eval: "effect.log",
+				view: "view.op"
+			},
+			parts: {
+				shape: "list",
+				of: "text"
+			},
+			side: "run",
+			summary: "It writes the result of its part to the log. This is an effect."
+		},
+		write: {
+			verbs: {
+				eval: "effect.write",
+				view: "view.op"
+			},
+			parts: {
+				shape: "record",
+				fields: ["value"]
+			},
+			side: "run",
+			summary: "It writes the result of its part to the store, at its key. This is an effect."
+		}
+	},
+	defaults: { view: "view.card" }
+};
+function isNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+/** This function evaluates each part, collects the errors, and gives the values when no part failed. */
+function allValues(results) {
+	const errors = results.filter((result) => !result.ok);
+	const first = errors[0];
+	if (first !== void 0 && errors.length === 1) return { error: first };
+	if (errors.length > 1) return { error: fail("#ARGS", `${errors.length} parts failed.`) };
+	return { values: results.map((result) => result.ok ? result.value : null) };
+}
+function numbers(values, kind) {
+	const bad = values.findIndex((value) => !isNumber(value));
+	if (bad !== -1) return fail("#VALUE!", `Part ${bad} of ${kind} is not a number.`);
+	return values.filter(isNumber);
+}
+function dataOf(type) {
+	return ({ data }) => typeof data === type && (type !== "number" || isNumber(data)) ? ok(data) : fail("#VALUE!", `The value must be a ${type === "string" ? "text" : type}.`);
+}
+/** The code of the evaluators of the standard world, by name. */
+const STD_EVALUATORS = {
+	"data.number": dataOf("number"),
+	"data.text": dataOf("string"),
+	"data.bool": dataOf("boolean"),
+	"math.add": ({ parts }) => {
+		const all = allValues(parts.map((part) => part.evaluate()));
+		if ("error" in all) return all.error;
+		const values = numbers(all.values, "add");
+		return Array.isArray(values) ? ok(values.reduce((sum, value) => sum + value, 0)) : values;
+	},
+	"math.multiply": ({ parts }) => {
+		const all = allValues(parts.map((part) => part.evaluate()));
+		if ("error" in all) return all.error;
+		const values = numbers(all.values, "multiply");
+		return Array.isArray(values) ? ok(values.reduce((product, value) => product * value, 1)) : values;
+	},
+	"math.greater": ({ parts }) => {
+		if (parts.length !== 2) return fail("#VALUE!", "greater needs exactly two parts.");
+		const all = allValues(parts.map((part) => part.evaluate()));
+		if ("error" in all) return all.error;
+		const values = numbers(all.values, "greater");
+		if (!Array.isArray(values)) return values;
+		const [a, b] = values;
+		return ok((a ?? 0) > (b ?? 0));
+	},
+	"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 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)
+};
+/**
+* This function evaluates a node of a tree. The node is a host thing. A step `parent` reaches the node that holds
+* it. A step with the name of a part evaluates that part on demand, one time. Each part sees the node as self.
+*/
+function treeNode(parts, context, type) {
+	const memo = /* @__PURE__ */ new Map();
+	const read = (key) => {
+		const known = memo.get(key);
+		if (known !== void 0) return known;
+		const part = parts.find((item) => item.key === key);
+		if (part === void 0) return void 0;
+		const result = part.evaluate({
+			...context,
+			self: me
+		});
+		memo.set(key, result);
+		return result;
+	};
+	const me = {
+		[THING]: true,
+		type,
+		label: `node ${type}`,
+		deref(key) {
+			if (key === "parent") return context.self;
+			if (key === "type") return type;
+			const result = read(String(key));
+			return result?.ok === true ? result.value : void 0;
+		},
+		toJson() {
+			const out = {};
+			for (const part of parts) {
+				const result = read(part.key);
+				out[part.key] = result?.ok === true ? result.value : null;
+			}
+			return out;
+		}
+	};
+	const out = {};
+	for (const part of parts) {
+		const result = read(part.key);
+		if (result === void 0) continue;
+		if (!result.ok) return result;
+		out[part.key] = result.value;
+	}
+	return ok(out);
+}
+function hostType(node, wanted) {
+	return isHostThing(node) && node.type === wanted;
+}
+/**
+* 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.
+*/
+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: "The walk is too long."
+		};
+	};
+}
+/** The walkers of the standard world, by name. */
+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 = [];
+	for (const part of parts) {
+		const result = yield* part.evaluate();
+		if (!result.ok) return { error: result };
+		values.push(result.value);
+	}
+	return { values };
+}
+/**
+* The runners of the standard world, by name: the kinds that can hold effects. Each one evaluates its parts in
+* order. In a run, an effect ends before the next step starts.
+*/
+const STD_RUNNERS = {
+	"control.seq": function* ({ parts, context }) {
+		let names = { ...context.names };
+		let last = null;
+		for (const part of parts) {
+			const result = yield* part.evaluate({
+				...context,
+				names
+			});
+			if (!result.ok) return result;
+			names = {
+				...names,
+				last: result.value
+			};
+			if (part.name !== void 0) names = {
+				...names,
+				[part.name]: result.value
+			};
+			last = result.value;
+		}
+		return ok(last);
+	},
+	"control.pure": function* ({ parts, context }) {
+		const only = parts[0];
+		if (only === void 0) return fail("#VALUE!", "pure needs one part.");
+		return yield* only.evaluate({
+			...context,
+			caps: []
+		});
+	},
+	"control.if": function* ({ parts }) {
+		const test = parts.find((part) => part.key === "test");
+		if (test === void 0) return fail("#VALUE!", "if needs a test.");
+		const chosen = yield* test.evaluate();
+		if (!chosen.ok) return chosen;
+		if (typeof chosen.value !== "boolean") return fail("#VALUE!", "The test of if must give a truth value.");
+		const branch = parts.find((part) => part.key === (chosen.value === true ? "then" : "else"));
+		return branch === void 0 ? ok(null) : yield* branch.evaluate();
+	},
+	"list.all": function* ({ parts }) {
+		const all = yield* inOrder(parts);
+		return "error" in all ? all.error : ok(all.values);
+	},
+	"effect.log": function* ({ parts, effect }) {
+		const all = yield* inOrder(parts);
+		if ("error" in all) return all.error;
+		return yield* effect("log", all.values.length === 1 ? all.values[0] ?? null : all.values);
+	},
+	"effect.write": function* ({ parts, data, effect }) {
+		const key = isRecord(data) ? field(data, "key") : void 0;
+		if (typeof key !== "string") return fail("#VALUE!", "write needs a text key.");
+		const value = parts.find((part) => part.key === "value");
+		if (value === void 0) return fail("#VALUE!", "write needs a value.");
+		const result = yield* value.evaluate();
+		if (!result.ok) return result;
+		return yield* effect("write", {
+			key,
+			value: result.value
+		});
+	}
+};
+/** The machine of the examples: the standard world, its evaluators, its runners and its walkers. */
+const STD_MACHINE = {
+	world: STD_WORLD,
+	evaluators: STD_EVALUATORS,
+	runners: STD_RUNNERS,
+	walkers: STD_WALKERS
+};
+/** The capabilities of the examples at the root: the two effects of the standard world. */
+const STD_CAPS = ["log", "write"];
+//#endregion
+//#region src/order.ts
+/**
+* This function finds the references that a sequence cannot resolve. A step can read only the steps before it.
+*
+* @param steps - The steps, in the written order.
+* @returns One problem for each bad reference, in the written order.
+*/
+function checkSteps(steps) {
+	const problems = [];
+	steps.forEach((step, index) => {
+		for (const name of step.reads) {
+			const at = steps.findIndex((other) => other.id === name);
+			if (at === -1) problems.push({
+				step: step.id,
+				reads: name,
+				problem: "unknown-name"
+			});
+			else if (at >= index) problems.push({
+				step: step.id,
+				reads: name,
+				problem: "read-before-defined"
+			});
+		}
+	});
+	return problems;
+}
+/**
+* This function gives the data edges: a step comes after each earlier step that it reads.
+*
+* @param steps - The steps, in the written order.
+* @returns The edges. A bad reference gives no edge.
+*/
+function dataEdges(steps) {
+	const edges = [];
+	steps.forEach((step, index) => {
+		for (const name of step.reads) {
+			const at = steps.findIndex((other) => other.id === name);
+			if (at !== -1 && at < index) edges.push([name, step.id]);
+		}
+	});
+	return edges;
+}
+/**
+* This function gives the effect edges: each step with an effect comes after the previous step with an effect.
+* Effects keep their written order. Steps without an effect get no effect edge.
+*
+* @param steps - The steps, in the written order.
+* @returns The edges, one for each pair of consecutive effect steps.
+*/
+function effectEdges(steps) {
+	const edges = [];
+	let previous;
+	for (const step of steps) {
+		if (!step.effect) continue;
+		if (previous !== void 0) edges.push([previous, step.id]);
+		previous = step.id;
+	}
+	return edges;
+}
+/**
+* This function tells if an order of the steps gives the same meaning as the written order.
+* The order must contain each step one time, and it must obey the data edges and the effect edges.
+*
+* @param steps - The steps, in the written order.
+* @param order - The names of the steps in the order to examine.
+* @returns `true` when the order is permitted.
+*/
+function isAllowedOrder(steps, order) {
+	if (order.length !== steps.length) return false;
+	if (new Set(order).size !== order.length) return false;
+	if (!steps.every((step) => order.includes(step.id))) return false;
+	const position = new Map(order.map((id, index) => [id, index]));
+	return [...dataEdges(steps), ...effectEdges(steps)].every(([before, after]) => (position.get(before) ?? 0) < (position.get(after) ?? 0));
+}
+/**
+* This function puts the steps in layers. Each step goes one layer after the last step that it must follow.
+* The steps of one layer do not depend on each other, thus they can run at the same time.
+*
+* @param steps - The steps, in the written order.
+* @returns The layers, first to last. Each layer keeps the written order.
+*/
+function layers(steps) {
+	const edges = [...dataEdges(steps), ...effectEdges(steps)];
+	const depth = /* @__PURE__ */ new Map();
+	for (const step of steps) {
+		const before = edges.filter(([, after]) => after === step.id).map(([first]) => depth.get(first) ?? 0);
+		depth.set(step.id, before.length === 0 ? 0 : Math.max(...before) + 1);
+	}
+	const result = [];
+	for (const step of steps) {
+		const at = depth.get(step.id) ?? 0;
+		while (result.length <= at) result.push([]);
+		result[at]?.push(step.id);
+	}
+	return result;
+}
+//#endregion
+//#region src/context.ts
+/** The parts of a context. A term can reach outside itself only through these parts. */
+const PARTS = [
+	"self",
+	"names",
+	"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: "world",
+		title: "World",
+		reaches: "The stored documents and collections, by an absolute ID or by a query.",
+		direction: "Out, to the store."
+	},
+	{
+		part: "event",
+		title: "Event",
+		reaches: "The trigger of a run: the event and its values.",
+		direction: "From the past, to the run that the event starts."
+	},
+	{
+		part: "caps",
+		title: "Capabilities",
+		reaches: "The effects that a term can cause. A part of the term gets the same set or a smaller set.",
+		direction: "Down, and only smaller."
+	}
+];
+const NONE = {
+	reads: false,
+	gives: "none",
+	note: "It does not use this part."
+};
+/** Six constructs that show the range of the context. */
+const CONSTRUCTS = [
+	{
+		id: "formula",
+		title: "Formula",
+		side: "derive",
+		summary: "A pure formula that gives a value at one position of a structure.",
+		example: {
+			type: "let",
+			value: {
+				bind: { gap: 8 },
+				body: {
+					type: ["ops", "add"],
+					value: [{
+						type: "ref",
+						value: [
+							"self",
+							"parent",
+							"width"
+						]
+					}, {
+						type: "ref",
+						value: ["names", "gap"]
+					}]
+				}
+			}
+		},
+		uses: {
+			names: {
+				reads: true,
+				gives: "extends",
+				note: "A let binds names for its body."
+			},
+			self: {
+				reads: true,
+				gives: "moves",
+				note: "A move reads the parent. An axis moves self to each target."
+			},
+			world: NONE,
+			event: NONE,
+			caps: {
+				reads: false,
+				gives: "none",
+				note: "A formula causes no effect, thus its parts get no capability."
+			}
+		}
+	},
+	{
+		id: "sequence",
+		title: "Sequence",
+		side: "run",
+		summary: "A list of steps. A step can read the result of each earlier step by its name.",
+		example: {
+			type: "seq",
+			value: [{
+				type: ["store", "find"],
+				value: { match: { board: "b1" } },
+				name: "cards"
+			}, {
+				type: ["store", "patch"],
+				value: {
+					ids: {
+						type: "ref",
+						value: [
+							"names",
+							"cards",
+							"ids"
+						]
+					},
+					set: { done: true }
+				}
+			}]
+		},
+		uses: {
+			names: {
+				reads: true,
+				gives: "extends",
+				note: "The result of each step is a name for the later steps."
+			},
+			self: NONE,
+			world: {
+				reads: true,
+				gives: "same",
+				note: "A step reads and writes the store through a procedure."
+			},
+			event: {
+				reads: false,
+				gives: "same",
+				note: "The steps get the event of the run without a change."
+			},
+			caps: {
+				reads: true,
+				gives: "narrows",
+				note: "A nested call gets the same capabilities or fewer."
+			}
+		}
+	},
+	{
+		id: "node",
+		title: "Tree node",
+		side: "derive",
+		summary: "A node of a document tree. Its data and its box go down to its children.",
+		example: {
+			type: "node",
+			value: {
+				data: { title: "Notes" },
+				children: [{
+					type: "text",
+					value: {
+						type: "ref",
+						value: ["names", "title"]
+					}
+				}]
+			}
+		},
+		uses: {
+			names: {
+				reads: true,
+				gives: "extends",
+				note: "The data of the node becomes a name for its children."
+			},
+			self: {
+				reads: true,
+				gives: "moves",
+				note: "Each child becomes self for its own part."
+			},
+			world: {
+				reads: true,
+				gives: "same",
+				note: "A node can show stored documents."
+			},
+			event: NONE,
+			caps: NONE
+		}
+	},
+	{
+		id: "rule",
+		title: "Layout rule",
+		side: "derive",
+		summary: "A rule that gives the box of a child from the box of its parent.",
+		example: {
+			type: ["layouts", "stack"],
+			value: { gap: 8 }
+		},
+		uses: {
+			names: {
+				reads: true,
+				gives: "none",
+				note: "The rule reads its parameters."
+			},
+			self: {
+				reads: true,
+				gives: "none",
+				note: "The rule reads the box of the parent and the key of the child."
+			},
+			world: NONE,
+			event: NONE,
+			caps: NONE
+		}
+	},
+	{
+		id: "handler",
+		title: "Event handler",
+		side: "run",
+		summary: "A run that an event starts. It holds a sequence as data until the event comes.",
+		example: {
+			type: "on",
+			value: {
+				event: "click",
+				run: {
+					type: "seq",
+					value: [{
+						type: ["card", "toggle"],
+						value: { id: {
+							type: "ref",
+							value: ["event", "target"]
+						} }
+					}]
+				}
+			}
+		},
+		uses: {
+			names: {
+				reads: true,
+				gives: "same",
+				note: "The handler reads the names of its place."
+			},
+			self: {
+				reads: true,
+				gives: "same",
+				note: "The handler knows the node that got the event."
+			},
+			world: {
+				reads: true,
+				gives: "same",
+				note: "The run reads and writes the store."
+			},
+			event: {
+				reads: true,
+				gives: "sets",
+				note: "The handler gives the event to its run."
+			},
+			caps: {
+				reads: true,
+				gives: "narrows",
+				note: "The run gets only the capabilities of the handler."
+			}
+		}
+	},
+	{
+		id: "query",
+		title: "Query",
+		side: "derive",
+		summary: "A selection of stored documents. A storage adapter decides where it runs.",
+		example: {
+			type: "query",
+			value: {
+				collection: "cards",
+				match: { board: {
+					type: "ref",
+					value: ["names", "board"]
+				} }
+			}
+		},
+		uses: {
+			names: {
+				reads: true,
+				gives: "none",
+				note: "The query reads its parameters."
+			},
+			self: NONE,
+			world: {
+				reads: true,
+				gives: "none",
+				note: "The query reads one collection."
+			},
+			event: NONE,
+			caps: NONE
+		}
+	}
+];
+//#endregion
+//#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