@mark1russell7/coeval 0.15.0 → 0.16.0

package/package.json

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

@@ -1,7 +1,7 @@
 import { type Key, docEquals, equalWith } from "./doc.ts";
 import type { Context } from "./deref.ts";
 import { type EvalError, type Result, isStackOverflow, thrown } from "./errors.ts";
-import { type Effect, type Journal, type Machine, type Perform, JOURNAL, evaluate, makeContext, prepare, run } from "./evaluate.ts";
+import { type Effect, type Journal, type Machine, type Perform, JOURNAL, evaluate, makeContext, prepare, run, sharedCopy } from "./evaluate.ts";
 import { Held, isClosure } from "./formula.ts";
 import { type Definitions, reference, referenceRun } from "./reference.ts";
 import { type ReplaySettle, recorder, replayer } from "./replay.ts";
@@ -14,9 +14,11 @@ import { type ReplaySettle, recorder, replayer } from "./replay.ts";
  * - `again`: a second evaluation of the same plan.
  * - `folds`: a second plan with the other choice of folds (PLAN.FOLD). It has no folds when the plan has them, and
  *   it has folds when the option `observe` stops the folds of the plan.
+ * - `fixed`: a plan that declares each name of plain data fixed (PLAN.FIXED). It evaluates with a frozen copy of
+ *   each such name, and then with the context of `agree`. `agreeRun` does not have this tier.
  * - `other`: the second tier of a language, from the option `other`.
  */
-export type Tier = "reference" | "traced" | "again" | "folds" | "other";
+export type Tier = "reference" | "traced" | "again" | "folds" | "fixed" | "other";
 
 /** What a second tier gives: its result, and its effects when it records them. */
 export interface TierResult {
@@ -45,8 +47,8 @@ export interface AgreeOptions {
   /** The definitional code of the compiled evaluators of the machine, for the reference. */
   readonly definitions?: Definitions;
   /**
-   * The tiers to compare with the plan. The default is the reference, the traced evaluation, a second evaluation and
-   * the plan with the other choice of folds.
+   * The tiers to compare with the plan. The default is the reference, the traced evaluation, a second evaluation, the
+   * plan with the other choice of folds and the plan with fixed names.
    */
   readonly tiers?: readonly Exclude<Tier, "other">[];
   /**
@@ -85,7 +87,7 @@ export interface AgreeOptions {
 }
 
 /** The tiers that `agree` compares when its options name none. */
-const DEFAULT_TIERS: readonly Exclude<Tier, "other">[] = /* @__PURE__ */ Object.freeze(["reference", "traced", "again", "folds"]);
+const DEFAULT_TIERS: readonly Exclude<Tier, "other">[] = /* @__PURE__ */ Object.freeze(["reference", "traced", "again", "folds", "fixed"]);
 
 /** The outcome of `agree`: the result of the plan, or the first tier that disagrees with it. */
 export type Agreement =
@@ -132,7 +134,8 @@ function sameInTiers(x: unknown, y: unknown): boolean | undefined {
 
 const CLOSURE = /* @__PURE__ */ Symbol.for("coeval.closure");
 
-function closureParams(fn: object): unknown {
+/** This function gives the parameters of a closure of `fn`, or `undefined` for another function. */
+export function closureParams(fn: object): unknown {
   return (fn as { readonly [CLOSURE]?: { readonly params: readonly string[] } })[CLOSURE]?.params;
 }
 
@@ -184,6 +187,57 @@ function effectsDiffer(a: readonly Effect[], b: readonly Effect[], options: Agre
   return undefined;
 }
 
+/**
+ * This function compares the plan with the tier `fixed` (PLAN.FIXED). The tier declares each name of plain data fixed,
+ * with a frozen copy of its value. It evaluates with these copies, thus the folds with fixed names give the result.
+ * Then it evaluates with the context of `agree`, thus the code without the fold gives the result. A fold moves the
+ * calls of the host to the compilation, thus only the result and the effects compare.
+ */
+function fixedDiffers(
+  machine: Machine,
+  doc: unknown,
+  context: Context,
+  result: Result,
+  effects: readonly Effect[],
+  given: { readonly declaredType?: string; readonly verb?: string; readonly perform?: Perform },
+  options: AgreeOptions,
+): { readonly other: Result; readonly reason: string } | undefined {
+  const { perform, ...declared } = given;
+  const held = fixedContext(context);
+  const plan = prepare(machine, doc, { ...declared, fixed: { names: held.fixed } });
+  for (const each of [held.context, context]) {
+    const tierEffects: Effect[] = [];
+    const other = plan.evaluate(each, { effects: tierEffects, ...(perform === undefined ? {} : { perform }) });
+    options.observe?.();
+    if (overflowed(result) || overflowed(other)) continue;
+    const reason = resultDiffers(result, other, options) ?? effectsDiffer(effects, tierEffects, options);
+    if (reason !== undefined) return { other, reason };
+  }
+  return undefined;
+}
+
+/**
+ * This function gives the context of the tier `fixed`. Each name of plain data gets a deeply frozen copy of its value,
+ * and the record of the fixed names holds the same copy. Each other name keeps its value.
+ */
+function fixedContext(context: Context): { readonly context: Context; readonly fixed: Readonly<Record<string, unknown>> } {
+  const given = context.names;
+  const names = Object.create(Object.getPrototypeOf(given) as object | null) as Record<string, unknown>;
+  const fixed = Object.create(null) as Record<string, unknown>;
+  for (const key of Reflect.ownKeys(given)) {
+    let field = Object.getOwnPropertyDescriptor(given, key) as PropertyDescriptor;
+    if (typeof key === "string" && "value" in field) {
+      const copy = sharedCopy(field.value);
+      if (copy !== undefined || field.value === undefined) {
+        Object.defineProperty(fixed, key, { value: copy, enumerable: true });
+        field = { ...field, value: copy };
+      }
+    }
+    Object.defineProperty(names, key, field);
+  }
+  return { context: { ...context, names }, fixed };
+}
+
 /**
  * This function evaluates a document with a plan and with other tiers, and compares the results (PLAN.AGREES). Two
  * results agree when they have the same value by `sameValue`, or errors with the same code, and the same place when
@@ -228,6 +282,10 @@ export function agree(machine: Machine, doc: unknown, context: Context = makeCon
       const traced = evaluate(machine, doc, context, { ...declared, ...mock });
       other = traced.result;
       otherEffects = [...traced.effects];
+    } else if (tier === "fixed") {
+      const why = fixedDiffers(machine, doc, context, result, effects, { ...declared, ...mock }, options);
+      if (why !== undefined) return { ok: false, tier, plan: result, other: why.other, reason: why.reason };
+      continue;
     } else if (tier === "folds") {
       other = prepare(machine, doc, { ...declared, fold: !folds }).evaluate(context, { effects: otherEffects, ...mock });
       if (observe !== undefined) {
@@ -340,6 +398,8 @@ export async function agreeRun(machine: Machine, doc: unknown, context: Context
   const log = recording.log();
 
   for (const tier of options.tiers ?? DEFAULT_TIERS) {
+    // A run has no tier with fixed names (PLAN.FIXED).
+    if (tier === "fixed") continue;
     const replay = watched(replayer(log));
     const host = { perform: replay.perform };
     let other: Result;

package/src/deref.ts

@@ -48,6 +48,15 @@ export interface HostThing {
    * @returns What the keys reach, or `undefined` when they reach nothing. `{ thing: undefined }` tells that the keys reach a field that holds `undefined`.
    */
   resolve?(keys: readonly Key[]): { readonly thing: Thing } | undefined;
+  /**
+   * This optional function answers one step only when the host has its value without new work (SCHED.CLOSURE). A
+   * kept read of a closure uses it, because the evaluation did not ask for that read. A schedule gives the value of
+   * a node that has its result in the data epoch. A throw gives the error of the step.
+   *
+   * @param key - The key of the step.
+   * @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;
 }
 
 /** Something that a path can reach: any value of the host, or a host thing. */
@@ -116,6 +125,14 @@ export interface WalkInput {
    * @returns What the step reaches, or `undefined`.
    */
   deref(thing: Thing, key: Key): Thing | undefined;
+  /**
+   * This optional function records one hop inside the walk (HOP.EACH-STEP). The resolution gives it only when it
+   * records hops. The hop of the whole walk comes after these hops, as before.
+   *
+   * @param key - The key that the walk followed.
+   * @param thing - The thing that the key reached.
+   */
+  readonly visit?: (key: Key, thing: Thing) => void;
 }
 
 /** A walker: the code of the verb `step` of a kind of step documents. */
@@ -651,15 +668,16 @@ function resolveFully(nav: Navigator, ctx: Context, path: readonly unknown[], ho
         const walker = given === undefined ? walkerOf(nav, step) : (given ?? undefined);
         if (walker === undefined) return failed("#STEP?", "A step is a key, or a document of a kind with the verb step.");
         const envelope = step as Envelope;
-        const result = walker({
-          data: envelope.value,
-          here,
-          context: ctx,
-          deref: (thing, key) => {
-            const reached = derefStep(nav, thing, key);
-            return reached === undefined ? undefined : adopt(reached.thing);
-          },
-        });
+        const deref = (thing: Thing, key: Key): Thing | undefined => {
+          const reached = derefStep(nav, thing, key);
+          return reached === undefined ? undefined : adopt(reached.thing);
+        };
+        // A resolution without a record of hops gives no `visit`, thus a walker records nothing (HOP.EACH-STEP).
+        const result = walker(
+          hops === undefined
+            ? { data: envelope.value, here, context: ctx, deref }
+            : { data: envelope.value, here, context: ctx, deref, visit: (key, thing) => hops.push({ step: key, thing, by: "step" }) },
+        );
         if (!result.ok) return failed(result.code ?? "#N/A", result.reason);
         here = adopt(result.thing);
         hops?.push({ step: envelope as Json, thing: here, by: "step" });

package/src/evaluate.ts

@@ -904,30 +904,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 };
@@ -1055,14 +1120,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;
   }
 
@@ -1402,6 +1468,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 +1515,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 +1677,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 +1774,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 +1852,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 +1961,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;
@@ -2042,7 +2222,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);

package/src/index.ts

@@ -176,6 +176,7 @@ export {
   STD_WORLD,
   attributeTrace,
   nearestWalker,
+  placeOf,
 } from "./stdlib.ts";
 export {
   type Edge,
@@ -266,6 +267,15 @@ export {
   edgesOf,
   schedule,
 } from "./schedule.ts";
+export {
+  type AgreeScheduleOptions,
+  type ScheduleAgreement,
+  type ScheduleAgreementCounts,
+  type ScheduleEngine,
+  type ScheduleEngineFactory,
+  type ScheduleEngineStart,
+  agreeSchedule,
+} from "./meaning.ts";
 export { type GraphCycle, type GraphEdge, type GraphNode, type GraphOptions, type NodeGraph, components, cycles, heights, necessary, nodeLayers } from "./graph.ts";
 export { type Recorder, type ReplayEntry, type ReplayLog, type ReplayOptions, type ReplaySettle, recorder, replayer } from "./replay.ts";
 export { type GenerateOptions, type Random, generate, random, typesOf } from "./generate.ts";