@mark1russell7/coeval 0.20.1 → 0.21.0

package/build/index.js

@@ -354,6 +354,11 @@ function describe(value) {
 	}
 }
 // src/world.ts
+/** The rule of the registry of binding names. */
+const NAMES_RULE = /* @__PURE__ */ Object.freeze({
+	ok: true,
+	names: true
+});
 /** The most rounds of a circular attribute without its own `limit` (TREE.CIRCULAR-LIMIT, D113). */
 const CIRCULAR_LIMIT = 100;
 /** This function tells if a value is JSON data: `null`, a truth value, a finite number, a text, or a container of them. */
@@ -403,6 +408,26 @@ function circularOf(declared) {
 	};
 }
 /**
+* This function reads the declaration `collect` of an attribute (D122). The tree kit, the reference, `check` and the
+* graph of attribute instances read it with this one function.
+*
+* @param declared - The value of the field `collect`.
+* @returns The rule of the collection, or the reason when the declaration has no correct form.
+*/
+function collectOf(declared) {
+	if (declared === "names") return NAMES_RULE;
+	if (!isRecord(declared) || !Object.hasOwn(declared, "unit") || !Object.hasOwn(declared, "combine")) return {
+		ok: false,
+		reason: "The declaration collect needs the text \"names\" or a record with the fields unit and combine."
+	};
+	return {
+		ok: true,
+		names: false,
+		unit: field(declared, "unit"),
+		combine: field(declared, "combine")
+	};
+}
+/**
 * This function gives the type of a bare equation of a kind (D42). It is the type `of` of the shape of its parts, or
 * else the type `of` of the shape `rest` of a record. The plan, the reference and `check` read it with this one function.
 *
@@ -1584,8 +1609,10 @@ function valueStep(value, key) {
 *
 * - A record gives the type of its field. A closed record without the field has no such step. An open record gives
 *   `unknown`.
-* - A list gives the type of its items for an index, and `number` for `length`.
-* - A base type reads the steps of its domain, then of each parent (`Domain.steps`).
+* - A list gives the type of its items for an index, and `number` for `length`. Another key has no such step.
+* - A base type reads the steps of its domain, then of each parent (`Domain.steps`). A base type of the kernel
+*   without such a step has no step, because its values are not objects (TYPE.NO-STEP, D120).
+* - A function type has no step, because a step into a function reaches nothing.
 * - A union joins the steps of its types. `one` gives the values that the step reaches.
 * - Each other step gives `unknown`, and `never` gives `never`.
 *
@@ -1604,10 +1631,11 @@ function stepType(type, key, domains, examine, depth = 0) {
 				const found = steps[name];
 				return { type: examine === void 0 ? found : examine(found, `type of the step ${name} of the domain ${each}`) };
 			}
-			return { type: "unknown" };
+			return Object.hasOwn(STD_DOMAINS, form.name) ? NO_STEP : { type: "unknown" };
+		case "fn": return NO_STEP;
 		case "list":
 			if (key === "length") return { type: "number" };
-			return { type: indexOf(key) >= 0 ? form.item : "unknown" };
+			return indexOf(key) >= 0 ? { type: form.item } : NO_STEP;
 		case "record":
 			if (Object.hasOwn(form.fields, name)) return { type: form.fields[name] };
 			return form.closed ? { missing: Object.keys(form.fields) } : { type: "unknown" };
@@ -1634,6 +1662,8 @@ function stepType(type, key, domains, examine, depth = 0) {
 		default: return { type: "unknown" };
 	}
 }
+/** The answer of `stepType` for a type whose members have no step with the key, and no fields to name. */
+const NO_STEP = { missing: [] };
 /**
 * This function lists the problems of a value type (TYPE.ISSUES). A problem is a term that is not a value type, a
 * base type without a domain, or a term that is too deep. `fits` and `member` read each such term as `unknown`.
@@ -3420,6 +3450,34 @@ function pathMatches(path, pattern) {
 	}
 	return true;
 }
+/**
+* This function tells if a list of rules in the form of the lazy rules covers a part (D24, D119). A rule without
+* `in` covers each part. With `after: n`, a rule covers only the parts after the first `n` parts that it matches.
+*
+* @param rules - The rules.
+* @param shape - The shape of the parts of the parent.
+* @param value - The value of the parent.
+* @param slot - The path of the part in the value.
+* @returns `true` when a rule covers the part.
+*/
+function rulesCover(rules, shape, value, slot) {
+	for (const rule of rules) {
+		if (rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(slot, pattern))) continue;
+		const after = rule.after ?? 0;
+		if (after <= 0) return true;
+		const split = splitParts(shape, value);
+		let count = 0;
+		for (const part of split.ok ? split.parts : []) {
+			if (rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(part.path, pattern))) continue;
+			if (part.path.length === slot.length && pathMatches(part.path, slot)) {
+				if (count >= after) return true;
+				break;
+			}
+			count += 1;
+		}
+	}
+	return false;
+}
 function valueAt(value, path) {
 	let here = value;
 	for (const key of path) if (Array.isArray(here)) here = here[Number(key)];
@@ -4583,6 +4641,7 @@ function pureCode(c, envelope, kind, typePath, name, quick) {
 	} catch {
 		return false;
 	}
+	if (answer?.effects !== void 0 && answer.effects.length > 0) return false;
 	const described = c.verb === "eval" && (envelope === void 0 || quick?.rung !== "own" || name === answerOf(c.machine.world, void 0, kind, c.verb)?.name);
 	const pure = described ? answer?.pure ?? kind.pure : answer?.pure;
 	const volatile = described ? answer?.volatile ?? kind.volatile : answer?.volatile;
@@ -5425,6 +5484,14 @@ const STD_WORLD = {
 			pure: true,
 			summary: "A step of a path: it follows a key again and again, until it reaches a node of a type."
 		},
+		tree: { kinds: { named: {
+			verbs: {
+				step: "walk.named",
+				view: "view.card"
+			},
+			pure: true,
+			summary: "A step of a path: it goes up to the nearest registry of names, and it gives the node with the name (TREE.NAMED)."
+		} } },
 		panel: {
 			verbs: {
 				eval: "tree.node",
@@ -5664,6 +5731,12 @@ const WORLD_SYNTAX = /* @__PURE__ */ Object.freeze({
 					"self"
 				]
 			},
+			{
+				name: "tree.named",
+				kind: "tree.named",
+				args: "named",
+				fields: ["name", "in"]
+			},
 			{
 				name: "add",
 				kind: "add"
@@ -6203,6 +6276,58 @@ function plainOf(value, path) {
 	}
 }
 /**
+* This function gives the collection of an attribute of a node (TREE.COLLECT, D122). It visits the node, then each node
+* of the same tree in each list `children`, in the order of the lists. Each node is visited one time.
+* The registry of names (TREE.NAMED) gives a record from each binding name to its node.
+*/
+function collected(root, key, declared) {
+	const top = stateOf(root);
+	const rule = collectOf(declared);
+	if (!rule.ok) return fail("#VALUE!", `The attribute ${attributeText(key, top.type, top.place)} has a bad declaration collect. ${rule.reason}`);
+	const registry = {};
+	const owners = /* @__PURE__ */ new Map();
+	let acc = rule.names ? ok(registry) : top.equation(rule.unit, NO_NAMES$1);
+	if (!acc.ok) return acc;
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [root];
+	while (stack.length > 0) {
+		const thing = stack.pop();
+		const at = stateOf(thing);
+		if (at === void 0 || at.build !== top.build || seen.has(at)) continue;
+		seen.add(at);
+		if (rule.names) {
+			const name = at.name;
+			const earlier = name === void 0 ? void 0 : owners.get(name);
+			if (earlier !== void 0) {
+				const both = `${earlier.type} at [${earlier.place.join(", ")}] and ${at.type} at [${at.place.join(", ")}]`;
+				return fail("#VALUE!", `Two nodes have the name ${name} in the registry ${attributeText(key, top.type, top.place)}: ${both}.`);
+			}
+			if (name !== void 0) {
+				owners.set(name, at);
+				putField(registry, name, thing);
+			}
+		} else {
+			const term = entryOf(at.tree?.contributes, key);
+			if (term !== void 0) {
+				const item = at.equation(term, NO_NAMES$1);
+				if (!item.ok) return item;
+				acc = top.equation(rule.combine, {
+					acc: acc.value,
+					item: item.value
+				});
+				if (!acc.ok) return acc;
+			}
+		}
+		const children = at.read("children");
+		if (children === void 0) continue;
+		if (!children.ok) return children;
+		if (!Array.isArray(children.value)) return fail("#VALUE!", `The collection of ${key} needs a list in children of ${at.type} at [${at.place.join(", ")}].`);
+		const list = children.value;
+		for (let index = list.length - 1; index >= 0; index -= 1) stack.push(list[index]);
+	}
+	return acc;
+}
+/**
 * This function makes a node of the decorated tree. A step `parent` gives the self of the context of the node, and a
 * step `type` gives its type. Another step reads an attribute through its ladder (TREE.LADDER). The rungs are a part of
 * the node, an equation of its kind and an equation `down` of the kind of its parent. A copy from the parent, then a
@@ -6279,6 +6404,10 @@ function treeThing(input, place, build, outer, host) {
 			result: fold(key, declared.fold),
 			by: "default"
 		};
+		if (declared?.collect !== void 0) return {
+			result: collected(node, key, declared.collect),
+			by: "default"
+		};
 		if (declared?.default !== void 0) return {
 			result: state.equation(declared.default, NO_NAMES$1),
 			by: "default"
@@ -6357,6 +6486,7 @@ function treeThing(input, place, build, outer, host) {
 	};
 	const state = {
 		build,
+		name: input.doc.name,
 		type,
 		place,
 		tree,
@@ -6538,8 +6668,45 @@ function nearestWalker(options = {}) {
 		};
 	};
 }
+const nearest = /* @__PURE__ */ nearestWalker();
+/**
+* The walker of the step `tree.named` (TREE.NAMED, D122). It goes up from the thing before the step through the key
+* `parent`, to the first thing that answers the registry. The field `in` names the registry, and the default is
+* `names`. The walker gives the node with the field `name` in that registry.
+*/
+const named$2 = ({ data, here, deref }) => {
+	const name = isRecord(data) ? field(data, "name") : void 0;
+	if (typeof name !== "string") return {
+		ok: false,
+		code: "#VALUE!",
+		reason: "The step tree.named needs a text name."
+	};
+	const registry = isRecord(data) && typeof field(data, "in") === "string" ? String(field(data, "in")) : "names";
+	let at = here;
+	for (let hops = 0; hops < 256 && at !== void 0 && at !== null; hops += 1) {
+		const found = deref(at, registry);
+		if (found !== void 0) {
+			if (!isRecord(found) || !Object.hasOwn(found, name)) return {
+				ok: false,
+				reason: `The registry ${registry} has no node with the name ${name}.`
+			};
+			return {
+				ok: true,
+				thing: field(found, name)
+			};
+		}
+		at = deref(at, "parent");
+	}
+	return {
+		ok: false,
+		reason: `No registry ${registry} is on the way.`
+	};
+};
 /** The walkers of the standard world, by name. */
-const STD_WALKERS = { "walk.nearest": /* @__PURE__ */ nearestWalker() };
+const STD_WALKERS = {
+	"walk.nearest": nearest,
+	"walk.named": named$2
+};
 /** This function evaluates parts one after the other, and stops at the first error. */
 function* inOrder(parts) {
 	const values = [];
@@ -7524,7 +7691,7 @@ function factsOf(machine, doc, options = {}) {
 					at: tight(place.at)
 				});
 			}
-			const declared = declaredEffects(v, verb);
+			const declared = verb === "eval" && answer?.effects !== void 0 ? effectKeys(v, answer.effects) : declaredEffects(v, verb);
 			if (verb === "eval" ? kind.side === "run" : declared.length > 0) {
 				if (node === void 0) side = "run";
 				else pure = false;
@@ -8245,8 +8412,57 @@ function rungReads(b, id) {
 		});
 		return;
 	}
+	const collect = declared?.collect === void 0 ? void 0 : collectOf(declared.collect);
+	if (collect?.ok === true) {
+		collectReads(b, node, key, collect, later);
+		return;
+	}
 	if (declared?.default !== void 0) termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.default`, declared.default), node, void 0, later);
 }
+/** This function gives the list children of a node before the run. A node without a rung for it has no children. */
+function childrenOf(b, at) {
+	const part = at.parts.get("children");
+	if (part !== void 0) return valueOf$1(part);
+	const tree = at.kind.tree;
+	if (hasOwnEntry(tree?.equations, "children") || hasOwnEntry(tree?.attributes, "children")) return "unknown";
+	if (at.up === void 0) return downNames(b.machine.world).has("children") ? "unknown" : "data";
+	return at.up !== null && hasOwnEntry(at.up.kind.tree?.down, "children") ? "unknown" : "data";
+}
+/**
+* This function adds the reads of a collection (TREE.COLLECT, D122), in the order of the run. Each node of the subtree
+* gives the reads of its contribution and of its list `children`. A list that only the run knows gives an edge with an
+* unknown source. The registry of names reads only the lists `children`.
+*/
+function collectReads(b, node, key, rule, later) {
+	if (!rule.names) termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.collect.unit`, rule.unit), node, void 0, later);
+	let combined = false;
+	const done = /* @__PURE__ */ new Set();
+	const stack = [node];
+	while (stack.length > 0) {
+		const at = stack.pop();
+		if (done.has(at)) continue;
+		done.add(at);
+		const term = rule.names || !hasOwnEntry(at.kind.tree?.contributes, key) ? void 0 : at.kind.tree?.contributes?.[key];
+		if (term !== void 0) {
+			termReads(b, termRefs(b, at.kind, `tree.contributes.${key}`, term), at, void 0, later);
+			combined = true;
+		}
+		edge(b, vertexOf(b, at, "children"), later);
+		const children = childrenOf(b, at);
+		if (children === "unknown") edge(b, void 0, later);
+		else if (typeof children === "object" && "list" in children) {
+			const items = itemsOf(children.list);
+			for (let index = items.length - 1; index >= 0; index -= 1) {
+				const child = items[index]?.node;
+				if (child !== void 0 && child.up === at) stack.push(child);
+			}
+		}
+	}
+	if (!rule.names) termReads(b, termRefs(b, node.kind, `tree.attributes.${key}.collect.combine`, rule.combine), node, void 0, combined ? later : {
+		...later,
+		lazy: true
+	});
+}
 function build(machine, doc, declaredType) {
 	const b = {
 		machine,
@@ -8732,21 +8948,56 @@ function mapRefs(world, doc, change, options = {}) {
 	}
 	return out;
 }
+/**
+* This function gives the parts that the code of a runner evaluates itself, without a wait (RUN.DRIVES, D119). The
+* answer of the hook `facts` for the code wins over the contract. The contract describes only the code of its kind for
+* `eval`. Without a declaration, the runner passes each wait of its parts through.
+*/
+function driveRules(machine, v, kind, name, rung, verb) {
+	if (verb !== "eval") return void 0;
+	const hook = machine.facts?.(v.typePath ?? [], name)?.drives;
+	if (hook !== void 0) return hook;
+	return v.declared || rung !== "own" || name === answerOf(machine.world, void 0, kind, verb)?.name ? kind.drives : void 0;
+}
 /** The least authority: the capability `[]` permits each effect (CAP.KEYS). */
 const EACH$1 = /* @__PURE__ */ Object.freeze([[]]);
 /** No declared effect. One list serves each visit without effects. */
 const NO_EFFECTS = /* @__PURE__ */ Object.freeze([]);
 /**
-* This function gives the effects that the contract of the kind of a visit declares for a verb, as keys
-* (FACTS.EFFECTS, VERB.EFFECTS). The text `"type"` gives the type of the document after each alias. A visit without a
-* kind declares no effect. `check`, `factsOf` and `effectsOf` read the declarations with this one function (D27).
+* This function gives the effects that the code of a visit declares for a verb, as keys (FACTS.EFFECTS, VERB.EFFECTS).
+* The text `"type"` gives the type of the document after each alias. A visit without a kind declares no effect.
+* `check`, `factsOf`, `effectsOf` and `checkLatent` read the declarations with this one function (D27).
+*
+* For `eval`, the answer of the hook `facts` of the machine for the code of the visit wins over the contract of the
+* kind (CAP.OWN-EFFECTS, D118). Thus a language gives the effects of an own entry for another evaluator. Without a
+* machine, or without the field `effects` in the answer, the contract gives the effects.
 *
 * @param v - The visit.
 * @param verb - The verb. The default is `eval`. A kind without a declaration for the verb gives no effect.
-* @returns The keys of each declared effect, in the order of the contract.
+* @param machine - The machine with the hook `facts`, when the caller has it.
+* @param name - The name of the evaluator of the visit, when the caller knows it. Else the ladder gives it.
+* @returns The keys of each declared effect, in the order of the declaration.
+*/
+function declaredEffects(v, verb = "eval", machine, name) {
+	return hookEffects(v, verb, machine, name) ?? verbDeclared(v, verb) ?? NO_EFFECTS;
+}
+/**
+* This function gives the effects that the hook `facts` gives for the code of a visit, as keys (D118). The result is
+* `undefined` for another verb than `eval`, without the hook, or when the answer has no field `effects`.
+*/
+function hookEffects(v, verb, machine, name) {
+	if (verb !== "eval" || machine?.facts === void 0 || v.kind === void 0) return void 0;
+	const code = name ?? answerOf(machine.world, v.declared ? void 0 : v.doc.own, v.kind, "eval")?.name;
+	const effects = code === void 0 ? void 0 : machine.facts(v.typePath ?? [], code)?.effects;
+	return effects === void 0 ? void 0 : effectKeys(v, effects);
+}
+/**
+* This function gives the keys of a declaration of effects at a visit (D27). The text `"type"` gives the type of the
+* document after each alias.
 */
-function declaredEffects(v, verb = "eval") {
-	return verbDeclared(v, verb) ?? NO_EFFECTS;
+function effectKeys(v, effects) {
+	if (effects.length === 0) return NO_EFFECTS;
+	return effects === "type" ? [v.typePath ?? []] : effects.map((kind) => kind.split("."));
 }
 /**
 * This function gives the effects that the contract of the kind of a visit declares for a verb, as keys. The result
@@ -8757,8 +9008,7 @@ function verbDeclared(v, verb) {
 	if (v.kind === void 0) return verb === "eval" ? NO_EFFECTS : void 0;
 	const effects = effectsOfVerb(v.kind, verb);
 	if (effects === void 0) return void 0;
-	if (effects.length === 0) return NO_EFFECTS;
-	return effects === "type" ? [v.typePath ?? []] : effects.map((kind) => kind.split("."));
+	return effectKeys(v, effects);
 }
 /**
 * This function gives the rule of a machine for an effect, for the static kit (CAP.PERMITS). The rule is the hook
@@ -8907,7 +9157,8 @@ const DOWN_NAMES = /* @__PURE__ */ Object.freeze([
 const FOLD_NAMES = /* @__PURE__ */ Object.freeze(["acc", "item"]);
 /**
 * This function gives each equation of the tree contract of a kind, with the names that it sees (D42). An equation of
-* `equations`, a `unit` and a `default` see no names. `check` and `factsOf` read the equations with this one function.
+* `equations`, a `unit`, a `default` and a contribution see no names. `check` and `factsOf` read the equations with
+* this one function.
 */
 function equationsOf(kind) {
 	const tree = kind.tree;
@@ -8951,7 +9202,32 @@ function equationsOf(kind) {
 			attribute: name,
 			down: false
 		});
+		const collect = declared.collect === void 0 ? void 0 : collectOf(declared.collect);
+		if (collect?.ok === true && !collect.names) {
+			out.push({
+				label: `tree.attributes.${name}.collect.unit`,
+				term: collect.unit,
+				names: [],
+				attribute: name,
+				down: false
+			});
+			out.push({
+				label: `tree.attributes.${name}.collect.combine`,
+				term: collect.combine,
+				names: FOLD_NAMES,
+				attribute: name,
+				down: false
+			});
+		}
 	}
+	for (const [name, term] of Object.entries(tree.contributes ?? {})) out.push({
+		label: `tree.contributes.${name}`,
+		term,
+		names: [],
+		attribute: name,
+		down: false,
+		contributes: true
+	});
 	return out;
 }
 /**
@@ -9073,7 +9349,7 @@ function answered(world, node, name) {
 	if (hasEntry(tree?.equations, name)) return true;
 	if (node.parent === void 0 ? downNames(world).has(name) : hasEntry(node.parent.kind.tree?.down, name)) return true;
 	const declared = tree?.attributes !== void 0 && Object.hasOwn(tree.attributes, name) ? tree.attributes[name] : void 0;
-	return declared !== void 0 && (declared.copy === true || declared.fold !== void 0 || declared.default !== void 0);
+	return declared !== void 0 && (declared.copy === true || declared.fold !== void 0 || declared.collect !== void 0 || declared.default !== void 0);
 }
 /**
 * This function checks the equations of the tree contract of a kind, each with the names of its rung (TREE.DOWN-NAMES).
@@ -9097,7 +9373,7 @@ function equationIssues(machine, kind, kindText, options, state) {
 		own: void 0,
 		parent: void 0
 	};
-	for (const { label, term, names, attribute, down } of equationsOf(kind)) {
+	for (const { label, term, names, attribute, down, contributes } of equationsOf(kind)) {
 		const inner = {
 			names,
 			...of === void 0 ? {} : { declaredType: of },
@@ -9107,7 +9383,7 @@ function equationIssues(machine, kind, kindText, options, state) {
 			needs.push({
 				name,
 				why: `the equation ${label} reads it`,
-				hidden: down ? void 0 : attribute
+				hidden: down || contributes === true ? void 0 : attribute
 			});
 		};
 		for (const issue of checkAll(machine, term, inner, void 0, state, {
@@ -9124,7 +9400,8 @@ function equationIssues(machine, kind, kindText, options, state) {
 /**
 * This function finds the issues of the contract of a tree kind (TREE.CHECK-RESERVED). An attribute with the name of a
 * structural step gets no read. A tree kind of the run side contradicts the evaluation on demand of its attributes. A
-* declaration `circular` without a start value or with a bad limit gives `#VALUE!` (TREE.CIRCULAR-CHECK).
+* declaration `circular` without a start value or with a bad limit gives `#VALUE!` (TREE.CIRCULAR-CHECK). A declaration
+* `collect` without its form gives `#VALUE!` too (TREE.COLLECT).
 */
 function contractIssues(kind, kindText) {
 	const out = [];
@@ -9132,7 +9409,8 @@ function contractIssues(kind, kindText) {
 	for (const table of [
 		"equations",
 		"down",
-		"attributes"
+		"attributes",
+		"contributes"
 	]) for (const name of Object.keys(tree?.[table] ?? {})) {
 		const why = Object.hasOwn(STRUCTURAL, name) ? STRUCTURAL[name] : void 0;
 		if (why !== void 0) out.push({
@@ -9148,6 +9426,12 @@ function contractIssues(kind, kindText) {
 			place: [],
 			reason: `The kind ${kindText} has a bad declaration tree.attributes.${name}.circular. ${rule.reason}`
 		});
+		const collect = declared.collect === void 0 ? void 0 : collectOf(declared.collect);
+		if (collect !== void 0 && !collect.ok) out.push({
+			code: "#VALUE!",
+			place: [],
+			reason: `The kind ${kindText} has a bad declaration tree.attributes.${name}.collect. ${collect.reason}`
+		});
 	}
 	if (kind.side === "run") out.push({
 		code: "#CALC!",
@@ -9235,6 +9519,7 @@ function checkAll(machine, doc, options, nodes, state = {
 	};
 	const allowed = options.caps === void 0 ? void 0 : permitsOf(machine);
 	const waits = options.run === true ? /* @__PURE__ */ new Map() : void 0;
+	const driven = /* @__PURE__ */ new Map();
 	const drives = [];
 	const maxDepth = machine.maxDepth ?? 1e3;
 	const anyName = options.names === "any";
@@ -9311,7 +9596,7 @@ function checkAll(machine, doc, options, nodes, state = {
 			});
 		}
 		const caps = v.caps;
-		const stated = verbDeclared(v, verb);
+		const stated = hookEffects(v, verb, machine, name) ?? verbDeclared(v, verb);
 		const declared = stated ?? NO_EFFECTS;
 		if (allowed !== void 0 && caps !== void 0) {
 			for (const kind of declared) if (!allowed(caps, kind)) push({
@@ -9322,7 +9607,9 @@ function checkAll(machine, doc, options, nodes, state = {
 			});
 		}
 		if (waits !== void 0 && coded) {
-			const up = v.parent === void 0 ? true : waits.get(v.parent);
+			let up = v.parent === void 0 ? true : waits.get(v.parent);
+			const rules = v.parent === void 0 ? void 0 : driven.get(v.parent);
+			if (up !== false && rules !== void 0 && v.parent !== void 0 && rulesCover(rules, v.parent.kind?.parts, v.parent.doc.value, v.slot)) up = false;
 			let chain = false;
 			if (runner && up === false) {
 				chain = {
@@ -9339,6 +9626,10 @@ function checkAll(machine, doc, options, nodes, state = {
 				drives.push(chain);
 			} else if (runner) chain = up ?? true;
 			waits.set(v, chain);
+			if (runner && v.kind !== void 0) {
+				const own = driveRules(machine, v, v.kind, name, answer.rung, verb);
+				if (own !== void 0 && own.length > 0) driven.set(v, own);
+			}
 			if (typeof chain === "object" && !chain.wait) {
 				const rule = allowed ?? permits;
 				chain.wait = stated === void 0 || declared.some((kind) => caps === void 0 || rule(caps, kind));
@@ -9444,7 +9735,7 @@ function reaching(machine, doc, options) {
 	const rule = options.caps === void 0 ? permits : permitsOf(machine);
 	walk(machine.world, doc, (v) => {
 		const caps = v.caps ?? EACH;
-		for (const kind of declaredEffects(v)) if (rule(caps, kind)) out.push({
+		for (const kind of declaredEffects(v, "eval", machine)) if (rule(caps, kind)) out.push({
 			kind,
 			visit: v
 		});
@@ -9465,7 +9756,9 @@ function reaching(machine, doc, options) {
 *
 * The result covers each effect that an evaluation or a run gives the host (CAP.EFFECTS-SOUND). A procedure value keeps
 * the capabilities of the document that made it, thus the effects of its body count at the body (CAP.LATENT). The
-* contract describes the code of its kind. The code of an own entry for another evaluator is outside the result.
+* contract describes the code of its kind. The contract does not describe the code of an own entry for another
+* evaluator. The answer of the hook `facts` for that code gives its effects (CAP.OWN-EFFECTS, D118). Without an
+* answer, its effects are outside the result.
 *
 * @param machine - The world and its contracts, and the hook `permits`.
 * @param doc - The document, as JSON.
@@ -9965,6 +10258,30 @@ function paramsOf(value) {
 	const params = isRecord(value) ? value["params"] : void 0;
 	return Array.isArray(params) ? params.filter((param) => typeof param === "string") : [];
 }
+/** This function gives the text of a step of a path: a key, or the kind of a step document in parentheses. */
+function stepText(step) {
+	if (isKey(step)) return String(step);
+	return isRecord(step) ? `(${typeName(step["type"])})` : "(step)";
+}
+/**
+* This function gives the type of what a step document reaches (TYPE.WALKER, D121). The type rule of its walker gives
+* it. A step document with parts gets its data in the run, thus its type is `unknown`, as for a walker without a rule.
+*
+* @param input - The input of the rule of the reference.
+* @param step - The step document.
+* @param here - The type before the step.
+* @returns The type of what the step reaches.
+*/
+function walkType(input, step, here) {
+	const rule = walkerOf(input.machine, step)?.type;
+	if (rule === void 0) return "unknown";
+	const read = partsOf(input.machine.world, step);
+	if (!read.ok || !read.split.ok || read.split.parts.length > 0) return "unknown";
+	return input.contract(rule({
+		data: read.doc.value,
+		here
+	}), `type of the step ${typeName(read.doc.type)}`);
+}
 /**
 * This function makes the type rules of the formula kit for one profile (TYPE.SYNTH, D25). Each evaluator of the kit
 * holds its rule. The rules read the rules of the profile that change a type: `truthy`, `truthType`, `logic`,
@@ -10105,11 +10422,14 @@ function formulaTypes(profile) {
 				if (isUnknown(type, domains) || !plain && holdsEnvelope(type, domains)) return "unknown";
 				if (index >= path.length) return type;
 				const step = path[index];
-				if (!isKey(step)) return "unknown";
+				if (!isKey(step)) {
+					type = walkType(input, step, type);
+					continue;
+				}
 				const next = stepType(type, step, domains, input.contract);
 				if ("missing" in next) {
 					const fields = next.missing.length === 0 ? "" : ` Its fields are ${listText(next.missing)}.`;
-					report({ reason: `The value at ${path.slice(0, index).map(String).join(".")} has no field ${String(step)}.${fields}` });
+					report({ reason: `The value at ${path.slice(0, index).map(stepText).join(".")} has no field ${String(step)}.${fields}` });
 					return "unknown";
 				}
 				type = next.type;
@@ -12638,6 +12958,55 @@ function foldOf(node, name, fold) {
 	return acc;
 }
 /**
+* TREE.COLLECT and TREE.NAMED: the node, then each node of this tree in each list `children`, in the order of the
+* lists. Each node counts one time. The registry `names` maps each binding name to its node.
+*/
+function collectIn(node, name, declared) {
+	const rule = collectOf(declared);
+	if (!rule.ok) return fail("#VALUE!", `The attribute ${nameOfAttribute(node, name)} has a bad declaration collect. ${rule.reason}`);
+	const registry = {};
+	const first = /* @__PURE__ */ new Map();
+	let acc = rule.names ? ok(registry) : equationOf(node, rule.unit, {});
+	if (!acc.ok) return acc;
+	const done = [];
+	const visit = (at) => {
+		if (done.includes(at)) return void 0;
+		done.push(at);
+		if (rule.names && at.name !== void 0) {
+			const earlier = first.get(at.name);
+			if (earlier !== void 0) return fail("#VALUE!", `Two nodes have the name ${at.name} in the registry ${nameOfAttribute(node, name)}: ${earlier.kind} at [${earlier.place.join(", ")}] and ${at.kind} at [${at.place.join(", ")}].`);
+			first.set(at.name, at);
+			Object.defineProperty(registry, at.name, {
+				value: at.thing,
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+		}
+		const term = rule.names ? void 0 : termIn(at.contract?.contributes, name);
+		if (!rule.names && term !== void 0) {
+			const item = equationOf(at, term, {});
+			if (!item.ok) return item;
+			acc = equationOf(node, rule.combine, {
+				acc: acc.ok ? acc.value : null,
+				item: item.value
+			});
+			if (!acc.ok) return acc;
+		}
+		const children = attributeOf(at, "children");
+		if (children === void 0) return void 0;
+		if (!children.ok) return children;
+		if (!Array.isArray(children.value)) return fail("#VALUE!", `The collection of ${name} needs a list in children of ${at.kind} at [${at.place.join(", ")}].`);
+		for (const item of children.value) {
+			const child = refNodeOf(item);
+			if (child === void 0 || child.tree !== node.tree) continue;
+			const failed = visit(child);
+			if (failed !== void 0) return failed;
+		}
+	};
+	return visit(node) ?? acc;
+}
+/**
 * TREE.LADDER: the rungs of the ladder of an attribute, in their order. A rung gives `undefined` when it does not
 * answer, and the next rung then tries.
 */
@@ -12661,6 +13030,7 @@ const REF_RUNGS = [
 	["default", (node, name) => {
 		const declared = termIn(node.contract?.attributes, name);
 		if (declared?.fold !== void 0) return foldOf(node, name, declared.fold);
+		if (declared?.collect !== void 0) return collectIn(node, name, declared.collect);
 		return declared?.default === void 0 ? void 0 : equationOf(node, declared.default, {});
 	}]
 ];
@@ -12848,7 +13218,7 @@ function plainValue(value, open) {
 * tree gives its JSON. A step on the thing reads an attribute, and a failed attribute throws its own error. The node
 * reads `self` only through `resolve` (C4, TREE.SELF).
 */
-const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolve: walk }) => {
+const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolve: walk, doc }) => {
 	const reached = walk(["self"]);
 	const parent = reached.ok ? reached.thing : void 0;
 	const outer = refNodeOf(parent);
@@ -12859,6 +13229,7 @@ const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolv
 	const node = {
 		tree: nested ? outer.tree : { open: true },
 		kind,
+		name: doc.name,
 		place,
 		parts,
 		ctx: context,
@@ -15182,6 +15553,7 @@ var Shot = class {
 	scenario;
 	context;
 	keys;
+	driven;
 	perform;
 	replay;
 	calls = [];
@@ -15195,12 +15567,13 @@ var Shot = class {
 	result = NO_RESULT;
 	afterwards = false;
 	running;
-	constructor(machine, runner, scenario, context, keys, perform, replay) {
+	constructor(machine, runner, scenario, context, keys, driven, perform, replay) {
 		this.machine = machine;
 		this.runner = runner;
 		this.scenario = scenario;
 		this.context = context;
 		this.keys = keys;
+		this.driven = driven;
 		this.perform = perform;
 		this.replay = replay;
 		this.running = scenario.running;
@@ -15224,7 +15597,7 @@ var Shot = class {
 		});
 		const key = this.keys[part] ?? String(part);
 		if (via === "run" && !this.runner) this.problems.push(`The code of an evaluator starts the steps of the part ${key}. Only a runner waits.`);
-		if (via === "code" && this.runner && this.running) this.problems.push(`The runner evaluates the part ${key} with its code, and that code cannot wait. A runner evaluates a part with its steps (K65).`);
+		if (via === "code" && this.runner && this.running && this.driven[part] !== true) this.problems.push(`The runner evaluates the part ${key} with its code, and that code cannot wait. A runner evaluates a part with its steps, or its contract declares the part in drives (D119).`);
 		return this.scenario.results[part] ?? NO_RESULT;
 	}
 	/** This function records a call of a part, and gives the steps of the probe part. In a run, the part can wait. */
@@ -15417,13 +15790,14 @@ function typesNaming(world, name, verb) {
 /** This function gives the facts of the kind of a type. The hook `facts` of the machine wins over the contract. */
 function contractOf(env, kind, typePath, caps) {
 	const facts = env.machine.facts?.(typePath, env.name);
-	const own = effectsOfVerb(kind, env.verb);
+	const own = (env.verb === "eval" ? facts?.effects : void 0) ?? effectsOfVerb(kind, env.verb);
 	const effects = own ?? kind.effects;
 	const declared = effects === void 0 ? [] : effects === "type" ? [typePath] : effects;
 	return {
 		declared,
 		pure: (facts?.pure ?? kind.pure) === true,
 		lazy: facts?.lazy ?? kind.lazy,
+		drives: env.verb === "eval" ? facts?.drives ?? kind.drives : void 0,
 		describes: env.verb === "eval",
 		declares: own !== void 0,
 		caps: caps ?? [...declared, "probe"]
@@ -15571,6 +15945,7 @@ function samplesOf(type, typePath, kind, contract, extra) {
 			},
 			otherSplit,
 			lazy: split.parts.map((_slot, index) => contract.lazy?.some((rule) => covers(rule, split.parts, index)) === true),
+			driven: split.parts.map((_slot, index) => contract.drives?.some((rule) => covers(rule, split.parts, index)) === true),
 			names: scopesOf(kind.scope, value, split.parts).sees
 		});
 	}
@@ -15717,7 +16092,7 @@ function instanceOf(env, under, doc, split, sample) {
 /** This function evaluates a probe document one time in a new shot. */
 function shoot(env, instance, sample, scenario, more = {}) {
 	const context = more.context ?? rootContext(env.machine, makeContext(env.names, scenario.caps));
-	const shot = new Shot(env.machine, env.runner, scenario, context, sample.split.parts.map((slot) => slot.key), env.perform, more.replay);
+	const shot = new Shot(env.machine, env.runner, scenario, context, sample.split.parts.map((slot) => slot.key), sample.driven, env.perform, more.replay);
 	instance(shot);
 	return shot;
 }
@@ -17189,18 +17564,89 @@ const READ = /* @__PURE__ */ new Set([
 	"enum",
 	"const",
 	"anyOf",
-	"oneOf"
+	"oneOf",
+	"allOf",
+	"$ref"
 ]);
 /**
-* The keywords that can permit more values than the other keywords permit. Older drafts ignore each keyword beside
-* `$ref`, and `nullable` of OpenAPI 3.0 permits `null`. Thus a schema with one of them reads as `unknown`.
+* The keywords that can permit more values than the other keywords permit. A dynamic reference can reach a schema
+* outside this schema, and `nullable` of OpenAPI 3.0 permits `null`. Thus a schema with one of them reads as `unknown`.
 */
 const WIDENING = /* @__PURE__ */ new Set([
-	"$ref",
 	"$dynamicRef",
 	"$recursiveRef",
 	"nullable"
 ]);
+/** The keywords of an object without the keyword `type`. They test only the values that are records. */
+const OBJECT_KEYS = [
+	"properties",
+	"required",
+	"additionalProperties"
+];
+/** The form of a local reference: a definition in `$defs` or `definitions` of the root schema. */
+const LOCAL_REF = /^#\/(\$defs|definitions)\/([^/]*)$/;
+/** The most pairs of members that the meet of two unions builds. A larger meet keeps the first type, which is sound. */
+const MAX_MEET_PAIRS = 64;
+/** This function tells if a field of a record type can be absent. */
+function isOptional(type, key) {
+	return type.optional?.includes(key) === true;
+}
+/**
+* This function gives the meet of two types of a reading: a type that holds each value of both types. A schema is
+* the conjunction of its keywords, thus its type is the meet of their types. The meet is exact for the forms that a
+* reading makes: base types, lists, records, unions and `one`. A meet of two different forms is `never`.
+*/
+function meet(a, b, depth) {
+	if (depth > MAX_SCHEMA_DEPTH) return a;
+	if (isUnknown(a, void 0)) return b;
+	if (isUnknown(b, void 0)) return a;
+	if (a === "never" || b === "never") return "never";
+	if (typeof a !== "string" && "one" in a) return { one: a.one.filter((value) => member(value, b)) };
+	if (typeof b !== "string" && "one" in b) return { one: b.one.filter((value) => member(value, a)) };
+	if (typeof b !== "string" && "union" in b && !(typeof a !== "string" && "union" in a)) return meet(b, a, depth);
+	if (typeof a !== "string" && "union" in a) {
+		const others = typeof b !== "string" && "union" in b ? b.union : [b];
+		if (a.union.length * others.length > MAX_MEET_PAIRS) return a;
+		return unionOf(a.union.flatMap((item) => others.map((other) => meet(item, other, depth + 1))));
+	}
+	if (typeof a === "string" || typeof b === "string") return a === b ? a : "never";
+	if ("list" in a && "list" in b) return { list: meet(a.list, b.list, depth + 1) };
+	if ("record" in a && "record" in b) return meetRecords(a, b, depth + 1);
+	return ("list" in a || "record" in a) && ("list" in b || "record" in b) ? "never" : a;
+}
+/**
+* This function gives the meet of two record types. A field of both records gets the meet of its types, and it is
+* optional only when both records permit its absence. A closed record has no other field, thus a field of only the
+* other record is absent. When the other record needs that field, no value fits both records.
+*/
+function meetRecords(a, b, depth) {
+	const fields = {};
+	const optional = [];
+	const keys = [...Object.keys(a.record), ...Object.keys(b.record).filter((key) => !Object.hasOwn(a.record, key))];
+	for (const key of keys) {
+		const inA = Object.hasOwn(a.record, key);
+		const inB = Object.hasOwn(b.record, key);
+		if (!inA && a.closed === true || !inB && b.closed === true) {
+			if (inA && !isOptional(a, key) || inB && !isOptional(b, key)) return "never";
+			continue;
+		}
+		setOwn(fields, key, inA && inB ? meet(a.record[key], b.record[key], depth) : inA ? a.record[key] : b.record[key]);
+		if ((!inA || isOptional(a, key)) && (!inB || isOptional(b, key))) optional.push(key);
+	}
+	const closed = a.closed === true || b.closed === true;
+	return {
+		record: fields,
+		...optional.length === 0 ? {} : { optional },
+		...closed ? { closed: true } : {}
+	};
+}
+/** This function applies a condition to a type: each member of the JSON type of the condition meets its type. */
+function narrow$1(type, condition) {
+	if (typeof type === "string") return type;
+	if ("union" in type) return unionOf(type.union.map((item) => narrow$1(item, condition)));
+	if ("one" in type) return { one: type.one.filter((value) => !(condition.on === "list" ? Array.isArray(value) : isRecord(value)) || member(value, condition.type)) };
+	return condition.on in type ? meet(type, condition.type, 0) : type;
+}
 /** The base type of each name of the keyword `type`. */
 const BASES = {
 	null: "null",
@@ -17223,26 +17669,57 @@ function setOwn(target, key, value) {
 function unionOf(types) {
 	return types.reduce((all, type) => join(all, type), "never");
 }
-/** The state of one reading of a schema: the issues that it found. */
+/** The state of one reading of a schema: the root, the issues and the definitions that it read. */
 var SchemaReader = class {
+	root;
 	issues = [];
+	/** The type of each definition that a reference reached. Each reading of a definition is sound, thus the first stays. */
+	defs = /* @__PURE__ */ new Map();
+	/** The definitions that the reading has not finished. A reference to one of them is a cycle. */
+	open = /* @__PURE__ */ new Set();
+	/** The number of schemas with an own `$id` around the current schema. A reference inside them has another base. */
+	inner = 0;
+	constructor(root) {
+		this.root = root;
+	}
 	issue(at, reason) {
 		this.issues.push({
 			at,
 			reason
 		});
 	}
-	/** This method reads one schema. */
+	/** This method reads one schema: the meet of the types of its keywords, then its conditions. */
 	read(schema, at, depth) {
+		const types = [];
+		const conditions = [];
+		this.parts(schema, at, depth, types, conditions);
+		let type = types.reduce((all, item) => meet(all, item, 0), "unknown");
+		for (const condition of conditions) {
+			if (isUnknown(type, void 0)) {
+				this.issue(condition.at, "The schema has no keyword type. Thus a value of each JSON type fits it, and the type reads it as unknown.");
+				break;
+			}
+			type = narrow$1(type, condition);
+		}
+		return type;
+	}
+	/**
+	* This method adds the type of each keyword of a schema to `types`, and its conditions to `conditions`. Each type
+	* holds each value that the schema accepts. The parts of `allOf` add their keywords too.
+	*/
+	parts(schema, at, depth, types, conditions) {
 		if (depth > MAX_SCHEMA_DEPTH) {
 			this.issue(at, `The schema is deeper than ${MAX_SCHEMA_DEPTH} levels. The type reads it as unknown.`);
-			return "unknown";
+			return;
+		}
+		if (schema === true) return;
+		if (schema === false) {
+			types.push("never");
+			return;
 		}
-		if (schema === true) return "unknown";
-		if (schema === false) return "never";
 		if (!isRecord(schema)) {
 			this.issue(at, "A schema is a record or a truth value. The type reads this value as unknown.");
-			return "unknown";
+			return;
 		}
 		let widens = false;
 		for (const key of Object.keys(schema)) {
@@ -17252,46 +17729,99 @@ var SchemaReader = class {
 				widens = true;
 			} else this.issue([...at, key], `The type does not read the keyword ${key}. It does not test what the keyword tests.`);
 		}
-		if (widens) return "unknown";
-		const sides = [];
-		if (Object.hasOwn(schema, "type")) sides.push({
-			key: "type",
-			type: this.byType(schema, at, depth)
-		});
-		else if ([
-			"properties",
-			"required",
-			"additionalProperties",
-			"items"
-		].some((key) => Object.hasOwn(schema, key)) && ![
-			"enum",
-			"const",
+		if (widens) return;
+		const nested = schema !== this.root && Object.hasOwn(schema, "$id");
+		if (nested) this.inner += 1;
+		try {
+			this.keywords(schema, at, depth, types, conditions);
+		} finally {
+			if (nested) this.inner -= 1;
+		}
+	}
+	/** This method reads the keywords of a schema that does not permit more values (WIDENING). */
+	keywords(schema, at, depth, types, conditions) {
+		if (Object.hasOwn(schema, "$ref")) {
+			for (const key of Object.keys(schema)) if (READ.has(key) && key !== "$ref") this.issue([...at, key], `The type reads only the target of $ref. It does not test the keyword ${key} beside it.`);
+			const type = this.target(schema["$ref"], [...at, "$ref"], depth);
+			if (type !== void 0) types.push(type);
+			return;
+		}
+		if (Object.hasOwn(schema, "type")) types.push(this.byType(schema, at, depth));
+		else {
+			if (OBJECT_KEYS.some((key) => Object.hasOwn(schema, key))) conditions.push({
+				on: "record",
+				type: this.object(schema, at, depth),
+				at
+			});
+			if (Object.hasOwn(schema, "items")) conditions.push({
+				on: "list",
+				type: this.array(schema, at, depth),
+				at
+			});
+		}
+		for (const key of [
 			"anyOf",
-			"oneOf"
-		].some((key) => Object.hasOwn(schema, key))) this.issue(at, "The schema has no keyword type. Thus a value of each JSON type fits it, and the type reads it as unknown.");
-		for (const key of ["anyOf", "oneOf"]) {
+			"oneOf",
+			"allOf"
+		]) {
 			if (!Object.hasOwn(schema, key)) continue;
 			const items = schema[key];
 			if (!Array.isArray(items)) {
 				this.issue([...at, key], `The value of ${key} is a list of schemas.`);
 				continue;
 			}
-			sides.push({
+			if (key === "allOf") for (const [index, item] of items.entries()) this.parts(item, [
+				...at,
 				key,
-				type: unionOf(items.map((item, index) => this.read(item, [
-					...at,
-					key,
-					index
-				], depth + 1)))
-			});
+				index
+			], depth + 1, types, conditions);
+			else types.push(unionOf(items.map((item, index) => this.read(item, [
+				...at,
+				key,
+				index
+			], depth + 1))));
 		}
 		const values = this.values(schema, at);
-		if (values !== void 0) return { one: values.filter((value) => sides.every((side) => member(value, side.type))) };
-		const known = sides.filter((side) => !isUnknown(side.type, void 0));
-		const kept = known[0];
-		if (kept === void 0) return "unknown";
-		for (const side of known.slice(1)) this.issue([...at, side.key], `The type reads the keyword ${kept.key}, and not the keyword ${side.key}.`);
-		return kept.type;
+		if (values !== void 0) types.push({ one: values });
+	}
+	/** This method reads the target of a reference: a definition of the root schema, or `undefined` for each value. */
+	target(ref, at, depth) {
+		const match = typeof ref === "string" ? LOCAL_REF.exec(ref) : null;
+		let name;
+		try {
+			name = match === null ? void 0 : decodeURIComponent(match[2] ?? "").replace(/~1/g, "/").replace(/~0/g, "~");
+		} catch {
+			name = void 0;
+		}
+		if (match === null || name === void 0) {
+			this.issue(at, "The type reads only a $ref to #/$defs/<name> or #/definitions/<name> of the same schema. Thus it reads the schema as unknown.");
+			return;
+		}
+		if (this.inner > 0) {
+			this.issue(at, "A $ref inside a schema with its own $id has another base. Thus the type reads the schema as unknown.");
+			return;
+		}
+		const group = match[1];
+		const defs = isRecord(this.root) ? this.root[group] : void 0;
+		if (!isRecord(defs) || !Object.hasOwn(defs, name)) {
+			this.issue(at, `The schema has no definition ${String(ref)}. Thus the type reads the reference as unknown.`);
+			return;
+		}
+		const key = `${group}/${name}`;
+		const known = this.defs.get(key);
+		if (known !== void 0) return known;
+		if (this.open.has(key)) {
+			this.issue(at, `The reference ${String(ref)} is in a cycle. The type reads this reference as unknown.`);
+			return;
+		}
+		this.open.add(key);
+		try {
+			const type = this.read(defs[name], [group, name], depth + 1);
+			this.defs.set(key, type);
+			return type;
+		} finally {
+			this.open.delete(key);
+		}
 	}
 	/** This method reads `enum` and `const`: the values that the schema permits, or `undefined` without them. */
 	values(schema, at) {
@@ -17379,17 +17909,20 @@ var SchemaReader = class {
 * - `properties`, `required` and `additionalProperties` give a record. `false` closes it, and a property that is not
 *   in `required` is optional.
 * - `items` gives a list. `enum` and `const` give `one`. `anyOf` and `oneOf` give a union.
+* - `$ref` reads a definition in `$defs` or `definitions` of the same schema (TYPE.SCHEMA-REF). Another reference, a
+*   missing definition and a reference in a cycle read as `unknown`.
+* - `allOf` and the other keywords of a schema give the meet of their types (TYPE.SCHEMA-ALLOF). Records merge their
+*   fields, and a closed part keeps the merge closed.
 *
 * The type holds each value that the schema accepts. Each keyword that the function does not read tests nothing, as
-* `unknown`, and the issues name it. Examples are `minimum`, `pattern` and `allOf`. A schema with `$ref` or `nullable`
-* reads as `unknown`, because these keywords can permit more values. A schema with more than one of `type`, `anyOf`
-* and `oneOf` gives the type of the first, and an issue for each other. The function does not throw.
+* `unknown`, and the issues name it. Examples are `minimum` and `pattern`. A schema with `nullable` or `$dynamicRef`
+* reads as `unknown`, because these keywords can permit more values. The function does not throw.
 *
 * @param schema - The schema, as JSON.
 * @returns The type, and the problems of the reading with their keys in the schema.
 */
 function typeFromSchema(schema) {
-	const reader = new SchemaReader();
+	const reader = new SchemaReader(schema);
 	try {
 		return {
 			type: reader.read(schema, [], 0),
@@ -17469,6 +18002,6 @@ function samplesAt(values, closed, depth) {
 function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
-export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, ask, attributeGraph, attributeTrace, attributeVertexId, capKeys, check, checkLatent, checkStep, checkSteps, checkWorld, circularOf, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, ask, attributeGraph, attributeTrace, attributeVertexId, capKeys, check, checkLatent, checkStep, checkSteps, checkWorld, circularOf, classify, collectOf, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
 
 //# sourceMappingURL=index.js.map