@mark1russell7/coeval 0.17.0 → 0.19.0

package/src/reads.ts

@@ -22,8 +22,41 @@ export type ReadsCheck =
       readonly read: Read;
       /** What the path of that read reaches in the new context. */
       readonly now: Result;
+      /**
+       * `true` when the read reaches the same thing by `sameResult`, but the print of that thing changed
+       * (READS.IN-PLACE). Only the option `prints` gives this mark.
+       */
+      readonly inPlace?: true;
     };
 
+/** The options of `printReads` (READS.IN-PLACE, D112). */
+export interface PrintOptions {
+  /**
+   * The most entries in the print of one value. Each value, each field name and each mark counts as one entry. A
+   * larger value gets no print, and `verifyReads` then gives its read as changed. The default is 10000.
+   */
+  readonly limit?: number;
+  /**
+   * The stamp of the host for an object, for example the version of a host thing. A stamp other than `undefined`
+   * takes the place of the fields of that object in the print. A stamp compares with `Object.is`.
+   *
+   * @param value - An object of the value of a read.
+   * @returns The stamp, or `undefined` for the walk of the fields.
+   */
+  readonly stamp?: (value: object) => unknown;
+}
+
+/**
+ * The prints of a list of reads, from `printReads`. `verifyReads` takes them with the option `prints`. The prints
+ * keep their options, thus the verification walks each value with the same rules.
+ */
+export interface ReadPrints {
+  /** The print of each read, at the index of the read. A read without an object in its value has no print. */
+  readonly prints: readonly (readonly unknown[] | undefined)[];
+  /** The options of the prints. */
+  readonly options: PrintOptions;
+}
+
 /** The options of `verifyReads`. */
 export interface VerifyOptions {
   /**
@@ -35,11 +68,154 @@ export interface VerifyOptions {
    * @returns `true` when the two things are the same, or `undefined` for the rules of `sameResult`.
    */
   readonly equal?: (a: unknown, b: unknown) => boolean | undefined;
+  /**
+   * The prints of the reads, from `printReads` after the evaluation (READS.IN-PLACE). When the prints are given, a
+   * read that reaches the same thing also compares its print. Thus a change in place of a host value is a changed
+   * read. Without the prints, the verification does no work for them.
+   */
+  readonly prints?: ReadPrints;
 }
 
 /** One answer serves each list whose reads are all the same. */
 const SAME: ReadsCheck = /* @__PURE__ */ Object.freeze({ same: true });
 
+/** The default limit of the entries in the print of one value. */
+const PRINT_LIMIT = 10_000;
+
+/** The marks of a print. Each mark is a private object, thus no value of a host is the same as a mark. */
+const OBJECT = /* @__PURE__ */ Object.freeze({ mark: "object" });
+const LIST = /* @__PURE__ */ Object.freeze({ mark: "list" });
+const DATE = /* @__PURE__ */ Object.freeze({ mark: "date" });
+const MAP = /* @__PURE__ */ Object.freeze({ mark: "map" });
+const SET = /* @__PURE__ */ Object.freeze({ mark: "set" });
+const SEEN = /* @__PURE__ */ Object.freeze({ mark: "seen" });
+const STAMP = /* @__PURE__ */ Object.freeze({ mark: "stamp" });
+
+/** The print of a value that the walk cannot finish: it is too large, or the host threw. It is not the same as any print. */
+const NO_PRINT: readonly unknown[] = /* @__PURE__ */ Object.freeze([]);
+
+/**
+ * This function gives the print of a value: a flat list of its parts, in the order of a walk (D112). Two prints are
+ * the same when they have the same length, and each entry is the same by `Object.is`.
+ *
+ * - An object starts with a mark and its prototype. A list adds its length, a date its time, and a map or a set
+ *   its size and its entries. Then come the count of the own enumerable fields, each name and the kind of each field.
+ * - A field with a getter gives the getter function. The walk does not start host code of a field.
+ * - A primitive value and a function are entries. A function compares by its identity.
+ * - An object that the walk already visited gives the mark `SEEN` and its number. Thus a cycle ends.
+ * - A value with more than `limit` entries, or an exception of the host, gives `NO_PRINT`.
+ *
+ * @param value - The value of a read.
+ * @param options - The limit and the stamp of the host.
+ * @returns The print.
+ */
+function printOf(value: unknown, options: PrintOptions): readonly unknown[] {
+  const limit = options.limit ?? PRINT_LIMIT;
+  const stamp = options.stamp;
+  const out: unknown[] = [];
+  const ids = new Map<object, number>();
+  const stack: unknown[] = [value];
+  try {
+    while (stack.length > 0) {
+      if (out.length > limit) return NO_PRINT;
+      const x = stack.pop();
+      if (typeof x !== "object" || x === null) {
+        out.push(x);
+        continue;
+      }
+      const id = ids.get(x);
+      if (id !== undefined) {
+        out.push(SEEN, id);
+        continue;
+      }
+      ids.set(x, ids.size);
+      const stamped = stamp?.(x);
+      if (stamped !== undefined) {
+        out.push(STAMP, stamped);
+        continue;
+      }
+      const children: unknown[] = [];
+      out.push(OBJECT, Object.getPrototypeOf(x));
+      if (Array.isArray(x)) out.push(LIST, x.length);
+      else if (x instanceof Date) out.push(DATE, Date.prototype.getTime.call(x));
+      else if (x instanceof Map) {
+        out.push(MAP, x.size);
+        if (out.length + 2 * x.size > limit) return NO_PRINT;
+        for (const [key, item] of Map.prototype.entries.call(x) as IterableIterator<[unknown, unknown]>) children.push(key, item);
+      } else if (x instanceof Set) {
+        out.push(SET, x.size);
+        if (out.length + x.size > limit) return NO_PRINT;
+        for (const item of Set.prototype.values.call(x) as IterableIterator<unknown>) children.push(item);
+      }
+      const keys = Object.keys(x);
+      if (out.length + 3 * keys.length > limit) return NO_PRINT;
+      out.push(keys.length);
+      for (const key of keys) {
+        const field = Object.getOwnPropertyDescriptor(x, key);
+        // A field that a proxy hides between `keys` and its descriptor reads as a field without a value.
+        const data = field === undefined || "value" in field;
+        out.push(key, data);
+        children.push(field === undefined ? undefined : "value" in field ? field.value : field.get);
+      }
+      // The stack gives the last entry first, thus the children go on it in the reverse order.
+      for (let index = children.length - 1; index >= 0; index -= 1) stack.push(children[index]);
+    }
+  } catch {
+    return NO_PRINT;
+  }
+  return out.length > limit ? NO_PRINT : out;
+}
+
+/** This function tells if two prints are the same. `NO_PRINT` is not the same as any print, also not as itself. */
+function samePrint(a: readonly unknown[], b: readonly unknown[]): boolean {
+  if (a === NO_PRINT || b === NO_PRINT || a.length !== b.length) return false;
+  for (let index = 0; index < a.length; index += 1) if (!Object.is(a[index], b[index])) return false;
+  return true;
+}
+
+/** This function gives the print of the value of a result, or `undefined` when the value holds no object. */
+function printOfResult(result: Result, options: PrintOptions, cache: Map<object, readonly unknown[]>): readonly unknown[] | undefined {
+  if (!result.ok || typeof result.value !== "object" || result.value === null) return undefined;
+  const value = result.value;
+  let print = cache.get(value);
+  if (print === undefined) {
+    print = printOf(value, options);
+    cache.set(value, print);
+  }
+  return print;
+}
+
+/**
+ * This function gives the prints of the values of a list of reads (READS.IN-PLACE, D112). A host starts it after
+ * the evaluation, and it gives the prints to `verifyReads` with the option `prints`.
+ *
+ * - The print of a value walks its lists, its plain records and the own enumerable fields of each other object. A
+ *   date adds its time, and a map or a set adds its entries.
+ * - A read that is not free, a read that reached an error and a read with a primitive value get no print.
+ * - A cycle ends, because the walk visits each object one time.
+ * - A value with more entries than the limit gets no print. `verifyReads` then gives that read as changed.
+ *
+ * The walk does not see the state in a closure or a private field. It does not see a field with a symbol name, a
+ * field that is not enumerable or the value of a getter. A host gives a stamp for such an object, for example its version.
+ *
+ * @param reads - The reads of the evaluation, from the option `reads`.
+ * @param options - The limit and the stamp of the host.
+ * @returns The prints, for the option `prints` of `verifyReads`.
+ */
+export function printReads(reads: readonly Read[], options: PrintOptions = {}): ReadPrints {
+  const cache = new Map<object, readonly unknown[]>();
+  const prints = reads.map((read) => (read.free ? printOfResult(read.reached, options, cache) : undefined));
+  return { prints, options };
+}
+
+/** This function tells if the print of a read changed, when the read has a print. */
+function changedInPlace(prints: ReadPrints, index: number, now: Result, cache: Map<object, readonly unknown[]>): boolean {
+  const old = prints.prints[index];
+  if (old === undefined) return false;
+  const print = printOfResult(now, prints.options, cache);
+  return print === undefined || !samePrint(old, print);
+}
+
 /** This function tells if two lists of hops are the same: the same steps, rungs and things, in order. */
 function sameHops(a: readonly Hop[], b: readonly Hop[] | undefined, equal: VerifyOptions["equal"]): boolean {
   if (b === undefined || a.length !== b.length) return false;
@@ -78,18 +254,22 @@ function heldStop(root: Context, path: readonly unknown[]): Result | undefined {
  *   extension of a profile can read outside `resolve`. The schedule asks `factsOf` first.
  *
  * The values of the context must not change in place, as PLAN.CACHE says for the documents. A value that changed in
- * place is the same object, thus the function cannot see the change.
+ * place is the same object, thus `sameResult` cannot see the change. The option `prints` finds such a change
+ * (READS.IN-PLACE). The prints come from `printReads` after the evaluation, and the answer then has the mark `inPlace`.
  *
  * @param target - The machine of the evaluation, or its plan.
  * @param reads - The reads of the evaluation, from the option `reads`.
  * @param context - The new context.
- * @param options - The rule of the host for two things.
+ * @param options - The rule of the host for two things, and the prints of the reads.
  * @returns `{ same: true }` when each free read reaches the same thing, or else the first changed read.
  */
 export function verifyReads(target: Machine | Plan, reads: readonly Read[], context: Context, options: VerifyOptions = {}): ReadsCheck {
   const machine = "evaluators" in target ? target : target.machine;
   const root = rootContext(machine, context);
   const equal = options.equal;
+  const prints = options.prints;
+  // The prints of the new values, made only with the option `prints`. Two reads of one object share its print.
+  let printed: Map<object, readonly unknown[]> | undefined;
   for (let index = 0; index < reads.length; index += 1) {
     const read = reads[index] as Read;
     if (!read.free) continue;
@@ -100,6 +280,7 @@ export function verifyReads(target: Machine | Plan, reads: readonly Read[], cont
       const now = keptAgain(machine, root, read.path);
       if (now === undefined) return { same: false, index, read, now: fail("#N/A", "The host does not know the value of the kept read yet.") };
       if (!sameResult(read.reached, now, equal)) return { same: false, index, read, now };
+      if (prints !== undefined && changedInPlace(prints, index, now, (printed ??= new Map()))) return { same: false, index, read, now, inPlace: true };
       continue;
     }
     const asked = read.hops !== undefined;
@@ -107,6 +288,9 @@ export function verifyReads(target: Machine | Plan, reads: readonly Read[], cont
     if (!sameResult(read.reached, now.reached, equal) || (read.hops !== undefined && !sameHops(read.hops, now.hops, equal))) {
       return { same: false, index, read, now: now.reached };
     }
+    if (prints !== undefined && changedInPlace(prints, index, now.reached, (printed ??= new Map()))) {
+      return { same: false, index, read, now: now.reached, inPlace: true };
+    }
   }
   return SAME;
 }

package/src/reference.ts

@@ -21,6 +21,7 @@ import {
   type Steps,
   type StopSignal,
   JOURNAL,
+  heldReason,
   makeContext,
   permits,
   placeText,
@@ -110,6 +111,8 @@ interface Env {
   readonly verb: string;
   /** The scope of the code that evaluates at this time. `all` changes it for each item. */
   scope: Scope;
+  /** The count of the drives without a wait that are active. In a run, an effect under one does not reach the host (RUN.HELD). */
+  held: number;
   /** The record of the reads. A nested evaluation for an equation of a tree keeps the record of its tree. */
   readonly reading: Reading | undefined;
 }
@@ -309,6 +312,12 @@ function* causeAndWait(env: Env, ctx: Context, kind: Cap, payload: unknown, plac
   if ("ok" in effect) return effect;
   const perform = env.perform;
   if (perform === undefined) return (effect.outcome = ok(payload));
+  if (env.held > 0) {
+    // The parent cannot wait for the answer of the host, thus the host does not get the effect (RUN.HELD).
+    effect.outcome = fail("#CALC!", heldReason(kind), { place });
+    yield Promise.resolve(undefined);
+    return effect.outcome;
+  }
   let given: unknown;
   try {
     given = perform(effect);
@@ -382,7 +391,16 @@ function evaluateSeen(env: Env, seen: Seen, at: At): Result {
   const { chosen } = seen;
   const { place } = at;
   if ("gap" in chosen) return fail("#NOEVAL", chosen.gap, { place });
-  if ("runner" in chosen) return drive(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
+  if ("runner" in chosen) {
+    if (!env.running) return drive(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
+    // In a run, an effect under this drive does not reach the host (RUN.HELD).
+    env.held += 1;
+    try {
+      return drive(runSeen(env, seen, at, chosen.runner), place, seen.kindText);
+    } finally {
+      env.held -= 1;
+    }
+  }
   const input = evalInput(env, seen, at);
   try {
     return placed(chosen.evaluator(input), place);
@@ -655,6 +673,7 @@ function envOf(machine: Machine, options: ReferenceOptions, running: boolean, ro
     running,
     verb: options.verb ?? "eval",
     scope: { prefix: "", counts: new Map(), alls: 0 },
+    held: 0,
     reading: outer ?? (options.reads === undefined ? undefined : { list: options.reads, root }),
   };
 }

package/src/replay.ts

@@ -230,7 +230,8 @@ export interface ReplayErrorJson {
   /**
    * The JSON form of a cause without a term document that is a list or a plain record with an exception at some depth
    * (RUN.REPLAY-CAUSE-PARTS, D87). It is a list of parts, the part `record` or the part `share`. The index 0 of `loop` is its
-   * first exception, and the index 0 of `share` is its first list or record.
+   * first exception, and the index 0 of `share` is its first list or record. Since D101, a list or a record cause that
+   * holds a container at two places is also `causeParts` (RUN.REPLAY-SHARED-VALUES).
    */
   readonly causeParts?: ReplayCausePartsJson;
   /** The names of the items of `causeParts` without a form, for example `cause.send`. This list is only a note. */
@@ -251,13 +252,18 @@ export type ReplayCausePartsJson = readonly ReplayPartsJson[] | { readonly recor
 export interface ReplayExceptionJson {
   readonly name: string;
   readonly message: string;
-  /** The term documents of the own fields of the exception that `encodeValue` writes, for example `code` or `errno`. */
+  /**
+   * The term documents of the own fields of the exception that `encodeValue` writes, for example `code` or `errno`. A list
+   * or a plain record that two places of the error share is in `parts` (RUN.REPLAY-SHARED-VALUES, D101).
+   */
   readonly fields?: Readonly<Record<string, Json>>;
   /**
    * The own enumerable fields without a term document that are an exception, a list or a plain record (RUN.REPLAY-FIELDS,
    * D78, D82). An example is a list `errors` on an `Error`. A list is a list of parts, and a record is the part `record`.
    * Each exception in them has the rule of a cause. A container without a form in it is a name in `dropped`. A container
    * that an earlier place holds is the part `share` (D88).
+   *
+   * Since D101, a shared container with a term document is in `parts` too, and so is each container that holds it.
    */
   readonly parts?: Readonly<Record<string, ReplayPartsJson>>;
   /**
@@ -279,7 +285,8 @@ export interface ReplayExceptionJson {
   readonly loop?: number;
   /**
    * The JSON form of a cause without a term document that is a list or a plain record with an exception at some depth
-   * (RUN.REPLAY-CAUSE-PARTS, D87). Each exception in it has the rule of a cause, also a `loop`.
+   * (RUN.REPLAY-CAUSE-PARTS, D87). Each exception in it has the rule of a cause, also a `loop`. Since D100, a list or a
+   * record without an exception is also `causeParts` when an item has a form (RUN.REPLAY-CAUSE-ITEMS).
    */
   readonly causeParts?: ReplayCausePartsJson;
 }
@@ -371,7 +378,10 @@ interface Holder {
   /** The name for `dropped` when no item of the container has a form. */
   readonly name: string;
   readonly list: boolean;
-  /** The value `true` marks a hidden list of a standard class. It keeps its marks also without a form (D78). */
+  /**
+   * The value `true` marks a hidden list of a standard class. It keeps its marks also without a form (D78). It also marks
+   * a shared container with a term document, thus an empty container keeps its form (D101).
+   */
   keep: boolean;
   /** The keys of a record in the order of the keys. A list has no keys. */
   readonly keys: readonly string[];
@@ -385,7 +395,10 @@ interface ExceptionTask {
   readonly name: string;
   /** The value `true` marks a value that `encodeValue` cannot write, thus the walk does not try again. */
   readonly tried: boolean;
-  /** The value `false` marks a cause. A cause is a container only when it holds an exception at some depth (D87). */
+  /**
+   * The value `false` marks the cause of an error value. It is a container only when it holds an exception at some depth
+   * (D87). The cause of an exception is a container as a field is (D100).
+   */
   readonly nest: boolean;
   /** The value `true` marks a hidden list of a standard class. It is always a container of parts (D77). */
   readonly keep: boolean;
@@ -421,9 +434,66 @@ function holdsHole(value: unknown): boolean {
   return false;
 }
 
+/**
+ * This function gives the lists and the plain records that the walk of `causeJson` keeps as containers of parts, also
+ * with a term document (D101). Such a container is at two places of the walk, or it holds such a container at some depth.
+ * It reads the values as the walk does: the fields of an exception, its hidden fields and its cause, and the items of a
+ * container. A term document gives a copy at each place, thus a shared container cannot be one.
+ */
+function sharedOf(root: unknown): ReadonlySet<object> {
+  const seen = new Set<object>();
+  const twice: object[] = [];
+  // The containers that hold each container. A container on the way to a shared container is a container of parts too.
+  const owners = new Map<object, object[]>();
+  const stack: [unknown, object | undefined][] = [[root, undefined]];
+  for (let next = stack.pop(); next !== undefined; next = stack.pop()) {
+    const [at, owner] = next;
+    if (typeof at !== "object" || at === null) continue;
+    const container = Array.isArray(at) || isRecord(at);
+    if (!container && !(at instanceof Error)) continue;
+    if (container && owner !== undefined) {
+      const list = owners.get(at);
+      if (list === undefined) owners.set(at, [owner]);
+      else list.push(owner);
+    }
+    if (seen.has(at)) {
+      if (container) twice.push(at);
+      continue;
+    }
+    seen.add(at);
+    if (Array.isArray(at)) {
+      for (let item = 0; item < at.length; item += 1) if (Object.hasOwn(at, item)) stack.push([readField(at, item), at]);
+    } else if (container) {
+      for (const key of Object.keys(at)) stack.push([readField(at, key), at]);
+    } else {
+      // An exception is never a term document of the walk, thus it is not an owner.
+      for (const key of Object.keys(at)) if (!ownField(key)) stack.push([readField(at, key), undefined]);
+      for (const key of HIDDEN) if (Object.getOwnPropertyDescriptor(at, key)?.enumerable === false) stack.push([readField(at, key), undefined]);
+      if (Object.hasOwn(at, "cause")) stack.push([readField(at, "cause"), undefined]);
+    }
+  }
+  const shared = new Set<object>();
+  for (let at = twice.pop(); at !== undefined; at = twice.pop()) {
+    if (shared.has(at)) continue;
+    shared.add(at);
+    for (const owner of owners.get(at) ?? []) twice.push(owner);
+  }
+  return shared;
+}
+
+/**
+ * This function tells if the walk of `causeJson` keeps a value with a term document as a container of parts (D101). The
+ * value is in the set of `sharedOf`. A member of a domain stays a term document, because its codec makes it again.
+ */
+function wholeOf(shared: ReadonlySet<object>, value: unknown, term: Json): boolean {
+  if (typeof value !== "object" || value === null || !shared.has(value)) return false;
+  const type = isRecord(term) ? term["type"] : undefined;
+  return !(Array.isArray(type) && type[0] === "ext" && type[1] === "domain");
+}
+
 /**
  * This function tells if a list or a plain record holds an exception at some depth (D87). It reads the items as the
- * walk of `causeJson` does, thus a cause container with an exception gets a form.
+ * walk of `causeJson` does, thus a container cause of an error value with an exception gets a form.
  */
 function holdsException(value: unknown): boolean {
   const seen = new Set<object>();
@@ -492,13 +562,15 @@ function keptOf(keys: readonly string[], built: readonly Built[]): [string, Repl
  *
  * The walk gives each exception an index in the order of a depth-first walk. It takes the fields in `parts` in the
  * order of their keys, the hidden fields in the order of `HIDDEN`, then the cause (D78). A list or a plain record
- * without a term document is a container of parts, with its items in their order (D82). A cause is a container only
- * when it holds an exception (D87). A value that is an earlier exception of the walk is its index in `loop` (D77).
+ * without a term document is a container of parts, with its items in their order (D82). The cause of an error value
+ * is a container only when it holds an exception (D87). The cause of an exception is a container as a field is (D100).
+ * A value that is an earlier exception of the walk is its index in `loop` (D77).
  *
- * A container that an earlier place holds is its index in `share`, also a container that holds itself (D88). The walk is
- * a loop, thus a long chain does not overflow the stack.
+ * A container that an earlier place holds is its index in `share`, also a container that holds itself (D88). A container
+ * of `sharedOf` is a container of parts also with a term document, thus each share gives one object (D101). The value
+ * `tried` marks a root that `encodeValue` cannot write. The walk is a loop, thus a long chain does not overflow the stack.
  */
-function causeJson(machine: Pick<Machine, "domains">, root: unknown): CauseJson {
+function causeJson(machine: Pick<Machine, "domains">, root: unknown, shared: ReadonlySet<object>, tried: boolean): CauseJson {
   // The nodes and the containers in the order of the walk. Each item of a node or of a container comes later.
   const items: (ExceptionNode | Holder)[] = [];
   const index = new Map<unknown, number>();
@@ -530,12 +602,14 @@ function causeJson(machine: Pick<Machine, "domains">, root: unknown): CauseJson
     const at = items.length;
     index.set(current, index.size);
     const fields: [string, Json][] = [];
-    const linked: [string, unknown][] = [];
+    // The value `true` marks a field without a term document. A shared container has one, and the walk writes it (D101).
+    const linked: [string, unknown, boolean][] = [];
     for (const key of Object.keys(current)) {
       if (ownField(key)) continue;
       const value = readField(current, key);
       const term = value === MISSING ? undefined : termOrNothing(machine, value);
-      if (term === undefined) linked.push([key, value]);
+      if (term === undefined) linked.push([key, value, true]);
+      else if (wholeOf(shared, value, term)) linked.push([key, value, false]);
       else fields.push([key, term]);
     }
     const head = { name: String(current.name), message: String(current.message), ...(fields.length === 0 ? {} : { fields: Object.fromEntries(fields) }) };
@@ -543,11 +617,11 @@ function causeJson(machine: Pick<Machine, "domains">, root: unknown): CauseJson
     items.push(node);
     const children: ExceptionTask[] = [];
     for (let place = 0; place < linked.length; place += 1) {
-      const [key, value] = linked[place] as [string, unknown];
+      const [key, value, without] = linked[place] as [string, unknown, boolean];
       const put = (part: Part): void => {
         node.parts[place] = part;
       };
-      children.push({ value, name: key, tried: true, nest: true, keep: false, put });
+      children.push({ value, name: key, tried: without, nest: true, keep: false, put });
     }
     for (const key of HIDDEN) {
       if (Object.getOwnPropertyDescriptor(current, key)?.enumerable !== false) continue;
@@ -564,7 +638,8 @@ function causeJson(machine: Pick<Machine, "domains">, root: unknown): CauseJson
       const put = (part: Part): void => {
         node.cause = part;
       };
-      children.push({ value: current.cause, name: "cause", tried: false, nest: false, keep: false, put });
+      // The cause of an exception keeps each item with a form, also without an exception in it (D100).
+      children.push({ value: current.cause, name: "cause", tried: false, nest: true, keep: false, put });
     }
     later(children);
     return at;
@@ -573,7 +648,7 @@ function causeJson(machine: Pick<Machine, "domains">, root: unknown): CauseJson
   tasks.push({
     value: root,
     name: "cause",
-    tried: true,
+    tried,
     nest: false,
     keep: false,
     put: (part) => {
@@ -591,20 +666,23 @@ function causeJson(machine: Pick<Machine, "domains">, root: unknown): CauseJson
       task.put({ loop });
       continue;
     }
+    const container = Array.isArray(value) || isRecord(value);
+    const held = container ? holders.get(value) : undefined;
+    if (held !== undefined) {
+      // A container that an earlier place holds, also a container that holds itself, is a share (D88, D101).
+      if (task.keep) (items[held] as Holder).keep = true;
+      task.put({ same: held, name: task.name });
+      continue;
+    }
     const term = task.tried || task.keep ? undefined : termOrNothing(machine, value);
-    if (term !== undefined) task.put({ value: term });
+    // A shared container with a term document is a container of parts, and it always has a form (D101).
+    const whole = term !== undefined && wholeOf(shared, value, term);
+    if (term !== undefined && !whole) task.put({ value: term });
     else if (value instanceof Error) task.put({ node: open(value) });
-    else if ((Array.isArray(value) || isRecord(value)) && (task.nest || holdsException(value))) {
-      const held = holders.get(value);
-      if (held === undefined) {
-        const children: ExceptionTask[] = [];
-        task.put({ holder: hold(task.name, value, task.keep, children) });
-        later(children);
-      } else {
-        // A container that an earlier place holds, also a container that holds itself, is a share (D88).
-        if (task.keep) (items[held] as Holder).keep = true;
-        task.put({ same: held, name: task.name });
-      }
+    else if (container && (whole || task.nest || holdsException(value))) {
+      const children: ExceptionTask[] = [];
+      task.put({ holder: hold(task.name, value as object, task.keep || whole, children) });
+      later(children);
     } else task.put({ none: task.name });
   }
   const { formed, shares } = formsOf(items);
@@ -718,14 +796,20 @@ function errorJson(machine: Pick<Machine, "domains">, error: EvalError, what: ()
   const base = { code: error.code, reason: error.reason, ...(error.place === undefined ? {} : { place: error.place }) };
   if (!Object.hasOwn(error, "cause")) return base;
   const cause: unknown = error.cause;
+  const shared = sharedOf(cause);
+  let term: Json | undefined;
+  let failure: unknown;
   try {
-    return { ...base, cause: encodeValue(machine, cause) };
-  } catch (failure) {
-    // An exception, or a list or a record with an exception, is a best effort (D76, D87). Each other cause is a refusal.
-    const { link, names } = causeJson(machine, cause);
-    if (link === undefined) throw new TypeError(`encodeLog cannot write the cause of ${what()}: ${messageOf(failure)}`);
-    return { ...base, ...link, ...(names.length === 0 ? {} : { dropped: names }) };
+    term = encodeValue(machine, cause);
+  } catch (thrown) {
+    failure = thrown;
   }
+  // A cause that holds a shared container is a container of parts, thus each place keeps one object (D101).
+  if (term !== undefined && !wholeOf(shared, cause, term)) return { ...base, cause: term };
+  // An exception, or a list or a record with an exception, is a best effort (D76, D87). Each other cause is a refusal.
+  const { link, names } = causeJson(machine, cause, shared, term === undefined);
+  if (link === undefined) throw new TypeError(`encodeLog cannot write the cause of ${what()}: ${messageOf(failure)}`);
+  return { ...base, ...link, ...(names.length === 0 ? {} : { dropped: names }) };
 }
 
 /**
@@ -743,8 +827,12 @@ function errorJson(machine: Pick<Machine, "domains">, error: EvalError, what: ()
  *   (RUN.REPLAY-FIELDS, D78, D82). An item of a list without a form is the mark `dropped` at its place.
  * - A cause without a term document that is a list or a plain record with an exception is in `causeParts`
  *   (RUN.REPLAY-CAUSE-PARTS, D87). The rule is the same for the cause of an exception and of an error value.
+ * - The cause of an exception is also in `causeParts` without an exception in it, when an item has a form
+ *   (RUN.REPLAY-CAUSE-ITEMS, D100). Each item without a form is a name in `dropped`, for example `cause.send`.
  * - A list or a record of parts that an earlier place of one error holds is the part `share` with its index
  *   (RUN.REPLAY-SHARED, D88). This rule also covers a container that holds itself.
+ * - A list or a plain record with a term document that two places of one error share is a container of parts
+ *   (RUN.REPLAY-SHARED-VALUES, D101). Each later place is a share. A member of a domain stays a term document.
  * - An outcome that the log does not have stays absent.
  *
  * @param machine - The machine of the run, or only its domains.