@mark1russell7/coeval 0.23.0 → 0.24.0

package/build/index.js

@@ -3744,7 +3744,7 @@ function intersectCaps(a, b) {
 /** This function gives the capability rules of a kind that cover a part and change its capabilities. */
 function rulesFor(rules, path) {
 	if (rules === void 0 || rules.length === 0) return NO_RULES;
-	const out = rules.filter((rule) => rule.rule !== "same" && (rule.in === void 0 || rule.in.some((pattern) => pathMatches(path, pattern))));
+	const out = rules.filter((rule) => rule.rule !== "same" && rule.rule !== "grant" && (rule.in === void 0 || rule.in.some((pattern) => pathMatches(path, pattern))));
 	return out.length === 0 ? NO_RULES : out;
 }
 /** This function applies the rules that cover a part to the capabilities of its document. */
@@ -3768,6 +3768,53 @@ function capsUnder(rules, caps) {
 function partCaps(rules, path, caps) {
 	return capsUnder(rulesFor(rules, path), caps);
 }
+/** This function collects the values at a path in a value. The key `"*"` steps into each item of a list. */
+function collectAt(value, path, index, out) {
+	if (index === path.length) {
+		if (typeof value === "string" || Array.isArray(value) && value.every((key) => typeof key === "string" || typeof key === "number")) out.push(value);
+		return;
+	}
+	const key = path[index];
+	if (key === "*") {
+		if (Array.isArray(value)) for (const item of value) collectAt(item, path, index + 1, out);
+		return;
+	}
+	if (typeof value === "object" && value !== null) collectAt(value[key], path, index + 1, out);
+}
+/**
+* This function gives the capabilities that the rules `grant` of a kind give one part (CAP.GRANT). The check and the
+* walk read them from the document. The kernel gets the same list from the clauses of the runner.
+*
+* @param rules - The capability rules of the kind (`Kind.caps`).
+* @param path - The path of the part in the value of the document.
+* @param value - The value of the document.
+* @returns The capabilities that the rules add, or an empty list.
+*/
+function partGrants(rules, path, value) {
+	if (rules === void 0) return NO_CAPS$2;
+	let out;
+	for (const rule of rules) {
+		if (rule.rule !== "grant" || rule.in !== void 0 && !rule.in.some((pattern) => pathMatches(path, pattern))) continue;
+		collectAt(value, rule.from, 0, out ??= []);
+	}
+	return out ?? NO_CAPS$2;
+}
+/**
+* The key of the frame of a context. Like the grant, it stays through a spread of a context, and only the kernel writes
+* it. It is not a root (D10): a document cannot read it (HANDLE.SEALED).
+*/
+const FRAME = /* @__PURE__ */ Symbol("coeval.frame");
+/** This function gives the frame of a context, when it has one. */
+function frameOf(ctx) {
+	return ctx[FRAME];
+}
+/** This function finds the frame and the clause that answer an effect. The innermost frame wins, then the first clause. */
+function clauseFor(start, keys) {
+	for (let frame = start; frame !== void 0; frame = frame.outer) for (const clause of frame.clauses) if (permits([clause.op], keys)) return {
+		frame,
+		clause
+	};
+}
 /**
 * The key of the grant of a context (CAP.NARROW-CODE): the capabilities that the kernel gave the document of the
 * context. A spread of a context keeps its grant. Thus compiled code passes the grant on in each context that it makes
@@ -4324,13 +4371,33 @@ var Session = class {
 		done.catch(() => void 0);
 		return effect.outcome = fail("#CALC!", `The mock gave a promise for the effect ${effect.kind}, and an evaluation does not wait.`, { place });
 	}
+	/**
+	* This function finds the clause that answers an effect (D146). Without it, the effect goes on to the host. An effect
+	* without a capability gets no clause, thus `record` gives its `#CAP!` (HANDLE.NARROW). A clause of a frame that has
+	* ended gives `#CAP!`, because the capability came from that frame (HANDLE.ENDED).
+	*/
+	clauseOf(given, start, kind, place) {
+		const ctx = inEpoch(given, this.epoch) ? granted(given) : ungranted(given, this.epoch);
+		const keys = typeof kind === "string" ? kind.split(".") : kind;
+		if (!this.permitted(ctx, keys)) return void 0;
+		const found = clauseFor(start, keys);
+		if (found === void 0) return void 0;
+		if (found.frame.ended || found.frame.owner !== this) return fail("#CAP!", `The handler of the effect ${keys.join(".")} has ended.`, { place });
+		return found.clause;
+	}
 	effect(ctx, kind, payload, place) {
 		const text = typeof kind === "string" ? kind : kind.join(".");
 		if (this.running) return fail("#CALC!", `The effect ${text} needs a runner: in a run, the host does each effect.`, { place });
+		const frame = frameOf(ctx);
+		const clause = frame === void 0 ? void 0 : this.clauseOf(ctx, frame, kind, place);
+		if (clause !== void 0) return "ok" in clause ? clause : drive$2(clause.answer(payload), text);
 		const made = this.record(ctx, kind, payload, place);
 		return "ok" in made ? made : this.answer(made, place);
 	}
 	*runEffect(ctx, kind, payload, place) {
+		const frame = frameOf(ctx);
+		const clause = frame === void 0 ? void 0 : this.clauseOf(ctx, frame, kind, place);
+		if (clause !== void 0) return "ok" in clause ? clause : yield* clause.answer(payload);
 		const made = this.record(ctx, kind, payload, place);
 		if ("ok" in made) return made;
 		const perform = this.perform;
@@ -4741,7 +4808,7 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	if (runner !== void 0) {
 		let inner;
 		try {
-			inner = isCompiledRunner(runner) ? runner.compileRun(input) : interpretRun(runner, input, split.fill);
+			inner = isCompiledRunner(runner) ? runner.compileRun(input) : interpretRun(runner, input, split.fill, kind?.caps?.some((rule) => rule.rule === "grant") === true);
 		} catch (error) {
 			return failingWith(c, meta, placed(thrown(error, `the runner ${name}`), place));
 		}
@@ -5241,7 +5308,35 @@ function interpret(fn, input, fill) {
 		});
 	};
 }
-function interpretRun(fn, input, fill) {
+/**
+* This function runs a part under a new frame (D146). The part gets the capabilities of the document and the kinds of
+* the clauses (CAP.GRANT), with the grant of the kernel. A rule around an effect narrows them as it narrows any other
+* capability (HANDLE.NARROW). The frame ends with the steps.
+*/
+function* handling(given, clauses, rt, run) {
+	const ctx = granted(given);
+	const frame = {
+		clauses,
+		outer: frameOf(ctx),
+		owner: rt,
+		ended: false
+	};
+	const caps = [...ctx.caps];
+	for (const clause of clauses) if (!permits(caps, clause.op)) caps.push(clause.op);
+	const inner = {
+		...ctx,
+		caps,
+		[GRANT]: caps,
+		[EPOCH]: epochOf(ctx),
+		[FRAME]: frame
+	};
+	try {
+		return yield* run(inner);
+	} finally {
+		frame.ended = true;
+	}
+}
+function interpretRun(fn, input, fill, grants) {
 	const { kind, typePath, doc, data, place, machine } = input;
 	const refill = input.fill;
 	const compiled = input.parts;
@@ -5251,7 +5346,8 @@ function interpretRun(fn, input, fill) {
 			key: part.key,
 			path: part.path,
 			...part.name === void 0 ? {} : { name: part.name },
-			evaluate: (override) => part.run(override === void 0 ? ctx : handed(ctx, override), rt)
+			evaluate: (override) => part.run(override === void 0 ? ctx : handed(ctx, override), rt),
+			...grants ? { handled: (clauses) => handling(ctx, clauses, rt, (inner) => part.run(inner, rt)) } : {}
 		}));
 		return fn({
 			kind,
@@ -5729,6 +5825,72 @@ const STD_WORLD = {
 			lazy: [{ after: 1 }],
 			summary: "It evaluates its part without capabilities, thus an effect in it fails."
 		},
+		handle: {
+			verbs: {
+				eval: "control.handle",
+				view: "view.op"
+			},
+			parts: {
+				shape: "record",
+				fields: {
+					with: {
+						shape: "list",
+						item: {
+							shape: "record",
+							fields: {
+								op: { shape: "none" },
+								do: { shape: "term" },
+								abort: { shape: "term" }
+							},
+							required: ["op"],
+							closed: true
+						}
+					},
+					return: { shape: "term" },
+					body: { shape: "term" }
+				},
+				required: ["with", "body"],
+				closed: true
+			},
+			scope: [{
+				names: { fixed: ["payload"] },
+				in: [[
+					"with",
+					"*",
+					"do"
+				], [
+					"with",
+					"*",
+					"abort"
+				]]
+			}, {
+				names: { fixed: ["result"] },
+				in: [["return"]]
+			}],
+			caps: [{
+				rule: "grant",
+				from: [
+					"with",
+					"*",
+					"op"
+				],
+				in: [["body"]]
+			}],
+			lazy: [{ in: [
+				[
+					"with",
+					"*",
+					"do"
+				],
+				[
+					"with",
+					"*",
+					"abort"
+				],
+				["return"]
+			] }],
+			summary: "It answers the effects of its body with its clauses, in place, thus a mock, a retry or a log is a document."
+		},
 		log: {
 			verbs: {
 				eval: "effect.log",
@@ -7103,6 +7265,10 @@ function* inOrder(parts) {
 	}
 	return { values };
 }
+/** This function tells if a value names a kind of effects: a text, or a list of keys. */
+function isOp(value) {
+	return typeof value === "string" || Array.isArray(value) && value.every(isKey);
+}
 /**
 * 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.
@@ -7134,6 +7300,43 @@ const STD_RUNNERS = {
 		if (only === void 0 || parts.length > 1) return fail("#VALUE!", "pure needs exactly one part.");
 		return yield* only.evaluate();
 	},
+	"control.handle": function* ({ value, context }) {
+		const { with: list, return: after, body } = value;
+		if (body?.handled === void 0) return fail("#VALUE!", "handle needs a body.");
+		let stopped;
+		const clauses = [];
+		for (const item of list) {
+			const part = item.do ?? item.abort;
+			if (!isOp(item.op)) return fail("#VALUE!", "The op of a clause of handle must be a text or a list of keys.");
+			if (part === void 0 || item.do !== void 0 && item.abort !== void 0) return fail("#VALUE!", "Each clause of handle needs exactly one of do and abort.");
+			const stops = item.do === void 0;
+			clauses.push({
+				op: item.op,
+				answer: function* (payload) {
+					const result = yield* part.evaluate({
+						...context,
+						names: {
+							...context.names,
+							payload
+						}
+					});
+					if (!stops) return result;
+					stopped ??= result;
+					return fail("#CALC!", "A clause abort of handle stopped the body.");
+				}
+			});
+		}
+		const result = yield* body.handled(clauses);
+		if (stopped !== void 0) return stopped;
+		if (!result.ok || after === void 0) return result;
+		return yield* after.evaluate({
+			...context,
+			names: {
+				...context.names,
+				result: result.value
+			}
+		});
+	},
 	"control.if": function* ({ parts }) {
 		const test = parts.find((part) => part.key === "test");
 		if (test === void 0) return fail("#VALUE!", "if needs a test.");
@@ -9180,11 +9383,12 @@ var Visit = class {
 	typePath;
 	address;
 	caps;
+	handled;
 	#place;
 	#at;
 	#bound;
 	#expect;
-	constructor(place, at, doc, declared, depth, names, later, slot, parent, kind, typePath, address, caps, bound, expect) {
+	constructor(place, at, doc, declared, depth, names, later, slot, parent, kind, typePath, address, caps, bound, expect, handled) {
 		this.doc = doc;
 		this.declared = declared;
 		this.depth = depth;
@@ -9196,6 +9400,7 @@ var Visit = class {
 		this.typePath = typePath;
 		this.address = address;
 		this.caps = caps;
+		this.handled = handled;
 		this.#place = place;
 		this.#at = at;
 		this.#bound = bound;
@@ -9241,6 +9446,7 @@ function walk(world, doc, visit, options = {}) {
 		slot: [],
 		parent: void 0,
 		caps: options.caps,
+		handled: void 0,
 		bound: [],
 		expect: void 0
 	}];
@@ -9257,7 +9463,7 @@ function walk(world, doc, visit, options = {}) {
 			continue;
 		}
 		const { doc, kind, split } = read;
-		const here = new Visit(item.place, item.at, doc, read.declared, item.depth, item.names, item.later, item.slot, item.parent, kind, read.typePath, item.address ? true : void 0, item.caps, item.bound, item.expect);
+		const here = new Visit(item.place, item.at, doc, read.declared, item.depth, item.names, item.later, item.slot, item.parent, kind, read.typePath, item.address ? true : void 0, item.caps, item.bound, item.expect, item.handled);
 		if (visit(here) === "skip" || kind === void 0) continue;
 		const base = read.declared ? item.at : {
 			up: item.at,
@@ -9280,6 +9486,7 @@ function walk(world, doc, visit, options = {}) {
 			const slot = split.parts[index];
 			const extra = sees[index] ?? [];
 			const hidden = later[index] ?? [];
+			const grants = partGrants(kind.caps, slot.path, doc.value);
 			stack.push({
 				value: slot.item,
 				place: slot.path.length === 0 ? item.place : {
@@ -9297,7 +9504,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),
+				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],
 				bound: extra,
 				expect: slot.expect
 			});
@@ -9708,6 +9916,7 @@ const KEEPS_SELF = /* @__PURE__ */ new Set([
 	"control.seq",
 	"control.pure",
 	"control.if",
+	"control.handle",
 	"list.all",
 	"effect.log",
 	"effect.write"
@@ -10272,7 +10481,7 @@ function reaching(machine, doc, options) {
 	const rule = options.caps === void 0 ? permits : permitsOf(machine);
 	walk(machine.world, doc, (v) => {
 		const caps = v.caps ?? EACH;
-		for (const kind of declaredEffects(v, "eval", machine)) if (rule(caps, kind)) out.push({
+		for (const kind of declaredEffects(v, "eval", machine)) if (rule(caps, kind) && (v.handled === void 0 || !permits(v.handled, kind))) out.push({
 			kind,
 			visit: v
 		});
@@ -11937,6 +12146,28 @@ function freeIn(root, ctx, path) {
 	const bound = Object.hasOwn(ctx.names, key);
 	return bound === Object.hasOwn(root.names, key) && (!bound || Object.is(ctx.names[key], root.names[key]));
 }
+/** The key of the frame of a context. */
+const REF_FRAME = /* @__PURE__ */ Symbol("coeval.reference.frame");
+/** This function gives the frame of a context. */
+function refFrame(ctx) {
+	return ctx[REF_FRAME];
+}
+/**
+* This function finds the clause for an effect (HANDLE.DO, HANDLE.FORWARD). An effect without a capability gets no clause
+* (HANDLE.NARROW). A clause of a frame that has ended gives `#CAP!` (HANDLE.ENDED).
+*/
+function clauseAt(env, ctx, kind, place) {
+	let frame = refFrame(ctx);
+	if (frame === void 0) return void 0;
+	const keys = typeof kind === "string" ? kind.split(".") : kind;
+	const machine = env.machine;
+	if (!(machine.permits === void 0 ? permits(ctx.caps, keys) : machine.permits(ctx.caps, keys, ctx))) return void 0;
+	for (; frame !== void 0; frame = frame.outer) for (const clause of frame.clauses) {
+		if (!permits([clause.op], keys)) continue;
+		if (frame.ended || frame.owner !== env.effects) return fail("#CAP!", `The handler of the effect ${keys.join(".")} has ended.`, { place });
+		return clause;
+	}
+}
 /**
 * This function causes an effect when the capabilities permit it (RUN.CAP, CAP.HOOK). It records the effect with its
 * address (RUN.ADDRESS) and its outcome (RUN.OUTCOME). The mock answers the effect at once (RUN.MOCK). Without a
@@ -11955,6 +12186,8 @@ function cause(env, ctx, kind, payload, place) {
 function causeFromEvaluator(env, ctx, kind, payload, place) {
 	const text = typeof kind === "string" ? kind : kind.join(".");
 	if (env.running) return fail("#CALC!", `The effect ${text} needs a runner: in a run, the host does each effect.`, { place });
+	const clause = clauseAt(env, ctx, kind, place);
+	if (clause !== void 0) return "ok" in clause ? clause : drive$1(clause.answer(payload), place, text);
 	return cause(env, ctx, kind, payload, place);
 }
 /**
@@ -11963,6 +12196,8 @@ function causeFromEvaluator(env, ctx, kind, payload, place) {
 * (RUN.OUTCOME).
 */
 function* causeAndWait(env, ctx, kind, payload, place) {
+	const clause = clauseAt(env, ctx, kind, place);
+	if (clause !== void 0) return "ok" in clause ? clause : yield* clause.answer(payload);
 	if (!env.running) return cause(env, ctx, kind, payload, place);
 	const effect = recordEffect(env, ctx, kind, payload, place);
 	if ("ok" in effect) return effect;
@@ -12109,6 +12344,28 @@ function evalInput(env, seen, at) {
 		fill
 	};
 }
+/** This function evaluates a part under a frame: the part also gets the kinds of the clauses (CAP.GRANT). */
+function* handledAt(env, part, clauses) {
+	const frame = {
+		clauses,
+		outer: refFrame(part.ctx),
+		owner: env.effects,
+		ended: false
+	};
+	const ctx = {
+		...part.ctx,
+		caps: [...part.ctx.caps, ...clauses.map((clause) => clause.op)],
+		[REF_FRAME]: frame
+	};
+	try {
+		return yield* stepsAt(env, {
+			...part,
+			ctx
+		});
+	} finally {
+		frame.ended = true;
+	}
+}
 function runInput(env, seen, at) {
 	const { split, doc } = seen;
 	const parts = split.parts.map((slot) => {
@@ -12117,7 +12374,8 @@ function runInput(env, seen, at) {
 			key: slot.key,
 			path: slot.path,
 			...name === void 0 ? {} : { name },
-			evaluate: (given) => stepsAt(env, partAt(seen, at, slot, given))
+			evaluate: (given) => stepsAt(env, partAt(seen, at, slot, given)),
+			handled: (clauses) => handledAt(env, partAt(seen, at, slot, void 0), clauses)
 		};
 	});
 	const fill = (items) => split.parts.length === 0 ? doc.value : split.fill(items);
@@ -16214,6 +16472,287 @@ function syntaxFormat(profile) {
 		evaluators: { "syntax.format": code }
 	};
 }
+/** This function tells how a document breaks `parse(print(doc))`. It gives `undefined` when the document comes back. */
+function lawBreak(profile, doc) {
+	const printed = print(profile, doc);
+	if (!printed.ok) return {
+		text: void 0,
+		why: printed.error.reason
+	};
+	const text = printed.value;
+	const back = parse(profile, text);
+	if (back.ok) return docEquals(back.doc, doc) ? void 0 : {
+		text,
+		why: `The text ${text} reads as ${JSON.stringify(back.doc)}.`
+	};
+	return {
+		text,
+		why: `The text ${text} gives the issue: ${back.issues[0]?.message ?? ""}`
+	};
+}
+/** This function gives the index of the first pattern that `parse` uses at the start of a text, or `-1`. */
+function patternAt(syn, text) {
+	return syn.patterns.findIndex(({ sticky }) => {
+		sticky.lastIndex = 0;
+		const match = sticky.exec(text)?.[0];
+		return match !== void 0 && match !== "" && !/[A-Za-z0-9_$(]/.test(text[match.length] ?? "");
+	});
+}
+/** This function gives each small document of an operator with `term` in one term. A `flat` operator also has three terms. */
+function operatorDocs(op, term, leaf) {
+	if (op.fixity !== "infix") return [opDoc(op, [term])];
+	const pairs = [[term, leaf], [leaf, term]];
+	return (op.assoc === "flat" ? [
+		...pairs,
+		[
+			term,
+			leaf,
+			leaf
+		],
+		[
+			leaf,
+			term,
+			leaf
+		]
+	] : pairs).map((terms) => opDoc(op, terms));
+}
+/** This function gives the longer symbol that reads two postfix operators without a space, or `undefined`. */
+function gluedSymbol(syn, outer, inner) {
+	if (outer.word || inner.word || outer.fixity !== "postfix" || inner.fixity !== "postfix") return void 0;
+	const glued = inner.symbol + outer.symbol;
+	const read = syn.binarySymbols.find((symbol) => glued.startsWith(symbol));
+	return read === inner.symbol ? void 0 : read;
+}
+function checkOperators({ profile, syn, leaf, keeps }) {
+	const ops = (profile.operators ?? []).map((given) => (given.fixity === "prefix" ? syn.prefix : syn.binary).get(given.symbol));
+	const sound = ops.filter((op, index) => operatorDocs(op, leaf, leaf).every((doc) => keeps("operator", ["operators", index], `The operator ${op.symbol} does not come back.`, doc)));
+	for (const outer of sound) {
+		const place = ["operators", ops.indexOf(outer)];
+		for (const inner of sound) {
+			const glued = gluedSymbol(syn, outer, inner);
+			const code = glued === void 0 ? "grouping" : "longest-match";
+			const rule = glued === void 0 ? `The operator ${outer.symbol} with ${inner.symbol} in a term loses the tree.` : `The symbol ${glued} reads the postfix operators ${inner.symbol} and ${outer.symbol}.`;
+			for (const term of operatorDocs(inner, leaf, leaf)) for (const doc of operatorDocs(outer, term, leaf)) keeps(code, place, rule, doc);
+		}
+	}
+}
+function checkLiterals({ profile, syn, report }) {
+	for (const [word, value] of syn.words) {
+		const back = parse(profile, word);
+		if (!back.ok || !docEquals(back.doc, envelop(syn, literalDoc(value)))) report("word", [
+			"literals",
+			"words",
+			word
+		], word, `The word ${word} does not read as its value.`);
+	}
+	for (const value of [
+		0,
+		-1,
+		"a"
+	]) {
+		const shape = literalShape(syn, value);
+		if (shape.tag === "text" && patternAt(syn, shape.text) >= 0) report("pattern", [], shape.text, `The literal ${shape.text} reads as a reference.`);
+	}
+}
+function checkRoots({ profile, syn, keeps }) {
+	(profile.refs?.roots ?? DEFAULT_ROOTS).forEach((root, index) => {
+		for (const path of syn.fields ? [[root], [root, "x"]] : [[root]]) keeps("root", [
+			"refs",
+			"roots",
+			index
+		], `The root ${root} does not come back.`, {
+			type: "ref",
+			value: path
+		}, path.join("."));
+	});
+}
+/** This function gives a value that a call form writes: the fewest arguments, and at least one. */
+function formValue(given, leaf) {
+	const args = given.args ?? (given.fields === void 0 ? "list" : "fields");
+	const least = Math.max(given.min ?? given.fields?.length ?? 0, 1);
+	if (args === "literal") return 1;
+	if (args === "list") return Array.from({ length: least }, () => leaf);
+	const keys = (given.fields ?? ["x"]).slice(0, args === "named" ? 1 : least);
+	return Object.fromEntries(keys.map((key) => [key, leaf]));
+}
+function checkCalls({ profile, syn, leaf, keeps }) {
+	const calls = profile.calls ?? {};
+	(calls.forms ?? []).forEach((form, index) => {
+		keeps("form", [
+			"calls",
+			"forms",
+			index
+		], `The form ${form.name} does not come back.`, {
+			type: typeOfKind(form.kind).type,
+			value: formValue(form, leaf)
+		});
+	});
+	if (syn.ops === true && syn.fields) keeps("call", ["calls", "ops"], "A call name with a dot does not come back.", {
+		type: [
+			"ops",
+			"m",
+			"p"
+		],
+		value: [leaf]
+	});
+	if (typeof calls.ops === "boolean" || calls.ops === void 0) return;
+	calls.ops.forEach((name, index) => {
+		keeps("call", [
+			"calls",
+			"ops",
+			index
+		], `The call ${name} does not come back.`, {
+			type: ["ops", ...name.split(".")],
+			value: [leaf]
+		});
+	});
+}
+/** This function writes two terms with the separator. It blames the separator only when a neutral separator keeps the document. */
+function checkSeparator({ profile, syn, leaf, report }) {
+	if (syn.ops !== true && syn.ops.size === 0 && syn.forms.size === 0 && syn.constructKinds.size === 0) return;
+	const open = {
+		...profile,
+		calls: {
+			...profile.calls,
+			ops: true
+		}
+	};
+	const neutral = {
+		...profile,
+		calls: {
+			...open.calls,
+			separator: "
"
+		}
+	};
+	const postfix = [...syn.binary.values()].filter((op) => op.fixity === "postfix").map((op) => opDoc(op, [leaf]));
+	const docs = [
+		leaf,
+		{
+			type: "ref",
+			value: [syn.bare, "b c"]
+		},
+		"a",
+		1,
+		...postfix
+	].map((term) => ({
+		type: ["ops", "probe__"],
+		value: [term, leaf]
+	}));
+	const entries = {
+		x: leaf,
+		y: leaf
+	};
+	const { record, let: bind } = syn.constructs;
+	if (record !== void 0) docs.push({
+		type: record,
+		value: entries
+	});
+	if (bind !== void 0) docs.push({
+		type: bind,
+		value: {
+			bind: entries,
+			body: leaf
+		}
+	});
+	for (const doc of docs) {
+		const broken = lawBreak(neutral, doc) === void 0 ? lawBreak(open, doc) : void 0;
+		if (broken !== void 0) report("separator", ["calls", "separator"], "", `The separator "${syn.separator}" does not end an argument. ${broken.why}`);
+	}
+}
+function checkConstructs({ syn, leaf, keeps }) {
+	const entries = { x: leaf };
+	const values = {
+		record: entries,
+		let: {
+			bind: entries,
+			body: leaf
+		},
+		fn: {
+			params: ["x"],
+			body: leaf
+		},
+		call: {
+			fn: leaf,
+			args: [leaf]
+		}
+	};
+	for (const name of CONSTRUCTS$1) {
+		const type = syn.constructs[name];
+		if (type !== void 0) keeps("construct", ["constructs", name], `The form ${name} does not come back.`, {
+			type,
+			value: values[name]
+		});
+	}
+}
+/**
+* This function finds the faults of a syntax profile before a host uses it (SYNTAX.PROFILE-CHECK, D140). A fault is a
+* document of an entry that breaks `parse(print(doc))`, or a text of an entry that reads another way. The function
+* writes and reads one small document for each entry, for each pair of operators and for each root. Thus an empty list
+* tells that these small documents come back. It does not prove the law for each document. `parse` and `print` do not
+* call this function, thus it adds no cost to them.
+*
+* @param profile - The syntax profile.
+* @returns At most one finding for each code and place, in the order of the operators, the literals, the references, the calls and the constructs.
+* @throws An error of a `read` or a `write` function of a pattern.
+*/
+function checkSyntax(profile) {
+	const open = {
+		...profile,
+		maxDepth: 256
+	};
+	let syn;
+	try {
+		syn = compileProfile(open);
+	} catch (error) {
+		if (error instanceof TypeError) return [{
+			code: "invalid",
+			place: [],
+			reason: error.message
+		}];
+		throw error;
+	}
+	const found = /* @__PURE__ */ new Map();
+	const report = (code, place, text, reason) => {
+		const index = patternAt(syn, text);
+		const finding = index < 0 ? {
+			code,
+			place,
+			reason
+		} : {
+			code: "pattern",
+			place: [
+				"refs",
+				"patterns",
+				index
+			],
+			reason: `The pattern reads the start of the text ${text}. ${reason}`
+		};
+		const key = JSON.stringify([finding.code, finding.place]);
+		if (!found.has(key)) found.set(key, finding);
+	};
+	const keeps = (code, place, rule, doc, start = "") => {
+		const broken = lawBreak(open, doc);
+		if (broken !== void 0) report(code, place, broken.text ?? start, `${rule} ${broken.why}`);
+		return broken === void 0;
+	};
+	const check = {
+		profile: open,
+		syn,
+		leaf: {
+			type: "ref",
+			value: [syn.bare, "a"]
+		},
+		report,
+		keeps
+	};
+	checkOperators(check);
+	checkLiterals(check);
+	checkRoots(check);
+	checkCalls(check);
+	checkSeparator(check);
+	checkConstructs(check);
+	return [...found.values()];
+}
 // src/generate.ts
 /**
 * This function makes a source of random numbers with a seed (the algorithm mulberry32). It needs no package.
@@ -17324,7 +17863,8 @@ function instanceOf(env, under, doc, split, sample) {
 			const ctx = shot.context;
 			const parts = split.parts.map((slot, index) => ({
 				...handleOf(slot),
-				evaluate: (given) => shot.steps(index, "evaluate", given ?? ctx)
+				evaluate: (given) => shot.steps(index, "evaluate", given ?? ctx),
+				handled: () => shot.steps(index, "evaluate", ctx)
 			}));
 			const input = {
 				...base,
@@ -20016,6 +20556,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, 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, 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, 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 };
 
 //# sourceMappingURL=index.js.map