@mark1russell7/coeval 0.22.0 → 0.24.0

package/src/deref.ts

@@ -58,6 +58,15 @@ export interface HostThing {
    * @returns What the step reaches, or `undefined` when the host does not know it yet. Then the kept read ends at the thing.
    */
   known?(key: Key): { readonly thing: Thing } | undefined;
+  /**
+   * This optional function holds a kept read (SCHED.OWN-NODE). The evaluation did not ask for that read. Thus a host
+   * that follows the reads of an evaluation can tell the two apart. The kernel calls this function of the root `world`
+   * around each kept read that resolves its path.
+   *
+   * @param read - This function does the read.
+   * @returns What `read` gives.
+   */
+  keeping?<T>(read: () => T): T;
 }
 
 /** Something that a path can reach: any value of the host, or a host thing. */
@@ -522,7 +531,8 @@ function walkQuick(start: unknown, path: readonly unknown[], plain: boolean, key
 /**
  * A compiled path: one static path for one navigator (PLAN.PATH). `compilePath` reads the root, the open roots and
  * the steps one time. It asks the ladder of the verb `step` for each step document one time. Each resolution then
- * examines only the values of the context.
+ * examines only the values of the context. Code of a language reads a compiled path with `resolveCompiled`, thus the
+ * list of reads gets the read (PLAN.PATH-READS).
  */
 export interface CompiledPath {
   /** The steps of the path, as the document gives them. The list of reads records these steps. */
@@ -530,7 +540,8 @@ export interface CompiledPath {
   /** The navigator of the compilation. A runtime with another navigator resolves the steps again. */
   readonly nav: Navigator;
   /**
-   * This function resolves the path from a context, without a record of hops.
+   * This function resolves the path from a context, without a record of hops. It records no read and it does not
+   * apply the grant of the evaluation, as `resolve` does not. Use it only outside an evaluation.
    *
    * @param ctx - The context.
    * @returns The same resolution as `resolve(nav, ctx, path, { hops: false })`.
@@ -592,8 +603,11 @@ class StaticPath implements CompiledPath {
  * - The walker of each step document comes from the ladder one time, here. The navigator and the step document do
  *   not change, thus the answer does not change either.
  *
+ * An evaluator of a language calls this function in its `compile`, with the field `machine` of the input, and reads the
+ * result with `resolveCompiled` (PLAN.PATH-EXPORT).
+ *
  * @param nav - The navigator. A plan compiles its paths for its machine.
- * @param path - The steps. The first step is a root.
+ * @param path - The steps. The first step is a root. The compiled path keeps this list, thus the host must not change it.
  * @returns The compiled path.
  */
 export function compilePath(nav: Navigator, path: readonly unknown[]): CompiledPath {

package/src/durable.ts

@@ -1,5 +1,5 @@
 import type { Context } from "./deref.ts";
-import type { Result } from "./errors.ts";
+import { type Result, overflowCount } from "./errors.ts";
 import { type Machine, type Plan, type PrepareOptions, type Read, prepare } from "./evaluate.ts";
 import { type DocFacts, type FactsOptions, factsOf } from "./facts.ts";
 import { type PrintOptions, type ReadPrints, type VerifyOptions, printReads, verifyReads } from "./reads.ts";
@@ -126,20 +126,24 @@ const NO_READS: readonly Read[] = /* @__PURE__ */ Object.freeze([]);
 /** The key of the document `-0` in a cache of value documents. A `Map` finds the entry of `0` for `-0`. */
 const NEGATIVE_ZERO = /* @__PURE__ */ Symbol("coeval.negative-zero");
 
-/** This function makes a cache by document. A document object gives its value one time, as PLAN.CACHE says. */
-function byDocument<T>(make: (doc: unknown) => T): (doc: unknown) => T {
+/**
+ * This function makes a cache by document. A document object gives its value one time, as PLAN.CACHE says. A value
+ * that `lasts` refuses stays out of the cache, and the next call makes it again.
+ */
+function byDocument<T>(make: (doc: unknown) => T, lasts?: () => boolean): (doc: unknown) => T {
   const objects = new WeakMap<object, T>();
   const values = new Map<unknown, T>();
   return (doc) => {
     if (typeof doc === "object" && doc !== null) {
       if (objects.has(doc)) return objects.get(doc) as T;
       const made = make(doc);
-      objects.set(doc, made);
+      if (lasts === undefined || lasts()) objects.set(doc, made);
       return made;
     }
     const key = Object.is(doc, -0) ? NEGATIVE_ZERO : doc;
     if (values.has(key)) return values.get(key) as T;
     const made = make(doc);
+    if (lasts !== undefined && !lasts()) return made;
     if (values.size >= MAX_VALUES) values.clear();
     values.set(key, made);
     return made;
@@ -180,11 +184,19 @@ export function durable(machine: Machine, options: DurableOptions = {}): Durable
   const results = new Map<unknown, Entry>();
   let current = machine;
   let epochs: Epochs = { structure: 0, data: 0 };
-  const plansOf = (m: Machine): ((doc: unknown) => Plan) =>
-    byDocument((doc) => {
-      counts.compiles += 1;
-      return prepare(m, doc, prepareOptions);
-    });
+  const plansOf = (m: Machine): ((doc: unknown) => Plan) => {
+    let before = 0;
+    // A compilation near the limit of the stack gives a plan that fails. That failure depends on the depth of the
+    // demand, not on the document, thus such a plan stays out of the cache (SCHED.DEEP-CYCLE-CHANGE).
+    return byDocument(
+      (doc) => {
+        counts.compiles += 1;
+        before = overflowCount();
+        return prepare(m, doc, prepareOptions);
+      },
+      () => overflowCount() === before,
+    );
+  };
   const factsFor = (m: Machine): ((doc: unknown) => DocFacts) =>
     byDocument((doc) => {
       counts.facts += 1;

package/src/effects.ts

@@ -46,7 +46,7 @@ function reaching(machine: Machine, doc: unknown, options: EffectsOptions): read
     doc,
     (v) => {
       const caps = v.caps ?? EACH;
-      for (const kind of declaredEffects(v, "eval", machine)) if (rule(caps, kind)) out.push({ kind, visit: v });
+      for (const kind of declaredEffects(v, "eval", machine)) if (rule(caps, kind) && (v.handled === undefined || !permits(v.handled, kind))) out.push({ kind, visit: v });
       return undefined;
     },
     { caps: options.caps ?? EACH, ...(options.declaredType === undefined ? {} : { declaredType: options.declaredType }) },

package/src/errors.ts

@@ -116,6 +116,19 @@ export function isStackOverflow(error: unknown): boolean {
   }
 }
 
+/** The count of the stack overflows that `thrown` changed into `#DEPTH!`. */
+let overflows = 0;
+
+/**
+ * This function gives the count of the stack overflows that `thrown` changed into `#DEPTH!`. A schedule compares two
+ * counts. Thus it finds an overflow also when a document catches the error (SCHED.DEEP-CYCLE).
+ *
+ * @returns The count since the start of the process.
+ */
+export function overflowCount(): number {
+  return overflows;
+}
+
 /**
  * This function changes an exception into an error value. A `Failure` gives its error value. A stack overflow
  * gives `#DEPTH!`. Each other exception gives `#CALC!`, with the exception as the cause.
@@ -126,7 +139,10 @@ export function isStackOverflow(error: unknown): boolean {
  */
 export function thrown(error: unknown, who: string): Failed {
   if (error instanceof Failure) return { ok: false, error: error.error };
-  if (isStackOverflow(error)) return fail("#DEPTH!", `The nesting of ${who} is too deep for the stack of the host.`, { cause: error });
+  if (isStackOverflow(error)) {
+    overflows += 1;
+    return fail("#DEPTH!", `The nesting of ${who} is too deep for the stack of the host.`, { cause: error });
+  }
   return fail("#CALC!", `${upper(who)} threw: ${describe(error)}`, { cause: error });
 }
 

package/src/evaluate.ts

@@ -109,7 +109,7 @@ export function intersectCaps(a: readonly Cap[], b: readonly Cap[]): readonly Ca
 /** This function gives the capability rules of a kind that cover a part and change its capabilities. */
 function rulesFor(rules: readonly CapsRule[] | undefined, path: readonly Key[]): readonly CapsRule[] {
   if (rules === undefined || rules.length === 0) return NO_RULES;
-  const out = rules.filter((rule) => rule.rule !== "same" && (rule.in === undefined || rule.in.some((pattern) => pathMatches(path, pattern))));
+  const out = rules.filter((rule) => rule.rule !== "same" && rule.rule !== "grant" && (rule.in === undefined || rule.in.some((pattern) => pathMatches(path, pattern))));
   return out.length === 0 ? NO_RULES : out;
 }
 
@@ -136,6 +136,87 @@ export function partCaps(rules: readonly CapsRule[] | undefined, path: readonly
   return capsUnder(rulesFor(rules, path), caps);
 }
 
+/** This function collects the values at a path in a value. The key `"*"` steps into each item of a list. */
+function collectAt(value: unknown, path: readonly Key[], index: number, out: Cap[]): void {
+  if (index === path.length) {
+    if (typeof value === "string" || (Array.isArray(value) && value.every((key) => typeof key === "string" || typeof key === "number"))) out.push(value as Cap);
+    return;
+  }
+  const key = path[index] as Key;
+  if (key === "*") {
+    if (Array.isArray(value)) for (const item of value) collectAt(item, path, index + 1, out);
+    return;
+  }
+  if (typeof value === "object" && value !== null) collectAt((value as Record<Key, unknown>)[key], path, index + 1, out);
+}
+
+/**
+ * This function gives the capabilities that the rules `grant` of a kind give one part (CAP.GRANT). The check and the
+ * walk read them from the document. The kernel gets the same list from the clauses of the runner.
+ *
+ * @param rules - The capability rules of the kind (`Kind.caps`).
+ * @param path - The path of the part in the value of the document.
+ * @param value - The value of the document.
+ * @returns The capabilities that the rules add, or an empty list.
+ */
+export function partGrants(rules: readonly CapsRule[] | undefined, path: readonly Key[], value: unknown): readonly Cap[] {
+  if (rules === undefined) return NO_CAPS;
+  let out: Cap[] | undefined;
+  for (const rule of rules) {
+    if (rule.rule !== "grant" || (rule.in !== undefined && !rule.in.some((pattern) => pathMatches(path, pattern)))) continue;
+    collectAt(value, rule.from, 0, (out ??= []));
+  }
+  return out ?? NO_CAPS;
+}
+
+/**
+ * One clause of a handler (D146): the effects under `op` go to `answer` and not to the host. The clause runs in place,
+ * as a part of the effect that it answers. Its result is the result of that effect.
+ */
+export interface Clause {
+  /** The kind of the effects: the clause answers this kind and each kind under it (CAP.KEYS). */
+  readonly op: Cap;
+  /**
+   * This function answers one effect. It sees only the payload (HANDLE.SEALED).
+   *
+   * @param payload - The data of the effect.
+   * @returns The steps that give the result of the effect.
+   */
+  answer(payload: unknown): Steps;
+}
+
+/** The clauses of one active `handle`, and the frame around it. */
+interface Frame {
+  readonly clauses: readonly Clause[];
+  readonly outer: Frame | undefined;
+  /** The runtime of the evaluation that started the frame. A frame of another evaluation has ended. */
+  readonly owner: Runtime;
+  /** `true` after the body ends. A closure can leave the body with the context of the frame (HANDLE.ENDED). */
+  ended: boolean;
+}
+
+/**
+ * The key of the frame of a context. Like the grant, it stays through a spread of a context, and only the kernel writes
+ * it. It is not a root (D10): a document cannot read it (HANDLE.SEALED).
+ */
+const FRAME = /* @__PURE__ */ Symbol("coeval.frame");
+
+/** A context that can have a frame. */
+type Framed = Context & { readonly [FRAME]?: Frame };
+
+/** This function gives the frame of a context, when it has one. */
+function frameOf(ctx: Context): Frame | undefined {
+  return (ctx as Framed)[FRAME];
+}
+
+/** This function finds the frame and the clause that answer an effect. The innermost frame wins, then the first clause. */
+function clauseFor(start: Frame, keys: readonly Key[]): { readonly frame: Frame; readonly clause: Clause } | undefined {
+  for (let frame: Frame | undefined = start; frame !== undefined; frame = frame.outer) {
+    for (const clause of frame.clauses) if (permits([clause.op], keys)) return { frame, clause };
+  }
+  return undefined;
+}
+
 /**
  * The key of the grant of a context (CAP.NARROW-CODE): the capabilities that the kernel gave the document of the
  * context. A spread of a context keeps its grant. Thus compiled code passes the grant on in each context that it makes
@@ -669,6 +750,14 @@ export interface RunPart {
    * @returns The steps of the evaluation of the part.
    */
   evaluate(context?: Context): Steps;
+  /**
+   * This function evaluates the part under clauses that answer its effects (D146). The kernel sets it on each part of
+   * a kind with a rule `grant`. A part that a runner makes itself has none, and a compiled runner gets no such part.
+   *
+   * @param clauses - The clauses, in order. An effect goes to the first clause that names its kind.
+   * @returns The steps of the evaluation of the part.
+   */
+  handled?(clauses: readonly Clause[]): Steps;
 }
 
 /** The input of a runner: the input of an evaluator, with parts and effects that can wait. */
@@ -1004,9 +1093,24 @@ function keptPath(nav: Navigator, root: Context, path: readonly unknown[]): Kept
   }
 }
 
+/**
+ * This function resolves the path of a kept read. A reference on the path can reach a node of a schedule, thus the
+ * resolution goes through `keeping` of the root `world` (SCHED.OWN-NODE).
+ *
+ * @param nav - The world and the code of the evaluators.
+ * @param ctx - The context.
+ * @param path - The path of the kept read.
+ * @returns What the path reaches.
+ */
+function readKept(nav: Navigator, ctx: Context, path: readonly unknown[]): Result {
+  const read = (): Result => readAgain(nav, ctx, path, false).reached;
+  const world = ctx.world;
+  return isHostThing(world) && world.keeping !== undefined ? world.keeping(read) : read();
+}
+
 /**
  * This function resolves the path of a kept read again, for `verifyReads` (SCHED.CLOSURE). It walks the path as
- * `keptPath` did. A host thing with `known` answers its step. A path without such a step resolves with `readAgain`.
+ * `keptPath` did. A host thing with `known` answers its step. A path without such a step resolves with `readKept`.
  *
  * @param nav - The world and the code of the evaluators.
  * @param ctx - The new context.
@@ -1018,7 +1122,7 @@ export function keptAgain(nav: Navigator, ctx: Context, path: readonly unknown[]
   let here = adopt(ctx[path[0] as Root]);
   let known = false;
   // Before a step of `known`, each other answer of the walk is the answer of `readAgain`, as before SCHED.CLOSURE.
-  const other = (): Result | undefined => (known ? undefined : readAgain(nav, ctx, path, false).reached);
+  const other = (): Result | undefined => (known ? undefined : readKept(nav, ctx, path));
   for (let index = 1; index < path.length; index += 1) {
     if (isHostThing(here)) {
       if (here.known === undefined) return other();
@@ -1049,6 +1153,22 @@ function readingOf(list: Read[] | undefined, root: Context): Reading | undefined
 
 /** This class holds the state of one evaluation or run: the machine, the effects, the clock and the trace. */
 class Session implements Runtime {
+  readonly machine: Machine;
+  /**
+   * The epoch of the evaluation: the list of capabilities that the host gave the root (CAP.NARROW-KEPT). A context
+   * keeps its grant only in an evaluation of the same epoch.
+   */
+  readonly epoch: readonly Cap[];
+  readonly running: boolean;
+  readonly traced: boolean;
+  readonly perform: Perform | undefined;
+  readonly signal: StopSignal | undefined;
+  /**
+   * The record of the reads. Without it, a resolution records nothing. A nested evaluation of an equation of a tree
+   * shares the record of the evaluation around it (READS.EQUATION).
+   */
+  readonly reading: Reading | undefined;
+
   /** The list of the effects. It is made at the first effect, thus an evaluation without effects makes no list. */
   private list: Effect[] | undefined;
   tick = 0;
@@ -1067,23 +1187,22 @@ class Session implements Runtime {
   private scope: Scope | undefined;
 
   constructor(
-    readonly machine: Machine,
-    /**
-     * The epoch of the evaluation: the list of capabilities that the host gave the root (CAP.NARROW-KEPT). A context
-     * keeps its grant only in an evaluation of the same epoch.
-     */
-    readonly epoch: readonly Cap[],
-    readonly running: boolean,
-    readonly traced: boolean,
-    readonly perform: Perform | undefined,
-    readonly signal: StopSignal | undefined,
+    machine: Machine,
+    epoch: readonly Cap[],
+    running: boolean,
+    traced: boolean,
+    perform: Perform | undefined,
+    signal: StopSignal | undefined,
     effects: Effect[] | undefined,
-    /**
-     * The record of the reads. Without it, a resolution records nothing. A nested evaluation of an equation of a tree
-     * shares the record of the evaluation around it (READS.EQUATION).
-     */
-    readonly reading: Reading | undefined = undefined,
+    reading: Reading | undefined = undefined,
   ) {
+    this.machine = machine;
+    this.epoch = epoch;
+    this.running = running;
+    this.traced = traced;
+    this.perform = perform;
+    this.signal = signal;
+    this.reading = reading;
     this.list = effects;
     this.holder = traced ? holderNode() : undefined;
     this.current = this.holder;
@@ -1185,7 +1304,7 @@ class Session implements Runtime {
     if (paths.has(text) || paths.has(JSON.stringify([root]))) return true;
     paths.add(text);
     if (path.length === 1 && root === "self") reading.self = true;
-    reading.list.push({ path, reached: walk.reached ?? readAgain(this.machine, reading.root, path, false).reached, free: true, kept: true });
+    reading.list.push({ path, reached: walk.reached ?? readKept(this.machine, reading.root, path), free: true, kept: true });
     return true;
   }
 
@@ -1197,7 +1316,7 @@ class Session implements Runtime {
     for (const root of roots) {
       if (root === "self") reading.self = true;
       const path = [root];
-      reading.list.push({ path, reached: readAgain(this.machine, reading.root, path, false).reached, free: true, kept: true });
+      reading.list.push({ path, reached: readKept(this.machine, reading.root, path), free: true, kept: true });
     }
   }
 
@@ -1258,14 +1377,35 @@ class Session implements Runtime {
     return (effect.outcome = fail("#CALC!", `The mock gave a promise for the effect ${effect.kind}, and an evaluation does not wait.`, { place }));
   }
 
+  /**
+   * This function finds the clause that answers an effect (D146). Without it, the effect goes on to the host. An effect
+   * without a capability gets no clause, thus `record` gives its `#CAP!` (HANDLE.NARROW). A clause of a frame that has
+   * ended gives `#CAP!`, because the capability came from that frame (HANDLE.ENDED).
+   */
+  private clauseOf(given: Context, start: Frame, kind: Cap, place: readonly Key[]): Clause | Result | undefined {
+    const ctx = inEpoch(given, this.epoch) ? granted(given) : ungranted(given, this.epoch);
+    const keys = typeof kind === "string" ? kind.split(".") : kind;
+    if (!this.permitted(ctx, keys)) return undefined;
+    const found = clauseFor(start, keys);
+    if (found === undefined) return undefined;
+    if (found.frame.ended || found.frame.owner !== this) return fail("#CAP!", `The handler of the effect ${keys.join(".")} has ended.`, { place });
+    return found.clause;
+  }
+
   effect(ctx: Context, kind: Cap, payload: unknown, place: readonly Key[]): Result {
     const text = typeof kind === "string" ? kind : kind.join(".");
     if (this.running) return fail("#CALC!", `The effect ${text} needs a runner: in a run, the host does each effect.`, { place });
+    const frame = frameOf(ctx);
+    const clause = frame === undefined ? undefined : this.clauseOf(ctx, frame, kind, place);
+    if (clause !== undefined) return "ok" in clause ? clause : drive(clause.answer(payload), text);
     const made = this.record(ctx, kind, payload, place);
     return "ok" in made ? made : this.answer(made, place);
   }
 
   *runEffect(ctx: Context, kind: Cap, payload: unknown, place: readonly Key[]): Steps {
+    const frame = frameOf(ctx);
+    const clause = frame === undefined ? undefined : this.clauseOf(ctx, frame, kind, place);
+    if (clause !== undefined) return "ok" in clause ? clause : yield* clause.answer(payload);
     const made = this.record(ctx, kind, payload, place);
     if ("ok" in made) return made;
     const perform = this.perform;
@@ -1422,7 +1562,9 @@ class Session implements Runtime {
 
 /**
  * This function resolves a compiled path through a runtime (PLAN.PATH). The runtime of the kernel uses the compiled
- * path. Each other runtime gets the steps through `resolve`, thus a runtime that wraps another runtime sees each path.
+ * path. Each other runtime gets the steps through `resolve`, thus a runtime that wraps another runtime sees each path
+ * (PLAN.PATH-ROUTE). The result and the list of reads are the same as for `rt.resolve(ctx, compiled.path)`
+ * (PLAN.PATH-READS).
  *
  * @param rt - The runtime.
  * @param ctx - The context.
@@ -1739,7 +1881,7 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
   if (runner !== undefined) {
     let inner: RunCode;
     try {
-      inner = isCompiledRunner(runner) ? runner.compileRun(input) : interpretRun(runner, input, split.fill);
+      inner = isCompiledRunner(runner) ? runner.compileRun(input) : interpretRun(runner, input, split.fill, kind?.caps?.some((rule) => rule.rule === "grant") === true);
     } catch (error) {
       return failingWith(c, meta, placed(thrown(error, `the runner ${name}`), place));
     }
@@ -1831,6 +1973,7 @@ function freeOf(doc: Envelope, kind: Kind, slots: readonly PartSlot[], frees: re
 
 /** This class is the runtime of a fold. It reads only the names that the folded part binds, and it causes no effect. */
 class Probe implements Runtime {
+  readonly machine: Machine;
   readonly running = false;
   /** `true` after the part asked for something that a fold cannot give. */
   refused = false;
@@ -1842,7 +1985,8 @@ class Probe implements Runtime {
    */
   readonly root: Context;
 
-  constructor(readonly machine: Machine) {
+  constructor(machine: Machine) {
+    this.machine = machine;
     const refuse = (): void => {
       this.refused = true;
     };
@@ -2282,7 +2426,25 @@ function interpret(fn: EvalFn, input: CompileInput, fill: <P>(handles: readonly
   };
 }
 
-function interpretRun(fn: RunFn, input: CompileInput, fill: <P>(handles: readonly P[]) => unknown): RunCode {
+/**
+ * This function runs a part under a new frame (D146). The part gets the capabilities of the document and the kinds of
+ * the clauses (CAP.GRANT), with the grant of the kernel. A rule around an effect narrows them as it narrows any other
+ * capability (HANDLE.NARROW). The frame ends with the steps.
+ */
+function* handling(given: Context, clauses: readonly Clause[], rt: Runtime, run: (ctx: Context) => Steps): Steps {
+  const ctx = granted(given);
+  const frame: Frame = { clauses, outer: frameOf(ctx), owner: rt, ended: false };
+  const caps = [...ctx.caps];
+  for (const clause of clauses) if (!permits(caps, clause.op)) caps.push(clause.op);
+  const inner: Granted & Framed = { ...ctx, caps, [GRANT]: caps, [EPOCH]: epochOf(ctx), [FRAME]: frame };
+  try {
+    return yield* run(inner);
+  } finally {
+    frame.ended = true;
+  }
+}
+
+function interpretRun(fn: RunFn, input: CompileInput, fill: <P>(handles: readonly P[]) => unknown, grants: boolean): RunCode {
   const { kind, typePath, doc, data, place, machine } = input;
   const refill = input.fill;
   const compiled = input.parts;
@@ -2293,6 +2455,8 @@ function interpretRun(fn: RunFn, input: CompileInput, fill: <P>(handles: readonl
       path: part.path,
       ...(part.name === undefined ? {} : { name: part.name }),
       evaluate: (override?: Context) => part.run(override === undefined ? ctx : handed(ctx, override), rt),
+      // Only a kind with a rule grant pays for this function: most runners stay as fast as before.
+      ...(grants ? { handled: (clauses: readonly Clause[]) => handling(ctx, clauses, rt, (inner) => part.run(inner, rt)) } : {}),
     }));
     return fn({
       kind,

package/src/formula.ts

@@ -97,7 +97,11 @@ 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) {}
+  readonly error: EvalError;
+
+  constructor(error: EvalError) {
+    this.error = error;
+  }
 }
 
 const CLOSURE: unique symbol = /* @__PURE__ */ Symbol.for("coeval.closure") as never;
@@ -242,6 +246,36 @@ function isSignature(value: unknown): value is Signature {
   return typeof value === "object" && value !== null && Array.isArray((value as { readonly params?: unknown }).params) && Object.hasOwn(value, "to");
 }
 
+/** This function gives the signatures of an operation as the profile holds them, or `undefined` for no entry. */
+function rawSignatures(profile: FormulaProfile, name: string): readonly unknown[] | undefined {
+  const sigs = profile.sigs;
+  if (sigs === undefined) return undefined;
+  let found: unknown;
+  if (typeof sigs === "function") {
+    try {
+      found = sigs(name);
+    } catch {
+      return undefined;
+    }
+  } else {
+    found = Object.hasOwn(sigs, name) ? sigs[name] : undefined;
+  }
+  if (found === undefined) return undefined;
+  return Array.isArray(found) ? found : [found];
+}
+
+/**
+ * This function gives each signature of an operation that has the form of a signature, for `conforms` (D137). The
+ * kernel does not export the function.
+ *
+ * @param profile - The profile.
+ * @param name - The name of the operation.
+ * @returns The signatures.
+ */
+export function signaturesOf(profile: FormulaProfile, name: string): readonly Signature[] {
+  return (rawSignatures(profile, name) ?? []).filter(isSignature);
+}
+
 /** This function tells if two signatures have the same parameters and the same rest parameter. */
 function sameParams(a: Signature, b: Signature): boolean {
   if (!docEquals(a.params, b.params)) return false;
@@ -329,22 +363,7 @@ function formulaTypes(profile: FormulaProfile): Readonly<Record<string, TypeRule
   };
   const logicValue = profile.logic === "value";
   const otherwise = Object.hasOwn(profile, "otherwise") ? valueType(profile.otherwise) : "null";
-  const lookup = (name: string): readonly unknown[] | undefined => {
-    const sigs = profile.sigs;
-    if (sigs === undefined) return undefined;
-    let found: unknown;
-    if (typeof sigs === "function") {
-      try {
-        found = sigs(name);
-      } catch {
-        return undefined;
-      }
-    } else {
-      found = Object.hasOwn(sigs, name) ? sigs[name] : undefined;
-    }
-    if (found === undefined) return undefined;
-    return Array.isArray(found) ? found : [found];
-  };
+  const lookup = (name: string): readonly unknown[] | undefined => rawSignatures(profile, name);
   const nameOf = (input: TypeInput): string => input.typePath.slice(1).join(".");
   /** The signatures of an operation. Each type of a signature is a contract, thus the check examines it one time. */
   const signatures = (input: TypeInput): { readonly sigs: readonly Signature[]; readonly bad: boolean } | undefined => {
@@ -644,6 +663,29 @@ export function declaredTruthOf(code: unknown): DeclaredTruth | undefined {
   return (typeof code === "object" || typeof code === "function") && code !== null ? truthByCode.get(code) : undefined;
 }
 
+/** An evaluator of the kit that reads functions of a profile: its name, and the fields of the profile (D137). */
+export interface ProfileReader {
+  readonly name: string;
+  readonly profile: FormulaProfile;
+}
+
+/** The evaluators of the kit that `conforms` examines the functions of a profile with. */
+const PROFILE_READERS: readonly string[] = ["formula.op", "formula.ext", "formula.record", "formula.ref"];
+
+/** The profile of each evaluator of the kit that reads its functions, for `conforms` (D137). */
+const readerByCode = /* @__PURE__ */ new WeakMap<object, ProfileReader>();
+
+/**
+ * This function gives the profile of an evaluator of the kit, when that evaluator reads functions of the profile
+ * (D137). The kernel does not export the function.
+ *
+ * @param code - The evaluator or the runner.
+ * @returns The name of the evaluator and the profile, or `undefined`.
+ */
+export function profileReaderOf(code: unknown): ProfileReader | undefined {
+  return (typeof code === "object" || typeof code === "function") && code !== null ? readerByCode.get(code) : undefined;
+}
+
 /** This function makes new evaluators of the formula kit for the fields of one profile. */
 function makeEvaluators(profile: FormulaProfile): Readonly<Record<string, Evaluator>> {
   const evaluators = formulaCode(profile);
@@ -656,6 +698,7 @@ function makeEvaluators(profile: FormulaProfile): Readonly<Record<string, Evalua
     const type = Object.hasOwn(types, name) ? types[name] : undefined;
     const made = Object.freeze(type === undefined ? evaluator : { compile: evaluator.compile, type });
     if (truth !== undefined && TRUTH_READERS.includes(name)) truthByCode.set(made, truth);
+    if (PROFILE_READERS.includes(name)) readerByCode.set(made, { name, profile });
     out[name] = made;
   }
   return Object.freeze(out);