@mark1russell7/coeval 0.8.0 → 0.9.0

package/build/index.js

@@ -2071,7 +2071,7 @@ function context(parts = {}) {
 	};
 }
 const MAX_COLLAPSE = 64;
-const NO_HOPS = /* @__PURE__ */ Object.freeze([]);
+const NO_HOPS$1 = /* @__PURE__ */ Object.freeze([]);
 /** A value that can be a reference document: a record with the type `ref`. The full check comes after. */
 function mayBeRef(thing) {
 	return typeof thing === "object" && thing !== null && thing.type === "ref";
@@ -2122,13 +2122,13 @@ function walkQuick(start, path, plain, keyed) {
 				ok: false,
 				code: "#N/A",
 				reason: `The path ${keys.join(".")} reaches nothing.`,
-				hops: NO_HOPS
+				hops: NO_HOPS$1
 			};
 			if (!plain && mayBeRef(reached.thing)) return void 0;
 			return {
 				ok: true,
 				thing: reached.thing,
-				hops: NO_HOPS
+				hops: NO_HOPS$1
 			};
 		}
 		const step = path[index];
@@ -2145,7 +2145,7 @@ function walkQuick(start, path, plain, keyed) {
 	return {
 		ok: true,
 		thing: here,
-		hops: NO_HOPS
+		hops: NO_HOPS$1
 	};
 }
 /** The root whose value starts the short path of a compiled path. `FULL` takes the full algorithm at once. */
@@ -2256,7 +2256,7 @@ function resolve(nav, ctx, path, options = {}) {
 * @returns What the path reached and each hop, or an error.
 */
 function resolveFully$1(nav, ctx, path, hops, known) {
-	const done = hops ?? NO_HOPS;
+	const done = hops ?? NO_HOPS$1;
 	const failed = (code, reason) => ({
 		ok: false,
 		code,
@@ -3054,6 +3054,7 @@ var Session = class {
 		if (reading === void 0) return this.find(ctx, path, compiled, hops);
 		const free = isFree(reading.root, ctx, path);
 		if (!free && path[0] === "self" && !reading.self) this.keep(reading, ["self"]);
+		else if (free && path.length === 1 && path[0] === "self") reading.self = true;
 		let found;
 		try {
 			found = this.find(ctx, path, compiled, hops);
@@ -4290,6 +4291,7 @@ const STD_WORLD = {
 			caps: [{ rule: "mask" }],
 			pure: true,
 			lazy: [{}],
+			reads: ["self"],
 			summary: "A node of a tree. Each part is an attribute that evaluates on demand, one time, with the node as self."
 		},
 		box: {
@@ -4309,6 +4311,7 @@ const STD_WORLD = {
 			caps: [{ rule: "mask" }],
 			pure: true,
 			lazy: [{}],
+			reads: ["self"],
 			summary: "A node of a tree, as panel. A formula in a box can read its parent and its siblings."
 		},
 		math: { kinds: {
@@ -4553,11 +4556,12 @@ function plainOf(value, path) {
 * step `type` gives its type. Another step reads an attribute through its ladder (TREE.LADDER). The rungs are a part of
 * the node, an equation of its kind and an equation `down` of the kind of its parent. A copy from the parent, then a
 * fold or a default, come last. A failed attribute throws `Failure` with its own error, thus a reference to it gives that error.
+* The argument `outer` is the self of the context, that `treeNode` resolved. The node reads no root of the context directly (C4).
 */
-function treeThing(input, build) {
+function treeThing(input, build, outer) {
 	const { parts, context, kind: type, place, machine } = input;
 	const { tree, of } = contractOf$1(machine, input.typePath);
-	const above = stateOf(context.self);
+	const above = stateOf(outer);
 	const up = above !== void 0 && above.build === build ? above : void 0;
 	const cells = /* @__PURE__ */ new Map();
 	/** The positions of the items of the list `children`, for the names of the children. */
@@ -4721,7 +4725,7 @@ function treeThing(input, build) {
 		type,
 		label: `node ${type}`,
 		deref(key) {
-			if (key === "parent") return context.self;
+			if (key === "parent") return outer;
 			if (key === "type") return type;
 			const result = read(String(key));
 			if (result === void 0) return void 0;
@@ -4752,15 +4756,22 @@ function treeThing(input, build) {
 function attributeTrace(node, attribute) {
 	return stateOf(node)?.trace(attribute);
 }
+/** The path of the root `self`. A node of the tree resolves it, thus the list of reads holds the read (C4). */
+const SELF_PATH = /* @__PURE__ */ Object.freeze(["self"]);
+/** The options of the resolution of `self`: the node needs no hops. */
+const NO_HOPS = /* @__PURE__ */ Object.freeze({ hops: false });
 /**
 * This function evaluates a node of the decorated tree. Inside an attribute of an open tree, the node gives its host
-* thing, and no attribute evaluates. Else the node is the root of a new tree, and it gives the JSON of the tree.
+* thing, and no attribute evaluates. Else the node is the root of a new tree, and it gives the JSON of the tree. The
+* node reads `self` through `resolve` (C4, D44). A machine that closes the root `self` thus gives no nested trees.
 */
 function treeNode(input) {
-	const above = stateOf(input.context.self);
-	if (above !== void 0 && above.build.open) return ok(treeThing(input, above.build));
+	const found = input.resolve(SELF_PATH, NO_HOPS);
+	const outer = found.ok ? found.thing : void 0;
+	const above = stateOf(outer);
+	if (above !== void 0 && above.build.open) return ok(treeThing(input, above.build, outer));
 	const build = { open: true };
-	const root = treeThing(input, build);
+	const root = treeThing(input, build, outer);
 	try {
 		return stateOf(root).json(/* @__PURE__ */ new Set());
 	} finally {
@@ -5847,6 +5858,66 @@ function typeCheck(machine, doc, options = {}) {
 		places: pass.places
 	};
 }
+/** This function tells if a table of verbs has an entry for a verb. */
+function hasVerb(table, verb) {
+	return table !== void 0 && Object.hasOwn(table, verb);
+}
+/**
+* This function checks the world of a machine before a document exists. It finds each kind that has no entry for a
+* verb of the list, when the world has no default for that verb (STATIC.COVERAGE). A document of such a kind gets no
+* evaluator for the verb, thus the check gives the same proof of coverage as a type system.
+*
+* The check visits each kind of each namespace, at each depth, and the fallback kind of each namespace and of the
+* world. It does not follow an alias, because the kind of an alias has its own place. The check reads only the world.
+*
+* @param machine - The machine, for its world.
+* @param verbs - The verbs that each kind of the language must answer, for example `eval`, `view` and `type`.
+* @returns One issue for each kind and verb without an evaluator. The order is the order of the world, then the
+*   order of the verbs. The fallback kind of a namespace comes after the entries of that namespace.
+*/
+function checkWorld(machine, verbs) {
+	const world = machine.world;
+	const open = verbs.filter((verb) => !hasVerb(world.defaults, verb));
+	const out = [];
+	if (open.length === 0) return out;
+	const visit = (kind, path, fallback) => {
+		const text = path.join(".");
+		const name = fallback ? path.length === 0 ? "the fallback kind of the world" : `the fallback kind of ${text}` : `the kind ${text}`;
+		for (const verb of open) {
+			if (hasVerb(kind.verbs, verb)) continue;
+			const reason = `${name.charAt(0).toUpperCase()}${name.slice(1)} has no entry for the verb ${verb}, and the world has no default for it.`;
+			out.push(fallback ? {
+				code: "#NOEVAL",
+				kind: path,
+				fallback: true,
+				verb,
+				reason
+			} : {
+				code: "#NOEVAL",
+				kind: path,
+				verb,
+				reason
+			});
+		}
+	};
+	const way = /* @__PURE__ */ new Set();
+	const entries = (kinds, path) => {
+		for (const key of Object.keys(kinds)) {
+			const entry = kinds[key];
+			const here = [...path, key];
+			if (isKind(entry)) visit(entry, here, false);
+			else if (isNamespace(entry) && !way.has(entry)) {
+				way.add(entry);
+				entries(entry.kinds, here);
+				if (entry.fallback !== void 0) visit(entry.fallback, here, true);
+				way.delete(entry);
+			}
+		}
+	};
+	entries(world.kinds, []);
+	if (world.fallback !== void 0) visit(world.fallback, [], true);
+	return out;
+}
 /** The names that an equation of `down` sees (TREE.DOWN). */
 const DOWN_NAMES = /* @__PURE__ */ Object.freeze([
 	"child",
@@ -6178,7 +6249,8 @@ function partLazy(above, parent, slot) {
 * by the contracts of its kinds:
 *
 * - `reads`: each free reference, with the root and the keys of its path. A read under a lazy part has the mark
-*   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`.
+*   `lazy`, for example a read in a branch of `if`. A read after a step document has `exact: false`. A kind that
+*   declares `reads` adds a read of each of its roots at each document of the kind.
 * - `side` and `effects`: from the contract of each kind.
 * - `pure`: each kind declares `pure`, and the document has no effect and is not volatile.
 * - `volatile`: a kind, an operation or a step document declares `volatile`, or the host marks a read.
@@ -6231,18 +6303,35 @@ function factsOf(machine, doc, options = {}) {
 		}
 		const code = codeOf(world, v.declared ? void 0 : v.doc.own, kind, verb, "eval");
 		const answer = code.name === void 0 ? void 0 : hook?.(v.typePath ?? [], code.name);
+		let roots;
 		if (code.described) {
 			note(answer?.pure ?? kind.pure, answer?.volatile ?? kind.volatile);
 			above.set(v, {
 				lazy,
 				rules: answer?.lazy ?? kind.lazy
 			});
+			roots = answer?.reads ?? kind.reads;
 		} else {
 			note(answer?.pure, answer?.volatile);
 			above.set(v, {
 				lazy,
 				rules: answer?.lazy ?? EACH$1
 			});
+			roots = answer?.reads;
+		}
+		for (const root of roots ?? NONE) {
+			const read = {
+				root,
+				keys: NONE,
+				exact: true,
+				lazy,
+				address: false,
+				path: [root],
+				place: tight(v.place),
+				at: tight(v.at)
+			};
+			reads.push(read);
+			if (options.volatile?.(read) === true) volatile = true;
 		}
 		if (kind.side === "run") side = "run";
 		for (const keys of declaredEffects(v)) {
@@ -7060,22 +7149,110 @@ function formulaTypes(profile) {
 * This function makes the evaluators of the formula kit for one language. Each evaluator compiles its document
 * one time into code. Each evaluator also holds its type rule, for a check of types (TYPE.SYNTH).
 *
+* Equal profiles give the same evaluator objects (COMPOSE.UNIFY, D46). Thus two machines of one profile merge without
+* a conflict. Each call gives a new record. Each evaluator object is frozen, because many machines can share it.
+*
 * @param profile - The operations and the rules of the language.
 * @returns The evaluators, by their name.
 */
 function formulaEvaluators(profile = {}) {
+	return { ...kitOf(profile).evaluators };
+}
+/** This function makes new evaluators of the formula kit for the fields of one profile. */
+function makeEvaluators(profile) {
 	const evaluators = formulaCode(profile);
 	const types = formulaTypes(profile);
 	const out = {};
 	for (const name of Object.keys(evaluators)) {
 		const evaluator = evaluators[name];
 		const type = Object.hasOwn(types, name) ? types[name] : void 0;
-		out[name] = type === void 0 ? evaluator : {
+		out[name] = Object.freeze(type === void 0 ? evaluator : {
 			compile: evaluator.compile,
 			type
+		});
+	}
+	return Object.freeze(out);
+}
+/** The keys of a profile that the kit reads. The kit ignores each other key. */
+const PROFILE_KEYS = /* @__PURE__ */ Object.freeze([
+	"ops",
+	"lazy",
+	"ext",
+	"truthy",
+	"otherwise",
+	"logic",
+	"omit",
+	"missing",
+	"check",
+	"combine",
+	"pure",
+	"volatile",
+	"sigs"
+]);
+/** The number of recent kits that a profile in a new object can find by its fields. */
+const RECENT_KITS = 16;
+/** The kit of each profile object. A kit goes when its profile object goes. */
+const kitsByProfile = /* @__PURE__ */ new WeakMap();
+/** The recent kits, the most recent first. The list holds `RECENT_KITS` kits or fewer. */
+const recentKits = [];
+/**
+* This function gives the canonical form of a profile: a frozen record of the fields that the kit reads. A field
+* with the value `undefined` is absent, but `otherwise` is present when the profile has it as an own key. A list
+* is a frozen copy. Each other value stays the same object.
+*/
+function fieldsOf(profile) {
+	const out = {};
+	for (const key of PROFILE_KEYS) {
+		if (key === "otherwise" ? !Object.hasOwn(profile, key) : profile[key] === void 0) continue;
+		const value = profile[key];
+		out[key] = Array.isArray(value) ? Object.freeze([...value]) : value;
+	}
+	return Object.freeze(out);
+}
+/**
+* This function tells if two canonical forms are equal. They must have the same keys. A function, a record and a host
+* value are equal only to themselves. Two lists are equal when their items are the same, in order.
+*/
+function sameFields(a, b) {
+	const left = a;
+	const right = b;
+	const keys = Object.keys(left);
+	if (keys.length !== Object.keys(right).length) return false;
+	return keys.every((key) => {
+		if (!Object.hasOwn(right, key)) return false;
+		const x = left[key];
+		const y = right[key];
+		if (Object.is(x, y)) return true;
+		return Array.isArray(x) && Array.isArray(y) && x.length === y.length && x.every((item, index) => Object.is(item, y[index]));
+	});
+}
+/**
+* This function gives the kit of a profile (D46). A profile object that the kit knows, with the same fields, gives its
+* kit. Then a recent kit with equal fields serves a new profile object. Else the function makes a new kit from the
+* canonical form. Thus a later change of a field of the profile object gives a new kit, and an old kit does not change.
+*/
+function kitOf(profile) {
+	const fields = fieldsOf(profile);
+	const known = kitsByProfile.get(profile);
+	if (known !== void 0 && sameFields(known.fields, fields)) return known;
+	const index = recentKits.findIndex((kit) => sameFields(kit.fields, fields));
+	let kit;
+	if (index >= 0) {
+		kit = recentKits[index];
+		recentKits.splice(index, 1);
+	} else {
+		const hook = makeKnown(fields);
+		kit = {
+			fields,
+			evaluators: makeEvaluators(fields),
+			known: hook,
+			facts: makeFacts(fields, hook)
 		};
 	}
-	return out;
+	recentKits.unshift(kit);
+	if (recentKits.length > RECENT_KITS) recentKits.length = RECENT_KITS;
+	kitsByProfile.set(profile, kit);
+	return kit;
 }
 /** This function makes the code of the evaluators of the formula kit, without their type rules. */
 function formulaCode(profile) {
@@ -7394,10 +7571,16 @@ function formulaCode(profile) {
 * `formula.ext` knows an extension of `ext` and each standard extension. The hook knows each name of the other
 * evaluators.
 *
+* Equal profiles give the same hook (D46).
+*
 * @param profile - The operations and the extensions of the language.
 * @returns The hook: `true`, or the reason of the `#NAME?` that the evaluator gives in a run.
 */
 function formulaKnown(profile = {}) {
+	return kitOf(profile).known;
+}
+/** This function makes a new hook `known` for the fields of one profile. */
+function makeKnown(profile) {
 	const hasOp = (name) => {
 		if (profile.lazy !== void 0 && Object.hasOwn(profile.lazy, name)) return true;
 		const ops = profile.ops;
@@ -7431,13 +7614,18 @@ const EACH_PART = /* @__PURE__ */ Object.freeze([/* @__PURE__ */ Object.freeze({
 * - An operation is pure when the profile names it in `pure`, or when `pure` is `true`. A volatile operation is not pure.
 * - A standard extension is pure. An extension of the profile gets the context, thus it is not pure.
 *
+* Equal profiles give the same hook (D46).
+*
 * @param profile - The operations, the extensions and their facts.
 * @returns The hook: the facts of a name, or `undefined` for the facts of the contract.
 */
 function formulaFacts(profile = {}) {
+	return kitOf(profile).facts;
+}
+/** This function makes a new hook `facts` for the fields of one profile, with the hook `known` of the same fields. */
+function makeFacts(profile, known) {
 	const volatile = new Set(profile.volatile ?? []);
 	const pure = profile.pure === true ? void 0 : new Set(profile.pure ?? []);
-	const known = formulaKnown(profile);
 	return (path, code) => {
 		if (code !== "formula.op" && code !== "formula.ext") return void 0;
 		const name = path.slice(1).join(".");
@@ -7465,18 +7653,23 @@ function formulaFacts(profile = {}) {
 * The kit gives the domains of the kernel (`STD_DOMAINS`). Thus a domain of the language with the name `number` is a
 * conflict. The language names `["domains", "number"]` in `replaces` to replace it.
 *
+* Equal profiles give the same evaluators and the same hooks (COMPOSE.UNIFY, D46). Thus two machines of one profile
+* merge, also when each adds its own language. Two profiles with different fields give different evaluators, and
+* their machines conflict at each evaluator name of the kit.
+*
 * @param profile - The operations and the rules of the language.
 * @param more - The parts of a machine that the language adds, with the paths of the entries that it replaces.
 * @returns The machine.
 * @throws {MergeError} The language and the kit have a conflict.
 */
 function formulaMachine(profile = {}, more = {}) {
+	const kit = kitOf(profile);
 	return mergeMachines({
 		world: { kinds: formulaKinds() },
-		evaluators: formulaEvaluators(profile),
+		evaluators: { ...kit.evaluators },
 		domains: STD_DOMAINS,
-		known: formulaKnown(profile),
-		facts: formulaFacts(profile)
+		known: kit.known,
+		facts: kit.facts
 	}, more);
 }
 //#endregion
@@ -8822,10 +9015,13 @@ function plainValue(value, open) {
 }
 /**
 * TREE.LAZY, TREE.PARENT, TREE.SIBLING and TREE.ERROR: a node of an open tree gives its thing, and the root of a new
-* tree gives its JSON. A step on the thing reads an attribute, and a failed attribute throws its own error.
+* tree gives its JSON. A step on the thing reads an attribute, and a failed attribute throws its own error. The node
+* reads `self` only through `resolve` (C4, TREE.SELF).
 */
-const treeDefinition = ({ parts, context, kind, place, machine, typePath }) => {
-	const outer = refNodeOf(context.self);
+const treeDefinition = ({ parts, context, kind, place, machine, typePath, resolve: walk }) => {
+	const reached = walk(["self"]);
+	const parent = reached.ok ? reached.thing : void 0;
+	const outer = refNodeOf(parent);
 	const nested = outer !== void 0 && outer.tree.open;
 	const found = machine === void 0 || typePath.length === 0 ? void 0 : lookupKind(machine.world, typePath);
 	const contract = found?.ok === true ? found.kind.tree : void 0;
@@ -8849,7 +9045,7 @@ const treeDefinition = ({ parts, context, kind, place, machine, typePath }) => {
 		type: kind,
 		label: `node ${kind}`,
 		deref: (key) => {
-			if (key === "parent") return context.self;
+			if (key === "parent") return parent;
 			if (key === "type") return kind;
 			const result = attributeOf(node, String(key));
 			if (result === void 0 || result.ok) return result?.ok === true ? result.value : void 0;
@@ -11890,6 +12086,6 @@ 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, agree, ask, attributeTrace, capKeys, check, checkLatent, checkSteps, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, 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, placed, planner, prepare, print, random, recorder, ref, reference, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stored, syntaxFormat, tag, thrown, toJson, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
+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, agree, ask, attributeTrace, capKeys, check, checkLatent, checkSteps, checkWorld, classify, components, conforms, context, cycles, dataEdges, decodeDomain, decodeValue, derefStep, describe, docEquals, durable, edgesOf, effectEdges, effectsOf, 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, placed, planner, prepare, print, random, recorder, ref, reference, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, schedule, splitParts, stored, syntaxFormat, tag, thrown, toJson, typeCheck, typeFromSamples, typeFromSchema, typeIssues, typeName, typePath, typeText, typed, typesOf, valueOfThing, verifyReads, walk, worldThing };
 
 //# sourceMappingURL=index.js.map