@mark1russell7/coeval 0.4.0 → 0.4.1

package/build/index.js

@@ -1281,6 +1281,52 @@ function narrow(parent, next) {
 		caps
 	};
 }
+/** No capabilities. One list serves each masked part. */
+const NO_CAPS = Object.freeze([]);
+/** No capability rules. One list serves each part that no rule narrows. */
+const NO_RULES = Object.freeze([]);
+/**
+* This function gives the capabilities that two lists both permit. An effect is permitted by the result when each
+* list permits it. When the list `b` permits each capability of `a`, the result is the list `a` itself.
+*
+* @param a - The first list, for example the capabilities of a document.
+* @param b - The second list, for example the list of a rule `only`.
+* @returns The capabilities that both lists permit.
+*/
+function intersectCaps(a, b) {
+	if (a.every((cap) => permits(b, cap))) return a;
+	const out = [];
+	for (const cap of b) if (permits(a, cap)) out.push(cap);
+	for (const cap of a) if (permits(b, cap) && !permits(out, cap)) out.push(cap);
+	return out;
+}
+/** 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))));
+	return out.length === 0 ? NO_RULES : out;
+}
+/** This function applies the rules that cover a part to the capabilities of its document. */
+function capsUnder(rules, caps) {
+	let out = caps;
+	for (const rule of rules) {
+		if (rule.rule === "mask") return NO_CAPS;
+		if (rule.rule === "only") out = intersectCaps(out, rule.caps);
+	}
+	return out;
+}
+/**
+* This function gives the capabilities that a kind gives one of its parts, by the capability rules of its contract.
+* The kernel and the static kit both use it, thus a run and a check narrow the same way.
+*
+* @param rules - The capability rules of the kind (`Kind.caps`).
+* @param path - The path of the part in the value of the document.
+* @param caps - The capabilities of the document.
+* @returns The capabilities of the part: the same list or a smaller one.
+*/
+function partCaps(rules, path, caps) {
+	return capsUnder(rulesFor(rules, path), caps);
+}
 function selfLabel(self) {
 	try {
 		if (isHostThing(self)) return self.label;
@@ -1676,7 +1722,9 @@ function compileNode(c, value, place, declared, depth, address = false) {
 	}
 	const parts = split.parts.map((slot) => {
 		const item = slot.item;
-		const compiled = compileNode(c, item, place.concat(slot.path), slot.of, depth + 1, slot.address === true);
+		const own = compileNode(c, item, place.concat(slot.path), slot.of, depth + 1, slot.address === true);
+		const rules = rulesFor(kind?.caps, slot.path);
+		const compiled = rules.length === 0 ? own : gated(rules, own);
 		const header = typeof item?.name === "string" && isEnvelope(item) ? item.name : void 0;
 		return header === void 0 ? {
 			key: slot.key,
@@ -1720,6 +1768,25 @@ function placedCode(inner, place, name) {
 		}
 	};
 }
+/**
+* This function gives the code of a part that capability rules cover. The code narrows the context of the part by
+* the rules before the part starts.
+*/
+function gated(rules, part) {
+	const inner = part.code;
+	const steps = part.run;
+	const under = (ctx) => {
+		const caps = capsUnder(rules, ctx.caps);
+		return caps === ctx.caps || caps.length === 0 && ctx.caps.length === 0 ? ctx : {
+			...ctx,
+			caps
+		};
+	};
+	return {
+		code: (ctx, rt) => inner(under(ctx), rt),
+		run: (ctx, rt) => steps(under(ctx), rt)
+	};
+}
 /** This function gives the steps of a runner, with the place of each error and of each exception. */
 function placedRun(inner, place, name) {
 	return function* (ctx, rt) {
@@ -2146,6 +2213,7 @@ const STD_WORLD = {
 				view: "view.op"
 			},
 			parts: { shape: "list" },
+			caps: [{ rule: "mask" }],
 			summary: "It evaluates its part without capabilities, thus an effect in it fails."
 		},
 		log: {
@@ -2158,6 +2226,7 @@ const STD_WORLD = {
 				of: "text"
 			},
 			side: "run",
+			effects: ["log"],
 			summary: "It writes the result of its part to the log. This is an effect."
 		},
 		write: {
@@ -2170,6 +2239,7 @@ const STD_WORLD = {
 				fields: ["value"]
 			},
 			side: "run",
+			effects: ["write"],
 			summary: "It writes the result of its part to the store, at its key. This is an effect."
 		}
 	},
@@ -2347,13 +2417,10 @@ const STD_RUNNERS = {
 		}
 		return ok(last);
 	},
-	"control.pure": function* ({ parts, context }) {
+	"control.pure": function* ({ parts }) {
 		const only = parts[0];
 		if (only === void 0) return fail("#VALUE!", "pure needs one part.");
-		return yield* only.evaluate({
-			...context,
-			caps: []
-		});
+		return yield* only.evaluate();
 	},
 	"control.if": function* ({ parts }) {
 		const test = parts.find((part) => part.key === "test");
@@ -2878,9 +2945,10 @@ var Visit = class {
 	kind;
 	typePath;
 	address;
+	caps;
 	#place;
 	#at;
-	constructor(place, at, doc, declared, depth, names, later, slot, parent, kind, typePath, address) {
+	constructor(place, at, doc, declared, depth, names, later, slot, parent, kind, typePath, address, caps) {
 		this.doc = doc;
 		this.declared = declared;
 		this.depth = depth;
@@ -2891,6 +2959,7 @@ var Visit = class {
 		this.kind = kind;
 		this.typePath = typePath;
 		this.address = address;
+		this.caps = caps;
 		this.#place = place;
 		this.#at = at;
 	}
@@ -2903,14 +2972,15 @@ var Visit = class {
 };
 /**
 * This function visits each document of a document: the root and each part at each depth, by the contracts of the
-* kinds. A part of a kind that the world does not have is not visited. The walk uses no stack of the host for the
+* kinds. A part of a kind that the world does not have is not visited. With capabilities in the options, the walk
+* narrows them for each part by the rules of its kind, as a run does. The walk uses no stack of the host for the
 * depth, thus a deep document cannot overflow it. The time and the memory of a walk are linear in the size of the
 * document. A visit makes the keys of its place and of its path only when a reader asks for them.
 *
 * @param world - The world of the kinds.
 * @param doc - The document, as JSON.
 * @param visit - The function that gets each document. It gives `"skip"` to not visit the parts of a document.
-* @param options - The type of a bare root value, the names of the host, and a function for the problems.
+* @param options - The type of a bare root value, the names, the capabilities and a function for the problems.
 */
 function walk(world, doc, visit, options = {}) {
 	const stack = [{
@@ -2923,7 +2993,8 @@ function walk(world, doc, visit, options = {}) {
 		later: NO_NAMES,
 		address: false,
 		slot: [],
-		parent: void 0
+		parent: void 0,
+		caps: options.caps
 	}];
 	while (stack.length > 0) {
 		const item = stack.pop();
@@ -2943,7 +3014,7 @@ function walk(world, doc, visit, options = {}) {
 		};
 		const found = lookupKind(world, doc.type);
 		const kind = found.ok ? found.kind : void 0;
-		const here = new Visit(item.place, item.at, doc, envelope === void 0, item.depth, item.names, item.later, item.slot, item.parent, kind, found.ok ? found.path : void 0, item.address ? true : void 0);
+		const here = new Visit(item.place, item.at, doc, envelope === void 0, item.depth, item.names, item.later, item.slot, item.parent, kind, found.ok ? found.path : void 0, item.address ? true : void 0, item.caps);
 		if (visit(here) === "skip" || kind === void 0) continue;
 		const split = splitParts(kind.parts, doc.value);
 		const base = envelope === void 0 ? item.at : {
@@ -2985,7 +3056,8 @@ function walk(world, doc, visit, options = {}) {
 				later: hidden.length === 0 ? item.later : /* @__PURE__ */ new Set([...item.later, ...hidden]),
 				address: slot.address === true,
 				slot: slot.path,
-				parent: here
+				parent: here,
+				caps: item.caps === void 0 || kind.caps === void 0 ? item.caps : partCaps(kind.caps, slot.path, item.caps)
 			});
 		}
 	}
@@ -3073,6 +3145,15 @@ function mapRefs(world, doc, change, options = {}) {
 	return out;
 }
 /**
+* This function gives the reason of a `#CAP!`. When a kind around the document narrowed the capabilities, the
+* reason names the nearest such kind.
+*/
+function capReason(v, kind) {
+	const text = kind.join(".");
+	for (let up = v.parent; up !== void 0; up = up.parent) if (up.caps !== void 0 && permits(up.caps, kind)) return `The capabilities do not permit the effect ${text} here. The kind ${typeName(up.doc.type)} around it narrows them for its parts.`;
+	return `The capabilities do not permit the effect ${text}.`;
+}
+/**
 * This function checks a document before an evaluation, by the contracts of its kinds. It finds the problems
 * that an evaluation finds when it reaches them:
 *
@@ -3083,7 +3164,7 @@ function mapRefs(world, doc, change, options = {}) {
 * - `#DEPTH!`: too much nesting.
 * - `#REF!` and `#STEP?`: a bad path.
 * - `#NAME?`: a name that nothing binds.
-* - `#CAP!`: an effect that the capabilities do not permit.
+* - `#CAP!`: an effect that the capabilities of its document do not permit. A kind around the document can narrow them.
 *
 * @param machine - The world and the code of the evaluators.
 * @param doc - The document, as JSON.
@@ -3124,12 +3205,13 @@ function check(machine, doc, options = {}) {
 			reason: `No rung gives an evaluator for ${typeName(v.doc.type)}.`,
 			at: v.at
 		});
-		if (options.caps !== void 0 && v.kind?.effects !== void 0) {
+		const caps = v.caps;
+		if (caps !== void 0 && v.kind?.effects !== void 0) {
 			const kinds = v.kind.effects === "type" ? [v.typePath ?? []] : v.kind.effects.map((kind) => kind.split("."));
-			for (const kind of kinds) if (!permits(options.caps, kind)) issues.push({
+			for (const kind of kinds) if (!permits(caps, kind)) issues.push({
 				code: "#CAP!",
 				place: v.place,
-				reason: `The capabilities do not permit the effect ${kind.join(".")}.`,
+				reason: capReason(v, kind),
 				at: v.at
 			});
 		}
@@ -3187,6 +3269,7 @@ function check(machine, doc, options = {}) {
 	}, {
 		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType },
 		...Array.isArray(options.names) ? { names: options.names } : {},
+		...options.caps === void 0 ? {} : { caps: options.caps },
 		problem: (problem) => issues.push({
 			code: problem.code,
 			place: problem.place,
@@ -3712,6 +3795,6 @@ function formulaMachine(profile = {}, more = {}) {
 	};
 }
 //#endregion
-export { CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_WALKERS, STD_WORLD, THING, ask, capKeys, check, checkSteps, classify, context, dataEdges, derefStep, describe, docEquals, effectEdges, entriesAsJson, evaluate, fail, failures, field, flatten, formulaEvaluators, formulaKinds, formulaMachine, fromJson, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isTypeRef, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, narrow, nearestWalker, nodeAt, ok, pathMatches, permits, placed, planner, prepare, ref, refsOf, resolve, run, splitParts, stored, tag, thrown, toJson, typeName, typePath, typed, valueOfThing, walk, worldThing };
+export { CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_WALKERS, STD_WORLD, THING, ask, capKeys, check, checkSteps, classify, context, dataEdges, derefStep, describe, docEquals, effectEdges, entriesAsJson, evaluate, fail, failures, field, flatten, formulaEvaluators, formulaKinds, formulaMachine, fromJson, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isTypeRef, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, narrow, nearestWalker, nodeAt, ok, partCaps, pathMatches, permits, placed, planner, prepare, ref, refsOf, resolve, run, splitParts, stored, tag, thrown, toJson, typeName, typePath, typed, valueOfThing, walk, worldThing };
 
 //# sourceMappingURL=index.js.map