@mark1russell7/coeval 0.6.0 → 0.6.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "coeval: the kernel of declarative languages. Documents in envelopes, a ladder that finds the evaluator, kind contracts, compiled plans, a static kit, a formula kit and a run side with capabilities.",
   "type": "module",
   "main": "./build/index.js",
@@ -36,6 +36,7 @@
   "devDependencies": {
     "@mark1russell7/cue": "github:mark1russell7/cue",
     "@types/node": "^26.6.4",
+    "esbuild": "^0.28.2",
     "typescript": "^7.0.2",
     "vitest": "^5.0.3"
   },

package/src/agree.ts

@@ -132,7 +132,7 @@ export function sameValue(a: unknown, b: unknown, equal?: (a: unknown, b: unknow
   return true;
 }
 
-const CLOSURE = Symbol.for("coeval.closure");
+const CLOSURE = /* @__PURE__ */ Symbol.for("coeval.closure");
 
 function closureParams(fn: object): unknown {
   return (fn as { readonly [CLOSURE]?: { readonly params: readonly string[] } })[CLOSURE]?.params;

package/src/deref.ts

@@ -6,7 +6,7 @@ import type { ErrorCode } from "./errors.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.
  */
-export const THING: unique symbol = Symbol.for("coeval.thing") as never;
+export const THING: unique symbol = /* @__PURE__ */ Symbol.for("coeval.thing") as never;
 
 /**
  * A host thing: an object that answers the steps of a path itself, for example a node of a live tree. It is the
@@ -220,7 +220,7 @@ export function isRef(thing: unknown): thing is Envelope & { readonly value: rea
   return path !== undefined && path.length === 1 && path[0] === "ref";
 }
 
-const worlds = new WeakMap<World, Json>();
+const worlds = /* @__PURE__ */ new WeakMap<World, Json>();
 
 /**
  * This function makes the thing of the root `world`: the entries of the world as JSON. An alias is a reference
@@ -256,7 +256,7 @@ export function context(parts: Partial<Context> = {}): Context {
 }
 
 const MAX_COLLAPSE = 64;
-const NO_HOPS: readonly Hop[] = Object.freeze([]);
+const NO_HOPS: readonly Hop[] = /* @__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: unknown): boolean {

package/src/evaluate.ts

@@ -75,10 +75,10 @@ export function narrow(parent: Context, next: Context): Context {
 }
 
 /** No capabilities. One list serves each masked part. */
-const NO_CAPS: readonly Cap[] = Object.freeze([]);
+const NO_CAPS: readonly Cap[] = /* @__PURE__ */ Object.freeze([]);
 
 /** No capability rules. One list serves each part that no rule narrows. */
-const NO_RULES: readonly CapsRule[] = Object.freeze([]);
+const NO_RULES: readonly CapsRule[] = /* @__PURE__ */ Object.freeze([]);
 
 /**
  * This function gives the capabilities that two lists both permit. An effect is permitted by the result when each
@@ -550,8 +550,8 @@ export interface EvalOptions {
 }
 
 /** The options of a resolution without a record of hops, and with one. One object of each serves each call. */
-const WITHOUT_HOPS: ResolveOptions = Object.freeze({ hops: false });
-const WITH_HOPS: ResolveOptions = Object.freeze({ hops: true });
+const WITHOUT_HOPS: ResolveOptions = /* @__PURE__ */ Object.freeze({ hops: false });
+const WITH_HOPS: ResolveOptions = /* @__PURE__ */ Object.freeze({ hops: true });
 
 /** This class holds the state of one evaluation or run: the machine, the effects, the clock and the trace. */
 class Session implements Runtime {
@@ -759,7 +759,7 @@ function drive(steps: Steps): Result {
   return fail("#CALC!", "A part waited, and its parent cannot wait.");
 }
 
-const ABORTED = Symbol("aborted");
+const ABORTED = /* @__PURE__ */ Symbol("aborted");
 
 /** This function drives steps that can wait. The steps before the first wait happen at once, in the call. */
 async function driveWaiting(steps: Steps, signal: StopSignal | undefined): Promise<Result> {
@@ -916,7 +916,7 @@ function evaluatorOf(world: World, envelope: Envelope | undefined, kind: Kind |
 }
 
 /** The meta of a node of a compilation without a trace. Only a trace reads the meta of a node. */
-const NO_META: Meta = Object.freeze({ path: [], doc: { type: "?", value: null }, declared: false, answer: NO_ANSWER, side: "derive" });
+const NO_META: Meta = /* @__PURE__ */ Object.freeze({ path: [], doc: { type: "?", value: null }, declared: false, answer: NO_ANSWER, side: "derive" });
 
 function compileNode(c: Compiler, value: unknown, place: readonly Key[], declared: string | undefined, depth: number, address = false): { readonly code: Code; readonly run: RunCode } {
   const world = c.machine.world;

package/src/formula.ts

@@ -48,14 +48,14 @@ export interface FormulaProfile {
 }
 
 /** The mark of a field that the profile leaves out of a record. */
-const SKIPPED: unique symbol = Symbol("skipped");
+const SKIPPED: unique symbol = /* @__PURE__ */ Symbol("skipped");
 
 /** The value of a name whose binding failed. A reference to the name gives the error. */
 export class Held {
   constructor(readonly error: EvalError) {}
 }
 
-const CLOSURE: unique symbol = Symbol.for("coeval.closure") as never;
+const CLOSURE: unique symbol = /* @__PURE__ */ Symbol.for("coeval.closure") as never;
 
 /** A function that the construct `fn` made. It throws a `Failure` when its body fails. */
 export type Closure = ((...args: readonly unknown[]) => unknown) & { readonly [CLOSURE]: { readonly params: readonly string[] } };

package/src/index.ts

@@ -55,7 +55,17 @@ export {
   looksLikeKind,
   lookupKind,
 } from "./world.ts";
-export { type MachinePart, type MergeConflict, type MergePath, type WorldPart, MergeError, mergeMachines, mergeWorlds } from "./merge.ts";
+export {
+  type MachinePart,
+  type MergeConflict,
+  type MergePath,
+  type WorldPart,
+  MergeError,
+  mergeMachines,
+  mergeWorlds,
+  restrictMachine,
+  restrictWorld,
+} from "./merge.ts";
 export {
   type Answer,
   type AskOptions,

package/src/merge.ts

@@ -55,7 +55,7 @@ export class MergeError extends Error {
 
 type Known = NonNullable<Machine["known"]>;
 
-const NONE: ReadonlySet<string> = new Set();
+const NONE: ReadonlySet<string> = /* @__PURE__ */ new Set();
 
 function keyOf(path: MergePath): string {
   return JSON.stringify(path.map(String));
@@ -246,7 +246,7 @@ export function mergeWorlds(...parts: readonly (WorldPart | ((prev: World) => Wo
 }
 
 /** The fields of a machine that merge by their own rules. Each other field is one value, or a conflict. */
-const TABLES = new Set(["world", "evaluators", "runners", "derefs", "walkers", "known", "replaces"]);
+const TABLES = /* @__PURE__ */ new Set(["world", "evaluators", "runners", "derefs", "walkers", "known", "replaces"]);
 
 interface MachineDraft {
   readonly world: WorldDraft;
@@ -385,3 +385,102 @@ export function mergeMachines(...parts: readonly (MachinePart | ((prev: Machine)
   if (m.conflicts.length > 0) throw new MergeError(m.conflicts);
   return machineOf(draft);
 }
+
+/** This function removes the entry at a path from a table of entries. It gives the same table when no entry is there. */
+function removeEntry(entries: Readonly<Record<string, WorldEntry>>, path: readonly Key[]): Readonly<Record<string, WorldEntry>> {
+  const [first, ...rest] = path;
+  if (first === undefined) return entries;
+  const key = String(first);
+  const entry = own(entries, key);
+  if (entry === undefined) return entries;
+  let next: WorldEntry | undefined;
+  if (rest.length > 0) {
+    if (!isNamespace(entry)) return entries;
+    if (rest.length === 1 && String(rest[0]) === "fallback") {
+      if (entry.fallback === undefined) return entries;
+      next = { kinds: entry.kinds };
+    } else {
+      if (String(rest[0]) !== "kinds") return entries;
+      const kinds = removeEntry(entry.kinds, rest.slice(1));
+      if (kinds === entry.kinds) return entries;
+      next = entry.fallback === undefined ? { kinds } : { kinds, fallback: entry.fallback };
+    }
+  }
+  const out: Record<string, WorldEntry> = { ...entries };
+  if (next === undefined) delete out[key];
+  else setOwn(out, key, next);
+  return out;
+}
+
+/**
+ * This function removes entries from a world, for a language that restricts another language. A path names an entry
+ * as `replaces` names it, for example `["kinds", "fn"]`, `["kinds", "ops", "kinds", "mul"]`,
+ * `["kinds", "ops", "fallback"]`, `["defaults", "view"]` or `["fallback"]`. A path that names no entry changes
+ * nothing. The function does not change the world.
+ *
+ * A removed kind gives `#KIND?`, also through an alias to it. A namespace without its fallback knows only its own keys.
+ * A world without its fallback is closed.
+ *
+ * @param world - The world.
+ * @param paths - The paths of the entries to remove.
+ * @returns The world without the entries.
+ */
+export function restrictWorld(world: World, paths: readonly MergePath[]): World {
+  let kinds = world.kinds;
+  const defaults: Record<string, string> = { ...world.defaults };
+  let fallback = world.fallback;
+  for (const path of paths) {
+    const [first, ...rest] = path.map(String);
+    if (first === "kinds") kinds = removeEntry(kinds, rest);
+    else if (first === "defaults" && rest.length === 1) delete defaults[rest[0] as string];
+    else if (first === "fallback" && rest.length === 0) fallback = undefined;
+  }
+  const out = { kinds: { ...kinds }, defaults };
+  return fallback === undefined ? out : { ...out, fallback };
+}
+
+/** The tables of the code of a machine, as the paths of a restriction name them. */
+const CODE_TABLES = ["evaluators", "runners", "derefs", "walkers"] as const;
+
+/**
+ * This function removes entries from a machine, for a language that restricts another language. A path names an
+ * entry as `replaces` names it:
+ *
+ * - A path that starts with `"world"` removes an entry of the world, with the rules of `restrictWorld`.
+ * - `["evaluators", name]` or `["runners", name]` removes the code of the name: its evaluator and its runner.
+ * - `["derefs", name]` and `["walkers", name]` remove one entry of their tables.
+ *
+ * A path that names no entry changes nothing. The function does not change the machine. An own entry names an
+ * evaluator directly, thus only a machine without the code of a name refuses each document that names it.
+ *
+ * @param machine - The machine.
+ * @param paths - The paths of the entries to remove.
+ * @returns The machine without the entries.
+ */
+export function restrictMachine(machine: Machine, paths: readonly MergePath[]): Machine {
+  const world = paths.filter((path) => String(path[0]) === "world").map((path) => path.slice(1));
+  const tables: Record<(typeof CODE_TABLES)[number], Record<string, unknown> | undefined> = {
+    evaluators: { ...machine.evaluators },
+    runners: machine.runners === undefined ? undefined : { ...machine.runners },
+    derefs: machine.derefs === undefined ? undefined : { ...machine.derefs },
+    walkers: machine.walkers === undefined ? undefined : { ...machine.walkers },
+  };
+  for (const path of paths) {
+    const [table, name, ...rest] = path.map(String);
+    if (name === undefined || rest.length > 0 || !(CODE_TABLES as readonly (string | undefined)[]).includes(table)) continue;
+    // The evaluator and the runner of a name are its code, as for a replacement (MACHINE.RUNNER).
+    const from = table === "evaluators" || table === "runners" ? ["evaluators", "runners"] : [table as string];
+    for (const key of from) {
+      const entries = tables[key as (typeof CODE_TABLES)[number]];
+      if (entries !== undefined) delete entries[name];
+    }
+  }
+  return {
+    ...machine,
+    world: world.length === 0 ? machine.world : restrictWorld(machine.world, world),
+    evaluators: tables.evaluators as Machine["evaluators"],
+    ...(tables.runners === undefined ? {} : { runners: tables.runners as NonNullable<Machine["runners"]> }),
+    ...(tables.derefs === undefined ? {} : { derefs: tables.derefs as NonNullable<Machine["derefs"]> }),
+    ...(tables.walkers === undefined ? {} : { walkers: tables.walkers as NonNullable<Machine["walkers"]> }),
+  };
+}

package/src/parts.ts

@@ -50,7 +50,7 @@ function setOwn(target: Record<string, unknown>, key: string, value: unknown): v
   else target[key] = value;
 }
 
-const NO_SLOTS: readonly PartSlot[] = Object.freeze([]);
+const NO_SLOTS: readonly PartSlot[] = /* @__PURE__ */ Object.freeze([]);
 
 function hasSlots(template: Template): boolean {
   return template.t !== "data";

package/src/reference.ts

@@ -366,7 +366,7 @@ interface RefNode {
   readonly pending: Set<string>;
 }
 
-const refNodes = new WeakMap<object, RefNode>();
+const refNodes = /* @__PURE__ */ new WeakMap<object, RefNode>();
 
 /** The attributes in evaluation in the reference, in the order of their demands (TREE.CYCLE). */
 const inEvaluation: { readonly node: RefNode; readonly name: string }[] = [];
@@ -484,7 +484,7 @@ export const STD_DEFINITIONS: Definitions = { evaluators: { "tree.node": treeDef
 
 /* The definitions of the formula kit: one function evaluator for each construct, written from docs/SPEC.md. */
 
-const CLOSURE: unique symbol = Symbol.for("coeval.closure") as never;
+const CLOSURE: unique symbol = /* @__PURE__ */ Symbol.for("coeval.closure") as never;
 
 /** This function sets an own field, also the field `__proto__` (SHAPE.PROTO). */
 function setField(target: Record<string, unknown>, key: string, value: unknown): void {
@@ -696,7 +696,7 @@ export function formulaDefinitions(profile: FormulaProfile = {}): Definitions {
 }
 
 /** The mark of a field that the profile leaves out of a record (FORMULA.RECORD). */
-const SKIP: unique symbol = Symbol("skip");
+const SKIP: unique symbol = /* @__PURE__ */ Symbol("skip");
 
 /** The values of parts in order. The first error stops them, also with `combine` (FORMULA.STEPS, FORMULA.FN). */
 function valuesOfStrict(parts: readonly Part[]): { readonly values: readonly unknown[] } | Failed {

package/src/static.ts

@@ -127,7 +127,7 @@ function scopesOf(rules: readonly ScopeRule[] | undefined, value: unknown, slots
 }
 
 /** 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: ReadonlySet<string> = new Set();
+const NO_NAMES: ReadonlySet<string> = /* @__PURE__ */ new Set();
 
 /** This function gives the options of a walk without the names of the host. */
 function withoutNames(options: WalkOptions): WalkOptions {

package/src/stdlib.ts

@@ -122,9 +122,9 @@ function dataOf(type: "number" | "string" | "boolean"): Evaluator {
 
 /** The code of the evaluators of the standard world, by name. */
 export const STD_EVALUATORS: Readonly<Record<string, Evaluator>> = {
-  "data.number": dataOf("number"),
-  "data.text": dataOf("string"),
-  "data.bool": dataOf("boolean"),
+  "data.number": /* @__PURE__ */ dataOf("number"),
+  "data.text": /* @__PURE__ */ dataOf("string"),
+  "data.bool": /* @__PURE__ */ dataOf("boolean"),
   "math.add": ({ parts }) => {
     const all = allValues(parts.map((part) => part.evaluate()));
     if ("error" in all) return all.error;
@@ -164,7 +164,7 @@ export const STD_EVALUATORS: Readonly<Record<string, Evaluator>> = {
  */
 
 /** The brand of a node of the decorated tree. Its value is the state that the kit reads. */
-const TREE_NODE: unique symbol = Symbol.for("coeval.tree.node") as never;
+const TREE_NODE: unique symbol = /* @__PURE__ */ Symbol.for("coeval.tree.node") as never;
 
 /** One tree in one evaluation. It is open until its root gives the JSON of the tree. */
 interface TreeBuild {
@@ -189,7 +189,7 @@ interface NodeState {
 /** The memo cell of one attribute: in evaluation, or done with its result. */
 type Cell = { readonly busy: true } | { readonly busy: false; readonly result: Result };
 
-const BUSY: Cell = Object.freeze({ busy: true });
+const BUSY: Cell = /* @__PURE__ */ Object.freeze({ busy: true });
 
 /** One attribute in evaluation. The text names it in the reason of a cycle. */
 interface Demand {
@@ -392,7 +392,7 @@ export function nearestWalker(options: NearestOptions = {}): Walker {
   };
 }
 
-const nearest: Walker = nearestWalker();
+const nearest: Walker = /* @__PURE__ */ nearestWalker();
 
 /** The walkers of the standard world, by name. */
 export const STD_WALKERS: Readonly<Record<string, Walker>> = { "walk.nearest": nearest };