@graphrefly/graphrefly 0.22.0 → 0.24.0

package/dist/{meta-n3FoVWML.d.ts → meta-CnkLA_43.d.ts}

@@ -1,4 +1,4 @@
-import { v as NodeDescribeKind, N as Node, A as Actor } from './node-C5UD5MGq.js';
+import { v as NodeDescribeKind, N as Node, A as Actor } from './node-B-f-Lu-k.js';
 
 /**
  * JSON-shaped slice of a node for `Graph.describe()`

package/dist/{meta--fr9sxRM.d.cts → meta-DWbkoq1s.d.cts}

@@ -1,4 +1,4 @@
-import { v as NodeDescribeKind, N as Node, A as Actor } from './node-C5UD5MGq.cjs';
+import { v as NodeDescribeKind, N as Node, A as Actor } from './node-B-f-Lu-k.cjs';
 
 /**
  * JSON-shaped slice of a node for `Graph.describe()`

package/dist/{node-C5UD5MGq.d.cts → node-B-f-Lu-k.d.cts}

@@ -559,7 +559,11 @@ declare function accessHintForGuard(guard: NodeGuard): string;
  * contract. See SESSION-foundation-redesign.md §§1–10 for design history.
  */
 
-/** Lifecycle status of a node (GRAPHREFLY-SPEC §2.2). */
+/**
+ * Lifecycle status of a node.
+ *
+ * @see GRAPHREFLY-SPEC.md §2.2
+ */
 type NodeStatus = "sentinel" | "pending" | "dirty" | "settled" | "resolved" | "completed" | "errored";
 /** Callback that receives downstream message batches. */
 type NodeSink = (messages: Messages) => void;
@@ -843,6 +847,21 @@ declare class NodeImpl<T = unknown> implements Node<T> {
      * treats `0` as "wave settled" — O(1) check for full dep settlement.
      */
     _dirtyDepCount: number;
+    /**
+     * Inside an explicit `batch(() => ...)` scope, every `_emit` accumulates
+     * its already-framed messages here instead of dispatching synchronously.
+     * At batch end, `_flushBatchPending` runs (registered via
+     * `registerBatchFlushHook`) and delivers the whole accumulated batch as
+     * one `downWithBatch` call — collapsing what would otherwise be K
+     * separate sink invocations into one. This is the fix for the diamond
+     * fan-in K+1 over-fire.
+     *
+     * `null` outside batch (or after flush). Only ever appended to within
+     * a single explicit batch lifetime; reset to `null` on flush. State
+     * updates (cache, version, status) still happen per-emit via
+     * `_updateState` — only the downstream delivery is coalesced.
+     */
+    _batchPendingMessages: Message[] | null;
     /**
      * Set of active pause locks held against this node. Every `[PAUSE, lockId]`
      * adds its `lockId` to the set; every `[RESUME, lockId]` removes it.
@@ -1068,37 +1087,35 @@ declare class NodeImpl<T = unknown> implements Node<T> {
     private _frameBatch;
     /**
      * @internal The unified dispatch waist — one call = one wave.
+     * See `GRAPHREFLY-SPEC.md` §1.3.1 for protocol context — the stages
+     * below are the implementation order.
      *
      * Pipeline stages, in order:
      *
-     *   1. Early-return on empty batch.
-     *   2. Terminal filter — post-COMPLETE/ERROR only TEARDOWN/INVALIDATE
+     *   1. Terminal filter — post-COMPLETE/ERROR only TEARDOWN/INVALIDATE
      *      still propagate so graph teardown and cache-clear still work.
-     *   3. Tier sort (stable) — the batch can be in any order when it
+     *   2. Tier sort (stable) — the batch can be in any order when it
      *      arrives; the walker downstream (`downWithBatch`) assumes
      *      ascending tier monotone, and so does `_updateState`'s tier-3
      *      slice walk. This is the single source of truth for ordering.
-     *   4. Synthetic DIRTY prefix — if a tier-3 payload is present, no
+     *   3. Synthetic DIRTY prefix — if a tier-3 payload is present, no
      *      DIRTY is already in the batch, and the node isn't already in
      *      `"dirty"` status, prepend `[DIRTY]` after any tier-0 START
      *      entries. Guarantees spec §1.3.1 (DIRTY precedes DATA within
      *      the same batch) uniformly across every entry point.
-     *   5. PAUSE/RESUME lock bookkeeping (C0) — update `_pauseLocks`,
+     *   4. PAUSE/RESUME lock bookkeeping (C0) — update `_pauseLocks`,
      *      derive `_paused`, filter unknown-lockId RESUME, replay
      *      bufferAll buffer on final lock release.
-     *   6. Meta TEARDOWN fan-out — notify meta children before
+     *   5. Meta TEARDOWN fan-out — notify meta children before
      *      `_updateState`'s TEARDOWN branch calls `_deactivate`. Hoisted
      *      out of the walk to keep `_updateState` re-entrance-free.
-     *   7. `_updateState` — walk the batch in tier order, advancing
+     *   6. `_updateState` — walk the batch in tier order, advancing
      *      `_cached` / `_status` / `_versioning` and running equals
      *      substitution on tier-3 DATA (§3.5.1). Returns
      *      `{finalMessages, equalsError?}`.
-     *   8. `downWithBatch` dispatch (or bufferAll capture if paused with
+     *   7. `downWithBatch` dispatch (or bufferAll capture if paused with
      *      `pausable: "resumeAll"`).
-     *   9. Recursive ERROR emission if equals threw mid-walk.
-     *
-     * `node.down` / `node.emit` / `actions.down` / `actions.emit` all
-     * converge here — the unified `_emit` waist (spec §1.3.1).
+     *   8. Recursive ERROR emission if equals threw mid-walk.
      */
     _emit(messages: Messages): void;
     /**
@@ -1127,6 +1144,33 @@ declare class NodeImpl<T = unknown> implements Node<T> {
      */
     private _updateState;
     private _deliverToSinks;
+    /**
+     * @internal Dispatch entry point that respects the per-batch emit
+     * accumulator (Bug 2). Inside an explicit `batch()` scope, append to
+     * `_batchPendingMessages` and register a flush hook on first append.
+     * Outside batch — or during a drain (where `flushInProgress` is true
+     * but `batchDepth` is 0) — dispatch synchronously through `downWithBatch`.
+     *
+     * Per-emit state updates (`_frameBatch`, `_updateState`) have already
+     * happened by the time we reach here; only the **downstream delivery**
+     * is coalesced. Cache, version, and status are visible mid-batch on
+     * the emitting node itself.
+     */
+    private _dispatchOrAccumulate;
+    /**
+     * @internal Flushes the accumulated batch through `downWithBatch` and
+     * clears the pending state. Idempotent — safe to call when pending is
+     * already null or empty (e.g. on a `batch()` throw, where the hook
+     * fires for cleanup but the drainPhase queues are wiped after).
+     *
+     * Critical: the accumulated batch is interleaved per-emit framings like
+     * `[DIRTY, DATA(1), DIRTY, DATA(2)]` — non-monotone tier order. We must
+     * re-frame to sort by tier before handing to `downWithBatch`, which
+     * assumes pre-sorted input. `_frameBatch` also handles the synthetic
+     * DIRTY prepend rule (no-op here — `hasDirty` is true since each
+     * accumulated emit already carries its own DIRTY prefix).
+     */
+    private _flushBatchPending;
 }
 /**
  * Creates a reactive {@link Node} — the single GraphReFly primitive (§2).

package/dist/{node-C5UD5MGq.d.ts → node-B-f-Lu-k.d.ts}

@@ -559,7 +559,11 @@ declare function accessHintForGuard(guard: NodeGuard): string;
  * contract. See SESSION-foundation-redesign.md §§1–10 for design history.
  */
 
-/** Lifecycle status of a node (GRAPHREFLY-SPEC §2.2). */
+/**
+ * Lifecycle status of a node.
+ *
+ * @see GRAPHREFLY-SPEC.md §2.2
+ */
 type NodeStatus = "sentinel" | "pending" | "dirty" | "settled" | "resolved" | "completed" | "errored";
 /** Callback that receives downstream message batches. */
 type NodeSink = (messages: Messages) => void;
@@ -843,6 +847,21 @@ declare class NodeImpl<T = unknown> implements Node<T> {
      * treats `0` as "wave settled" — O(1) check for full dep settlement.
      */
     _dirtyDepCount: number;
+    /**
+     * Inside an explicit `batch(() => ...)` scope, every `_emit` accumulates
+     * its already-framed messages here instead of dispatching synchronously.
+     * At batch end, `_flushBatchPending` runs (registered via
+     * `registerBatchFlushHook`) and delivers the whole accumulated batch as
+     * one `downWithBatch` call — collapsing what would otherwise be K
+     * separate sink invocations into one. This is the fix for the diamond
+     * fan-in K+1 over-fire.
+     *
+     * `null` outside batch (or after flush). Only ever appended to within
+     * a single explicit batch lifetime; reset to `null` on flush. State
+     * updates (cache, version, status) still happen per-emit via
+     * `_updateState` — only the downstream delivery is coalesced.
+     */
+    _batchPendingMessages: Message[] | null;
     /**
      * Set of active pause locks held against this node. Every `[PAUSE, lockId]`
      * adds its `lockId` to the set; every `[RESUME, lockId]` removes it.
@@ -1068,37 +1087,35 @@ declare class NodeImpl<T = unknown> implements Node<T> {
     private _frameBatch;
     /**
      * @internal The unified dispatch waist — one call = one wave.
+     * See `GRAPHREFLY-SPEC.md` §1.3.1 for protocol context — the stages
+     * below are the implementation order.
      *
      * Pipeline stages, in order:
      *
-     *   1. Early-return on empty batch.
-     *   2. Terminal filter — post-COMPLETE/ERROR only TEARDOWN/INVALIDATE
+     *   1. Terminal filter — post-COMPLETE/ERROR only TEARDOWN/INVALIDATE
      *      still propagate so graph teardown and cache-clear still work.
-     *   3. Tier sort (stable) — the batch can be in any order when it
+     *   2. Tier sort (stable) — the batch can be in any order when it
      *      arrives; the walker downstream (`downWithBatch`) assumes
      *      ascending tier monotone, and so does `_updateState`'s tier-3
      *      slice walk. This is the single source of truth for ordering.
-     *   4. Synthetic DIRTY prefix — if a tier-3 payload is present, no
+     *   3. Synthetic DIRTY prefix — if a tier-3 payload is present, no
      *      DIRTY is already in the batch, and the node isn't already in
      *      `"dirty"` status, prepend `[DIRTY]` after any tier-0 START
      *      entries. Guarantees spec §1.3.1 (DIRTY precedes DATA within
      *      the same batch) uniformly across every entry point.
-     *   5. PAUSE/RESUME lock bookkeeping (C0) — update `_pauseLocks`,
+     *   4. PAUSE/RESUME lock bookkeeping (C0) — update `_pauseLocks`,
      *      derive `_paused`, filter unknown-lockId RESUME, replay
      *      bufferAll buffer on final lock release.
-     *   6. Meta TEARDOWN fan-out — notify meta children before
+     *   5. Meta TEARDOWN fan-out — notify meta children before
      *      `_updateState`'s TEARDOWN branch calls `_deactivate`. Hoisted
      *      out of the walk to keep `_updateState` re-entrance-free.
-     *   7. `_updateState` — walk the batch in tier order, advancing
+     *   6. `_updateState` — walk the batch in tier order, advancing
      *      `_cached` / `_status` / `_versioning` and running equals
      *      substitution on tier-3 DATA (§3.5.1). Returns
      *      `{finalMessages, equalsError?}`.
-     *   8. `downWithBatch` dispatch (or bufferAll capture if paused with
+     *   7. `downWithBatch` dispatch (or bufferAll capture if paused with
      *      `pausable: "resumeAll"`).
-     *   9. Recursive ERROR emission if equals threw mid-walk.
-     *
-     * `node.down` / `node.emit` / `actions.down` / `actions.emit` all
-     * converge here — the unified `_emit` waist (spec §1.3.1).
+     *   8. Recursive ERROR emission if equals threw mid-walk.
      */
     _emit(messages: Messages): void;
     /**
@@ -1127,6 +1144,33 @@ declare class NodeImpl<T = unknown> implements Node<T> {
      */
     private _updateState;
     private _deliverToSinks;
+    /**
+     * @internal Dispatch entry point that respects the per-batch emit
+     * accumulator (Bug 2). Inside an explicit `batch()` scope, append to
+     * `_batchPendingMessages` and register a flush hook on first append.
+     * Outside batch — or during a drain (where `flushInProgress` is true
+     * but `batchDepth` is 0) — dispatch synchronously through `downWithBatch`.
+     *
+     * Per-emit state updates (`_frameBatch`, `_updateState`) have already
+     * happened by the time we reach here; only the **downstream delivery**
+     * is coalesced. Cache, version, and status are visible mid-batch on
+     * the emitting node itself.
+     */
+    private _dispatchOrAccumulate;
+    /**
+     * @internal Flushes the accumulated batch through `downWithBatch` and
+     * clears the pending state. Idempotent — safe to call when pending is
+     * already null or empty (e.g. on a `batch()` throw, where the hook
+     * fires for cleanup but the drainPhase queues are wiped after).
+     *
+     * Critical: the accumulated batch is interleaved per-emit framings like
+     * `[DIRTY, DATA(1), DIRTY, DATA(2)]` — non-monotone tier order. We must
+     * re-frame to sort by tier before handing to `downWithBatch`, which
+     * assumes pre-sorted input. `_frameBatch` also handles the synthetic
+     * DIRTY prepend rule (no-op here — `hasDirty` is true since each
+     * accumulated emit already carries its own DIRTY prefix).
+     */
+    private _flushBatchPending;
 }
 /**
  * Creates a reactive {@link Node} — the single GraphReFly primitive (§2).

package/dist/{observable-DWydVy5b.d.cts → observable-DBnrwcar.d.cts}

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { N as Node, t as Messages } from './node-C5UD5MGq.cjs';
+import { N as Node, t as Messages } from './node-B-f-Lu-k.cjs';
 
 /** Options for {@link toObservable}. */
 type ToObservableOptions = {

package/dist/{observable-CQRBtEbq.d.ts → observable-uP-wy_uK.d.ts}

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { N as Node, t as Messages } from './node-C5UD5MGq.js';
+import { N as Node, t as Messages } from './node-B-f-Lu-k.js';
 
 /** Options for {@link toObservable}. */
 type ToObservableOptions = {