@mark1russell7/coeval 0.15.0 → 0.17.0

package/src/evaluate.ts

@@ -146,13 +146,23 @@ const GRANT = /* @__PURE__ */ Symbol("coeval.grant");
 /**
  * The key of the epoch of a grant (CAP.NARROW-KEPT). The epoch is the list of capabilities that the host gave the root
  * of the evaluation of the grant. A spread of a context keeps its epoch, as it keeps its grant. An
- * effect and a resolution read a context of another epoch as a context without a grant.
+ * effect and a resolution read a context of another epoch as a context without a grant. The root has no field of
+ * the epoch, because its grant is the list of the host (`epochOf`).
  */
 const EPOCH = /* @__PURE__ */ Symbol("coeval.epoch");
 
 /** A context with the grant of the kernel and the epoch of that grant. */
 type Granted = Context & { readonly [GRANT]?: readonly Cap[]; readonly [EPOCH]?: readonly Cap[] | undefined };
 
+/**
+ * This function gives the epoch of the grant of a context (CAP.NARROW-KEPT). A context without the field of the epoch
+ * has the epoch of its grant. Only a root has no field, thus its grant is the list of the host. The root then has
+ * one field fewer, and each evaluation makes it faster (K154).
+ */
+function epochOf(ctx: Context): readonly Cap[] | undefined {
+  return (ctx as Granted)[EPOCH] ?? (ctx as Granted)[GRANT];
+}
+
 /**
  * This function gives the capabilities that a context and its grant both permit, the meet `intersectCaps` (CAP.MEET).
  * A context whose grant is its own list gives that list after one comparison. A context without a grant gives none.
@@ -171,10 +181,37 @@ function grantedCaps(ctx: Context): readonly Cap[] {
 function granted(ctx: Context): Context {
   if ((ctx as Granted)[GRANT] === ctx.caps) return ctx;
   const caps = grantedCaps(ctx);
-  const out: Granted = { ...ctx, caps, [GRANT]: caps };
+  const out: Granted = { ...ctx, caps, [GRANT]: caps, [EPOCH]: epochOf(ctx) };
   return out;
 }
 
+/**
+ * This function tells if a list of capabilities is equal to the epoch of the evaluation (CAP.EPOCH-EQUAL). An equal list
+ * has the same length, and at each index the same text or the same keys in the same order. The runtime uses it only
+ * when the two lists are not the same object. Thus a host that gives a new copy of its list for each evaluation keeps
+ * the grant of a kept context.
+ */
+function sameCaps(caps: readonly Cap[] | undefined, epoch: readonly Cap[]): boolean {
+  if (caps === undefined || caps.length !== epoch.length) return false;
+  for (let index = 0; index < caps.length; index += 1) {
+    const a = caps[index] as Cap;
+    const b = epoch[index] as Cap;
+    if (a === b) continue;
+    if (typeof a === "string" || typeof b === "string" || a.length !== b.length) return false;
+    for (let key = 0; key < a.length; key += 1) if (!Object.is(a[key], b[key])) return false;
+  }
+  return true;
+}
+
+/**
+ * This function tells if a context has the epoch of the evaluation: the same list, or an equal list (CAP.NARROW-KEPT,
+ * CAP.EPOCH-EQUAL). The comparison of the entries happens only when the two lists are not the same object.
+ */
+function inEpoch(ctx: Context, epoch: readonly Cap[]): boolean {
+  const own = epochOf(ctx);
+  return own === epoch || sameCaps(own, epoch);
+}
+
 /**
  * This function gives a context of another epoch the epoch of the evaluation, without capabilities (CAP.NARROW-KEPT).
  * Thus the context reads as a context without a grant. The kernel cannot know the document of the context in this
@@ -190,13 +227,23 @@ function ungranted(ctx: Context, epoch: readonly Cap[]): Context {
  * The context has the meet of its list and its grant, and a context without a grant has none. Thus a read of the root
  * `caps` and a walker of a step document get the capabilities of the document from a widened context.
  * A context that the code narrowed keeps its own list. A context whose list does not change stays the same object.
- * A context of another epoch has no capabilities (CAP.NARROW-KEPT).
+ *
+ * A context of another epoch has no capabilities (CAP.NARROW-KEPT). An equal list of the host is the same epoch
+ * (CAP.EPOCH-EQUAL). The first test answers for a context of the epoch whose grant is its list, for example the root.
+ * The other contexts go to `readableOther`, thus the hot part of the function stays small (K154).
  */
 function readable(ctx: Context, epoch: readonly Cap[]): Context {
-  if ((ctx as Granted)[EPOCH] !== epoch) return ctx.caps.length === 0 ? ctx : ungranted(ctx, epoch);
+  const grant = (ctx as Granted)[GRANT];
+  if (grant === ctx.caps && ((ctx as Granted)[EPOCH] ?? grant) === epoch) return ctx;
+  return readableOther(ctx, epoch);
+}
+
+/** This function gives the result of `readable` for each other context: a context of another epoch or a narrowed context. */
+function readableOther(ctx: Context, epoch: readonly Cap[]): Context {
+  if (!inEpoch(ctx, epoch)) return ctx.caps.length === 0 ? ctx : ungranted(ctx, epoch);
   const caps = grantedCaps(ctx);
   if (caps === ctx.caps || (caps.length === 0 && ctx.caps.length === 0)) return ctx;
-  const out: Granted = { ...ctx, caps, [GRANT]: caps };
+  const out: Granted = { ...ctx, caps, [GRANT]: caps, [EPOCH]: epochOf(ctx) };
   return out;
 }
 
@@ -207,8 +254,8 @@ function readable(ctx: Context, epoch: readonly Cap[]): Context {
  */
 function handed(parent: Context, next: Context): Context {
   const ctx = narrow(parent, next);
-  const epoch = (parent as Granted)[EPOCH];
-  if ((ctx as Granted)[GRANT] === ctx.caps && (ctx as Granted)[EPOCH] === epoch) return ctx;
+  const epoch = epochOf(parent);
+  if ((ctx as Granted)[GRANT] === ctx.caps && epochOf(ctx) === epoch) return ctx;
   const out: Granted = { ...ctx, [GRANT]: ctx.caps, [EPOCH]: epoch };
   return out;
 }
@@ -358,9 +405,11 @@ export interface Journal {
    *
    * @param all - The address of the `all`.
    * @param waiting - The indices of the items that wait.
+   * @param before - The number of the waits of this `all` that settled before this call. The kernel gives it, thus a
+   *   replayer keeps no state of a run (RUN.REPLAY-RUNS). An older copy of the kernel does not give it.
    * @returns The index of an item that waits, or `undefined` for the order of the host.
    */
-  readonly next?: (all: string, waiting: readonly number[]) => number | undefined;
+  readonly next?: (all: string, waiting: readonly number[], before?: number) => number | undefined;
 }
 
 /** This function gives the journal of a function `perform`, when it has one. */
@@ -904,30 +953,95 @@ interface Reading {
   paths?: Set<string>;
 }
 
+/** The walk of a kept path: the path, and what it reached when a host thing answered a step with `known`. */
+interface KeptWalk {
+  readonly path: readonly unknown[];
+  /** What the path reached. Without it, the read resolves its path with `readAgain`. */
+  readonly reached?: Result;
+}
+
 /**
  * This function gives the path of a kept read (READS.CLOSURE). The evaluation did not ask for the read. Thus the read
- * does not step into a host thing, and the path ends at the first host thing. The host gives a new thing for a new state.
+ * does not step into a host thing with `deref`. A host thing with `known` answers a step without new work
+ * (SCHED.CLOSURE). Each other host thing ends the path, and a host thing that does not know the step ends it too.
  * A reference in the data reads the context of its reader, thus the function then gives `undefined`.
  *
  * @param nav - The world and the code of the evaluators.
  * @param root - The context at the root of the evaluation.
  * @param path - The root and the keys of the static read.
- * @returns The path of the kept read, or `undefined` for a reference on the way.
+ * @returns The path of the kept read with what it reached after a step of `known`, or `undefined` for a reference on the way.
  */
-function keptPath(nav: Navigator, root: Context, path: readonly unknown[]): readonly unknown[] | undefined {
+function keptPath(nav: Navigator, root: Context, path: readonly unknown[]): KeptWalk | undefined {
   const adopt = nav.adopt ?? ((value: unknown): Thing => value);
   let here = adopt(root[path[0] as Root]);
+  // This mark is `true` after a step of `known`. Then the walk gives what the path reached, and no resolution follows.
+  let known = false;
+  const end = (index: number): KeptWalk => {
+    const kept = index >= path.length ? path : path.slice(0, index);
+    return known ? { path: kept, reached: ok(here) } : { path: kept };
+  };
   for (let index = 1; ; index += 1) {
-    if (isHostThing(here)) return index === path.length ? path : path.slice(0, index);
+    if (isHostThing(here)) {
+      if (index >= path.length || here.known === undefined) return end(index);
+      let step: { readonly thing: Thing } | undefined;
+      try {
+        step = here.known(path[index] as Key);
+      } catch (error) {
+        // A failed value gives its error to the read, as an exception in `readAgain` does.
+        return { path: path.slice(0, index + 1), reached: thrown(error, READ_FAILED) };
+      }
+      if (step === undefined) return end(index);
+      known = true;
+      here = adopt(step.thing);
+      continue;
+    }
     if (nav.plain !== true && isRef(here)) return undefined;
-    if (index >= path.length) return path;
+    if (index >= path.length) return end(index);
     const reached = derefStep(nav, here, path[index] as Key);
     // A step that reaches nothing fails, and the resolution of the path fails at the same step.
-    if (reached === undefined) return path;
+    if (reached === undefined) return known ? end(index) : { path };
     here = adopt(reached.thing);
   }
 }
 
+/**
+ * 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`.
+ *
+ * @param nav - The world and the code of the evaluators.
+ * @param ctx - The new context.
+ * @param path - The path of the kept read.
+ * @returns What the path reaches, or `undefined` when a host does not know a step yet. Then the read changed.
+ */
+export function keptAgain(nav: Navigator, ctx: Context, path: readonly unknown[]): Result | undefined {
+  const adopt = nav.adopt ?? ((value: unknown): Thing => value);
+  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);
+  for (let index = 1; index < path.length; index += 1) {
+    if (isHostThing(here)) {
+      if (here.known === undefined) return other();
+      let step: { readonly thing: Thing } | undefined;
+      try {
+        step = here.known(path[index] as Key);
+      } catch (error) {
+        return thrown(error, READ_FAILED);
+      }
+      if (step === undefined) return undefined;
+      known = true;
+      here = adopt(step.thing);
+      continue;
+    }
+    if (nav.plain !== true && isRef(here)) return other();
+    const reached = derefStep(nav, here, path[index] as Key);
+    if (reached === undefined) return other();
+    here = adopt(reached.thing);
+  }
+  if (!known) return other();
+  return nav.plain !== true && isRef(here) ? undefined : ok(here);
+}
+
 /** This function makes the record of the reads of an evaluation, when the host gives a list. */
 function readingOf(list: Read[] | undefined, root: Context): Reading | undefined {
   return list === undefined ? undefined : { list, root, kept: false, self: false };
@@ -959,8 +1073,11 @@ class Session implements Runtime {
     readonly perform: Perform | undefined,
     readonly signal: StopSignal | undefined,
     effects: Effect[] | undefined,
-    /** The record of the reads. Without it, a resolution records nothing. */
-    private readonly reading: Reading | undefined = 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,
   ) {
     this.list = effects;
     this.holder = traced ? holderNode() : undefined;
@@ -1055,14 +1172,15 @@ class Session implements Runtime {
     // A read of the whole root self already holds each path of self.
     if (root === "self" && reading.self) return true;
     // A step document can walk outside the keys of its path, thus such a read keeps the whole root.
-    const path = keptPath(this.machine, reading.root, read.exact ? exact : [root]);
-    if (path === undefined) return false;
+    const walk = keptPath(this.machine, reading.root, read.exact ? exact : [root]);
+    if (walk === undefined) return false;
+    const path = walk.path;
     const paths = (reading.paths ??= new Set());
     const text = JSON.stringify(path);
     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: readAgain(this.machine, reading.root, path, false).reached, free: true, kept: true });
+    reading.list.push({ path, reached: walk.reached ?? readAgain(this.machine, reading.root, path, false).reached, free: true, kept: true });
     return true;
   }
 
@@ -1086,10 +1204,10 @@ class Session implements Runtime {
    * This function checks the capability of an effect, and records the effect with its address (RUN.ADDRESS). The
    * context keeps only the capabilities of its grant, thus compiled code cannot widen the context of its own effect
    * (CAP.NARROW-CODE). A context of another epoch has no capabilities, thus code cannot keep a context for a later
-   * evaluation with fewer capabilities (CAP.NARROW-KEPT).
+   * evaluation with fewer capabilities (CAP.NARROW-KEPT). An equal list of the host is the same epoch (CAP.EPOCH-EQUAL).
    */
   private record(given: Context, kind: Cap, payload: unknown, place: readonly Key[]): Result | Recorded {
-    const ctx = (given as Granted)[EPOCH] === this.epoch ? granted(given) : ungranted(given, this.epoch);
+    const ctx = inEpoch(given, this.epoch) ? granted(given) : ungranted(given, this.epoch);
     const keys = typeof kind === "string" ? kind.split(".") : kind;
     const text = keys.join(".");
     if (!this.permitted(ctx, keys)) return fail("#CAP!", `The context has no capability for the effect ${text}.`, { place });
@@ -1180,6 +1298,7 @@ class Session implements Runtime {
     }
     const active: Active[] = [];
     let next = 0;
+    let before = 0;
     const settle = (index: number, result: Result): void => {
       results[index] = result;
       if (failFast && !result.ok) failed = true;
@@ -1231,7 +1350,7 @@ class Session implements Runtime {
     start();
     while (active.length > 0 && !failed) {
       // A replay settles the waits in the recorded order. Each other run takes the first wait that settles.
-      const chosen = journal?.next?.(address, active.map((item) => item.index));
+      const chosen = journal?.next?.(address, active.map((item) => item.index), before);
       const pick = chosen === undefined ? undefined : active.find((item) => item.index === chosen);
       const settled = (yield pick === undefined ? Promise.race(active.map((item) => item.pending)) : pick.pending) as {
         readonly item: Active;
@@ -1240,6 +1359,7 @@ class Session implements Runtime {
         readonly threw: boolean;
       };
       journal?.settled?.(address, settled.item.index);
+      before += 1;
       active.splice(active.indexOf(settled.item), 1);
       advance(settled.item.index, settled.item.steps, settled);
       start();
@@ -1402,6 +1522,15 @@ export interface PrepareOptions {
    * evaluates one time, when the plan compiles. Its result is one frozen value for each evaluation (PLAN.FOLD).
    */
   readonly fold?: boolean;
+  /**
+   * The values that the host declares fixed for each evaluation of the plan (PLAN.FIXED, D60). The field `names` gives
+   * a value for each fixed name. A path from a fixed name then resolves one time, when the plan compiles, and a pure
+   * part that reads only fixed names folds. Only a deeply frozen value of plain data fixes its name.
+   *
+   * Each folded part compares the value of its names with one own-key test and `Object.is`. A different value gives
+   * the code without the fold. A plan without folds ignores this option.
+   */
+  readonly fixed?: { readonly names?: Readonly<Record<string, unknown>> };
 }
 
 /** A compiled document. It evaluates many times, and it does the work of the ladder one time. */
@@ -1440,6 +1569,8 @@ interface Compiler {
   readonly noAnswer: Answer;
   /** `true` when closed pure parts fold (PLAN.FOLD). A plan with a trace does not fold. */
   readonly fold: boolean;
+  /** The fixed names and their values, or `undefined` when the plan has none (PLAN.FIXED). */
+  readonly fixed: Readonly<Record<string, unknown>> | undefined;
   /** The runtime of the folds of this compilation. The first fold makes it. */
   probe?: Probe;
 }
@@ -1600,7 +1731,11 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
   if (frees === undefined || kind === undefined || !pureCode(c, envelope, kind, typePath, name, quick)) return done;
   const free = freeOf(doc, kind, split.parts, frees);
   if (free === undefined) return done;
-  return free.length === 0 ? folded(c, done) : { code: done.code, run: done.run, free };
+  if (free.length === 0) return folded(c, done, undefined);
+  // A part that reads only fixed names folds, and its code compares the values of these names (PLAN.FIXED).
+  const fixed = c.fixed;
+  if (fixed !== undefined && free.every((each) => Object.hasOwn(fixed, each))) return folded(c, done, free);
+  return { code: done.code, run: done.run, free };
 }
 
 /*
@@ -1693,6 +1828,20 @@ class Probe implements Runtime {
     this.root = root;
   }
 
+  /** The context of a part that folds with fixed names: the context of the probe, with the fixed names (PLAN.FIXED). */
+  private withFixed: Context | undefined;
+
+  /**
+   * This function gives the context of a part that folds with fixed names. Its root `names` holds only the fixed
+   * names, thus the probe resolves each fixed name and refuses each other name.
+   *
+   * @param fixed - The fixed names and their values.
+   * @returns The context.
+   */
+  fixedRoot(fixed: Readonly<Record<string, unknown>>): Context {
+    return (this.withFixed ??= { ...this.root, names: fixed });
+  }
+
   resolve(ctx: Context, path: readonly unknown[]): Resolution {
     const name = path[1];
     if (path[0] === "names" && isKey(name) && Object.hasOwn(ctx.names, String(name))) {
@@ -1757,25 +1906,106 @@ function trap(refuse: () => void, copies: boolean): object {
  * one deeply frozen copy, and the code gives that copy at each evaluation (PLAN.SHARED). A fold that the probe cancels
  * gives the code without free names, thus no parent tries the fold again.
  */
-function folded(c: Compiler, done: Compiled): Compiled {
+function folded(c: Compiler, done: Compiled, fixed: readonly string[] | undefined): Compiled {
   const probe = (c.probe ??= new Probe(c.machine));
   probe.refused = false;
   probe.reads = 0;
   let constant: Result | undefined;
   try {
-    const result = done.code(probe.root, probe);
+    const root = fixed === undefined ? probe.root : probe.fixedRoot(c.fixed as Readonly<Record<string, unknown>>);
+    const result = done.code(root, probe);
     if (!probe.refused && (result.ok || result.error.code !== "#DEPTH!")) constant = sharedCopy(result) as Result | undefined;
   } catch {
     constant = undefined;
   }
   if (constant === undefined) return { code: done.code, run: done.run };
   const value = constant;
+  const original = done.code;
+  if (fixed !== undefined) return { code: fixedCode(fixed, c.fixed as Readonly<Record<string, unknown>>, value, original), run: undefined, free: fixed };
   if (probe.reads === 0) return { code: () => value, run: undefined, free: CLOSED };
   // The part reads its own names. A list of reads gets each read, thus the code evaluates again (READS.RECORD).
-  const original = done.code;
   return { code: (ctx, rt) => (rt instanceof Session && !rt.traced && !rt.recording ? value : original(ctx, rt)), run: undefined, free: CLOSED };
 }
 
+/**
+ * This function gives the code of a part that folded with fixed names (PLAN.FIXED, D60). The code gives the folded
+ * value when the context has the fixed value of each name, by an own-key test and `Object.is`. A fixed value is
+ * deeply frozen, thus the same object gives the same result. Each other context, a list of reads and another runtime
+ * get the code without the fold. The probe of a parent fold gets the folded value, and it counts a read.
+ */
+function fixedCode(names: readonly string[], fixed: Readonly<Record<string, unknown>>, value: Result, original: Code): Code {
+  if (names.length === 1) {
+    const name = names[0] as string;
+    const want = fixed[name];
+    return (ctx, rt) => {
+      const given = ctx.names;
+      return Object.hasOwn(given, name) && Object.is(given[name], want) && folds(rt) ? value : original(ctx, rt);
+    };
+  }
+  const wants = names.map((name) => fixed[name]);
+  return (ctx, rt) => {
+    const given = ctx.names;
+    for (let index = 0; index < names.length; index += 1) {
+      const name = names[index] as string;
+      if (!Object.hasOwn(given, name) || !Object.is(given[name], wants[index])) return original(ctx, rt);
+    }
+    return folds(rt) ? value : original(ctx, rt);
+  };
+}
+
+/**
+ * This function tells if the code of a part with fixed names can give its folded value in a runtime. The probe of a
+ * fold counts the read of the part, as the code without the fold reads the names.
+ */
+function folds(rt: Runtime): boolean {
+  if (rt instanceof Session) return !rt.recording;
+  if (!(rt instanceof Probe)) return false;
+  rt.reads += 1;
+  return true;
+}
+
+/**
+ * This function gives the fixed names of the options of `prepare` (PLAN.FIXED). A name fixes only when its value is
+ * deeply frozen plain data. Then no change in place can make the folded value stale.
+ *
+ * @returns A record without a prototype, or `undefined` when no name fixes.
+ */
+function fixedNamesOf(given: Readonly<Record<string, unknown>> | undefined): Readonly<Record<string, unknown>> | undefined {
+  if (given === undefined) return undefined;
+  let out: Record<string, unknown> | undefined;
+  for (const name of Object.keys(given)) {
+    const value = given[name];
+    if (!frozenPlain(value)) continue;
+    out ??= Object.create(null) as Record<string, unknown>;
+    Object.defineProperty(out, name, { value, enumerable: true });
+  }
+  return out;
+}
+
+/** This function tells if a value is plain data, as `sharedCopy` reads it, and if each of its objects is frozen. */
+function frozenPlain(value: unknown): boolean {
+  const seen = new Set<object>();
+  const walk = (here: unknown): boolean => {
+    if (typeof here === "function") return false;
+    if (typeof here !== "object" || here === null || SHARED.has(here) || seen.has(here)) return true;
+    if (!Object.isFrozen(here)) return false;
+    seen.add(here);
+    const proto: unknown = Object.getPrototypeOf(here);
+    if (Array.isArray(here) ? proto !== Array.prototype : proto !== Object.prototype && proto !== null) return false;
+    for (const key of Reflect.ownKeys(here)) {
+      const field = Object.getOwnPropertyDescriptor(here, key);
+      if (typeof key !== "string" || field === undefined || !("value" in field) || !walk(field.value)) return false;
+    }
+    return true;
+  };
+  try {
+    return walk(value);
+  } catch {
+    // A very deep value overflows the stack of the host.
+    return false;
+  }
+}
+
 /** The objects that a fold made. Each one is deeply frozen, thus a later fold uses it again and does not copy it. */
 const SHARED: WeakSet<object> = /* @__PURE__ */ new WeakSet();
 
@@ -1785,9 +2015,13 @@ const NOT_PLAIN: unique symbol = /* @__PURE__ */ Symbol("not plain");
 /**
  * This function gives a deeply frozen copy of plain data, or `undefined` for other values. Plain data is a primitive or
  * an array without holes and extra keys. It is also a record of enumerable data fields with the prototype of an object
- * or no prototype. The copy keeps cycles and shared objects. The objects of the host do not change.
+ * or no prototype. The copy keeps cycles and shared objects. The objects of the host do not change. The tier `fixed`
+ * of `agree` uses it. The package does not export it.
+ *
+ * @param value - The value.
+ * @returns The frozen copy, or `undefined`.
  */
-function sharedCopy(value: unknown): unknown {
+export function sharedCopy(value: unknown): unknown {
   try {
     const out = copyPlain(value, new Map());
     return out === NOT_PLAIN ? undefined : out;
@@ -1890,7 +2124,7 @@ function gated(rules: readonly CapsRule[], part: Compiled): Compiled {
     const ctx = granted(given);
     const caps = capsUnder(rules, ctx.caps);
     if (caps === ctx.caps || (caps.length === 0 && ctx.caps.length === 0)) return ctx;
-    const out: Granted = { ...ctx, caps, [GRANT]: caps };
+    const out: Granted = { ...ctx, caps, [GRANT]: caps, [EPOCH]: epochOf(ctx) };
     return out;
   };
   // The steps of an evaluator are `runOf` of its code, thus `runOf` of this code narrows the context the same way.
@@ -1946,6 +2180,36 @@ function fillOf(split: Extract<Split, { readonly ok: true }>, doc: Envelope): <P
   return (items) => (split.parts.length === 0 ? doc.value : split.fill(items));
 }
 
+/**
+ * The key of the runtime on the input of an evaluator. Only the kernel reads it. The node of a tree evaluates its
+ * equations in the evaluation of this runtime, thus their reads go in its list (READS.EQUATION). A copy of the input
+ * with a spread keeps the key.
+ */
+export const RUNTIME: unique symbol = /* @__PURE__ */ Symbol("coeval.runtime") as never;
+
+/** The input of an evaluator, with the runtime of its evaluation. */
+export interface InputWithRuntime extends EvalInput {
+  readonly [RUNTIME]?: Runtime;
+}
+
+/**
+ * This function evaluates a plan inside the evaluation of another runtime, for example an equation of a tree inside
+ * the evaluation of its tree (READS.EQUATION). The plan gets its own runtime, as in `plan.evaluate`. The reads of the
+ * plan go in the record of the reads of `outer`. The context at the root of `outer` tells which reads are free
+ * (READS.FREE). Without such a record, the function gives `plan.evaluate(context)`.
+ *
+ * @param plan - The plan.
+ * @param context - The context of the plan.
+ * @param outer - The runtime of the evaluation around the plan, or `undefined`.
+ * @returns The result.
+ */
+export function evaluateWithin(plan: Plan, context: Context, outer: Runtime | undefined): Result {
+  const reading = outer instanceof Session ? outer.reading : undefined;
+  if (reading === undefined || !(plan instanceof CompiledPlan)) return plan.evaluate(context);
+  const machine = plan.machine;
+  const ctx = rootContext(machine, context);
+  return plan.code(ctx, new Session(machine, ctx.caps, false, plan.traced, undefined, undefined, undefined, reading));
+}
 
 function interpret(fn: EvalFn, input: CompileInput, fill: <P>(handles: readonly P[]) => unknown): Code {
   const { kind, typePath, doc, data, place, machine } = input;
@@ -1975,7 +2239,8 @@ function interpret(fn: EvalFn, input: CompileInput, fill: <P>(handles: readonly
       resolve: (path, options) => rt.resolve(ctx, path, options),
       effect: (effectKind, payload) => rt.effect(ctx, effectKind, payload, place),
       fill: refill,
-    });
+      [RUNTIME]: rt,
+    } as InputWithRuntime);
   };
 }
 
@@ -2012,16 +2277,25 @@ function interpretRun(fn: RunFn, input: CompileInput, fill: <P>(handles: readonl
 /**
  * This function gives the context at the root of an evaluation. It is the context of the host, with the world of
  * the machine when the context has none. The host gives the capabilities, thus the root has the grant of each one
- * (CAP.NARROW-CODE). The list of the host is also the epoch of the grant (CAP.NARROW-KEPT). An evaluation and
- * `verifyReads` share it.
+ * (CAP.NARROW-CODE). The list of the host is also the epoch of the grant (CAP.NARROW-KEPT). The root has no field of
+ * the epoch, thus it has the shape of a context before K120 (K154). An evaluation and `verifyReads` share it.
+ *
+ * The function reads the epoch of the context one time, and one test keeps a context that is already a root (K169).
  *
  * @param machine - The machine.
  * @param ctx - The context of the host.
  * @returns The context at the root.
  */
 export function rootContext(machine: Machine, ctx: Context): Context {
-  if (ctx.world !== null && (ctx as Granted)[GRANT] === ctx.caps && (ctx as Granted)[EPOCH] === ctx.caps) return ctx;
-  const root: Granted = { ...ctx, world: ctx.world === null ? worldThing(machine.world) : ctx.world, [GRANT]: ctx.caps, [EPOCH]: ctx.caps };
+  const epoch = (ctx as Granted)[EPOCH];
+  if (ctx.world !== null && (ctx as Granted)[GRANT] === ctx.caps && (epoch === undefined || epoch === ctx.caps)) return ctx;
+  const world = ctx.world === null ? worldThing(machine.world) : ctx.world;
+  if (epoch === undefined) {
+    const root: Granted = { ...ctx, world, [GRANT]: ctx.caps };
+    return root;
+  }
+  // A context of the kernel as the context of the host gets the list of the host as its epoch.
+  const root: Granted = { ...ctx, world, [GRANT]: ctx.caps, [EPOCH]: ctx.caps };
   return root;
 }
 
@@ -2042,7 +2316,9 @@ export function prepare(machine: Machine, doc: unknown, options: PrepareOptions
   const verb = options.verb ?? "eval";
   const noAnswer: Answer = verb === "eval" ? NO_ANSWER : { verb, error: "no-answer", steps: [] };
   const traced = options.trace === true;
-  const c: Compiler = { machine, traced, maxDepth: machine.maxDepth ?? 1000, verb, noAnswer, fold: !traced && options.fold !== false };
+  const fold = !traced && options.fold !== false;
+  const fixed = fold ? fixedNamesOf(options.fixed?.names) : undefined;
+  const c: Compiler = { machine, traced, maxDepth: machine.maxDepth ?? 1000, verb, noAnswer, fold, fixed };
   let root: Compiled;
   try {
     root = compileNode(c, doc, [], options.declaredType, 0);