@mark1russell7/coeval 0.8.0 → 0.10.0

package/build/index.js

@@ -368,6 +368,21 @@ function equationType(kind) {
 	return parts?.of ?? parts?.rest?.of;
 }
 /**
+* This function gives the effects that the contract of a kind declares for a verb (VERB.EFFECTS, D49). For `eval`,
+* the field `effects` declares them, and a kind without the field declares no effect. For another verb, the entry of
+* `verbEffects` declares them. `check` and `conforms` read the declarations with this one function.
+*
+* @param kind - The kind.
+* @param verb - The verb.
+* @returns The declaration in the form of `effects`, or `undefined` when the contract does not declare the effects of
+*   the verb.
+*/
+function effectsOfVerb(kind, verb) {
+	if (verb === "eval") return kind.effects ?? [];
+	const table = kind.verbEffects;
+	return table !== void 0 && Object.hasOwn(table, verb) ? table[verb] : void 0;
+}
+/**
 * This function tells if an entry of the world is a kind.
 *
 * @param entry - The entry.
@@ -546,6 +561,10 @@ const STD_DOMAINS = {
 		is: (value) => value === null,
 		summary: "The value null."
 	},
+	undefined: {
+		is: (value) => value === void 0,
+		summary: "The value undefined. A document holds it as the extension ext.undefined."
+	},
 	bool: {
 		is: (value) => typeof value === "boolean",
 		summary: "A truth value: true or false."
@@ -2071,7 +2090,7 @@ function context(parts = {}) {
 	};
 }
 const MAX_COLLAPSE = 64;
-const NO_HOPS = /* @__PURE__ */ Object.freeze([]);
+const NO_HOPS$1 = /* @__PURE__ */ Object.freeze([]);
 /** A value that can be a reference document: a record with the type `ref`. The full check comes after. */
 function mayBeRef(thing) {
 	return typeof thing === "object" && thing !== null && thing.type === "ref";
@@ -2122,13 +2141,13 @@ function walkQuick(start, path, plain, keyed) {
 				ok: false,
 				code: "#N/A",
 				reason: `The path ${keys.join(".")} reaches nothing.`,
-				hops: NO_HOPS
+				hops: NO_HOPS$1
 			};
 			if (!plain && mayBeRef(reached.thing)) return void 0;
 			return {
 				ok: true,
 				thing: reached.thing,
-				hops: NO_HOPS
+				hops: NO_HOPS$1
 			};
 		}
 		const step = path[index];
@@ -2145,7 +2164,7 @@ function walkQuick(start, path, plain, keyed) {
 	return {
 		ok: true,
 		thing: here,
-		hops: NO_HOPS
+		hops: NO_HOPS$1
 	};
 }
 /** The root whose value starts the short path of a compiled path. `FULL` takes the full algorithm at once. */
@@ -2256,7 +2275,7 @@ function resolve(nav, ctx, path, options = {}) {
 * @returns What the path reached and each hop, or an error.
 */
 function resolveFully$1(nav, ctx, path, hops, known) {
-	const done = hops ?? NO_HOPS;
+	const done = hops ?? NO_HOPS$1;
 	const failed = (code, reason) => ({
 		ok: false,
 		code,
@@ -3054,6 +3073,7 @@ var Session = class {
 		if (reading === void 0) return this.find(ctx, path, compiled, hops);
 		const free = isFree(reading.root, ctx, path);
 		if (!free && path[0] === "self" && !reading.self) this.keep(reading, ["self"]);
+		else if (free && path.length === 1 && path[0] === "self") reading.self = true;
 		let found;
 		try {
 			found = this.find(ctx, path, compiled, hops);
@@ -4290,6 +4310,7 @@ const STD_WORLD = {
 			caps: [{ rule: "mask" }],
 			pure: true,
 			lazy: [{}],
+			reads: ["self"],
 			summary: "A node of a tree. Each part is an attribute that evaluates on demand, one time, with the node as self."
 		},
 		box: {
@@ -4309,6 +4330,7 @@ const STD_WORLD = {
 			caps: [{ rule: "mask" }],
 			pure: true,
 			lazy: [{}],
+			reads: ["self"],
 			summary: "A node of a tree, as panel. A formula in a box can read its parent and its siblings."
 		},
 		math: { kinds: {
@@ -4553,11 +4575,12 @@ function plainOf(value, path) {
 * 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
 * fold or a default, come last. A failed attribute throws `Failure` with its own error, thus a reference to it gives that error.
+* The argument `outer` is the self of the context, that `treeNode` resolved. The node reads no root of the context directly (C4).
 */
-function treeThing(input, build) {
+function treeThing(input, build, outer) {
 	const { parts, context, kind: type, place, machine } = input;
 	const { tree, of } = contractOf$1(machine, input.typePath);
-	const above = stateOf(context.self);
+	const above = stateOf(outer);
 	const up = above !== void 0 && above.build === build ? above : void 0;
 	const cells = /* @__PURE__ */ new Map();
 	/** The positions of the items of the list `children`, for the names of the children. */
@@ -4721,7 +4744,7 @@ function treeThing(input, build) {
 		type,
 		label: `node ${type}`,
 		deref(key) {
-			if (key === "parent") return context.self;
+			if (key === "parent") return outer;
 			if (key === "type") return type;
 			const result = read(String(key));
 			if (result === void 0) return void 0;
@@ -4752,15 +4775,22 @@ function treeThing(input, build) {
 function attributeTrace(node, attribute) {
 	return stateOf(node)?.trace(attribute);
 }
+/** The path of the root `self`. A node of the tree resolves it, thus the list of reads holds the read (C4). */
+const SELF_PATH = /* @__PURE__ */ Object.freeze(["self"]);
+/** The options of the resolution of `self`: the node needs no hops. */
+const NO_HOPS = /* @__PURE__ */ Object.freeze({ hops: false });
 /**
 * This function evaluates a node of the decorated tree. Inside an attribute of an open tree, the node gives its host
-* thing, and no attribute evaluates. Else the node is the root of a new tree, and it gives the JSON of the tree.
+* thing, and no attribute evaluates. Else the node is the root of a new tree, and it gives the JSON of the tree. The
+* node reads `self` through `resolve` (C4, D44). A machine that closes the root `self` thus gives no nested trees.
 */
 function treeNode(input) {
-	const above = stateOf(input.context.self);
-	if (above !== void 0 && above.build.open) return ok(treeThing(input, above.build));
+	const found = input.resolve(SELF_PATH, NO_HOPS);
+	const outer = found.ok ? found.thing : void 0;
+	const above = stateOf(outer);
+	if (above !== void 0 && above.build.open) return ok(treeThing(input, above.build, outer));
 	const build = { open: true };
-	const root = treeThing(input, build);
+	const root = treeThing(input, build, outer);
 	try {
 		return stateOf(root).json(/* @__PURE__ */ new Set());
 	} finally {
@@ -5749,16 +5779,27 @@ const EACH$2 = /* @__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, as keys (FACTS.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 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).
 *
 * @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.
 */
-function declaredEffects(v) {
-	const effects = v.kind?.effects;
-	if (effects === void 0 || effects.length === 0) return NO_EFFECTS;
+function declaredEffects(v, verb = "eval") {
+	return verbDeclared(v, verb) ?? NO_EFFECTS;
+}
+/**
+* This function gives the effects that the contract of the kind of a visit declares for a verb, as keys. The result
+* is `undefined` when the contract has no declaration for the verb (D49). A visit without a kind declares no effect
+* for `eval` and no declaration for another verb.
+*/
+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("."));
 }
 /**
@@ -5809,7 +5850,9 @@ function capReason(v, kind, allowed) {
 *   A run does not always fail there, thus a type issue is a static finding, not an error of a run.
 *
 * The check asks the ladder for the verb of the options, `eval` by default (VERB.CHECK). The shapes, the paths and the
-* names follow the contracts, thus they are the same for each verb. Only `eval` checks the declared effects.
+* names follow the contracts, thus they are the same for each verb. The check tests the effects that each contract
+* declares for the verb: `effects` for `eval`, and the entry of `verbEffects` for another verb (VERB.EFFECTS). A kind
+* without a declaration for the verb gives no `#CAP!` and no `#CALC!` for an effect.
 *
 * @param machine - The world and the code of the evaluators.
 * @param doc - The document, as JSON.
@@ -5847,6 +5890,66 @@ function typeCheck(machine, doc, options = {}) {
 		places: pass.places
 	};
 }
+/** This function tells if a table of verbs has an entry for a verb. */
+function hasVerb(table, verb) {
+	return table !== void 0 && Object.hasOwn(table, verb);
+}
+/**
+* This function checks the world of a machine before a document exists. It finds each kind that has no entry for a
+* verb of the list, when the world has no default for that verb (STATIC.COVERAGE). A document of such a kind gets no
+* evaluator for the verb, thus the check gives the same proof of coverage as a type system.
+*
+* The check visits each kind of each namespace, at each depth, and the fallback kind of each namespace and of the
+* world. It does not follow an alias, because the kind of an alias has its own place. The check reads only the world.
+*
+* @param machine - The machine, for its world.
+* @param verbs - The verbs that each kind of the language must answer, for example `eval`, `view` and `type`.
+* @returns One issue for each kind and verb without an evaluator. The order is the order of the world, then the
+*   order of the verbs. The fallback kind of a namespace comes after the entries of that namespace.
+*/
+function checkWorld(machine, verbs) {
+	const world = machine.world;
+	const open = verbs.filter((verb) => !hasVerb(world.defaults, verb));
+	const out = [];
+	if (open.length === 0) return out;
+	const visit = (kind, path, fallback) => {
+		const text = path.join(".");
+		const name = fallback ? path.length === 0 ? "the fallback kind of the world" : `the fallback kind of ${text}` : `the kind ${text}`;
+		for (const verb of open) {
+			if (hasVerb(kind.verbs, verb)) continue;
+			const reason = `${name.charAt(0).toUpperCase()}${name.slice(1)} has no entry for the verb ${verb}, and the world has no default for it.`;
+			out.push(fallback ? {
+				code: "#NOEVAL",
+				kind: path,
+				fallback: true,
+				verb,
+				reason
+			} : {
+				code: "#NOEVAL",
+				kind: path,
+				verb,
+				reason
+			});
+		}
+	};
+	const way = /* @__PURE__ */ new Set();
+	const entries = (kinds, path) => {
+		for (const key of Object.keys(kinds)) {
+			const entry = kinds[key];
+			const here = [...path, key];
+			if (isKind(entry)) visit(entry, here, false);
+			else if (isNamespace(entry) && !way.has(entry)) {
+				way.add(entry);
+				entries(entry.kinds, here);
+				if (entry.fallback !== void 0) visit(entry.fallback, here, true);
+				way.delete(entry);
+			}
+		}
+	};
+	entries(world.kinds, []);
+	if (world.fallback !== void 0) visit(world.fallback, [], true);
+	return out;
+}
 /** The names that an equation of `down` sees (TREE.DOWN). */
 const DOWN_NAMES = /* @__PURE__ */ Object.freeze([
 	"child",
@@ -5930,7 +6033,6 @@ function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()
 		issues.push(issue);
 		if (current !== void 0) current.marked = true;
 	};
-	const effects = verb === "eval";
 	const allowed = options.caps === void 0 ? void 0 : permitsOf(machine);
 	const waits = options.run === true ? /* @__PURE__ */ new Map() : void 0;
 	const drives = [];
@@ -6001,7 +6103,8 @@ function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()
 			});
 		}
 		const caps = v.caps;
-		const declared = effects ? declaredEffects(v) : NO_EFFECTS;
+		const stated = 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({
 				code: "#CAP!",
@@ -6023,14 +6126,14 @@ function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()
 					},
 					index: issues.length,
 					node: current,
-					wait: !effects
+					wait: false
 				};
 				drives.push(chain);
 			} else if (runner) chain = up ?? true;
 			waits.set(v, chain);
 			if (typeof chain === "object" && !chain.wait) {
 				const rule = allowed ?? permits;
-				chain.wait = declared.some((kind) => caps === void 0 || rule(caps, kind));
+				chain.wait = stated === void 0 || declared.some((kind) => caps === void 0 || rule(caps, kind));
 			}
 			const first = declared[0];
 			if (!runner && first !== void 0) push({
@@ -6178,7 +6281,8 @@ function partLazy(above, parent, slot) {
 * by the contracts of its kinds:
 *
 * - `reads`: each free reference, with the root and the keys of its path. A read under a lazy part has the mark
-*   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`.
+*   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`. A kind that
+*   declares `reads` adds a read of each of its roots at each document of the kind.
 * - `side` and `effects`: from the contract of each kind.
 * - `pure`: each kind declares `pure`, and the document has no effect and is not volatile.
 * - `volatile`: a kind, an operation or a step document declares `volatile`, or the host marks a read.
@@ -6231,18 +6335,35 @@ function factsOf(machine, doc, options = {}) {
 		}
 		const code = codeOf(world, v.declared ? void 0 : v.doc.own, kind, verb, "eval");
 		const answer = code.name === void 0 ? void 0 : hook?.(v.typePath ?? [], code.name);
+		let roots;
 		if (code.described) {
 			note(answer?.pure ?? kind.pure, answer?.volatile ?? kind.volatile);
 			above.set(v, {
 				lazy,
 				rules: answer?.lazy ?? kind.lazy
 			});
+			roots = answer?.reads ?? kind.reads;
 		} else {
 			note(answer?.pure, answer?.volatile);
 			above.set(v, {
 				lazy,
 				rules: answer?.lazy ?? EACH$1
 			});
+			roots = answer?.reads;
+		}
+		for (const root of roots ?? NONE) {
+			const read = {
+				root,
+				keys: NONE,
+				exact: true,
+				lazy,
+				address: false,
+				path: [root],
+				place: tight(v.place),
+				at: tight(v.at)
+			};
+			reads.push(read);
+			if (options.volatile?.(read) === true) volatile = true;
 		}
 		if (kind.side === "run") side = "run";
 		for (const keys of declaredEffects(v)) {
@@ -6764,9 +6885,13 @@ function formulaKinds() {
 		}
 	};
 }
-/** This function gives the type of a value of a profile: the value itself as `one`. `undefined` and a function give `unknown`. */
+/**
+* This function gives the type of a value of a profile: the value itself as `one`. `undefined` gives the base type
+* `undefined`, because JSON and thus `one` cannot hold it (D48). A function gives `unknown`.
+*/
 function valueType(value) {
-	return value === void 0 || typeof value === "function" ? "unknown" : { one: [value] };
+	if (value === void 0) return "undefined";
+	return typeof value === "function" ? "unknown" : { one: [value] };
 }
 /** This function tells if a value has the form of a signature: a record with `params` as a list, and `to`. */
 function isSignature(value) {
@@ -6786,14 +6911,14 @@ function listText(names) {
 	return names.length < 2 ? names.join("") : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
 }
 /**
-* This function tells if a signature takes a count of arguments. A parameter of the type `unknown` at the end is
-* optional, because a missing argument is `undefined`.
+* This function tells if a signature takes a count of arguments. A parameter at the end is optional when its type
+* holds `undefined`, because a missing argument is `undefined`. `unknown` and the base type `undefined` hold it.
 *
 * @returns `undefined` when the number is correct, or else the text of the numbers that the signature takes.
 */
 function arityOf(sig, count, domains) {
 	let least = sig.params.length;
-	while (least > 0 && isUnknown(sig.params[least - 1], domains)) least -= 1;
+	while (least > 0 && member(void 0, sig.params[least - 1], domains)) least -= 1;
 	const most = sig.rest === void 0 ? sig.params.length : Number.POSITIVE_INFINITY;
 	if (count >= least && count <= most) return void 0;
 	if (most === Number.POSITIVE_INFINITY) return `at least ${argumentsText(least)}`;
@@ -7051,6 +7176,7 @@ function formulaTypes(profile) {
 		"formula.ext": { synth: (input) => {
 			const name = nameOf(input);
 			if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) return "unknown";
+			if (name === "undefined") return "undefined";
 			if (name === "number") return "number";
 			return name === "domain" ? domainTypeOf(input.doc.value, input.machine.domains) : "unknown";
 		} }
@@ -7060,22 +7186,111 @@ function formulaTypes(profile) {
 * This function makes the evaluators of the formula kit for one language. Each evaluator compiles its document
 * one time into code. Each evaluator also holds its type rule, for a check of types (TYPE.SYNTH).
 *
+* Equal profiles give the same evaluator objects (COMPOSE.UNIFY, D46). Thus two machines of one profile merge without
+* a conflict. Each call gives a new record. Each evaluator object is frozen, because many machines can share it.
+*
 * @param profile - The operations and the rules of the language.
 * @returns The evaluators, by their name.
 */
 function formulaEvaluators(profile = {}) {
+	return { ...kitOf(profile).evaluators };
+}
+/** This function makes new evaluators of the formula kit for the fields of one profile. */
+function makeEvaluators(profile) {
 	const evaluators = formulaCode(profile);
 	const types = formulaTypes(profile);
 	const out = {};
 	for (const name of Object.keys(evaluators)) {
 		const evaluator = evaluators[name];
 		const type = Object.hasOwn(types, name) ? types[name] : void 0;
-		out[name] = type === void 0 ? evaluator : {
+		out[name] = Object.freeze(type === void 0 ? evaluator : {
 			compile: evaluator.compile,
 			type
+		});
+	}
+	return Object.freeze(out);
+}
+/** The keys of a profile that the kit reads. The kit ignores each other key. */
+const PROFILE_KEYS = /* @__PURE__ */ Object.freeze([
+	"ops",
+	"lazy",
+	"ext",
+	"truthy",
+	"otherwise",
+	"logic",
+	"omit",
+	"missing",
+	"check",
+	"combine",
+	"pure",
+	"pureExt",
+	"volatile",
+	"sigs"
+]);
+/** The number of recent kits that a profile in a new object can find by its fields. */
+const RECENT_KITS = 16;
+/** The kit of each profile object. A kit goes when its profile object goes. */
+const kitsByProfile = /* @__PURE__ */ new WeakMap();
+/** The recent kits, the most recent first. The list holds `RECENT_KITS` kits or fewer. */
+const recentKits = [];
+/**
+* This function gives the canonical form of a profile: a frozen record of the fields that the kit reads. A field
+* with the value `undefined` is absent, but `otherwise` is present when the profile has it as an own key. A list
+* is a frozen copy. Each other value stays the same object.
+*/
+function fieldsOf(profile) {
+	const out = {};
+	for (const key of PROFILE_KEYS) {
+		if (key === "otherwise" ? !Object.hasOwn(profile, key) : profile[key] === void 0) continue;
+		const value = profile[key];
+		out[key] = Array.isArray(value) ? Object.freeze([...value]) : value;
+	}
+	return Object.freeze(out);
+}
+/**
+* This function tells if two canonical forms are equal. They must have the same keys. A function, a record and a host
+* value are equal only to themselves. Two lists are equal when their items are the same, in order.
+*/
+function sameFields(a, b) {
+	const left = a;
+	const right = b;
+	const keys = Object.keys(left);
+	if (keys.length !== Object.keys(right).length) return false;
+	return keys.every((key) => {
+		if (!Object.hasOwn(right, key)) return false;
+		const x = left[key];
+		const y = right[key];
+		if (Object.is(x, y)) return true;
+		return Array.isArray(x) && Array.isArray(y) && x.length === y.length && x.every((item, index) => Object.is(item, y[index]));
+	});
+}
+/**
+* This function gives the kit of a profile (D46). A profile object that the kit knows, with the same fields, gives its
+* kit. Then a recent kit with equal fields serves a new profile object. Else the function makes a new kit from the
+* canonical form. Thus a later change of a field of the profile object gives a new kit, and an old kit does not change.
+*/
+function kitOf(profile) {
+	const fields = fieldsOf(profile);
+	const known = kitsByProfile.get(profile);
+	if (known !== void 0 && sameFields(known.fields, fields)) return known;
+	const index = recentKits.findIndex((kit) => sameFields(kit.fields, fields));
+	let kit;
+	if (index >= 0) {
+		kit = recentKits[index];
+		recentKits.splice(index, 1);
+	} else {
+		const hook = makeKnown(fields);
+		kit = {
+			fields,
+			evaluators: makeEvaluators(fields),
+			known: hook,
+			facts: makeFacts(fields, hook)
 		};
 	}
-	return out;
+	recentKits.unshift(kit);
+	if (recentKits.length > RECENT_KITS) recentKits.length = RECENT_KITS;
+	kitsByProfile.set(profile, kit);
+	return kit;
 }
 /** This function makes the code of the evaluators of the formula kit, without their type rules. */
 function formulaCode(profile) {
@@ -7394,10 +7609,16 @@ function formulaCode(profile) {
 * `formula.ext` knows an extension of `ext` and each standard extension. The hook knows each name of the other
 * evaluators.
 *
+* Equal profiles give the same hook (D46).
+*
 * @param profile - The operations and the extensions of the language.
 * @returns The hook: `true`, or the reason of the `#NAME?` that the evaluator gives in a run.
 */
 function formulaKnown(profile = {}) {
+	return kitOf(profile).known;
+}
+/** This function makes a new hook `known` for the fields of one profile. */
+function makeKnown(profile) {
 	const hasOp = (name) => {
 		if (profile.lazy !== void 0 && Object.hasOwn(profile.lazy, name)) return true;
 		const ops = profile.ops;
@@ -7417,9 +7638,12 @@ function formulaKnown(profile = {}) {
 		return hasExt(name) ? true : `The language has no extension ${name}.`;
 	};
 }
-/** The facts of an extension of the profile. It gets the context, thus it can read outside `resolve`. */
+/**
+* The facts of an extension of the profile that `pureExt` does not name. It gets the context, thus it can read outside
+* `resolve`.
+*/
 const NOT_PURE = /* @__PURE__ */ Object.freeze({ pure: false });
-/** The facts of a standard extension. */
+/** The facts of a standard extension, and of an extension that `pureExt` names. */
 const PURE = /* @__PURE__ */ Object.freeze({ pure: true });
 /** The lazy rule of a lazy operation: it covers each argument. */
 const EACH_PART = /* @__PURE__ */ Object.freeze([/* @__PURE__ */ Object.freeze({})]);
@@ -7429,19 +7653,29 @@ const EACH_PART = /* @__PURE__ */ Object.freeze([/* @__PURE__ */ Object.freeze({
 *
 * - An operation of `lazy` has a lazy rule for each argument.
 * - An operation is pure when the profile names it in `pure`, or when `pure` is `true`. A volatile operation is not pure.
-* - A standard extension is pure. An extension of the profile gets the context, thus it is not pure.
+* - A standard extension is pure. An extension of the profile is pure only when the profile names it in `pureExt` (D47).
+*   Such an extension keeps C4: it reads the context only through `resolve`.
+*
+* Equal profiles give the same hook (D46).
 *
 * @param profile - The operations, the extensions and their facts.
 * @returns The hook: the facts of a name, or `undefined` for the facts of the contract.
 */
 function formulaFacts(profile = {}) {
+	return kitOf(profile).facts;
+}
+/** This function makes a new hook `facts` for the fields of one profile, with the hook `known` of the same fields. */
+function makeFacts(profile, known) {
 	const volatile = new Set(profile.volatile ?? []);
 	const pure = profile.pure === true ? void 0 : new Set(profile.pure ?? []);
-	const known = formulaKnown(profile);
+	const pureExt = new Set(profile.pureExt ?? []);
 	return (path, code) => {
 		if (code !== "formula.op" && code !== "formula.ext") return void 0;
 		const name = path.slice(1).join(".");
-		if (code === "formula.ext") return profile.ext !== void 0 && Object.hasOwn(profile.ext, name) ? NOT_PURE : Object.hasOwn(STD_EXT, name) ? PURE : void 0;
+		if (code === "formula.ext") {
+			if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) return pureExt.has(name) ? PURE : NOT_PURE;
+			return Object.hasOwn(STD_EXT, name) ? PURE : void 0;
+		}
 		if (known(path, code) !== true) return void 0;
 		const isVolatile = volatile.has(name);
 		const lazy = profile.lazy !== void 0 && Object.hasOwn(profile.lazy, name);
@@ -7465,18 +7699,23 @@ function formulaFacts(profile = {}) {
 * The kit gives the domains of the kernel (`STD_DOMAINS`). Thus a domain of the language with the name `number` is a
 * conflict. The language names `["domains", "number"]` in `replaces` to replace it.
 *
+* Equal profiles give the same evaluators and the same hooks (COMPOSE.UNIFY, D46). Thus two machines of one profile
+* merge, also when each adds its own language. Two profiles with different fields give different evaluators, and
+* their machines conflict at each evaluator name of the kit.
+*
 * @param profile - The operations and the rules of the language.
 * @param more - The parts of a machine that the language adds, with the paths of the entries that it replaces.
 * @returns The machine.
 * @throws {MergeError} The language and the kit have a conflict.
 */
 function formulaMachine(profile = {}, more = {}) {
+	const kit = kitOf(profile);
 	return mergeMachines({
 		world: { kinds: formulaKinds() },
-		evaluators: formulaEvaluators(profile),
+		evaluators: { ...kit.evaluators },
 		domains: STD_DOMAINS,
-		known: formulaKnown(profile),
-		facts: formulaFacts(profile)
+		known: kit.known,
+		facts: kit.facts
 	}, more);
 }
 //#endregion
@@ -8822,10 +9061,13 @@ function plainValue(value, open) {
 }
 /**
 * TREE.LAZY, TREE.PARENT, TREE.SIBLING and TREE.ERROR: a node of an open tree gives its thing, and the root of a new
-* tree gives its JSON. A step on the thing reads an attribute, and a failed attribute throws its own error.
+* 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 }) => {
-	const outer = refNodeOf(context.self);
+const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolve: walk }) => {
+	const reached = walk(["self"]);
+	const parent = reached.ok ? reached.thing : void 0;
+	const outer = refNodeOf(parent);
 	const nested = outer !== void 0 && outer.tree.open;
 	const found = machine === void 0 || typePath.length === 0 ? void 0 : lookupKind(machine.world, typePath);
 	const contract = found?.ok === true ? found.kind.tree : void 0;
@@ -8849,7 +9091,7 @@ const treeDefinition = ({ parts, context, kind, place, machine, typePath }) => {
 		type: kind,
 		label: `node ${kind}`,
 		deref: (key) => {
-			if (key === "parent") return context.self;
+			if (key === "parent") return parent;
 			if (key === "type") return kind;
 			const result = attributeOf(node, String(key));
 			if (result === void 0 || result.ok) return result?.ok === true ? result.value : void 0;
@@ -10056,13 +10298,15 @@ 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 effects = kind.effects;
+	const own = 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,
 		describes: env.verb === "eval",
+		declares: own !== void 0,
 		caps: caps ?? [...declared, "probe"]
 	};
 }
@@ -10458,8 +10702,10 @@ function checkShot(env, sample, contract, scenario, shot) {
 	const keyOf = (part) => shot.keys[part] ?? String(part);
 	for (const call of shot.calls) if (!call.context.caps.every((cap) => permits(docCaps, cap))) report(env, "C1", `The code gives the part ${keyOf(call.part)} ${capsText(call.context.caps)}, and its document has ${capsText(docCaps)}.`, probe);
 	for (const effect of shot.caused) if (!effect.context.caps.every((cap) => permits(docCaps, cap))) report(env, "C1", `The code gives its effect ${effect.kind} ${capsText(effect.context.caps)}, and its document has ${capsText(docCaps)}.`, probe);
+	if (contract.declares) {
+		for (const effect of shot.caused) if (!permits(contract.declared, effect.kind)) report(env, "C2", `The code causes the effect ${effect.kind}, and the contract of ${sample.type} declares ${contract.declared.length === 0 ? "no effects" : capsText(contract.declared)}${env.verb === "eval" ? "" : ` for the verb ${env.verb}`}.`, probe);
+	}
 	if (contract.describes) {
-		for (const effect of shot.caused) if (!permits(contract.declared, effect.kind)) report(env, "C2", `The code causes the effect ${effect.kind}, and the contract of ${sample.type} declares ${contract.declared.length === 0 ? "no effects" : capsText(contract.declared)}.`, probe);
 		const first = shot.caused[0];
 		if (contract.pure && first !== void 0) report(env, "C4", `The kind ${sample.type} is pure, and the code causes the effect ${first.kind}.`, probe);
 		if (shot.result.ok) sample.split.parts.forEach((_slot, index) => {
@@ -11836,6 +12082,7 @@ function samplesAt(values, closed, depth) {
 	const records = [];
 	let lists = false;
 	for (const value of values) if (value === null) bases.add("null");
+	else if (value === void 0) bases.add("undefined");
 	else if (typeof value === "boolean") bases.add("bool");
 	else if (typeof value === "number") bases.add("number");
 	else if (typeof value === "string") bases.add("text");
@@ -11846,6 +12093,7 @@ function samplesAt(values, closed, depth) {
 	else return "unknown";
 	for (const base of [
 		"null",
+		"undefined",
 		"bool",
 		"number",
 		"text"
@@ -11873,7 +12121,7 @@ function samplesAt(values, closed, depth) {
 * This function infers a value type from sample values (TYPE.SAMPLES), as a type provider of F# does. A host uses it
 * for the type of a root, for example from some events.
 *
-* - `null`, a truth value, a number and a text give their base types, not their values.
+* - `null`, `undefined`, a truth value, a number and a text give their base types, not their values.
 * - The items of each list join into one type of items.
 * - All records join into one record with each key of the samples. A key that a record does not have is optional.
 * - Values of different forms give a union, as `join` gives. No samples give `never`.
@@ -11890,6 +12138,6 @@ function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
 //#endregion
-export { ATTRIBUTE_RUNGS, CAPS_TYPE, 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, agree, ask, attributeTrace, capKeys, check, checkLatent, checkSteps, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, 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, 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, placed, planner, prepare, print, random, recorder, ref, reference, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stored, syntaxFormat, tag, thrown, toJson, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+export { ATTRIBUTE_RUNGS, CAPS_TYPE, 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, agree, ask, attributeTrace, capKeys, check, checkLatent, checkSteps, checkWorld, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, 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, 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, placed, planner, prepare, print, random, recorder, ref, reference, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stored, syntaxFormat, tag, thrown, toJson, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
 
 //# sourceMappingURL=index.js.map