@mark1russell7/coeval 0.24.0 → 0.24.1

package/build/index.js

@@ -1568,7 +1568,7 @@ const MAX_TEXT_VALUES = 8;
 /** The most characters of one JSON value in the text of a type. */
 const MAX_TEXT_VALUE = 40;
 /** This function gives a short text of a JSON value for the text of a type. */
-function valueText$1(value) {
+function valueText$2(value) {
 	let text;
 	try {
 		text = JSON.stringify(value) ?? String(value);
@@ -1590,7 +1590,7 @@ function textAt(type, depth, wrap) {
 	if (term === "one") {
 		if (!Array.isArray(type["one"])) return "unknown";
 		const values = type["one"];
-		const shown = values.slice(0, MAX_TEXT_VALUES).map(valueText$1);
+		const shown = values.slice(0, MAX_TEXT_VALUES).map(valueText$2);
 		return group(values.length > MAX_TEXT_VALUES ? [...shown, `… ${values.length - MAX_TEXT_VALUES} more`] : shown);
 	}
 	if (term === "fn") {
@@ -4812,7 +4812,8 @@ function compileNode(c, value, place, declared, depth, address = false) {
 		} catch (error) {
 			return failingWith(c, meta, placed(thrown(error, `the runner ${name}`), place));
 		}
-		const run = placedRun(inner, place, name);
+		const guard = guardOf(c, place);
+		const run = placedRun(guard === void 0 ? inner : guardRun(inner, guard, c.machine.domains), place, name);
 		return finish$1(c, meta, runnerCode(run, place, kindText), run);
 	}
 	let inner;
@@ -4821,7 +4822,8 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	} catch (error) {
 		return failingWith(c, meta, placed(thrown(error, `the evaluator ${name}`), place));
 	}
-	const done = finish$1(c, meta, TOTAL.has(inner) ? inner : placedCode(inner, place, name), void 0);
+	const guard = guardOf(c, place);
+	const done = finish$1(c, meta, guard !== void 0 ? placedCode(guardCode(inner, guard, c.machine.domains), place, name) : TOTAL.has(inner) ? inner : placedCode(inner, place, name), void 0);
 	if (frees === void 0 || kind === void 0 || !pureCode(c, envelope, kind, typePath, name, quick)) return done;
 	const free = freeOf(doc, kind, split.parts, frees);
 	if (free === void 0) return done;
@@ -5217,6 +5219,29 @@ function gated(rules, part) {
 * This function gives the steps of a runner, with the place of each error and of each exception. The steps get the
 * context that its grant permits (CAP.NARROW-CODE).
 */
+/** This function gives the key of a place in the guards of a plan. */
+function guardKey(place) {
+	return JSON.stringify(place.map(String));
+}
+/** This function gives the type of the boundary at a place, when the plan has one (PLAN.GUARD). */
+function guardOf(c, place) {
+	return c.guards?.get(guardKey(place));
+}
+/** This function gives the result of a part of a boundary: a value that is not a member gives `#VALUE!` (PLAN.GUARD). */
+function guarded(result, type, domains) {
+	if (!result.ok || member(result.value, type, domains)) return result;
+	return fail("#VALUE!", `The value is not a member of ${typeText(type)}, the type of its boundary.`);
+}
+/** This function adds the test of a boundary to the code of a part. */
+function guardCode(inner, type, domains) {
+	return (ctx, rt) => guarded(inner(ctx, rt), type, domains);
+}
+/** This function adds the test of a boundary to the steps of a part. */
+function guardRun(inner, type, domains) {
+	return function* (ctx, rt) {
+		return guarded(yield* inner(ctx, rt), type, domains);
+	};
+}
 function placedRun(inner, place, name) {
 	return function* (ctx, rt) {
 		try {
@@ -5417,6 +5442,7 @@ function prepare(machine, doc, options = {}) {
 	const traced = options.trace === true;
 	const fold = !traced && options.fold !== false;
 	const fixed = fold ? fixedNamesOf(options.fixed?.names) : void 0;
+	const guards = options.guards === void 0 || options.guards.length === 0 ? void 0 : new Map(options.guards.map((each) => [guardKey(each.place), each.type]));
 	const c = {
 		machine,
 		traced,
@@ -5424,7 +5450,8 @@ function prepare(machine, doc, options = {}) {
 		verb,
 		noAnswer,
 		fold,
-		fixed
+		fixed,
+		guards
 	};
 	let root;
 	try {
@@ -5537,7 +5564,8 @@ function evaluate(machine, doc, context = makeContext(), options) {
 	const plan = prepare(machine, doc, {
 		trace: true,
 		...declaredType === void 0 ? {} : { declaredType },
-		...given.verb === void 0 ? {} : { verb: given.verb }
+		...given.verb === void 0 ? {} : { verb: given.verb },
+		...given.guards === void 0 ? {} : { guards: given.guards }
 	});
 	const ctx = rootContext(machine, context);
 	const s = new Session(machine, ctx.caps, false, true, given.perform, void 0, void 0, readingOf(given.reads, ctx));
@@ -5558,6 +5586,7 @@ async function run(machine, doc, context = makeContext(), options = {}) {
 	const plan = prepare(machine, doc, {
 		trace: true,
 		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType },
+		...options.guards === void 0 ? {} : { guards: options.guards },
 		...options.verb === void 0 ? {} : { verb: options.verb }
 	});
 	const ctx = rootContext(machine, context);
@@ -5928,7 +5957,8 @@ const STD_WORLD = {
 * A literal in a place that takes a document gets its data envelope (K159, D65). Such a place is a part of `if`,
 * `list`, `seq` or `pure`, the value of `write`, or the whole text. The document after a header name is such a place
 * too. Thus `list(1, "a")` evaluates to `[1, "a"]`. The forms `add`, `multiply` and `greater` write an operator document that its operator
-* does not write, for example `add(5)` (K163).
+* does not write, for example `add(5)` (K163). The field `with` of `handle` is a field of data, thus each clause is a
+* record between braces in a list between brackets (D177).
 *
 * A host with more kinds spreads this profile and adds its forms to `calls.forms`. `STD_SYNTAX` stays the profile of
 * the formula kit.
@@ -6068,6 +6098,18 @@ const WORLD_SYNTAX = /* @__PURE__ */ Object.freeze({
 				kind: "tree.quote",
 				args: "literal"
 			},
+			{
+				name: "handle",
+				kind: "handle",
+				args: "named",
+				fields: [
+					"with",
+					"return",
+					"body"
+				],
+				data: ["with"],
+				wrap: ["return", "body"]
+			},
 			{
 				name: "add",
 				kind: "add"
@@ -6524,6 +6566,7 @@ function leaderOnHost(n, key, rule, host) {
 /**
 * This function gives an attribute of a node with circular attributes, or an attribute in an open fixed point (D113).
 * The memo and the marks of the node do not hold the attribute. An open fixed point does not use the cells of the host.
+* With the cells of a host, only a circular attribute comes here outside a fixed point. A plain attribute takes its cell.
 */
 function circularRead(n, key) {
 	const rule = circularRule(n.tree, key);
@@ -6938,7 +6981,7 @@ function treeThing(input, place, build, outer, host) {
 		const text = attributeText(key, type, place);
 		if (marks.has(key)) return busyAt(state, key);
 		if (tree === void 0 && up?.tree === void 0 && !parts.some((item) => item.key === key)) return void 0;
-		if (circular || openPoint !== void 0) return circularRead(state, key);
+		if (openPoint !== void 0 || circular && circularRule(tree, key) !== void 0) return circularRead(state, key);
 		marks.set(key, BUSY);
 		demands.push({
 			cells: marks,
@@ -7270,6 +7313,26 @@ function isOp(value) {
 	return typeof value === "string" || Array.isArray(value) && value.every(isKey);
 }
 /**
+* This function gives the runner of an `if` with its own truth (RUN.IF-TRUTH). A branch can wait for the host, thus a
+* language with the function `truthy` of a profile does not need a copy of `if`. A missing test and a test without a
+* truth give `#VALUE!`, a failed test gives its failure, and a missing branch gives `null`.
+*
+* @param truth - The function that gives the truth of a value, or `undefined` for a value without a truth.
+* @returns The runner.
+*/
+function ifRunner(truth) {
+	return function* ({ parts }) {
+		const test = parts.find((part) => part.key === "test");
+		if (test === void 0) return fail("#VALUE!", "if needs a test.");
+		const chosen = yield* test.evaluate();
+		if (!chosen.ok) return chosen;
+		const held = truth(chosen.value);
+		if (held === void 0) return fail("#VALUE!", "The test of if must give a truth value.");
+		const branch = parts.find((part) => part.key === (held ? "then" : "else"));
+		return branch === void 0 ? ok(null) : yield* branch.evaluate();
+	};
+}
+/**
 * The runners of the standard world, by name: the kinds that can hold effects. Each one evaluates its parts in
 * order. In a run, an effect ends before the next step starts.
 */
@@ -7337,15 +7400,7 @@ const STD_RUNNERS = {
 			}
 		});
 	},
-	"control.if": function* ({ parts }) {
-		const test = parts.find((part) => part.key === "test");
-		if (test === void 0) return fail("#VALUE!", "if needs a test.");
-		const chosen = yield* test.evaluate();
-		if (!chosen.ok) return chosen;
-		if (typeof chosen.value !== "boolean") return fail("#VALUE!", "The test of if must give a truth value.");
-		const branch = parts.find((part) => part.key === (chosen.value === true ? "then" : "else"));
-		return branch === void 0 ? ok(null) : yield* branch.evaluate();
-	},
+	"control.if": /* @__PURE__ */ ifRunner((value) => typeof value === "boolean" ? value : void 0),
 	"list.all": function* ({ parts }) {
 		const all = yield* inOrder(parts);
 		return "error" in all ? all.error : ok(all.values);
@@ -7768,6 +7823,26 @@ const CONSTRUCTS = [
 * narrows the capabilities for each part, thus the host does not give this type.
 */
 const CAPS_TYPE = { list: { union: ["text", { list: { union: ["text", "number"] } }] } };
+/**
+* This function gives the boundaries of a check. A part with an imprecise type at a position that needs a type is a
+* boundary. A read of a known type is a boundary too, because the check trusts the root types (PLAN.GUARD-BOUNDARY).
+*
+* @param typing - The places of a check of types.
+* @param domains - The domains of the machine.
+* @returns The boundaries, in the order of the document.
+*/
+function boundariesOf(typing, domains) {
+	const found = [];
+	for (const item of typing.places) if (item.expected !== void 0 && item.expected !== "unknown" && !isPrecise(item.type, domains)) found.push({
+		place: item.place,
+		type: item.expected
+	});
+	else if (item.read === true && item.type !== "unknown") found.push({
+		place: item.place,
+		type: item.type
+	});
+	return found;
+}
 /** The roots that can change, as a rule gives them in `PartType.roots`. */
 const CHANGING = [
 	"self",
@@ -7787,7 +7862,7 @@ function pathKey(path) {
 function ruleOf(machine, name) {
 	if (name === void 0 || machine.runners !== void 0 && Object.hasOwn(machine.runners, name)) return void 0;
 	const evaluator = Object.hasOwn(machine.evaluators, name) ? machine.evaluators[name] : void 0;
-	const rule = typeof evaluator === "object" && evaluator !== null ? evaluator.type : void 0;
+	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`. */
@@ -7968,9 +8043,11 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 	}
 	const places = nodes.map((node, index) => {
 		const want = needed[index];
+		const read = !node.marked && ruleOf(machine, node.evaluator)?.read === true;
 		const entry = {
 			type: types[index] ?? "unknown",
-			...want === void 0 ? {} : { expected: want }
+			...want === void 0 ? {} : { expected: want },
+			...read ? { read } : {}
 		};
 		Object.defineProperty(entry, "place", {
 			enumerable: true,
@@ -9482,11 +9559,13 @@ function walk(world, doc, visit, options = {}) {
 			continue;
 		}
 		const { sees, later } = scopesOf(kind.scope, doc.value, split.parts);
+		const grantRules = kind.caps !== void 0 && kind.caps.some((rule) => rule.rule === "grant") ? kind.caps : void 0;
 		for (let index = split.parts.length - 1; index >= 0; index -= 1) {
 			const slot = split.parts[index];
 			const extra = sees[index] ?? [];
 			const hidden = later[index] ?? [];
-			const grants = partGrants(kind.caps, slot.path, doc.value);
+			const grants = grantRules === void 0 ? void 0 : partGrants(grantRules, slot.path, doc.value);
+			const granted = grants !== void 0 && grants.length > 0 ? grants : void 0;
 			stack.push({
 				value: slot.item,
 				place: slot.path.length === 0 ? item.place : {
@@ -9504,8 +9583,8 @@ function walk(world, doc, visit, options = {}) {
 				address: slot.address === true,
 				slot: slot.path,
 				parent: here,
-				caps: item.caps === void 0 || kind.caps === void 0 ? item.caps : [...partCaps(kind.caps, slot.path, item.caps), ...grants],
-				handled: grants.length === 0 ? item.handled : [...item.handled ?? [], ...grants],
+				caps: item.caps === void 0 || kind.caps === void 0 ? item.caps : granted === void 0 ? partCaps(kind.caps, slot.path, item.caps) : [...partCaps(kind.caps, slot.path, item.caps), ...granted],
+				handled: granted === void 0 ? item.handled : [...item.handled ?? [], ...granted],
 				bound: extra,
 				expect: slot.expect
 			});
@@ -9595,6 +9674,28 @@ function mapRefs(world, doc, change, options = {}) {
 	return out;
 }
 /**
+* This function changes the documents of a document, from the root to the parts (STATIC.MAPDOCS). The function
+* `change` reads only the original documents. It decides at each node, and it can stop at a node. The kinds of a
+* position come from the world, thus this function names no kind. The document is not changed: the function gives a
+* new document that shares each part without a change.
+*
+* @param world - The world of the kinds.
+* @param doc - The document, as JSON.
+* @param change - The function that gives the answer for each visit. See `DocChange`.
+* @param options - The type of a bare root value, and the names that the host binds at the root.
+* @returns The new document, or `doc` itself when no document changes.
+*/
+function mapDocs(world, doc, change, options = {}) {
+	let out = doc;
+	walk(world, doc, (visit) => {
+		const next = change(visit);
+		if (next === void 0 || next === "skip") return next;
+		out = setAt(out, visit.at, next.to);
+		return next.into === true ? void 0 : "skip";
+	}, options);
+	return out;
+}
+/**
 * This function gives the parts that the code of a runner evaluates itself, without a wait (RUN.DRIVES, D119). The
 * answer of the hook `facts` for the code wins over the contract. The contract describes only the code of its kind for
 * `eval`. Without a declaration, the runner passes each wait of its parts through.
@@ -11161,39 +11262,42 @@ function formulaTypes(profile) {
 	});
 	return {
 		"formula.lit": { synth: (input) => valueType(input.doc.value) },
-		"formula.ref": { synth: (input, report) => {
-			const path = input.doc.value;
-			if (input.address || !Array.isArray(path) || path.length === 0) return "unknown";
-			const domains = input.machine.domains;
-			const plain = input.machine.plain === true;
-			let type;
-			let start;
-			if (path[0] === "names") {
-				const name = path[1];
-				if (!isKey(name) || !plain && HEADER_KEYS.has(String(name))) return "unknown";
-				type = input.nameType(String(name)) ?? "unknown";
-				start = 2;
-			} else {
-				type = input.rootType(String(path[0]));
-				start = 1;
-			}
-			for (let index = start;; index += 1) {
-				if (isUnknown(type, domains) || !plain && holdsEnvelope(type, domains)) return "unknown";
-				if (index >= path.length) return type;
-				const step = path[index];
-				if (!isKey(step)) {
-					type = walkType(input, step, type);
-					continue;
+		"formula.ref": {
+			read: true,
+			synth: (input, report) => {
+				const path = input.doc.value;
+				if (input.address || !Array.isArray(path) || path.length === 0) return "unknown";
+				const domains = input.machine.domains;
+				const plain = input.machine.plain === true;
+				let type;
+				let start;
+				if (path[0] === "names") {
+					const name = path[1];
+					if (!isKey(name) || !plain && HEADER_KEYS.has(String(name))) return "unknown";
+					type = input.nameType(String(name)) ?? "unknown";
+					start = 2;
+				} else {
+					type = input.rootType(String(path[0]));
+					start = 1;
 				}
-				const next = stepType(type, step, domains, input.contract);
-				if ("missing" in next) {
-					const fields = next.missing.length === 0 ? "" : ` Its fields are ${listText(next.missing)}.`;
-					report({ reason: `The value at ${path.slice(0, index).map(stepText).join(".")} has no field ${String(step)}.${fields}` });
-					return "unknown";
+				for (let index = start;; index += 1) {
+					if (isUnknown(type, domains) || !plain && holdsEnvelope(type, domains)) return "unknown";
+					if (index >= path.length) return type;
+					const step = path[index];
+					if (!isKey(step)) {
+						type = walkType(input, step, type);
+						continue;
+					}
+					const next = stepType(type, step, domains, input.contract);
+					if ("missing" in next) {
+						const fields = next.missing.length === 0 ? "" : ` Its fields are ${listText(next.missing)}.`;
+						report({ reason: `The value at ${path.slice(0, index).map(stepText).join(".")} has no field ${String(step)}.${fields}` });
+						return "unknown";
+					}
+					type = next.type;
 				}
-				type = next.type;
 			}
-		} },
+		},
 		"formula.record": {
 			part: (input, path) => {
 				const want = fieldOf(input.expected, String(path[0]), input.machine.domains);
@@ -14702,6 +14806,14 @@ function readsUnknown(reads) {
 function resolutions(reads) {
 	return reads.filter((read) => read.free && read.kept !== true);
 }
+/** This function gives the text of a value of a trace. It does not throw for a bigint or a record with a cycle. */
+function valueText$1(value) {
+	try {
+		return JSON.stringify(value) ?? describe(value);
+	} catch {
+		return describe(value);
+	}
+}
 function pathText(path) {
 	if (path === void 0) return "no read";
 	try {
@@ -14857,6 +14969,96 @@ async function agreeRun(machine, doc, context = makeContext(), options = {}) {
 		reads: compared
 	};
 }
+/** The type errors of the kernel, by the evaluator that gives them (STATIC.TYPES-AGREE). */
+const TYPE_ERRORS = {
+	"formula.op": "#NAME?",
+	"formula.if": "#VALUE!",
+	"formula.and": "#VALUE!",
+	"formula.or": "#VALUE!"
+};
+/**
+* This function examines the agreement rule for types (STATIC.TYPES-AGREE, D148). A document with no issue evaluates
+* with a trace. Each value of the trace is a member of the type of its place. A value of a precise type is also a member
+* of the type that its position needs. No document with precise parts gives a type error of the kernel.
+*
+* A language imports this function for its own property tests, with `agree`. A failure tells that a signature, a type
+* rule, a cover or a root type does not hold. A value that breaks a position of an imprecise type ends the promise, and
+* the result then has `checked: false` (TYPE.GRADUAL).
+*
+* @param machine - The world and the code of the evaluators, with their type rules.
+* @param doc - The document.
+* @param context - The context. Its roots are members of the root types.
+* @param options - The options of `check`, with the root types, and `guards`.
+* @returns The agreement, or the first place that breaks it.
+*/
+function agreeTypes(machine, doc, context = makeContext(), options = {}) {
+	const typing = typeCheck(machine, doc, options);
+	if (typing.issues.length > 0) return {
+		ok: true,
+		checked: false,
+		values: 0
+	};
+	const keyOf = (path) => JSON.stringify(path.map(String));
+	const places = new Map(typing.places.map((item) => [keyOf(item.place), item]));
+	const domains = machine.domains;
+	const guards = options.guards === true ? boundariesOf(typing, domains) : void 0;
+	const stack = [evaluate(machine, doc, context, {
+		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType },
+		...guards === void 0 ? {} : { guards }
+	}).trace];
+	const nodes = [];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		nodes.push(node);
+		stack.push(...node.children);
+	}
+	for (const node of nodes) {
+		const place = places.get(keyOf(node.path));
+		if (place?.expected === void 0 || !node.result.ok || isPrecise(place.type, domains)) continue;
+		if (!member(node.result.value, place.expected, domains)) return {
+			ok: true,
+			checked: false,
+			values: 0
+		};
+	}
+	let values = 0;
+	for (const node of nodes.reverse()) {
+		const place = places.get(keyOf(node.path));
+		if (place === void 0) continue;
+		const at = node.path.map(String);
+		if (!node.result.ok) {
+			const parts = node.children.map((child) => places.get(keyOf(child.path)));
+			const decided = node.children.every((child) => child.result.ok) && parts.every((part) => part?.expected !== void 0 && isPrecise(part.type, domains));
+			const code = TYPE_ERRORS[node.answer.evaluator ?? ""];
+			if (decided && node.result.error.code === code) return {
+				ok: false,
+				clause: "error",
+				place: at,
+				reason: `The document gives ${code}, but it checks with no issue.`
+			};
+			continue;
+		}
+		const value = node.result.value;
+		values += 1;
+		if (!member(value, place.type, domains)) return {
+			ok: false,
+			clause: "value",
+			place: at,
+			reason: `The value ${valueText$1(value)} is not a member of ${typeText(place.type)}.`
+		};
+		if (place.expected !== void 0 && !member(value, place.expected, domains)) return {
+			ok: false,
+			clause: "argument",
+			place: at,
+			reason: `The value ${valueText$1(value)} is not a member of the needed type ${typeText(place.expected)}.`
+		};
+	}
+	return {
+		ok: true,
+		checked: true,
+		values
+	};
+}
 // src/codec-laws.ts
 /** The order of the laws in the list of findings. */
 const ORDER$1 = [
@@ -15280,6 +15482,13 @@ function compileConstructs(given, ops) {
 		constructKinds
 	};
 }
+/** This function examines the field `domain` of a call form (D141). A form `literal` of `ext.domain` needs a name, and each other form refuses it. */
+function compileDomain(given, args) {
+	const writes = args === "literal" && given.kind === "ext.domain";
+	if (writes && (typeof given.domain !== "string" || given.domain === "")) throw new TypeError(`The call form "${given.name}" of ext.domain needs the name of its domain.`);
+	if (!writes && given.domain !== void 0) throw new TypeError(`The call form "${given.name}" takes no domain: only a form literal of ext.domain has one.`);
+	return given.domain;
+}
 /** This function examines the field `wrap` of a call form (K159). A name that is not a field of the form throws. */
 function compileWrap(given, args) {
 	const wrap = given.wrap;
@@ -15291,6 +15500,16 @@ function compileWrap(given, args) {
 	return new Set(wrap);
 }
 /** This function gives the types of the data envelopes of a profile (K159), or `undefined` without them. */
+/** This function examines the field `data` of a call form (D177). Each name is a field of the form, and no name is in `wrap`. */
+function compileData(given, wrap) {
+	const data = given.data ?? [];
+	if (data.length > 0 && given.fields === void 0) throw new TypeError(`The call form "${given.name}" takes data only with fields.`);
+	for (const name of data) {
+		if (given.fields?.includes(name) !== true) throw new TypeError(`The call form "${given.name}" has no field ${name} for its data.`);
+		if (wrap === true || wrap !== false && wrap.has(name)) throw new TypeError(`The call form "${given.name}" has the field ${name} in wrap and in data.`);
+	}
+	return new Set(data);
+}
 function compileEnvelopes(given) {
 	if (given === void 0) return void 0;
 	const out = {};
@@ -15327,17 +15546,22 @@ function compileProfile(profile) {
 		if (!FORM_ARGS.includes(args)) throw new TypeError(`The call form "${given.name}" has the unknown arguments ${String(args)}.`);
 		if (args === "fields" !== (given.fields !== void 0) && args !== "named") throw new TypeError(`The call form "${given.name}" with the arguments ${args} ${args === "fields" ? "needs" : "takes no"} fields.`);
 		if (given.min !== void 0 && (args === "named" || args === "literal")) throw new TypeError(`The call form "${given.name}" with the arguments ${args} takes no min.`);
+		const wrap = compileWrap(given, args);
 		const form = {
 			name: given.name,
 			type,
 			args,
 			fields: given.fields,
 			min: given.min ?? given.fields?.length ?? 0,
-			wrap: compileWrap(given, args)
+			wrap,
+			domain: compileDomain(given, args),
+			data: compileData(given, wrap)
 		};
 		forms.set(form.name, form);
 		addTo(formsByKind, key, form);
 	}
+	const brackets = [...forms.values()].some((form) => form.data.size > 0);
+	for (const symbol of brackets ? [...ops.prefixSymbols, ...ops.binarySymbols] : []) if (/^[[\]{}]/.test(symbol)) throw new TypeError(`The operator "${symbol}" reads the text of a field of data.`);
 	const compiled = {
 		...ops,
 		numbers: literals.numbers ?? true,
@@ -15369,7 +15593,8 @@ function compileProfile(profile) {
 			...ops.opWords,
 			...roots
 		]),
-		maxDepth: profile.maxDepth ?? 256
+		maxDepth: profile.maxDepth ?? 256,
+		brackets
 	};
 	compiledProfiles.set(profile, compiled);
 	return compiled;
@@ -15828,7 +16053,7 @@ var Parser = class {
 	}
 	/** This method stops at a token where a group or a list must end. A list can also continue with its separator. */
 	noEnd(close, list) {
-		const closer = close === ")" ? "parenthesis" : "brace";
+		const closer = closerName(close);
 		const before = list ? `"${this.syn.separator}" or a ` : "";
 		return this.stop(`A ${before}closing ${closer} is missing.`, this.pos, this.tokenLength());
 	}
@@ -15853,16 +16078,31 @@ var Parser = class {
 				this.pos += 1;
 				return args;
 			}
-			if (this.pos >= this.text.length) this.stop(`A closing ${close === ")" ? "parenthesis" : "brace"} is missing.`, open, 1);
+			if (this.pos >= this.text.length) this.stop(`A closing ${closerName(close)} is missing.`, open, 1);
 			this.noEnd(close, true);
 		}
 	}
 	/**
-	* This method reads the entries `key: expr` into a record: the arguments of a form `named` (SYNTAX.RECORD), or the
-	* entries between braces without a form (SYNTAX.RECORD-TEXT).
+	* This method reads the argument of a field of data (D177): a list between brackets, a record between braces, or a
+	* document. A literal in it stays its data.
+	*/
+	data() {
+		this.skip();
+		const start = this.pos;
+		const c = this.text[start];
+		if (c !== "[" && c !== "{") return this.bound();
+		this.depth += 1;
+		if (this.depth > this.syn.maxDepth) this.stop(`The text is deeper than ${String(this.syn.maxDepth)} levels.`, start, 0);
+		const value = c === "[" ? this.argumentsOf(() => this.data(), "]") : this.entries(void 0, true);
+		this.depth -= 1;
+		return value;
+	}
+	/**
+	* This method reads the entries `key: expr` into a record. The record is the arguments of a form `named`
+	* (SYNTAX.RECORD), or the entries between braces (SYNTAX.RECORD-TEXT). It is also a record of data (D177).
 	*/
-	entries(form) {
-		const owner = form === void 0 ? "record" : `form ${form.name}`;
+	entries(form, data = false) {
+		const owner = data ? "record of data" : form === void 0 ? "record" : `form ${form.name}`;
 		const value = {};
 		const entry = () => {
 			this.skip();
@@ -15872,9 +16112,10 @@ var Parser = class {
 			this.skip();
 			if (key === void 0 || this.text[this.pos] !== ":") this.stop(`Each ${form === void 0 ? "entry" : "argument"} of the ${owner} is a key, a ":" and a document.`, at, Math.max(end - at, this.tokenLength()));
 			if (form?.fields !== void 0 && !form.fields.includes(key)) this.stop(`The form ${form.name} has no field ${key}.`, at, end - at);
+			if (data && key === "type") this.stop("A record of data has no key type, because the key type makes a document.", at, end - at);
 			if (Object.hasOwn(value, key)) this.stop(`The ${owner} has the field ${key} two times.`, at, end - at);
 			this.pos += 1;
-			const arg = this.bound();
+			const arg = data || form?.data.has(key) === true ? this.data() : this.bound();
 			setOwn$1(value, key, form !== void 0 && wraps(form, key) ? envelop(this.syn, arg) : arg);
 		};
 		this.argumentsOf(entry, form === void 0 ? "}" : ")");
@@ -15883,11 +16124,19 @@ var Parser = class {
 	call(name, start, nameLength) {
 		const form = this.syn.forms.get(name);
 		if (form?.args === "named") return opDoc(form, this.entries(form));
-		const args = this.argumentsOf(() => this.bound());
+		let index = 0;
+		const args = this.argumentsOf(() => {
+			const key = form?.fields?.[index];
+			index += 1;
+			return key !== void 0 && form?.data.has(key) === true ? this.data() : this.bound();
+		});
 		if (form?.args === "literal") {
 			const [only] = args;
 			if (args.length !== 1 || !isScalar(only)) this.stop(`The form ${name} takes one literal that JSON writes.`, start, this.pos - start);
-			return opDoc(form, only);
+			return opDoc(form, form.domain === void 0 ? only : {
+				domain: form.domain,
+				data: only
+			});
 		}
 		if (form !== void 0) {
 			const most = form.fields?.length ?? Number.POSITIVE_INFINITY;
@@ -15913,15 +16162,20 @@ var Parser = class {
 /** The end of a recovery. The class `Recovery` throws it, and its method `run` catches it. */
 var End = class {};
 function hasBraces(syn) {
-	return syn.constructs.record !== void 0 || syn.constructs.let !== void 0;
+	return syn.constructs.record !== void 0 || syn.constructs.let !== void 0 || syn.brackets;
+}
+/** This function gives the name of a closer in a message. */
+function closerName(close) {
+	return close === ")" ? "parenthesis" : close === "]" ? "bracket" : "brace";
 }
 /** This function gives the closer of an opening bracket of a profile, or `undefined` for each other character. */
 function closerOf(syn, c) {
 	if (c === "(") return ")";
+	if (c === "[" && syn.brackets) return "]";
 	return c === "{" && hasBraces(syn) ? "}" : void 0;
 }
 function isCloser(syn, c) {
-	return c === ")" || c === "}" && hasBraces(syn);
+	return c === ")" || c === "]" && syn.brackets || c === "}" && hasBraces(syn);
 }
 /** This function gives the position after a quoted text at `at`, or after one other character. An open quote gives `Infinity`. */
 function pastToken(syn, text, at) {
@@ -16164,6 +16418,7 @@ function refShape(syn, value) {
 }
 function callName(syn, keys) {
 	if (keys.length === 0 || !keys.every((key) => typeof key === "string" && NAME.test(key))) return void 0;
+	if (keys.length > 1 && !syn.fields) 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;
@@ -16186,10 +16441,16 @@ function wrappedShape(syn, doc) {
 	const literal = literalShape(syn, doc.value);
 	return literal.tag === "text" ? literal : void 0;
 }
+/** This function tells if a value of `ext.domain` is a record with this domain and its data, and no other key. */
+function holdsDomain(value, domain) {
+	return isRecord(value) && value["domain"] === domain && Object.hasOwn(value, "data") && Object.keys(value).length === 2;
+}
 function formShape(syn, form, value) {
 	if (form.args === "literal") {
-		if (!isScalar(value)) return void 0;
-		const literal = literalShape(syn, value);
+		if (form.domain !== void 0 && !holdsDomain(value, form.domain)) return void 0;
+		const data = form.domain === void 0 ? value : value["data"];
+		if (!isScalar(data)) return void 0;
+		const literal = literalShape(syn, data);
 		return literal.tag === "text" ? {
 			tag: "text",
 			text: `${form.name}(${literal.text})`
@@ -16205,7 +16466,8 @@ function formShape(syn, form, value) {
 			args: keys.map((key) => [
 				key,
 				value[key],
-				wraps(form, key)
+				wraps(form, key),
+				form.data.has(key)
 			]),
 			named: true
 		};
@@ -16232,7 +16494,8 @@ function formShape(syn, form, value) {
 		args: present.map((key) => [
 			key,
 			value[key],
-			wraps(form, key)
+			wraps(form, key),
+			form.data.has(key)
 		])
 	};
 }
@@ -16368,6 +16631,18 @@ function bracesText(syn, record, path, sub) {
 	if (!texts.ok) return texts;
 	return ok(`{${texts.value.map((text, index) => `${keyText(keys[index])}: ${text}`).join(`${syn.separator} `)}}`);
 }
+/**
+* This function writes the argument of a field of data (D177): a list between brackets, or a record between braces.
+* The function `sub` writes a literal and a document. A record that is an envelope is a document.
+*/
+function dataText(syn, value, path, sub) {
+	const each = (child, at) => dataText(syn, child, at, sub);
+	if (Array.isArray(value)) {
+		const texts = partTexts(value.map((item, index) => [index, item]), path, each);
+		return texts.ok ? ok(`[${texts.value.join(`${syn.separator} `)}]`) : texts;
+	}
+	return isRecord(value) && !isEnvelope(value) && !Object.hasOwn(value, "type") ? bracesText(syn, value, path, each) : sub(value, path);
+}
 /** This function writes a construct form (K145). */
 function constructText(syn, shape, sub) {
 	if (shape.tag === "record") return bracesText(syn, shape.entries, [], sub);
@@ -16410,8 +16685,8 @@ function printNode(syn, doc, sub) {
 		return ok(texts.join("."));
 	}
 	const texts = [];
-	for (const [key, arg, wrapped] of shape.args) {
-		const result = sub(arg, [key], wrapped);
+	for (const [key, arg, wrapped, data] of shape.args) {
+		const result = data === true ? dataText(syn, arg, [key], sub) : sub(arg, [key], wrapped);
 		if (!result.ok) return result;
 		texts.push(shape.named === true ? `${keyText(String(key))}: ${result.value}` : result.value);
 	}
@@ -19286,6 +19561,7 @@ function schedule(machine, options = {}) {
 	let keptAt = -1;
 	const keptNodes = [];
 	let keptMet = false;
+	let keptFrom = 0;
 	let count = 0;
 	let ahead = 0;
 	let wanted;
@@ -19356,7 +19632,10 @@ function schedule(machine, options = {}) {
 		const reader = stack[stack.length - 1];
 		const known = epoch.values.get(id);
 		if (known !== void 0) {
-			if (reader !== void 0 && onOpen.has(id)) lower(reader, order.get(id));
+			if (reader !== void 0 && onOpen.has(id)) {
+				if (keptAt >= 0 && order.get(id) < keptFrom) keptMet = true;
+				else lower(reader, order.get(id));
+			}
 			return known;
 		}
 		if (busy.has(id)) {
@@ -19560,9 +19839,11 @@ function schedule(machine, options = {}) {
 		keeping(read) {
 			const outer = keptAt;
 			const outerMet = keptMet;
+			const outerFrom = keptFrom;
 			const from = keptNodes.length;
 			keptAt = stack.length;
 			keptMet = false;
+			keptFrom = count;
 			try {
 				return read();
 			} finally {
@@ -19573,6 +19854,7 @@ function schedule(machine, options = {}) {
 				}
 				keptAt = outer;
 				keptMet = outerMet;
+				keptFrom = outerFrom;
 			}
 		}
 	});
@@ -20556,6 +20838,6 @@ function samplesAt(values, closed, depth) {
 function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
-export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, GENERATION_LIMIT, Held, JOURNAL, MAX_SYNTAX_ISSUES, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, argsKey, ask, atArgsOf, atRuleOf, attributeGraph, attributeTrace, attributeVertexId, capKeys, check, checkCycles, checkLatent, checkStep, checkSteps, checkSyntax, checkWorld, circularOf, classify, codecLaws, collectOf, compilePath, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, documentKey, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partGrants, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, resolveCompiled, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+export { ATTRIBUTE_RUNGS, CAPS_TYPE, CIRCULAR_LIMIT, CONSTRUCTS, ENVELOPE_KEYS, Failure, GENERATION_LIMIT, Held, JOURNAL, MAX_SYNTAX_ISSUES, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, agreeTypes, argsKey, ask, atArgsOf, atRuleOf, attributeGraph, attributeTrace, attributeVertexId, boundariesOf, capKeys, check, checkCycles, checkLatent, checkStep, checkSteps, checkSyntax, checkWorld, circularOf, classify, codecLaws, collectOf, compilePath, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, documentKey, durable, edgesOf, effectEdges, effectsOf, effectsOfVerb, encodeLog, encodeValue, entriesAsJson, equationType, evaluate, extendDomain, factsOf, fail, failures, field, fits, flatten, formulaDefinitions, formulaEvaluators, formulaFacts, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, heights, ifRunner, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isStep, isTypeRef, join, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapDocs, mapRefs, member, mergeMachines, mergeWorlds, narrow, nearestWalker, necessary, nodeAt, nodeLayers, ok, parse, partCaps, partGrants, partsOf, pathMatches, permits, placeOf, placed, planner, prepare, print, printReads, random, recorder, ref, reference, referenceRun, refsOf, replayer, resolve, resolveCompiled, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stepLadder, stepOf, stepRank, stored, syntaxFormat, tag, thrown, toJson, treeNodeEvaluator, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
 
 //# sourceMappingURL=index.js.map