@mark1russell7/coeval 0.24.1 → 0.25.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.24.1",
+  "version": "0.25.1",
   "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",

package/src/formula.ts

@@ -5,8 +5,8 @@ import { type CompiledPath, type Context, type Resolution, compilePath, valueOfT
 import { type EvalError, type Failed, type Result, Failure, fail, ok, thrown } from "./errors.ts";
 import { type Code, type CompileInput, type CompiledEvaluator, type CompiledPart, type Evaluator, type Machine, type Runtime, resolveCompiled, totalCode } from "./evaluate.ts";
 import { type MachinePart, mergeMachines } from "./merge.ts";
-import { type Domain, type ValueType, HEADER_KEYS, STD_DOMAINS, callable, fieldOf, fits, fnOf, holdsEnvelope, isPrecise, isUnknown, itemOf, join, member, stepType, typeIssues, typeText } from "./types.ts";
-import type { Declared, PartType, TypeInput, TypeRule } from "./typing.ts";
+import { type Domain, type Proof, type ValueType, HEADER_KEYS, STD_DOMAINS, callable, fieldOf, fits, fnOf, holdsEnvelope, isPrecise, isUnknown, itemOf, join, member, stepType, typeIssues, typeText } from "./types.ts";
+import type { Declared, PartType, Proven, TypeInput, TypeRule } from "./typing.ts";
 import { decodeDomain, domainTypeOf } from "./codec.ts";
 import { type StaticRead, factsOf } from "./facts.ts";
 
@@ -80,8 +80,7 @@ export interface FormulaProfile {
 
 /**
  * The signature of an operation: the value types of its parameters and of its result (TYPE.SIGNATURE). A parameter at
- * the end of `params` is optional when `undefined` is a member of its type, for example `unknown`. A later version can add a key, for example the type that a
- * true result proves.
+ * the end of `params` is optional when `undefined` is a member of its type, for example `unknown`. A later version can add a key.
  */
 export interface Signature {
   /** The types of the parameters, in order. */
@@ -90,8 +89,21 @@ export interface Signature {
   readonly rest?: ValueType;
   /** The type of the result. */
   readonly to: ValueType;
+  /**
+   * The type that a true result proves of the first argument, and a false result refutes (STATIC.OCCURRENCE). The
+   * operation gives a true result for each member of the type, and for no other value.
+   */
+  readonly proves?: ValueType;
+  /** `true` when a true result tells that the first argument has a value, and a false result that it has none. */
+  readonly present?: boolean;
 }
 
+/** The most proofs that one test keeps. A proof only adds knowledge, thus the check can leave one out. */
+const MAX_PROOFS = 32;
+
+/** The result of a test that proves nothing. */
+const NO_PROOFS: Proven = { yes: [], no: [] };
+
 /** The mark of a field that the profile leaves out of a record. */
 const SKIPPED: unique symbol = /* @__PURE__ */ Symbol("skipped");
 
@@ -400,6 +412,7 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
         sig.params.forEach((param, position) => out.push({ at: [...at, "params", position], type: param, what: `parameter ${position + 1} of a signature of ops.${name}` }));
         if (sig.rest !== undefined) out.push({ at: [...at, "rest"], type: sig.rest, what: `rest parameter of a signature of ops.${name}` });
         out.push({ at: [...at, "to"], type: sig.to, what: `result of a signature of ops.${name}` });
+        if (sig.proves !== undefined) out.push({ at: [...at, "proves"], type: sig.proves, what: `proved type of a signature of ops.${name}` });
         const earlier = list.slice(0, index).findIndex((other) => isSignature(other) && sameParams(other, sig));
         if (earlier >= 0) out.push({ at, problem: `The overload ${index + 1} of ops.${name} has the parameters of the overload ${earlier + 1}. Thus the check never selects it.` });
       });
@@ -407,7 +420,21 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     return out;
   };
   const logic = (word: "and" | "or"): TypeRule => ({
-    part: (input, path) => truthPart(input, `term ${Number(path[0]) + 1} of ${word}`),
+    usesProofs: true,
+    // A later term runs only after a term that did not decide, thus it reads the proof of that result (STATIC.OCCURRENCE-LOGIC).
+    part: (input, path) => {
+      const index = Number(path[0]);
+      const part = truthPart(input, `term ${index + 1} of ${word}`);
+      if (index === 0) return part;
+      const before = input.provenBy([index - 1]);
+      return { ...part, narrow: word === "and" ? before.yes : before.no, keep: true };
+    },
+    proves: (input) => {
+      const each = input.paths.map((path) => input.provenBy(path));
+      const all = (side: "yes" | "no"): readonly Proof[] => each.flatMap((proven) => proven[side]).slice(0, MAX_PROOFS);
+      const one = each.length === 1 ? (each[0] as Proven) : undefined;
+      return word === "and" ? { yes: all("yes"), no: one?.no ?? [] } : { yes: one?.yes ?? [], no: all("no") };
+    },
     synth: (input) => {
       if (!logicValue) return "bool";
       // With the logic "value", the result is the term that decided, or the last term.
@@ -421,6 +448,11 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
 
     "formula.ref": {
       read: true,
+      reads: (input) => {
+        const path = input.doc.value;
+        if (input.address || !Array.isArray(path) || path.length === 0) return undefined;
+        return path.every((step): step is string => typeof step === "string") ? path : undefined;
+      },
       synth: (input, report) => {
         const path = input.doc.value;
         // An address gives a thing, not a value. The check gives #VALUE! for a path that is not a list.
@@ -542,9 +574,13 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
     "formula.if": {
       // The rule of if declares the truth type of the profile, thus one bad truth type gives one issue in checkWorld.
       declared: () => (declared ? [{ at: ["truthType"], type: truth, what: "truth type of the profile" }] : []),
+      first: "test",
+      usesProofs: true,
       part: (input, path) => {
         if (path[0] === "test") return truthPart(input, "test of if");
-        return isUnknown(input.expected, input.machine.domains) ? {} : { expect: input.expected, what: `${String(path[0])} branch of if` };
+        const proven = input.provenBy(["test"]);
+        const narrow = path[0] === "then" ? proven.yes : proven.no;
+        return isUnknown(input.expected, input.machine.domains) ? { narrow } : { expect: input.expected, what: `${String(path[0])} branch of if`, narrow };
       },
       synth: (input) => {
         const value = input.doc.value;
@@ -558,6 +594,25 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
 
     "formula.op": {
       declared: sigsDeclared,
+      proves: (input) => {
+        // Overloads select after the check of the arguments, thus only one signature proves.
+        const sigs = signatures(input)?.sigs;
+        const sig = sigs?.length === 1 ? (sigs[0] as Signature) : undefined;
+        if (sig === undefined || (sig.proves === undefined && sig.present !== true) || input.paths.length === 0) return NO_PROOFS;
+        const path = input.readOf(input.paths[0] as readonly Key[]);
+        if (path === undefined) return NO_PROOFS;
+        const yes: Proof[] = [];
+        const no: Proof[] = [];
+        if (sig.proves !== undefined && typeIssues(input.contract(sig.proves, `proved type of ops.${nameOf(input)}`), input.machine.domains).length === 0) {
+          yes.push({ path, fact: "is", type: sig.proves });
+          no.push({ path, fact: "not", type: sig.proves });
+        }
+        if (sig.present === true) {
+          yes.push({ path, fact: "present" });
+          no.push({ path, fact: "absent" });
+        }
+        return { yes, no };
+      },
       part: (input, path) => {
         const read = signatures(input);
         // Only one signature gives the types of the arguments before their check. Overloads select after it.

package/src/index.ts

@@ -79,6 +79,7 @@ export {
 } from "./world.ts";
 export {
   type DomainExtension,
+  type VerbEntries,
   type MachinePart,
   type MergeConflict,
   type MergePath,
@@ -90,6 +91,7 @@ export {
   restrictMachine,
   restrictWorld,
 } from "./merge.ts";
+export { type Language, type LanguageCode, type LanguageDefinition, compose, defineLanguage } from "./language.ts";
 export {
   type Answer,
   type AskOptions,
@@ -348,6 +350,6 @@ export {
   replayer,
 } from "./replay.ts";
 export { type GenerateOptions, type Random, generate, random, typesOf } from "./generate.ts";
-export { type Domain, type DomainCodec, type TypeIssue, type ValueType, STD_DOMAINS, fits, join, member, typeIssues, typeText } from "./types.ts";
-export { type Boundary, type Declared, type PartType, type RootTypes, type TypeInput, type TypeProblem, type TypeRule, type Typed, CAPS_TYPE, boundariesOf } from "./typing.ts";
+export { type Domain, type DomainCodec, type Proof, type TypeIssue, type ValueType, STD_DOMAINS, fits, join, member, typeIssues, typeText } from "./types.ts";
+export { type Boundary, type Declared, type PartType, type Proven, type RootTypes, type TypeInput, type TypeProblem, type TypeRule, type Typed, CAPS_TYPE, boundariesOf } from "./typing.ts";
 export { type SampleOptions, type TypeReading, typeFromSamples, typeFromSchema } from "./providers.ts";

package/src/language.ts

@@ -0,0 +1,147 @@
+import { type Key, isRecord } from "./doc.ts";
+import type { Machine } from "./evaluate.ts";
+import { type MachinePart, type MergeConflict, type WorldPart, MergeError, mergeMachines } from "./merge.ts";
+
+/** The code half of a language: each field of a machine part, without the world. */
+export type LanguageCode = Omit<MachinePart, "world">;
+
+/** The input of `defineLanguage`. */
+export interface LanguageDefinition {
+  /** The name of the language. A composition holds one language of a name. */
+  readonly name: string;
+  /** The version, as `MAJOR.MINOR.PATCH`. */
+  readonly version: string;
+  /** The world of the language, with the verbs that it owns. It is JSON. */
+  readonly world?: WorldPart;
+  /** The lowest compatible version of each language that this language needs, by name (LANG.REQUIRES). */
+  readonly requires?: Readonly<Record<string, string>>;
+  /** The evaluators, the hooks and the other code. A function reads the merge of the languages before it. */
+  readonly code?: LanguageCode | ((prev: Machine) => LanguageCode);
+}
+
+/** One language as one frozen value, for `compose`. */
+export interface Language {
+  readonly name: string;
+  readonly version: string;
+  readonly world: WorldPart;
+  readonly requires: Readonly<Record<string, string>>;
+  readonly code?: LanguageCode | ((prev: Machine) => LanguageCode);
+  /**
+   * The canonical JSON of the data half: `requires` and `world`, with the keys in order. Two equal data halves give
+   * one text, in each order of their keys (LANG.IDENTITY). The name, the version and this text identify a language.
+   */
+  readonly data: string;
+}
+
+const VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+
+function numbers(version: string): readonly [number, number, number] {
+  const found = VERSION.exec(version);
+  if (found === null) throw new TypeError(`A language version has the form MAJOR.MINOR.PATCH. The text ${JSON.stringify(version)} does not.`);
+  return [Number(found[1]), Number(found[2]), Number(found[3])];
+}
+
+/**
+ * This function tells if a version satisfies a lowest version, by the rules of a caret range of SemVer. The first
+ * number that is not zero stays the same, and the version is not lower.
+ */
+function compatible(version: string, lowest: string): boolean {
+  const have = numbers(version);
+  const want = numbers(lowest);
+  const stable = want.findIndex((part) => part !== 0);
+  const fixed = stable < 0 ? 3 : stable + 1;
+  for (let index = 0; index < 3; index += 1) {
+    const [a, b] = [have[index] as number, want[index] as number];
+    if (a !== b) return index >= fixed && a > b;
+  }
+  return true;
+}
+
+/** This function gives the JSON text of a value with its keys in order. A value that is not JSON is an error. */
+function canonical(value: unknown, path: readonly Key[]): string {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number" && Number.isFinite(value)) return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((item, index) => canonical(item, [...path, index])).join(",")}]`;
+  if (!isRecord(value)) throw new TypeError(`The data half of a language is JSON. The value at ${JSON.stringify(path)} is not.`);
+  const keys = Object.keys(value)
+    .filter((key) => value[key] !== undefined)
+    .sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${canonical(value[key], [...path, key])}`).join(",")}}`;
+}
+
+function frozen<T>(value: T): T {
+  if (typeof value !== "object" || value === null) return value;
+  for (const item of Object.values(value)) frozen(item);
+  return Object.freeze(value);
+}
+
+/**
+ * This function makes one value of a language. The data half is JSON, thus a host can store it and compare it. The
+ * code half binds the evaluator names of the world.
+ *
+ * The language keeps a frozen copy of its data half, thus a later change to the input changes nothing.
+ *
+ * @param definition - The name, the version, the world, the needed languages and the code.
+ * @returns The language.
+ * @throws {TypeError} A version in the definition is not `MAJOR.MINOR.PATCH`, the name is empty, or the
+ *   data half is not JSON.
+ */
+export function defineLanguage(definition: LanguageDefinition): Language {
+  if (definition.name === "") throw new TypeError("A language has a name.");
+  numbers(definition.version);
+  const requires = definition.requires ?? {};
+  for (const name of Object.keys(requires)) numbers(requires[name] as string);
+  const data = canonical({ requires, world: definition.world ?? {} }, []);
+  const copy = frozen(JSON.parse(data) as { readonly requires: Readonly<Record<string, string>>; readonly world: WorldPart });
+  const language = { name: definition.name, version: definition.version, world: copy.world, requires: copy.requires, data };
+  return Object.freeze(definition.code === undefined ? language : { ...language, code: definition.code });
+}
+
+function partOf(language: Language): MachinePart | ((prev: Machine) => MachinePart) {
+  const { code, world } = language;
+  return typeof code === "function" ? (prev) => ({ ...code(prev), world }) : { ...code, world };
+}
+
+/**
+ * This function merges languages into one machine, in the order of the arguments, with `mergeMachines`.
+ *
+ * - A language comes after each language that it names in `requires`, at a compatible version (LANG.REQUIRES).
+ * - One language that comes twice counts once. Thus two languages can share a base.
+ * - Two versions of one name, or two data halves under one name and one version, are conflicts (LANG.COMPOSE).
+ *
+ * @param languages - The languages.
+ * @returns The machine.
+ * @throws {MergeError} The languages do not fit, or their merge has a conflict. The error lists each conflict.
+ */
+export function compose(...languages: readonly Language[]): Machine {
+  const conflicts: MergeConflict[] = [];
+  const parts: (MachinePart | ((prev: Machine) => MachinePart))[] = [];
+  const seen = new Map<string, { readonly language: Language; readonly index: number }>();
+  languages.forEach((language, index) => {
+    const earlier = seen.get(language.name);
+    const conflict = (name: string, other: number, reason: string): void => {
+      conflicts.push({ path: ["languages", name], parts: [Math.min(other, index), Math.max(other, index)], reason });
+    };
+    if (earlier !== undefined) {
+      if (earlier.language.version !== language.version) conflict(language.name, earlier.index, "Two versions of one language.");
+      else if (earlier.language.data !== language.data) conflict(language.name, earlier.index, "Two languages with one name and one version differ.");
+      else if (earlier.language.code !== language.code) parts.push(partOf(language));
+      return;
+    }
+    for (const name of Object.keys(language.requires)) {
+      const needed = language.requires[name] as string;
+      const found = seen.get(name);
+      if (found === undefined) {
+        const later = languages.findIndex((other) => other.name === name);
+        if (later < 0) conflict(name, index, `A language requires ${name}, and the composition does not have it.`);
+        else conflict(name, later, `A language requires ${name}, and ${name} comes after it.`);
+      } else if (!compatible(found.language.version, needed)) {
+        conflict(name, found.index, `A language requires ${name} ${needed}, and the composition has ${found.language.version}.`);
+      }
+    }
+    seen.set(language.name, { language, index });
+    parts.push(partOf(language));
+  });
+  if (conflicts.length > 0) throw new MergeError(conflicts);
+  return mergeMachines(...parts);
+}

package/src/merge.ts

@@ -7,14 +7,30 @@ import { type Kind, type World, type WorldEntry, isAlias, isKind, isNamespace }
 /** The keys from a part of a merge to one of its entries, for example `["kinds", "ref"]`. */
 export type MergePath = readonly Key[];
 
+/** The entries of one kind of another part (COMPOSE.EXTEND-VERB). */
+export interface VerbEntries {
+  /**
+   * The path of the kind, as `replaces` names it, for example `["kinds", "ref"]`, `["kinds", "ops", "kinds", "mul"]`,
+   * `["kinds", "ops", "fallback"]` or `["fallback"]`.
+   */
+  readonly kind: MergePath;
+  /** The evaluator names, by verb, as in `verbs` of a kind. */
+  readonly verbs: Readonly<Record<string, string>>;
+}
+
 /**
  * A world as a part of a merge. Each field is optional. `replaces` names the paths of the entries that this part
- * replaces, for example `["kinds", "ref"]` or `["defaults", "view"]`. The result of a merge has no `replaces`.
+ * replaces, for example `["kinds", "ref"]` or `["defaults", "view"]`. The result of a merge has no `replaces`, no
+ * `verbs` and no `extends`.
  */
 export interface WorldPart {
   readonly kinds?: Readonly<Record<string, WorldEntry>>;
   readonly defaults?: Readonly<Record<string, string>>;
   readonly fallback?: Kind;
+  /** The verbs that this part owns. A part can add an entry of such a verb to a kind of another part. */
+  readonly verbs?: readonly string[];
+  /** The entries that this part adds to kinds. The merge adds them after each part (COMPOSE.EXTEND-VERB). */
+  readonly extends?: readonly VerbEntries[];
   readonly replaces?: readonly MergePath[];
 }
 
@@ -58,6 +74,8 @@ type Known = NonNullable<Machine["known"]>;
 type Facts = NonNullable<Machine["facts"]>;
 
 const NONE: ReadonlySet<string> = /* @__PURE__ */ new Set();
+/** The verbs that the kernel reads. Thus no language owns them (COMPOSE.PIRACY). */
+const KERNEL_VERBS: ReadonlySet<string> = /* @__PURE__ */ new Set(["eval", "deref", "step"]);
 
 function keyOf(path: MergePath): string {
   return JSON.stringify(path.map(String));
@@ -283,15 +301,112 @@ function mergeEntry(m: Merger, earlier: WorldEntry, later: WorldEntry, path: Mer
   return earlier;
 }
 
+/** One entry of `extends`, with what the merge knows from its part. */
+interface VerbEntry {
+  readonly kind: MergePath;
+  readonly verb: string;
+  readonly code: string;
+  readonly path: MergePath;
+  readonly part: number;
+  /** The part owns the verb, or it gives the kind. Thus the entry is not piracy. */
+  readonly allowed: boolean;
+  readonly replaced: boolean;
+}
+
 interface WorldDraft {
   readonly kinds: Record<string, WorldEntry>;
   readonly defaults: Record<string, string>;
   fallback?: Kind;
+  /** The part that owns each verb. */
+  readonly owners: Map<string, WorldPart>;
+  readonly entries: VerbEntry[];
+}
+
+function worldDraft(): WorldDraft {
+  return { kinds: {}, defaults: {}, owners: new Map(), entries: [] };
+}
+
+interface KindTable {
+  readonly kinds: Readonly<Record<string, WorldEntry>>;
+  readonly fallback?: Kind;
+}
+
+/**
+ * This function gives a copy of a table with a change to the kind at a path, as `replaces` names the path. It gives
+ * `undefined` when no kind is at the path. An alias is not a kind.
+ */
+function changeKind<T extends KindTable>(table: T, path: MergePath, change: (kind: Kind) => Kind): T | undefined {
+  const [first, key, ...rest] = path;
+  if (String(first) === "fallback" && key === undefined) return table.fallback === undefined ? undefined : { ...table, fallback: change(table.fallback) };
+  if (String(first) !== "kinds" || key === undefined) return undefined;
+  const entry = own(table.kinds, String(key));
+  const next = rest.length === 0 ? (isKind(entry) ? change(entry) : undefined) : isNamespace(entry) ? changeKind(entry, rest, change) : undefined;
+  if (next === undefined) return undefined;
+  const kinds = { ...table.kinds };
+  setOwn(kinds, String(key), next);
+  return { ...table, kinds };
 }
 
-function worldOf(draft: WorldDraft): World {
-  const world = { kinds: { ...draft.kinds }, defaults: { ...draft.defaults } };
-  return draft.fallback === undefined ? world : { ...world, fallback: draft.fallback };
+/**
+ * This function adds the entries of `extends` to the kinds of a draft. A later part can give the kind, thus this step
+ * reads the whole draft. Without `m`, it reports no conflict: a function part sees the entries of the parts before it.
+ */
+function addVerbs(draft: WorldDraft, m?: Merger): KindTable {
+  let table: KindTable = draft.fallback === undefined ? { kinds: draft.kinds } : { kinds: draft.kinds, fallback: draft.fallback };
+  for (const entry of draft.entries) {
+    if (!entry.allowed && !entry.replaced) {
+      m?.clash(entry.path, entry.part, "A part adds a verb that it does not own to a kind that it does not give.");
+      continue;
+    }
+    const next = changeKind(table, entry.kind, (kind) => {
+      const verbs: Record<string, string> = { ...kind.verbs };
+      const earlier = own(verbs, entry.verb);
+      if (earlier === undefined) m?.give(entry.path, entry.part);
+      else if (entry.replaced) m?.replace(entry.path, entry.part);
+      else if (earlier !== entry.code) m?.clash(entry.path, entry.part, "Two parts give two different evaluators for this verb of this kind.");
+      if (earlier === undefined || entry.replaced) setOwn(verbs, entry.verb, entry.code);
+      return { ...kind, verbs };
+    });
+    if (next !== undefined) table = next;
+    else if (!entry.replaced) m?.clash(entry.path, entry.part, "A part adds a verb to a path without a kind.");
+  }
+  return table;
+}
+
+function worldOf(draft: WorldDraft, m?: Merger): World {
+  const table = addVerbs(draft, m);
+  const world = { kinds: { ...table.kinds }, defaults: { ...draft.defaults } };
+  return table.fallback === undefined ? world : { ...world, fallback: table.fallback };
+}
+
+/** This function records the verbs that a part owns, and the entries that it adds to kinds. */
+function mergeVerbs(m: Merger, draft: WorldDraft, part: WorldPart, index: number, replaces: ReadonlySet<string>, base: MergePath): void {
+  const owned = part.verbs ?? [];
+  for (const verb of owned) {
+    const path = [...base, "verbs", verb];
+    const owner = draft.owners.get(verb);
+    if (replaces.has(keyOf(path))) {
+      draft.owners.set(verb, part);
+      m.replace(path, index);
+    } else if (KERNEL_VERBS.has(verb)) {
+      m.clash(path, index, "The kernel owns this verb.");
+    } else if (owner === undefined) {
+      draft.owners.set(verb, part);
+      m.give(path, index);
+    } else if (!same(owner, part)) {
+      m.clash(path, index, "Two parts own this verb.");
+    }
+  }
+  const table: KindTable = part.fallback === undefined ? { kinds: part.kinds ?? {} } : { kinds: part.kinds ?? {}, fallback: part.fallback };
+  for (const { kind, verbs } of part.extends ?? []) {
+    const gives = changeKind(table, kind, (found) => found) !== undefined;
+    for (const verb of Object.keys(verbs)) {
+      const code = verbs[verb];
+      if (code === undefined) continue;
+      const path = [...base, ...kind, "verbs", verb];
+      draft.entries.push({ kind, verb, code, path, part: index, allowed: gives || owned.includes(verb), replaced: replaces.has(keyOf(path)) });
+    }
+  }
 }
 
 function mergeWorldInto(m: Merger, draft: WorldDraft, part: WorldPart | undefined, index: number, replaces: ReadonlySet<string>, base: MergePath): void {
@@ -303,6 +418,7 @@ function mergeWorldInto(m: Merger, draft: WorldDraft, part: WorldPart | undefine
   }
   const fallback = mergeFallback(m, draft.fallback, part.fallback, [...base, "fallback"], index, replaces);
   if (fallback !== undefined) draft.fallback = fallback;
+  mergeVerbs(m, draft, part, index, replaces, base);
 }
 
 /**
@@ -313,6 +429,8 @@ function mergeWorldInto(m: Merger, draft: WorldDraft, part: WorldPart | undefine
  * - The defaults merge verb by verb, and the world keeps one fallback.
  * - Each other pair of entries at one path is a conflict, unless the later part names the path in `replaces`.
  *   Then the later entry wins, with no merge below it.
+ * - The entries of `extends` join their kinds after each part, thus the order of the parts does not change them. A
+ *   verb that a part does not own on a kind that it does not give is a conflict (COMPOSE.PIRACY).
  *
  * A part can be a function of the merge of the parts before it (`prev`, as an overlay of Nix). Thus a part can read
  * the entry that it replaces.
@@ -323,13 +441,14 @@ function mergeWorldInto(m: Merger, draft: WorldDraft, part: WorldPart | undefine
  */
 export function mergeWorlds(...parts: readonly (WorldPart | ((prev: World) => WorldPart))[]): World {
   const m = new Merger();
-  const draft: WorldDraft = { kinds: {}, defaults: {} };
+  const draft = worldDraft();
   parts.forEach((input, index) => {
     const part = typeof input === "function" ? input(worldOf(draft)) : input;
     mergeWorldInto(m, draft, part, index, new Set((part.replaces ?? []).map(keyOf)), []);
   });
+  const world = worldOf(draft, m);
   if (m.conflicts.length > 0) throw new MergeError(m.conflicts);
-  return worldOf(draft);
+  return world;
 }
 
 /** The fields of a machine that merge by their own rules. Each other field is one value, or a conflict. */
@@ -392,12 +511,12 @@ function composeFacts(hooks: readonly { readonly part: number; readonly facts: F
   };
 }
 
-function machineOf(draft: MachineDraft): Machine {
+function machineOf(draft: MachineDraft, m?: Merger): Machine {
   const known = composeKnown(draft.hooks, draft.replaced);
   const facts = composeFacts(draft.factHooks, draft.replaced);
   return {
     ...draft.rest,
-    world: worldOf(draft.world),
+    world: worldOf(draft.world, m),
     evaluators: { ...draft.evaluators },
     ...(draft.runners === undefined ? {} : { runners: { ...draft.runners } }),
     ...(draft.derefs === undefined ? {} : { derefs: { ...draft.derefs } }),
@@ -474,7 +593,7 @@ function checkHidden(m: Merger, draft: MachineDraft): void {
  */
 export function mergeMachines(...parts: readonly (MachinePart | ((prev: Machine) => MachinePart))[]): Machine {
   const m = new Merger();
-  const draft: MachineDraft = { world: { kinds: {}, defaults: {} }, evaluators: {}, hooks: [], factHooks: [], replaced: new Map(), rest: {}, parts: [] };
+  const draft: MachineDraft = { world: worldDraft(), evaluators: {}, hooks: [], factHooks: [], replaced: new Map(), rest: {}, parts: [] };
   parts.forEach((input, index) => {
     const part = typeof input === "function" ? input(machineOf(draft)) : input;
     draft.parts.push(part);
@@ -502,8 +621,9 @@ export function mergeMachines(...parts: readonly (MachinePart | ((prev: Machine)
     }
   });
   checkHidden(m, draft);
+  const machine = machineOf(draft, m);
   if (m.conflicts.length > 0) throw new MergeError(m.conflicts);
-  return machineOf(draft);
+  return machine;
 }
 
 /** This function removes the entry at a path from a table of entries. It gives the same table when no entry is there. */

package/src/reference.ts

@@ -1336,11 +1336,22 @@ const treeDefinition: EvalFn = ({ parts, context, kind, place, machine, typePath
   }
 };
 
+/**
+ * The definition of the standard evaluator `ref.resolve` (REF.RESOLVE, D133). It resolves the steps of the path at each
+ * evaluation. The plan compiles the same path one time.
+ */
+const refDefinition: EvalFn = ({ data, resolve: walk }) => {
+  if (!Array.isArray(data) || data.length === 0) return fail("#VALUE!", 'The value of ref is a path: a list that starts with a root, for example ["names", "a"].');
+  const found = walk(data as readonly Json[]);
+  return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
+};
+
 /**
  * The definitions of the reference for the evaluators of the standard machine that need their own reading. The
- * reference uses them for the standard evaluators, also without the option `definitions`. It holds `tree.node`.
+ * reference uses them for the standard evaluators, also without the option `definitions`. It holds `tree.node` and
+ * `ref.resolve`. A host that wraps `ref.resolve` wraps this function, because the standard evaluator is compiled.
  */
-export const STD_DEFINITIONS: Definitions = { evaluators: { "tree.node": treeDefinition } };
+export const STD_DEFINITIONS: Definitions = { evaluators: { "tree.node": treeDefinition, "ref.resolve": refDefinition } };
 
 /* The definitions of the formula kit: one function evaluator for each construct, written from docs/SPEC.md. */
 

package/src/static.ts

@@ -641,7 +641,8 @@ export function check(machine: Machine, doc: unknown, options: CheckOptions = {}
 export function typeCheck(machine: Machine, doc: unknown, options: CheckOptions = {}): Typing {
   const nodes: TypeNode[] = [];
   const issues = checkAll(machine, doc, options, nodes);
-  const pass = typePass(machine, nodes, options.verb ?? "eval", options.expect, options.rootTypes);
+  const verb = options.verb ?? "eval";
+  const pass = typePass(machine, nodes, verb, options.expect, options.rootTypes, (node) => declaredEffects(node.visit, verb, machine, node.evaluator).length > 0);
   return { type: pass.type, issues: pass.issues.length === 0 ? issues : [...issues, ...pass.issues], places: pass.places };
 }
 

package/src/stdlib.ts

@@ -15,9 +15,10 @@ import {
   fail,
   ok,
   planner,
+  resolveCompiled,
 } from "./evaluate.ts";
 import { Failure } from "./errors.ts";
-import { type Cap, type HostThing, type Thing, type Walker, THING, isHostThing, valueOfThing } from "./deref.ts";
+import { type Cap, type HostThing, type Thing, type Walker, THING, compilePath, isHostThing, valueOfThing } from "./deref.ts";
 import type { World } from "./ladder.ts";
 import {
   type AttributeDeclaration,
@@ -289,12 +290,19 @@ export const STD_EVALUATORS: Readonly<Record<string, Evaluator>> = {
     const [a, b] = values as readonly number[];
     return ok((a ?? 0) > (b ?? 0));
   },
-  "ref.resolve": ({ data, resolve }) => {
-    if (!Array.isArray(data) || data.length === 0) {
-      return fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
-    }
-    const found = resolve(data as readonly Json[]);
-    return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
+  // The path is data of the document, thus it compiles one time for the machine of the plan (PLAN.PATH-STD, D133).
+  "ref.resolve": {
+    compile: ({ data, machine }) => {
+      if (!Array.isArray(data) || data.length === 0) {
+        const bad = fail("#VALUE!", "The value of ref is a path: a list that starts with a root, for example [\"names\", \"a\"].");
+        return () => bad;
+      }
+      const path = compilePath(machine, data);
+      return (ctx, rt) => {
+        const found = resolveCompiled(rt, ctx, path);
+        return found.ok ? ok(valueOfThing(found.thing)) : fail(found.code, found.reason);
+      };
+    },
   },
   "tree.node": (input) => treeNode(input, undefined),
 };