@mark1russell7/coeval 0.26.0 → 0.27.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.26.0",
+  "version": "0.27.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",
@@ -46,6 +46,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@mark1russell7/rigor-generators": "^0.1.8"
+  },
   "scripts": {
     "build": "tsdown",
     "test": "vitest run",

package/src/errors.ts

@@ -16,6 +16,7 @@ export type KernelCode =
   | "#CAP!"
   | "#CALC!"
   | "#DEPTH!"
+  | "#WORK!"
   | "#ABORT"
   | "#REPLAY!"
   | "#TYPE!";

package/src/evaluate.ts

@@ -541,6 +541,25 @@ export function placeText(place: readonly Key[]): string {
 /** An effect while the kernel waits for its outcome. */
 type Recorded = { -readonly [K in keyof Effect]: Effect[K] };
 
+/**
+ * The most work of one evaluation for a machine without its own `maxWork` (WORK.LIMIT, D134). One application of a
+ * closure is one point.
+ */
+export const WORK_LIMIT = 200000;
+
+/** The work of one node that an equation makes (WORK.NODE, D134). A node costs more than an application. */
+export const NODE_WORK = 8;
+
+/**
+ * This function gives the error of the limit of work. Each tier gives this error (WORK.AGREES).
+ *
+ * @param limit - The limit of the machine.
+ * @returns The error.
+ */
+export function workFailure(limit: number): EvalError {
+  return fail("#WORK!", `The work of one evaluation is more than ${limit} points. The field maxWork of the machine sets the limit.`).error;
+}
+
 /**
  * The runtime of one evaluation or run. Compiled code gets it with the context, and asks it to resolve paths and
  * to cause effects.
@@ -549,6 +568,15 @@ export interface Runtime {
   readonly machine: Machine;
   /** `true` in a run: the host does each effect, and a part that waits needs a parent that can wait. */
   readonly running: boolean;
+  /** `true` when a node that this runtime makes costs work: in an equation of a tree (WORK.NODE) and in a fold. */
+  readonly nested?: boolean;
+  /**
+   * This optional function adds work to the count of the evaluation (WORK.LIMIT). A runtime without it counts nothing.
+   *
+   * @param points - The work.
+   * @throws {Failure} The error `#WORK!`, when the count is over the limit of the machine.
+   */
+  spend?(points: number): void;
   /**
    * This function resolves a path from a context.
    *
@@ -819,6 +847,11 @@ export interface CompiledEvaluator {
    * (TYPE.RULE). Only a check reads it. An evaluator without a rule gives `unknown`.
    */
   readonly type?: TypeRule;
+  /**
+   * `true` when a value that the code gives can use its runtime after the end of the evaluation (WORK.KEEPS). The plan
+   * then marks that end. A compiled evaluator without this field gives no such value.
+   */
+  readonly keeps?: boolean;
 }
 
 /** An evaluator: a function of its input, or a compiler. */
@@ -848,6 +881,7 @@ export type Runner = RunFn | CompiledRunner;
  * A machine: a world of kinds, and the code of each evaluator name, of each `deref` and of each walker.
  *
  * - `maxDepth`: the deepest nesting of documents. The default is 1000.
+ * - `maxWork`: the most work of one evaluation (WORK.LIMIT, D134). The default is `WORK_LIMIT`.
  * - `permits`: the rule of the host for an effect. The default is the function `permits` on the capabilities. A run,
  *   `check` and `effectsOf` ask it (CAP.PERMITS). In a check, its context has only the capabilities and the world.
  * - `known`: the names that the evaluators know, for `check`. Without it, `check` does not check such names.
@@ -859,6 +893,7 @@ export interface Machine extends Navigator {
   /** The runners, by evaluator name. A runner wins over an evaluator of the same name. */
   readonly runners?: Readonly<Record<string, Runner>>;
   readonly maxDepth?: number;
+  readonly maxWork?: number;
   readonly permits?: (caps: readonly Cap[], kind: readonly Key[], context: Context) => boolean;
   /**
    * This function tells if an evaluator knows the name in the path of a kind. An example is the operation
@@ -1157,6 +1192,13 @@ 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 {
+  /**
+   * The count of the work, on the runtime of the root of the evaluation (WORK.LIMIT). The first count adds the field,
+   * thus an evaluation without a counted point has no field.
+   */
+  declare work?: number;
+  /** The count of the applications of closures that run at this time. `formula.fn` writes it (FORMULA.CALL-DEPTH). */
+  declare applying?: number;
   readonly machine: Machine;
   /**
    * The epoch of the evaluation: the list of capabilities that the host gave the root (CAP.NARROW-KEPT). A context
@@ -1166,7 +1208,12 @@ class Session implements Runtime {
   readonly running: boolean;
   readonly traced: boolean;
   readonly perform: Perform | undefined;
-  readonly signal: StopSignal | undefined;
+  /**
+   * The runtime of the root, on the runtime of an equation of a tree (WORK.EQUATION). The runtime of a root holds
+   * itself after the end of its evaluation (WORK.AFTER, WORK.KEEPS), thus the end mark adds no field to the object.
+   * Each runtime has this field, thus a tree and its equations have one object shape.
+   */
+  top: Session | 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).
@@ -1196,7 +1243,7 @@ class Session implements Runtime {
     running: boolean,
     traced: boolean,
     perform: Perform | undefined,
-    signal: StopSignal | undefined,
+    top: Session | undefined,
     effects: Effect[] | undefined,
     reading: Reading | undefined = undefined,
   ) {
@@ -1205,13 +1252,36 @@ class Session implements Runtime {
     this.running = running;
     this.traced = traced;
     this.perform = perform;
-    this.signal = signal;
+    this.top = top;
     this.reading = reading;
     this.list = effects;
     this.holder = traced ? holderNode() : undefined;
     this.current = this.holder;
   }
 
+  /** This getter gives `true` for the runtime of an equation of a tree (WORK.NODE). */
+  get nested(): boolean {
+    const top = this.top;
+    return top !== undefined && top !== this;
+  }
+
+  /**
+   * This function adds work to the count of the evaluation (WORK.LIMIT). One count is on the runtime of the root, thus
+   * each equation of a tree adds to it. After the end of the evaluation, each entry from the host starts a new count
+   * (WORK.AFTER).
+   *
+   * @param points - The work.
+   * @throws {Failure} The error `#WORK!`, when the count is over the limit of the machine.
+   */
+  spend(points: number): void {
+    const root = this.top ?? this;
+    const entry = root.top === root && (this.applying ?? 0) === 0;
+    const work = (entry ? 0 : (root.work ?? 0)) + points;
+    root.work = work;
+    const limit = this.machine.maxWork ?? WORK_LIMIT;
+    if (work > limit) throw new Failure(workFailure(limit));
+  }
+
   /** The effects of the evaluation, in their order. */
   get effects(): Effect[] {
     return (this.list ??= []);
@@ -1753,6 +1823,8 @@ interface Compiler {
   readonly guards: ReadonlyMap<string, ValueType> | undefined;
   /** The runtime of the folds of this compilation. The first fold makes it. */
   probe?: Probe;
+  /** `true` when a document of this compilation can use its runtime after the end of the evaluation (WORK.KEEPS). */
+  keeps?: boolean;
 }
 
 function failing(c: Compiler, meta: Meta, place: readonly Key[], code: ErrorCode, reason: string): Compiled {
@@ -1890,6 +1962,7 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
   };
   // A compiler that throws fails its own document when that document evaluates, with its place (PLAN.FAIL-LATE).
   if (runner !== undefined) {
+    c.keeps = true;
     let inner: RunCode;
     try {
       inner = isCompiledRunner(runner) ? runner.compileRun(input) : interpretRun(runner, input, split.fill, kind?.caps?.some((rule) => rule.rule === "grant") === true);
@@ -1901,6 +1974,7 @@ function compileNode(c: Compiler, value: unknown, place: readonly Key[], declare
     return finish(c, meta, runnerCode(run, place, kindText), run);
   }
 
+  if (!isCompiledEvaluator(evaluator as Evaluator) || (evaluator as CompiledEvaluator).keeps === true) c.keeps = true;
   let inner: Code;
   try {
     inner = isCompiledEvaluator(evaluator as Evaluator) ? (evaluator as CompiledEvaluator).compile(input) : interpret(evaluator as EvalFn, input, split.fill);
@@ -1990,6 +2064,8 @@ class Probe implements Runtime {
   readonly running = false;
   /** `true` after the part asked for something that a fold cannot give. */
   refused = false;
+  /** A node in a fold costs work, thus a tree stops the fold before it evaluates an equation (WORK.PREPARE). */
+  readonly nested = true;
   /** The count of the names that the part read. */
   reads = 0;
   /**
@@ -2058,6 +2134,12 @@ class Probe implements Runtime {
   keepsContext(): void {
     this.refused = true;
   }
+
+  /** This function stops the fold at the first point of work, thus `prepare` does no such work (WORK.PREPARE). */
+  spend(): void {
+    this.refused = true;
+    throw new Failure(workFailure(0));
+  }
 }
 
 /**
@@ -2418,8 +2500,8 @@ export interface InputWithRuntime extends EvalInput {
 /**
  * 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)`.
+ * plan go in the record of the reads of `outer`, and its work goes in the count of `outer` (WORK.EQUATION). The context
+ * at the root of `outer` tells which reads are free (READS.FREE). Without a session, the function gives `plan.evaluate(context)`.
  *
  * @param plan - The plan.
  * @param context - The context of the plan.
@@ -2427,11 +2509,10 @@ export interface InputWithRuntime extends EvalInput {
  * @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);
+  if (!(outer instanceof Session) || !(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));
+  return plan.code(ctx, new Session(machine, ctx.caps, false, plan.traced, undefined, outer.top ?? outer, undefined, outer.reading));
 }
 
 function interpret(fn: EvalFn, input: CompileInput, fill: <P>(handles: readonly P[]) => unknown): Code {
@@ -2570,7 +2651,23 @@ export function prepare(machine: Machine, doc: unknown, options: PrepareOptions
     const result = placed(thrown(error, "the compilation"), []);
     root = { code: () => result, run: undefined };
   }
-  return new CompiledPlan(machine, c.traced, root.code, root.run);
+  return new CompiledPlan(machine, c.traced, c.keeps === true ? endingCode(root.code) : root.code, root.run);
+}
+
+/**
+ * This function gives the code of a plan with a document that can use its runtime after the end of the evaluation. The
+ * code marks that end (WORK.KEEPS). Each other plan has no such step, thus the count adds nothing to a read.
+ *
+ * @param code - The code of the root.
+ * @returns The code that marks the end.
+ */
+function endingCode(code: Code): Code {
+  return (ctx, rt) => {
+    const result = code(ctx, rt);
+    const session = rt as Session;
+    session.top ??= session;
+    return result;
+  };
 }
 
 /**
@@ -2619,8 +2716,10 @@ class CompiledPlan implements Plan {
   run(context: Context = makeContext(), runOptions: PlanRunOptions = {}): Promise<Result> {
     const machine = this.machine;
     const ctx = rootContext(machine, context);
-    const s = new Session(machine, ctx.caps, true, this.traced, runOptions.perform, runOptions.signal, undefined, readingOf(runOptions.reads, ctx));
-    return driveWaiting(this.runCode()(ctx, s), runOptions.signal);
+    const s = new Session(machine, ctx.caps, true, this.traced, runOptions.perform, undefined, undefined, readingOf(runOptions.reads, ctx));
+    return driveWaiting(this.runCode()(ctx, s), runOptions.signal).finally(() => {
+      s.top = s;
+    });
   }
 }
 
@@ -2689,8 +2788,7 @@ export function evaluate(machine: Machine, doc: unknown, context: Context = make
   });
   const ctx = rootContext(machine, context);
   const s = new Session(machine, ctx.caps, false, true, given.perform, undefined, undefined, readingOf(given.reads, ctx));
-  const result = (plan as CompiledPlan).code(ctx, s);
-  return record(s, result);
+  return record(s, (plan as CompiledPlan).code(ctx, s));
 }
 
 /**
@@ -2712,8 +2810,9 @@ export async function run(machine: Machine, doc: unknown, context: Context = mak
     ...(options.verb === undefined ? {} : { verb: options.verb }),
   });
   const ctx = rootContext(machine, context);
-  const s = new Session(machine, ctx.caps, true, true, options.perform, options.signal, undefined, readingOf(options.reads, ctx));
+  const s = new Session(machine, ctx.caps, true, true, options.perform, undefined, undefined, readingOf(options.reads, ctx));
   const result = await driveWaiting((plan as CompiledPlan).runCode()(ctx, s), options.signal);
+  s.top = s;
   return record(s, result);
 }
 

package/src/formula.ts

@@ -175,8 +175,8 @@ function setOwn(target: Record<string, unknown>, key: string, value: unknown): v
   else target[key] = value;
 }
 
-function compiled(compile: (input: CompileInput) => Code): CompiledEvaluator {
-  return { compile };
+function compiled(compile: (input: CompileInput) => Code, keeps?: true): CompiledEvaluator {
+  return keeps === undefined ? { compile } : { compile, keeps };
 }
 
 /** This function evaluates parts in order. It gives the value of each part, or the first error. */
@@ -756,7 +756,7 @@ function makeEvaluators(profile: FormulaProfile): Readonly<Record<string, Evalua
   for (const name of Object.keys(evaluators)) {
     const evaluator = evaluators[name] as CompiledEvaluator;
     const type = Object.hasOwn(types, name) ? types[name] : undefined;
-    const made = Object.freeze(type === undefined ? evaluator : { compile: evaluator.compile, type });
+    const made = Object.freeze(type === undefined ? evaluator : { ...evaluator, 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;
@@ -1045,6 +1045,8 @@ function formulaCode(profile: FormulaProfile): Readonly<Record<string, CompiledE
           // Each application counts one level on the runtime of its evaluation, and the count goes down after it (FORMULA.CALL-DEPTH).
           const level = (clock.applying ?? 0) + 1;
           if (level > limit) throw new Failure(fail("#DEPTH!", `The applications of functions nest deeper than ${limit} levels.`).error);
+          // WORK.LIMIT: an application is a place where work can multiply, thus each one counts one point (D134).
+          rt.spend?.(1);
           clock.applying = level;
           try {
             const scope: Record<string, unknown> = { ...ctx.names };
@@ -1059,7 +1061,8 @@ function formulaCode(profile: FormulaProfile): Readonly<Record<string, CompiledE
         Object.defineProperty(closure, CLOSURE, { value: { params: names } });
         return ok(closure);
       };
-    }),
+      // A closure uses its runtime after the end of the evaluation (WORK.KEEPS).
+    }, true),
 
     "formula.call": compiled(({ value }) => {
       const record = partsOf(value);

package/src/generate.ts

@@ -1,6 +1,7 @@
 import { type Json, type Key, docEquals, isEnvelope, typePath } from "./doc.ts";
 import { type Kind, type ScopeRule, type Shape, type World, type WorldEntry, isAlias, isKind, isNamespace, lookupKind } from "./world.ts";
 import { pathMatches } from "./parts.ts";
+import { mulberry32 } from "@mark1russell7/rigor-generators";
 import { ROOTS, type Root } from "./deref.ts";
 
 /** A source of random numbers with a seed. The same seed gives the same numbers. */
@@ -16,20 +17,14 @@ export interface Random {
 }
 
 /**
- * This function makes a source of random numbers with a seed (the algorithm mulberry32). It needs no package.
+ * This function makes a source of random numbers with a seed. The numbers come from `mulberry32` of
+ * `@mark1russell7/rigor-generators` (K248, D191). The draws `int`, `chance` and `pick` keep the rules of the core.
  *
  * @param seed - The seed: a whole number.
  * @returns The source.
  */
 export function random(seed: number): Random {
-  let state = seed >>> 0;
-  const next = (): number => {
-    state = (state + 0x6d2b79f5) >>> 0;
-    let t = state;
-    t = Math.imul(t ^ (t >>> 15), t | 1);
-    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
+  const next = mulberry32(seed);
   const int = (below: number): number => Math.floor(next() * below);
   return { next, int, chance: (p) => next() < p, pick: (items) => items[int(items.length)] as never };
 }

package/src/index.ts

@@ -186,6 +186,7 @@ export {
   prepare,
   resolveCompiled,
   run,
+  WORK_LIMIT,
 } from "./evaluate.ts";
 export {
   type AttributeAnswer,

package/src/merge.ts

@@ -581,7 +581,7 @@ function checkHidden(m: Merger, draft: MachineDraft): void {
  * - A runner hides the evaluator of its name. Thus one part must give both, or the merge gives a conflict.
  * - The hooks `known` compose in the order of the parts. A hook does not answer for a name that a later part replaces.
  *   The hooks `facts` compose the same way, and the first answer that is not `undefined` wins.
- * - Each other field, for example `permits`, `adopt`, `roots`, `plain` or `maxDepth`, is one value. Two different
+ * - Each other field, for example `permits`, `adopt`, `roots`, `plain`, `maxDepth` or `maxWork`, is one value. Two different
  *   values are a conflict. An absent field has no value.
  *
  * A conflict stops the merge, unless the later part names its path in `replaces`. A part can be a function of the

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,13 @@ 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 state of one evaluation of the reference. */
 interface Env {
   readonly machine: Machine;
@@ -130,6 +140,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 +705,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 && env.applying === 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 +753,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 +780,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 },
+    nested: meter !== undefined,
     reading: outer ?? (options.reads === undefined ? undefined : { list: options.reads, root }),
   };
 }
@@ -869,7 +906,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 +1277,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 +1335,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 +1373,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 +1383,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,10 +1521,12 @@ 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 clock = activeEnvs[activeEnvs.length - 1] ?? { applying: 0, maxDepth: 1000, maxWork: WORK_LIMIT, meter: { spent: 0, ended: false } };
     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;
       try {
         const scope: Record<string, unknown> = {};