@mark1russell7/coeval 0.0.0-stage → 0.1.0

package/build/index.js

@@ -0,0 +1,1856 @@
+//#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 JSON record (not an array and not null).
+*
+* @param value - The value to examine.
+* @returns `true` for a record.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* 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)";
+}
+/**
+* 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)) return false;
+	if (!isTypeRef(field(value, "type")) || !Object.hasOwn(value, "value")) return false;
+	const name = field(value, "name");
+	if (name !== void 0 && typeof name !== "string") return false;
+	const own = field(value, "own");
+	if (own !== void 0 && !isRecord(own)) return false;
+	return Object.keys(value).every((key) => ENVELOPE_KEYS.includes(key));
+}
+/**
+* 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 } : {}
+	});
+}
+//#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);
+}
+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.
+*
+* @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 entry;
+		let followed = false;
+		for (let index = 0; index < path.length; index += 1) {
+			const key = path[index];
+			entry = entryAt(entries, key);
+			if (entry === void 0) return {
+				ok: false,
+				reason: "unknown",
+				path
+			};
+			if (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 (isKind(entry)) return {
+					ok: false,
+					reason: "not-a-kind",
+					path
+				};
+				entries = entry.kinds;
+			}
+		}
+		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;
+}
+/**
+* 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) {
+	const parts = kind.parts === void 0 || kind.parts.shape === "none" ? "none" : kind.parts.shape === "list" ? `a list${kind.parts.of === void 0 ? "" : ` of ${kind.parts.of}`}` : `the fields ${kind.parts.fields.join(", ")}`;
+	return {
+		type: "kind",
+		value: {
+			name,
+			verbs: { ...kind.verbs },
+			parts,
+			side: kind.side ?? "derive",
+			summary: kind.summary ?? ""
+		}
+	};
+}
+//#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. */
+const THING = Symbol("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 && !Array.isArray(thing) && 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;
+}
+function plainStep(thing, key) {
+	if (Array.isArray(thing)) {
+		const index = typeof key === "number" ? key : /^\d+$/.test(key) ? Number(key) : -1;
+		return index >= 0 ? thing[index] : void 0;
+	}
+	if (isRecord(thing) && typeof key === "string") return field(thing, key);
+}
+/**
+* This function answers one step of a path on a thing, through the ladder of the verb `deref`. A host thing
+* answers for itself (own). A document asks its own entry, then its kind. The default goes into the value: a field
+* of a record, or an item of a list.
+*
+* @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`.
+*/
+function derefStep(nav, thing, key) {
+	if (isHostThing(thing)) {
+		const reached = thing.deref(key);
+		return reached === void 0 ? void 0 : {
+			thing: reached,
+			by: "own"
+		};
+	}
+	const envelope = fromJson(thing);
+	if (envelope !== void 0) {
+		const own = entryOf(envelope.own, "deref");
+		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,
+			by: "default"
+		};
+	}
+	const reached = plainStep(thing, key);
+	return reached === void 0 ? void 0 : {
+		thing: reached,
+		by: "default"
+	};
+}
+/**
+* This function tells if a thing is a reference document: an envelope of the type `ref`.
+*
+* @param thing - The thing.
+* @returns `true` for a reference document.
+*/
+function isRef(thing) {
+	if (thing === void 0 || isHostThing(thing)) return false;
+	const envelope = fromJson(thing);
+	if (envelope === void 0 || !Array.isArray(envelope.value)) return false;
+	const path = typePath(envelope.type);
+	return path !== void 0 && path.length === 1 && path[0] === "ref";
+}
+/**
+* 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).
+*
+* @param world - The world.
+* @returns The thing.
+*/
+function worldThing(world) {
+	return entriesAsJson(world.kinds);
+}
+/**
+* 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;
+/**
+* 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).
+*
+* @param nav - The world and the code of the evaluators.
+* @param ctx - The context.
+* @param path - The steps.
+* @returns What the path reached and each hop, or an error.
+*/
+function resolve(nav, ctx, path) {
+	const hops = [];
+	let collapses = 0;
+	const collapse = (thing) => {
+		let here = thing;
+		while (isRef(here)) {
+			collapses += 1;
+			if (collapses > MAX_COLLAPSE) return {
+				ok: false,
+				code: "#CYCLE!",
+				reason: "The references form a cycle.",
+				hops
+			};
+			const inner = walk(here.value);
+			if (!inner.ok) return inner;
+			here = inner.thing;
+			hops.push({
+				step: here === null ? null : "collapse",
+				thing: here,
+				by: "collapse"
+			});
+		}
+		return {
+			ok: true,
+			thing: here,
+			hops
+		};
+	};
+	const walk = (steps) => {
+		const [root, ...rest] = steps;
+		if (typeof root !== "string" || !ROOTS.includes(root)) return {
+			ok: false,
+			code: "#REF!",
+			reason: `A path starts with a root: ${ROOTS.join(", ")}.`,
+			hops
+		};
+		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 (const step of rest) {
+			if (isKey(step)) {
+				const reached = derefStep(nav, here, step);
+				if (reached === void 0) return {
+					ok: false,
+					code: "#REF!",
+					reason: `The step ${String(step)} reaches nothing.`,
+					hops
+				};
+				hops.push({
+					step,
+					thing: reached.thing,
+					by: reached.by
+				});
+				here = reached.thing;
+			} else {
+				const envelope = fromJson(step);
+				const found = envelope === void 0 ? void 0 : lookupKind(nav.world, envelope.type);
+				const name = found?.ok === true ? entryOf(found.kind.verbs, "step") : void 0;
+				const walker = name === void 0 ? void 0 : nav.walkers?.[name];
+				if (envelope === void 0 || walker === void 0) return {
+					ok: false,
+					code: "#STEP?",
+					reason: "A step is a key, or a document of a kind with the verb step.",
+					hops
+				};
+				const result = walker({
+					data: envelope.value,
+					here,
+					context: ctx,
+					deref: (thing, key) => derefStep(nav, thing, key)?.thing
+				});
+				if (!result.ok) return {
+					ok: false,
+					code: "#REF!",
+					reason: result.reason,
+					hops
+				};
+				hops.push({
+					step,
+					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
+		};
+	};
+	if (path.length === 0) return {
+		ok: false,
+		code: "#REF!",
+		reason: "A path has at least one step: its root.",
+		hops
+	};
+	return walk(path);
+}
+/**
+* This function gives the value of a thing: the thing itself for JSON, or the value that a host thing gives.
+*
+* @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
+/**
+* This function splits a value into its data and its parts, by the contract of its kind. The evaluator and the
+* view use the same split, thus a picture shows the parts that the evaluation gets.
+*
+* @param spec - The contract of the parts.
+* @param value - The value of the document.
+* @returns The data and the parts, or the reason why the value does not obey the contract.
+*/
+function splitParts(spec, value) {
+	const of = (slot, declared) => declared === void 0 ? slot : {
+		...slot,
+		of: declared
+	};
+	if (spec === void 0 || spec.shape === "none") return {
+		ok: true,
+		data: value,
+		parts: []
+	};
+	if (spec.shape === "list") {
+		if (!Array.isArray(value)) return {
+			ok: false,
+			reason: "The value must be a list."
+		};
+		return {
+			ok: true,
+			data: null,
+			parts: value.map((item, index) => of({
+				key: String(index),
+				item
+			}, spec.of))
+		};
+	}
+	if (!isRecord(value)) return {
+		ok: false,
+		reason: "The value must be a record."
+	};
+	const record = value;
+	const rest = {};
+	for (const [key, item] of Object.entries(record)) if (!spec.fields.includes(key)) rest[key] = item;
+	const parts = [];
+	for (const key of spec.fields) {
+		const item = field(record, key);
+		if (item !== void 0) parts.push(of({
+			key,
+			item
+		}, spec.of));
+	}
+	return {
+		ok: true,
+		data: rest,
+		parts
+	};
+}
+//#endregion
+//#region src/evaluate.ts
+/**
+* This function makes a result with a value.
+*
+* @param value - The value.
+* @returns The result.
+*/
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+/**
+* This function makes a result with an error value.
+*
+* @param code - The code of the error.
+* @param reason - One sentence that tells the cause.
+* @returns The result.
+*/
+function fail(code, reason) {
+	return {
+		ok: false,
+		error: {
+			code,
+			reason
+		}
+	};
+}
+/**
+* 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 tells if the capabilities permit an effect. A capability permits the kind of its name, and each kind
+* in its namespace: `store` permits `store.update`.
+*
+* @param caps - The capabilities of the context.
+* @param kind - The kind of the effect.
+* @returns `true` when one capability permits it.
+*/
+function permits(caps, kind) {
+	return caps.some((cap) => cap === kind || kind.startsWith(`${cap}.`));
+}
+function selfLabel(self) {
+	if (isHostThing(self)) return self.label;
+	return self === null ? "none" : JSON.stringify(self).slice(0, 40);
+}
+const NO_ANSWER = {
+	verb: "eval",
+	error: "no-answer",
+	steps: []
+};
+/** 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);
+	return fail("#CALC!", "A part waited, and its parent cannot wait.");
+}
+/** This function drives steps that can wait. The steps before the first wait happen at once, in the call. */
+async function driveWaiting(steps) {
+	let step = steps.next();
+	while (step.done !== true) {
+		let value;
+		try {
+			value = await step.value;
+		} catch (error) {
+			step = steps.throw(error);
+			continue;
+		}
+		step = steps.next(value);
+	}
+	return step.value;
+}
+function* visit(s, value, path, declared, ctx, parent, canWait) {
+	const envelope = fromJson(value);
+	const doc = envelope ?? typed(declared ?? "?", value);
+	const node = {
+		id: s.nextId,
+		path,
+		doc,
+		declared: envelope === void 0,
+		answer: NO_ANSWER,
+		side: "derive",
+		names: Object.keys(ctx.names),
+		scope: ctx.names,
+		caps: ctx.caps,
+		self: selfLabel(ctx.self),
+		enter: s.tick,
+		exit: s.tick,
+		result: fail("#NOEVAL", "The evaluation did not end."),
+		children: [],
+		effects: []
+	};
+	s.nextId += 1;
+	s.tick += 1;
+	parent.children.push(node);
+	const finish = (result) => {
+		node.result = result;
+		node.exit = s.tick;
+		s.tick += 1;
+		return result;
+	};
+	if (envelope === void 0 && declared === void 0) return finish(fail("#PART?", "The value has no envelope, and its position declares no type."));
+	const maxDepth = s.machine.maxDepth ?? 200;
+	if (path.length > maxDepth) return finish(fail("#DEPTH!", `The nesting is deeper than ${maxDepth} documents.`));
+	const answer = ask(s.machine.world, envelope ?? {}, "eval", declared === void 0 ? {} : { declaredType: declared });
+	node.answer = answer;
+	const kind = kindOf(s.machine.world, doc.type);
+	node.side = kind?.side ?? "derive";
+	if (answer.error === "unknown-kind") return finish(fail("#KIND?", `The world has no kind ${typeName(doc.type)}.`));
+	const name = answer.evaluator;
+	const runners = s.machine.runners ?? {};
+	const runner = name !== void 0 && Object.hasOwn(runners, name) ? runners[name] : void 0;
+	const code = name !== void 0 && Object.hasOwn(s.machine.evaluators, name) ? s.machine.evaluators[name] : void 0;
+	if (name === void 0 || runner === void 0 && code === void 0) return finish(fail("#NOEVAL", `No rung gives an evaluator for ${typeName(doc.type)}.`));
+	if (runner !== void 0 && s.running && !canWait) return finish(fail("#CALC!", `${typeName(doc.type)} waits for effects, and its parent cannot wait. Give the parent a runner.`));
+	const split = splitParts(kind?.parts, doc.value);
+	if (!split.ok) return finish(fail("#VALUE!", `${split.reason} The kind is ${typeName(doc.type)}.`));
+	const slots = split.parts.map((slot) => ({
+		slot,
+		header: fromJson(slot.item)
+	}));
+	const record = (effectKind, payload) => {
+		if (!permits(ctx.caps, effectKind)) return fail("#CAP!", `The context has no capability for the effect ${effectKind}.`);
+		const effect = {
+			index: s.effects.length,
+			kind: effectKind,
+			payload,
+			node: node.id,
+			at: s.tick
+		};
+		s.effects.push(effect);
+		node.effects.push(effect.index);
+		return effect;
+	};
+	const kindText = typeName(doc.type);
+	const resolveHere = (steps) => resolve(s.machine, ctx, steps);
+	if (runner !== void 0) {
+		const parts = slots.map(({ slot, header }) => ({
+			key: slot.key,
+			...header?.name === void 0 ? {} : { name: header.name },
+			evaluate: (override) => visit(s, slot.item, [...path, slot.key], slot.of, override ?? ctx, node, true)
+		}));
+		const input = {
+			kind: kindText,
+			data: split.data,
+			parts,
+			context: ctx,
+			resolve: resolveHere,
+			effect: function* (effectKind, payload) {
+				const made = record(effectKind, payload);
+				if ("ok" in made) return made;
+				if (!s.running || s.perform === void 0) return ok(payload);
+				const failed = (error) => fail("#CALC!", `The host failed the effect ${effectKind}: ${String(error)}`);
+				let done;
+				try {
+					done = s.perform(made);
+				} catch (error) {
+					return failed(error);
+				}
+				if (!(done instanceof Promise)) return ok(done ?? null);
+				return yield done.then((result) => ok(result ?? null), failed);
+			}
+		};
+		try {
+			return finish(yield* runner(input));
+		} catch (error) {
+			return finish(fail("#CALC!", `The runner ${name} threw: ${String(error)}`));
+		}
+	}
+	const parts = slots.map(({ slot, header }) => ({
+		key: slot.key,
+		...header?.name === void 0 ? {} : { name: header.name },
+		evaluate: (override) => drive(visit(s, slot.item, [...path, slot.key], slot.of, override ?? ctx, node, false))
+	}));
+	const input = {
+		kind: kindText,
+		data: split.data,
+		parts,
+		context: ctx,
+		resolve: resolveHere,
+		effect: (effectKind, payload) => {
+			if (s.running) return fail("#CALC!", `The effect ${effectKind} needs a runner: in a run, the host does each effect.`);
+			const made = record(effectKind, payload);
+			return "ok" in made ? made : ok(payload);
+		}
+	};
+	try {
+		return finish(code(input));
+	} catch (error) {
+		return finish(fail("#CALC!", `The evaluator ${name} threw: ${String(error)}`));
+	}
+}
+function holderNode() {
+	return {
+		id: -1,
+		path: [],
+		doc: typed("?", null),
+		declared: false,
+		answer: NO_ANSWER,
+		side: "derive",
+		names: [],
+		scope: {},
+		caps: [],
+		self: "none",
+		enter: 0,
+		exit: 0,
+		result: ok(null),
+		children: [],
+		effects: []
+	};
+}
+function rootContext(machine, context) {
+	return context.world === null ? {
+		...context,
+		world: worldThing(machine.world)
+	} : context;
+}
+function record(s, holder, result) {
+	const root = 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 s = {
+		machine,
+		running: false,
+		perform: void 0,
+		effects: [],
+		tick: 0,
+		nextId: 0
+	};
+	const holder = holderNode();
+	return record(s, holder, drive(visit(s, doc, [], declaredType, rootContext(machine, context), holder, false)));
+}
+/**
+* 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.
+*
+* @param machine - The world, the evaluators and the runners.
+* @param doc - The document, as JSON.
+* @param context - The names and the capabilities at the root.
+* @param options - The host code that does the effects, and the type of a bare root value.
+* @returns The result, the trace and the effects in their order, when the run ends.
+*/
+async function run(machine, doc, context = makeContext(), options = {}) {
+	const s = {
+		machine,
+		running: true,
+		perform: options.perform,
+		effects: [],
+		tick: 0,
+		nextId: 0
+	};
+	const holder = holderNode();
+	return record(s, holder, await driveWaiting(visit(s, doc, [], options.declaredType, rootContext(machine, context), holder, true)));
+}
+/**
+* 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) {
+	let node = trace;
+	for (const key of path) {
+		node = node?.children.find((child) => child.path[child.path.length - 1] === key);
+		if (node === void 0) return void 0;
+	}
+	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 walk = (node) => {
+		out.push(node);
+		node.children.forEach(walk);
+	};
+	walk(trace);
+	return out.sort((a, b) => a.enter - b.enter);
+}
+//#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" },
+			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 path = data;
+		const found = resolve(path);
+		if (found.ok) return ok(valueOfThing(found.thing));
+		if (path[0] === "names" && found.hops.length === 1) return fail("#NAME?", `The context has no name ${String(path[1])}.`);
+		return fail(found.code, found.reason);
+	},
+	"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);
+}
+/**
+* The walker of `nearest`: it follows a key (the default is `parent`) until the node that it reaches has the
+* wanted type. With `self: true`, the node where the walk starts is the first candidate. A node without that key
+* ends the walk with an error.
+*/
+const nearest = ({ data, here, deref }) => {
+	const follow = isRecord(data) && typeof field(data, "follow") === "string" ? String(field(data, "follow")) : "parent";
+	const wanted = isRecord(data) ? field(data, "type") : void 0;
+	const fromSelf = isRecord(data) && field(data, "self") === true;
+	let at = here;
+	for (let hops = 0; hops < 256; hops += 1) {
+		if (hops > 0 || !fromSelf) at = at === void 0 || at === null ? void 0 : deref(at, follow);
+		if (at === void 0 || at === null) return {
+			ok: false,
+			reason: `No node of the type ${String(wanted)} is on the way.`
+		};
+		if ((isHostThing(at) ? at.type : void 0) === wanted) return {
+			ok: true,
+			thing: at
+		};
+	}
+	return {
+		ok: false,
+		reason: "The walk is too long."
+	};
+};
+/** The walkers of the standard world, by name. */
+const STD_WALKERS = { "walk.nearest": nearest };
+/** 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 = [
+	"names",
+	"focus",
+	"world",
+	"event",
+	"caps"
+];
+/** The descriptions of the parts, in the order of `PARTS`. */
+const PART_INFO = [
+	{
+		part: "names",
+		title: "Names",
+		reaches: "The values that a binding gives: a let, a parameter, or the result of an earlier step.",
+		direction: "Back, to the place where the program binds the name."
+	},
+	{
+		part: "focus",
+		title: "Focus",
+		reaches: "A position in a structure: the node itself, its parent, its children or its siblings.",
+		direction: "Any direction that a move permits: up, down or to the side."
+	},
+	{
+		part: "world",
+		title: "World",
+		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: "formula",
+			value: {
+				let: { gap: 8 },
+				body: {
+					op: "add",
+					args: [{
+						ref: "width",
+						at: "parent"
+					}, { var: "gap" }]
+				}
+			}
+		},
+		uses: {
+			names: {
+				reads: true,
+				gives: "extends",
+				note: "A let binds names for its body."
+			},
+			focus: {
+				reads: true,
+				gives: "moves",
+				note: "A move reads the parent. An axis moves the focus 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: "cards.ids"
+					},
+					set: { done: true }
+				}
+			}]
+		},
+		uses: {
+			names: {
+				reads: true,
+				gives: "extends",
+				note: "The result of each step is a name for the later steps."
+			},
+			focus: 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: "title"
+					}
+				}]
+			}
+		},
+		uses: {
+			names: {
+				reads: true,
+				gives: "extends",
+				note: "The data of the node becomes a name for its children."
+			},
+			focus: {
+				reads: true,
+				gives: "moves",
+				note: "Each child becomes the focus of 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: "rule",
+			value: {
+				use: "stack",
+				with: { gap: 8 }
+			}
+		},
+		uses: {
+			names: {
+				reads: true,
+				gives: "none",
+				note: "The rule reads its parameters."
+			},
+			focus: {
+				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."
+			},
+			focus: {
+				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: "board"
+				} }
+			}
+		},
+		uses: {
+			names: {
+				reads: true,
+				gives: "none",
+				note: "The query reads its parameters."
+			},
+			focus: NONE,
+			world: {
+				reads: true,
+				gives: "none",
+				note: "The query reads one collection."
+			},
+			event: NONE,
+			caps: NONE
+		}
+	}
+];
+//#endregion
+export { CONSTRUCTS, ENVELOPE_KEYS, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_EVALUATORS, STD_MACHINE, STD_RUNNERS, STD_WALKERS, STD_WORLD, THING, ask, checkSteps, classify, context, dataEdges, derefStep, effectEdges, entriesAsJson, evaluate, fail, field, flatten, fromJson, isAlias, isAllowedOrder, isEnvelope, isHostThing, isKey, isKind, isRecord, isRef, isTypeRef, kindDocument, kindNamed, kindOf, layers, lookupKind, makeContext, nodeAt, ok, permits, ref, resolve, run, splitParts, tag, toJson, typeName, typePath, typed, valueOfThing, worldThing };
+
+//# sourceMappingURL=index.js.map