@mark1russell7/coeval 0.17.0 → 0.18.0

package/build/index.js

@@ -1,4 +1,4 @@
-//#region src/doc.ts
+// src/doc.ts
 /** The keys that an envelope can have. */
 const ENVELOPE_KEYS = [
 	"type",
@@ -240,8 +240,7 @@ function equalWith(a, b, rule) {
 	}
 	return true;
 }
-//#endregion
-//#region src/errors.ts
+// src/errors.ts
 /**
 * This function makes a result with a value.
 *
@@ -354,8 +353,7 @@ function describe(value) {
 		return "(a value without a text)";
 	}
 }
-//#endregion
-//#region src/world.ts
+// src/world.ts
 /**
 * This function gives the type of a bare equation of a kind (D42). It is the type `of` of the shape of its parts, or
 * else the type `of` of the shape `rest` of a record. The plan, the reference and `check` read it with this one function.
@@ -568,8 +566,7 @@ function kindDocument(name, kind) {
 function looksLikeKind(value) {
 	return isRecord(value) && isRecord(field(value, "verbs"));
 }
-//#endregion
-//#region src/types.ts
+// src/types.ts
 /**
 * The domains of the kernel. `unknown` and `never` are not domains: they are the top and the bottom of the types.
 * A machine that does not name one of these domains gets it from this table.
@@ -592,6 +589,7 @@ const STD_DOMAINS = {
 	},
 	number: {
 		is: (value) => typeof value === "number",
+		samples: [0, -1],
 		summary: "A number of the host, also NaN, an infinity and -0."
 	},
 	text: {
@@ -860,7 +858,8 @@ function membersAt(type, domains, samples, depth) {
 /**
 * This function gives members of a type for a test of a declaration (D86). A type with at most 64 members gives each
 * member, from the lists `values` of its domains (TYPE.FITS-FINITE). A union gives the members of each of its types.
-* Each other type gives the samples that are its members. The kernel does not export the function.
+* Each other type gives the samples that are its members. The samples of the domains come after the given samples (D99).
+* The kernel does not export the function.
 *
 * @param type - The type.
 * @param domains - The domains of the machine.
@@ -868,7 +867,51 @@ function membersAt(type, domains, samples, depth) {
 * @returns Distinct members of the type.
 */
 function membersOf(type, domains, samples) {
-	return membersAt(type, domains, samples, 0);
+	return membersAt(type, domains, withDomainSamples(samples, domains), 0);
+}
+/**
+* This function adds the samples of the domains to a palette (D99). It reads the list `samples` of each domain of the
+* table and of each standard domain that the table does not replace. The result holds each value one time.
+*/
+function withDomainSamples(palette, domains) {
+	const out = [];
+	for (const value of palette) addValue(out, value);
+	const names = /* @__PURE__ */ new Set([...Object.keys(STD_DOMAINS), ...domains === void 0 ? [] : Object.keys(domains)]);
+	for (const name of names) {
+		const samples = domainOf(name, domains)?.samples;
+		if (Array.isArray(samples)) for (const value of samples) addValue(out, value);
+	}
+	return out;
+}
+/**
+* This function finds the false covers of a language from samples (D94). A cover is false when a sample of the covered
+* domain is in no domain of the cover. The function tests each valid cover of each domain of the table. It ignores a
+* cover that does not count by the line rule of D85, because `fits` ignores it too. It also ignores a sample outside
+* the covered domain.
+*
+* The samples of the domains come after the given samples (D99). `conforms` and a test of `fits` use the function. The
+* kernel does not export it.
+*
+* @param domains - The domains of the language, by their names.
+* @param samples - The samples of each covered domain, by the name of the domain.
+* @returns Each sample that breaks a cover, in the order of the domains, the covers and the samples.
+*/
+function falseCovers(domains, samples) {
+	const out = [];
+	for (const [name, domain] of Object.entries(domains)) {
+		const covers = domain.covers;
+		if (!Array.isArray(covers)) continue;
+		const values = withDomainSamples((Object.hasOwn(samples, name) ? samples[name] : void 0) ?? [], domains);
+		for (const cover of covers) {
+			if (!validCover(name, cover, domains)) continue;
+			for (const value of values) if (member(value, name, domains) && !cover.some((part) => member(value, part, domains))) out.push({
+				domain: name,
+				cover,
+				value
+			});
+		}
+	}
+	return out;
 }
 /** This function holds the rules of the shapes of `fits`: base types, lists, records and functions. */
 function shapeFits(a, b, domains, next, gradual, budget) {
@@ -963,7 +1006,8 @@ function partFits(part, expected, domains, depth, gradual, state) {
 * cases is a split. An optional field also has the absent case.
 *
 * The type splits follow each value split, in the same order (D90). A base type with a valid cover in its line splits
-* into the domains of the cover. A union without a finite list splits into its members. The prefix is the path of `a`.
+* into the domains of a cover, and it tries each valid cover (D102). A union without a finite list splits into its
+* members. The prefix is the path of `a`.
 */
 function splitsOf(a, domains, depth, prefix = []) {
 	const out = [];
@@ -996,10 +1040,10 @@ function splitsOf(a, domains, depth, prefix = []) {
 				optional
 			});
 			else if (inner.t === "base") {
-				const cover = coverOf(inner.name, domains, false);
-				if (cover !== void 0) later.push({
+				const covers = coversOf(inner.name, domains, false);
+				if (covers.length > 0) later.push({
 					path: [...path, key],
-					types: cover,
+					covers,
 					optional
 				});
 			}
@@ -1013,16 +1057,17 @@ function validCover(name, cover, domains) {
 	return Array.isArray(cover) && cover.length > 0 && cover.every((part) => typeof part === "string" && part !== name && lineOf(part, domains).has(name));
 }
 /**
-* This function gives the cover of a base type for a type split (D90). The cover is the first valid cover of the first
-* domain in the line with a valid cover. With `own`, only the domain of the type itself counts. Each other type gives
-* `undefined`.
+* This function gives the valid covers of a base type for a type split (D90, D102). The order is the order of the line,
+* then the order of the covers of each domain. With `own`, only the domain of the type itself counts.
 */
-function coverOf(name, domains, own) {
+function coversOf(name, domains, own) {
+	const out = [];
 	for (const each of own ? [name] : lineOf(name, domains)) {
 		const covers = domainOf(each, domains)?.covers;
 		if (!Array.isArray(covers)) continue;
-		for (const cover of covers) if (validCover(each, cover, domains)) return cover;
+		for (const cover of covers) if (validCover(each, cover, domains)) out.push(cover);
 	}
+	return out;
 }
 /**
 * This function gives the splits of a case of a type split, at the path of the case (D90). A case with a finite list
@@ -1044,10 +1089,10 @@ function againOf(type, path, domains, depth) {
 		types: form.members,
 		optional: false
 	}];
-	const cover = form.t === "base" ? coverOf(form.name, domains, true) : void 0;
-	return cover === void 0 ? [] : [{
+	const covers = form.t === "base" ? coversOf(form.name, domains, true) : [];
+	return covers.length === 0 ? [] : [{
 		path,
-		types: cover,
+		covers,
 		optional: false
 	}];
 }
@@ -1081,6 +1126,8 @@ function narrowAt(type, path, at, narrowed, domains) {
 * A record of the split that does not fit splits the next such field. A record of a type split first splits its case
 * again, at the same path. One budget of 64 records serves the outer split and each split inside its work, at each
 * depth. Thus nested splits do not multiply the work.
+*
+* A cover split tries each valid cover of its field until one fits (D102). Each try takes from the same budget.
 */
 function splitFits(found, a, expected, domains, depth, gradual, budget) {
 	const splits = splitsOf(a, domains, depth);
@@ -1091,6 +1138,18 @@ function splitFits(found, a, expected, domains, depth, gradual, budget) {
 function casesFit(type, closed, splits, index, expected, domains, depth, gradual, budget) {
 	const split = splits[index];
 	if (split === void 0) return false;
+	if (split.covers !== void 0) {
+		for (const cover of split.covers) {
+			const tried = [...splits];
+			tried[index] = {
+				path: split.path,
+				types: cover,
+				optional: split.optional
+			};
+			if (casesFit(type, closed, tried, index, expected, domains, depth, gradual, budget)) return true;
+		}
+		return false;
+	}
 	const cases = (split.values?.map((value) => ({ one: [value] })) ?? split.types ?? []).map((each) => narrowAt(type, split.path, 0, each, domains));
 	if (split.optional) cases.push(narrowAt(type, split.path, 0, void 0, domains));
 	for (const [at, record] of cases.entries()) {
@@ -1137,16 +1196,18 @@ function casesFit(type, closed, splits, index, expected, domains, depth, gradual
 *   split first, then the paths of each next depth, in the order of the keys. A path goes into a record without a
 *   finite list. Thus `{a: {x: bool}}` fits the union of `{a: {x: true}}` and `{a: {x: false}}`.
 * - A type split comes after each value split (TYPE.FITS-SPLIT-TYPE, D90). A field of a base type with a valid cover in
-*   its line splits into the domains of the first such cover. A field of a union without a finite list splits into its
-*   members. A case that does not fit splits again at its path, by the same rules. A base type there uses only a
-*   cover of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
+*   its line splits into the domains of a cover. A field of a union without a finite list splits into its
+*   members. A case that does not fit splits again at its path, by the same rules. A base type there uses only the
+*   covers of its own domain. Thus `{a: number}` fits `{a: neg} | {a: nonneg}` when `neg` and `nonneg` cover `number`.
+* - A field with more than one valid cover tries each cover until one fits (TYPE.FITS-SPLIT-COVERS, D102). The order
+*   is the order of the line, then the order of the covers of each domain.
 *
 * The relation is sound: a member of `found` is a member of `expected` when no `unknown` is in the types
 * (TYPE.FITS-SOUND). The finite rule trusts `values`, and the cover rule trusts `covers`. Thus a list without a member
 * or a false cover makes the relation unsound for that domain.
 *
-* The relation is not complete. A split builds at most 64 records, with each split inside its work at each depth. A
-* type split uses one cover of a field, not each cover of its line. A domain without `values` gets no finite rule, and
+* The relation is not complete. A split builds at most 64 records, with each split inside its work at each depth. The
+* failed tries of covers take from these 64 records too. A domain without `values` gets no finite rule, and
 * neither does a type with more than 64 members that is not a record. The cover rule tests at most 64 domains of
 * covers. The function does not throw.
 *
@@ -1563,8 +1624,7 @@ function typeIssues(type, domains) {
 	}
 	return issues;
 }
-//#endregion
-//#region src/merge.ts
+// src/merge.ts
 /** The exception of a merge with conflicts. It lists each conflict of the merge, not only the first. */
 var MergeError = class extends Error {
 	conflicts;
@@ -1611,7 +1671,7 @@ function same(a, b) {
 }
 /**
 * Two domains are the same when they are one object. They are also the same when they have the same test `is`,
-* parents, summary, steps, codec, list of values and covers. Thus two languages that give one test under one name give one
+* parents, summary, steps, codec, list of values, samples and covers. Thus two languages that give one test under one name give one
 * domain. Two codecs are the same when they have the same functions `encode` and `decode` (D80).
 */
 function sameDomain(a, b) {
@@ -1623,6 +1683,7 @@ function sameDomain(a, b) {
 		steps: same(a.steps ?? {}, b.steps ?? {}),
 		codec: same(a.codec ?? null, b.codec ?? null),
 		values: same(a.values ?? null, b.values ?? null),
+		samples: same(a.samples ?? null, b.samples ?? null),
 		covers: same(a.covers ?? [], b.covers ?? [])
 	};
 	return Object.values(fields).every(Boolean);
@@ -1630,8 +1691,8 @@ function sameDomain(a, b) {
 /**
 * This function makes a part of a merge that adds parents, steps or covers to a domain of an earlier part
 * (TYPE.PARENTS). An example is a domain of another language. The part reads the domain from the merge before it
-* (`prev`). It gives a copy with the same test, summary, codec and list of values, and it names `["domains", name]`
-* in `replaces` (D17).
+* (`prev`). It gives a copy with the same test, summary, codec, list of values and samples, and it names
+* `["domains", name]` in `replaces` (D17).
 * A domain of the kernel that the earlier parts do not name comes from `STD_DOMAINS`.
 *
 * An extension does not change the codec. Thus each member keeps its document (D80).
@@ -1664,6 +1725,7 @@ function extendDomain(name, more) {
 			steps: Object.keys(steps).length === 0 ? void 0 : steps,
 			codec: found.codec,
 			values: found.values,
+			samples: found.samples,
 			covers: covers.length === 0 ? void 0 : covers
 		};
 		const domain = {};
@@ -2108,8 +2170,7 @@ function restrictMachine(machine, paths) {
 		...tables.domains === void 0 ? {} : { domains: tables.domains }
 	};
 }
-//#endregion
-//#region src/ladder.ts
+// src/ladder.ts
 /** The rungs of the ladder, in the order that a question visits them. */
 const RUNGS = [
 	"own",
@@ -2277,8 +2338,7 @@ function ask(world, doc, verb, options = {}) {
 		steps
 	};
 }
-//#endregion
-//#region src/deref.ts
+// src/deref.ts
 /**
 * The brand of a host thing: an object of the host that answers the steps of a path itself. The brand is a
 * global symbol, thus two copies of the kernel in one program know the things of each other.
@@ -2822,8 +2882,7 @@ function resolveFully$1(nav, ctx, path, hops, known) {
 function valueOfThing(thing) {
 	return isHostThing(thing) ? thing.toJson() : thing;
 }
-//#endregion
-//#region src/classify.ts
+// src/classify.ts
 function isStrictSuperset(larger, smaller) {
 	return larger.length > smaller.length && smaller.every((name) => larger.includes(name));
 }
@@ -2861,8 +2920,7 @@ function classify(shapes, value) {
 function tag(value, kind) {
 	return typed(kind, value);
 }
-//#endregion
-//#region src/parts.ts
+// src/parts.ts
 var Bad = class {
 	reason;
 	at;
@@ -3196,8 +3254,7 @@ function scopesOf(rules, value, slots) {
 		later
 	};
 }
-//#endregion
-//#region src/evaluate.ts
+// src/evaluate.ts
 /**
 * This function makes a context with names and capabilities. The other roots are empty, and an evaluation sets
 * the world.
@@ -3635,6 +3692,11 @@ var Session = class {
 	list;
 	tick = 0;
 	nextId = 0;
+	/**
+	* The count of the drives without a wait that are active at this time. In a run, an effect under such a drive does
+	* not reach the host (RUN.HELD).
+	*/
+	held = 0;
 	current;
 	holder;
 	/**
@@ -3842,6 +3904,11 @@ var Session = class {
 		if ("ok" in made) return made;
 		const perform = this.perform;
 		if (!this.running || perform === void 0) return this.answer(made, place);
+		if (this.held > 0) {
+			made.outcome = fail("#CALC!", heldReason(made.kind), { place });
+			yield HELD;
+			return made.outcome;
+		}
 		let done;
 		try {
 			done = perform(made);
@@ -4021,6 +4088,18 @@ function holderNode() {
 function waitedReason(kindText) {
 	return `${kindText} waits for effects, and its parent cannot wait. Give the parent a runner.`;
 }
+/**
+* This function gives the reason of an effect that a run does not give to the host: the parent of its runner cannot
+* wait (RUN.HELD). The plan and the reference give the same reason.
+*
+* @param kind - The kind of the effect.
+* @returns The reason.
+*/
+function heldReason(kind) {
+	return `The parent of the runner cannot wait, thus the host does not get the effect ${typeof kind === "string" ? kind : kind.join(".")}.`;
+}
+/** The wait of an effect that a run does not give to the host. A drive without a wait stops at it (RUN.HELD). */
+const HELD = /* @__PURE__ */ Promise.resolve(void 0);
 /** This function drives steps that cannot wait. A step that waits stops the steps, and gives `#CALC!`. */
 function drive$2(steps, kindText) {
 	const step = steps.next();
@@ -4649,10 +4728,19 @@ function placedRun(inner, place, name) {
 /**
 * This function gives the code of a runner under a parent that cannot wait: its steps, driven without a wait. An
 * evaluation and a run both drive them (RUN.DRIVE-NESTED). Only a step that really waits gives `#CALC!`, at the place
-* of the runner, where the error started (RUN.WAIT).
+* of the runner, where the error started (RUN.WAIT). In a run, an effect under the runner does not reach the host,
+* because the parent cannot wait for its answer (RUN.HELD).
 */
 function runnerCode(run, place, kindText) {
-	return (ctx, rt) => placed(drive$2(run(ctx, rt), kindText), place);
+	return (ctx, rt) => {
+		if (!rt.running || !(rt instanceof Session)) return placed(drive$2(run(ctx, rt), kindText), place);
+		rt.held += 1;
+		try {
+			return placed(drive$2(run(ctx, rt), kindText), place);
+		} finally {
+			rt.held -= 1;
+		}
+	};
 }
 /** This function gives the steps of a run of an evaluator. The code runs at the first step, and it does not wait. */
 function runOf(code) {
@@ -4993,8 +5081,7 @@ function flatten(trace) {
 function failures(trace) {
 	return flatten(trace).filter((node) => !node.result.ok && !node.children.some((child) => !child.result.ok && child.result.error === node.result.error)).map((node) => node.result.error);
 }
-//#endregion
-//#region src/stdlib.ts
+// src/stdlib.ts
 /**
 * The world of the examples: small kinds for numbers, lists, conditions, names, sequences and effects.
 * Each kind names an evaluator for `eval` and a view for `view`. The site draws each document with its view.
@@ -5895,8 +5982,7 @@ const STD_MACHINE = {
 };
 /** The capabilities of the examples at the root: the two effects of the standard world. */
 const STD_CAPS = ["log", "write"];
-//#endregion
-//#region src/order.ts
+// src/order.ts
 /**
 * This function finds the references that a sequence cannot resolve. A step can read only the steps before it.
 *
@@ -5992,8 +6078,7 @@ function layers(steps) {
 	}
 	return result;
 }
-//#endregion
-//#region src/context.ts
+// src/context.ts
 /** The parts of a context. A term can reach outside itself only through these parts. */
 const PARTS = [
 	"self",
@@ -6281,8 +6366,7 @@ const CONSTRUCTS = [
 		}
 	}
 ];
-//#endregion
-//#region src/typing.ts
+// src/typing.ts
 /**
 * The value type of the root `caps`: a list of capabilities. A capability is a text, or a list of keys. The kernel
 * narrows the capabilities for each part, thus the host does not give this type.
@@ -6509,8 +6593,7 @@ function typePass(machine, nodes, verb, expect, rootTypes = {}) {
 		places
 	};
 }
-//#endregion
-//#region src/static.ts
+// src/static.ts
 /** The names of a walk without names. A walk does not change a set at any time: it makes a new set to add names. */
 const NO_NAMES = /* @__PURE__ */ new Set();
 /** This function gives the options of a walk without the names of the host. */
@@ -7192,8 +7275,7 @@ function checkAll(machine, doc, options, nodes, seen = /* @__PURE__ */ new Set()
 	}
 	return issues;
 }
-//#endregion
-//#region src/facts.ts
+// src/facts.ts
 /** The lazy rules that cover each part: the rules of a document whose evaluator the contract does not describe. */
 const EACH$1 = "each";
 /** An empty list. One frozen list serves each empty list of the facts, thus a store of many facts keeps less (PLAN.LEAN). */
@@ -7422,8 +7504,7 @@ function factsOf(machine, doc, options = {}) {
 		size
 	};
 }
-//#endregion
-//#region src/effects.ts
+// src/effects.ts
 /** Each capability: one capability with no keys. It permits each effect, because each kind starts with no keys (CAP.KEYS). */
 const EACH = /* @__PURE__ */ Object.freeze([[]]);
 /**
@@ -7503,8 +7584,7 @@ function checkLatent(machine, declared, body, options = {}) {
 	}
 	return issues;
 }
-//#endregion
-//#region src/codec.ts
+// 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;
@@ -7675,8 +7755,7 @@ function encodeValue(machine, value) {
 function decodeValue(machine, doc) {
 	return prepare(machine, doc, { declaredType: "lit" }).evaluate(makeContext());
 }
-//#endregion
-//#region src/formula.ts
+// src/formula.ts
 /** The mark of a field that the profile leaves out of a record. */
 const SKIPPED = /* @__PURE__ */ Symbol("skipped");
 /** The value of a name whose binding failed. A reference to the name gives the error. */
@@ -7937,7 +8016,7 @@ function paramsOf(value) {
 /**
 * This function makes the type rules of the formula kit for one profile (TYPE.SYNTH, D25). Each evaluator of the kit
 * holds its rule. The rules read the rules of the profile that change a type: `truthy`, `truthType`, `logic`,
-* `otherwise`, `omit` and `sigs`.
+* `otherwise`, `omit`, `sigs` and `extTypes`.
 */
 function formulaTypes(profile) {
 	const declared = profile.truthy !== void 0 && profile.truthType !== void 0;
@@ -8191,7 +8270,13 @@ function formulaTypes(profile) {
 		},
 		"formula.ext": { synth: (input) => {
 			const name = nameOf(input);
-			if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) return "unknown";
+			if (profile.ext !== void 0 && Object.hasOwn(profile.ext, name)) {
+				const types = profile.extTypes;
+				const declared = types !== void 0 && Object.hasOwn(types, name) ? types[name] : void 0;
+				if (declared === void 0) return "unknown";
+				const type = input.contract(declared, `type of ext.${name} in extTypes`);
+				return typeIssues(type, input.machine.domains).length > 0 ? "unknown" : type;
+			}
 			if (name === "undefined") return "undefined";
 			if (name === "number") return "number";
 			return name === "domain" ? domainTypeOf(input.doc.value, input.machine.domains) : "unknown";
@@ -8257,6 +8342,7 @@ const PROFILE_KEYS = /* @__PURE__ */ Object.freeze([
 	"ops",
 	"lazy",
 	"ext",
+	"extTypes",
 	"truthy",
 	"truthType",
 	"otherwise",
@@ -8772,8 +8858,7 @@ function formulaMachine(profile = {}, more = {}) {
 		facts: kit.facts
 	}, more);
 }
-//#endregion
-//#region src/syntax.ts
+// 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
@@ -9869,8 +9954,7 @@ function syntaxFormat(profile) {
 		evaluators: { "syntax.format": code }
 	};
 }
-//#endregion
-//#region src/reference.ts
+// src/reference.ts
 function own$1(table, name) {
 	return table !== void 0 && Object.hasOwn(table, name) ? table[name] : void 0;
 }
@@ -10056,6 +10140,11 @@ function* causeAndWait(env, ctx, kind, payload, place) {
 	if ("ok" in effect) return effect;
 	const perform = env.perform;
 	if (perform === void 0) return effect.outcome = ok(payload);
+	if (env.held > 0) {
+		effect.outcome = fail("#CALC!", heldReason(kind), { place });
+		yield Promise.resolve(void 0);
+		return effect.outcome;
+	}
 	let given;
 	try {
 		given = perform(effect);
@@ -10125,7 +10214,15 @@ function evaluateSeen(env, seen, at) {
 	const { chosen } = seen;
 	const { place } = at;
 	if ("gap" in chosen) return fail("#NOEVAL", chosen.gap, { place });
-	if ("runner" in chosen) return drive$1(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
+	if ("runner" in chosen) {
+		if (!env.running) return drive$1(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
+		env.held += 1;
+		try {
+			return drive$1(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
+		} finally {
+			env.held -= 1;
+		}
+	}
 	const input = evalInput(env, seen, at);
 	try {
 		return placed(chosen.evaluator(input), place);
@@ -10385,6 +10482,7 @@ function envOf(machine, options, running, root, outer) {
 			counts: /* @__PURE__ */ new Map(),
 			alls: 0
 		},
+		held: 0,
 		reading: outer ?? (options.reads === void 0 ? void 0 : {
 			list: options.reads,
 			root
@@ -10886,8 +10984,7 @@ function valuesOfStrict(parts) {
 	}
 	return { values };
 }
-//#endregion
-//#region src/replay.ts
+// src/replay.ts
 /**
 * This function makes a recorder (RUN.RECORD). The recorder gives each effect to the function `perform` of the host.
 * Its log keeps each effect with its address, its kind, its payload and the outcome that the kernel gives it. The log
@@ -11053,8 +11150,60 @@ function holdsHole(value) {
 	return false;
 }
 /**
+* This function gives the lists and the plain records that the walk of `causeJson` keeps as containers of parts, also
+* with a term document (D101). Such a container is at two places of the walk, or it holds such a container at some depth.
+* It reads the values as the walk does: the fields of an exception, its hidden fields and its cause, and the items of a
+* container. A term document gives a copy at each place, thus a shared container cannot be one.
+*/
+function sharedOf(root) {
+	const seen = /* @__PURE__ */ new Set();
+	const twice = [];
+	const owners = /* @__PURE__ */ new Map();
+	const stack = [[root, void 0]];
+	for (let next = stack.pop(); next !== void 0; next = stack.pop()) {
+		const [at, owner] = next;
+		if (typeof at !== "object" || at === null) continue;
+		const container = Array.isArray(at) || isRecord(at);
+		if (!container && !(at instanceof Error)) continue;
+		if (container && owner !== void 0) {
+			const list = owners.get(at);
+			if (list === void 0) owners.set(at, [owner]);
+			else list.push(owner);
+		}
+		if (seen.has(at)) {
+			if (container) twice.push(at);
+			continue;
+		}
+		seen.add(at);
+		if (Array.isArray(at)) {
+			for (let item = 0; item < at.length; item += 1) if (Object.hasOwn(at, item)) stack.push([readField(at, item), at]);
+		} else if (container) for (const key of Object.keys(at)) stack.push([readField(at, key), at]);
+		else {
+			for (const key of Object.keys(at)) if (!ownField(key)) stack.push([readField(at, key), void 0]);
+			for (const key of HIDDEN) if (Object.getOwnPropertyDescriptor(at, key)?.enumerable === false) stack.push([readField(at, key), void 0]);
+			if (Object.hasOwn(at, "cause")) stack.push([readField(at, "cause"), void 0]);
+		}
+	}
+	const shared = /* @__PURE__ */ new Set();
+	for (let at = twice.pop(); at !== void 0; at = twice.pop()) {
+		if (shared.has(at)) continue;
+		shared.add(at);
+		for (const owner of owners.get(at) ?? []) twice.push(owner);
+	}
+	return shared;
+}
+/**
+* This function tells if the walk of `causeJson` keeps a value with a term document as a container of parts (D101). The
+* value is in the set of `sharedOf`. A member of a domain stays a term document, because its codec makes it again.
+*/
+function wholeOf(shared, value, term) {
+	if (typeof value !== "object" || value === null || !shared.has(value)) return false;
+	const type = isRecord(term) ? term["type"] : void 0;
+	return !(Array.isArray(type) && type[0] === "ext" && type[1] === "domain");
+}
+/**
 * This function tells if a list or a plain record holds an exception at some depth (D87). It reads the items as the
-* walk of `causeJson` does, thus a cause container with an exception gets a form.
+* walk of `causeJson` does, thus a container cause of an error value with an exception gets a form.
 */
 function holdsException(value) {
 	const seen = /* @__PURE__ */ new Set();
@@ -11116,13 +11265,15 @@ function keptOf(keys, built) {
 *
 * The walk gives each exception an index in the order of a depth-first walk. It takes the fields in `parts` in the
 * order of their keys, the hidden fields in the order of `HIDDEN`, then the cause (D78). A list or a plain record
-* without a term document is a container of parts, with its items in their order (D82). A cause is a container only
-* when it holds an exception (D87). A value that is an earlier exception of the walk is its index in `loop` (D77).
+* without a term document is a container of parts, with its items in their order (D82). The cause of an error value
+* is a container only when it holds an exception (D87). The cause of an exception is a container as a field is (D100).
+* A value that is an earlier exception of the walk is its index in `loop` (D77).
 *
-* A container that an earlier place holds is its index in `share`, also a container that holds itself (D88). The walk is
-* a loop, thus a long chain does not overflow the stack.
+* A container that an earlier place holds is its index in `share`, also a container that holds itself (D88). A container
+* of `sharedOf` is a container of parts also with a term document, thus each share gives one object (D101). The value
+* `tried` marks a root that `encodeValue` cannot write. The walk is a loop, thus a long chain does not overflow the stack.
 */
-function causeJson(machine, root) {
+function causeJson(machine, root, shared, tried) {
 	const items = [];
 	const index = /* @__PURE__ */ new Map();
 	const holders = /* @__PURE__ */ new Map();
@@ -11170,7 +11321,16 @@ function causeJson(machine, root) {
 			if (ownField(key)) continue;
 			const value = readField(current, key);
 			const term = value === MISSING ? void 0 : termOrNothing(machine, value);
-			if (term === void 0) linked.push([key, value]);
+			if (term === void 0) linked.push([
+				key,
+				value,
+				true
+			]);
+			else if (wholeOf(shared, value, term)) linked.push([
+				key,
+				value,
+				false
+			]);
 			else fields.push([key, term]);
 		}
 		const node = {
@@ -11187,14 +11347,14 @@ function causeJson(machine, root) {
 		items.push(node);
 		const children = [];
 		for (let place = 0; place < linked.length; place += 1) {
-			const [key, value] = linked[place];
+			const [key, value, without] = linked[place];
 			const put = (part) => {
 				node.parts[place] = part;
 			};
 			children.push({
 				value,
 				name: key,
-				tried: true,
+				tried: without,
 				nest: true,
 				keep: false,
 				put
@@ -11225,7 +11385,7 @@ function causeJson(machine, root) {
 				value: current.cause,
 				name: "cause",
 				tried: false,
-				nest: false,
+				nest: true,
 				keep: false,
 				put
 			});
@@ -11237,7 +11397,7 @@ function causeJson(machine, root) {
 	tasks.push({
 		value: root,
 		name: "cause",
-		tried: true,
+		tried,
 		nest: false,
 		keep: false,
 		put: (part) => {
@@ -11255,22 +11415,24 @@ function causeJson(machine, root) {
 			task.put({ loop });
 			continue;
 		}
+		const container = Array.isArray(value) || isRecord(value);
+		const held = container ? holders.get(value) : void 0;
+		if (held !== void 0) {
+			if (task.keep) items[held].keep = true;
+			task.put({
+				same: held,
+				name: task.name
+			});
+			continue;
+		}
 		const term = task.tried || task.keep ? void 0 : termOrNothing(machine, value);
-		if (term !== void 0) task.put({ value: term });
+		const whole = term !== void 0 && wholeOf(shared, value, term);
+		if (term !== void 0 && !whole) task.put({ value: term });
 		else if (value instanceof Error) task.put({ node: open(value) });
-		else if ((Array.isArray(value) || isRecord(value)) && (task.nest || holdsException(value))) {
-			const held = holders.get(value);
-			if (held === void 0) {
-				const children = [];
-				task.put({ holder: hold(task.name, value, task.keep, children) });
-				later(children);
-			} else {
-				if (task.keep) items[held].keep = true;
-				task.put({
-					same: held,
-					name: task.name
-				});
-			}
+		else if (container && (whole || task.nest || holdsException(value))) {
+			const children = [];
+			task.put({ holder: hold(task.name, value, task.keep || whole, children) });
+			later(children);
 		} else task.put({ none: task.name });
 	}
 	const { formed, shares } = formsOf(items);
@@ -11394,20 +11556,25 @@ function errorJson(machine, error, what) {
 	};
 	if (!Object.hasOwn(error, "cause")) return base;
 	const cause = error.cause;
+	const shared = sharedOf(cause);
+	let term;
+	let failure;
 	try {
-		return {
-			...base,
-			cause: encodeValue(machine, cause)
-		};
-	} catch (failure) {
-		const { link, names } = causeJson(machine, cause);
-		if (link === void 0) throw new TypeError(`encodeLog cannot write the cause of ${what()}: ${messageOf(failure)}`);
-		return {
-			...base,
-			...link,
-			...names.length === 0 ? {} : { dropped: names }
-		};
+		term = encodeValue(machine, cause);
+	} catch (thrown) {
+		failure = thrown;
 	}
+	if (term !== void 0 && !wholeOf(shared, cause, term)) return {
+		...base,
+		cause: term
+	};
+	const { link, names } = causeJson(machine, cause, shared, term === void 0);
+	if (link === void 0) throw new TypeError(`encodeLog cannot write the cause of ${what()}: ${messageOf(failure)}`);
+	return {
+		...base,
+		...link,
+		...names.length === 0 ? {} : { dropped: names }
+	};
 }
 /**
 * This function writes a log as JSON (RUN.REPLAY-JSON, D75). Then `JSON.stringify` gives the text of a golden file.
@@ -11424,8 +11591,12 @@ function errorJson(machine, error, what) {
 *   (RUN.REPLAY-FIELDS, D78, D82). An item of a list without a form is the mark `dropped` at its place.
 * - A cause without a term document that is a list or a plain record with an exception is in `causeParts`
 *   (RUN.REPLAY-CAUSE-PARTS, D87). The rule is the same for the cause of an exception and of an error value.
+* - The cause of an exception is also in `causeParts` without an exception in it, when an item has a form
+*   (RUN.REPLAY-CAUSE-ITEMS, D100). Each item without a form is a name in `dropped`, for example `cause.send`.
 * - A list or a record of parts that an earlier place of one error holds is the part `share` with its index
 *   (RUN.REPLAY-SHARED, D88). This rule also covers a container that holds itself.
+* - A list or a plain record with a term document that two places of one error share is a container of parts
+*   (RUN.REPLAY-SHARED-VALUES, D101). Each later place is a share. A member of a domain stays a term document.
 * - An outcome that the log does not have stays absent.
 *
 * @param machine - The machine of the run, or only its domains.
@@ -11856,8 +12027,7 @@ function decodeLog(machine, data) {
 		settles
 	});
 }
-//#endregion
-//#region src/agree.ts
+// src/agree.ts
 /** The tiers that `agree` compares when its options name none. */
 const DEFAULT_TIERS = /* @__PURE__ */ Object.freeze([
 	"reference",
@@ -12330,8 +12500,7 @@ async function agreeRun(machine, doc, context = makeContext(), options = {}) {
 		reads: compared
 	};
 }
-//#endregion
-//#region src/generate.ts
+// src/generate.ts
 /**
 * This function makes a source of random numbers with a seed (the algorithm mulberry32). It needs no package.
 *
@@ -12733,8 +12902,7 @@ function generate(world, options) {
 		hint: void 0
 	});
 }
-//#endregion
-//#region src/conform.ts
+// src/conform.ts
 /** The order of the obligations in the list of findings. */
 const ORDER = [
 	"C1",
@@ -12747,7 +12915,8 @@ const ORDER = [
 	"C8",
 	"local",
 	"agree",
-	"truth"
+	"truth",
+	"cover"
 ];
 /** A function in the results of the probe parts. It gives the count of its arguments. */
 const PROBE_FN = (...args) => args.length;
@@ -13627,7 +13796,8 @@ function examine(env, sample, contract) {
 /**
 * This function checks the declared truth of a profile (D86). The function `truthy` must give `true` or `false` for
 * each member of `truthType`, and it must not throw. The members come from the lists `values` of the domains of the
-* type. A type without such a list gets the values of the results of the palette that are its members.
+* type. A type without such a list gets its members from the results of the palette and from the samples of the
+* domains (D99).
 */
 function checkTruth(env, code, probe) {
 	const truth = declaredTruthOf(code);
@@ -13650,6 +13820,21 @@ function checkTruth(env, code, probe) {
 	}
 }
 /**
+* This function checks the covers of the domains of the machine from samples (D94). Each sample of a covered domain
+* must be in one domain of each valid cover. The samples of a domain come from its list `values`. A domain without
+* that list gets its members from the palette and from the samples of the domains, as for the check `truth`.
+*/
+function checkCovers(env, probe) {
+	const domains = env.machine.domains;
+	if (domains === void 0) return;
+	const palette = env.results.flatMap((result) => result.ok ? [result.value] : []);
+	const samples = {};
+	for (const [name, domain] of Object.entries(domains)) if (domain.covers !== void 0) samples[name] = membersOf(name, domains, palette);
+	const found = falseCovers(domains, samples)[0];
+	if (found === void 0) return;
+	report(env, "cover", `The member ${valueText(found.value)} of the domain ${found.domain} is in no domain of its cover ${found.cover.join(", ")}. The check of types trusts the cover, thus it is unsound for ${found.domain}.`, () => probe(found.value));
+}
+/**
 * This function examines one evaluator or runner of a machine against the obligations of host code (K92, D36). It
 * starts the code directly, without the kernel, with probe parts and a probe runtime. It generates probe documents from
 * the contract of each kind that names the code, and it gives the probe parts chosen and random results.
@@ -13659,7 +13844,8 @@ function checkTruth(env, code, probe) {
 * compiled code with its definition. The finding of an obligation names the first probe that breaks it. An empty list
 * means that each probe conforms.
 *
-* The check `truth` tests the declared truth of a formula profile (D86).
+* The check `truth` tests the declared truth of a formula profile (D86). The check `cover` tests the covers of the
+* domains of the machine from samples (D94).
 *
 * @param machine - The machine with the code and the world of the kinds.
 * @param name - The name of the evaluator or of the runner. A runner wins over an evaluator of the same name.
@@ -13702,7 +13888,7 @@ function conforms(machine, name, options = {}) {
 			examine(env, sample, contract);
 		}
 	}
-	checkTruth(env, code, (value) => first === void 0 ? {
+	const probeWith = (value) => first === void 0 ? {
 		type: typeName(types[0]),
 		doc: {
 			type: types[0],
@@ -13717,11 +13903,12 @@ function conforms(machine, name, options = {}) {
 		waits: [],
 		caps: NO_CAPS,
 		running: runner
-	}));
+	});
+	checkTruth(env, code, probeWith);
+	checkCovers(env, probeWith);
 	return ORDER.filter((obligation) => env.found.has(obligation)).map((obligation) => env.found.get(obligation));
 }
-//#endregion
-//#region src/same.ts
+// src/same.ts
 /**
 * This function tells if two results are the same for an early cutoff (RESULT.SAME). A schedule uses it to stop the
 * work when a part that evaluates again gives the same result. A wrong `true` keeps a stale value, but a wrong `false`
@@ -13757,8 +13944,7 @@ function sameError(a, b) {
 	if (a.place === void 0 || b.place === void 0) return a.place === b.place;
 	return docEquals(a.place, b.place);
 }
-//#endregion
-//#region src/reads.ts
+// src/reads.ts
 /** One answer serves each list whose reads are all the same. */
 const SAME = /* @__PURE__ */ Object.freeze({ same: true });
 /** This function tells if two lists of hops are the same: the same steps, rungs and things, in order. */
@@ -13849,8 +14035,7 @@ function verifyReads(target, reads, context, options = {}) {
 	}
 	return SAME;
 }
-//#endregion
-//#region src/durable.ts
+// src/durable.ts
 /** The most values that a cache of value documents keeps, as in `planner`. */
 const MAX_VALUES = 1e3;
 /** No reads. One frozen list serves each result of a pure document without reads. */
@@ -13990,8 +14175,7 @@ function durable(machine, options = {}) {
 		}
 	};
 }
-//#endregion
-//#region src/graph.ts
+// src/graph.ts
 /** This function gives the indexed form of a graph, with the edges that the options keep. */
 function indexed(graph, options) {
 	const eager = options.eager === true;
@@ -14321,8 +14505,7 @@ function deepestFirst(from, edgesOf) {
 	}
 	return out;
 }
-//#endregion
-//#region src/schedule.ts
+// src/schedule.ts
 /**
 * This function gives the edges of a node from the static facts of its document (SCHED.EDGES). Each read of the root
 * `world` is an edge to the node of its first key. The keys after that key are the field of the edge (SCHED.GRAIN).
@@ -14616,8 +14799,7 @@ function schedule(machine, options = {}) {
 		}
 	};
 }
-//#endregion
-//#region src/meaning.ts
+// src/meaning.ts
 /** A list of eight reference types. The generator then gives more references, thus more reads of nodes. */
 function moreRefs() {
 	return Array.from({ length: 8 }, () => ["ref"]);
@@ -15016,8 +15198,7 @@ function agreeSchedule(engine, options = {}) {
 		counts
 	};
 }
-//#endregion
-//#region src/providers.ts
+// src/providers.ts
 /** The deepest schema that `typeFromSchema` reads. A deeper schema reads as `unknown`. */
 const MAX_SCHEMA_DEPTH = 256;
 /** The keywords that describe a schema and do not test a value. The reading ignores them without an issue. */
@@ -15326,7 +15507,6 @@ function samplesAt(values, closed, depth) {
 function typeFromSamples(values, options = {}) {
 	return samplesAt(values, options.closed === true, 0);
 }
-//#endregion
 export { ATTRIBUTE_RUNGS, CAPS_TYPE, CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_DOMAINS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_SYNTAX, STD_WALKERS, STD_WORLD, THING, WORLD_SYNTAX, agree, agreeRun, agreeSchedule, ask, attributeTrace, capKeys, check, checkLatent, checkSteps, checkWorld, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeLog, decodeValue, derefStep, describe, docEquals, 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, 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, random, recorder, ref, reference, referenceRun, 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