@mark1russell7/coeval 0.24.1 → 0.25.0

package/build/index.js

@@ -1353,6 +1353,61 @@ function narrowAt(type, path, at, narrowed, domains) {
 		...form.closed ? { closed: true } : {}
 	};
 }
+/** This function gives the type of a value that is a member of both types. The result is the narrower known type. */
+function meetOf(type, proved, domains) {
+	if (isUnknown(proved, domains)) return type;
+	const form = formOf(type, domains);
+	if (form.t === "one") return { one: form.values.filter((value) => member(value, proved, domains)) };
+	return !isUnknown(type, domains) && isPrecise(type, domains) && fits(type, proved, domains) ? type : proved;
+}
+/** This function gives the type of a value of the first type that is not a member of the second type. */
+function withoutOf(type, removed, domains) {
+	if (isUnknown(removed, domains)) return type;
+	const form = formOf(type, domains);
+	if (form.t === "one") return { one: form.values.filter((value) => !member(value, removed, domains)) };
+	if (form.t === "union") {
+		const members = form.members.map((each) => withoutOf(each, removed, domains)).filter((each) => each !== "never");
+		return members.length === 0 ? "never" : members.length === 1 ? members[0] : { union: members };
+	}
+	return isPrecise(type, domains) && fits(type, removed, domains) ? "never" : type;
+}
+/**
+* This function gives a type with one proof at a path (STATIC.OCCURRENCE). A path that leaves the records of the type
+* gives the type back. A fact about a field also tells if the field exists. A value of a type without `undefined`
+* exists. An optional field without a remaining type does not.
+*
+* @param type - The type of the value at the first `at` keys of the path.
+* @param proof - The proof.
+* @param at - The number of keys of the path that the type already holds.
+* @param domains - The domains of the machine.
+* @returns The narrowed type.
+*/
+function narrowType(type, proof, at, domains) {
+	if (at === proof.path.length) {
+		if (proof.fact === "is") return meetOf(type, proof.type, domains);
+		return proof.fact === "not" ? withoutOf(type, proof.type, domains) : type;
+	}
+	const form = formOf(type, domains);
+	const key = proof.path[at];
+	if (form.t !== "record" || !Object.hasOwn(form.fields, key)) return type;
+	const before = form.fields[key];
+	const optional = new Set(form.optional);
+	let after = narrowType(before, proof, at + 1, domains);
+	if (at + 1 === proof.path.length && optional.has(key)) {
+		if (proof.fact === "present" || proof.fact === "is" && !member(void 0, proof.type, domains)) optional.delete(key);
+		else if (proof.fact === "absent" || after === "never") after = void 0;
+	}
+	const fields = {};
+	for (const name of Object.keys(form.fields)) if (name !== key) setOwn$6(fields, name, form.fields[name]);
+	if (after !== void 0) setOwn$6(fields, key, after);
+	else if (form.closed) optional.delete(key);
+	else setOwn$6(fields, key, "never");
+	return {
+		record: fields,
+		...optional.size === 0 ? {} : { optional: [...optional] },
+		...form.closed ? { closed: true } : {}
+	};
+}
 /**
 * This function is the split rule of `fits` (TYPE.FITS-FINITE, D84, TYPE.FITS-PATH, D89). A record type fits when each
 * record of its split fits. A split takes the first field in the order of `splitsOf`. Each member of the field gives a
@@ -1882,6 +1937,12 @@ var MergeError = class extends Error {
 	}
 };
 const NONE$2 = /* @__PURE__ */ new Set();
+/** The verbs that the kernel reads. Thus no language owns them (COMPOSE.PIRACY). */
+const KERNEL_VERBS = /* @__PURE__ */ new Set([
+	"eval",
+	"deref",
+	"step"
+]);
 function keyOf(path) {
 	return JSON.stringify(path.map(String));
 }
@@ -2072,16 +2133,123 @@ function mergeEntry(m, earlier, later, path, part, replaces) {
 	m.clash(path, part, a === b ? `Two parts give two different ${a === "an alias" ? "aliases" : "kinds"}.` : `One part gives ${a}, and the other part gives ${b}.`);
 	return earlier;
 }
-function worldOf(draft) {
+function worldDraft() {
+	return {
+		kinds: {},
+		defaults: {},
+		owners: /* @__PURE__ */ new Map(),
+		entries: []
+	};
+}
+/**
+* This function gives a copy of a table with a change to the kind at a path, as `replaces` names the path. It gives
+* `undefined` when no kind is at the path. An alias is not a kind.
+*/
+function changeKind(table, path, change) {
+	const [first, key, ...rest] = path;
+	if (String(first) === "fallback" && key === void 0) return table.fallback === void 0 ? void 0 : {
+		...table,
+		fallback: change(table.fallback)
+	};
+	if (String(first) !== "kinds" || key === void 0) return void 0;
+	const entry = own$2(table.kinds, String(key));
+	const next = rest.length === 0 ? isKind(entry) ? change(entry) : void 0 : isNamespace(entry) ? changeKind(entry, rest, change) : void 0;
+	if (next === void 0) return void 0;
+	const kinds = { ...table.kinds };
+	setOwn$5(kinds, String(key), next);
+	return {
+		...table,
+		kinds
+	};
+}
+/**
+* This function adds the entries of `extends` to the kinds of a draft. A later part can give the kind, thus this step
+* reads the whole draft. Without `m`, it reports no conflict: a function part sees the entries of the parts before it.
+*/
+function addVerbs(draft, m) {
+	let table = draft.fallback === void 0 ? { kinds: draft.kinds } : {
+		kinds: draft.kinds,
+		fallback: draft.fallback
+	};
+	for (const entry of draft.entries) {
+		if (!entry.allowed && !entry.replaced) {
+			m?.clash(entry.path, entry.part, "A part adds a verb that it does not own to a kind that it does not give.");
+			continue;
+		}
+		const next = changeKind(table, entry.kind, (kind) => {
+			const verbs = { ...kind.verbs };
+			const earlier = own$2(verbs, entry.verb);
+			if (earlier === void 0) m?.give(entry.path, entry.part);
+			else if (entry.replaced) m?.replace(entry.path, entry.part);
+			else if (earlier !== entry.code) m?.clash(entry.path, entry.part, "Two parts give two different evaluators for this verb of this kind.");
+			if (earlier === void 0 || entry.replaced) setOwn$5(verbs, entry.verb, entry.code);
+			return {
+				...kind,
+				verbs
+			};
+		});
+		if (next !== void 0) table = next;
+		else if (!entry.replaced) m?.clash(entry.path, entry.part, "A part adds a verb to a path without a kind.");
+	}
+	return table;
+}
+function worldOf(draft, m) {
+	const table = addVerbs(draft, m);
 	const world = {
-		kinds: { ...draft.kinds },
+		kinds: { ...table.kinds },
 		defaults: { ...draft.defaults }
 	};
-	return draft.fallback === void 0 ? world : {
+	return table.fallback === void 0 ? world : {
 		...world,
-		fallback: draft.fallback
+		fallback: table.fallback
 	};
 }
+/** This function records the verbs that a part owns, and the entries that it adds to kinds. */
+function mergeVerbs(m, draft, part, index, replaces, base) {
+	const owned = part.verbs ?? [];
+	for (const verb of owned) {
+		const path = [
+			...base,
+			"verbs",
+			verb
+		];
+		const owner = draft.owners.get(verb);
+		if (replaces.has(keyOf(path))) {
+			draft.owners.set(verb, part);
+			m.replace(path, index);
+		} else if (KERNEL_VERBS.has(verb)) m.clash(path, index, "The kernel owns this verb.");
+		else if (owner === void 0) {
+			draft.owners.set(verb, part);
+			m.give(path, index);
+		} else if (!same(owner, part)) m.clash(path, index, "Two parts own this verb.");
+	}
+	const table = part.fallback === void 0 ? { kinds: part.kinds ?? {} } : {
+		kinds: part.kinds ?? {},
+		fallback: part.fallback
+	};
+	for (const { kind, verbs } of part.extends ?? []) {
+		const gives = changeKind(table, kind, (found) => found) !== void 0;
+		for (const verb of Object.keys(verbs)) {
+			const code = verbs[verb];
+			if (code === void 0) continue;
+			const path = [
+				...base,
+				...kind,
+				"verbs",
+				verb
+			];
+			draft.entries.push({
+				kind,
+				verb,
+				code,
+				path,
+				part: index,
+				allowed: gives || owned.includes(verb),
+				replaced: replaces.has(keyOf(path))
+			});
+		}
+	}
+}
 function mergeWorldInto(m, draft, part, index, replaces, base) {
 	if (part === void 0) return;
 	if (part.kinds !== void 0) mergeEntries(m, draft.kinds, part.kinds, [...base, "kinds"], index, replaces);
@@ -2093,6 +2261,7 @@ function mergeWorldInto(m, draft, part, index, replaces, base) {
 	], index, replaces, Object.is, "Two parts give two different defaults for this verb.");
 	const fallback = mergeFallback(m, draft.fallback, part.fallback, [...base, "fallback"], index, replaces);
 	if (fallback !== void 0) draft.fallback = fallback;
+	mergeVerbs(m, draft, part, index, replaces, base);
 }
 /**
 * This function merges worlds into one world, in the order of the parts. It does not change a part.
@@ -2102,6 +2271,8 @@ function mergeWorldInto(m, draft, part, index, replaces, base) {
 * - The defaults merge verb by verb, and the world keeps one fallback.
 * - Each other pair of entries at one path is a conflict, unless the later part names the path in `replaces`.
 *   Then the later entry wins, with no merge below it.
+* - The entries of `extends` join their kinds after each part, thus the order of the parts does not change them. A
+*   verb that a part does not own on a kind that it does not give is a conflict (COMPOSE.PIRACY).
 *
 * A part can be a function of the merge of the parts before it (`prev`, as an overlay of Nix). Thus a part can read
 * the entry that it replaces.
@@ -2112,16 +2283,14 @@ function mergeWorldInto(m, draft, part, index, replaces, base) {
 */
 function mergeWorlds(...parts) {
 	const m = new Merger();
-	const draft = {
-		kinds: {},
-		defaults: {}
-	};
+	const draft = worldDraft();
 	parts.forEach((input, index) => {
 		const part = typeof input === "function" ? input(worldOf(draft)) : input;
 		mergeWorldInto(m, draft, part, index, new Set((part.replaces ?? []).map(keyOf)), []);
 	});
+	const world = worldOf(draft, m);
 	if (m.conflicts.length > 0) throw new MergeError(m.conflicts);
-	return worldOf(draft);
+	return world;
 }
 /** The fields of a machine that merge by their own rules. Each other field is one value, or a conflict. */
 const TABLES = /* @__PURE__ */ new Set([
@@ -2174,12 +2343,12 @@ function composeFacts(hooks, replaced) {
 		}
 	};
 }
-function machineOf(draft) {
+function machineOf(draft, m) {
 	const known = composeKnown(draft.hooks, draft.replaced);
 	const facts = composeFacts(draft.factHooks, draft.replaced);
 	return {
 		...draft.rest,
-		world: worldOf(draft.world),
+		world: worldOf(draft.world, m),
 		evaluators: { ...draft.evaluators },
 		...draft.runners === void 0 ? {} : { runners: { ...draft.runners } },
 		...draft.derefs === void 0 ? {} : { derefs: { ...draft.derefs } },
@@ -2253,10 +2422,7 @@ function checkHidden(m, draft) {
 function mergeMachines(...parts) {
 	const m = new Merger();
 	const draft = {
-		world: {
-			kinds: {},
-			defaults: {}
-		},
+		world: worldDraft(),
 		evaluators: {},
 		hooks: [],
 		factHooks: [],
@@ -2297,8 +2463,9 @@ function mergeMachines(...parts) {
 		}
 	});
 	checkHidden(m, draft);
+	const machine = machineOf(draft, m);
 	if (m.conflicts.length > 0) throw new MergeError(m.conflicts);
-	return machineOf(draft);
+	return machine;
 }
 /** This function removes the entry at a path from a table of entries. It gives the same table when no entry is there. */
 function removeEntry(entries, path) {
@@ -6177,11 +6344,17 @@ const STD_EVALUATORS = {
 		const [a, b] = values;
 		return ok((a ?? 0) > (b ?? 0));
 	},
-	"ref.resolve": ({ data, resolve }) => {
-		if (!Array.isArray(data) || data.length === 0) return fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
-		const found = resolve(data);
-		return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
-	},
+	"ref.resolve": { compile: ({ data, machine }) => {
+		if (!Array.isArray(data) || data.length === 0) {
+			const bad = fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
+			return () => bad;
+		}
+		const path = compilePath(machine, data);
+		return (ctx, rt) => {
+			const found = resolveCompiled(rt, ctx, path);
+			return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
+		};
+	} },
 	"tree.node": (input) => treeNode(input, void 0)
 };
 /** The brand of a node of the decorated tree. Its value is the state that the kit reads. */
@@ -7843,6 +8016,11 @@ function boundariesOf(typing, domains) {
 	});
 	return found;
 }
+/** The result of a test that proves nothing. */
+const NO_PROOFS$1 = {
+	yes: [],
+	no: []
+};
 /** The roots that can change, as a rule gives them in `PartType.roots`. */
 const CHANGING = [
 	"self",
@@ -7865,8 +8043,12 @@ function ruleOf(machine, name) {
 	const rule = typeof evaluator === "object" && evaluator !== null || typeof evaluator === "function" ? evaluator.type : void 0;
 	return typeof rule === "object" && rule !== null && typeof rule.synth === "function" ? rule : void 0;
 }
-/** This function gives the order of the parts of a document: first the parts that give the names of a rule `keysAt`. */
-function orderOf(node, nodes) {
+/** This function gives the order of the parts of a document. The part `first` of the rule comes first, or else the parts that give the names of a rule `keysAt`. */
+function orderOf(node, nodes, first) {
+	if (first !== void 0) {
+		const isFirst = (index) => String(nodes[index].visit.slot[0]) === first;
+		return [...node.children.filter(isFirst), ...node.children.filter((index) => !isFirst(index))];
+	}
 	const sources = (node.visit.kind?.scope ?? []).flatMap((rule) => "keysAt" in rule.names ? [rule.names.keysAt] : []);
 	if (sources.length === 0 || node.children.length < 2) return node.children;
 	const gives = (index) => {
@@ -7890,7 +8072,7 @@ function message(error) {
 * @param rootTypes - The types of the roots and of the names of the host.
 * @returns The type of the root, the type issues in the order of the document, and the type of each document.
 */
-function typePass(machine, nodes, verb, expect, rootTypes = {}) {
+function typePass(machine, nodes, verb, expect, rootTypes = {}, hasEffect = () => false) {
 	if (nodes.length === 0) return {
 		type: "unknown",
 		issues: [],
@@ -7902,6 +8084,29 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 	const types = new Array(nodes.length);
 	const needed = new Array(nodes.length);
 	const seen = /* @__PURE__ */ new Set();
+	const inputs = new Array(nodes.length);
+	let changes;
+	const rootsChange = () => changes ??= nodes.some(hasEffect);
+	const narrowed = (names, roots, proofs) => {
+		let nextNames = names;
+		let nextRoots = roots;
+		for (const proof of proofs) {
+			const head = proof.path[0];
+			if (head === "names") {
+				const name = proof.path[1];
+				if (name === void 0) continue;
+				if (nextNames === names) nextNames = new Map(names);
+				nextNames.set(name, narrowType(nextNames.get(name) ?? "unknown", proof, 2, domains));
+			} else if ((head === "self" || head === "world" || head === "event") && !rootsChange()) nextRoots = {
+				...nextRoots,
+				[head]: narrowType(nextRoots[head], proof, 1, domains)
+			};
+		}
+		return {
+			names: nextNames,
+			roots: nextRoots
+		};
+	};
 	const issueAt = (index, problem) => {
 		const visit = nodes[index].visit;
 		const issue = {
@@ -7939,19 +8144,30 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 			typeOf: (path) => typed.get(pathKey(path)) ?? "unknown",
 			nameType: (name) => names.get(name),
 			rootType: (root) => root === "caps" ? CAPS_TYPE : root === "self" || root === "world" || root === "event" ? roots[root] : "unknown",
-			contract: (type, what) => contract(index, type, what)
+			contract: (type, what) => contract(index, type, what),
+			readOf: (path) => {
+				const key = pathKey(path);
+				const part = node.children.find((child) => pathKey(nodes[child].visit.slot) === key);
+				const read = part === void 0 ? void 0 : ruleOf(machine, nodes[part].evaluator)?.reads;
+				return read === void 0 || nodes[part].marked ? void 0 : read(inputs[part]);
+			},
+			provenBy: (path) => frame.proven?.get(pathKey(path)) ?? NO_PROOFS$1
 		};
-		return {
+		inputs[index] = input;
+		const rule = node.marked ? void 0 : ruleOf(machine, node.evaluator);
+		const frame = {
 			index,
-			rule: node.marked ? void 0 : ruleOf(machine, node.evaluator),
+			rule,
 			input,
-			order: orderOf(node, nodes),
+			order: orderOf(node, nodes, rule?.first),
 			next: 0,
 			typed,
 			needs,
 			names,
-			roots
+			roots,
+			proven: void 0
 		};
+		return frame;
 	};
 	const ruleFailed = (frame, error) => {
 		issueAt(frame.index, { reason: `The type rule of ${nodes[frame.index].evaluator ?? "the evaluator"} fails: ${message(error)}` });
@@ -7999,12 +8215,22 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 			if (contracts && node.expect !== void 0) need(contract(child, node.expect, `expected type of the ${what}`), what);
 			if (part.expect !== void 0) need(part.expect, part.what ?? what);
 			let names = frame.names;
+			let kept = frame.roots;
+			if (part.narrow !== void 0 && part.narrow.length > 0) {
+				const after = narrowed(names, kept, part.narrow);
+				names = after.names;
+				kept = after.roots;
+				if (part.keep === true) {
+					frame.names = names;
+					frame.roots = kept;
+				}
+			}
 			if (node.bound.length > 0) {
 				const copy = new Map(names);
 				for (const name of node.bound) copy.set(name, part.names !== void 0 && Object.hasOwn(part.names, name) ? part.names[name] : "unknown");
 				names = copy;
 			}
-			let roots = frame.rule === void 0 ? UNKNOWN_ROOTS : frame.roots;
+			let roots = frame.rule === void 0 ? UNKNOWN_ROOTS : kept;
 			const changes = part.roots;
 			if (typeof changes === "object" && changes !== null) {
 				const copy = { ...roots };
@@ -8039,7 +8265,15 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 		}
 		types[frame.index] = type;
 		needed[frame.index] = frame.needs.length === 0 ? void 0 : frame.needs[frame.needs.length - 1].type;
-		stack[stack.length - 1]?.typed.set(pathKey(node.visit.slot), type);
+		const parent = stack[stack.length - 1];
+		if (parent === void 0) continue;
+		const key = pathKey(node.visit.slot);
+		parent.typed.set(key, type);
+		if (parent.rule?.usesProofs === true && frame.rule?.proves !== void 0) try {
+			(parent.proven ??= /* @__PURE__ */ new Map()).set(key, frame.rule.proves(frame.input));
+		} catch (error) {
+			ruleFailed(frame, error);
+		}
 	}
 	const places = nodes.map((node, index) => {
 		const want = needed[index];
@@ -9838,7 +10072,8 @@ function check(machine, doc, options = {}) {
 function typeCheck(machine, doc, options = {}) {
 	const nodes = [];
 	const issues = checkAll(machine, doc, options, nodes);
-	const pass = typePass(machine, nodes, options.verb ?? "eval", options.expect, options.rootTypes);
+	const verb = options.verb ?? "eval";
+	const pass = typePass(machine, nodes, verb, options.expect, options.rootTypes, (node) => declaredEffects(node.visit, verb, machine, node.evaluator).length > 0);
 	return {
 		type: pass.type,
 		issues: pass.issues.length === 0 ? issues : [...issues, ...pass.issues],
@@ -10843,6 +11078,13 @@ function decodeValue(machine, doc) {
 	return prepare(machine, doc, { declaredType: "lit" }).evaluate(makeContext());
 }
 // src/formula.ts
+/** The most proofs that one test keeps. A proof only adds knowledge, thus the check can leave one out. */
+const MAX_PROOFS = 32;
+/** The result of a test that proves nothing. */
+const NO_PROOFS = {
+	yes: [],
+	no: []
+};
 /** The mark of a field that the profile leaves out of a record. */
 const SKIPPED = /* @__PURE__ */ Symbol("skipped");
 /** The value of a name whose binding failed. A reference to the name gives the error. */
@@ -11243,6 +11485,11 @@ function formulaTypes(profile) {
 					type: sig.to,
 					what: `result of a signature of ops.${name}`
 				});
+				if (sig.proves !== void 0) out.push({
+					at: [...at, "proves"],
+					type: sig.proves,
+					what: `proved type of a signature of ops.${name}`
+				});
 				const earlier = list.slice(0, index).findIndex((other) => isSignature(other) && sameParams(other, sig));
 				if (earlier >= 0) out.push({
 					at,
@@ -11253,7 +11500,30 @@ function formulaTypes(profile) {
 		return out;
 	};
 	const logic = (word) => ({
-		part: (input, path) => truthPart(input, `term ${Number(path[0]) + 1} of ${word}`),
+		usesProofs: true,
+		part: (input, path) => {
+			const index = Number(path[0]);
+			const part = truthPart(input, `term ${index + 1} of ${word}`);
+			if (index === 0) return part;
+			const before = input.provenBy([index - 1]);
+			return {
+				...part,
+				narrow: word === "and" ? before.yes : before.no,
+				keep: true
+			};
+		},
+		proves: (input) => {
+			const each = input.paths.map((path) => input.provenBy(path));
+			const all = (side) => each.flatMap((proven) => proven[side]).slice(0, MAX_PROOFS);
+			const one = each.length === 1 ? each[0] : void 0;
+			return word === "and" ? {
+				yes: all("yes"),
+				no: one?.no ?? []
+			} : {
+				yes: one?.yes ?? [],
+				no: all("no")
+			};
+		},
 		synth: (input) => {
 			if (!logicValue) return "bool";
 			if (input.paths.length === 0) return { one: [word === "and"] };
@@ -11264,6 +11534,11 @@ function formulaTypes(profile) {
 		"formula.lit": { synth: (input) => valueType(input.doc.value) },
 		"formula.ref": {
 			read: true,
+			reads: (input) => {
+				const path = input.doc.value;
+				if (input.address || !Array.isArray(path) || path.length === 0) return void 0;
+				return path.every((step) => typeof step === "string") ? path : void 0;
+			},
 			synth: (input, report) => {
 				const path = input.doc.value;
 				if (input.address || !Array.isArray(path) || path.length === 0) return "unknown";
@@ -11407,11 +11682,16 @@ function formulaTypes(profile) {
 				type: truth,
 				what: "truth type of the profile"
 			}] : [],
+			first: "test",
+			usesProofs: true,
 			part: (input, path) => {
 				if (path[0] === "test") return truthPart(input, "test of if");
-				return isUnknown(input.expected, input.machine.domains) ? {} : {
+				const proven = input.provenBy(["test"]);
+				const narrow = path[0] === "then" ? proven.yes : proven.no;
+				return isUnknown(input.expected, input.machine.domains) ? { narrow } : {
 					expect: input.expected,
-					what: `${String(path[0])} branch of if`
+					what: `${String(path[0])} branch of if`,
+					narrow
 				};
 			},
 			synth: (input) => {
@@ -11424,6 +11704,41 @@ function formulaTypes(profile) {
 		"formula.or": logic("or"),
 		"formula.op": {
 			declared: sigsDeclared,
+			proves: (input) => {
+				const sigs = signatures(input)?.sigs;
+				const sig = sigs?.length === 1 ? sigs[0] : void 0;
+				if (sig === void 0 || sig.proves === void 0 && sig.present !== true || input.paths.length === 0) return NO_PROOFS;
+				const path = input.readOf(input.paths[0]);
+				if (path === void 0) return NO_PROOFS;
+				const yes = [];
+				const no = [];
+				if (sig.proves !== void 0 && typeIssues(input.contract(sig.proves, `proved type of ops.${nameOf(input)}`), input.machine.domains).length === 0) {
+					yes.push({
+						path,
+						fact: "is",
+						type: sig.proves
+					});
+					no.push({
+						path,
+						fact: "not",
+						type: sig.proves
+					});
+				}
+				if (sig.present === true) {
+					yes.push({
+						path,
+						fact: "present"
+					});
+					no.push({
+						path,
+						fact: "absent"
+					});
+				}
+				return {
+					yes,
+					no
+				};
+			},
 			part: (input, path) => {
 				const read = signatures(input);
 				if (read === void 0 || read.sigs.length !== 1) return {};
@@ -13211,10 +13526,23 @@ const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolv
 	}
 };
 /**
+* The definition of the standard evaluator `ref.resolve` (REF.RESOLVE, D133). It resolves the steps of the path at each
+* evaluation. The plan compiles the same path one time.
+*/
+const refDefinition = ({ data, resolve: walk }) => {
+	if (!Array.isArray(data) || data.length === 0) return fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
+	const found = walk(data);
+	return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
+};
+/**
 * The definitions of the reference for the evaluators of the standard machine that need their own reading. The
-* reference uses them for the standard evaluators, also without the option `definitions`. It holds `tree.node`.
+* reference uses them for the standard evaluators, also without the option `definitions`. It holds `tree.node` and
+* `ref.resolve`. A host that wraps `ref.resolve` wraps this function, because the standard evaluator is compiled.
 */
-const STD_DEFINITIONS = { evaluators: { "tree.node": treeDefinition } };
+const STD_DEFINITIONS = { evaluators: {
+	"tree.node": treeDefinition,
+	"ref.resolve": refDefinition
+} };
 const CLOSURE$1 = /* @__PURE__ */ Symbol.for("coeval.closure");
 /** This function sets an own field, also the field `__proto__` (SHAPE.PROTO). */
 function setField$1(target, key, value) {