@mark1russell7/coeval 0.7.0 → 0.7.1

package/build/index.js

@@ -759,7 +759,7 @@ function fits(found, expected, domains) {
 	return fitsAt(found, expected, domains, 0);
 }
 /** This function sets an own field of a new record. Only the key `__proto__` needs `defineProperty`. */
-function setOwn$4(target, key, value) {
+function setOwn$5(target, key, value) {
 	if (key === "__proto__") Object.defineProperty(target, key, {
 		value,
 		enumerable: true,
@@ -778,10 +778,10 @@ function joinRecords(a, b, domains, depth) {
 		const inA = Object.hasOwn(a.fields, key);
 		const inB = Object.hasOwn(b.fields, key);
 		if (inA && inB) {
-			setOwn$4(fields, key, joinAt(a.fields[key], b.fields[key], domains, depth));
+			setOwn$5(fields, key, joinAt(a.fields[key], b.fields[key], domains, depth));
 			if (a.optional.has(key) || b.optional.has(key)) optional.push(key);
 		} else if (closed) {
-			setOwn$4(fields, key, inA ? a.fields[key] : b.fields[key]);
+			setOwn$5(fields, key, inA ? a.fields[key] : b.fields[key]);
 			optional.push(key);
 		}
 	}
@@ -1185,7 +1185,7 @@ function keyOf(path) {
 	return JSON.stringify(path.map(String));
 }
 /** This function sets an own data property. An assignment to the key `__proto__` changes the prototype. */
-function setOwn$3(target, key, value) {
+function setOwn$4(target, key, value) {
 	if (key === "__proto__") Object.defineProperty(target, key, {
 		value,
 		enumerable: true,
@@ -1202,7 +1202,7 @@ function defined(value) {
 	if (Array.isArray(value)) return value.map(defined);
 	if (!isRecord(value)) return value;
 	const out = {};
-	for (const key of Object.keys(value)) if (value[key] !== void 0) setOwn$3(out, key, defined(value[key]));
+	for (const key of Object.keys(value)) if (value[key] !== void 0) setOwn$4(out, key, defined(value[key]));
 	return out;
 }
 /** Two values are the same when they are equal by `docEquals`. A function and a host value are equal only to themselves. */
@@ -1247,7 +1247,7 @@ function extendDomain(name, more) {
 			...Object.keys(steps).length === 0 ? {} : { steps }
 		};
 		const domains = {};
-		setOwn$3(domains, name, domain);
+		setOwn$4(domains, name, domain);
 		return {
 			domains,
 			replaces: [["domains", name]]
@@ -1297,10 +1297,10 @@ function mergeLeaf(m, table, key, later, path, part, replaces, equal, reason) {
 	if (later === void 0) return;
 	const earlier = own$2(table, key);
 	if (earlier === void 0) {
-		setOwn$3(table, key, later);
+		setOwn$4(table, key, later);
 		m.give(path, part);
 	} else if (replaces.has(keyOf(path))) {
-		setOwn$3(table, key, later);
+		setOwn$4(table, key, later);
 		m.replace(path, part);
 	} else if (!equal(earlier, later)) m.clash(path, part, reason);
 }
@@ -1321,9 +1321,9 @@ function mergeEntries(m, into, from, path, part, replaces) {
 		const at = [...path, key];
 		const earlier = own$2(into, key);
 		if (earlier === void 0) {
-			setOwn$3(into, key, later);
+			setOwn$4(into, key, later);
 			m.give(at, part);
-		} else setOwn$3(into, key, mergeEntry(m, earlier, later, at, part, replaces));
+		} else setOwn$4(into, key, mergeEntry(m, earlier, later, at, part, replaces));
 	}
 }
 /** This function merges two entries at one path. Two namespaces merge key by key, and their fallbacks merge too. */
@@ -1476,8 +1476,8 @@ function mergeCode(m, draft, part, index, replaces) {
 		const runnerPath = ["runners", name];
 		if (replaces.has(keyOf(evaluatorPath)) || replaces.has(keyOf(runnerPath))) {
 			if (evaluator === void 0) delete draft.evaluators[name];
-			else setOwn$3(draft.evaluators, name, evaluator);
-			if (runner !== void 0) setOwn$3(draft.runners ??= {}, name, runner);
+			else setOwn$4(draft.evaluators, name, evaluator);
+			if (runner !== void 0) setOwn$4(draft.runners ??= {}, name, runner);
 			else if (draft.runners !== void 0) delete draft.runners[name];
 			m.replace(evaluatorPath, index);
 			m.replace(runnerPath, index);
@@ -1600,7 +1600,7 @@ function removeEntry(entries, path) {
 	}
 	const out = { ...entries };
 	if (next === void 0) delete out[key];
-	else setOwn$3(out, key, next);
+	else setOwn$4(out, key, next);
 	return out;
 }
 /**
@@ -2412,7 +2412,7 @@ var Bad = class {
 	}
 };
 /** This function sets an own data property. Only the key `__proto__` needs `defineProperty`. */
-function setOwn$2(target, key, value) {
+function setOwn$3(target, key, value) {
 	if (key === "__proto__") Object.defineProperty(target, key, {
 		value,
 		enumerable: true,
@@ -2584,7 +2584,7 @@ function splitParts(shape, value) {
 		const out = {};
 		for (const [key, child] of node.fields) {
 			const kept = strip(child);
-			if (kept !== void 0) setOwn$2(out, key, kept);
+			if (kept !== void 0) setOwn$3(out, key, kept);
 		}
 		return out;
 	};
@@ -2593,7 +2593,7 @@ function splitParts(shape, value) {
 		if (node.t === "slot") return handles[node.index];
 		if (node.t === "list") return node.items.map((child) => fillWith(child, handles));
 		const out = {};
-		for (const [key, child] of node.fields) setOwn$2(out, key, fillWith(child, handles));
+		for (const [key, child] of node.fields) setOwn$3(out, key, fillWith(child, handles));
 		return out;
 	};
 	return {
@@ -3555,7 +3555,7 @@ function fillOf(split, doc) {
 	return (items) => split.parts.length === 0 ? doc.value : split.fill(items);
 }
 function interpret(fn, input, fill) {
-	const { kind, typePath, doc, data, place } = input;
+	const { kind, typePath, doc, data, place, machine } = input;
 	const address = input.address === true ? { address: true } : {};
 	const refill = input.fill;
 	const compiled = input.parts;
@@ -3576,6 +3576,7 @@ function interpret(fn, input, fill) {
 			parts,
 			context: ctx,
 			place,
+			machine,
 			...address,
 			resolve: (path, options) => rt.resolve(ctx, path, options),
 			effect: (effectKind, payload) => rt.effect(ctx, effectKind, payload, place),
@@ -3584,7 +3585,7 @@ function interpret(fn, input, fill) {
 	};
 }
 function interpretRun(fn, input, fill) {
-	const { kind, typePath, doc, data, place } = input;
+	const { kind, typePath, doc, data, place, machine } = input;
 	const refill = input.fill;
 	const compiled = input.parts;
 	const hasParts = compiled.length > 0;
@@ -3604,6 +3605,7 @@ function interpretRun(fn, input, fill) {
 			parts,
 			context: ctx,
 			place,
+			machine,
 			resolve: (path, options) => rt.resolve(ctx, path, options),
 			effect: (effectKind, payload) => rt.runEffect(ctx, effectKind, payload, place),
 			all: (list, options) => rt.all(list.map((part) => () => part.evaluate()), options),
@@ -5873,6 +5875,178 @@ function checkLatent(machine, declared, body, options = {}) {
 	return issues;
 }
 //#endregion
+//#region src/codec.ts
+/** This function gives the codec of a domain, or `undefined` when the domain has no codec. */
+function codecOf(domain) {
+	const codec = domain.codec;
+	if (typeof codec !== "object" || codec === null) return void 0;
+	const { encode, decode } = codec;
+	return typeof encode === "function" && typeof decode === "function" ? codec : void 0;
+}
+/**
+* This function reads the value of an extension `ext.domain` (EXT.DOMAIN). The value is a record with only the text
+* `domain` and the JSON `data`. The codec of the named domain reads the data, and the result must be a member of the
+* domain.
+*
+* @param data - The value of the extension document.
+* @param domains - The domains of the machine.
+* @returns The member, `#NAME?` for a domain without a codec, or `#VALUE!` for data that the codec cannot read.
+*/
+function decodeDomain(data, domains) {
+	if (!isRecord(data) || typeof data["domain"] !== "string" || !Object.hasOwn(data, "data") || Object.keys(data).length !== 2) return fail("#VALUE!", "The value of ext.domain is a record with only the text domain and the data.");
+	const name = data["domain"];
+	const domain = domainOf(name, domains);
+	if (domain === void 0) return fail("#NAME?", `The machine has no domain ${name}.`);
+	const codec = codecOf(domain);
+	if (codec === void 0) return fail("#NAME?", `The domain ${name} has no codec.`);
+	let value;
+	try {
+		value = codec.decode(data["data"]);
+	} catch (error) {
+		return fail("#VALUE!", `The codec of the domain ${name} cannot read the data: ${describe(error)}`, { cause: error });
+	}
+	if (!member(value, name, domains)) return fail("#VALUE!", `The codec of the domain ${name} gives a value that is not a member of the domain.`);
+	return ok(value);
+}
+/**
+* This function gives the static type of an extension `ext.domain`: the name of its domain when that domain has a
+* codec. A run then gives a member of the domain or an error, because `decodeDomain` tests the membership.
+*
+* @param data - The value of the extension document.
+* @param domains - The domains of the machine.
+* @returns The name of the domain, or `unknown`.
+*/
+function domainTypeOf(data, domains) {
+	if (!isRecord(data) || typeof data["domain"] !== "string") return "unknown";
+	const domain = domainOf(data["domain"], domains);
+	return domain !== void 0 && codecOf(domain) !== void 0 ? data["domain"] : "unknown";
+}
+/** This function sets an own data property. Only the key `__proto__` needs `defineProperty`. */
+function setOwn$2(target, key, value) {
+	if (key === "__proto__") Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	else target[key] = value;
+}
+/**
+* This function tells if JSON writes a value exactly. Such a value is a finite number other than `-0`, a text, a truth
+* value, `null`, or a container of such values.
+*/
+function isJson(value, encoder) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value) && !Object.is(value, -0);
+	const list = Array.isArray(value);
+	if (!list && !isRecord(value)) return false;
+	const container = value;
+	const known = encoder.json.get(container);
+	if (known !== void 0) return known;
+	encoder.json.set(container, false);
+	let all = true;
+	if (list) {
+		const items = value;
+		for (let index = 0; index < items.length && all; index += 1) all = isJson(items[index], encoder);
+	} else {
+		const record = value;
+		for (const key of Object.keys(record)) if (!isJson(record[key], encoder)) {
+			all = false;
+			break;
+		}
+	}
+	encoder.json.set(container, all);
+	return all;
+}
+/** This function gives the text of a number that JSON cannot write, for `ext.number`. */
+function numberText(value) {
+	if (Number.isNaN(value)) return "NaN";
+	if (value === Number.POSITIVE_INFINITY) return "Infinity";
+	if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+	return "-0";
+}
+/** This function gives the term document of a value in one call of `encodeValue`. */
+function encodeTerm(value, encoder) {
+	if (isJson(value, encoder)) return isEnvelope(value) ? {
+		type: "lit",
+		value
+	} : value;
+	if (value === void 0) return {
+		type: ["ext", "undefined"],
+		value: null
+	};
+	if (typeof value === "number") return {
+		type: ["ext", "number"],
+		value: numberText(value)
+	};
+	for (const [name, codec] of encoder.codecs) if (member(value, name, encoder.domains)) return {
+		type: ["ext", "domain"],
+		value: {
+			domain: name,
+			data: codec.encode(value)
+		}
+	};
+	if (!Array.isArray(value) && !isRecord(value)) throw new TypeError(`encodeValue cannot write the value ${describe(value)}: no domain of the machine with a codec holds it.`);
+	if (encoder.open.has(value)) throw new TypeError("encodeValue cannot write a value with a cycle.");
+	encoder.open.add(value);
+	let out;
+	if (Array.isArray(value)) out = {
+		type: "list",
+		value: Array.from(value, (item) => encodeTerm(item, encoder))
+	};
+	else {
+		const fields = {};
+		const record = value;
+		for (const key of Object.keys(record)) setOwn$2(fields, key, encodeTerm(record[key], encoder));
+		out = {
+			type: "record",
+			value: fields
+		};
+	}
+	encoder.open.delete(value);
+	return out;
+}
+/**
+* This function writes a host value as a term document of the formula kit (EXT.ENCODE, D40). Thus the same value has
+* the same document in each language (D12).
+*
+* - A value that JSON writes exactly stays as it is. A literal with the shape of an envelope goes into `lit`.
+* - `NaN`, an infinity and `-0` become `ext.number`, and `undefined` becomes `ext.undefined`.
+* - A member of a domain with a codec becomes `ext.domain`. The domains go in the order of their names.
+* - A list or a plain record with such a value becomes the construct `list` or `record`.
+*
+* @param machine - The machine, or only its domains.
+* @param value - The host value.
+* @returns The document. `decodeValue` gives the value again (EXT.ROUNDTRIP).
+* @throws {TypeError} The value has a cycle, or it is not JSON and no domain with a codec holds it.
+*/
+function encodeValue(machine, value) {
+	const domains = machine.domains;
+	const codecs = [];
+	if (domains !== void 0) for (const name of Object.keys(domains).sort()) {
+		const domain = domainOf(name, domains);
+		const codec = domain === void 0 ? void 0 : codecOf(domain);
+		if (codec !== void 0) codecs.push([name, codec]);
+	}
+	return encodeTerm(value, {
+		domains,
+		codecs,
+		json: /* @__PURE__ */ new WeakMap(),
+		open: /* @__PURE__ */ new Set()
+	});
+}
+/**
+* This function reads a document of `encodeValue` again: it evaluates the document as a term, in an empty context.
+* A bare root value is a literal.
+*
+* @param machine - A machine of the formula kit, with the domains of the document.
+* @param doc - The document.
+* @returns The value, or the error of the evaluation.
+*/
+function decodeValue(machine, doc) {
+	return prepare(machine, doc, { declaredType: "lit" }).evaluate(makeContext());
+}
+//#endregion
 //#region src/formula.ts
 /** The mark of a field that the profile leaves out of a record. */
 const SKIPPED = /* @__PURE__ */ Symbol("skipped");
@@ -5893,7 +6067,10 @@ const CLOSURE$2 = /* @__PURE__ */ Symbol.for("coeval.closure");
 function isClosure(value) {
 	return typeof value === "function" && value[CLOSURE$2] !== void 0;
 }
-/** The standard extensions: the values that JSON cannot write. */
+/**
+* The standard extensions: the values that JSON cannot write. `ext.domain` reads a member of a domain through the
+* codec of the domain (EXT.DOMAIN, D40).
+*/
 const STD_EXT = {
 	undefined: () => ok(void 0),
 	number: (data) => {
@@ -5902,7 +6079,8 @@ const STD_EXT = {
 		if (data === "-Infinity") return ok(Number.NEGATIVE_INFINITY);
 		if (data === "-0") return ok(-0);
 		return fail("#VALUE!", "The value of ext.number is NaN, Infinity, -Infinity or -0.");
-	}
+	},
+	domain: (data, _context, domains) => decodeDomain(data, domains)
 };
 /** The truth of a value in the rules of JavaScript: `0`, `""`, `null`, `undefined` and `NaN` are false. */
 function jsTruthy(value) {
@@ -6369,8 +6547,9 @@ function formulaTypes(profile) {
 		},
 		"formula.ext": { synth: (input) => {
 			const name = nameOf(input);
-			const own = profile.ext !== void 0 && Object.hasOwn(profile.ext, name);
-			return name === "number" && !own ? "number" : "unknown";
+			if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) return "unknown";
+			if (name === "number") return "number";
+			return name === "domain" ? domainTypeOf(input.doc.value, input.machine.domains) : "unknown";
 		} }
 	};
 }
@@ -6688,7 +6867,7 @@ function formulaCode(profile) {
 				}
 			};
 		}),
-		"formula.ext": compiled(({ typePath, doc }) => {
+		"formula.ext": compiled(({ typePath, doc, machine }) => {
 			const name = typePath.slice(1).join(".");
 			const handler = (profile.ext !== void 0 && Object.hasOwn(profile.ext, name) ? profile.ext[name] : void 0) ?? (Object.hasOwn(STD_EXT, name) ? STD_EXT[name] : void 0);
 			if (handler === void 0) {
@@ -6697,7 +6876,7 @@ function formulaCode(profile) {
 			}
 			return (ctx) => {
 				try {
-					return handler(doc.value, ctx);
+					return handler(doc.value, ctx, machine.domains);
 				} catch (error) {
 					return thrown(error, `the extension ${name}`);
 				}
@@ -6798,6 +6977,835 @@ function formulaMachine(profile = {}, more = {}) {
 	}, more);
 }
 //#endregion
+//#region src/syntax.ts
+/**
+* The standard syntax of the formula kit. It gives the site and the playground a text form. The operators are
+* `or`, `and`, `not`, the comparisons, `+ - * / %`, a minus sign and `^`, from the loosest to the tightest. A call
+* `name(args)` applies the operation `ops.name`. `if(test, then, else)` and `list(items)` make the constructs.
+*/
+const STD_SYNTAX = /* @__PURE__ */ Object.freeze({
+	operators: [
+		{
+			symbol: "or",
+			fixity: "infix",
+			prec: 1,
+			assoc: "flat",
+			kind: "or"
+		},
+		{
+			symbol: "and",
+			fixity: "infix",
+			prec: 2,
+			assoc: "flat",
+			kind: "and"
+		},
+		{
+			symbol: "not",
+			fixity: "prefix",
+			prec: 3,
+			kind: "ops.not"
+		},
+		{
+			symbol: "==",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.eq"
+		},
+		{
+			symbol: "!=",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.ne"
+		},
+		{
+			symbol: "<",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.lt"
+		},
+		{
+			symbol: "<=",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.le"
+		},
+		{
+			symbol: ">",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.gt"
+		},
+		{
+			symbol: ">=",
+			fixity: "infix",
+			prec: 4,
+			assoc: "none",
+			kind: "ops.ge"
+		},
+		{
+			symbol: "+",
+			fixity: "infix",
+			prec: 5,
+			kind: "ops.add"
+		},
+		{
+			symbol: "-",
+			fixity: "infix",
+			prec: 5,
+			kind: "ops.sub"
+		},
+		{
+			symbol: "*",
+			fixity: "infix",
+			prec: 6,
+			kind: "ops.mul"
+		},
+		{
+			symbol: "/",
+			fixity: "infix",
+			prec: 6,
+			kind: "ops.div"
+		},
+		{
+			symbol: "%",
+			fixity: "infix",
+			prec: 6,
+			kind: "ops.mod"
+		},
+		{
+			symbol: "-",
+			fixity: "prefix",
+			prec: 7,
+			kind: "ops.neg"
+		},
+		{
+			symbol: "^",
+			fixity: "infix",
+			prec: 8,
+			assoc: "right",
+			kind: "ops.pow"
+		}
+	],
+	literals: { words: {
+		true: true,
+		false: false,
+		null: null,
+		undefined: void 0,
+		NaN: NaN,
+		Infinity: Infinity
+	} },
+	calls: { forms: [{
+		name: "if",
+		kind: "if",
+		fields: [
+			"test",
+			"then",
+			"else"
+		],
+		min: 2
+	}, {
+		name: "list",
+		kind: "list"
+	}] }
+});
+const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const NAME_AT = /[A-Za-z_][A-Za-z0-9_]*/y;
+const DIGITS_AT = /[0-9]+/y;
+const NUMBER_AT = /(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/y;
+const SYMBOL = /^[^\sA-Za-z0-9_"'`()$.]+$/;
+const DEFAULT_WORDS = {
+	true: true,
+	false: false,
+	null: null
+};
+const DEFAULT_ROOTS = [
+	"self",
+	"world",
+	"event",
+	"caps"
+];
+const compiledProfiles = /* @__PURE__ */ new WeakMap();
+function typeOfKind(kind) {
+	const keys = kind.split(".");
+	if (kind === "" || keys.some((key) => key === "")) throw new TypeError(`The kind "${kind}" of a syntax profile has an empty key.`);
+	return {
+		type: keys.length === 1 ? keys[0] : keys,
+		key: JSON.stringify(keys)
+	};
+}
+function addTo(map, key, value) {
+	const list = map.get(key);
+	if (list === void 0) map.set(key, [value]);
+	else list.push(value);
+}
+function compileOps(profile, separator) {
+	const prefix = /* @__PURE__ */ new Map();
+	const binary = /* @__PURE__ */ new Map();
+	const byKind = /* @__PURE__ */ new Map();
+	const assocAt = /* @__PURE__ */ new Map();
+	const opWords = /* @__PURE__ */ new Set();
+	for (const given of profile.operators ?? []) {
+		const word = NAME.test(given.symbol);
+		if (!word && (!SYMBOL.test(given.symbol) || given.symbol.includes(separator))) throw new TypeError(`The operator "${given.symbol}" is not a plain name or a group of symbols.`);
+		if (!Number.isFinite(given.prec)) throw new TypeError(`The operator "${given.symbol}" has no finite precedence.`);
+		const { type, key } = typeOfKind(given.kind);
+		const op = {
+			symbol: given.symbol,
+			fixity: given.fixity,
+			prec: given.prec,
+			assoc: given.assoc ?? "left",
+			type,
+			kindKey: key,
+			word
+		};
+		const table = op.fixity === "prefix" ? prefix : binary;
+		if (table.has(op.symbol)) throw new TypeError(`The operator "${op.symbol}" has two entries of the same place.`);
+		table.set(op.symbol, op);
+		if (op.fixity === "infix") {
+			const assoc = assocAt.get(op.prec);
+			if (assoc !== void 0 && assoc !== op.assoc) throw new TypeError(`The infix operators of the precedence ${String(op.prec)} have different groupings.`);
+			assocAt.set(op.prec, op.assoc);
+		}
+		if (word) opWords.add(op.symbol);
+		addTo(byKind, key, op);
+	}
+	const longestFirst = (table) => [...table.keys()].filter((symbol) => !NAME.test(symbol)).sort((a, b) => b.length - a.length);
+	return {
+		prefix,
+		binary,
+		prefixSymbols: longestFirst(prefix),
+		binarySymbols: longestFirst(binary),
+		byKind,
+		opWords
+	};
+}
+function compileProfile(profile) {
+	const cached = compiledProfiles.get(profile);
+	if (cached !== void 0) return cached;
+	const calls = profile.calls ?? {};
+	const separator = calls.separator ?? ",";
+	const ops = compileOps(profile, separator);
+	const literals = profile.literals ?? {};
+	const strings = literals.strings === false ? void 0 : literals.strings ?? {};
+	const words = new Map(Object.entries(literals.words ?? DEFAULT_WORDS));
+	const refs = profile.refs ?? {};
+	const roots = new Set(refs.roots ?? DEFAULT_ROOTS);
+	const forms = /* @__PURE__ */ new Map();
+	const formsByKind = /* @__PURE__ */ new Map();
+	for (const given of calls.forms ?? []) {
+		if (!NAME.test(given.name)) throw new TypeError(`The call form "${given.name}" is not a plain name.`);
+		const { type, key } = typeOfKind(given.kind);
+		const form = {
+			name: given.name,
+			type,
+			fields: given.fields,
+			min: given.min ?? given.fields?.length ?? 0
+		};
+		forms.set(form.name, form);
+		addTo(formsByKind, key, form);
+	}
+	const compiled = {
+		...ops,
+		numbers: literals.numbers ?? true,
+		signed: literals.signed ?? true,
+		quote: strings === void 0 ? void 0 : strings.quote ?? "\"",
+		doubled: strings !== void 0 && strings.escape === "double",
+		words,
+		bare: refs.bare ?? "names",
+		roots,
+		fields: refs.fields ?? true,
+		patterns: (refs.patterns ?? []).map((p) => {
+			const flags = p.pattern.flags.replace(/[gy]/g, "");
+			return {
+				sticky: new RegExp(p.pattern.source, `${flags}y`),
+				whole: new RegExp(`^(?:${p.pattern.source})$`, flags),
+				read: p.read,
+				write: p.write
+			};
+		}),
+		ops: calls.ops === void 0 || calls.ops === true ? true : new Set(calls.ops === false ? [] : calls.ops),
+		forms,
+		formsByKind,
+		separator,
+		reserved: /* @__PURE__ */ new Set([
+			...words.keys(),
+			...ops.opWords,
+			...roots
+		]),
+		maxDepth: profile.maxDepth ?? 256
+	};
+	compiledProfiles.set(profile, compiled);
+	return compiled;
+}
+/** The stop of a parse. The parser throws it, and `parse` gives its issue. */
+var Stop = class {
+	issue;
+	constructor(issue) {
+		this.issue = issue;
+	}
+};
+function literalDoc(value) {
+	return encodeValue({}, value);
+}
+function opDoc(op, value) {
+	return {
+		type: op.type,
+		value
+	};
+}
+const ESCAPES = {
+	"\"": "\"",
+	"'": "'",
+	"\\": "\\",
+	"/": "/",
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	"
+};
+var Parser = class {
+	syn;
+	text;
+	pos = 0;
+	depth = 0;
+	constructor(syn, text) {
+		this.syn = syn;
+		this.text = text;
+	}
+	parse() {
+		this.skip();
+		if (this.pos >= this.text.length) this.stop("The text is empty.", 0, 0);
+		const doc = this.expr(0);
+		this.skip();
+		if (this.pos < this.text.length) this.stop("The text continues after the expression.", this.pos, this.tokenLength());
+		return doc;
+	}
+	position() {
+		return this.pos;
+	}
+	stop(message, offset, length) {
+		throw new Stop({
+			offset,
+			length,
+			message
+		});
+	}
+	skip() {
+		while (this.pos < this.text.length && /\s/.test(this.text[this.pos])) this.pos += 1;
+	}
+	at(pattern, pos = this.pos) {
+		pattern.lastIndex = pos;
+		return pattern.exec(this.text)?.[0];
+	}
+	tokenLength() {
+		return (this.at(NAME_AT) ?? this.at(DIGITS_AT) ?? "x").length;
+	}
+	/** This method reads an expression by precedence climbing. It stops at an operator below `min`. */
+	expr(min) {
+		const start = this.pos;
+		this.depth += 1;
+		if (this.depth > this.syn.maxDepth) this.stop(`The text is deeper than ${String(this.syn.maxDepth)} levels.`, start, 0);
+		let left = this.operand();
+		for (;;) {
+			this.skip();
+			const found = this.operatorAt();
+			if (found === void 0 || found.op.prec < min) break;
+			const op = found.op;
+			this.pos += found.length;
+			if (op.fixity === "postfix") {
+				left = opDoc(op, [left]);
+				continue;
+			}
+			if (op.assoc === "flat") {
+				const terms = [left, this.expr(op.prec + 1)];
+				for (;;) {
+					this.skip();
+					const next = this.operatorAt();
+					if (next === void 0 || next.op.fixity !== "infix" || next.op.kindKey !== op.kindKey) break;
+					this.pos += next.length;
+					terms.push(this.expr(op.prec + 1));
+				}
+				left = opDoc(op, terms);
+				continue;
+			}
+			left = opDoc(op, [left, this.expr(op.assoc === "right" ? op.prec : op.prec + 1)]);
+			if (op.assoc === "none") {
+				this.skip();
+				const next = this.operatorAt();
+				if (next !== void 0 && next.op.fixity === "infix" && next.op.prec === op.prec) this.stop(`The operator ${next.op.symbol} does not chain after ${op.symbol}. Add parentheses.`, this.pos, next.length);
+			}
+		}
+		this.depth -= 1;
+		return left;
+	}
+	/** This method finds an infix or a postfix operator at the position. */
+	operatorAt() {
+		const name = this.at(NAME_AT);
+		if (name !== void 0) {
+			const op = this.syn.binary.get(name);
+			return op !== void 0 && op.word ? {
+				op,
+				length: name.length
+			} : void 0;
+		}
+		for (const symbol of this.syn.binarySymbols) if (this.text.startsWith(symbol, this.pos)) return {
+			op: this.syn.binary.get(symbol),
+			length: symbol.length
+		};
+	}
+	operand() {
+		this.skip();
+		const start = this.pos;
+		const c = this.text[start];
+		if (c === void 0) return this.stop("A term is missing at the end of the text.", start, 0);
+		for (const pattern of this.syn.patterns) {
+			const match = this.at(pattern.sticky);
+			if (match !== void 0 && match !== "" && !/[A-Za-z0-9_$(]/.test(this.text[start + match.length] ?? "")) {
+				this.pos += match.length;
+				return {
+					type: "ref",
+					value: pattern.read(match)
+				};
+			}
+		}
+		if (/[0-9]/.test(c)) return this.number(false);
+		if (c === "-" && this.syn.signed && /[0-9]/.test(this.text[start + 1] ?? "")) return this.number(true);
+		if (c === this.syn.quote) return this.string();
+		if (c === "(") return this.group();
+		if (c === "`" || /[A-Za-z_]/.test(c)) return this.named();
+		for (const symbol of this.syn.prefixSymbols) if (this.text.startsWith(symbol, start)) {
+			this.pos += symbol.length;
+			const op = this.syn.prefix.get(symbol);
+			return opDoc(op, [this.expr(op.prec + 1)]);
+		}
+		if (c === ")" || this.text.startsWith(this.syn.separator, start)) return this.stop("A term is missing.", start, 0);
+		return this.stop(`The text "${c}" cannot start a term.`, start, 1);
+	}
+	number(negative) {
+		const start = this.pos;
+		if (!this.syn.numbers) this.stop("This syntax has no numbers.", start, this.tokenLength());
+		if (negative) this.pos += 1;
+		const digits = this.at(NUMBER_AT);
+		this.pos += digits.length;
+		const value = Number(digits);
+		return literalDoc(negative ? -value : value);
+	}
+	string() {
+		const start = this.pos;
+		const quote = this.syn.quote;
+		let out = "";
+		this.pos += 1;
+		for (;;) {
+			const c = this.text[this.pos];
+			if (c === void 0) return this.stop("A closing quote is missing.", start, this.text.length - start);
+			if (c === quote) {
+				if (this.syn.doubled && this.text[this.pos + 1] === quote) {
+					out += quote;
+					this.pos += 2;
+					continue;
+				}
+				this.pos += 1;
+				return literalDoc(out);
+			}
+			if (c === "\\" && !this.syn.doubled) {
+				out += this.escape();
+				continue;
+			}
+			out += c;
+			this.pos += 1;
+		}
+	}
+	escape() {
+		const start = this.pos;
+		const c = this.text[start + 1] ?? "";
+		if (c === "u") {
+			const hex = this.text.slice(start + 2, start + 6);
+			if (!/^[0-9A-Fa-f]{4}$/.test(hex)) return this.stop("The escape \\u needs four hex digits.", start, 2);
+			this.pos += 6;
+			return String.fromCharCode(Number.parseInt(hex, 16));
+		}
+		const out = Object.hasOwn(ESCAPES, c) ? ESCAPES[c] : void 0;
+		if (out === void 0) return this.stop(`The escape \\${c} is not valid.`, start, 2);
+		this.pos += 2;
+		return out;
+	}
+	group() {
+		const open = this.pos;
+		this.pos += 1;
+		const inner = this.expr(0);
+		this.skip();
+		if (this.text[this.pos] !== ")") {
+			if (this.pos >= this.text.length) this.stop("A closing parenthesis is missing.", open, 1);
+			this.stop("A closing parenthesis is missing.", this.pos, this.tokenLength());
+		}
+		this.pos += 1;
+		return inner;
+	}
+	/** This method reads a name in backticks. Two backticks in the name are one backtick. */
+	quoted() {
+		const start = this.pos;
+		let out = "";
+		this.pos += 1;
+		for (;;) {
+			const c = this.text[this.pos];
+			if (c === void 0) return this.stop("A closing backtick is missing.", start, this.text.length - start);
+			if (c === "`") {
+				if (this.text[this.pos + 1] !== "`") {
+					this.pos += 1;
+					return out;
+				}
+				this.pos += 1;
+			}
+			out += c;
+			this.pos += 1;
+		}
+	}
+	/** This method reads a name: a word operator, a call, a literal word or a reference. */
+	named() {
+		const start = this.pos;
+		const plain = this.text[start] !== "`";
+		const first = plain ? this.at(NAME_AT) : this.quoted();
+		if (plain) {
+			this.pos += first.length;
+			const prefix = this.syn.prefix.get(first);
+			if (prefix !== void 0 && prefix.word) return opDoc(prefix, [this.expr(prefix.prec + 1)]);
+			if (this.syn.binary.get(first)?.word === true) this.stop(`A term is missing before ${first}.`, start, first.length);
+		}
+		const path = [first];
+		let allPlain = plain;
+		for (;;) {
+			const back = this.pos;
+			this.skip();
+			if (!this.syn.fields || this.text[this.pos] !== ".") {
+				this.pos = back;
+				break;
+			}
+			this.pos += 1;
+			this.skip();
+			if (this.text[this.pos] === "`") {
+				path.push(this.quoted());
+				allPlain = false;
+				continue;
+			}
+			const name = this.at(NAME_AT);
+			const digits = name === void 0 ? this.at(DIGITS_AT) : void 0;
+			if (name === void 0 && digits === void 0) this.stop("A name is missing after the dot.", this.pos, 0);
+			this.pos += (name ?? digits).length;
+			path.push(name ?? Number(digits));
+			if (name === void 0) allPlain = false;
+		}
+		const back = this.pos;
+		this.skip();
+		if (this.text[this.pos] === "(") {
+			if (!allPlain) this.stop("The name of a call is a plain name.", start, back - start);
+			return this.call(path.join("."), start, back - start);
+		}
+		this.pos = back;
+		if (plain && path.length === 1 && this.syn.words.has(first)) return literalDoc(this.syn.words.get(first));
+		return {
+			type: "ref",
+			value: plain && this.syn.roots.has(first) ? path : [this.syn.bare, ...path]
+		};
+	}
+	call(name, start, nameLength) {
+		const open = this.pos;
+		const args = [];
+		this.pos += 1;
+		this.skip();
+		if (this.text[this.pos] === ")") this.pos += 1;
+		else for (;;) {
+			args.push(this.expr(0));
+			this.skip();
+			if (this.text.startsWith(this.syn.separator, this.pos)) {
+				this.pos += this.syn.separator.length;
+				continue;
+			}
+			if (this.text[this.pos] === ")") {
+				this.pos += 1;
+				break;
+			}
+			if (this.pos >= this.text.length) this.stop("A closing parenthesis is missing.", open, 1);
+			this.stop(`A "${this.syn.separator}" or a closing parenthesis is missing.`, this.pos, this.tokenLength());
+		}
+		const form = this.syn.forms.get(name);
+		if (form !== void 0) {
+			const most = form.fields?.length ?? Number.POSITIVE_INFINITY;
+			if (args.length < form.min || args.length > most) {
+				const range = most === form.min ? String(most) : most === Number.POSITIVE_INFINITY ? `${String(form.min)} or more` : `${String(form.min)} to ${String(most)}`;
+				this.stop(`The form ${name} takes ${range} arguments.`, start, this.pos - start);
+			}
+			if (form.fields === void 0) return opDoc(form, args);
+			const value = {};
+			args.forEach((arg, index) => {
+				value[form.fields?.[index]] = arg;
+			});
+			return opDoc(form, value);
+		}
+		if (this.syn.ops !== true && !this.syn.ops.has(name)) this.stop(`This syntax has no function ${name}.`, start, nameLength);
+		return {
+			type: ["ops", ...name.split(".")],
+			value: args
+		};
+	}
+};
+/**
+* This function reads a text into a document with the rules of a profile (SYNTAX.PARSE). It does not throw for a
+* bad text. The issue gives the offset, the length and a message (SYNTAX.SPAN).
+*
+* @param profile - The syntax profile.
+* @param text - The text.
+* @returns The document, or the issues of the text.
+* @throws {TypeError} The profile is not valid, for example an operator has two entries of the same place.
+*/
+function parse(profile, text) {
+	const parser = new Parser(compileProfile(profile), text);
+	try {
+		return {
+			ok: true,
+			doc: parser.parse()
+		};
+	} catch (error) {
+		if (error instanceof Stop) return {
+			ok: false,
+			issues: [error.issue]
+		};
+		if (isStackOverflow(error)) return {
+			ok: false,
+			issues: [{
+				offset: parser.position(),
+				length: 0,
+				message: "The text is too deep for the stack of the host."
+			}]
+		};
+		throw error;
+	}
+}
+function none(reason) {
+	return {
+		tag: "none",
+		reason
+	};
+}
+function quoteName(name) {
+	return `\`${name.replaceAll("`", "``")}\``;
+}
+function wordFor(syn, value) {
+	for (const [word, held] of syn.words) if (Object.is(held, value)) return word;
+}
+function textOfString(syn, value) {
+	const quote = syn.quote;
+	if (quote === void 0) return void 0;
+	if (syn.doubled) return `${quote}${value.replaceAll(quote, quote + quote)}${quote}`;
+	const json = JSON.stringify(value);
+	return quote === "\"" ? json : `'${json.slice(1, -1).replaceAll("\\\"", "\"").replaceAll("'", "\\'")}'`;
+}
+function textOfNumber(syn, value) {
+	if (!syn.numbers) return wordFor(syn, value);
+	const negative = value < 0 || Object.is(value, -0);
+	if (negative && !syn.signed) return wordFor(syn, value);
+	if (Number.isFinite(value)) return negative ? `-${String(-value)}` : String(value);
+	return wordFor(syn, value) ?? (Number.isNaN(value) ? void 0 : negative ? "-1e999" : "1e999");
+}
+function literalShape(syn, value) {
+	const text = typeof value === "string" ? textOfString(syn, value) : typeof value === "number" ? textOfNumber(syn, value) : wordFor(syn, value);
+	return text === void 0 ? none(`This syntax has no text for the literal ${describe(value)}.`) : {
+		tag: "text",
+		text
+	};
+}
+function plainSegment(syn, name) {
+	return NAME.test(name) && !syn.reserved.has(name) && !syn.patterns.some((p) => p.whole.test(name));
+}
+function laterSegment(step) {
+	if (typeof step === "string") return NAME.test(step) ? step : quoteName(step);
+	return typeof step === "number" && Number.isSafeInteger(step) && step >= 0 ? String(step) : void 0;
+}
+function refShape(syn, value) {
+	if (!Array.isArray(value) || value.length === 0) return none("The path of the reference is empty.");
+	for (const pattern of syn.patterns) {
+		const text = pattern.write(value);
+		if (text !== void 0) return {
+			tag: "text",
+			text
+		};
+	}
+	const [root, ...rest] = value;
+	if ((rest.length > 1 || root !== syn.bare && rest.length > 0) && !syn.fields) return none("This syntax has no field steps.");
+	const later = rest.slice(1).map(laterSegment);
+	let first;
+	let tail = later;
+	if (root === syn.bare && typeof rest[0] === "string") first = plainSegment(syn, rest[0]) ? rest[0] : quoteName(rest[0]);
+	else if (typeof root === "string" && syn.roots.has(root) && !syn.patterns.some((p) => p.whole.test(root))) {
+		first = root;
+		tail = rest.map(laterSegment);
+	}
+	if (first === void 0 || tail.includes(void 0)) return none("This syntax has no text for the path of the reference.");
+	return {
+		tag: "text",
+		text: [first, ...tail].join(".")
+	};
+}
+function callName(syn, keys) {
+	if (keys.length === 0 || !keys.every((key) => typeof key === "string" && NAME.test(key))) return void 0;
+	const name = keys.join(".");
+	if (syn.forms.has(name) || syn.opWords.has(keys[0])) return void 0;
+	return syn.ops === true || syn.ops.has(name) ? name : void 0;
+}
+function formShape(form, value) {
+	if (form.fields === void 0) {
+		if (!Array.isArray(value) || value.length < form.min) return void 0;
+		return {
+			tag: "call",
+			name: form.name,
+			args: value.map((item, index) => [index, item])
+		};
+	}
+	if (!isRecord(value)) return void 0;
+	const count = Object.keys(value).length;
+	const present = form.fields.slice(0, count);
+	if (count < form.min || present.length < count || !present.every((key) => Object.hasOwn(value, key))) return void 0;
+	return {
+		tag: "call",
+		name: form.name,
+		args: present.map((key) => [key, value[key]])
+	};
+}
+function opShape(syn, key, terms) {
+	for (const op of syn.byKind.get(key) ?? []) if (op.fixity === "infix" ? terms.length === 2 || op.assoc === "flat" && terms.length > 2 : terms.length === 1) return {
+		tag: "op",
+		op,
+		terms
+	};
+}
+/** This function gives the shape of a document: a literal or a reference, an operator, a call, or no text. */
+function shapeOf(syn, doc) {
+	if (!isEnvelope(doc)) return Array.isArray(doc) || isRecord(doc) ? none("This syntax has no text for a list or a record literal.") : literalShape(syn, doc);
+	if (doc.name !== void 0 || doc.own !== void 0) return none("This syntax has no text for the header of a document.");
+	const path = typePath(doc.type);
+	if (path === void 0) return none("This syntax has no text for a computed type.");
+	const value = doc.value;
+	const name = path.join(".");
+	if (name === "lit") return isEnvelope(value) || Array.isArray(value) || isRecord(value) ? none("This syntax has no text for a list or a record literal.") : literalShape(syn, value);
+	if (name === "ext.undefined") return literalShape(syn, void 0);
+	if (name === "ext.number") {
+		const numbers = {
+			NaN: NaN,
+			Infinity: Number.POSITIVE_INFINITY,
+			"-Infinity": Number.NEGATIVE_INFINITY,
+			"-0": -0
+		};
+		return typeof value === "string" && Object.hasOwn(numbers, value) ? literalShape(syn, numbers[value]) : none("The value of ext.number is not valid.");
+	}
+	if (name === "ref") return refShape(syn, value);
+	const key = JSON.stringify(path);
+	const op = Array.isArray(value) ? opShape(syn, key, value) : void 0;
+	if (op !== void 0) return op;
+	for (const form of syn.formsByKind.get(key) ?? []) {
+		const shape = formShape(form, value);
+		if (shape !== void 0) return shape;
+	}
+	const called = path[0] === "ops" && Array.isArray(value) ? callName(syn, path.slice(1)) : void 0;
+	if (called !== void 0) return {
+		tag: "call",
+		name: called,
+		args: value.map((item, index) => [index, item])
+	};
+	return none(`This syntax has no text for the kind ${name}.`);
+}
+function levelOf(syn, doc) {
+	const shape = shapeOf(syn, doc);
+	return shape.tag === "op" ? shape.op.prec : Number.POSITIVE_INFINITY;
+}
+/** This function tells if a term needs parentheses in its position, so that `parse` reads the same tree. */
+function needsGroup(op, index, level) {
+	if (op.fixity === "postfix") return level < op.prec;
+	if (op.fixity === "prefix" || op.assoc === "none" || op.assoc === "flat") return level <= op.prec;
+	return (op.assoc === "left" ? index === 0 : index !== 0) ? level < op.prec : level <= op.prec;
+}
+function opText(syn, op, terms, sub) {
+	const texts = [];
+	for (let index = 0; index < terms.length; index += 1) {
+		const term = terms[index];
+		const result = sub(term, [index]);
+		if (!result.ok) return result;
+		let text = result.value;
+		const signedDigit = op.fixity === "prefix" && op.symbol === "-" && syn.signed && /^[0-9]/.test(text);
+		if (needsGroup(op, index, levelOf(syn, term)) || signedDigit) text = `(${text})`;
+		texts.push(text);
+	}
+	const [only = ""] = texts;
+	if (op.fixity === "prefix") return ok(op.word || /^[^A-Za-z0-9_("'`$]/.test(only) ? `${op.symbol} ${only}` : `${op.symbol}${only}`);
+	if (op.fixity === "postfix") return ok(op.word ? `${only} ${op.symbol}` : `${only}${op.symbol}`);
+	return ok(texts.join(` ${op.symbol} `));
+}
+/** This function writes one document. `sub` gives the text of each part. */
+function printNode(syn, doc, sub) {
+	const shape = shapeOf(syn, doc);
+	if (shape.tag === "text") return ok(shape.text);
+	if (shape.tag === "none") return fail("#VALUE!", shape.reason);
+	if (shape.tag === "op") return opText(syn, shape.op, shape.terms, sub);
+	const texts = [];
+	for (const [key, arg] of shape.args) {
+		const result = sub(arg, [key]);
+		if (!result.ok) return result;
+		texts.push(result.value);
+	}
+	return ok(`${shape.name}(${texts.join(`${syn.separator} `)})`);
+}
+function printTree(syn, doc, place) {
+	const result = printNode(syn, doc, (child, path) => printTree(syn, child, [...place, ...path]));
+	return result.ok || result.error.place !== void 0 ? result : fail(result.error.code, result.error.reason, { place });
+}
+/**
+* This function writes a document as text with the rules of a profile (SYNTAX.PRINT). It writes the fewest
+* parentheses that keep the tree. `parse` reads the text back to the same document (SYNTAX.ROUNDTRIP).
+*
+* @param profile - The syntax profile.
+* @param doc - The document.
+* @returns The text, or `#VALUE!` at the place of a document that the profile cannot write.
+* @throws {TypeError} The profile is not valid.
+*/
+function print(profile, doc) {
+	const syn = compileProfile(profile);
+	try {
+		return printTree(syn, doc, []);
+	} catch (error) {
+		if (isStackOverflow(error)) return fail("#DEPTH!", "The document is too deep for the stack of the host.", { cause: error });
+		throw error;
+	}
+}
+/**
+* This function makes the part of a merge that adds the verb `format` to a machine (D23, D41). Its default writes
+* each document with the printer of the profile. A part gives its own text through the ladder, thus an own entry or
+* a kind entry of `format` still wins.
+*
+* @param profile - The syntax profile.
+* @returns The part for `mergeMachines`.
+*/
+function syntaxFormat(profile) {
+	const syn = compileProfile(profile);
+	const code = ({ doc, parts, place }) => {
+		const byPath = new Map(parts.map((part) => [JSON.stringify(part.path), part]));
+		return printNode(syn, doc, (child, path) => {
+			const part = byPath.get(JSON.stringify(path));
+			if (part === void 0) return printTree(syn, child, [...place, ...path]);
+			const result = part.evaluate();
+			if (!result.ok) return result;
+			return typeof result.value === "string" ? ok(result.value) : fail("#VALUE!", `The verb format of a part gave ${describe(result.value)}, not a text.`, { place: [...place, ...path] });
+		});
+	};
+	return {
+		world: { defaults: { format: "syntax.format" } },
+		evaluators: { "syntax.format": code }
+	};
+}
+//#endregion
 //#region src/reference.ts
 function own$1(table, name) {
 	return table !== void 0 && Object.hasOwn(table, name) ? table[name] : void 0;
@@ -7008,6 +8016,7 @@ function evalInput(env, seen, at) {
 		parts,
 		context: at.ctx,
 		place: at.place,
+		machine: env.machine,
 		...at.address ? { address: true } : {},
 		resolve: (path, options) => resolveFully(env.machine, at.ctx, path, options),
 		effect: (kind, payload) => cause(env, at.ctx, kind, payload, at.place),
@@ -7035,6 +8044,7 @@ function runInput(env, seen, at) {
 		parts,
 		context: at.ctx,
 		place: at.place,
+		machine: env.machine,
 		resolve: (path, options) => resolveFully(env.machine, at.ctx, path, options),
 		effect: function* (kind, payload) {
 			return cause(env, at.ctx, kind, payload, at.place);
@@ -7437,12 +8447,12 @@ function formulaDefinitions(profile = {}) {
 			return thrown(error, `the operation ${name}`);
 		}
 	};
-	const ext = ({ typePath, doc, context }) => {
+	const ext = ({ typePath, doc, context, machine }) => {
 		const name = typePath.slice(1).join(".");
 		const handler = own$1(profile.ext, name) ?? own$1(STD_EXT, name);
 		if (handler === void 0) return fail("#NAME?", `The language has no extension ${name}.`);
 		try {
-			return handler(doc.value, context);
+			return handler(doc.value, context, machine?.domains);
 		} catch (error) {
 			return thrown(error, `the extension ${name}`);
 		}
@@ -8633,6 +9643,7 @@ function instanceOf(env, under, doc, split, sample) {
 		doc,
 		data: split.data,
 		place: PLACE,
+		machine: env.machine,
 		fill
 	};
 	const who = `the ${env.runner ? "runner" : "evaluator"} ${env.name}`;
@@ -10244,6 +11255,6 @@ function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
 //#endregion
-export { 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_WALKERS, STD_WORLD, THING, agree, ask, capKeys, check, checkLatent, checkSteps, classify, components, conforms, context, cycles, dataEdges, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, entriesAsJson, 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, partCaps, partsOf, pathMatches, permits, placed, planner, prepare, random, recorder, ref, reference, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stored, tag, thrown, toJson, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+export { 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, capKeys, check, checkLatent, checkSteps, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, encodeValue, entriesAsJson, 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