@mark1russell7/coeval 0.26.1 → 0.27.1

package/src/reference.ts

@@ -36,12 +36,15 @@ import {
   type Steps,
   type StopSignal,
   JOURNAL,
+  NODE_WORK,
+  WORK_LIMIT,
   heldReason,
   makeContext,
   permits,
   placeText,
   reachedOf,
   waitedReason,
+  workFailure,
 } from "./evaluate.ts";
 import { type FormulaProfile, type OpFn, Held, STD_EXT } from "./formula.ts";
 
@@ -111,6 +114,15 @@ interface Reading {
   readonly root: Context;
 }
 
+/** The count of the work of one evaluation of the reference (WORK.LIMIT). */
+interface Meter {
+  spent: number;
+  /** `true` after the end of the evaluation. Then each entry from the host starts a new count (WORK.AFTER). */
+  ended: boolean;
+  /** The count of the applications of closures that run at this time, in each state of the evaluation (WORK.AFTER). */
+  active: number;
+}
+
 /** The state of one evaluation of the reference. */
 interface Env {
   readonly machine: Machine;
@@ -130,6 +142,12 @@ interface Env {
   held: number;
   /** The count of the applications of closures that run at this time: the clock of `call` (FORMULA.CALL-DEPTH, D125). */
   applying: number;
+  /** The most work of one evaluation (WORK.LIMIT, D134). */
+  readonly maxWork: number;
+  /** The count of the work. An equation of a tree shares the count around it (WORK.EQUATION). */
+  readonly meter: Meter;
+  /** `true` for an equation of a tree (WORK.NODE). */
+  readonly nested: boolean;
   /** The record of the reads. A nested evaluation for an equation of a tree keeps the record of its tree. */
   readonly reading: Reading | undefined;
 }
@@ -689,23 +707,37 @@ function* together(env: Env, list: readonly RunPart[], options: AllOptions = {})
  * @returns The result.
  */
 export function reference(machine: Machine, doc: unknown, context: Context = makeContext(), options: ReferenceOptions = {}): Result {
-  return evaluateRoot(machine, doc, context, options, undefined);
+  return evaluateRoot(machine, doc, context, options, undefined, undefined);
 }
 
 /**
- * This function evaluates a document from its root. An equation of a tree gives the record of its tree. Thus the
- * reads of the equation go in the list of the outer evaluation (REF.READS).
+ * This function evaluates a document from its root. An equation of a tree gives the record of its tree and the count
+ * of its work. Thus its reads go in the list of the outer evaluation (REF.READS), and its work in the outer count
+ * (WORK.EQUATION).
  */
-function evaluateRoot(machine: Machine, doc: unknown, context: Context, options: ReferenceOptions, outer: Reading | undefined): Result {
+function evaluateRoot(machine: Machine, doc: unknown, context: Context, options: ReferenceOptions, outer: Reading | undefined, meter: Meter | undefined): Result {
   const at = rootAt(machine, doc, context, options);
-  const env = envOf(machine, options, false, at.ctx, outer);
+  const env = envOf(machine, options, false, at.ctx, outer, meter);
   try {
     return within(env, () => evaluateAt(env, at));
   } catch (error) {
     return placed(thrown(error, "the reference"), []);
+  } finally {
+    if (!env.nested) env.meter.ended = true;
   }
 }
 
+/**
+ * WORK.LIMIT: this function adds work to the count of an evaluation. After the end of the evaluation, each entry from
+ * the host starts a new count (WORK.AFTER). A count over the limit throws `#WORK!`.
+ */
+function spend(env: Pick<Env, "maxWork" | "meter" | "applying">, points: number): void {
+  const meter = env.meter;
+  if (meter.ended && meter.active === 0) meter.spent = 0;
+  meter.spent += points;
+  if (meter.spent > env.maxWork) throw new Failure(workFailure(env.maxWork));
+}
+
 /**
  * This function starts a run of a document by the rules, without a compilation (REF.RUN). The host does each effect of a runner,
  * and a step waits when the host waits (RUN.SEQ). `all` settles the waits in the order of the host, or in the order
@@ -723,16 +755,20 @@ function evaluateRoot(machine: Machine, doc: unknown, context: Context, options:
  */
 export function referenceRun(machine: Machine, doc: unknown, context: Context = makeContext(), options: ReferenceRunOptions = {}): Promise<Result> {
   const at = rootAt(machine, doc, context, options);
-  const env = envOf(machine, options, true, at.ctx, undefined);
+  const env = envOf(machine, options, true, at.ctx, undefined, undefined);
   const steps = stepsAt(env, at);
-  return driveRun(env, steps, options.signal).catch((error: unknown) => placed(thrown(error, "the reference"), []));
+  return driveRun(env, steps, options.signal)
+    .catch((error: unknown) => placed(thrown(error, "the reference"), []))
+    .finally(() => {
+      env.meter.ended = true;
+    });
 }
 
 /**
  * This function makes the state of the reference for one evaluation or one run. The record of the reads comes from
  * the evaluation around it, or from the list of the options.
  */
-function envOf(machine: Machine, options: ReferenceOptions, running: boolean, root: Context, outer: Reading | undefined): Env {
+function envOf(machine: Machine, options: ReferenceOptions, running: boolean, root: Context, outer: Reading | undefined, meter: Meter | undefined): Env {
   const perform = options.perform;
   return {
     machine,
@@ -746,6 +782,9 @@ function envOf(machine: Machine, options: ReferenceOptions, running: boolean, ro
     scope: { prefix: "", counts: new Map(), alls: 0 },
     held: 0,
     applying: 0,
+    maxWork: machine.maxWork ?? WORK_LIMIT,
+    meter: meter ?? { spent: 0, ended: false, active: 0 },
+    nested: meter !== undefined,
     reading: outer ?? (options.reads === undefined ? undefined : { list: options.reads, root }),
   };
 }
@@ -869,7 +908,7 @@ function equationOf(node: RefNode, term: Json, names: Readonly<Record<string, un
   const env = node.env;
   if (env === undefined) return fail("#NOEVAL", "The evaluation of an equation needs the machine.");
   const ctx: Context = { ...node.ctx, names, caps: [], self: node.thing };
-  return evaluateRoot(env.machine, term, ctx, { definitions: env.definitions, ...(node.of === undefined ? {} : { declaredType: node.of }) }, env.reading);
+  return evaluateRoot(env.machine, term, ctx, { definitions: env.definitions, ...(node.of === undefined ? {} : { declaredType: node.of }) }, env.reading, env.meter);
 }
 
 function termIn<T>(table: Readonly<Record<string, T>> | undefined, name: string): T | undefined {
@@ -1240,43 +1279,56 @@ function instanceOf(node: RefNode, attr: string, args: unknown): Result | undefi
 }
 
 /** TREE.RESULT: the JSON of a node. `open` holds the nodes and the containers whose JSON is in progress. */
-function jsonOfNode(node: RefNode, self: HostThing, open: readonly object[]): Result {
-  const record: Record<string, unknown> = {};
-  for (const part of node.parts) {
-    const result = attributeOf(node, part.key) as Result;
-    if (!result.ok) return result;
-    const value = plainValue(result.value, [...open, self]);
-    if (!value.ok) return value;
-    setField(record, part.key, value.value);
+function jsonOfNode(node: RefNode, self: HostThing, open: readonly object[], seen: Set<object>): Result {
+  try {
+    const record: Record<string, unknown> = {};
+    for (const part of node.parts) {
+      const result = attributeOf(node, part.key) as Result;
+      if (!result.ok) return result;
+      const value = plainValue(node, result.value, [...open, self], seen);
+      if (!value.ok) return value;
+      setField(record, part.key, value.value);
+    }
+    return ok(record);
+  } finally {
+    seen.add(self);
   }
-  return ok(record);
 }
 
-/** This function gives a copy of a value with the JSON of each node in it. */
-function plainValue(value: unknown, open: readonly object[]): Result {
+/**
+ * This function gives a copy of a value with the JSON of each node in it. The set `seen` holds each node, list and
+ * record that the walk left. A second visit of one of them counts one point on the evaluation of `owner` (WORK.SHARED).
+ */
+function plainValue(owner: RefNode, value: unknown, open: readonly object[], seen: Set<object>): Result {
   const node = refNodeOf(value);
   if (node !== undefined) {
     if (open.includes(value as object)) return fail("#CYCLE!", `The JSON of the node ${node.kind} at [${node.place.join(", ")}] holds the node itself.`);
-    return jsonOfNode(node, value as HostThing, open);
+    if (seen.has(value as object) && owner.env !== undefined) spend(owner.env, 1);
+    return jsonOfNode(node, value as HostThing, open, seen);
   }
   if (typeof value !== "object" || value === null || isHostThing(value) || open.includes(value)) return ok(value);
-  if (Array.isArray(value)) {
-    const items: unknown[] = [];
-    for (const item of value) {
-      const plain = plainValue(item, [...open, value]);
+  if (!Array.isArray(value) && !isRecord(value)) return ok(value);
+  if (seen.has(value) && owner.env !== undefined) spend(owner.env, 1);
+  try {
+    if (Array.isArray(value)) {
+      const items: unknown[] = [];
+      for (const item of value) {
+        const plain = plainValue(owner, item, [...open, value], seen);
+        if (!plain.ok) return plain;
+        items.push(plain.value);
+      }
+      return ok(items);
+    }
+    const copy: Record<string, unknown> = {};
+    for (const key of Object.keys(value)) {
+      const plain = plainValue(owner, value[key], [...open, value], seen);
       if (!plain.ok) return plain;
-      items.push(plain.value);
+      setField(copy, key, plain.value);
     }
-    return ok(items);
-  }
-  if (!isRecord(value)) return ok(value);
-  const copy: Record<string, unknown> = {};
-  for (const key of Object.keys(value)) {
-    const plain = plainValue(value[key], [...open, value]);
-    if (!plain.ok) return plain;
-    setField(copy, key, plain.value);
+    return ok(copy);
+  } finally {
+    seen.add(value);
   }
-  return ok(copy);
 }
 
 /**
@@ -1285,6 +1337,9 @@ function plainValue(value: unknown, open: readonly object[]): Result {
  * reads `self` only through `resolve` (C4, TREE.SELF).
  */
 const treeDefinition: EvalFn = ({ parts, context, kind, place, machine, typePath, resolve: walk, doc }) => {
+  // WORK.NODE: a node that an equation makes counts. A node of the text of the document does not.
+  const maker = activeEnvs[activeEnvs.length - 1];
+  if (maker?.nested === true) spend(maker, NODE_WORK);
   const reached = walk(["self"]);
   const parent: Thing | undefined = reached.ok ? reached.thing : undefined;
   const outer = refNodeOf(parent);
@@ -1320,7 +1375,7 @@ const treeDefinition: EvalFn = ({ parts, context, kind, place, machine, typePath
     },
     has: (key) => key === "parent" || key === "type" || parts.some((part) => part.key === String(key)) || node.values.has(String(key)),
     toJson: () => {
-      const result = jsonOfNode(node, self, []);
+      const result = jsonOfNode(node, self, [], new Set());
       if (result.ok) return result.value;
       throw new Failure(result.error);
     },
@@ -1330,7 +1385,7 @@ const treeDefinition: EvalFn = ({ parts, context, kind, place, machine, typePath
   AT_READERS.set(self, (attr, args) => instanceOf(node, attr, args));
   if (nested) return ok(self);
   try {
-    return jsonOfNode(node, self, []);
+    return jsonOfNode(node, self, [], new Set());
   } finally {
     node.tree.open = false;
   }
@@ -1468,20 +1523,28 @@ export function formulaDefinitions(profile: FormulaProfile = {}): Definitions {
     const names = params as readonly string[];
     const body = partNamed(parts, "body") as Part;
     // FORMULA.CALL-DEPTH: the evaluation that makes the closure counts its applications. A quarter of maxDepth is the limit.
-    const clock = activeEnvs[activeEnvs.length - 1] ?? { applying: 0, maxDepth: 1000 };
+    const maker = activeEnvs[activeEnvs.length - 1];
+    const clock = maker ?? { applying: 0, maxDepth: 1000, maxWork: WORK_LIMIT, meter: { spent: 0, ended: false, active: 0 } };
     const limit = Math.ceil(clock.maxDepth / 4);
     const closure = (...args: readonly unknown[]): unknown => {
       if (clock.applying >= limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+      // WORK.LIMIT: each application counts one point, after the clock of its depth.
+      spend(clock, 1);
       clock.applying += 1;
+      clock.meter.active += 1;
       try {
         const scope: Record<string, unknown> = {};
         for (const key of Object.keys(context.names)) setField(scope, key, context.names[key]);
         names.forEach((name, index) => setField(scope, name, args[index]));
-        const result = body.evaluate({ ...context, names: scope });
+        // The body evaluates in the state of the evaluation that made the closure, also for a host after the end. Thus a
+        // node of a tree in the body has the machine for its equations (WORK.AFTER).
+        const scoped: Context = { ...context, names: scope };
+        const result = maker === undefined ? body.evaluate(scoped) : within(maker, () => body.evaluate(scoped));
         if (!result.ok) throw new Failure(result.error);
         return result.value;
       } finally {
         clock.applying -= 1;
+        clock.meter.active -= 1;
       }
     };
     Object.defineProperty(closure, CLOSURE, { value: { params: names } });

package/src/stdlib.ts

@@ -9,7 +9,9 @@ import {
   type Result,
   type RunPart,
   type Runner,
+  type Runtime,
   type Steps,
+  NODE_WORK,
   RUNTIME,
   evaluateWithin,
   fail,
@@ -245,11 +247,20 @@ function isNumber(value: unknown): value is number {
 function allValues(results: readonly Result[]): { readonly values: readonly unknown[] } | { readonly error: Result } {
   const errors = results.filter((result) => !result.ok);
   const first = errors[0];
+  // D190: the test of the errors comes before the values. With the values first, a case of the bench took 1.2 to 1.4
+  // times the time in the Maglev tier of V8, in probe 4 of K216.
   if (first !== undefined && errors.length === 1) return { error: first };
-  if (errors.length > 1) return { error: fail("#ARGS", `${errors.length} parts failed.`) };
+  if (errors.length > 1) return { error: partsFailed(errors) };
   return { values: results.map((result) => (result.ok ? result.value : null)) };
 }
 
+/** This function gives the error of more than one failed part. */
+function partsFailed(errors: readonly Result[]): Result {
+  // WORK.LIMIT: after the limit each counted part fails, and the code of the limit stays the code of the result.
+  const stopped = errors.find((result) => !result.ok && result.error.code === "#WORK!");
+  return stopped ?? fail("#ARGS", `${errors.length} parts failed.`);
+}
+
 function numbers(values: readonly unknown[], kind: string): readonly number[] | Result {
   const bad = values.findIndex((value) => !isNumber(value));
   if (bad !== -1) return fail("#VALUE!", `Part ${bad} of ${kind} is not a number.`);
@@ -379,7 +390,7 @@ interface NodeState extends LoopNode {
    * @param path - The nodes and the containers whose JSON is in progress. A node on it gives `#CYCLE!`.
    * @returns The JSON, or the first error.
    */
-  json(path: Set<object>): Result;
+  json(path: JsonWalk): Result;
 }
 
 /** The answer of the ladder for one attribute of one node (TREE.CELL, D108). */
@@ -887,24 +898,35 @@ function putField(target: Record<string, unknown>, key: string, value: unknown):
   Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
 }
 
+/**
+ * The record of a walk for JSON. A node, list or record has `true` while its JSON is in progress, and `false` after
+ * that. Thus a value in the map with `false` is a second visit (WORK.SHARED).
+ */
+type JsonWalk = Map<object, boolean>;
+
 /**
  * This function gives a value with the JSON of each node of a tree in it. A list or a plain record is new only when
  * it holds a node. A container that holds itself stays as it is.
  */
-function plainOf(value: unknown, path: Set<object>): Result {
+function plainOf(value: unknown, path: JsonWalk, runtime: Runtime | undefined): Result {
+  if (typeof value !== "object" || value === null) return ok(value);
   const state = stateOf(value);
+  const open = path.get(value);
   if (state !== undefined) {
-    if (path.has(value as object)) return fail("#CYCLE!", `The JSON of the node ${state.type} at [${state.place.join(", ")}] holds the node itself.`);
+    if (open === true) return fail("#CYCLE!", `The JSON of the node ${state.type} at [${state.place.join(", ")}] holds the node itself.`);
+    if (open === false) runtime?.spend?.(1);
     return state.json(path);
   }
-  if (typeof value !== "object" || value === null || path.has(value) || isHostThing(value)) return ok(value);
+  if (open === true || isHostThing(value)) return ok(value);
   if (!Array.isArray(value) && !isRecord(value)) return ok(value);
-  path.add(value);
+  // WORK.SHARED: a second visit of a container counts one point, because a chain of shared containers doubles the walk.
+  if (open === false) runtime?.spend?.(1);
+  path.set(value, true);
   try {
     if (Array.isArray(value)) {
       let list: unknown[] | undefined;
       for (let index = 0; index < value.length; index += 1) {
-        const item = plainOf(value[index], path);
+        const item = plainOf(value[index], path, runtime);
         if (!item.ok) return item;
         if (item.value !== value[index]) (list ??= [...(value as readonly unknown[])])[index] = item.value;
       }
@@ -913,7 +935,7 @@ function plainOf(value: unknown, path: Set<object>): Result {
     const record = value as Readonly<Record<string, unknown>>;
     let out: Record<string, unknown> | undefined;
     for (const key of Object.keys(record)) {
-      const item = plainOf(record[key], path);
+      const item = plainOf(record[key], path, runtime);
       if (!item.ok) return item;
       if (item.value === record[key]) continue;
       if (out === undefined) {
@@ -924,7 +946,7 @@ function plainOf(value: unknown, path: Set<object>): Result {
     }
     return ok(out ?? value);
   } finally {
-    path.delete(value);
+    path.set(value, false);
   }
 }
 
@@ -1323,19 +1345,19 @@ function treeThing(input: EvalInput, place: readonly Key[], build: TreeBuild, ou
       return cell.by === undefined ? { attribute: key, rungs } : { attribute: key, rungs, by: cell.by };
     },
     json(path) {
-      path.add(node);
+      path.set(node, true);
       try {
         const out: Record<string, unknown> = {};
         for (const part of parts) {
           const result = read(part.key) as Result;
           if (!result.ok) return result;
-          const value = plainOf(result.value, path);
+          const value = plainOf(result.value, path, runtime);
           if (!value.ok) return value;
           putField(out, part.key, value.value);
         }
         return ok(out);
       } finally {
-        path.delete(node);
+        path.set(node, false);
       }
     },
   };
@@ -1359,7 +1381,7 @@ function treeThing(input: EvalInput, place: readonly Key[], build: TreeBuild, ou
       return cell !== undefined && !cell.busy && cell.result !== undefined;
     },
     toJson(): unknown {
-      const result = state.json(new Set());
+      const result = state.json(new Map());
       if (!result.ok) throw new Failure(result.error);
       return result.value;
     },
@@ -1404,6 +1426,9 @@ const NO_HOPS = /* @__PURE__ */ Object.freeze({ hops: false });
  * The argument `host` gives the memo cells of the host (TREE.CELL), or `undefined` for the plain memo of each node.
  */
 function treeNode(input: EvalInput, host: AttributeCell | undefined): Result {
+  const runtime = (input as InputWithRuntime)[RUNTIME];
+  // WORK.NODE: a node that an equation makes counts. A node of the text of the document does not.
+  if (runtime?.nested === true) runtime.spend?.(NODE_WORK);
   const found = input.resolve(SELF_PATH, NO_HOPS);
   const outer = found.ok ? found.thing : undefined;
   const above = stateOf(outer);
@@ -1415,7 +1440,7 @@ function treeNode(input: EvalInput, host: AttributeCell | undefined): Result {
   build.open = true;
   const root = treeThing(input, place, build, outer, host);
   try {
-    return (stateOf(root) as NodeState).json(new Set());
+    return (stateOf(root) as NodeState).json(new Map());
   } finally {
     build.open = false;
   }

package/src/stepper.ts

@@ -1,11 +1,12 @@
 import { type Envelope, type Json, type Key, type TypeRef, docEquals, field, isEnvelope, isRecord, typeName } from "./doc.ts";
 import { type Cap, type Context, type Resolution, type ResolveOptions, type Thing, isHostThing, worldThing } from "./deref.ts";
 import { type EvalError, type Result, Failure, describe, fail, ok, placed, thrown } from "./errors.ts";
-import { type Effect, type EvalInput, type Machine, type Part, type Perform, intersectCaps, makeContext, permits, placeText } from "./evaluate.ts";
+import { type Effect, type EvalInput, type Machine, type Part, type Perform, WORK_LIMIT, intersectCaps, makeContext, permits, placeText, workFailure } from "./evaluate.ts";
 import { type FormulaProfile, type OpFn, Held, STD_EXT } from "./formula.ts";
 import type { World } from "./ladder.ts";
 import { pathMatches } from "./parts.ts";
-import type { Definitions } from "./reference.ts";
+import { type Definitions, STD_DEFINITIONS } from "./reference.ts";
+import { STD_EVALUATORS } from "./stdlib.ts";
 import { type CapsRule, type Kind, type Shape, type WorldEntry, isAlias, isKind, isNamespace } from "./world.ts";
 
 /**
@@ -111,6 +112,12 @@ interface Shared {
   readonly applying: number;
   /** `true` after a closure or a held error goes in a value. Only then does a value need a change for the host. */
   readonly marked: boolean;
+  /** The work of the evaluation after the last call of `stepperNext` (WORK.LIMIT). A configuration without it has done no work. */
+  readonly work?: number;
+  /** The number of earlier effects at each place, after the last call of `stepperNext` (RUN.ADDRESS). */
+  readonly counts?: Readonly<Record<string, number>>;
+  /** The number of effects of the evaluation, after the last call of `stepperNext`. */
+  readonly effected?: number;
 }
 
 /**
@@ -164,8 +171,16 @@ interface Program {
   readonly perform: Perform | undefined;
   /** The number of earlier effects at each place, by the text of the place (RUN.ADDRESS). */
   readonly counts: Map<string, number>;
+  /** The number of effects of the evaluation before the list `effects`. */
+  before: number;
   /** The count of the applications at the last call of host code. */
   applying: number;
+  /** The most work of one evaluation (WORK.LIMIT). */
+  readonly maxWork: number;
+  /** The work of the evaluation: one point for each application of a closure (WORK.LIMIT). */
+  work: number;
+  /** `true` after the end of the evaluation. Then each application from the host starts a new count (WORK.AFTER). */
+  ended: boolean;
 }
 
 const CLOSURE_MARK = "coeval.closure";
@@ -555,6 +570,9 @@ function apply(p: Program, c: Configuration, target: unknown, args: readonly unk
   }
   const limit = Math.ceil(p.maxDepth / 4);
   if (c.applying >= limit) return back(c, fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`));
+  // WORK.LIMIT: each application counts one point, after the clock of its depth.
+  p.work += 1;
+  if (p.work > p.maxWork) return back(c, { ok: false, error: workFailure(p.maxWork) });
   const frame: Frame = { f: "return", place: closure.place.concat(closure.body.path) };
   pushed(c, frame);
   const start = enter(c, { at: NO_KEYS }, closure.site, closure.body, scopeOf(closure, args));
@@ -576,6 +594,11 @@ function hostClosure(p: Program, value: object, closure: Closure): unknown {
   const fn = (...args: readonly unknown[]): unknown => {
     const limit = Math.ceil(p.maxDepth / 4);
     if (p.applying >= limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+    // WORK.AFTER: after the end of the evaluation, each application from the host starts a new count.
+    p.work = (p.ended && p.applying === 0 ? 0 : p.work) + 1;
+    if (p.work > p.maxWork) throw new Failure(workFailure(p.maxWork));
+    // Host code in the nested stepper writes the count of the applications, thus the call puts back the count of its start.
+    const before = p.applying;
     p.applying += 1;
     try {
       const place = closure.place.concat(closure.body.path);
@@ -584,7 +607,7 @@ function hostClosure(p: Program, value: object, closure: Closure): unknown {
       if (!end.result.ok) throw new Failure(end.result.error);
       return forHost(p, end, end.result.value);
     } finally {
-      p.applying -= 1;
+      p.applying = before;
     }
   };
   Object.defineProperty(fn, CLOSURE, { value: { params: closure.params } });
@@ -856,7 +879,7 @@ function cause(p: Program, ctx: Context, kind: Cap, payload: unknown, place: rea
   const count = counts.get(at) ?? 0;
   counts.set(at, count + 1);
   const effect: { -readonly [K in keyof Effect]: Effect[K] } = {
-    index: effects.length,
+    index: p.before + effects.length,
     kind: text,
     path: keys,
     payload,
@@ -948,7 +971,9 @@ function evaluateDoc(p: Program, c: Evaluating): Configuration {
       return back(c, thrown(error, `the evaluator ${name}`));
     }
   }
-  const defined = own(p.definitions.evaluators, name);
+  // A standard evaluator gets the definition of the reference, unless the options give another definition (REF.TREE).
+  const standard = code === own(STD_EVALUATORS, name) ? own(STD_DEFINITIONS.evaluators, name) : undefined;
+  const defined = own(p.definitions.evaluators, name) ?? standard;
   if (defined !== undefined) return hostEvaluator(p, c, name, defined, doc, keys, read.data, read.slots, site);
   return back(c, fail("#NOEVAL", `The stepper has no definition of the compiled evaluator ${name}.`));
 }
@@ -1087,7 +1112,11 @@ function programOf(machine: Machine, options: StepperOptions): Program {
     effects: options.effects ?? [],
     perform: options.perform,
     counts: new Map(),
+    before: 0,
     applying: 0,
+    maxWork: machine.maxWork ?? WORK_LIMIT,
+    work: 0,
+    ended: false,
   };
 }
 
@@ -1124,7 +1153,20 @@ export function stepperNext(machine: Machine, configuration: Configuration, opti
     else if (f === "let") stack[stack.length - 1] = { ...top, names: { ...top.names } };
     else stack[stack.length - 1] = { ...top };
   }
-  return advance(programOf(machine, options), { ...configuration, stack });
+  const p = programOf(machine, options);
+  // Each call has a new program. Thus the configuration holds the state of the evaluation that a later step needs.
+  p.work = configuration.work ?? 0;
+  for (const [at, count] of Object.entries(configuration.counts ?? {})) p.counts.set(at, count);
+  // A list of effects from the host holds the earlier effects. Without it, the configuration holds their number.
+  p.before = options.effects === undefined ? (configuration.effected ?? 0) : 0;
+  const next = advance(p, { ...configuration, stack });
+  const effected = p.before + p.effects.length;
+  return {
+    ...next,
+    ...(p.work === 0 ? {} : { work: p.work }),
+    ...(p.counts.size === 0 ? {} : { counts: Object.fromEntries(p.counts) }),
+    ...(effected === 0 ? {} : { effected }),
+  };
 }
 
 /**
@@ -1143,6 +1185,7 @@ export function stepper(machine: Machine, doc: unknown, context: Context = makeC
   const p = programOf(machine, options);
   try {
     const end = drive(p, stepperStart(machine, doc, context, options));
+    p.ended = true;
     return end.result.ok ? ok(forHost(p, end, end.result.value)) : end.result;
   } catch (error) {
     return placed(thrown(error, "the stepper"), []);