@mark1russell7/coeval 0.6.2 → 0.6.3

package/build/index.js

@@ -184,19 +184,36 @@ function fromJson(value) {
 * 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.
 */
 function docEquals(a, b) {
+	return equalWith(a, b, void 0);
+}
+/**
+* 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.
+*/
+function equalWith(a, b, rule) {
 	const stack = [[a, b]];
 	let seen;
 	while (stack.length > 0) {
 		const [x, y] = stack.pop();
 		if (Object.is(x, y)) continue;
+		const told = rule?.(x, y);
+		if (told !== void 0) {
+			if (told) continue;
+			return false;
+		}
 		const list = Array.isArray(x);
 		if (list !== Array.isArray(y)) return false;
 		if (!list && (!isRecord(x) || !isRecord(y))) return false;
@@ -1143,10 +1160,10 @@ function plainStep(thing, key) {
 function derefStep(nav, thing, key) {
 	if (isHostThing(thing)) {
 		const reached = thing.deref(key);
-		return reached === void 0 ? void 0 : {
+		return reached !== void 0 || thing.has?.(key) === true ? {
 			thing: reached,
 			by: "own"
-		};
+		} : void 0;
 	}
 	if (nav.plain !== true && isEnvelope(thing)) {
 		const envelope = thing;
@@ -1843,6 +1860,43 @@ function capsUnder(rules, caps) {
 function partCaps(rules, path, caps) {
 	return capsUnder(rulesFor(rules, path), caps);
 }
+/** The key of the journal of a recorder or of a replayer, on its function. Two copies of the kernel share it. */
+const JOURNAL = /* @__PURE__ */ Symbol.for("coeval.journal");
+/** This function gives the journal of a function `perform`, when it has one. */
+function journalOf(perform) {
+	return perform === void 0 ? void 0 : perform[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, place, error) {
+	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
+	});
+}
+/**
+* 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.
+*/
+function placeText(place) {
+	let text = "";
+	for (let index = 0; index < place.length; index += 1) {
+		const key = place[index];
+		if (index > 0) text += "/";
+		text += typeof key === "number" || /^[\w$-]+$/.test(key) ? String(key) : JSON.stringify(key);
+	}
+	return text;
+}
 function selfLabel(self) {
 	try {
 		if (isHostThing(self)) return self.label;
@@ -1873,6 +1927,11 @@ var Session = class {
 	nextId = 0;
 	current;
 	holder;
+	/**
+	* 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.
+	*/
+	scope;
 	constructor(machine, running, traced, perform, signal, effects) {
 		this.machine = machine;
 		this.running = running;
@@ -1894,12 +1953,22 @@ var Session = class {
 	permitted(ctx, keys) {
 		return this.machine.permits === void 0 ? permits(ctx.caps, keys) : this.machine.permits(ctx.caps, keys, ctx);
 	}
+	/** This function checks the capability of an effect, and records the effect with its address (RUN.ADDRESS). */
 	record(ctx, kind, payload, place) {
 		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 scope = this.scope ??= {
+			prefix: "",
+			counts: void 0,
+			alls: 0
+		};
+		const at = placeText(place);
+		const counts = scope.counts ??= /* @__PURE__ */ new Map();
+		const count = counts.get(at) ?? 0;
+		counts.set(at, count + 1);
 		const effect = {
 			index: list.length,
 			kind: text,
@@ -1908,40 +1977,63 @@ var Session = class {
 			node: node?.id ?? -1,
 			at: this.tick,
 			place,
-			context: ctx
+			context: ctx,
+			address: `${scope.prefix}${at}#${count}`
 		};
 		list.push(effect);
 		if (node !== void 0) 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!`.
+	*/
+	answer(effect, place) {
+		const perform = this.perform;
+		if (perform === void 0) return effect.outcome = ok(effect.payload);
+		let done;
+		try {
+			done = perform(effect);
+		} catch (error) {
+			return effect.outcome = hostFailed(effect.kind, place, error);
+		}
+		if (!(done instanceof Promise)) return effect.outcome = ok(done);
+		done.catch(() => void 0);
+		return effect.outcome = fail("#CALC!", `The mock gave a promise for the effect ${effect.kind}, and an evaluation does not wait.`, { place });
+	}
 	effect(ctx, kind, payload, place) {
 		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, kind, payload, place) {
 		const made = this.record(ctx, kind, payload, place);
 		if ("ok" in made) return made;
 		const perform = this.perform;
-		if (!this.running || perform === void 0) return ok(payload);
-		const failed = (error) => fail("#CALC!", `The host failed the effect ${made.kind}: ${describe(error)}`, {
-			place,
-			cause: error
-		});
+		if (!this.running || perform === void 0) return this.answer(made, place);
 		let done;
 		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) => ok(value), failed);
+		if (!(done instanceof Promise)) return made.outcome = ok(done);
+		return made.outcome = yield done.then((value) => ok(value), (error) => hostFailed(made.kind, place, error));
 	}
 	*all(list, options = {}) {
 		const results = new Array(list.length);
 		const limit = Math.max(1, options.concurrency ?? list.length);
 		const failFast = options.failFast === true;
+		const outer = this.scope ??= {
+			prefix: "",
+			counts: void 0,
+			alls: 0
+		};
+		const address = `${outer.prefix}all${outer.alls}`;
+		outer.alls += 1;
+		const scopes = new Array(list.length);
+		const journal = journalOf(this.perform);
 		let failed = false;
 		const active = [];
 		let next = 0;
@@ -1951,11 +2043,15 @@ var Session = class {
 		};
 		const advance = (index, steps, input) => {
 			let step;
+			const before = this.scope;
+			this.scope = scopes[index];
 			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);
@@ -1981,20 +2077,33 @@ var Session = class {
 			while (!failed && active.length < limit && next < list.length) {
 				const index = next;
 				next += 1;
+				const scope = {
+					prefix: `${address}.${index}/`,
+					counts: void 0,
+					alls: 0
+				};
+				scopes[index] = scope;
 				const begin = list[index];
 				let 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));
+			const chosen = journal?.next?.(address, active.map((item) => item.index));
+			const pick = chosen === void 0 ? void 0 : active.find((item) => item.index === chosen);
+			const settled = yield pick === void 0 ? Promise.race(active.map((item) => item.pending)) : pick.pending;
+			journal?.settled?.(address, settled.item.index);
 			active.splice(active.indexOf(settled.item), 1);
 			advance(settled.item.index, settled.item.steps, settled);
 			start();
@@ -2449,7 +2558,7 @@ function planOf(machine, traced, root) {
 		traced,
 		root,
 		evaluate(context = makeContext(), evalOptions) {
-			const s = new Session(machine, false, traced, void 0, void 0, evalOptions?.effects);
+			const s = new Session(machine, false, traced, evalOptions?.perform, void 0, evalOptions?.effects);
 			return root.code(rootContext(machine, context), s);
 		},
 		run(context = makeContext(), runOptions = {}) {
@@ -2487,7 +2596,7 @@ function planner(machine, options = {}) {
 		return plan;
 	};
 }
-function record$1(s, result) {
+function record(s, result) {
 	const root = s.holder?.children[0];
 	if (root === void 0) throw new Error("The evaluation made no trace.");
 	return {
@@ -2502,21 +2611,24 @@ function record$1(s, result) {
 *
 * 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.
 */
-function evaluate(machine, doc, context = makeContext(), declaredType) {
+function evaluate(machine, doc, context = makeContext(), options) {
+	const given = typeof options === "string" ? { declaredType: options } : options ?? {};
+	const declaredType = given.declaredType;
 	const plan = prepare(machine, doc, {
 		trace: true,
 		...declaredType === void 0 ? {} : { declaredType }
 	});
-	const s = new Session(machine, false, true, void 0, void 0, void 0);
-	return record$1(s, plan.root.code(rootContext(machine, context), s));
+	const s = new Session(machine, false, true, given.perform, void 0, void 0);
+	return record(s, plan.root.code(rootContext(machine, context), s));
 }
 /**
 * This function runs a document: an evaluation in which the host does each effect. A runner waits for its
@@ -2535,7 +2647,7 @@ async function run(machine, doc, context = makeContext(), options = {}) {
 		...options.declaredType === void 0 ? {} : { declaredType: options.declaredType }
 	});
 	const s = new Session(machine, true, true, options.perform, options.signal, void 0);
-	return record$1(s, await driveWaiting(plan.root.run(rootContext(machine, context), s), options.signal));
+	return record(s, await driveWaiting(plan.root.run(rootContext(machine, context), s), options.signal));
 }
 /**
 * This function finds a node of a trace by its path.
@@ -2971,6 +3083,9 @@ function treeThing(parts, context, type, place, build) {
 			if (!result.ok) throw new Failure(result.error);
 			return result.value;
 		},
+		has(key) {
+			return key === "parent" || key === "type" || parts.some((part) => part.key === String(key));
+		},
 		toJson() {
 			const result = state.json(/* @__PURE__ */ new Set());
 			if (!result.ok) throw new Failure(result.error);
@@ -4581,13 +4696,20 @@ function resolveFully(machine, ctx, path, options) {
 		hops: []
 	};
 }
-/** This function records an effect when the capabilities permit it (RUN.CAP, CAP.HOOK). */
-function record(env, ctx, kind, payload, place) {
+/**
+* This function causes an effect when the capabilities permit it (RUN.CAP, CAP.HOOK). It records the effect with its
+* address (RUN.ADDRESS) and its outcome (RUN.OUTCOME). The mock answers the effect at once (RUN.MOCK). Without a
+* mock, the effect gives its payload (RUN.EVAL).
+*/
+function cause(env, ctx, kind, payload, place) {
 	const keys = typeof kind === "string" ? kind.split(".") : kind;
 	const text = keys.join(".");
 	const machine = env.machine;
 	if (!(machine.permits === void 0 ? permits(ctx.caps, keys) : machine.permits(ctx.caps, keys, ctx))) return fail("#CAP!", `The context has no capability for the effect ${text}.`, { place });
-	env.effects.push({
+	const at = placeText(place);
+	const count = env.scope.counts.get(at) ?? 0;
+	env.scope.counts.set(at, count + 1);
+	const effect = {
 		index: env.effects.length,
 		kind: text,
 		path: keys,
@@ -4595,8 +4717,35 @@ function record(env, ctx, kind, payload, place) {
 		node: -1,
 		at: 0,
 		place,
-		context: ctx
-	});
+		context: ctx,
+		address: `${env.scope.prefix}${at}#${count}`
+	};
+	env.effects.push(effect);
+	effect.outcome = answer(env.perform, effect, place);
+	return effect.outcome;
+}
+/**
+* This function gives the answer of the mock to an effect. A throw gives `#CALC!` with the cause, and a `Failure`
+* gives its own error value. A promise gives `#CALC!`, because an evaluation does not wait.
+*/
+function answer(perform, effect, place) {
+	if (perform === void 0) return ok(effect.payload);
+	let given;
+	try {
+		given = perform(effect);
+	} catch (error) {
+		if (error instanceof Failure) return placed({
+			ok: false,
+			error: error.error
+		}, place);
+		return fail("#CALC!", `The host failed the effect ${effect.kind}: ${describe(error)}`, {
+			place,
+			cause: error
+		});
+	}
+	if (!(given instanceof Promise)) return ok(given);
+	given.catch(() => void 0);
+	return fail("#CALC!", `The mock gave a promise for the effect ${effect.kind}, and an evaluation does not wait.`, { place });
 }
 /** This function evaluates a document. Each error gets the place of the document where it started (K5). */
 function evaluateAt(env, at) {
@@ -4662,7 +4811,7 @@ function evalInput(env, seen, at) {
 		place: at.place,
 		...at.address ? { address: true } : {},
 		resolve: (path, options) => resolveFully(env.machine, at.ctx, path, options),
-		effect: (kind, payload) => record(env, at.ctx, kind, payload, at.place) ?? ok(payload),
+		effect: (kind, payload) => cause(env, at.ctx, kind, payload, at.place),
 		fill
 	};
 }
@@ -4689,9 +4838,9 @@ function runInput(env, seen, at) {
 		place: at.place,
 		resolve: (path, options) => resolveFully(env.machine, at.ctx, path, options),
 		effect: function* (kind, payload) {
-			return record(env, at.ctx, kind, payload, at.place) ?? ok(payload);
+			return cause(env, at.ctx, kind, payload, at.place);
 		},
-		all: (list, options) => together(list, options),
+		all: (list, options) => together(env, list, options),
 		fill
 	};
 }
@@ -4700,14 +4849,25 @@ function runInput(env, seen, at) {
 * goes on until it ends or waits. In an evaluation, a part that waits does not end, thus it keeps its place in the
 * limit. With `failFast`, the first failure stops the parts that wait, and the later parts do not start
 * (RUN.FAIL-FAST). When no part failed and a part waits, the steps wait, and the drive gives `#CALC!`.
+*
+* Each part has its own scope of addresses. Its prefix names the use of `all` in the scope around it, and the part
+* (RUN.ADDRESS).
 */
-function* together(list, options = {}) {
+function* together(env, list, options = {}) {
 	const limit = Math.max(1, options.concurrency ?? list.length);
 	const results = list.map(() => void 0);
 	const waiting = [];
+	const outer = env.scope;
+	const address = `${outer.prefix}all${outer.alls}`;
+	outer.alls += 1;
 	let failed = false;
 	for (let index = 0; index < list.length && !failed && waiting.length < limit; index += 1) {
 		let result;
+		env.scope = {
+			prefix: `${address}.${index}/`,
+			counts: /* @__PURE__ */ new Map(),
+			alls: 0
+		};
 		try {
 			const steps = list[index].evaluate();
 			const step = steps.next();
@@ -4718,6 +4878,8 @@ function* together(list, options = {}) {
 			});
 		} catch (error) {
 			result = thrown(error, "a part");
+		} finally {
+			env.scope = outer;
 		}
 		results[index] = result;
 		if (result !== void 0 && options.failFast === true && !result.ok) failed = true;
@@ -4735,12 +4897,12 @@ function* together(list, options = {}) {
 /**
 * This function evaluates a document by the rules, without a compilation. It is the reference of the plans: a plan,
 * a traced plan and the second tier of a language must give its results. It covers evaluations, not runs: an effect
-* gives its payload, and a part that waits gives `#CALC!`.
+* gives the answer of the mock or its payload, and a part that waits gives `#CALC!`.
 *
 * @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 type of a bare root value, the definitions of compiled code, and a list for the effects.
+* @param options - The type of a bare root value, the definitions of compiled code, a list for the effects and a mock.
 * @returns The result.
 */
 function reference(machine, doc, context = makeContext(), options = {}) {
@@ -4748,7 +4910,13 @@ function reference(machine, doc, context = makeContext(), options = {}) {
 		machine,
 		definitions: options.definitions ?? {},
 		effects: options.effects ?? [],
-		maxDepth: machine.maxDepth ?? 1e3
+		maxDepth: machine.maxDepth ?? 1e3,
+		perform: options.perform,
+		scope: {
+			prefix: "",
+			counts: /* @__PURE__ */ new Map(),
+			alls: 0
+		}
 	};
 	const ctx = context.world === null ? {
 		...context,
@@ -4868,6 +5036,7 @@ const treeDefinition = ({ parts, context, kind, place }) => {
 			if (result === void 0 || result.ok) return result?.ok === true ? result.value : void 0;
 			throw new Failure(result.error);
 		},
+		has: (key) => key === "parent" || key === "type" || parts.some((part) => part.key === String(key)),
 		toJson: () => {
 			const result = jsonOfNode(node, self, []);
 			if (result.ok) return result.value;
@@ -5114,8 +5283,9 @@ function valuesOfStrict(parts) {
 * 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.
@@ -5123,46 +5293,12 @@ function valuesOfStrict(parts) {
 * @returns `true` when the values are the same.
 */
 function sameValue(a, b, equal) {
-	const stack = [[a, b]];
-	const seen = /* @__PURE__ */ new Map();
-	while (stack.length > 0) {
-		const [x, y] = stack.pop();
-		if (Object.is(x, y)) continue;
-		const told = equal?.(x, y);
-		if (told !== void 0) {
-			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;
-		const pairs = seen.get(x) ?? /* @__PURE__ */ new Set();
-		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) !== void 0) 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 === void 0 ? 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, y) {
+	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) === void 0;
 }
 const CLOSURE = /* @__PURE__ */ Symbol.for("coeval.closure");
 function closureParams(fn) {
@@ -5188,34 +5324,44 @@ function resultDiffers(a, b, options) {
 	if (!a.ok && !b.ok) return errorDiffers(a.error, b.error, options.strict === true);
 	return a.ok ? `The plan gives a value, and the tier gives ${codeAndPlace(b.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, b, options) {
 	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) {
 		const x = a[index];
 		const y = b[index];
 		if (x.kind !== y.kind || !docEquals(x.place, y.place) || !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 !== void 0 && y.address !== void 0 && 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 !== void 0 && y.outcome !== void 0 ? resultDiffers(x.outcome, y.outcome, options) : void 0;
+		if (why !== void 0) return `The outcome of the effect ${index} differs. ${why}`;
 	}
 }
 /**
 * 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.
 */
 function agree(machine, doc, context = makeContext(), options = {}) {
 	const declared = options.declaredType === void 0 ? {} : { declaredType: options.declaredType };
+	const mock = options.perform === void 0 ? {} : { perform: options.perform };
 	const observe = options.observe;
 	observe?.();
 	const plan = prepare(machine, doc, declared);
 	const effects = [];
-	const result = plan.evaluate(context, { effects });
+	const result = plan.evaluate(context, {
+		effects,
+		...mock
+	});
 	const saw = observe?.();
 	const differs = (other, otherEffects) => {
 		if (overflowed(result) || overflowed(other)) return void 0;
@@ -5232,14 +5378,21 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 		let otherEffects = [];
 		if (tier === "reference") other = reference(machine, doc, context, {
 			...declared,
+			...mock,
 			effects: otherEffects,
 			...options.definitions === void 0 ? {} : { 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 });
+		} else other = plan.evaluate(context, {
+			effects: otherEffects,
+			...mock
+		});
 		const why = differs(other, otherEffects);
 		if (why !== void 0) return {
 			ok: false,
@@ -5252,7 +5405,7 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 	if (options.other !== void 0) {
 		let given;
 		try {
-			given = options.other(doc, context);
+			given = options.other(doc, context, mock);
 		} catch (error) {
 			given = thrown(error, "the tier");
 		}
@@ -5273,6 +5426,138 @@ function agree(machine, doc, context = makeContext(), options = {}) {
 	};
 }
 //#endregion
+//#region src/same.ts
+/**
+* This function tells if two results are the same for an early cutoff (RESULT.SAME). A schedule uses it to stop the
+* work when a part that evaluates again gives the same result. A wrong `true` keeps a stale value, but a wrong `false`
+* only costs work. Thus each rule gives `false` when it is not sure.
+*
+* - Two values compare by the rules of `docEquals`. Lists and plain records compare by their items and fields. Each
+*   other value compares with `Object.is`.
+* - Thus `-0` is not `0`, and `NaN` is `NaN`. A date, a map and a closure of `fn` are the same only as themselves.
+* - Two errors are the same when they have the same code, reason and place (RESULT.SAME-ERROR). The cause is not
+*   compared. A `Held` value compares its error by the same rule.
+* - A value and an error are not the same.
+*
+* `sameValue` of `agree` uses the same walk, with rules for two tiers (D20). It compares two closures by their
+* parameters, and two errors by their code and place.
+*
+* @param a - The earlier result.
+* @param b - The new result.
+* @param equal - The rule of the host for two values, for example two dates. It answers first, and `undefined` gives the rules above.
+* @returns `true` when the results are the same.
+*/
+function sameResult(a, b, equal) {
+	if (a.ok && b.ok) return equalWith(a.value, b.value, equal === void 0 ? sameHeld : (x, y) => equal(x, y) ?? sameHeld(x, y));
+	if (!a.ok && !b.ok) return sameError(a.error, b.error);
+	return false;
+}
+/** The rule of `sameResult` for held errors. Two `Held` values are the same when their errors are the same. */
+function sameHeld(x, y) {
+	if (x instanceof Held || y instanceof Held) return x instanceof Held && y instanceof Held && sameError(x.error, y.error);
+}
+/** Two errors are the same when they have the same code, reason and place. An error without a place has no place in both. */
+function sameError(a, b) {
+	if (a.code !== b.code || a.reason !== b.reason) return false;
+	if (a.place === void 0 || b.place === void 0) return a.place === b.place;
+	return docEquals(a.place, b.place);
+}
+//#endregion
+//#region src/replay.ts
+/**
+* This function makes a recorder (RUN.RECORD). The recorder gives each effect to the function `perform` of the host.
+* Its log keeps each effect with its address, its kind, its payload and the outcome that the kernel gives it. The log
+* also keeps the order in which the waits of each `all` settle.
+*
+* @param perform - The function of the host. Without it, each effect gives its payload, as in a run without a host.
+* @returns The function `perform` for the run, and the log.
+*/
+function recorder(perform) {
+	const seen = [];
+	const settles = [];
+	const journal = { settled: (all, item) => {
+		settles.push({
+			all,
+			item
+		});
+	} };
+	const host = (effect) => {
+		const entry = {
+			effect,
+			waited: false
+		};
+		seen.push(entry);
+		const answer = perform === void 0 ? effect.payload : perform(effect);
+		if (answer instanceof Promise) entry.waited = true;
+		return answer;
+	};
+	return {
+		perform: Object.assign(host, { [JOURNAL]: journal }),
+		log: () => ({
+			effects: seen.map(({ effect, waited }) => ({
+				address: effect.address ?? "",
+				kind: effect.kind,
+				payload: effect.payload,
+				waited,
+				...effect.outcome === void 0 ? {} : { outcome: effect.outcome }
+			})),
+			settles: [...settles]
+		})
+	};
+}
+/**
+* This function makes a replayer: a function `perform` that answers each effect from a log, by its address (RUN.REPLAY). A
+* recorded error comes again with its code, its reason, its place and its cause. The waits of each `all` settle in the
+* recorded order. An effect that the log does not have at its address gives `#REPLAY!` (RUN.REPLAY-MISMATCH).
+*
+* A replayer keeps its place in the order of the waits, thus each run needs a new replayer.
+*
+* @param log - The log of a recorder.
+* @param options - `wait: false` for an evaluation.
+* @returns The function `perform` for the replay.
+*/
+function replayer(log, options = {}) {
+	const wait = options.wait !== false;
+	const entries = /* @__PURE__ */ new Map();
+	for (const entry of log.effects) entries.set(entry.address, entry);
+	const order = /* @__PURE__ */ new Map();
+	for (const settle of log.settles) {
+		const items = order.get(settle.all);
+		if (items === void 0) order.set(settle.all, [settle.item]);
+		else items.push(settle.item);
+	}
+	const journal = { next: (all, waiting) => {
+		const items = order.get(all);
+		const item = items?.[0];
+		if (items === void 0 || item === void 0 || !waiting.includes(item)) return void 0;
+		items.shift();
+		return item;
+	} };
+	const perform = (effect) => {
+		const entry = effect.address === void 0 ? void 0 : entries.get(effect.address);
+		const wrong = mismatch(effect, entry);
+		if (wrong !== void 0 || entry === void 0) throw wrong;
+		const outcome = entry.outcome;
+		const failure = outcome === void 0 ? replayError(effect, `The log has no outcome for the effect ${effect.kind} at ${effect.address ?? ""}: the recorded run stopped before the answer.`) : outcome.ok ? void 0 : new Failure(outcome.error);
+		const value = outcome?.ok === true ? outcome.value : void 0;
+		if (wait && entry.waited) return failure === void 0 ? Promise.resolve(value) : Promise.reject(failure);
+		if (failure !== void 0) throw failure;
+		return value;
+	};
+	return Object.assign(perform, { [JOURNAL]: journal });
+}
+/** This function gives the error of an effect that the log does not have at its address, or `undefined`. */
+function mismatch(effect, entry) {
+	const at = effect.address ?? "";
+	if (entry === void 0) return replayError(effect, `The log has no effect at the address ${at}, and the run asks for the effect ${effect.kind}.`);
+	if (entry.kind !== effect.kind) return replayError(effect, `The log has the effect ${entry.kind} at the address ${at}, and the run asks for the effect ${effect.kind}.`);
+	if (!docEquals(entry.payload, effect.payload)) return replayError(effect, `The effect ${effect.kind} at the address ${at} has another payload than the log.`);
+}
+/** This function gives the exception that carries `#REPLAY!` to the kernel, with the place of the effect. */
+function replayError(effect, reason) {
+	return new Failure(fail("#REPLAY!", reason, { place: effect.place }).error);
+}
+//#endregion
 //#region src/generate.ts
 /**
 * This function makes a source of random numbers with a seed (the algorithm mulberry32). It needs no package.
@@ -5672,6 +5957,6 @@ function generate(world, options) {
 	});
 }
 //#endregion
-export { CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_WALKERS, STD_WORLD, THING, agree, ask, capKeys, check, checkSteps, classify, context, dataEdges, derefStep, describe, docEquals, effectEdges, entriesAsJson, evaluate, fail, failures, field, flatten, formulaDefinitions, formulaEvaluators, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isTypeRef, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, mergeMachines, mergeWorlds, narrow, nearestWalker, nodeAt, ok, partCaps, partsOf, pathMatches, permits, placed, planner, prepare, random, ref, reference, refsOf, resolve, restrictMachine, restrictWorld, run, sameValue, splitParts, stored, tag, thrown, toJson, typeName, typePath, typed, typesOf, valueOfThing, walk, worldThing };
+export { CONSTRUCTS, ENVELOPE_KEYS, Failure, Held, JOURNAL, MergeError, PARTS, PART_INFO, ROOTS, RUNGS, STD_CAPS, STD_DEFINITIONS, STD_EVALUATORS, STD_EXT, STD_MACHINE, STD_RUNNERS, STD_WALKERS, STD_WORLD, THING, agree, ask, capKeys, check, checkSteps, classify, context, dataEdges, derefStep, describe, docEquals, effectEdges, entriesAsJson, evaluate, fail, failures, field, flatten, formulaDefinitions, formulaEvaluators, formulaKinds, formulaKnown, formulaMachine, fromJson, generate, intersectCaps, isAlias, isAllowedOrder, isClosure, isEnvelope, isHostThing, isKey, isKind, isNamespace, isRecord, isRef, isStackOverflow, isTypeRef, jsTruthy, kindDocument, kindNamed, kindOf, layers, looksLikeKind, lookupKind, makeContext, mapRefs, mergeMachines, mergeWorlds, narrow, nearestWalker, nodeAt, ok, partCaps, partsOf, pathMatches, permits, placed, planner, prepare, random, recorder, ref, reference, refsOf, replayer, resolve, restrictMachine, restrictWorld, run, sameResult, sameValue, splitParts, stored, tag, thrown, toJson, typeName, typePath, typed, typesOf, valueOfThing, walk, worldThing };
 
 //# sourceMappingURL=index.js.map