fyflow-orchestration 0.8.0 → 0.9.0

package/dist/node/chunks/{chunk-EUU44PHD.js → chunk-3U4UZC34.js}

@@ -3089,6 +3089,49 @@ var defaultCreateTask = (config) => new FyflowTask(config);
 var SETTLEMENT_EVENTS = ["task.completed", "task.failed", "task.user_action", "task.cancelled"];
 var SUBSCRIBED_EVENTS = [...SETTLEMENT_EVENTS, "task.running"];
 var PASS_THROUGH = [["task.message", "onTaskMessage"], ["task.progress", "onTaskProgress"]];
+var NO_RECORDS = Object.freeze([]);
+var TaskLog = class {
+  byTask = /* @__PURE__ */ new Map();
+  visits = 0;
+  /** `append`'s half: the record joins its task's sub-log, by reference. */
+  push(record) {
+    const sub = this.byTask.get(record.taskId);
+    if (sub) sub.push(record);
+    else this.byTask.set(record.taskId, [record]);
+  }
+  /** One task's records, in append order — what `effectiveOutcome` and `isSuspended` are handed. Read, never kept. */
+  of(taskId) {
+    const sub = this.byTask.get(taskId) ?? NO_RECORDS;
+    this.visits += sub.length;
+    return sub;
+  }
+};
+var Fifo = class {
+  items = [];
+  head = 0;
+  get length() {
+    return this.items.length - this.head;
+  }
+  push(x) {
+    this.items.push(x);
+  }
+  /** The oldest element, removed — `undefined` when empty, as `Array.prototype.shift`. */
+  shift() {
+    if (this.head >= this.items.length) return void 0;
+    const x = this.items[this.head];
+    this.items[this.head] = void 0;
+    this.head += 1;
+    if (this.head === this.items.length) {
+      this.items = [];
+      this.head = 0;
+    }
+    return x;
+  }
+  /** Every element still queued, oldest first. */
+  *[Symbol.iterator]() {
+    for (let i = this.head; i < this.items.length; i += 1) yield this.items[i];
+  }
+};
 var Driver = class {
   /**
    * `OR-R7` — nothing outside the inbound API writes to run state. Private, and
@@ -3106,13 +3149,21 @@ var Driver = class {
    * channels with no shared order, so `RN-R3`'s *"read in append order"* was about
    * a value no one could hold.
    *
-   * `log` above is the **record-kind subsequence of this array**, kept as its own
-   * array only because `effectiveOutcome` and `isSuspended` scan it on every
-   * settlement and rebuilding it by filter each time is quadratic. It holds the
-   * same record objects, never copies. `test/driver/` asserts the two agree, so
-   * the redundancy is checked rather than trusted.
+   * `log` above is the **record-kind subsequence of this array**, by reference — the
+   * same record objects, never copies; `test/driver/` asserts the two agree, so the
+   * redundancy is checked rather than trusted. *(It was kept "only because
+   * `effectiveOutcome` and `isSuspended` scan it on every settlement" until W195,
+   * whose {@link TaskLog} hands each of them one task's records instead — P39 fact 5.
+   * It stays for what still reads it WHOLE and in order: `snapshot()`, `outputs()`'s
+   * catch-up, and the retention walk's alias check.)*
    */
   inputs = [];
+  /**
+   * **Each task's records, by reference and in append order** — {@link TaskLog}, `RN-R13` v0.30, ADR 0121 (W195). Written in
+   * `append` beside `log`; read by every per-task question the driver asks of its log — `advance`, `parked`, `hasParked`,
+   * `inFlight`, `outputs()`, `effectiveOutcomeOf` — so each costs the task, never the run.
+   */
+  taskLog = new TaskLog();
   graph;
   regions;
   dispatched = /* @__PURE__ */ new Set();
@@ -3360,7 +3411,7 @@ var Driver = class {
    * brief: *an owner element a resume's replay feeds is TAKEN AT REST*): accepted at the call — every refusal already asked — and its resolution
    * appended when the step ends, in the same call order as the pauses beside it.
    */
-  pausePending = [];
+  pausePending = new Fifo();
   /**
    * **The highest attempt number RECORDED for each task, by task id** — `RN-R40`, v0.26, W186, P36 (f) and (g): the
    * number the last `attempted` element for it carried — appended, or fed by a replay. What decides that a `task.running`
@@ -3375,7 +3426,7 @@ var Driver = class {
    * every one is appended when the step ends, BEFORE a pause, an unpause, an answer or a stop pending on that step is taken
    * (`leaveStep()`): the attempt started before any of them. Empty at rest.
    */
-  attemptsPending = [];
+  attemptsPending = new Fifo();
   /**
    * **The dispatch hold is SHUT: a halt is on the run, and the driver dispatches and routes nothing further for it** —
    * `RN-R29`,
@@ -3874,9 +3925,7 @@ var Driver = class {
    * handing it to a worker again would run what a person was asked to decide.
    */
   inFlight() {
-    const settled = /* @__PURE__ */ new Set();
-    for (const r of this.log) if (r.kind === "outcome") settled.add(r.taskId);
-    return [...this.dispatched].filter((id) => !settled.has(id));
+    return [...this.dispatched].filter((id) => !this.taskLog.of(id).some((r) => r.kind === "outcome"));
   }
   /**
    * **Whether a callback fires for the element at `seq`** — `RN-R24`. Always, except during a replay,
@@ -3912,7 +3961,7 @@ var Driver = class {
   /** `resolve`'s body — wrapped so the driver knows it is on the stack of its own step (`stepping`, `RN-R31`, W173 D-1). */
   resolveStep(taskId, resolvedAs, value, midStep = false) {
     if (!this.parked(taskId)) return false;
-    if (this.pausePending.some((c) => c.kind === "answer" && c.record.taskId === taskId)) return false;
+    for (const c of this.pausePending) if (c.kind === "answer" && c.record.taskId === taskId) return false;
     const { runId, nodeId, branchPath } = parseTaskId(taskId);
     if (this.shut() || this.stopRequest !== null) return false;
     if (resolvedAs === "done" && this.opts.validateBoundaries !== false) {
@@ -4267,7 +4316,7 @@ var Driver = class {
       throw new RunControlRefused(
         "pause",
         "paused",
-        `RunControlRefused (paused): run "${this.runId}" is already paused${this.pausePending.some((c) => c.kind !== "answer") ? " \u2014 by a call earlier in this step, taken when it ends" : ""} (RN-R35, P34 (e)). Unpause it first. Nothing was recorded.`
+        `RunControlRefused (paused): run "${this.runId}" is already paused${[...this.pausePending].some((c) => c.kind !== "answer") ? " \u2014 by a call earlier in this step, taken when it ends" : ""} (RN-R35, P34 (e)). Unpause it first. Nothing was recorded.`
       );
     }
     if (this.stepping === 0 && this.inFlight().length === 0 && !this.hasParked()) {
@@ -4293,7 +4342,7 @@ var Driver = class {
       throw new RunControlRefused(
         "unpause",
         "not-paused",
-        `RunControlRefused (not-paused): run "${this.runId}" is not paused${this.pausePending.some((c) => c.kind !== "answer") ? " \u2014 an unpause earlier in this step already lifts it" : ""} (RN-R35, P34 (e)). Nothing was recorded and nothing was handed on.`
+        `RunControlRefused (not-paused): run "${this.runId}" is not paused${[...this.pausePending].some((c) => c.kind !== "answer") ? " \u2014 an unpause earlier in this step already lifts it" : ""} (RN-R35, P34 (e)). Nothing was recorded and nothing was handed on.`
       );
     }
     this.pausePending.push({ kind: "unpaused", actor: options.actor });
@@ -4301,7 +4350,7 @@ var Driver = class {
   }
   /** The pause the owner has ASKED for: the last call still to be taken, else the pause taken (`RN-R35`). */
   pauseWanted() {
-    const last = this.pausePending.filter((c) => c.kind !== "answer").at(-1);
+    const last = [...this.pausePending].filter((c) => c.kind !== "answer").at(-1);
     return last !== void 0 ? last.kind === "paused" : this.paused;
   }
   /**
@@ -4694,7 +4743,7 @@ var Driver = class {
     if (!node) return;
     const itemIndices = this.indicesFrom(nodeId, branchPath);
     const taskId = buildTaskId(runId, nodeId, branchIndices(this.pathOf(nodeId, itemIndices)));
-    const outcome = effectiveOutcome(this.log, taskId);
+    const outcome = effectiveOutcome(this.taskLog.of(taskId), taskId);
     if (!outcome) return;
     const result = selectEdge(
       node,
@@ -5041,7 +5090,7 @@ var Driver = class {
    * [ADR 0040](../../doc/decisions/0040-what-a-node-can-reach-is-the-runs-own-outputs-and-a-node-id-names-them-relative-to-a-branch-path.md)
    * rules 2 and 3, and `FD-C2`.
    *
-   * **It is a PROJECTION of the log and adds no retention** — measured at
+   * **It is a PROJECTION of the log and adds no retention of a result** — measured at
    * [P12](../../doc/plans/p12-what-a-node-receives-and-what-a-decision-sees.md)'s
    * declaration and again before this was written: this driver holds
    * `private readonly log: LogRecord[]` with exactly one `push` and no `splice`,
@@ -5051,14 +5100,11 @@ var Driver = class {
    * described **today** before this method existed, and this adds **no retention**.
    * *(Q19 is RESOLVED since W53 —
    * [ADR 0046](../../doc/decisions/0046-a-run-retains-what-its-tasks-returned-and-a-region-releases-its-collection-when-its-join-becomes-terminal.md)
-   * — and `RN-R13` names this memo by id: it holds results **by reference only**,
+   * — and `RN-R13` names `outputsCache` by id: it holds results **by reference only**,
    * asserted by IDENTITY at ladder L2 rather than by a byte count, because a
    * reachability SET cannot tell an alias from a copy. W53's readers found that
    * from both ends — the rule's stated test returned a third name on a `needs`
    * flow, and cloning here cost ZERO.)*
-   * *(It adds ONE field — `outputsCache` below — which is a memo the log invalidates
-   * and which holds nothing the log does not. This read *"zero fields"* until W41's
-   * conformity reader read it beside the memo the cost measurement had just added.)*
    *
    * **`effectiveOutcome` and not the raw record**, for `spec/flow-definition.md`
    * section 3 rule 4's own reason: a resumed node has two records in the log and
@@ -5066,43 +5112,97 @@ var Driver = class {
    * suspended has no effective outcome and therefore no entry — which is what makes
    * `FD-R3` fire rather than a reference quietly resolving to `undefined`.
    *
-   * **Computed on demand rather than maintained**, and the cost is why: it is
-   * `O(log)` per call, so maintaining it would be a second source that could
-   * disagree with the log — the defect [Q43](../../doc/questions/q43.md) and
-   * `arrival-count`'s re-sourcing are each an instance of. **A node that declares no
-   * `needs` never reaches this method**, which is what keeps ADR 0040 rule 1's *the
-   * default is unchanged* true of the cost as well as of the value.
+   * **CAUGHT UP rather than rebuilt** — `RN-R13` v0.30, P39 decision 4 and fact 7,
+   * [ADR 0121](../../doc/decisions/0121-the-driver-keeps-a-per-task-view-of-its-log.md) (W195), amending ADR 0040
+   * rule 2's *computed rather than maintained*. Until W195 this was memoised on the log's LENGTH and rebuilt from the
+   * WHOLE log whenever the log had grown — so a node with a `needs` entered once per settlement, which is every instance
+   * of a `map` whose branch declares one, paid O(log) per entry and the run O(log²): the case its own memo missed by
+   * construction. Now each call reads only the records appended since the last (`at`, an index into the append-only
+   * `log`), and for each one asks `effectiveOutcome` of THAT TASK's records ({@link TaskLog}) — so the merge stays in
+   * ONE place, which is ADR 0040 rule 2's own reason, and an entry is always the merge of its task's whole sub-log at
+   * the moment of the call: nothing here can say what the log does not. **Equal to a rebuild at every read**
+   * (`test/driver/log-view.test.ts`, at every fold input of every valid corpus flow): the same entries, a node's list
+   * in its tasks' first-record order, each `result` the log record's own object.
+   *
+   * **Still LAZY, so ADR 0040 rule 1's *the default is unchanged* holds of the cost**: nothing is caught up until a
+   * node or an edge that declares a `needs` asks, and a run that declares none never builds it.
    */
   outputs() {
-    if (this.outputsCache && this.outputsCache.at === this.log.length) return this.outputsCache.byNode;
-    const byNode = /* @__PURE__ */ new Map();
-    const groups = /* @__PURE__ */ new Map();
-    for (const r of this.log) {
-      const g = groups.get(r.taskId);
-      if (g) g.push(r);
-      else groups.set(r.taskId, [r]);
-    }
-    for (const [taskId, group] of groups) {
-      const eff = effectiveOutcome(group, taskId);
-      if (!eff) continue;
-      let parts;
-      try {
-        parts = parseTaskId(taskId);
-      } catch {
-        continue;
+    const c = this.outputsCache ??= { at: 0, byNode: /* @__PURE__ */ new Map(), tasks: /* @__PURE__ */ new Map(), orders: /* @__PURE__ */ new Map() };
+    for (; c.at < this.log.length; c.at += 1) {
+      const r = this.log[c.at];
+      let t = c.tasks.get(r.taskId);
+      if (t === void 0) {
+        let parts;
+        try {
+          parts = parseTaskId(r.taskId);
+        } catch {
+          c.tasks.set(r.taskId, null);
+          continue;
+        }
+        t = { nodeId: parts.nodeId, path: parts.branchPath, order: c.tasks.size, entry: null };
+        c.tasks.set(r.taskId, t);
       }
-      const list = byNode.get(parts.nodeId);
-      if (list) list.push({ path: parts.branchPath, result: eff.result });
-      else byNode.set(parts.nodeId, [{ path: parts.branchPath, result: eff.result }]);
+      if (t === null) continue;
+      this.place(c, t, effectiveOutcome(this.taskLog.of(r.taskId), r.taskId));
     }
-    this.outputsCache = { at: this.log.length, byNode };
-    return byNode;
+    return c.byNode;
   }
   /**
-   * The memo above. **Not run state and not a second copy of it** — it is discarded
-   * and rebuilt the moment the log grows, and nothing ever reads it without checking
-   * the length first, so there is no state here that could be stale in a way anything
-   * could observe. `ADR 0014`'s *the driver computes no run state* is untouched.
+   * **One task's entry, made what its effective outcome now says** — `outputs()`'s catch-up, for a task one of whose records
+   * was just read. An entry is `{ path, result }` with `result` the record's own object (`RN-R13`); a node's list is kept
+   * in its tasks' FIRST-RECORD order, the order the rebuild grouped them in.
+   *
+   * **`!eff` — a suspended node contributes no entry.** The first record of a `user_action` task has none, and its
+   * RESOLUTION, later, gives it one: that is the one entry that is not appended at the END of its node's list but placed
+   * at its first record's position — reachable, and the corpus's *parked, attempted, resolved* drain reaches it. *(Whether
+   * a suspended node's ABSENCE is ever read: no — W41's adequacy reader measured making it contribute
+   * `{result: undefined}` cost **0**, because every shipped policy leaves a parked branch holding a token, so no join
+   * fires while one is parked and no reader downstream of it is entered. [Q97](../../doc/questions/q97.md).)* An entry
+   * that LOSES its effective outcome is removed — **reachable**: `ID-R4` asks only whether a settlement's id was dispatched,
+   * so a settlement event repeated for a settled task is appended, and a `done` then a `user_action` leaves the task with
+   * none (W195's conformity reader, C4; `test/driver/log-view.test.ts` drives it and the resolution that places it again).
+   */
+  place(c, t, eff) {
+    const list = c.byNode.get(t.nodeId);
+    const orders = c.orders.get(t.nodeId);
+    if (eff === null) {
+      if (t.entry === null || list === void 0 || orders === void 0) return;
+      const at = list.indexOf(t.entry);
+      list.splice(at, 1);
+      orders.splice(at, 1);
+      t.entry = null;
+      if (list.length === 0) {
+        c.byNode.delete(t.nodeId);
+        c.orders.delete(t.nodeId);
+      }
+      return;
+    }
+    const entry = { path: t.path, result: eff.result };
+    if (t.entry !== null && list !== void 0) {
+      list[list.indexOf(t.entry)] = entry;
+      t.entry = entry;
+      return;
+    }
+    t.entry = entry;
+    if (list === void 0 || orders === void 0) {
+      c.byNode.set(t.nodeId, [entry]);
+      c.orders.set(t.nodeId, [t.order]);
+      return;
+    }
+    let i = list.length;
+    while (i > 0 && orders[i - 1] > t.order) i -= 1;
+    list.splice(i, 0, entry);
+    orders.splice(i, 0, t.order);
+  }
+  /**
+   * The projection above, CAUGHT UP to `at` — `RN-R13` v0.30, ADR 0121 (W195). **Not run state and not a second copy of
+   * it**: `byNode`'s entries hold each result BY REFERENCE (the log record's own object) — so it is a holder of results and
+   * never a copy — `tasks` is one slot per task id
+   * read — its node, its path, its first-record position and its current entry — and `orders` the same positions, per
+   * node, parallel to its list. Everything here is the merge `effectiveOutcome` computed from the task's own records at the moment they were
+   * read, and `at` says which records have been; so there is nothing here that could disagree with the log. `ADR 0014`'s
+   * *the driver computes no run state* is untouched. `null` until a `needs` first asks.
    */
   outputsCache = null;
   /**
@@ -5332,7 +5432,7 @@ var Driver = class {
    * predicate read it here: `resolve()`, the replay's fed resolution, and the three `ended` refusals (`hasParked`).
    */
   parked(taskId) {
-    return isSuspended(this.log, taskId, this.asked.has(taskId));
+    return isSuspended(this.taskLog.of(taskId), taskId, this.asked.has(taskId));
   }
   /**
    * **Whether anything in the run waits on a person** — a parked task or an unanswered ask. `cancel`, `stop` and `pause`
@@ -5341,7 +5441,7 @@ var Driver = class {
    * never dispatched, it is never in flight, so every road reading `inFlight()` passes it by (`RN-R38`, W181).
    */
   hasParked() {
-    for (const id of this.dispatched) if (isSuspended(this.log, id)) return true;
+    for (const id of this.dispatched) if (isSuspended(this.taskLog.of(id), id)) return true;
     for (const id of this.asked) if (this.parked(id)) return true;
     return false;
   }
@@ -5619,13 +5719,18 @@ var Driver = class {
    *
    * A record is pushed to `log` as well, by reference: `effectiveOutcome` reads
    * the stored object and `OR-R8` derives rather than appends, so a second copy
-   * here would be a second truth. What leaves through `onFoldInput` **is** a
+   * here would be a second truth. **And to its task's sub-log in {@link TaskLog}**,
+   * by reference too (`RN-R13` v0.30, ADR 0121, W195) — here, the one place every
+   * element passes, so the view can never lag the log. What leaves through `onFoldInput` **is** a
    * copy, frozen, for the same reason `snapshot()` is: a listener holding the
    * driver's own array could forge a settlement and bypass `RS-R1`.
    */
   append(input) {
     const seq = this.inputs.push(input) - 1;
-    if (input.kind === "outcome" || input.kind === "resolution") this.log.push(input.record);
+    if (input.kind === "outcome" || input.kind === "resolution") {
+      this.log.push(input.record);
+      this.taskLog.push(input.record);
+    }
     const replay = this.replay;
     if (replay !== null && seq < replay.stored.length) {
       const same = isFed(input) ? replay.feeding === seq && input.kind === replay.stored[seq]?.kind : sameData(input, replay.stored[seq]);
@@ -5850,7 +5955,7 @@ var Driver = class {
    * the way in.
    */
   effectiveOutcomeOf(taskId) {
-    const o = effectiveOutcome(this.log, taskId);
+    const o = effectiveOutcome(this.taskLog.of(taskId), taskId);
     return o === null ? null : cloneRecord(o);
   }
   terminalStateOf(taskId) {
@@ -5858,6 +5963,484 @@ var Driver = class {
   }
 };
 
+// src/fold/accumulator.ts
+var Suspended = class {
+  items = [];
+  alive = /* @__PURE__ */ new Map();
+  gen = 0;
+  count;
+  constructor(from, count) {
+    this.count = count;
+    const g = ++this.gen;
+    for (const v of from) {
+      this.alive.set(v, g);
+      this.items.push({ v, g });
+    }
+    count(from.length);
+  }
+  has(v) {
+    return this.alive.has(v);
+  }
+  add(v) {
+    if (this.alive.has(v)) return;
+    const g = ++this.gen;
+    this.alive.set(v, g);
+    this.items.push({ v, g });
+  }
+  remove(v) {
+    this.alive.delete(v);
+  }
+  toArray() {
+    this.count(this.items.length);
+    const out = [];
+    for (const e of this.items) if (this.alive.get(e.v) === e.g) out.push(e.v);
+    return out;
+  }
+};
+function regionWeight(opened, joined) {
+  const unjoined = joined !== true ? 1 : 0;
+  return { unjoined, openedNothing: opened.length === 0 && joined !== true ? 1 : 0 };
+}
+var hasOwn2 = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+function put(o, k, v) {
+  if (k === "__proto__") Object.defineProperty(o, k, { value: v, writable: true, enumerable: true, configurable: true });
+  else o[k] = v;
+}
+var Accumulator = class _Accumulator {
+  runId;
+  outcome;
+  haltedBy;
+  cancelRequest;
+  interruption;
+  paused;
+  /** Entries written since the load, by task id, in first-write order. A task id not here reads through to the base. */
+  nodes = /* @__PURE__ */ new Map();
+  /** Instances touched since the load, by opener and then by the opener's branch path, in first-touch order. */
+  regions = /* @__PURE__ */ new Map();
+  pathEnds = [];
+  resumes = [];
+  gated = [];
+  counts = null;
+  base;
+  counter;
+  constructor(base, counter) {
+    this.base = base;
+    this.counter = counter;
+    this.runId = base.runId;
+    this.outcome = base.outcome;
+    this.haltedBy = base.haltedBy;
+    this.cancelRequest = base.cancelRequest;
+    this.interruption = base.interruption;
+    this.paused = base.paused;
+  }
+  /** An accumulator over `state`, which it reads and never mutates. `counter`, when given, is charged for its work. */
+  static load(state, counter) {
+    return new _Accumulator(state, counter);
+  }
+  tick(n = 1) {
+    if (this.counter !== void 0) this.counter.visits += n;
+  }
+  // --- the reads a runtime keeps an accumulator OPEN for — W196, ADR 0122, `RN-R44` -----------------------------
+  /**
+   * **The outcome as the last applied input left it** — what {@link materialise} would write into `outcome`, read in
+   * O(1). The runtime's `RunHandle.outcome()` and `done`'s predicate read this, never a materialisation (P39 prediction 4).
+   */
+  outcomeNow() {
+    return this.outcome;
+  }
+  /**
+   * **One task's entry, or `undefined`** — the object {@link materialise} would place at `nodes[taskId]`, read in O(1).
+   * An OWN entry only: a task id naming an `Object.prototype` member (`toString`, `__proto__`) is a task the run never
+   * dispatched, where `prev.nodes[taskId]` on a plain record would read the inherited member.
+   */
+  entry(taskId) {
+    if (this.nodes.has(taskId)) return this.nodes.get(taskId);
+    return hasOwn2(this.base.nodes, taskId) ? this.base.nodes[taskId] : void 0;
+  }
+  // --- reads, through to the base ---------------------------------------------------------------------------
+  /** `prev.nodes[taskId]` — the entry written since the load, else the base's own read, prototype and all. */
+  node(taskId) {
+    return this.nodes.has(taskId) ? this.nodes.get(taskId) : this.base.nodes[taskId];
+  }
+  /** `prev.regions[regionId]?.[regionPath]` — the touched instance, else the base's. */
+  instance(regionId, regionPath) {
+    const touched = this.regions.get(regionId)?.get(regionPath);
+    return touched ?? this.base.regions[regionId]?.[regionPath];
+  }
+  /** The counts, taken from everything the state holds on first need — O(the state), once per accumulator. */
+  tally() {
+    if (this.counts !== null) return this.counts;
+    const c = { byState: /* @__PURE__ */ new Map(), nodes: 0, unjoined: 0, openedNothing: 0, noEligibleEdge: 0, ends: 0, pathEnds: 0 };
+    const baseNodes = this.base.nodes;
+    const keys = Object.keys(baseNodes);
+    this.tick(keys.length);
+    for (const k of keys) if (!this.nodes.has(k)) this.countNode(c, baseNodes[k], 1);
+    for (const n of this.nodes.values()) this.countNode(c, n, 1);
+    this.tick(this.nodes.size);
+    const baseRegions = this.base.regions;
+    for (const id of Object.keys(baseRegions)) {
+      const byPath = baseRegions[id];
+      const touched = this.regions.get(id);
+      for (const p of Object.keys(byPath)) {
+        this.tick();
+        if (touched?.has(p)) continue;
+        const r = byPath[p];
+        const w = regionWeight(r.opened, r.joined);
+        c.unjoined += w.unjoined;
+        c.openedNothing += w.openedNothing;
+      }
+    }
+    for (const byPath of this.regions.values()) {
+      for (const acc of byPath.values()) {
+        this.tick();
+        const w = regionWeight(acc.opened, acc.joined);
+        c.unjoined += w.unjoined;
+        c.openedNothing += w.openedNothing;
+      }
+    }
+    for (const list of [this.base.pathEnds, this.pathEnds]) {
+      this.tick(list.length);
+      for (const e of list) {
+        c.pathEnds += 1;
+        if (e.reason === "no-eligible-edge") c.noEligibleEdge += 1;
+        if (e.reason === "end") c.ends += 1;
+      }
+    }
+    this.counts = c;
+    return c;
+  }
+  countNode(c, n, by) {
+    c.nodes += by;
+    c.byState.set(n.state, (c.byState.get(n.state) ?? 0) + by);
+  }
+  stateCount(state) {
+    return this.tally().byState.get(state) ?? 0;
+  }
+  // --- writes ------------------------------------------------------------------------------------------------
+  /** `nodes[taskId] = entry`, the counts kept. An entry is REPLACED, never mutated: a materialised state may hold the old one. */
+  setNode(taskId, entry) {
+    if (this.counts !== null) {
+      const own3 = this.nodes.has(taskId) || hasOwn2(this.base.nodes, taskId);
+      if (own3) this.countNode(this.counts, this.node(taskId), -1);
+      this.countNode(this.counts, entry, 1);
+    }
+    this.nodes.set(taskId, entry);
+    this.tick();
+  }
+  /**
+   * The instance at (`regionId`, `regionPath`) to write to — the touched one, else a COPY of the base's (O(its branch
+   * paths), once), else an empty one; with its share of the region counts taken out, for {@link settleRegion} to put back.
+   */
+  touchRegion(regionId, regionPath) {
+    let byPath = this.regions.get(regionId);
+    let acc = byPath?.get(regionPath);
+    if (acc === void 0) {
+      const at = this.base.regions[regionId]?.[regionPath];
+      if (at) {
+        this.tick(at.opened.length + Object.keys(at.settled).length);
+        acc = {
+          origin: at,
+          opened: [...at.opened],
+          openedSet: new Set(at.opened),
+          settled: new Map(Object.entries(at.settled)),
+          suspended: new Suspended(at.suspended, (n) => this.tick(n)),
+          joined: at.joined
+        };
+      } else {
+        acc = {
+          origin: { opened: [], settled: {}, suspended: [], joined: null },
+          opened: [],
+          openedSet: /* @__PURE__ */ new Set(),
+          settled: /* @__PURE__ */ new Map(),
+          suspended: new Suspended([], (n) => this.tick(n)),
+          joined: null
+        };
+      }
+      if (byPath === void 0) {
+        byPath = /* @__PURE__ */ new Map();
+        this.regions.set(regionId, byPath);
+      }
+      byPath.set(regionPath, acc);
+      const inner = this.base.regions[regionId];
+      if (this.counts !== null && at && inner !== void 0 && hasOwn2(this.base.regions, regionId) && hasOwn2(inner, regionPath)) {
+        this.unweigh(regionWeight(at.opened, at.joined));
+      }
+    } else if (this.counts !== null) {
+      this.unweigh(regionWeight(acc.opened, acc.joined));
+    }
+    this.tick();
+    return acc;
+  }
+  unweigh(w) {
+    this.counts.unjoined -= w.unjoined;
+    this.counts.openedNothing -= w.openedNothing;
+  }
+  /** The instance's share of the region counts put back after a write. */
+  settleRegion(acc) {
+    if (this.counts === null) return;
+    const w = regionWeight(acc.opened, acc.joined);
+    this.counts.unjoined += w.unjoined;
+    this.counts.openedNothing += w.openedNothing;
+  }
+  addPathEnd(e) {
+    this.pathEnds.push(e);
+    this.tick();
+    if (this.counts !== null) {
+      this.counts.pathEnds += 1;
+      if (e.reason === "no-eligible-edge") this.counts.noEligibleEdge += 1;
+      if (e.reason === "end") this.counts.ends += 1;
+    }
+  }
+  // --- the arms -------------------------------------------------------------------------------------------------
+  /**
+   * **Apply one input.** `true` when the arm moved the state — where `step` before W194 returned a NEW object — and
+   * `false` where it returned the state it was handed, so `step` can return that same object. Throws where
+   * that `step` threw: a malformed task id (`parseTaskId`), a kind it does not name (`input.record` undefined) — within
+   * the module header's stated limit on region paths.
+   */
+  apply(input) {
+    this.tick();
+    if (input.kind === "halted" || input.kind === "stopped") {
+      this.haltedBy = input.reason;
+      this.outcome = "halted";
+      return true;
+    }
+    if (input.kind === "cancelRequested") {
+      if (this.cancelRequest !== null || this.outcome === "cancelled") return false;
+      this.cancelRequest = { actor: input.actor, reason: input.reason };
+      return this.withOutcome();
+    }
+    if (input.kind === "interrupted") {
+      if (this.interruption !== null) return false;
+      this.interruption = { actor: input.actor, reason: input.reason };
+      return this.withOutcome();
+    }
+    if (input.kind === "paused" || input.kind === "unpaused") {
+      const paused = input.kind === "paused";
+      if (this.paused === paused) return false;
+      this.paused = paused;
+      return true;
+    }
+    if (input.kind === "region") {
+      this.applyRegion(input.event);
+      return this.withOutcome();
+    }
+    if (input.kind === "dispatched") {
+      const { runId: runId2, nodeId: nodeId2, branchPath: branchPath2, attempt: attempt2 } = parseTaskId(input.taskId);
+      if (this.node(input.taskId)) return false;
+      this.runId = this.runId ?? runId2;
+      this.setNode(input.taskId, {
+        runId: runId2,
+        nodeId: nodeId2,
+        branchPath: branchPath2,
+        flowAttempt: attempt2,
+        attemptNumber: null,
+        state: "running",
+        result: null,
+        error: null
+      });
+      return this.withOutcome();
+    }
+    if (input.kind === "asked") {
+      const { runId: runId2, nodeId: nodeId2, branchPath: branchPath2, attempt: attempt2 } = parseTaskId(input.taskId);
+      if (this.node(input.taskId)) return false;
+      this.runId = this.runId ?? runId2;
+      this.setNode(input.taskId, {
+        runId: runId2,
+        nodeId: nodeId2,
+        branchPath: branchPath2,
+        flowAttempt: attempt2,
+        attemptNumber: null,
+        state: "suspended",
+        result: null,
+        error: null,
+        input: structuredClone(input.input)
+      });
+      return this.withOutcome();
+    }
+    if (input.kind === "pathEnded") {
+      this.addPathEnd({ reason: input.reason, at: input.at });
+      return this.withOutcome();
+    }
+    if (input.kind === "regionEntered") {
+      if (this.instance(input.regionId, input.regionPath)) return false;
+      const acc = this.touchRegion(input.regionId, input.regionPath);
+      this.settleRegion(acc);
+      return this.withOutcome();
+    }
+    if (input.kind === "resumed") {
+      this.resumes.push([...input.taskIds]);
+      this.tick(input.taskIds.length + 1);
+      if (this.interruption !== null) {
+        this.interruption = null;
+        return this.withOutcome();
+      }
+      return true;
+    }
+    if (input.kind === "gated") {
+      const d = { gateId: input.gateId, branchPath: input.branchPath, route: input.route };
+      if (input.key !== void 0) d.key = structuredClone(input.key);
+      this.gated.push(d);
+      this.tick();
+      return true;
+    }
+    if (input.kind === "attempted") {
+      const node = this.node(input.taskId);
+      if (node === void 0) return false;
+      this.setNode(input.taskId, { ...node, attemptNumber: input.attemptNumber });
+      return true;
+    }
+    if (input.kind === "joinSettled") {
+      const acc = this.touchRegion(input.regionId, input.regionPath);
+      acc.joined = input.fired;
+      this.settleRegion(acc);
+      return this.withOutcome();
+    }
+    const r = input.record;
+    const { runId, nodeId, branchPath, attempt } = parseTaskId(r.taskId);
+    const existing = this.node(r.taskId);
+    const attemptNumber = existing?.attemptNumber ?? null;
+    if (r.kind === "outcome") {
+      this.setNode(r.taskId, {
+        runId,
+        nodeId,
+        branchPath,
+        flowAttempt: attempt,
+        attemptNumber,
+        // `user_action` is `suspended` at flow level: a resolution resumes it.
+        state: r.terminalState === "user_action" ? "suspended" : r.terminalState,
+        result: r.result,
+        error: r.error
+      });
+    } else {
+      this.setNode(r.taskId, {
+        runId: existing?.runId ?? runId,
+        nodeId: existing?.nodeId ?? nodeId,
+        branchPath: existing?.branchPath ?? branchPath,
+        flowAttempt: existing?.flowAttempt ?? attempt,
+        attemptNumber,
+        state: r.resolvedAs,
+        result: r.result,
+        error: r.error,
+        ...existing !== void 0 && "input" in existing ? { input: existing.input } : {}
+      });
+    }
+    this.runId = this.runId ?? runId;
+    return this.withOutcome();
+  }
+  applyRegion(e) {
+    const acc = this.touchRegion(e.regionId, e.regionPath);
+    switch (e.type) {
+      case "branch.opened":
+        if (!acc.openedSet.has(e.branchPath)) {
+          acc.opened.push(e.branchPath);
+          acc.openedSet.add(e.branchPath);
+        }
+        break;
+      case "branch.arrived":
+      case "branch.exited":
+      case "branch.lost": {
+        const how = e.type === "branch.arrived" ? "arrived" : e.type === "branch.exited" ? "exited" : "lost";
+        acc.settled.set(e.branchPath, how);
+        acc.suspended.remove(e.branchPath);
+        break;
+      }
+      case "branch.suspended":
+        acc.suspended.add(e.branchPath);
+        break;
+      case "branch.resumed":
+        acc.suspended.remove(e.branchPath);
+        break;
+    }
+    this.settleRegion(acc);
+  }
+  /**
+   * **Section 3's precedence, read off the counts** — `RN-R7`, `RN-R8`, `RN-R10`, `RN-R28`, `RN-R30` and `RN-R32` in the
+   * one order they have always had. Called by exactly the arms that recomputed before W194. Always `true`: an arm that
+   * recomputes has moved the state.
+   */
+  withOutcome() {
+    this.outcome = this.precedence();
+    return true;
+  }
+  precedence() {
+    if (this.haltedBy !== null) return "halted";
+    if (this.cancelRequest === null && this.stateCount("cancelled") > 0) return "cancelled";
+    if (this.cancelRequest !== null) return this.stateCount("running") > 0 ? "cancelling" : "cancelled";
+    if (this.interruption !== null) return "interrupted";
+    if (this.stateCount("suspended") > 0) return "awaiting_action";
+    if (this.stateCount("running") > 0) return "running";
+    const c = this.tally();
+    if (c.nodes === 0 && c.pathEnds === 0 && c.openedNothing === 0) return "running";
+    if (c.unjoined > 0) return "stuck";
+    if (c.noEligibleEdge > 0) return "failed";
+    if (c.ends > 0) return "completed";
+    if (this.stateCount("failed") > 0) return "failed";
+    return "completed";
+  }
+  // --- materialisation ------------------------------------------------------------------------------------------
+  /**
+   * **One plain `RunState`**, built from the base and what was written since the load: a record or list nothing wrote is
+   * the base's own object, and one that was written is a new one with the base's entries in their places and the new
+   * entries after them, in first-write order — the key order a spread-per-step produced. O(what it builds).
+   */
+  materialise() {
+    const b = this.base;
+    let nodes = b.nodes;
+    if (this.nodes.size > 0) {
+      nodes = { ...b.nodes };
+      this.tick(Object.keys(b.nodes).length);
+      for (const [k, n] of this.nodes) put(nodes, k, n);
+      this.tick(this.nodes.size);
+    }
+    let regions = b.regions;
+    if (this.regions.size > 0) {
+      regions = { ...b.regions };
+      this.tick(Object.keys(b.regions).length);
+      for (const [id, byPath] of this.regions) {
+        const inner = { ...b.regions[id] };
+        this.tick(Object.keys(inner).length);
+        for (const [p, acc] of byPath) put(inner, p, this.materialiseRegion(acc));
+        put(regions, id, inner);
+      }
+    }
+    return {
+      ...b,
+      runId: this.runId,
+      outcome: this.outcome,
+      nodes,
+      regions,
+      pathEnds: this.list(b.pathEnds, this.pathEnds),
+      haltedBy: this.haltedBy,
+      cancelRequest: this.cancelRequest,
+      interruption: this.interruption,
+      paused: this.paused,
+      resumes: this.list(b.resumes, this.resumes),
+      gated: this.list(b.gated, this.gated)
+    };
+  }
+  list(base, added) {
+    if (added.length === 0) return base;
+    this.tick(base.length + added.length);
+    return [...base, ...added];
+  }
+  materialiseRegion(acc) {
+    const settled = {};
+    for (const [k, v] of acc.settled) settled[k] = v;
+    this.tick(acc.opened.length + acc.settled.size + 1);
+    return { ...acc.origin, opened: [...acc.opened], settled, suspended: acc.suspended.toArray(), joined: acc.joined };
+  }
+};
+function foldWith(inputs, counter) {
+  const acc = Accumulator.load(emptyState(), counter);
+  for (const i of inputs) acc.apply(i);
+  return acc.materialise();
+}
+function stepWith(prev, input, counter) {
+  const acc = Accumulator.load(prev, counter);
+  return acc.apply(input) ? acc.materialise() : prev;
+}
+
 // src/fold/run-state.ts
 function emptyState() {
   return {
@@ -5875,181 +6458,10 @@ function emptyState() {
   };
 }
 function step(prev, input) {
-  if (input.kind === "halted" || input.kind === "stopped") {
-    return { ...prev, haltedBy: input.reason, outcome: "halted" };
-  }
-  if (input.kind === "cancelRequested") {
-    if (prev.cancelRequest !== null || prev.outcome === "cancelled") return prev;
-    return withOutcome({ ...prev, cancelRequest: { actor: input.actor, reason: input.reason } });
-  }
-  if (input.kind === "interrupted") {
-    if (prev.interruption !== null) return prev;
-    return withOutcome({ ...prev, interruption: { actor: input.actor, reason: input.reason } });
-  }
-  if (input.kind === "paused" || input.kind === "unpaused") {
-    const paused = input.kind === "paused";
-    if (prev.paused === paused) return prev;
-    return { ...prev, paused };
-  }
-  if (input.kind === "region") {
-    return withOutcome(applyRegion(prev, input.event));
-  }
-  if (input.kind === "dispatched") {
-    const { runId: runId2, nodeId: nodeId2, branchPath: branchPath2, attempt: attempt2 } = parseTaskId(input.taskId);
-    if (prev.nodes[input.taskId]) return prev;
-    return withOutcome({
-      ...prev,
-      runId: prev.runId ?? runId2,
-      nodes: {
-        ...prev.nodes,
-        [input.taskId]: { runId: runId2, nodeId: nodeId2, branchPath: branchPath2, flowAttempt: attempt2, attemptNumber: null, state: "running", result: null, error: null }
-      }
-    });
-  }
-  if (input.kind === "asked") {
-    const { runId: runId2, nodeId: nodeId2, branchPath: branchPath2, attempt: attempt2 } = parseTaskId(input.taskId);
-    if (prev.nodes[input.taskId]) return prev;
-    return withOutcome({
-      ...prev,
-      runId: prev.runId ?? runId2,
-      nodes: {
-        ...prev.nodes,
-        [input.taskId]: {
-          runId: runId2,
-          nodeId: nodeId2,
-          branchPath: branchPath2,
-          flowAttempt: attempt2,
-          attemptNumber: null,
-          state: "suspended",
-          result: null,
-          error: null,
-          input: structuredClone(input.input)
-        }
-      }
-    });
-  }
-  if (input.kind === "pathEnded") {
-    return withOutcome({ ...prev, pathEnds: [...prev.pathEnds, { reason: input.reason, at: input.at }] });
-  }
-  if (input.kind === "regionEntered") {
-    if (prev.regions[input.regionId]?.[input.regionPath]) return prev;
-    return withOutcome({
-      ...prev,
-      regions: withRegion(prev.regions, input.regionId, input.regionPath, emptyRegion())
-    });
-  }
-  if (input.kind === "resumed") {
-    const resumes = [...prev.resumes, [...input.taskIds]];
-    if (prev.interruption !== null) return withOutcome({ ...prev, interruption: null, resumes });
-    return { ...prev, resumes };
-  }
-  if (input.kind === "gated") {
-    const d = { gateId: input.gateId, branchPath: input.branchPath, route: input.route };
-    if (input.key !== void 0) d.key = structuredClone(input.key);
-    return { ...prev, gated: [...prev.gated, d] };
-  }
-  if (input.kind === "attempted") {
-    const node = prev.nodes[input.taskId];
-    if (node === void 0) return prev;
-    return { ...prev, nodes: { ...prev.nodes, [input.taskId]: { ...node, attemptNumber: input.attemptNumber } } };
-  }
-  if (input.kind === "joinSettled") {
-    const cur = prev.regions[input.regionId]?.[input.regionPath] ?? emptyRegion();
-    return withOutcome({
-      ...prev,
-      regions: withRegion(prev.regions, input.regionId, input.regionPath, { ...cur, joined: input.fired })
-    });
-  }
-  const r = input.record;
-  const { runId, nodeId, branchPath, attempt } = parseTaskId(r.taskId);
-  const nodes = { ...prev.nodes };
-  const existing = nodes[r.taskId];
-  const attemptNumber = existing?.attemptNumber ?? null;
-  if (r.kind === "outcome") {
-    nodes[r.taskId] = {
-      runId,
-      nodeId,
-      branchPath,
-      flowAttempt: attempt,
-      attemptNumber,
-      // `user_action` is `suspended` at flow level: a resolution resumes it, and
-      // calling it terminal is what makes a design drop the fifth state.
-      state: r.terminalState === "user_action" ? "suspended" : r.terminalState,
-      result: r.result,
-      error: r.error
-    };
-  } else {
-    nodes[r.taskId] = {
-      runId: existing?.runId ?? runId,
-      nodeId: existing?.nodeId ?? nodeId,
-      branchPath: existing?.branchPath ?? branchPath,
-      flowAttempt: existing?.flowAttempt ?? attempt,
-      attemptNumber,
-      state: r.resolvedAs,
-      result: r.result,
-      error: r.error,
-      ...existing !== void 0 && "input" in existing ? { input: existing.input } : {}
-    };
-  }
-  return withOutcome({ ...prev, runId: prev.runId ?? runId, nodes });
-}
-function emptyRegion() {
-  return { opened: [], settled: {}, suspended: [], joined: null };
-}
-function withRegion(regions, regionId, regionPath, run) {
-  return { ...regions, [regionId]: { ...regions[regionId], [regionPath]: run } };
-}
-function allRegionRuns(s) {
-  return Object.values(s.regions).flatMap((byPath) => Object.values(byPath));
-}
-function applyRegion(prev, e) {
-  const at = prev.regions[e.regionId]?.[e.regionPath];
-  const cur = at ? { ...at, opened: [...at.opened], settled: { ...at.settled }, suspended: [...at.suspended] } : emptyRegion();
-  switch (e.type) {
-    case "branch.opened":
-      if (!cur.opened.includes(e.branchPath)) cur.opened.push(e.branchPath);
-      break;
-    case "branch.arrived":
-    case "branch.exited":
-    case "branch.lost": {
-      const how = e.type === "branch.arrived" ? "arrived" : e.type === "branch.exited" ? "exited" : "lost";
-      cur.settled[e.branchPath] = how;
-      cur.suspended = cur.suspended.filter((b) => b !== e.branchPath);
-      break;
-    }
-    case "branch.suspended":
-      if (!cur.suspended.includes(e.branchPath)) cur.suspended.push(e.branchPath);
-      break;
-    case "branch.resumed":
-      cur.suspended = cur.suspended.filter((b) => b !== e.branchPath);
-      break;
-  }
-  return { ...prev, regions: withRegion(prev.regions, e.regionId, e.regionPath, cur) };
-}
-function withOutcome(s) {
-  if (s.haltedBy !== null) return { ...s, outcome: "halted" };
-  const nodes = Object.values(s.nodes);
-  if (s.cancelRequest === null && nodes.some((n) => n.state === "cancelled")) return { ...s, outcome: "cancelled" };
-  if (s.cancelRequest !== null) {
-    return { ...s, outcome: nodes.some((n) => n.state === "running") ? "cancelling" : "cancelled" };
-  }
-  if (s.interruption !== null) return { ...s, outcome: "interrupted" };
-  if (nodes.some((n) => n.state === "suspended")) return { ...s, outcome: "awaiting_action" };
-  if (nodes.some((n) => n.state === "running")) return { ...s, outcome: "running" };
-  const openedNothing = allRegionRuns(s).some((r) => r.opened.length === 0 && r.joined !== true);
-  if (nodes.length === 0 && s.pathEnds.length === 0 && !openedNothing) {
-    return { ...s, outcome: "running" };
-  }
-  if (allRegionRuns(s).some((r) => r.joined !== true)) return { ...s, outcome: "stuck" };
-  if (s.pathEnds.some((e) => e.reason === "no-eligible-edge")) return { ...s, outcome: "failed" };
-  if (s.pathEnds.some((e) => e.reason === "end")) return { ...s, outcome: "completed" };
-  if (nodes.some((n) => n.state === "failed")) return { ...s, outcome: "failed" };
-  return { ...s, outcome: "completed" };
+  return stepWith(prev, input);
 }
 function fold(inputs) {
-  let s = emptyState();
-  for (const i of inputs) s = step(s, i);
-  return s;
+  return foldWith(inputs);
 }
 function foldLog(log) {
   return fold(log.map((r) => ({ kind: r.kind, record: r })));
@@ -6264,6 +6676,7 @@ export {
   UndispatchedTask,
   MissingJoinPolicy,
   Driver,
+  Accumulator,
   emptyState,
   step,
   fold,