@mark1russell7/coeval 0.24.1 → 0.25.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "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,
@@ -348,6 +349,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/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),
 };

package/src/types.ts

@@ -722,6 +722,71 @@ function narrowAt(type: unknown, path: readonly string[], at: number, narrowed:
   return { record: fields, ...(optional.length === 0 ? {} : { optional }), ...(form.closed ? { closed: true } : {}) };
 }
 
+/**
+ * What the result of a test proves of the value at one path (STATIC.OCCURRENCE, D147). The path starts at a root, or at
+ * `names` and a name, and each later key is a field of a record. The fact `is` tells that the value is a member of the
+ * type, and `not` tells that it is not. The facts `present` and `absent` tell if the path reaches a value.
+ */
+export type Proof =
+  | { readonly path: readonly string[]; readonly fact: "is" | "not"; readonly type: ValueType }
+  | { readonly path: readonly string[]; readonly fact: "present" | "absent" };
+
+/** This function gives the type of a value that is a member of both types. The result is the narrower known type. */
+function meetOf(type: ValueType, proved: ValueType, domains: Readonly<Record<string, Domain>> | undefined): ValueType {
+  if (isUnknown(proved, domains)) return type;
+  const form = formOf(type, domains);
+  if (form.t === "one") return { one: form.values.filter((value) => member(value, proved, domains)) };
+  return !isUnknown(type, domains) && isPrecise(type, domains) && fits(type, proved, domains) ? type : proved;
+}
+
+/** This function gives the type of a value of the first type that is not a member of the second type. */
+function withoutOf(type: ValueType, removed: ValueType, domains: Readonly<Record<string, Domain>> | undefined): ValueType {
+  if (isUnknown(removed, domains)) return type;
+  const form = formOf(type, domains);
+  if (form.t === "one") return { one: form.values.filter((value) => !member(value, removed, domains)) };
+  if (form.t === "union") {
+    const members = form.members.map((each) => withoutOf(each, removed, domains)).filter((each) => each !== "never");
+    return members.length === 0 ? "never" : members.length === 1 ? (members[0] as ValueType) : { union: members };
+  }
+  // Only a precise type can leave: a gradual type fits each type, but its values do not.
+  return isPrecise(type, domains) && fits(type, removed, domains) ? "never" : type;
+}
+
+/**
+ * This function gives a type with one proof at a path (STATIC.OCCURRENCE). A path that leaves the records of the type
+ * gives the type back. A fact about a field also tells if the field exists. A value of a type without `undefined`
+ * exists. An optional field without a remaining type does not.
+ *
+ * @param type - The type of the value at the first `at` keys of the path.
+ * @param proof - The proof.
+ * @param at - The number of keys of the path that the type already holds.
+ * @param domains - The domains of the machine.
+ * @returns The narrowed type.
+ */
+export function narrowType(type: ValueType, proof: Proof, at: number, domains: Readonly<Record<string, Domain>> | undefined): ValueType {
+  if (at === proof.path.length) {
+    if (proof.fact === "is") return meetOf(type, proof.type, domains);
+    return proof.fact === "not" ? withoutOf(type, proof.type, domains) : type;
+  }
+  const form = formOf(type, domains);
+  const key = proof.path[at] as string;
+  if (form.t !== "record" || !Object.hasOwn(form.fields, key)) return type;
+  const before = form.fields[key] as ValueType;
+  const optional = new Set(form.optional);
+  let after: ValueType | undefined = narrowType(before, proof, at + 1, domains);
+  if (at + 1 === proof.path.length && optional.has(key)) {
+    if (proof.fact === "present" || (proof.fact === "is" && !member(undefined, proof.type, domains))) optional.delete(key);
+    else if (proof.fact === "absent" || after === "never") after = undefined;
+  }
+  const fields: Record<string, ValueType> = {};
+  for (const name of Object.keys(form.fields)) if (name !== key) setOwn(fields, name, form.fields[name] as ValueType);
+  // The absent case removes the field of a closed record. An open record keeps it as an optional field of the type `never`.
+  if (after !== undefined) setOwn(fields, key, after);
+  else if (form.closed) optional.delete(key);
+  else setOwn(fields, key, "never");
+  return { record: fields, ...(optional.size === 0 ? {} : { optional: [...optional] }), ...(form.closed ? { closed: true } : {}) };
+}
+
 /**
  * This function is the split rule of `fits` (TYPE.FITS-FINITE, D84, TYPE.FITS-PATH, D89). A record type fits when each
  * record of its split fits. A split takes the first field in the order of `splitsOf`. Each member of the field gives a