@mark1russell7/coeval 0.6.2 → 0.6.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/coeval",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "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, isRecord } from "./doc.ts";
+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 Machine, evaluate, makeContext, prepare } from "./evaluate.ts";
+import { type Effect, type Machine, type Perform, evaluate, makeContext, prepare } from "./evaluate.ts";
 import { Held, isClosure } from "./formula.ts";
 import { type Definitions, reference } from "./reference.ts";
 
@@ -21,6 +21,12 @@ export interface TierResult {
   readonly effects?: readonly Effect[];
 }
 
+/** What `agree` gives the second tier of a language beside the document and the context. */
+export interface TierInput {
+  /** The mock of the host, when `agree` has one (AGREE.MOCK). The tier answers each effect with it. */
+  readonly perform?: Perform;
+}
+
 /** The options of `agree`. */
 export interface AgreeOptions {
   /** The type of a bare root value. */
@@ -34,9 +40,15 @@ export interface AgreeOptions {
    *
    * @param doc - The document.
    * @param context - The context.
+   * @param input - The mock of the host, when `agree` has one.
    * @returns The result, or the result with the effects.
    */
-  readonly other?: (doc: unknown, context: Context) => Result | TierResult;
+  readonly other?: (doc: unknown, context: Context, input: TierInput) => Result | TierResult;
+  /**
+   * The mock of the host (RUN.MOCK, AGREE.MOCK). Each tier gets it, thus the tiers agree on documents with effects. A
+   * mock must give the same answer to the same effect, because each tier asks it again.
+   */
+  readonly perform?: Perform;
   /**
    * This function compares two values that the rules of `sameValue` do not know, for example two dates.
    *
@@ -80,8 +92,9 @@ export type Agreement =
  * errors have the same code and place. Each other object is the same only as itself, unless the rule of the caller
  * tells otherwise.
  *
- * `docEquals` uses the same rules for lists, plain records and the other objects. It has no rules for closures, for
- * `Held` values and for a rule of the caller. Thus two closures are equal there only when they are the same function.
+ * `docEquals` and `sameResult` use the same walk (D20). `docEquals` has no rules for closures, for `Held` values and
+ * for a rule of the caller. `sameResult` is for an early cutoff, thus a closure is the same there only as itself, and
+ * two errors also need the same reason.
  *
  * @param a - The first value.
  * @param b - The second value.
@@ -89,47 +102,14 @@ export type Agreement =
  * @returns `true` when the values are the same.
  */
 export function sameValue(a: unknown, b: unknown, equal?: (a: unknown, b: unknown) => boolean | undefined): boolean {
-  const stack: (readonly [unknown, unknown])[] = [[a, b]];
-  const seen = new Map<object, Set<object>>();
-  while (stack.length > 0) {
-    const [x, y] = stack.pop() as readonly [unknown, unknown];
-    if (Object.is(x, y)) continue;
-    const told = equal?.(x, y);
-    if (told !== undefined) {
-      if (told) continue;
-      return false;
-    }
-    if (typeof x !== "object" && typeof x !== "function") return false;
-    if (typeof y !== "object" && typeof y !== "function") return false;
-    if (x === null || y === null) return false;
-    // A pair that the comparison already visits is the same, unless another pair shows a difference.
-    const pairs = seen.get(x) ?? new Set<object>();
-    if (pairs.has(y)) continue;
-    pairs.add(y);
-    seen.set(x, pairs);
-    if (isClosure(x) || isClosure(y)) {
-      if (!(isClosure(x) && isClosure(y))) return false;
-      stack.push([closureParams(x), closureParams(y)]);
-      continue;
-    }
-    if (x instanceof Held || y instanceof Held) {
-      if (!(x instanceof Held && y instanceof Held) || errorDiffers(x.error, y.error, false) !== undefined) return false;
-      continue;
-    }
-    if (Array.isArray(x) || Array.isArray(y)) {
-      if (!Array.isArray(x) || !Array.isArray(y) || x.length !== y.length) return false;
-      for (let index = 0; index < x.length; index += 1) stack.push([x[index], y[index]]);
-      continue;
-    }
-    if (!isRecord(x) || !isRecord(y)) return false;
-    const keys = Object.keys(x);
-    if (keys.length !== Object.keys(y).length) return false;
-    for (const key of keys) {
-      if (!Object.hasOwn(y, key)) return false;
-      stack.push([x[key], y[key]]);
-    }
-  }
-  return true;
+  return equalWith(a, b, equal === undefined ? sameInTiers : (x, y) => equal(x, y) ?? sameInTiers(x, y));
+}
+
+/** The rules of `sameValue` for the values that two tiers make again: closures and held errors. */
+function sameInTiers(x: unknown, y: unknown): boolean | undefined {
+  if (isClosure(x) || isClosure(y)) return isClosure(x) && isClosure(y) && docEquals(closureParams(x), closureParams(y));
+  if (x instanceof Held || y instanceof Held) return x instanceof Held && y instanceof Held && errorDiffers(x.error, y.error, false) === undefined;
+  return undefined;
 }
 
 const CLOSURE = /* @__PURE__ */ Symbol.for("coeval.closure");
@@ -165,7 +145,10 @@ function resultDiffers(a: Result, b: Result, options: AgreeOptions): string | un
   return a.ok ? `The plan gives a value, and the tier gives ${codeAndPlace((b as { readonly error: EvalError }).error)}.` : `The plan gives ${codeAndPlace(a.error)}, and the tier gives a value.`;
 }
 
-/** This function gives the difference of two lists of effects, or `undefined` when they agree (EFFECT.ORDER). */
+/**
+ * This function gives the difference of two lists of effects, or `undefined` when they agree (EFFECT.ORDER). When both
+ * tiers record the address or the outcome of an effect, these must agree too (AGREE.MOCK).
+ */
 function effectsDiffer(a: readonly Effect[], b: readonly Effect[], options: AgreeOptions): string | undefined {
   if (a.length !== b.length) return `The plan causes ${a.length} effects, and the tier causes ${b.length}.`;
   for (let index = 0; index < a.length; index += 1) {
@@ -174,6 +157,11 @@ function effectsDiffer(a: readonly Effect[], b: readonly Effect[], options: Agre
     if (x.kind !== y.kind || !docEquals(x.place as readonly Key[], y.place as readonly Key[]) || !sameValue(x.payload, y.payload, options.equal)) {
       return `The effect ${index} differs: ${x.kind} at [${x.place.join(", ")}] in the plan, and ${y.kind} at [${y.place.join(", ")}] in the tier.`;
     }
+    if (x.address !== undefined && y.address !== undefined && x.address !== y.address) {
+      return `The effect ${index} has the address ${x.address} in the plan, and ${y.address} in the tier.`;
+    }
+    const why = x.outcome !== undefined && y.outcome !== undefined ? resultDiffers(x.outcome, y.outcome, options) : undefined;
+    if (why !== undefined) return `The outcome of the effect ${index} differs. ${why}`;
   }
   return undefined;
 }
@@ -182,21 +170,22 @@ function effectsDiffer(a: readonly Effect[], b: readonly Effect[], options: Agre
  * 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
  * both have one. The effects must have the same kinds, places and payloads, in the same order. A language gives its
- * own tier with the option `other`.
+ * own tier with the option `other`. Each tier gets the mock of the option `perform` (AGREE.MOCK).
  *
  * @param machine - The world and the code of the evaluators.
  * @param doc - The document.
  * @param context - The names and the capabilities at the root.
- * @param options - The tiers, the definitions for the reference, the rules of the comparison and the second tier.
+ * @param options - The tiers, the definitions for the reference, the rules of the comparison, the second tier and the mock.
  * @returns The result of the plan, or the first tier that disagrees and the reason.
  */
 export function agree(machine: Machine, doc: unknown, context: Context = makeContext(), options: AgreeOptions = {}): Agreement {
   const declared = options.declaredType === undefined ? {} : { declaredType: options.declaredType };
+  const mock = options.perform === undefined ? {} : { perform: options.perform };
   const observe = options.observe;
   observe?.();
   const plan = prepare(machine, doc, declared);
   const effects: Effect[] = [];
-  const result = plan.evaluate(context, { effects });
+  const result = plan.evaluate(context, { effects, ...mock });
   const saw = observe?.();
 
   const differs = (other: Result, otherEffects: readonly Effect[] | undefined): string | undefined => {
@@ -210,13 +199,13 @@ export function agree(machine: Machine, doc: unknown, context: Context = makeCon
     let other: Result;
     let otherEffects: Effect[] = [];
     if (tier === "reference") {
-      other = reference(machine, doc, context, { ...declared, effects: otherEffects, ...(options.definitions === undefined ? {} : { definitions: options.definitions }) });
+      other = reference(machine, doc, context, { ...declared, ...mock, effects: otherEffects, ...(options.definitions === undefined ? {} : { definitions: options.definitions }) });
     } else if (tier === "traced") {
-      const traced = evaluate(machine, doc, context, options.declaredType);
+      const traced = evaluate(machine, doc, context, { ...declared, ...mock });
       other = traced.result;
       otherEffects = [...traced.effects];
     } else {
-      other = plan.evaluate(context, { effects: otherEffects });
+      other = plan.evaluate(context, { effects: otherEffects, ...mock });
     }
     const why = differs(other, otherEffects);
     if (why !== undefined) return { ok: false, tier, plan: result, other, reason: why };
@@ -225,7 +214,7 @@ export function agree(machine: Machine, doc: unknown, context: Context = makeCon
   if (options.other !== undefined) {
     let given: Result | TierResult;
     try {
-      given = options.other(doc, context);
+      given = options.other(doc, context, mock);
     } catch (error) {
       given = thrown(error, "the tier");
     }

package/src/deref.ts

@@ -17,12 +17,22 @@ export interface HostThing {
   /** A short text for a reader, for example `node card`. */
   readonly label: string;
   /**
-   * This function answers one step.
+   * This function answers one step. A field that holds `undefined` also gives `undefined`. The function `has` tells
+   * the two cases apart (DEREF.HOST-UNDEFINED).
    *
    * @param key - The key of the step.
    * @returns What the step reaches, or `undefined` when it reaches nothing.
    */
   deref(key: Key): Thing | undefined;
+  /**
+   * This optional function tells if the thing has a field for a key. The kernel asks it only when `deref` gives
+   * `undefined`. Then `true` tells that the field holds `undefined`. A thing without `has` reads `undefined` as a
+   * missing field.
+   *
+   * @param key - The key of the step.
+   * @returns `true` when the thing has the field.
+   */
+  has?(key: Key): boolean;
   /**
    * This function gives the thing as a value, when a reference ends on it.
    *
@@ -34,7 +44,7 @@ export interface HostThing {
    * path without one call for each step.
    *
    * @param keys - The keys.
-   * @returns What the keys reach, or `undefined` when they reach nothing.
+   * @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;
 }
@@ -183,7 +193,8 @@ function plainStep(thing: unknown, key: Key): { readonly found: true; readonly v
 export function derefStep(nav: Navigator, thing: Thing, key: Key): { readonly thing: Thing; readonly by: HopBy } | undefined {
   if (isHostThing(thing)) {
     const reached = thing.deref(key);
-    return reached === undefined ? undefined : { thing: reached, by: "own" };
+    // DEREF.HOST-UNDEFINED: `has` tells a field that holds undefined from a missing field.
+    return reached !== undefined || thing.has?.(key) === true ? { thing: reached, by: "own" } : undefined;
   }
   if (nav.plain !== true && isEnvelope(thing)) {
     const envelope = thing as JsonRecord & Envelope;

package/src/doc.ts

@@ -230,20 +230,41 @@ export function fromJson(value: unknown): Envelope | undefined {
  * with this function does not keep a stale host value.
  *
  * The function does not use the stack for the depth, thus a deep document cannot overflow it. A cycle of lists or
- * records does not make it loop. `sameValue` of `agree` uses the same rules, and it adds rules for closures and for
- * a rule of the caller.
+ * records does not make it loop. `sameValue` of `agree` and `sameResult` use the same walk, and each adds its rules
+ * for other values (D20).
  *
  * @param a - The first value.
  * @param b - The second value.
  * @returns `true` when the values are equal.
  */
 export function docEquals(a: unknown, b: unknown): boolean {
+  return equalWith(a, b, undefined);
+}
+
+/** A rule for two values that are not the same by `Object.is`: `true`, `false`, or `undefined` for the next rule. */
+export type SameRule = (a: unknown, b: unknown) => boolean | undefined;
+
+/**
+ * This function is the one walk of `docEquals`, `sameValue` and `sameResult` (D20). It compares two values by the
+ * rules of `docEquals`. A rule of the caller answers first for each pair that is not the same by `Object.is`.
+ *
+ * @param a - The first value.
+ * @param b - The second value.
+ * @param rule - The rule of the caller. Its `undefined` gives the rules of `docEquals`.
+ * @returns `true` when the values are equal.
+ */
+export function equalWith(a: unknown, b: unknown, rule: SameRule | undefined): boolean {
   const stack: [unknown, unknown][] = [[a, b]];
   // The pairs of containers that the comparison already visits. It is made at the first pair of containers.
   let seen: Map<object, Set<object>> | undefined;
   while (stack.length > 0) {
     const [x, y] = stack.pop() as [unknown, unknown];
     if (Object.is(x, y)) continue;
+    const told = rule?.(x, y);
+    if (told !== undefined) {
+      if (told) continue;
+      return false;
+    }
     const list = Array.isArray(x);
     if (list !== Array.isArray(y)) return false;
     // An object that is not a list and not a plain record is a host value: Object.is above compared it.

package/src/errors.ts

@@ -16,7 +16,8 @@ export type KernelCode =
   | "#CAP!"
   | "#CALC!"
   | "#DEPTH!"
-  | "#ABORT";
+  | "#ABORT"
+  | "#REPLAY!";
 
 /** The code of an error value. A language can add its own codes. Each code starts with `#`. */
 export type ErrorCode = KernelCode | `#${string}`;

package/src/evaluate.ts

@@ -2,7 +2,7 @@ import { type Envelope, type Json, type Key, type TypeRef, isEnvelope, typeName
 import { type Split, partsOf, pathMatches } from "./parts.ts";
 import { ask, type Answer } from "./ladder.ts";
 import type { CapsRule, Kind, Side, World } from "./world.ts";
-import { type ErrorCode, type EvalError, type Result, fail, ok, placed, thrown, describe } from "./errors.ts";
+import { type ErrorCode, type EvalError, type Result, Failure, fail, ok, placed, thrown, describe } from "./errors.ts";
 import {
   type Cap,
   type Context,
@@ -135,6 +135,7 @@ export type Steps = Generator<Promise<unknown>, Result, unknown>;
 
 /** An effect that an evaluation caused, in the order of the effects. */
 export interface Effect {
+  /** The number of effects before this effect. Under `all`, this number follows the order of the host. */
   readonly index: number;
   /** The kind of the effect, as a text with dots. */
   readonly kind: string;
@@ -149,11 +150,100 @@ export interface Effect {
   readonly place: readonly Key[];
   /** The context of the document that caused the effect: its names, its node and its capabilities. */
   readonly context: Context;
+  /**
+   * The stable address of the effect (RUN.ADDRESS). The order of the host does not change it. The address has the
+   * keys of the place, a `#` and the count of the earlier effects at that place in its scope. An example is
+   * `1/bind/x#0`. Each item of `all` is a scope, and its prefix comes first: `all0.1/` is the item 1 of the first `all`
+   * of the scope. The kernel gives each effect its address.
+   */
+  readonly address?: string;
+  /**
+   * The outcome of the effect: the result that it gave its document (RUN.OUTCOME). The kernel sets it when the answer
+   * comes. It stays `undefined` when the run stops first, for example at an abort.
+   */
+  readonly outcome?: Result;
 }
 
-/** The host side of a run: it does one effect, and gives its result. A throw or a rejection is an error value. */
+/**
+ * The host side of a run: it does one effect, and gives its result. A throw or a rejection is an error value, and a
+ * `Failure` gives its own error value. In an evaluation, this function is a mock: it answers at once, and a promise
+ * from it gives `#CALC!` (RUN.MOCK).
+ */
 export type Perform = (effect: Effect) => unknown;
 
+/** The key of the journal of a recorder or of a replayer, on its function. Two copies of the kernel share it. */
+export const JOURNAL: unique symbol = /* @__PURE__ */ Symbol.for("coeval.journal") as never;
+
+/**
+ * The journal of a recorder or of a replayer, on its function `perform`. The kernel tells it the order in which the
+ * waits of each `all` settle. In a replay, the kernel asks the journal for that order (RUN.RECORD, RUN.REPLAY).
+ */
+export interface Journal {
+  /**
+   * This function gets the item whose wait settled.
+   *
+   * @param all - The address of the `all`, for example `all0` or `all0.1/all0`.
+   * @param item - The index of the item.
+   */
+  readonly settled?: (all: string, item: number) => void;
+  /**
+   * This function gives the item whose wait settles next.
+   *
+   * @param all - The address of the `all`.
+   * @param waiting - The indices of the items that wait.
+   * @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;
+}
+
+/** This function gives the journal of a function `perform`, when it has one. */
+function journalOf(perform: Perform | undefined): Journal | undefined {
+  return perform === undefined ? undefined : (perform as { readonly [JOURNAL]?: Journal })[JOURNAL];
+}
+
+/**
+ * This function gives the outcome of an effect that the host failed. A `Failure` gives its own error value, for
+ * example the recorded error of a replay or `#REPLAY!`. Each other exception gives `#CALC!`, with the exception as the
+ * cause (RUN.CAUSE).
+ */
+function hostFailed(kind: string, place: readonly Key[], error: unknown): Result {
+  if (error instanceof Failure) return placed({ ok: false, error: error.error }, place);
+  return fail("#CALC!", `The host failed the effect ${kind}: ${describe(error)}`, { place, cause: error });
+}
+
+/**
+ * The scope of the addresses of effects (RUN.ADDRESS). The root of an evaluation is one scope, and each item of `all`
+ * is a scope. The code of one scope does not interleave with itself, thus its counts do not depend on the host.
+ */
+interface Scope {
+  /** The text before each address of the scope, for example `all0.1/`. */
+  readonly prefix: string;
+  /** The number of earlier effects at each place, by the text of the place. It is made at the first effect. */
+  counts: Map<string, number> | undefined;
+  /** The number of earlier uses of `all` in the scope. */
+  alls: number;
+}
+
+/**
+ * This function gives the text of a place in an address: each key, with a slash between two keys. A text key with
+ * other characters than letters, digits, `_`, `$` and `-` gets quotes.
+ *
+ * @param place - The keys from the root document to a document.
+ * @returns The text of the place.
+ */
+export function placeText(place: readonly Key[]): string {
+  let text = "";
+  for (let index = 0; index < place.length; index += 1) {
+    const key = place[index] as Key;
+    if (index > 0) text += "/";
+    text += typeof key === "number" || /^[\w$-]+$/.test(key) ? String(key) : JSON.stringify(key);
+  }
+  return text;
+}
+
+/** An effect while the kernel waits for its outcome. */
+type Recorded = { -readonly [K in keyof Effect]: Effect[K] };
+
 /**
  * The runtime of one evaluation or run. Compiled code gets it with the context, and asks it to resolve paths and
  * to cause effects.
@@ -179,7 +269,7 @@ export interface Runtime {
    * @param kind - The kind of the effect.
    * @param payload - The data of the effect.
    * @param place - The place of the document.
-   * @returns The payload, or an error value.
+   * @returns The answer of the mock, the payload without a mock, or an error value.
    */
   effect(ctx: Context, kind: Cap, payload: unknown, place: readonly Key[]): Result;
   /**
@@ -316,7 +406,7 @@ export interface EvalInput {
    *
    * @param kind - The kind of the effect, for example `log`.
    * @param payload - The data of the effect.
-   * @returns The payload, or the error `#CAP!`.
+   * @returns The answer of the mock, the payload without a mock, or an error value, for example `#CAP!`.
    */
   effect(kind: Cap, payload: unknown): Result;
   /**
@@ -360,7 +450,7 @@ export interface RunInput {
   resolve(path: readonly unknown[], options?: ResolveOptions): Resolution;
   /**
    * This function causes an effect. In a run, the host does the effect, and the steps wait when the host waits. In
-   * an evaluation, the effect gives its payload. Take its result with `yield*`.
+   * an evaluation, a mock answers the effect at once, or the effect gives its payload. Take its result with `yield*`.
    *
    * @param kind - The kind of the effect, for example `log`.
    * @param payload - The data of the effect.
@@ -547,6 +637,19 @@ export interface RunOptions {
 export interface EvalOptions {
   /** A list that gets each effect, in its order. */
   readonly effects?: Effect[];
+  /**
+   * The mock of the host (RUN.MOCK). It answers each effect at once, and its answer is the result of the effect.
+   * Without it, an effect gives its payload (RUN.EVAL).
+   */
+  readonly perform?: Perform;
+}
+
+/** The options of `evaluate`. */
+export interface EvaluateOptions {
+  /** The type of a bare root value. */
+  readonly declaredType?: string;
+  /** The mock of the host (RUN.MOCK). Without it, an effect gives its payload (RUN.EVAL). */
+  readonly perform?: Perform;
 }
 
 /** The options of a resolution without a record of hops, and with one. One object of each serves each call. */
@@ -561,6 +664,11 @@ class Session implements Runtime {
   nextId = 0;
   current: Building | undefined;
   readonly holder: Building | undefined;
+  /**
+   * The scope of the addresses of the code that runs at this time (RUN.ADDRESS). `all` changes it for each item. The
+   * root scope is made at the first effect or `all`, thus an evaluation without effects makes no scope.
+   */
+  private scope: Scope | undefined;
 
   constructor(
     readonly machine: Machine,
@@ -589,45 +697,90 @@ class Session implements Runtime {
     return this.machine.permits === undefined ? permits(ctx.caps, keys) : this.machine.permits(ctx.caps, keys, ctx);
   }
 
-  private record(ctx: Context, kind: Cap, payload: unknown, place: readonly Key[]): Result | Effect {
+  /** This function checks the capability of an effect, and records the effect with its address (RUN.ADDRESS). */
+  private record(ctx: Context, kind: Cap, payload: unknown, place: readonly Key[]): Result | Recorded {
     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 });
     const node = this.current;
     const list = this.effects;
-    const effect: Effect = { index: list.length, kind: text, path: keys, payload, node: node?.id ?? -1, at: this.tick, place, context: ctx };
+    const scope = (this.scope ??= { prefix: "", counts: undefined, alls: 0 });
+    const at = placeText(place);
+    const counts = (scope.counts ??= new Map<string, number>());
+    const count = counts.get(at) ?? 0;
+    counts.set(at, count + 1);
+    const effect: Recorded = {
+      index: list.length,
+      kind: text,
+      path: keys,
+      payload,
+      node: node?.id ?? -1,
+      at: this.tick,
+      place,
+      context: ctx,
+      address: `${scope.prefix}${at}#${count}`,
+    };
     list.push(effect);
     if (node !== undefined) node.effects.push(effect.index);
     return effect;
   }
 
+  /**
+   * This function answers an effect at once, without a wait: the mock gives the result, or the effect gives its
+   * payload without a mock (RUN.MOCK, RUN.EVAL). A promise from the mock gives `#CALC!`.
+   */
+  private answer(effect: Recorded, place: readonly Key[]): Result {
+    const perform = this.perform;
+    if (perform === undefined) return (effect.outcome = ok(effect.payload));
+    let done: unknown;
+    try {
+      done = perform(effect);
+    } catch (error) {
+      return (effect.outcome = hostFailed(effect.kind, place, error));
+    }
+    if (!(done instanceof Promise)) return (effect.outcome = ok(done));
+    // The evaluation does not read the promise, thus its rejection must not be unhandled.
+    void done.catch(() => undefined);
+    return (effect.outcome = fail("#CALC!", `The mock gave a promise for the effect ${effect.kind}, and an evaluation does not wait.`, { place }));
+  }
+
   effect(ctx: Context, kind: Cap, payload: unknown, place: readonly Key[]): Result {
     const text = typeof kind === "string" ? kind : kind.join(".");
     if (this.running) return fail("#CALC!", `The effect ${text} needs a runner: in a run, the host does each effect.`, { place });
     const made = this.record(ctx, kind, payload, place);
-    return "ok" in made ? made : ok(payload);
+    return "ok" in made ? made : this.answer(made, place);
   }
 
   *runEffect(ctx: Context, kind: Cap, payload: unknown, place: readonly Key[]): Steps {
     const made = this.record(ctx, kind, payload, place);
     if ("ok" in made) return made;
     const perform = this.perform;
-    if (!this.running || perform === undefined) return ok(payload);
-    const failed = (error: unknown): Result => fail("#CALC!", `The host failed the effect ${made.kind}: ${describe(error)}`, { place, cause: error });
+    if (!this.running || perform === undefined) return this.answer(made, place);
     let done: unknown;
     try {
       done = perform(made);
     } catch (error) {
-      return failed(error);
+      return (made.outcome = hostFailed(made.kind, place, error));
     }
-    if (!(done instanceof Promise)) return ok(done);
-    return (yield done.then((value: unknown) => ok(value), failed)) as Result;
+    if (!(done instanceof Promise)) return (made.outcome = ok(done));
+    const result = (yield done.then(
+      (value: unknown) => ok(value),
+      (error: unknown) => hostFailed(made.kind, place, error),
+    )) as Result;
+    // A run that stops at this wait does not reach this line, thus the effect keeps no outcome (RUN.OUTCOME).
+    return (made.outcome = result);
   }
 
   *all(list: readonly (() => Steps)[], options: AllOptions = {}): Generator<Promise<unknown>, readonly Result[], unknown> {
     const results: Result[] = new Array<Result>(list.length);
     const limit = Math.max(1, options.concurrency ?? list.length);
     const failFast = options.failFast === true;
+    // The address of this call, and a scope for each item (RUN.ADDRESS). The journal of a replay reads the address.
+    const outer = (this.scope ??= { prefix: "", counts: undefined, alls: 0 });
+    const address = `${outer.prefix}all${outer.alls}`;
+    outer.alls += 1;
+    const scopes: Scope[] = new Array<Scope>(list.length);
+    const journal = journalOf(this.perform);
     let failed = false;
     interface Active {
       readonly index: number;
@@ -642,11 +795,15 @@ class Session implements Runtime {
     };
     const advance = (index: number, steps: Steps, input: { readonly value?: unknown; readonly error?: unknown; readonly threw: boolean }): void => {
       let step: IteratorResult<Promise<unknown>, Result>;
+      const before = this.scope;
+      this.scope = scopes[index] as Scope;
       try {
         step = input.threw ? steps.throw(input.error) : steps.next(input.value);
       } catch (error) {
         settle(index, thrown(error, "a part"));
         return;
+      } finally {
+        this.scope = before;
       }
       if (step.done === true) {
         settle(index, step.value);
@@ -663,25 +820,35 @@ class Session implements Runtime {
       while (!failed && active.length < limit && next < list.length) {
         const index = next;
         next += 1;
+        const scope: Scope = { prefix: `${address}.${index}/`, counts: undefined, alls: 0 };
+        scopes[index] = scope;
         const begin = list[index] as () => Steps;
         let steps: Steps;
+        const before = this.scope;
+        this.scope = scope;
         try {
           steps = begin();
         } catch (error) {
           settle(index, thrown(error, "a part"));
           continue;
+        } finally {
+          this.scope = before;
         }
         advance(index, steps, { threw: false });
       }
     };
     start();
     while (active.length > 0 && !failed) {
-      const settled = (yield Promise.race(active.map((item) => item.pending))) as {
+      // 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 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;
         readonly value?: unknown;
         readonly error?: unknown;
         readonly threw: boolean;
       };
+      journal?.settled?.(address, settled.item.index);
       active.splice(active.indexOf(settled.item), 1);
       advance(settled.item.index, settled.item.steps, settled);
       start();
@@ -819,10 +986,11 @@ export interface Plan {
   /** The compiled root document. */
   readonly root: CompiledPart;
   /**
-   * This function evaluates the document. It does not wait, and the host does no effect.
+   * This function evaluates the document. It does not wait, and the host does no effect. A mock can answer each
+   * effect at once (RUN.MOCK).
    *
    * @param context - The names and the capabilities at the root.
-   * @param options - A list that gets the effects.
+   * @param options - A list that gets the effects, and the mock of the host.
    * @returns The result.
    */
   evaluate(context?: Context, options?: EvalOptions): Result;
@@ -1161,7 +1329,7 @@ function planOf(machine: Machine, traced: boolean, root: CompiledPart): Plan {
     traced,
     root,
     evaluate(context: Context = makeContext(), evalOptions?: EvalOptions): Result {
-      const s = new Session(machine, false, traced, undefined, undefined, evalOptions?.effects);
+      const s = new Session(machine, false, traced, evalOptions?.perform, undefined, evalOptions?.effects);
       return root.code(rootContext(machine, context), s);
     },
     run(context: Context = makeContext(), runOptions: RunOptions = {}): Promise<Result> {
@@ -1212,17 +1380,20 @@ function record(s: Session, result: Result): Run {
  *
  * The verb `eval` goes up the ladder for each document. The kind of the document tells where its parts are. The
  * evaluator gets each part sealed: it can evaluate the part, and it cannot read its value. A failure gives an error
- * value, and the function does not throw. An effect is recorded in its order, and nothing does it.
+ * value, and the function does not throw. An effect is recorded in its order, and the host does not do it. A mock
+ * can answer each effect at once (RUN.MOCK).
  *
  * @param machine - The world and the code of the evaluators.
  * @param doc - The document, as JSON.
  * @param context - The names and the capabilities at the root.
- * @param declaredType - The type of a bare root value.
+ * @param options - The type of a bare root value, or the options: that type and the mock of the host.
  * @returns The result, the trace and the effects in their order.
  */
-export function evaluate(machine: Machine, doc: unknown, context: Context = makeContext(), declaredType?: string): Run {
+export function evaluate(machine: Machine, doc: unknown, context: Context = makeContext(), options?: string | EvaluateOptions): Run {
+  const given: EvaluateOptions = typeof options === "string" ? { declaredType: options } : (options ?? {});
+  const declaredType = given.declaredType;
   const plan = prepare(machine, doc, { trace: true, ...(declaredType === undefined ? {} : { declaredType }) });
-  const s = new Session(machine, false, true, undefined, undefined, undefined);
+  const s = new Session(machine, false, true, given.perform, undefined, undefined);
   const result = plan.root.code(rootContext(machine, context), s);
   return record(s, result);
 }