@graphrefly/graphrefly 0.21.0 → 0.23.0

package/dist/core/index.cjs

@@ -20,50 +20,53 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/core/index.ts
 var core_exports = {};
 __export(core_exports, {
-  CLEANUP_RESULT: () => CLEANUP_RESULT,
   COMPLETE: () => COMPLETE,
+  COMPLETE_MSG: () => COMPLETE_MSG,
+  COMPLETE_ONLY_BATCH: () => COMPLETE_ONLY_BATCH,
   DATA: () => DATA,
   DEFAULT_ACTOR: () => DEFAULT_ACTOR,
-  DEFAULT_DOWN: () => DEFAULT_DOWN,
   DIRTY: () => DIRTY,
-  DynamicNodeImpl: () => DynamicNodeImpl,
+  DIRTY_MSG: () => DIRTY_MSG,
+  DIRTY_ONLY_BATCH: () => DIRTY_ONLY_BATCH,
   ERROR: () => ERROR,
+  GraphReFlyConfig: () => GraphReFlyConfig,
   GuardDenied: () => GuardDenied,
   INVALIDATE: () => INVALIDATE,
+  INVALIDATE_MSG: () => INVALIDATE_MSG,
+  INVALIDATE_ONLY_BATCH: () => INVALIDATE_ONLY_BATCH,
+  NodeImpl: () => NodeImpl,
   PAUSE: () => PAUSE,
   RESOLVED: () => RESOLVED,
+  RESOLVED_MSG: () => RESOLVED_MSG,
+  RESOLVED_ONLY_BATCH: () => RESOLVED_ONLY_BATCH,
   RESUME: () => RESUME,
-  ResettableTimer: () => ResettableTimer,
   START: () => START,
+  START_MSG: () => START_MSG,
   TEARDOWN: () => TEARDOWN,
+  TEARDOWN_MSG: () => TEARDOWN_MSG,
+  TEARDOWN_ONLY_BATCH: () => TEARDOWN_ONLY_BATCH,
   accessHintForGuard: () => accessHintForGuard,
   advanceVersion: () => advanceVersion,
+  autoTrackNode: () => autoTrackNode,
   batch: () => batch,
-  bridge: () => bridge,
-  cleanupResult: () => cleanupResult,
+  configure: () => configure,
   createVersioning: () => createVersioning,
+  defaultConfig: () => defaultConfig,
   defaultHash: () => defaultHash,
   derived: () => derived,
   downWithBatch: () => downWithBatch,
   dynamicNode: () => dynamicNode,
   effect: () => effect,
   isBatching: () => isBatching,
-  isKnownMessageType: () => isKnownMessageType,
-  isLocalOnly: () => isLocalOnly,
-  isPhase2Message: () => isPhase2Message,
-  isTerminalMessage: () => isTerminalMessage,
   isV1: () => isV1,
-  knownMessageTypes: () => knownMessageTypes,
-  messageTier: () => messageTier,
   monotonicNs: () => monotonicNs,
   node: () => node,
   normalizeActor: () => normalizeActor,
-  partitionForBatch: () => partitionForBatch,
   pipe: () => pipe,
   policy: () => policy,
   policyFromRules: () => policyFromRules,
   producer: () => producer,
-  propagatesToMeta: () => propagatesToMeta,
+  registerBuiltins: () => registerBuiltins,
   resolveDescribeFields: () => resolveDescribeFields,
   state: () => state,
   wallClockNs: () => wallClockNs
@@ -82,66 +85,27 @@ function normalizeActor(actor) {
   };
 }
 
-// src/core/messages.ts
-var START = /* @__PURE__ */ Symbol.for("graphrefly/START");
-var DATA = /* @__PURE__ */ Symbol.for("graphrefly/DATA");
-var DIRTY = /* @__PURE__ */ Symbol.for("graphrefly/DIRTY");
-var RESOLVED = /* @__PURE__ */ Symbol.for("graphrefly/RESOLVED");
-var INVALIDATE = /* @__PURE__ */ Symbol.for("graphrefly/INVALIDATE");
-var PAUSE = /* @__PURE__ */ Symbol.for("graphrefly/PAUSE");
-var RESUME = /* @__PURE__ */ Symbol.for("graphrefly/RESUME");
-var TEARDOWN = /* @__PURE__ */ Symbol.for("graphrefly/TEARDOWN");
-var COMPLETE = /* @__PURE__ */ Symbol.for("graphrefly/COMPLETE");
-var ERROR = /* @__PURE__ */ Symbol.for("graphrefly/ERROR");
-var knownMessageTypes = [
-  START,
-  DATA,
-  DIRTY,
-  RESOLVED,
-  INVALIDATE,
-  PAUSE,
-  RESUME,
-  TEARDOWN,
-  COMPLETE,
-  ERROR
-];
-var knownMessageSet = new Set(knownMessageTypes);
-function isKnownMessageType(t) {
-  return knownMessageSet.has(t);
-}
-function messageTier(t) {
-  if (t === START) return 0;
-  if (t === DIRTY || t === INVALIDATE) return 1;
-  if (t === PAUSE || t === RESUME) return 2;
-  if (t === DATA || t === RESOLVED) return 3;
-  if (t === COMPLETE || t === ERROR) return 4;
-  if (t === TEARDOWN) return 5;
-  return 1;
-}
-function isPhase2Message(msg) {
-  const t = msg[0];
-  return t === DATA || t === RESOLVED;
-}
-function isTerminalMessage(t) {
-  return t === COMPLETE || t === ERROR;
-}
-function isLocalOnly(t) {
-  if (!knownMessageSet.has(t)) return false;
-  return messageTier(t) < 3;
-}
-function propagatesToMeta(t) {
-  return t === TEARDOWN;
-}
-
 // src/core/batch.ts
 var MAX_DRAIN_ITERATIONS = 1e3;
 var batchDepth = 0;
 var flushInProgress = false;
-var pendingPhase2 = [];
-var pendingPhase3 = [];
+var drainPhase2 = [];
+var drainPhase3 = [];
+var drainPhase4 = [];
+var flushHooks = [];
 function isBatching() {
   return batchDepth > 0 || flushInProgress;
 }
+function isExplicitlyBatching() {
+  return batchDepth > 0;
+}
+function registerBatchFlushHook(hook) {
+  if (batchDepth > 0) {
+    flushHooks.push(hook);
+  } else {
+    hook();
+  }
+}
 function batch(fn) {
   batchDepth += 1;
   let threw = false;
@@ -155,8 +119,16 @@ function batch(fn) {
     if (batchDepth === 0) {
       if (threw) {
         if (!flushInProgress) {
-          pendingPhase2.length = 0;
-          pendingPhase3.length = 0;
+          const hooks = flushHooks.splice(0);
+          for (const h of hooks) {
+            try {
+              h();
+            } catch {
+            }
+          }
+          drainPhase2.length = 0;
+          drainPhase3.length = 0;
+          drainPhase4.length = 0;
         }
       } else {
         drainPending();
@@ -166,147 +138,348 @@ function batch(fn) {
 }
 function drainPending() {
   const ownsFlush = !flushInProgress;
-  if (ownsFlush) {
-    flushInProgress = true;
-  }
+  if (ownsFlush) flushInProgress = true;
   const errors = [];
+  let iterations = 0;
   try {
-    let iterations = 0;
-    while (pendingPhase2.length > 0 || pendingPhase3.length > 0) {
-      while (pendingPhase2.length > 0) {
-        iterations += 1;
-        if (iterations > MAX_DRAIN_ITERATIONS) {
-          pendingPhase2.length = 0;
-          pendingPhase3.length = 0;
-          throw new Error(
-            `batch drain exceeded ${MAX_DRAIN_ITERATIONS} iterations \u2014 likely a reactive cycle`
-          );
-        }
-        const ops = pendingPhase2.splice(0);
-        for (const run of ops) {
+    while (drainPhase2.length > 0 || drainPhase3.length > 0 || drainPhase4.length > 0 || ownsFlush && flushHooks.length > 0) {
+      if (ownsFlush && flushHooks.length > 0) {
+        const hooks = flushHooks.splice(0);
+        for (const h of hooks) {
           try {
-            run();
+            h();
           } catch (e) {
             errors.push(e);
           }
         }
+        continue;
       }
-      if (pendingPhase3.length > 0) {
-        iterations += 1;
-        if (iterations > MAX_DRAIN_ITERATIONS) {
-          pendingPhase2.length = 0;
-          pendingPhase3.length = 0;
-          throw new Error(
-            `batch drain exceeded ${MAX_DRAIN_ITERATIONS} iterations \u2014 likely a reactive cycle`
-          );
-        }
-        const ops = pendingPhase3.splice(0);
-        for (const run of ops) {
-          try {
-            run();
-          } catch (e) {
-            errors.push(e);
-          }
+      iterations += 1;
+      if (iterations > MAX_DRAIN_ITERATIONS) {
+        drainPhase2.length = 0;
+        drainPhase3.length = 0;
+        drainPhase4.length = 0;
+        throw new Error(
+          `batch drain exceeded ${MAX_DRAIN_ITERATIONS} iterations \u2014 likely a reactive cycle`
+        );
+      }
+      const queue = drainPhase2.length > 0 ? drainPhase2 : drainPhase3.length > 0 ? drainPhase3 : drainPhase4;
+      const ops = queue.splice(0);
+      for (const run of ops) {
+        try {
+          run();
+        } catch (e) {
+          errors.push(e);
         }
       }
     }
   } finally {
-    if (ownsFlush) {
-      flushInProgress = false;
-    }
-  }
-  if (errors.length === 1) {
-    throw errors[0];
+    if (ownsFlush) flushInProgress = false;
   }
+  if (errors.length === 1) throw errors[0];
   if (errors.length > 1) {
     throw new AggregateError(errors, "batch drain: multiple callbacks threw");
   }
 }
-function partitionForBatch(messages) {
-  const immediate = [];
-  const deferred = [];
-  const terminal = [];
-  for (const m of messages) {
-    if (isPhase2Message(m)) {
-      deferred.push(m);
-    } else if (isTerminalMessage(m[0])) {
-      terminal.push(m);
-    } else {
-      immediate.push(m);
-    }
-  }
-  return { immediate, deferred, terminal };
-}
-function downWithBatch(sink, messages, phase = 2, options) {
-  if (messages.length === 0) {
-    return;
-  }
-  if (options?.strategy === "sequential") {
-    _downSequential(sink, messages, phase);
-    return;
-  }
-  const queue = phase === 3 ? pendingPhase3 : pendingPhase2;
+function downWithBatch(sink, messages, tierOf) {
+  if (messages.length === 0) return;
   if (messages.length === 1) {
-    const t = messages[0][0];
-    if (t === DATA || t === RESOLVED) {
-      if (isBatching()) {
-        queue.push(() => sink(messages));
-      } else {
-        sink(messages);
-      }
-    } else if (isTerminalMessage(t)) {
-      if (isBatching()) {
-        queue.push(() => sink(messages));
-      } else {
-        sink(messages);
-      }
-    } else {
+    const tier = tierOf(messages[0][0]);
+    if (tier < 3 || !isBatching()) {
       sink(messages);
+      return;
     }
+    const queue = tier >= 5 ? drainPhase4 : tier === 4 ? drainPhase3 : drainPhase2;
+    queue.push(() => sink(messages));
     return;
   }
-  const { immediate, deferred, terminal } = partitionForBatch(messages);
-  if (immediate.length > 0) {
+  const n = messages.length;
+  let phase2Start = n;
+  let phase3Start = n;
+  let phase4Start = n;
+  let i = 0;
+  while (i < n && tierOf(messages[i][0]) < 3) i++;
+  phase2Start = i;
+  while (i < n && tierOf(messages[i][0]) === 3) i++;
+  phase3Start = i;
+  while (i < n && tierOf(messages[i][0]) === 4) i++;
+  phase4Start = i;
+  const batching = isBatching();
+  if (phase2Start > 0) {
+    const immediate = messages.slice(0, phase2Start);
     sink(immediate);
   }
-  if (isBatching()) {
-    if (deferred.length > 0) {
-      queue.push(() => sink(deferred));
-    }
-    if (terminal.length > 0) {
-      queue.push(() => sink(terminal));
-    }
-  } else {
-    if (deferred.length > 0) {
-      sink(deferred);
-    }
-    if (terminal.length > 0) {
-      sink(terminal);
-    }
+  if (phase3Start > phase2Start) {
+    const phase2 = messages.slice(phase2Start, phase3Start);
+    if (batching) drainPhase2.push(() => sink(phase2));
+    else sink(phase2);
+  }
+  if (phase4Start > phase3Start) {
+    const phase3 = messages.slice(phase3Start, phase4Start);
+    if (batching) drainPhase3.push(() => sink(phase3));
+    else sink(phase3);
+  }
+  if (n > phase4Start) {
+    const phase4 = messages.slice(phase4Start, n);
+    if (batching) drainPhase4.push(() => sink(phase4));
+    else sink(phase4);
   }
 }
-function _downSequential(sink, messages, phase = 2) {
-  const dataQueue = phase === 3 ? pendingPhase3 : pendingPhase2;
-  for (const msg of messages) {
-    const tier = messageTier(msg[0]);
-    if (tier === 3) {
-      if (isBatching()) {
-        const m = msg;
-        dataQueue.push(() => sink([m]));
-      } else {
-        sink([msg]);
-      }
-    } else if (tier >= 4) {
-      if (isBatching()) {
-        const m = msg;
-        pendingPhase3.push(() => sink([m]));
-      } else {
-        sink([msg]);
-      }
-    } else {
-      sink([msg]);
+
+// src/core/clock.ts
+function monotonicNs() {
+  return Math.trunc(performance.now() * 1e6);
+}
+function wallClockNs() {
+  return Date.now() * 1e6;
+}
+
+// src/core/messages.ts
+var START = /* @__PURE__ */ Symbol.for("graphrefly/START");
+var DATA = /* @__PURE__ */ Symbol.for("graphrefly/DATA");
+var DIRTY = /* @__PURE__ */ Symbol.for("graphrefly/DIRTY");
+var RESOLVED = /* @__PURE__ */ Symbol.for("graphrefly/RESOLVED");
+var INVALIDATE = /* @__PURE__ */ Symbol.for("graphrefly/INVALIDATE");
+var PAUSE = /* @__PURE__ */ Symbol.for("graphrefly/PAUSE");
+var RESUME = /* @__PURE__ */ Symbol.for("graphrefly/RESUME");
+var TEARDOWN = /* @__PURE__ */ Symbol.for("graphrefly/TEARDOWN");
+var COMPLETE = /* @__PURE__ */ Symbol.for("graphrefly/COMPLETE");
+var ERROR = /* @__PURE__ */ Symbol.for("graphrefly/ERROR");
+var DIRTY_MSG = Object.freeze([DIRTY]);
+var RESOLVED_MSG = Object.freeze([RESOLVED]);
+var INVALIDATE_MSG = Object.freeze([INVALIDATE]);
+var START_MSG = Object.freeze([START]);
+var COMPLETE_MSG = Object.freeze([COMPLETE]);
+var TEARDOWN_MSG = Object.freeze([TEARDOWN]);
+var DIRTY_ONLY_BATCH = Object.freeze([DIRTY_MSG]);
+var RESOLVED_ONLY_BATCH = Object.freeze([RESOLVED_MSG]);
+var INVALIDATE_ONLY_BATCH = Object.freeze([INVALIDATE_MSG]);
+var COMPLETE_ONLY_BATCH = Object.freeze([COMPLETE_MSG]);
+var TEARDOWN_ONLY_BATCH = Object.freeze([TEARDOWN_MSG]);
+
+// src/core/config.ts
+var GraphReFlyConfig = class {
+  _messageTypes = /* @__PURE__ */ new Map();
+  _codecs = /* @__PURE__ */ new Map();
+  _onMessage;
+  _onSubscribe;
+  _defaultVersioning;
+  _defaultHashFn;
+  _inspectorEnabled = !(typeof process !== "undefined" && process.env?.NODE_ENV === "production");
+  _globalInspector;
+  _frozen = false;
+  /**
+   * Pre-bound tier lookup — shared by every node bound to this config. Since
+   * the registry is frozen on first hook access, this closure can be built
+   * once in the constructor and handed directly to `downWithBatch` /
+   * `_frameBatch` paths without per-node or per-emission `.bind(config)`
+   * allocation.
+   */
+  tierOf;
+  constructor(init) {
+    this._onMessage = init.onMessage;
+    this._onSubscribe = init.onSubscribe;
+    this._defaultVersioning = init.defaultVersioning;
+    this._defaultHashFn = init.defaultHashFn;
+    this.tierOf = (t) => {
+      const reg = this._messageTypes.get(t);
+      return reg != null ? reg.tier : 1;
+    };
+  }
+  // --- Hook getters (freeze on read) ---
+  get onMessage() {
+    this._frozen = true;
+    return this._onMessage;
+  }
+  get onSubscribe() {
+    this._frozen = true;
+    return this._onSubscribe;
+  }
+  // --- Hook setters (throw when frozen) ---
+  set onMessage(v) {
+    this._assertUnfrozen();
+    this._onMessage = v;
+  }
+  set onSubscribe(v) {
+    this._assertUnfrozen();
+    this._onSubscribe = v;
+  }
+  /**
+   * Default versioning level applied to every node bound to this config,
+   * unless the node's own `opts.versioning` provides an explicit override.
+   * Setting this is only allowed before the config freezes (i.e., before
+   * the first node is created) so every node in the graph sees a
+   * consistent starting level. Individual nodes can still opt into a
+   * higher level via `opts.versioning`, or post-hoc via
+   * `NodeImpl._applyVersioning(level)` when the node is quiescent.
+   *
+   * v0 is the minimum opt-in — unversioned nodes (`undefined`) skip
+   * the version counter entirely. v1 adds content-addressed cid.
+   * Future levels (v2, v3) are reserved for linked-history and
+   * cryptographic attestation extensions.
+   */
+  get defaultVersioning() {
+    return this._defaultVersioning;
+  }
+  set defaultVersioning(v) {
+    this._assertUnfrozen();
+    this._defaultVersioning = v;
+  }
+  /**
+   * Default content-hash function applied to every versioned node bound
+   * to this config, unless the node's own `opts.versioningHash` provides
+   * an explicit override. Use this when a graph needs a non-default hash
+   * — e.g., swap the vendored sync SHA-256 for a faster non-crypto hash
+   * (xxHash, FNV-1a) in hot-path workloads, or a stronger hash when
+   * versioning v1 cids are used as audit anchors.
+   *
+   * Only settable before the config freezes. Individual nodes can still
+   * override via `opts.versioningHash`.
+   */
+  get defaultHashFn() {
+    return this._defaultHashFn;
+  }
+  set defaultHashFn(v) {
+    this._assertUnfrozen();
+    this._defaultHashFn = v;
+  }
+  /**
+   * When `false`, structured observation options (`causal`, `timeline`)
+   * and `Graph.trace()` writes are no-ops. Raw `Graph.observe()` always
+   * works. Default: `true` outside production (`NODE_ENV !== "production"`).
+   *
+   * Settable at any time — inspector gating is an operational concern, not
+   * a protocol invariant, so it does NOT require freeze before node creation.
+   */
+  get inspectorEnabled() {
+    return this._inspectorEnabled;
+  }
+  set inspectorEnabled(v) {
+    this._inspectorEnabled = v;
+  }
+  /**
+   * Process-global observability hook (Redux-DevTools-style full-graph
+   * tracer). Fires once per outgoing batch from every node bound to this
+   * config, gated by {@link inspectorEnabled}. See {@link GlobalInspectorHook}.
+   *
+   * Settable at any time — like {@link inspectorEnabled} this is operational,
+   * not protocol-shaping, so it does NOT trigger config freeze.
+   */
+  get globalInspector() {
+    return this._globalInspector;
+  }
+  set globalInspector(v) {
+    this._globalInspector = v;
+  }
+  // --- Registry (writes require unfrozen; reads are free lookups) ---
+  /**
+   * Register a custom message type. Must be called before any node that
+   * uses this config has been created — otherwise throws. Default
+   * `wireCrossing` is `tier >= 3`.
+   */
+  registerMessageType(t, input) {
+    this._assertUnfrozen();
+    this._messageTypes.set(t, {
+      tier: input.tier,
+      wireCrossing: input.wireCrossing ?? input.tier >= 3,
+      metaPassthrough: input.metaPassthrough ?? true
+    });
+    return this;
+  }
+  /** Tier for `t`. Unknown types default to tier 1 (immediate, after START). */
+  messageTier(t) {
+    const reg = this._messageTypes.get(t);
+    return reg != null ? reg.tier : 1;
+  }
+  /**
+   * Whether `t` is registered as wire-crossing. Unknown types default to
+   * `true` (spec §1.3.6 forward-compat — unknowns cross the wire).
+   */
+  isWireCrossing(t) {
+    const reg = this._messageTypes.get(t);
+    return reg != null ? reg.wireCrossing : true;
+  }
+  /** Convenience inverse of {@link isWireCrossing}. */
+  isLocalOnly(t) {
+    return !this.isWireCrossing(t);
+  }
+  /**
+   * Whether `t` is forwarded to meta companions by `Graph.signal`. Defaults
+   * to `true` for unknowns (forward-compat — new types pass through meta by
+   * default; opt-in filter via `registerMessageType({metaPassthrough: false})`).
+   */
+  isMetaPassthrough(t) {
+    const reg = this._messageTypes.get(t);
+    return reg != null ? reg.metaPassthrough : true;
+  }
+  /** Whether `t` is a registered (built-in or custom) type. */
+  isKnownMessageType(t) {
+    return this._messageTypes.has(t);
+  }
+  // --- Codec registry (writes require unfrozen; reads are free lookups) ---
+  /**
+   * Register a graph codec by `codec.name`. Used by the envelope-based
+   * `graph.snapshot({format: "bytes", codec: name})` path and
+   * `Graph.decode(bytes)` auto-dispatch. Must be called before any node
+   * bound to this config is created — otherwise throws.
+   *
+   * Re-registering the same name overwrites, so user codecs can shadow
+   * built-in ones before freeze (e.g., to swap a zstd-wrapped dag-cbor in
+   * for `"dag-cbor"`).
+   */
+  registerCodec(codec) {
+    this._assertUnfrozen();
+    this._codecs.set(codec.name, codec);
+    return this;
+  }
+  /**
+   * Resolve a registered codec by name. Returns `undefined` for unknown
+   * names. Typed callers cast to their concrete codec interface (e.g.,
+   * `config.lookupCodec<GraphCodec>("json")`) — this method stays
+   * layer-pure (no import of graph-layer types into `core/`).
+   */
+  lookupCodec(name) {
+    return this._codecs.get(name);
+  }
+  /** @internal Used by tests and dev tooling — check freeze state without triggering it. */
+  _isFrozen() {
+    return this._frozen;
+  }
+  _assertUnfrozen() {
+    if (this._frozen) {
+      throw new Error(
+        "GraphReFlyConfig is frozen: a node has already captured this config. Register custom types and set hooks before creating any node."
+      );
     }
   }
+};
+function registerBuiltins(cfg) {
+  cfg.registerMessageType(START, { tier: 0, wireCrossing: false });
+  cfg.registerMessageType(DIRTY, { tier: 1, wireCrossing: false });
+  cfg.registerMessageType(INVALIDATE, {
+    tier: 1,
+    wireCrossing: false,
+    metaPassthrough: false
+  });
+  cfg.registerMessageType(PAUSE, { tier: 2, wireCrossing: false });
+  cfg.registerMessageType(RESUME, { tier: 2, wireCrossing: false });
+  cfg.registerMessageType(DATA, { tier: 3, wireCrossing: true });
+  cfg.registerMessageType(RESOLVED, { tier: 3, wireCrossing: true });
+  cfg.registerMessageType(COMPLETE, {
+    tier: 4,
+    wireCrossing: true,
+    metaPassthrough: false
+  });
+  cfg.registerMessageType(ERROR, {
+    tier: 4,
+    wireCrossing: true,
+    metaPassthrough: false
+  });
+  cfg.registerMessageType(TEARDOWN, {
+    tier: 5,
+    wireCrossing: true,
+    metaPassthrough: false
+  });
 }
 
 // src/core/guard.ts
@@ -407,16 +580,25 @@ function accessHintForGuard(guard) {
   return allowed.join("+");
 }
 
-// src/core/clock.ts
-function monotonicNs() {
-  return Math.trunc(performance.now() * 1e6);
-}
-function wallClockNs() {
-  return Date.now() * 1e6;
+// src/graph/codec.ts
+var JsonCodec = {
+  name: "json",
+  version: 1,
+  contentType: "application/json",
+  encode(snapshot) {
+    const json = JSON.stringify(snapshot);
+    return new TextEncoder().encode(json);
+  },
+  decode(buffer, _codecVersion) {
+    const json = new TextDecoder().decode(buffer);
+    return JSON.parse(json);
+  }
+};
+function registerBuiltinCodecs(config) {
+  config.registerCodec(JsonCodec);
 }
 
 // src/core/versioning.ts
-var import_node_crypto = require("crypto");
 function canonicalizeForHash(value) {
   if (value === void 0) return null;
   if (typeof value === "number") {
@@ -445,13 +627,153 @@ function canonicalizeForHash(value) {
   }
   return null;
 }
+var SHA256_K = /* @__PURE__ */ new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var UTF8_ENCODER = /* @__PURE__ */ new TextEncoder();
+function sha256Hex(msg) {
+  const bytes = UTF8_ENCODER.encode(msg);
+  const msgLen = bytes.length;
+  const bitLen = msgLen * 8;
+  const totalLen = msgLen + 9 + 63 & ~63;
+  const padded = new Uint8Array(totalLen);
+  padded.set(bytes);
+  padded[msgLen] = 128;
+  const dv = new DataView(padded.buffer);
+  dv.setUint32(totalLen - 4, bitLen >>> 0, false);
+  dv.setUint32(totalLen - 8, Math.floor(bitLen / 4294967296) >>> 0, false);
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const W = new Uint32Array(64);
+  const rotr = (x, n) => x >>> n | x << 32 - n;
+  for (let off = 0; off < totalLen; off += 64) {
+    for (let i = 0; i < 16; i++) W[i] = dv.getUint32(off + i * 4, false);
+    for (let i = 16; i < 64; i++) {
+      const w15 = W[i - 15];
+      const w2 = W[i - 2];
+      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+      W[i] = W[i - 16] + s0 + W[i - 7] + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const t1 = h + S1 + ch + SHA256_K[i] + W[i] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const mj = a & b ^ a & c ^ b & c;
+      const t2 = S0 + mj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  const toHex = (x) => x.toString(16).padStart(8, "0");
+  return toHex(h0) + toHex(h1) + toHex(h2) + toHex(h3) + toHex(h4) + toHex(h5) + toHex(h6) + toHex(h7);
+}
 function defaultHash(value) {
   const canonical = canonicalizeForHash(value ?? null);
   const json = JSON.stringify(canonical);
-  return (0, import_node_crypto.createHash)("sha256").update(json).digest("hex").slice(0, 16);
+  return sha256Hex(json).slice(0, 16);
+}
+function randomUuid() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  const r = () => Math.floor(Math.random() * 4294967296).toString(16).padStart(8, "0");
+  const hex = r() + r() + r() + r();
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-${(parseInt(hex.slice(16, 17), 16) & 3 | 8).toString(16)}${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
 }
 function createVersioning(level, initialValue, opts) {
-  const id = opts?.id ?? (0, import_node_crypto.randomUUID)();
+  const id = opts?.id ?? randomUuid();
   if (level === 0) {
     return { id, version: 0 };
   }
@@ -470,288 +792,418 @@ function isV1(info) {
   return "cid" in info;
 }
 
-// src/core/node-base.ts
-var NO_VALUE = /* @__PURE__ */ Symbol.for("graphrefly/NO_VALUE");
-var CLEANUP_RESULT = /* @__PURE__ */ Symbol.for("graphrefly/CLEANUP_RESULT");
-function cleanupResult(cleanup, ...args) {
-  const r = { [CLEANUP_RESULT]: true, cleanup };
-  if (args.length > 0) r.value = args[0];
-  return r;
-}
-var isCleanupResult = (value) => typeof value === "object" && value !== null && CLEANUP_RESULT in value;
-var isCleanupFn = (value) => typeof value === "function";
-function statusAfterMessage(status, msg) {
-  const t = msg[0];
-  if (t === DIRTY) return "dirty";
-  if (t === DATA) return "settled";
-  if (t === RESOLVED) return "resolved";
-  if (t === COMPLETE) return "completed";
-  if (t === ERROR) return "errored";
-  if (t === INVALIDATE) return "dirty";
-  if (t === TEARDOWN) return "disconnected";
-  return status;
-}
-function createIntBitSet(size) {
-  const fullMask = size >= 32 ? -1 : ~(-1 << size);
-  let bits = 0;
+// src/core/node.ts
+var noopUnsub = () => {
+};
+var MAX_RERUN_DEPTH = 100;
+function createDepRecord(n) {
   return {
-    set(i) {
-      bits |= 1 << i;
-    },
-    clear(i) {
-      bits &= ~(1 << i);
-    },
-    has(i) {
-      return (bits & 1 << i) !== 0;
-    },
-    covers(other) {
-      const otherBits = other._bits();
-      return (bits & otherBits) === otherBits;
-    },
-    any() {
-      return bits !== 0;
-    },
-    reset() {
-      bits = 0;
-    },
-    setAll() {
-      bits = fullMask;
-    },
-    _bits() {
-      return bits;
-    }
+    node: n,
+    unsub: null,
+    prevData: void 0,
+    dirty: false,
+    involvedThisWave: false,
+    dataBatch: [],
+    terminal: void 0
   };
 }
-function createArrayBitSet(size) {
-  const words = new Uint32Array(Math.ceil(size / 32));
-  const lastBits = size % 32;
-  const lastWordMask = lastBits === 0 ? 4294967295 : (1 << lastBits) - 1 >>> 0;
-  return {
-    set(i) {
-      words[i >>> 5] |= 1 << (i & 31);
-    },
-    clear(i) {
-      words[i >>> 5] &= ~(1 << (i & 31));
-    },
-    has(i) {
-      return (words[i >>> 5] & 1 << (i & 31)) !== 0;
-    },
-    covers(other) {
-      const ow = other._words;
-      for (let w = 0; w < words.length; w++) {
-        if ((words[w] & ow[w]) >>> 0 !== ow[w]) return false;
-      }
-      return true;
-    },
-    any() {
-      for (let w = 0; w < words.length; w++) {
-        if (words[w] !== 0) return true;
-      }
-      return false;
-    },
-    reset() {
-      words.fill(0);
-    },
-    setAll() {
-      for (let w = 0; w < words.length - 1; w++) words[w] = 4294967295;
-      if (words.length > 0) words[words.length - 1] = lastWordMask;
-    },
-    _words: words
-  };
+function resetDepRecord(d) {
+  d.prevData = void 0;
+  d.dirty = false;
+  d.involvedThisWave = false;
+  d.dataBatch.length = 0;
+  d.terminal = void 0;
+}
+function normalizeMessages(input) {
+  if (input.length === 0) return input;
+  return typeof input[0] === "symbol" ? [input] : input;
 }
-function createBitSet(size) {
-  return size <= 31 ? createIntBitSet(size) : createArrayBitSet(size);
+var defaultOnMessage = (node2, msg, ctx, _actions) => {
+  if (ctx.direction === "down-in") {
+    node2._onDepMessage(ctx.depIndex, msg);
+  }
+  return void 0;
+};
+var defaultOnSubscribe = (node2, sink, _ctx, _actions) => {
+  const impl = node2;
+  if (impl._status === "completed" || impl._status === "errored") return;
+  const cached = impl._cached;
+  const initial = cached === void 0 ? [START_MSG] : [START_MSG, [DATA, cached]];
+  if (impl._status === "dirty") initial.push(DIRTY_MSG);
+  downWithBatch(sink, initial, impl._config.tierOf);
+};
+var defaultConfig = new GraphReFlyConfig({
+  onMessage: defaultOnMessage,
+  onSubscribe: defaultOnSubscribe
+});
+registerBuiltins(defaultConfig);
+registerBuiltinCodecs(defaultConfig);
+function configure(fn) {
+  if (defaultConfig._isFrozen()) {
+    throw new Error(
+      "configure() called after a node was created \u2014 the default GraphReFlyConfig is frozen. Call configure(...) at application startup, before any node factories run."
+    );
+  }
+  fn(defaultConfig);
 }
-var NodeBase = class {
-  // --- Identity (set once) ---
+var NodeImpl = class _NodeImpl {
+  // --- Identity ---
   _optsName;
-  _registryName;
-  /** @internal Read by `describeNode` before inference. */
   _describeKind;
   meta;
-  // --- Options ---
+  /**
+   * Cached `Object.keys(meta).length > 0` check. `meta` is frozen at
+   * construction so this boolean never flips. Used by `_emit` to skip
+   * the meta TEARDOWN fan-out block allocation on the common "no meta"
+   * hot path.
+   */
+  _hasMeta;
+  // --- Config ---
+  _config;
+  // --- Topology ---
+  /** Mutable for autoTrackNode / Graph.connect() post-construction dep addition. */
+  _deps;
+  _sinks = null;
+  _sinkCount = 0;
+  // --- State ---
+  _cached;
+  _status;
+  _cleanup;
+  _store = {};
+  _waveHasNewData = false;
+  _hasNewTerminal = false;
+  _hasCalledFnOnce = false;
+  _paused = false;
+  _pendingWave = false;
+  _isExecutingFn = false;
+  _pendingRerun = false;
+  _rerunDepth = 0;
+  // --- Settlement counter (A3) ---
+  /**
+   * Count of deps currently in `dirty === true`. `_maybeRunFnOnSettlement`
+   * treats `0` as "wave settled" — O(1) check for full dep settlement.
+   */
+  _dirtyDepCount = 0;
+  // --- Per-batch emit accumulator (Bug 2: K+1 fan-in fix) ---
+  /**
+   * 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 = null;
+  // --- PAUSE/RESUME lock tracking (C0) ---
+  /**
+   * Set of active pause locks held against this node. Every `[PAUSE, lockId]`
+   * adds its `lockId` to the set; every `[RESUME, lockId]` removes it.
+   * `_paused` is a derived quantity: `_pauseLocks.size > 0`. Multi-pauser
+   * correctness — one controller releasing its lock does NOT resume the
+   * node while another controller still holds its lock.
+   */
+  _pauseLocks = null;
+  /**
+   * Buffered DATA messages held while paused. Only populated when
+   * `_pausable === "resumeAll"` (bufferAll mode). On final lock release
+   * the buffer is replayed through the node's outgoing pipeline in the
+   * order received. Non-bufferAll pause mode drops DATA on the floor
+   * (upstream is expected to honor PAUSE by suppressing production).
+   */
+  _pauseBuffer = null;
+  // --- Options (frozen at construction) ---
+  _fn;
   _equals;
   _resubscribable;
   _resetOnTeardown;
-  _onResubscribe;
-  _onMessage;
-  /** @internal Read by `describeNode` for `accessHintForGuard`. */
+  _autoComplete;
+  _autoError;
+  _pausable;
   _guard;
-  /** @internal Subclasses update this through {@link _recordMutation}. */
-  _lastMutation;
-  // --- Versioning ---
   _hashFn;
   _versioning;
-  // --- Lifecycle state ---
-  /** @internal Read by `describeNode` and `graph.ts`. */
-  _cached;
-  /** @internal Read externally via `get status()`. */
-  _status;
-  _terminal = false;
-  _active = false;
-  // --- Sink storage ---
-  /** @internal Read by `graph/profile.ts` for subscriber counts. */
-  _sinkCount = 0;
-  _singleDepSinkCount = 0;
-  _singleDepSinks = /* @__PURE__ */ new WeakSet();
-  _sinks = null;
-  // --- Actions + bound helpers ---
+  /**
+   * Explicit versioning level, tracked separately from `_versioning` so
+   * monotonicity checks and future v2/v3 extensions don't rely on the
+   * fragile `"cid" in _versioning` shape discriminator. `undefined` means
+   * the node has no versioning attached; `0` / `1` / future levels name
+   * the tier. Mutated in lockstep with `_versioning` by the constructor
+   * and by `_applyVersioning`.
+   */
+  _versioningLevel;
+  // --- ABAC ---
+  _lastMutation;
+  /**
+   * @internal Per-node inspector hooks for `Graph.observe(path,
+   * { causal, derived })`. Fires in `_onDepMessage` and `_execFn`.
+   * Attached via `_setInspectorHook` (returns a disposer). Multiple
+   * observers can attach simultaneously — all registered hooks fire for
+   * every event.
+   */
+  _inspectorHooks;
+  // --- Actions (built once in the constructor) ---
   _actions;
-  _boundDownToSinks;
-  // --- Inspector hook (Graph observability) ---
-  _inspectorHook;
-  constructor(opts) {
+  constructor(deps, fn, opts) {
+    this._config = opts.config ?? defaultConfig;
+    void this._config.onMessage;
     this._optsName = opts.name;
     this._describeKind = opts.describeKind;
     this._equals = opts.equals ?? Object.is;
     this._resubscribable = opts.resubscribable ?? false;
     this._resetOnTeardown = opts.resetOnTeardown ?? false;
-    this._onResubscribe = opts.onResubscribe;
-    this._onMessage = opts.onMessage;
+    this._autoComplete = opts.completeWhenDepsComplete ?? true;
+    this._autoError = opts.errorWhenDepsError ?? true;
+    this._pausable = opts.pausable ?? true;
     this._guard = opts.guard;
-    this._cached = "initial" in opts ? opts.initial : NO_VALUE;
-    this._status = "disconnected";
-    this._hashFn = opts.versioningHash ?? defaultHash;
-    this._versioning = opts.versioning != null ? createVersioning(opts.versioning, this._cached === NO_VALUE ? void 0 : this._cached, {
+    this._fn = fn;
+    this._cached = opts.initial !== void 0 ? opts.initial : void 0;
+    this._status = deps.length === 0 && fn == null && this._cached !== void 0 ? "settled" : "sentinel";
+    this._hashFn = opts.versioningHash ?? this._config.defaultHashFn ?? defaultHash;
+    const versioningLevel = opts.versioning ?? this._config.defaultVersioning;
+    this._versioningLevel = versioningLevel;
+    this._versioning = versioningLevel != null ? createVersioning(versioningLevel, this._cached === void 0 ? void 0 : this._cached, {
       id: opts.versioningId,
       hash: this._hashFn
     }) : void 0;
+    this._deps = deps.map(createDepRecord);
     const meta = {};
     for (const [k, v] of Object.entries(opts.meta ?? {})) {
-      meta[k] = this._createMetaNode(k, v, opts);
+      const metaOpts = {
+        initial: v,
+        name: `${opts.name ?? "node"}:meta:${k}`,
+        describeKind: "state",
+        config: this._config
+      };
+      if (opts.guard != null) metaOpts.guard = opts.guard;
+      meta[k] = new _NodeImpl([], void 0, metaOpts);
     }
     Object.freeze(meta);
     this.meta = meta;
+    this._hasMeta = Object.keys(meta).length > 0;
     const self = this;
     this._actions = {
-      down(messages) {
-        self._onManualEmit();
-        self._downInternal(messages);
-      },
       emit(value) {
-        self._onManualEmit();
-        self._downAutoValue(value);
+        self._emit([[DATA, value]]);
       },
-      up(messages) {
-        self._upInternal(messages);
+      down(messageOrMessages) {
+        self._emit(normalizeMessages(messageOrMessages));
+      },
+      up(messageOrMessages) {
+        self._emitUp(normalizeMessages(messageOrMessages));
       }
     };
-    this._boundDownToSinks = this._downToSinks.bind(this);
+    this.down = this.down.bind(this);
+    this.up = this.up.bind(this);
   }
-  /**
-   * Subclass hook invoked by `actions.down` / `actions.emit`. Default no-op;
-   * {@link NodeImpl} overrides to set `_manualEmitUsed`.
-   */
-  _onManualEmit() {
+  // --- Derived state ---
+  get _isTerminal() {
+    return this._status === "completed" || this._status === "errored";
   }
-  // --- Identity getters ---
+  // --- Public getters ---
   get name() {
-    return this._registryName ?? this._optsName;
-  }
-  /** @internal Assigned by `Graph.add` when registered without an options `name`. */
-  _assignRegistryName(localName) {
-    if (this._optsName !== void 0 || this._registryName !== void 0) return;
-    this._registryName = localName;
-  }
-  /**
-   * @internal Attach/remove inspector hook for graph-level observability.
-   * Returns a disposer that restores the previous hook.
-   */
-  _setInspectorHook(hook) {
-    const prev = this._inspectorHook;
-    this._inspectorHook = hook;
-    return () => {
-      if (this._inspectorHook === hook) {
-        this._inspectorHook = prev;
-      }
-    };
-  }
-  /** @internal Used by subclasses to surface inspector events. */
-  _emitInspectorHook(event) {
-    this._inspectorHook?.(event);
+    return this._optsName;
   }
   get status() {
     return this._status;
   }
+  get cache() {
+    return this._cached === void 0 ? void 0 : this._cached;
+  }
   get lastMutation() {
     return this._lastMutation;
   }
   get v() {
     return this._versioning;
   }
-  /** @internal Used by `Graph.setVersioning` to retroactively apply versioning. */
-  _applyVersioning(level, opts) {
-    if (this._versioning != null) return;
-    this._hashFn = opts?.hash ?? this._hashFn;
-    this._versioning = createVersioning(
-      level,
-      this._cached === NO_VALUE ? void 0 : this._cached,
-      {
-        id: opts?.id,
-        hash: this._hashFn
-      }
-    );
-  }
   hasGuard() {
     return this._guard != null;
   }
-  allowsObserve(actor) {
-    if (this._guard == null) return true;
-    return this._guard(normalizeActor(actor), "observe");
-  }
-  // --- Public transport ---
-  get() {
-    return this._cached === NO_VALUE ? void 0 : this._cached;
-  }
-  down(messages, options) {
-    if (messages.length === 0) return;
-    if (!options?.internal && this._guard != null) {
-      const actor = normalizeActor(options?.actor);
-      const delivery = options?.delivery ?? "write";
-      const action = delivery === "signal" ? "signal" : "write";
-      if (!this._guard(actor, action)) {
-        throw new GuardDenied({ actor, action, nodeName: this.name });
-      }
-      this._recordMutation(actor);
-    }
-    this._downInternal(messages);
-  }
-  /** @internal Record a successful guarded mutation (called by `down` and subclass `up`). */
-  _recordMutation(actor) {
-    this._lastMutation = { actor, timestamp_ns: wallClockNs() };
-  }
   /**
-   * At-most-once deactivation guard. Both TEARDOWN (eager) and
-   * unsubscribe-body (lazy) call this. The `_active` flag ensures
-   * `_doDeactivate` runs exactly once per activation cycle.
+   * @internal Retroactively attach (or upgrade) versioning state on this
+   * node. Intended for `Graph.setVersioning(level)` bulk application and
+   * for rare cases where a specific node needs to be bumped to a higher
+   * level (e.g., `v0 → v1`) after construction.
+   *
+   * **Safety:** the mutation is rejected mid-wave. Specifically,
+   * throws if the node is currently executing its fn (`_isExecutingFn`).
+   * Callers at quiescent points — before the first sink subscribes, or
+   * after all sinks unsubscribe, or between external `down()` / `emit()`
+   * invocations — are safe. The re-entrance window that motivated §10.6.4
+   * removal was the "transition `_versioning` from `undefined` to a fresh
+   * object mid-`_updateState`" case; that path is now guarded.
+   *
+   * **Monotonicity:** levels can only go up. Downgrade (e.g., `v1 → v0`)
+   * is a no-op — once a node carries higher-level metadata, dropping it
+   * mid-graph would tear the linked-history invariant for v1 and above.
+   *
+   * **Linked-history boundary (D1, 2026-04-13):** upgrading v0 → v1
+   * produces a **fresh history root**. The new v1 state has `cid =
+   * hash(currentCachedValue)` and `prev = null`, not a synthetic `prev`
+   * anchored to any previous v0 value. The v0 monotonic `version` counter
+   * is preserved across the upgrade, but the linked-cid chain (spec §7)
+   * starts fresh at the upgrade point. Downstream audit tools that walk
+   * `v.cid.prev` backwards through time will see a `null` boundary at
+   * the upgrade — **this is intentional**: v0 had no cid to link to, and
+   * fabricating one would lie about the hash. Callers that require an
+   * unbroken cid chain from birth must attach versioning at construction
+   * via `opts.versioning` or `config.defaultVersioning`, not retroactively.
+   *
+   * @param level - New minimum versioning level.
+   * @param opts - Optional id / hash overrides; applied only if the
+   *   node currently has no versioning state.
    */
-  _onDeactivate() {
-    if (!this._active) return;
-    this._active = false;
-    this._doDeactivate();
-  }
-  // --- Subscribe (uniform across node shapes) ---
-  subscribe(sink, hints) {
-    if (hints?.actor != null && this._guard != null) {
-      const actor = normalizeActor(hints.actor);
-      if (!this._guard(actor, "observe")) {
-        throw new GuardDenied({ actor, action: "observe", nodeName: this.name });
-      }
+  _applyVersioning(level, opts) {
+    if (this._isExecutingFn) {
+      throw new Error(
+        `Node "${this.name}": _applyVersioning cannot run mid-fn \u2014 call it outside of \`_execFn\` (typically at graph setup time before the first subscribe).`
+      );
     }
-    if (this._terminal && this._resubscribable) {
-      this._terminal = false;
-      this._cached = NO_VALUE;
-      this._status = "disconnected";
-      this._onResubscribe?.();
+    const currentLevel = this._versioningLevel;
+    if (currentLevel != null && level <= currentLevel) {
+      return;
     }
-    this._sinkCount += 1;
-    if (hints?.singleDep) {
-      this._singleDepSinkCount += 1;
-      this._singleDepSinks.add(sink);
+    const hash = opts?.hash ?? this._hashFn;
+    if (hash !== this._hashFn) this._hashFn = hash;
+    const initialValue = this._cached === void 0 ? void 0 : this._cached;
+    const current = this._versioning;
+    const preservedId = current?.id ?? opts?.id;
+    const preservedVersion = current?.version ?? 0;
+    const fresh = createVersioning(level, initialValue, {
+      id: preservedId,
+      hash
+    });
+    fresh.version = preservedVersion;
+    this._versioning = fresh;
+    this._versioningLevel = level;
+  }
+  /**
+   * @internal Attach an inspector hook. Returns a disposer that removes
+   * the hook. Used by `Graph.observe(path, { causal, derived })` to build
+   * causal traces. Multiple hooks may be attached concurrently — all fire
+   * for every event in registration order. Passing `undefined` is a no-op
+   * and returns a no-op disposer.
+   */
+  _setInspectorHook(hook) {
+    if (hook == null) return () => {
+    };
+    if (this._inspectorHooks == null) this._inspectorHooks = /* @__PURE__ */ new Set();
+    this._inspectorHooks.add(hook);
+    return () => {
+      this._inspectorHooks?.delete(hook);
+      if (this._inspectorHooks?.size === 0) this._inspectorHooks = void 0;
+    };
+  }
+  allowsObserve(actor) {
+    if (this._guard == null) return true;
+    return this._guard(normalizeActor(actor), "observe");
+  }
+  // --- Guard helper ---
+  _checkGuard(options) {
+    if (options?.internal || this._guard == null) return;
+    const actor = normalizeActor(options?.actor);
+    const action = options?.delivery === "signal" ? "signal" : "write";
+    if (!this._guard(actor, action)) {
+      throw new GuardDenied({ actor, action, nodeName: this.name });
+    }
+    this._lastMutation = { actor, timestamp_ns: wallClockNs() };
+  }
+  // --- Public transport ---
+  down(messageOrMessages, options) {
+    const messages = normalizeMessages(messageOrMessages);
+    if (messages.length === 0) return;
+    this._checkGuard(options);
+    this._emit(messages);
+  }
+  emit(value, options) {
+    this._checkGuard(options);
+    this._emit([[DATA, value]]);
+  }
+  up(messageOrMessages, options) {
+    if (this._deps.length === 0) return;
+    const messages = normalizeMessages(messageOrMessages);
+    if (messages.length === 0) return;
+    this._checkGuard(options);
+    const forwardOpts = options ?? { internal: true };
+    this._validateUpTiers(messages);
+    for (const d of this._deps) {
+      d.node.up?.(messages, forwardOpts);
+    }
+  }
+  /**
+   * @internal Internal up-path used by `actions.up(...)` from inside fn.
+   * Same tier validation as public `up`, but bypasses the guard check
+   * since the fn context is already inside an authorized operation.
+   */
+  _emitUp(messages) {
+    if (this._deps.length === 0) return;
+    if (messages.length === 0) return;
+    this._validateUpTiers(messages);
+    for (const d of this._deps) {
+      d.node.up?.(messages, { internal: true });
     }
-    if (!this._terminal) {
-      const startMessages = this._cached === NO_VALUE ? [[START]] : [[START], [DATA, this._cached]];
-      downWithBatch(sink, startMessages);
+  }
+  /**
+   * @internal Enforce spec §1.2 — up-direction messages are restricted to
+   * tier 0–2 and tier 5 (START, DIRTY, INVALIDATE, PAUSE, RESUME,
+   * TEARDOWN). Tier 3 (DATA/RESOLVED) and tier 4 (COMPLETE/ERROR) are
+   * downstream-only. Emitting tier-3/4 via `up` would bypass equals
+   * substitution and cache advance entirely and is a protocol bug.
+   */
+  _validateUpTiers(messages) {
+    const tierOf = this._config.tierOf;
+    for (const m of messages) {
+      const tier = tierOf(m[0]);
+      if (tier === 3 || tier === 4) {
+        throw new Error(
+          `Node "${this.name}": tier-${tier} messages cannot flow up \u2014 DATA/RESOLVED/COMPLETE/ERROR are downstream-only. Use \`down(...)\` for value delivery; \`up(...)\` is for control signals (DIRTY, INVALIDATE, PAUSE, RESUME, TEARDOWN).`
+        );
+      }
+    }
+  }
+  subscribe(sink, actor) {
+    if (actor != null && this._guard != null) {
+      const a = normalizeActor(actor);
+      if (!this._guard(a, "observe")) {
+        throw new GuardDenied({ actor: a, action: "observe", nodeName: this.name });
+      }
+    }
+    const wasTerminal = this._isTerminal;
+    const afterTerminalReset = wasTerminal && this._resubscribable;
+    if (afterTerminalReset) {
+      this._cached = void 0;
+      this._status = "sentinel";
+      this._store = {};
+      this._hasCalledFnOnce = false;
+      this._waveHasNewData = false;
+      this._hasNewTerminal = false;
+      this._paused = false;
+      this._pendingWave = false;
+      this._pendingRerun = false;
+      this._isExecutingFn = false;
+      this._rerunDepth = 0;
+      this._dirtyDepCount = 0;
+      this._pauseLocks = null;
+      this._pauseBuffer = null;
+      for (const d of this._deps) resetDepRecord(d);
+    }
+    this._sinkCount += 1;
+    let subCleanup;
+    try {
+      subCleanup = this._config.onSubscribe(
+        this,
+        sink,
+        { sinkCount: this._sinkCount, afterTerminalReset },
+        this._actions
+      );
+    } catch (err) {
+      this._sinkCount -= 1;
+      throw err;
     }
     if (this._sinks == null) {
       this._sinks = sink;
@@ -760,11 +1212,24 @@ var NodeBase = class {
     } else {
       this._sinks.add(sink);
     }
-    if (this._sinkCount === 1 && !this._terminal) {
-      this._active = true;
-      this._onActivate();
+    const isTerminalNow = this._isTerminal;
+    if (this._sinkCount === 1 && !isTerminalNow) {
+      try {
+        this._activate();
+      } catch (err) {
+        this._sinkCount -= 1;
+        this._removeSink(sink);
+        if (this._sinkCount === 0) this._status = "sentinel";
+        if (typeof subCleanup === "function") {
+          try {
+            subCleanup();
+          } catch {
+          }
+        }
+        throw err;
+      }
     }
-    if (!this._terminal && this._status === "disconnected" && this._cached === NO_VALUE) {
+    if (this._status === "sentinel" && this._cached === void 0) {
       this._status = "pending";
     }
     let removed = false;
@@ -772,853 +1237,802 @@ var NodeBase = class {
       if (removed) return;
       removed = true;
       this._sinkCount -= 1;
-      if (this._singleDepSinks.has(sink)) {
-        this._singleDepSinkCount -= 1;
-        this._singleDepSinks.delete(sink);
-      }
-      if (this._sinks == null) return;
-      if (typeof this._sinks === "function") {
-        if (this._sinks === sink) this._sinks = null;
-      } else {
-        this._sinks.delete(sink);
-        if (this._sinks.size === 1) {
-          const [only] = this._sinks;
-          this._sinks = only;
-        } else if (this._sinks.size === 0) {
-          this._sinks = null;
-        }
-      }
-      if (this._sinks == null) {
-        this._onDeactivate();
-      }
+      this._removeSink(sink);
+      if (typeof subCleanup === "function") subCleanup();
+      if (this._sinks == null) this._deactivate();
     };
   }
-  // --- Down pipeline ---
+  _removeSink(sink) {
+    if (this._sinks === sink) {
+      this._sinks = null;
+    } else if (this._sinks != null && typeof this._sinks !== "function") {
+      this._sinks.delete(sink);
+      if (this._sinks.size === 1) {
+        const [only] = this._sinks;
+        this._sinks = only;
+      } else if (this._sinks.size === 0) {
+        this._sinks = null;
+      }
+    }
+  }
+  // --- Lifecycle ---
   /**
-   * Core outgoing dispatch. Applies terminal filter + local lifecycle
-   * update, then hands messages to `downWithBatch` for tier-aware delivery.
+   * @internal First-sink activation. For a producer (no deps + fn),
+   * invokes fn once. For a compute node (has deps), subscribes to every
+   * dep with the pre-set-dirty trick so the first-run gate waits for
+   * every dep to settle at least once.
    */
-  _downInternal(messages) {
-    if (messages.length === 0) return;
-    let sinkMessages = messages;
-    if (this._terminal && !this._resubscribable) {
-      const pass = messages.filter((m) => m[0] === TEARDOWN || m[0] === INVALIDATE);
-      if (pass.length === 0) return;
-      sinkMessages = pass;
-    }
-    this._handleLocalLifecycle(sinkMessages);
-    if (this._canSkipDirty()) {
-      let hasPhase2 = false;
-      for (let i = 0; i < sinkMessages.length; i++) {
-        const t = sinkMessages[i][0];
-        if (t === DATA || t === RESOLVED) {
-          hasPhase2 = true;
-          break;
-        }
+  _activate() {
+    if (this._deps.length === 0) {
+      if (this._fn) this._execFn();
+      return;
+    }
+    this._dirtyDepCount = 0;
+    const initialLen = this._deps.length;
+    let subscribedCount = 0;
+    try {
+      for (let i = 0; i < initialLen; i++) {
+        const depIdx = i;
+        const dep = this._deps[i];
+        dep.unsub = noopUnsub;
+        dep.unsub = dep.node.subscribe((msgs) => {
+          if (dep.unsub === null) return;
+          const tierOf = this._config.tierOf;
+          let sawSettlement = false;
+          for (const m of msgs) {
+            if (tierOf(m[0]) >= 3) sawSettlement = true;
+            this._config.onMessage(
+              this,
+              m,
+              { direction: "down-in", depIndex: depIdx },
+              this._actions
+            );
+          }
+          if (sawSettlement) this._maybeRunFnOnSettlement();
+        });
+        subscribedCount++;
       }
-      if (hasPhase2) {
-        const filtered = [];
-        for (let i = 0; i < sinkMessages.length; i++) {
-          if (sinkMessages[i][0] !== DIRTY) filtered.push(sinkMessages[i]);
-        }
-        if (filtered.length > 0) {
-          downWithBatch(this._boundDownToSinks, filtered);
+    } catch (err) {
+      this._deps[subscribedCount].unsub = null;
+      for (let j = 0; j < subscribedCount; j++) {
+        const d = this._deps[j];
+        if (d.unsub != null) {
+          const u = d.unsub;
+          d.unsub = null;
+          try {
+            u();
+          } catch {
+          }
+          resetDepRecord(d);
         }
-        return;
       }
+      this._dirtyDepCount = 0;
+      throw err;
     }
-    downWithBatch(this._boundDownToSinks, sinkMessages);
-  }
-  _canSkipDirty() {
-    return this._sinkCount === 1 && this._singleDepSinkCount === 1;
   }
-  _downToSinks(messages) {
-    if (this._sinks == null) return;
-    if (typeof this._sinks === "function") {
-      this._sinks(messages);
-      return;
-    }
-    const snapshot = [...this._sinks];
-    for (const sink of snapshot) {
-      sink(messages);
+  /**
+   * @internal Append a dep post-construction. Used by `autoTrackNode`
+   * (runtime dep discovery) and `Graph.connect()` (post-construction
+   * wiring). Subscribes immediately — if DATA arrives synchronously
+   * during subscribe and fn is currently executing, the re-run is
+   * deferred via `_pendingRerun` flag (see `_execFn` guard).
+   *
+   * **Dedup:** idempotent on duplicate `depNode` — if `depNode` is
+   * already in `_deps`, returns the existing index without mutating
+   * state. Callers can safely invoke `_addDep` without their own
+   * "already added" check. `autoTrackNode` still keeps a `depIndexMap`
+   * as a fast-path lookup for known deps (returning cached `data[idx]`
+   * without calling `_addDep` at all); this internal dedup is the
+   * backstop for any caller that doesn't track its own dep set.
+   *
+   * @returns The index of the new dep in `_deps`, or the existing index
+   *   if the dep was already present.
+   */
+  _addDep(depNode) {
+    for (let i = 0; i < this._deps.length; i++) {
+      if (this._deps[i].node === depNode) return i;
+    }
+    const depIdx = this._deps.length;
+    const record = createDepRecord(depNode);
+    this._deps.push(record);
+    if (this._sinks == null) return depIdx;
+    record.dirty = true;
+    this._dirtyDepCount++;
+    if (this._status !== "dirty") this._emit(DIRTY_ONLY_BATCH);
+    record.unsub = noopUnsub;
+    try {
+      record.unsub = depNode.subscribe((msgs) => {
+        if (record.unsub === null) return;
+        const tierOf = this._config.tierOf;
+        let sawSettlement = false;
+        for (const m of msgs) {
+          if (tierOf(m[0]) >= 3) sawSettlement = true;
+          this._config.onMessage(
+            this,
+            m,
+            { direction: "down-in", depIndex: depIdx },
+            this._actions
+          );
+        }
+        if (sawSettlement) this._maybeRunFnOnSettlement();
+      });
+    } catch (err) {
+      record.unsub = null;
+      this._deps.pop();
+      this._dirtyDepCount--;
+      throw err;
     }
+    return depIdx;
   }
   /**
-   * Update `_cached`, `_status`, `_terminal` from message batch before
-   * delivery. Subclass hooks `_onInvalidate` / `_onTeardown` let
-   * {@link NodeImpl} clear `_lastDepValues` and invoke cleanup fns.
+   * @internal Unsubscribes from deps, fires fn cleanup (both shapes),
+   * clears wave/store state, and (for compute nodes) drops `_cached` per
+   * the ROM/RAM rule. Idempotent: second call is a no-op.
+   *
+   * @param skipStatusUpdate — When `true`, the caller takes responsibility
+   *   for setting `_status` after deactivation (e.g. TEARDOWN always sets
+   *   `"sentinel"` unconditionally). When `false` (default), deactivation
+   *   applies the ROM rule: compute nodes → `"sentinel"`, state nodes
+   *   preserve their current status.
    */
-  _handleLocalLifecycle(messages) {
-    for (const m of messages) {
-      const t = m[0];
-      if (t === DATA) {
-        if (m.length < 2) {
-          continue;
-        }
-        this._cached = m[1];
-        if (this._versioning != null) {
-          advanceVersion(this._versioning, m[1], this._hashFn);
-        }
-      }
-      if (t === INVALIDATE) {
-        this._onInvalidate();
-        this._cached = NO_VALUE;
+  _deactivate(skipStatusUpdate = false) {
+    const cleanup = this._cleanup;
+    this._cleanup = void 0;
+    if (typeof cleanup === "function") {
+      try {
+        cleanup();
+      } catch (err) {
+        this._emit([[ERROR, this._wrapFnError("cleanup threw", err)]]);
       }
-      this._status = statusAfterMessage(this._status, m);
-      if (t === COMPLETE || t === ERROR) {
-        this._terminal = true;
+    } else if (cleanup != null && typeof cleanup.deactivation === "function") {
+      try {
+        cleanup.deactivation();
+      } catch (err) {
+        this._emit([[ERROR, this._wrapFnError("cleanup.deactivation threw", err)]]);
       }
-      if (t === TEARDOWN) {
-        if (this._resetOnTeardown) {
-          this._cached = NO_VALUE;
-        }
-        this._onTeardown();
+    }
+    for (const d of this._deps) {
+      if (d.unsub != null) {
+        const u = d.unsub;
+        d.unsub = null;
         try {
-          this._propagateToMeta(t);
-        } finally {
-          this._onDeactivate();
+          u();
+        } catch {
         }
       }
-      if (t !== TEARDOWN && propagatesToMeta(t)) {
-        this._propagateToMeta(t);
-      }
+      resetDepRecord(d);
+    }
+    this._waveHasNewData = false;
+    this._hasNewTerminal = false;
+    this._hasCalledFnOnce = false;
+    this._paused = false;
+    this._pendingWave = false;
+    this._pendingRerun = false;
+    this._rerunDepth = 0;
+    this._store = {};
+    this._dirtyDepCount = 0;
+    this._pauseLocks = null;
+    this._pauseBuffer = null;
+    if (this._fn != null) {
+      this._cached = void 0;
     }
-  }
-  /**
-   * Subclass hook: invoked when INVALIDATE arrives (before `_cached` is
-   * cleared). {@link NodeImpl} uses this to run the fn cleanup fn and
-   * drop `_lastDepValues` so the next wave re-runs fn.
-   */
-  _onInvalidate() {
-  }
-  /**
-   * Subclass hook: invoked when TEARDOWN arrives, before `_onDeactivate`.
-   * {@link NodeImpl} uses this to run any pending cleanup fn.
-   */
-  _onTeardown() {
-  }
-  /** Forward a signal to all companion meta nodes (best-effort). */
-  _propagateToMeta(t) {
-    for (const metaNode of Object.values(this.meta)) {
-      try {
-        metaNode._downInternal([[t]]);
-      } catch {
+    if (!skipStatusUpdate) {
+      if (this._fn != null || this._deps.length > 0) {
+        if (!this._isTerminal || this._resubscribable) {
+          this._status = "sentinel";
+        }
       }
     }
   }
+  // --- Dep message dispatch (§3.5 singleton default) ---
   /**
-   * Frame a computed value into the right protocol messages and dispatch
-   * via `_downInternal`. Used by `_runFn` and `actions.emit`.
+   * @internal Default per-tier dispatch for incoming dep messages. Called
+   * by `defaultOnMessage`. Updates the DepRecord, triggers wave
+   * completion, and forwards passthrough traffic.
    */
-  _downAutoValue(value) {
-    const wasDirty = this._status === "dirty";
-    let unchanged;
-    try {
-      unchanged = this._cached !== NO_VALUE && this._equals(this._cached, value);
-    } catch (eqErr) {
-      const eqMsg = eqErr instanceof Error ? eqErr.message : String(eqErr);
-      const wrapped = new Error(`Node "${this.name}": equals threw: ${eqMsg}`, {
-        cause: eqErr
-      });
-      this._downInternal([[ERROR, wrapped]]);
-      return;
+  _onDepMessage(depIndex, msg) {
+    const dep = this._deps[depIndex];
+    const t = msg[0];
+    if (this._inspectorHooks != null) {
+      const ev = { kind: "dep_message", depIndex, message: msg };
+      for (const hook of this._inspectorHooks) hook(ev);
     }
-    if (unchanged) {
-      this._downInternal(wasDirty ? [[RESOLVED]] : [[DIRTY], [RESOLVED]]);
+    if (t === START) return;
+    if (t === DIRTY) {
+      this._depDirtied(dep);
       return;
     }
-    this._downInternal(wasDirty ? [[DATA, value]] : [[DIRTY], [DATA, value]]);
-  }
-};
-
-// src/core/node.ts
-var NodeImpl = class extends NodeBase {
-  // --- Dep configuration (set once) ---
-  _deps;
-  _fn;
-  _opts;
-  _hasDeps;
-  _isSingleDep;
-  _autoComplete;
-  // --- Wave tracking masks ---
-  _depDirtyMask;
-  _depSettledMask;
-  _depCompleteMask;
-  _allDepsCompleteMask;
-  // --- Identity-skip optimization ---
-  _lastDepValues;
-  _cleanup;
-  // --- Upstream bookkeeping ---
-  _upstreamUnsubs = [];
-  // --- Fn behavior flag ---
-  /** @internal Read by `describeNode` to infer `"operator"` label. */
-  _manualEmitUsed = false;
-  constructor(deps, fn, opts) {
-    super(opts);
-    this._deps = deps;
-    this._fn = fn;
-    this._opts = opts;
-    this._hasDeps = deps.length > 0;
-    this._isSingleDep = deps.length === 1 && fn != null;
-    this._autoComplete = opts.completeWhenDepsComplete ?? true;
-    if (!this._hasDeps && fn == null && this._cached !== NO_VALUE) {
-      this._status = "settled";
-    }
-    this._depDirtyMask = createBitSet(deps.length);
-    this._depSettledMask = createBitSet(deps.length);
-    this._depCompleteMask = createBitSet(deps.length);
-    this._allDepsCompleteMask = createBitSet(deps.length);
-    for (let i = 0; i < deps.length; i++) this._allDepsCompleteMask.set(i);
-    this.down = this.down.bind(this);
-    this.up = this.up.bind(this);
-  }
-  // --- Meta node factory (called from base constructor) ---
-  _createMetaNode(key, initialValue, opts) {
-    return node({
-      initial: initialValue,
-      name: `${opts.name ?? "node"}:meta:${key}`,
-      describeKind: "state",
-      ...opts.guard != null ? { guard: opts.guard } : {}
-    });
-  }
-  // --- Manual emit tracker (set by actions.down / actions.emit) ---
-  _onManualEmit() {
-    this._manualEmitUsed = true;
-  }
-  // --- Up / unsubscribe ---
-  up(messages, options) {
-    if (!this._hasDeps) return;
-    if (!options?.internal && this._guard != null) {
-      const actor = normalizeActor(options?.actor);
-      if (!this._guard(actor, "write")) {
-        throw new GuardDenied({ actor, action: "write", nodeName: this.name });
-      }
-      this._recordMutation(actor);
+    if (t === INVALIDATE) {
+      this._depInvalidated(dep);
+      this._emit(INVALIDATE_ONLY_BATCH);
+      return;
     }
-    for (const dep of this._deps) {
-      if (options === void 0) {
-        dep.up?.(messages);
-      } else {
-        dep.up?.(messages, options);
-      }
+    if (t === PAUSE || t === RESUME) {
+      this._emit([msg]);
+      return;
     }
-  }
-  _upInternal(messages) {
-    if (!this._hasDeps) return;
-    for (const dep of this._deps) {
-      dep.up?.(messages, { internal: true });
+    if (t === TEARDOWN) {
+      this._emit(TEARDOWN_ONLY_BATCH);
+      return;
     }
-  }
-  unsubscribe() {
-    if (!this._hasDeps) return;
-    this._disconnectUpstream();
-  }
-  // --- Activation (first-subscriber / last-subscriber hooks) ---
-  _onActivate() {
-    if (this._hasDeps) {
-      this._connectUpstream();
+    if (t === DATA) {
+      this._depSettledAsData(dep, msg[1]);
+    } else if (t === RESOLVED) {
+      this._depSettledAsResolved(dep);
+    } else if (t === COMPLETE) {
+      this._depSettledAsTerminal(dep, true);
+    } else if (t === ERROR) {
+      this._depSettledAsTerminal(dep, msg[1]);
+    } else {
+      this._emit([msg]);
       return;
     }
-    if (this._fn) {
-      this._runFn();
+    if (!this._fn) {
+      if (t === DATA || t === RESOLVED) {
+        this._emit([msg]);
+      }
+      if (t === COMPLETE || t === ERROR) {
+        this._maybeAutoTerminalAfterWave();
+      }
       return;
     }
   }
-  _doDeactivate() {
-    this._disconnectUpstream();
-    const cleanup = this._cleanup;
-    this._cleanup = void 0;
-    cleanup?.();
-    if (this._fn != null) {
-      this._cached = NO_VALUE;
-      this._lastDepValues = void 0;
-    }
-    if (this._hasDeps || this._fn != null) {
-      this._status = "disconnected";
+  // --- Centralized dep-state transitions (A3 settlement counters) ---
+  //
+  // Every mutation to `DepRecord.dirty` / `DepRecord.prevData` /
+  // `DepRecord.terminal` must go through one of these helpers so the
+  // `_dirtyDepCount` and `_sentinelDepCount` counters stay in sync with
+  // the per-record flags. `_maybeRunFnOnSettlement` reads the counters
+  // and never re-scans the `_deps` array.
+  /**
+   * Called when a dep transitions `dirty: false → true` (either from an
+   * incoming DIRTY, or pre-set during `_activate` / `_addDep` /
+   * `_depInvalidated`). No-op if the dep is already dirty. Fires the
+   * downstream DIRTY emit if we're the first to dirty this wave.
+   */
+  _depDirtied(dep) {
+    if (dep.dirty) return;
+    dep.dirty = true;
+    dep.involvedThisWave = true;
+    this._dirtyDepCount++;
+    if (this._status !== "dirty") {
+      this._emit(DIRTY_ONLY_BATCH);
     }
   }
-  // --- INVALIDATE / TEARDOWN hooks (clear fn state) ---
-  _onInvalidate() {
-    const cleanup = this._cleanup;
-    this._cleanup = void 0;
-    cleanup?.();
-    this._lastDepValues = void 0;
-  }
-  _onTeardown() {
-    const cleanup = this._cleanup;
-    this._cleanup = void 0;
-    cleanup?.();
-  }
-  // --- Upstream connect / disconnect ---
-  _connectUpstream() {
-    if (!this._hasDeps) return;
-    if (this._upstreamUnsubs.length > 0) return;
-    this._depDirtyMask.setAll();
-    this._depSettledMask.reset();
-    this._depCompleteMask.reset();
-    const depValuesBefore = this._lastDepValues;
-    const subHints = this._isSingleDep ? { singleDep: true } : void 0;
-    for (let i = 0; i < this._deps.length; i += 1) {
-      const dep = this._deps[i];
-      this._upstreamUnsubs.push(
-        dep.subscribe((msgs) => this._handleDepMessages(i, msgs), subHints)
-      );
-    }
-    if (this._fn && this._onMessage && !this._terminal && this._lastDepValues === depValuesBefore) {
-      this._runFn();
+  /**
+   * Called when a dep delivers new DATA: clears dirty, stores the payload,
+   * marks wave-has-data, and — if this is the dep's first DATA — clears
+   * its sentinel slot so the first-run gate can open.
+   */
+  _depSettledAsData(dep, value) {
+    if (dep.dirty) {
+      dep.dirty = false;
+      this._dirtyDepCount--;
     }
+    dep.involvedThisWave = true;
+    dep.dataBatch.push(value);
+    this._waveHasNewData = true;
   }
-  _disconnectUpstream() {
-    if (this._upstreamUnsubs.length === 0) return;
-    for (const unsub of this._upstreamUnsubs.splice(0)) {
-      unsub();
+  /**
+   * Called when a dep emits RESOLVED (wave settled, value unchanged).
+   * Clears dirty; does NOT touch `prevData` / `terminal` / sentinel
+   * count — sentinel only exits on first DATA or terminal, not RESOLVED.
+   */
+  _depSettledAsResolved(dep) {
+    if (dep.dirty) {
+      dep.dirty = false;
+      this._dirtyDepCount--;
     }
-    this._depDirtyMask.reset();
-    this._depSettledMask.reset();
-    this._depCompleteMask.reset();
   }
-  // --- Wave handling ---
-  _handleDepMessages(index, messages) {
-    for (const msg of messages) {
-      this._emitInspectorHook({ kind: "dep_message", depIndex: index, message: msg });
-      const t = msg[0];
-      if (this._onMessage) {
-        try {
-          const consumed = this._onMessage(msg, index, this._actions);
-          if (consumed) {
-            if (t === START || t === DATA || t === RESOLVED) {
-              this._depDirtyMask.clear(index);
-              if (this._depDirtyMask.any() && this._depSettledMask.covers(this._depDirtyMask)) {
-                this._depDirtyMask.reset();
-                this._depSettledMask.reset();
-                this._runFn();
-              }
-            }
-            continue;
-          }
-        } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
-          const wrapped = new Error(`Node "${this.name}": onMessage threw: ${errMsg}`, {
-            cause: err
-          });
-          this._downInternal([[ERROR, wrapped]]);
-          return;
-        }
-      }
-      if (messageTier(t) < 1) continue;
-      if (!this._fn) {
-        if (t === COMPLETE && this._deps.length > 1) {
-          this._depCompleteMask.set(index);
-          this._maybeCompleteFromDeps();
-          continue;
-        }
-        this._downInternal([msg]);
-        continue;
-      }
-      if (t === DIRTY) {
-        this._onDepDirty(index);
-        continue;
-      }
-      if (t === DATA || t === RESOLVED) {
-        this._onDepSettled(index);
-        continue;
-      }
-      if (t === COMPLETE) {
-        this._depCompleteMask.set(index);
-        this._depDirtyMask.clear(index);
-        this._depSettledMask.clear(index);
-        if (this._depDirtyMask.any() && this._depSettledMask.covers(this._depDirtyMask)) {
-          this._depDirtyMask.reset();
-          this._depSettledMask.reset();
-          this._runFn();
-        } else if (!this._depDirtyMask.any() && this._status === "dirty") {
-          this._depSettledMask.reset();
-          this._runFn();
-        }
-        this._maybeCompleteFromDeps();
-        continue;
-      }
-      if (t === ERROR) {
-        this._downInternal([msg]);
-        continue;
-      }
-      if (t === INVALIDATE || t === TEARDOWN || t === PAUSE || t === RESUME) {
-        this._downInternal([msg]);
-        continue;
-      }
-      this._downInternal([msg]);
+  /**
+   * Called when a dep delivers COMPLETE (`terminal = true`) or ERROR
+   * (`terminal = errorPayload`). Clears dirty, stores the terminal, and
+   * — if the dep had never contributed a DATA yet — leaves sentinel
+   * since the gate treats "terminated without data" as gate-open too.
+   */
+  _depSettledAsTerminal(dep, terminal) {
+    if (dep.dirty) {
+      dep.dirty = false;
+      this._dirtyDepCount--;
     }
+    dep.terminal = terminal;
+    dep.involvedThisWave = true;
+    this._hasNewTerminal = true;
   }
-  _onDepDirty(index) {
-    const wasDirty = this._depDirtyMask.has(index);
-    this._depDirtyMask.set(index);
-    this._depSettledMask.clear(index);
-    if (!wasDirty) {
-      this._downInternal([[DIRTY]]);
+  /**
+   * Called when a dep emits INVALIDATE: clears prevData, terminal, and
+   * dataBatch. The dep is now back in the "never delivered a real value"
+   * state — `prevData === undefined` so the sentinel check in fn will fire.
+   */
+  _depInvalidated(dep) {
+    dep.prevData = void 0;
+    dep.terminal = void 0;
+    dep.dataBatch.length = 0;
+    if (!dep.dirty) {
+      dep.dirty = true;
+      dep.involvedThisWave = true;
+      this._dirtyDepCount++;
+    } else {
+      dep.involvedThisWave = false;
     }
   }
-  _onDepSettled(index) {
-    if (!this._depDirtyMask.has(index)) {
-      this._onDepDirty(index);
+  _maybeRunFnOnSettlement() {
+    if (this._isTerminal && !this._resubscribable) return;
+    if (this._dirtyDepCount > 0) return;
+    if (this._paused) {
+      this._pendingWave = true;
+      return;
     }
-    this._depSettledMask.set(index);
-    if (this._depDirtyMask.any() && this._depSettledMask.covers(this._depDirtyMask)) {
-      this._depDirtyMask.reset();
-      this._depSettledMask.reset();
-      this._runFn();
+    if (!this._waveHasNewData && !this._hasNewTerminal && this._hasCalledFnOnce) {
+      this._clearWaveFlags();
+      this._emit(RESOLVED_ONLY_BATCH);
+      this._maybeAutoTerminalAfterWave();
+      return;
     }
+    if (this._fn) this._execFn();
+    this._maybeAutoTerminalAfterWave();
   }
-  _maybeCompleteFromDeps() {
-    if (this._autoComplete && this._deps.length > 0 && this._depCompleteMask.covers(this._allDepsCompleteMask)) {
-      this._downInternal([[COMPLETE]]);
+  _maybeAutoTerminalAfterWave() {
+    if (this._deps.length === 0) return;
+    if (this._isTerminal) return;
+    const erroredDep = this._deps.find((d) => d.terminal !== void 0 && d.terminal !== true);
+    if (erroredDep != null) {
+      if (this._autoError) {
+        this._emit([[ERROR, erroredDep.terminal]]);
+      }
+      return;
+    }
+    if (this._autoComplete && this._deps.every((d) => d.terminal !== void 0)) {
+      this._emit(COMPLETE_ONLY_BATCH);
     }
   }
   // --- Fn execution ---
-  _runFn() {
+  /**
+   * @internal Runs the node fn once. Default cleanup (function form) fires
+   * before the new run; `{ deactivation }` cleanup survives.
+   */
+  _execFn() {
     if (!this._fn) return;
-    if (this._terminal && !this._resubscribable) return;
-    try {
-      const n = this._deps.length;
-      const depValues = new Array(n);
-      for (let i = 0; i < n; i++) depValues[i] = this._deps[i].get();
-      const prev = this._lastDepValues;
-      if (n > 0 && prev != null && prev.length === n) {
-        let allSame = true;
-        for (let i = 0; i < n; i++) {
-          if (!Object.is(depValues[i], prev[i])) {
-            allSame = false;
-            break;
-          }
-        }
-        if (allSame) {
-          if (this._status === "dirty") {
-            this._downInternal([[RESOLVED]]);
-          }
-          return;
-        }
-      }
-      const prevCleanup = this._cleanup;
+    if (this._isTerminal && !this._resubscribable) return;
+    if (this._isExecutingFn) {
+      this._pendingRerun = true;
+      return;
+    }
+    const prevCleanup = this._cleanup;
+    if (typeof prevCleanup === "function") {
       this._cleanup = void 0;
-      prevCleanup?.();
-      this._manualEmitUsed = false;
-      this._lastDepValues = depValues;
-      this._emitInspectorHook({ kind: "run", depValues });
-      const out = this._fn(depValues, this._actions);
-      if (isCleanupResult(out)) {
-        this._cleanup = out.cleanup;
-        if (this._manualEmitUsed) return;
-        if ("value" in out) {
-          this._downAutoValue(out.value);
-        }
-        return;
-      }
-      if (isCleanupFn(out)) {
-        this._cleanup = out;
+      try {
+        prevCleanup();
+      } catch (err) {
+        this._emit([[ERROR, this._wrapFnError("cleanup threw", err)]]);
         return;
       }
-      if (this._manualEmitUsed) return;
-      if (out === void 0) return;
-      this._downAutoValue(out);
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      const wrapped = new Error(`Node "${this.name}": fn threw: ${errMsg}`, { cause: err });
-      this._downInternal([[ERROR, wrapped]]);
     }
-  }
-};
-var isNodeArray = (value) => Array.isArray(value);
-var isNodeOptions = (value) => typeof value === "object" && value != null && !Array.isArray(value);
-function node(depsOrFn, fnOrOpts, optsArg) {
-  const deps = isNodeArray(depsOrFn) ? depsOrFn : [];
-  const fn = typeof depsOrFn === "function" ? depsOrFn : typeof fnOrOpts === "function" ? fnOrOpts : void 0;
-  let opts = {};
-  if (isNodeArray(depsOrFn)) {
-    opts = (isNodeOptions(fnOrOpts) ? fnOrOpts : optsArg) ?? {};
-  } else if (isNodeOptions(depsOrFn)) {
-    opts = depsOrFn;
-  } else {
-    opts = (isNodeOptions(fnOrOpts) ? fnOrOpts : optsArg) ?? {};
-  }
-  return new NodeImpl(deps, fn, opts);
-}
-
-// src/core/bridge.ts
-var DEFAULT_DOWN = [
-  DATA,
-  DIRTY,
-  RESOLVED,
-  COMPLETE,
-  ERROR,
-  TEARDOWN,
-  PAUSE,
-  RESUME,
-  INVALIDATE
-];
-var STANDARD_TYPES = /* @__PURE__ */ new Set([
-  DATA,
-  DIRTY,
-  RESOLVED,
-  COMPLETE,
-  ERROR,
-  TEARDOWN,
-  PAUSE,
-  RESUME,
-  INVALIDATE
-]);
-function bridge(from, to, opts) {
-  const allowedDown = new Set(opts?.down ?? DEFAULT_DOWN);
-  const onMessage = (msg, _depIndex, _actions) => {
-    const type = msg[0];
-    if (!STANDARD_TYPES.has(type)) {
-      to.down([msg]);
-      return true;
-    }
-    if (type === COMPLETE || type === ERROR) {
-      if (allowedDown.has(type)) {
-        to.down([msg]);
+    const batchData = this._deps.map(
+      (d) => !d.involvedThisWave ? void 0 : d.dataBatch.length > 0 ? [...d.dataBatch] : []
+    );
+    const prevData = this._deps.map((d) => d.prevData);
+    for (let i = 0; i < this._deps.length; i++) {
+      const batch2 = batchData[i];
+      if (batch2 != null && batch2.length > 0) {
+        this._deps[i].prevData = batch2[batch2.length - 1];
       }
-      return false;
     }
-    if (!allowedDown.has(type)) {
-      return true;
+    const terminalDeps = this._deps.map((d) => d.terminal);
+    const ctx = { prevData, terminalDeps, store: this._store };
+    this._hasCalledFnOnce = true;
+    this._clearWaveFlags();
+    if (this._inspectorHooks != null) {
+      const ev = { kind: "run", batchData, prevData };
+      for (const hook of this._inspectorHooks) hook(ev);
+    }
+    this._isExecutingFn = true;
+    try {
+      const result = this._fn(batchData, this._actions, ctx);
+      if (typeof result === "function") {
+        this._cleanup = result;
+      } else if (result != null && typeof result === "object" && typeof result.deactivation === "function") {
+        this._cleanup = result;
+      }
+    } catch (err) {
+      this._emit([[ERROR, this._wrapFnError("fn threw", err)]]);
+    } finally {
+      this._isExecutingFn = false;
+      if (this._pendingRerun) {
+        this._pendingRerun = false;
+        this._rerunDepth += 1;
+        if (this._rerunDepth > MAX_RERUN_DEPTH) {
+          this._rerunDepth = 0;
+          this._emit([
+            [
+              ERROR,
+              new Error(
+                `Node "${this.name}": _pendingRerun depth exceeded ${MAX_RERUN_DEPTH} \u2014 likely a reactive cycle`
+              )
+            ]
+          ]);
+        } else {
+          this._maybeRunFnOnSettlement();
+        }
+      } else {
+        this._rerunDepth = 0;
+      }
+      this._clearWaveFlags();
     }
-    to.down([msg]);
-    return true;
-  };
-  return node([from], void 0, {
-    name: opts?.name,
-    describeKind: "effect",
-    onMessage,
-    meta: { _internal: true }
-  });
-}
-
-// src/core/dynamic-node.ts
-var MAX_RERUN = 16;
-function dynamicNode(fn, opts) {
-  return new DynamicNodeImpl(fn, opts ?? {});
-}
-var DynamicNodeImpl = class extends NodeBase {
-  _fn;
-  _autoComplete;
-  // Dynamic deps tracking
-  /** @internal Read by `describeNode`. */
-  _deps = [];
-  _depUnsubs = [];
-  _depIndexMap = /* @__PURE__ */ new Map();
-  _depDirtyBits = /* @__PURE__ */ new Set();
-  _depSettledBits = /* @__PURE__ */ new Set();
-  _depCompleteBits = /* @__PURE__ */ new Set();
-  // Execution state
-  _running = false;
-  _rewiring = false;
-  _bufferedDepMessages = [];
-  _trackedValues = /* @__PURE__ */ new Map();
-  _rerunCount = 0;
-  constructor(fn, opts) {
-    super(opts);
-    this._fn = fn;
-    this._autoComplete = opts.completeWhenDepsComplete ?? true;
-    this.down = this.down.bind(this);
-    this.up = this.up.bind(this);
   }
-  _createMetaNode(key, initialValue, opts) {
-    return node({
-      initial: initialValue,
-      name: `${opts.name ?? "dynamicNode"}:meta:${key}`,
-      describeKind: "state",
-      ...opts.guard != null ? { guard: opts.guard } : {}
-    });
+  _clearWaveFlags() {
+    this._waveHasNewData = false;
+    this._hasNewTerminal = false;
+    for (const d of this._deps) {
+      d.involvedThisWave = false;
+      d.dataBatch.length = 0;
+    }
   }
-  /** Versioning not supported on DynamicNodeImpl (override base). */
-  get v() {
-    return void 0;
+  _wrapFnError(label, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return new Error(`Node "${this.name}": ${label}: ${msg}`, { cause: err });
   }
-  // --- Up / unsubscribe ---
-  up(messages, options) {
-    if (this._deps.length === 0) return;
-    if (!options?.internal && this._guard != null) {
-      const actor = normalizeActor(options?.actor);
-      if (!this._guard(actor, "write")) {
-        throw new GuardDenied({ actor, action: "write", nodeName: this.name });
+  // --- Framing (tier sort + synthetic DIRTY prefix) ---
+  /**
+   * @internal Stable tier sort + synthetic DIRTY prefix for an outgoing
+   * batch. Fast path: already-monotone single-tier batches (the common
+   * case from interned singletons like `DIRTY_ONLY_BATCH`) return the
+   * input unchanged. General path: decorate-sort-undecorate into a new
+   * array, then prepend `[DIRTY]` after any tier-0 START entries when
+   * a tier-3 payload is present and the node isn't already dirty.
+   *
+   * Single source of truth for the spec §1.3.1 framing invariant. Every
+   * outgoing path hits `_frameBatch` exactly once via `_emit`.
+   */
+  _frameBatch(messages) {
+    const tierOf = this._config.tierOf;
+    if (messages.length === 1) {
+      const t = tierOf(messages[0][0]);
+      if (t === 3 && this._status !== "dirty") {
+        return [DIRTY_MSG, messages[0]];
       }
-      this._recordMutation(actor);
+      return messages;
     }
-    for (const dep of this._deps) {
-      dep.up?.(messages, options);
+    let monotone = true;
+    let hasTier3 = false;
+    let hasDirty = false;
+    let prevTier = -1;
+    for (const m of messages) {
+      const tier = tierOf(m[0]);
+      if (tier < prevTier) monotone = false;
+      if (tier === 3) hasTier3 = true;
+      if (m[0] === DIRTY) hasDirty = true;
+      prevTier = tier;
+    }
+    let sorted = messages;
+    if (!monotone) {
+      const indexed = messages.map((m, i) => ({ m, i, tier: tierOf(m[0]) }));
+      indexed.sort((a, b) => a.tier - b.tier || a.i - b.i);
+      sorted = indexed.map((x) => x.m);
+    }
+    if (hasTier3 && !hasDirty && this._status !== "dirty") {
+      let insertAt = 0;
+      while (insertAt < sorted.length && tierOf(sorted[insertAt][0]) === 0) insertAt++;
+      if (insertAt === 0) return [DIRTY_MSG, ...sorted];
+      return [...sorted.slice(0, insertAt), DIRTY_MSG, ...sorted.slice(insertAt)];
     }
+    return sorted;
   }
-  _upInternal(messages) {
-    for (const dep of this._deps) {
-      dep.up?.(messages, { internal: true });
+  // --- Emit pipeline ---
+  /**
+   * @internal The unified dispatch waist — one call = one wave.
+   *
+   * Pipeline stages, in order:
+   *
+   *   1. Early-return on empty batch.
+   *   2. 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
+   *      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
+   *      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`,
+   *      derive `_paused`, filter unknown-lockId RESUME, replay
+   *      bufferAll buffer on final lock release.
+   *   6. 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
+   *      `_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
+   *      `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).
+   */
+  _emit(messages) {
+    if (messages.length === 0) return;
+    let deliverable = messages;
+    const terminal = this._isTerminal;
+    if (terminal && !this._resubscribable) {
+      const pass = messages.filter((m) => m[0] === TEARDOWN || m[0] === INVALIDATE);
+      if (pass.length === 0) return;
+      deliverable = pass;
     }
-  }
-  unsubscribe() {
-    this._disconnect();
-  }
-  // --- Activation hooks ---
-  _onActivate() {
-    this._runFn();
-  }
-  _doDeactivate() {
-    this._disconnect();
-  }
-  _disconnect() {
-    for (const unsub of this._depUnsubs) unsub();
-    this._depUnsubs = [];
-    this._deps = [];
-    this._depIndexMap.clear();
-    this._depDirtyBits.clear();
-    this._depSettledBits.clear();
-    this._depCompleteBits.clear();
-    this._cached = NO_VALUE;
-    this._status = "disconnected";
-  }
-  // --- Fn execution with rewire buffer ---
-  _runFn() {
-    if (this._terminal && !this._resubscribable) return;
-    if (this._running) return;
-    this._running = true;
-    this._rerunCount = 0;
-    let result;
-    try {
-      for (; ; ) {
-        const trackedDeps = [];
-        const trackedValuesMap = /* @__PURE__ */ new Map();
-        const trackedSet = /* @__PURE__ */ new Set();
-        const get = (dep) => {
-          if (!trackedSet.has(dep)) {
-            trackedSet.add(dep);
-            trackedDeps.push(dep);
-            trackedValuesMap.set(dep, dep.get());
+    deliverable = this._frameBatch(deliverable);
+    let filtered = null;
+    for (let i = 0; i < deliverable.length; i++) {
+      const m = deliverable[i];
+      const t = m[0];
+      if (t !== PAUSE && t !== RESUME) {
+        if (filtered != null) filtered.push(m);
+        continue;
+      }
+      if (m.length < 2) {
+        throw new Error(
+          `Node "${this.name}": [[${t === PAUSE ? "PAUSE" : "RESUME"}]] must carry a lockId payload \u2014 bare PAUSE/RESUME is a protocol violation (C0 rule). Use \`[[PAUSE, lockId]]\` / \`[[RESUME, lockId]]\`.`
+        );
+      }
+      let forward = true;
+      if (this._pausable !== false) {
+        const lockId = m[1];
+        if (t === PAUSE) {
+          if (this._pauseLocks == null) this._pauseLocks = /* @__PURE__ */ new Set();
+          this._pauseLocks.add(lockId);
+          this._paused = true;
+          if (this._pausable === "resumeAll" && this._pauseBuffer == null) {
+            this._pauseBuffer = [];
           }
-          return dep.get();
-        };
-        this._trackedValues = trackedValuesMap;
-        const depValues = [];
-        for (const dep of this._deps) depValues.push(dep.get());
-        this._emitInspectorHook({ kind: "run", depValues });
-        try {
-          result = this._fn(get);
-        } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
-          const wrapped = new Error(`Node "${this.name}": fn threw: ${errMsg}`, {
-            cause: err
-          });
-          this._downInternal([[ERROR, wrapped]]);
-          return;
-        }
-        this._rewiring = true;
-        this._bufferedDepMessages = [];
-        try {
-          this._rewire(trackedDeps);
-        } finally {
-          this._rewiring = false;
-        }
-        let needsRerun = false;
-        for (const entry of this._bufferedDepMessages) {
-          for (const msg of entry.msgs) {
-            if (msg[0] === DATA) {
-              const dep = this._deps[entry.index];
-              const trackedValue = dep != null ? this._trackedValues.get(dep) : void 0;
-              const actualValue = msg[1];
-              if (!this._equals(trackedValue, actualValue)) {
-                needsRerun = true;
-                break;
+        } else {
+          if (this._pauseLocks == null || !this._pauseLocks.has(lockId)) {
+            forward = false;
+          } else {
+            this._pauseLocks.delete(lockId);
+            if (this._pauseLocks.size === 0) {
+              this._paused = false;
+              if (this._pauseBuffer != null && this._pauseBuffer.length > 0) {
+                const drain = this._pauseBuffer;
+                this._pauseBuffer = [];
+                this._emit(drain);
+              }
+              if (this._pendingWave) {
+                this._pendingWave = false;
+                this._maybeRunFnOnSettlement();
               }
             }
           }
-          if (needsRerun) break;
-        }
-        if (needsRerun) {
-          this._rerunCount += 1;
-          if (this._rerunCount > MAX_RERUN) {
-            this._bufferedDepMessages = [];
-            this._downInternal([
-              [
-                ERROR,
-                new Error(
-                  `dynamicNode "${this.name ?? "anonymous"}": rewire did not stabilize within ${MAX_RERUN} iterations`
-                )
-              ]
-            ]);
-            return;
-          }
-          this._bufferedDepMessages = [];
-          continue;
         }
-        const drain = this._bufferedDepMessages;
-        this._bufferedDepMessages = [];
-        for (const entry of drain) {
-          for (const msg of entry.msgs) {
-            this._updateMasksForMessage(entry.index, msg);
-          }
-        }
-        this._depDirtyBits.clear();
-        this._depSettledBits.clear();
-        break;
       }
-    } finally {
-      this._running = false;
-    }
-    this._downAutoValue(result);
-  }
-  _rewire(newDeps) {
-    const oldMap = this._depIndexMap;
-    const newMap = /* @__PURE__ */ new Map();
-    const newUnsubs = [];
-    for (let i = 0; i < newDeps.length; i++) {
-      const dep = newDeps[i];
-      newMap.set(dep, i);
-      const oldIdx = oldMap.get(dep);
-      if (oldIdx !== void 0) {
-        newUnsubs.push(this._depUnsubs[oldIdx]);
-        this._depUnsubs[oldIdx] = () => {
-        };
-      } else {
-        const idx = i;
-        const unsub = dep.subscribe((msgs) => this._handleDepMessages(idx, msgs));
-        newUnsubs.push(unsub);
+      if (!forward) {
+        if (filtered == null) filtered = deliverable.slice(0, i);
+      } else if (filtered != null) {
+        filtered.push(m);
       }
     }
-    for (const [dep, oldIdx] of oldMap) {
-      if (!newMap.has(dep)) {
-        this._depUnsubs[oldIdx]();
-      }
+    if (filtered != null) {
+      if (filtered.length === 0) return;
+      deliverable = filtered;
     }
-    this._deps = newDeps;
-    this._depUnsubs = newUnsubs;
-    this._depIndexMap = newMap;
-    this._depDirtyBits.clear();
-    this._depSettledBits.clear();
-    const newCompleteBits = /* @__PURE__ */ new Set();
-    for (const oldIdx of this._depCompleteBits) {
-      for (const [dep, idx] of oldMap) {
-        if (idx === oldIdx && newMap.has(dep)) {
-          newCompleteBits.add(newMap.get(dep));
-          break;
+    if (this._hasMeta && deliverable.some((m) => m[0] === TEARDOWN)) {
+      for (const k of Object.keys(this.meta)) {
+        try {
+          this.meta[k]._emit(TEARDOWN_ONLY_BATCH);
+        } catch {
         }
       }
     }
-    this._depCompleteBits = newCompleteBits;
-  }
-  // --- Dep message handling ---
-  _handleDepMessages(index, messages) {
-    if (this._rewiring) {
-      this._bufferedDepMessages.push({ index, msgs: messages });
-      return;
-    }
-    for (const msg of messages) {
-      this._emitInspectorHook({ kind: "dep_message", depIndex: index, message: msg });
-      const t = msg[0];
-      if (this._onMessage) {
+    const { finalMessages, equalsError } = this._updateState(deliverable);
+    if (finalMessages.length > 0 && this._config.inspectorEnabled) {
+      const inspector = this._config.globalInspector;
+      if (inspector != null) {
         try {
-          if (this._onMessage(msg, index, this._actions)) continue;
-        } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
-          const wrapped = new Error(`Node "${this.name}": onMessage threw: ${errMsg}`, {
-            cause: err
-          });
-          this._downInternal([[ERROR, wrapped]]);
-          return;
+          inspector({ kind: "emit", node: this, messages: finalMessages });
+        } catch {
         }
       }
-      if (messageTier(t) < 1) continue;
-      if (t === DIRTY) {
-        const wasEmpty = this._depDirtyBits.size === 0;
-        this._depDirtyBits.add(index);
-        this._depSettledBits.delete(index);
-        if (wasEmpty) {
-          this._downInternal([[DIRTY]]);
+    }
+    if (finalMessages.length > 0) {
+      if (this._paused && this._pausable === "resumeAll" && this._pauseBuffer != null) {
+        const tierOf = this._config.tierOf;
+        const immediate = [];
+        for (const m of finalMessages) {
+          const tier = tierOf(m[0]);
+          if (tier < 3 || tier === 5) {
+            immediate.push(m);
+          } else {
+            this._pauseBuffer.push(m);
+          }
         }
-        continue;
+        if (immediate.length > 0) {
+          this._dispatchOrAccumulate(immediate);
+        }
+      } else {
+        this._dispatchOrAccumulate(finalMessages);
       }
-      if (t === DATA || t === RESOLVED) {
-        if (!this._depDirtyBits.has(index)) {
-          const wasEmpty = this._depDirtyBits.size === 0;
-          this._depDirtyBits.add(index);
-          if (wasEmpty) {
-            this._downInternal([[DIRTY]]);
-          }
+    }
+    if (equalsError != null) {
+      this._emit([[ERROR, equalsError]]);
+    }
+  }
+  /**
+   * @internal Walk an outgoing (already-framed) batch, updating own
+   * cache / status / versioning and running equals substitution on
+   * every tier-3 DATA (§3.5.1). Framing — tier sort and synthetic
+   * DIRTY prefix — has already happened upstream in `_frameBatch`.
+   * This walk trusts the input is in monotone tier order and that the
+   * spec §1.3.1 DIRTY/RESOLVED precedence invariant is already
+   * satisfied by the frame.
+   *
+   * Equals substitution: every DATA payload is compared against the
+   * live `_cached`; when equal, the tuple is rewritten to `[RESOLVED]`
+   * in a per-call copy and cache is not re-advanced. `.cache` remains
+   * coherent with "the last DATA payload this node actually sent
+   * downstream".
+   *
+   * Returns `{ finalMessages, equalsError? }`:
+   * - `finalMessages` — the array to deliver to sinks (may be
+   *   `messages` unchanged, a rewritten copy with DATA→RESOLVED
+   *   substitutions, or a truncated prefix when equals throws mid-walk).
+   * - `equalsError` — present only when the configured `equals` function
+   *   threw on some DATA message. `_emit` delivers the prefix first,
+   *   then emits a fresh ERROR batch via a recursive `_emit` call so
+   *   subscribers observe `[...walked_prefix, ERROR]` in order.
+   */
+  _updateState(messages) {
+    const tierOf = this._config.tierOf;
+    let rewritten;
+    let equalsError;
+    let abortedAt = -1;
+    let dataCount = 0;
+    for (const m of messages) {
+      if (tierOf(m[0]) === 3) dataCount++;
+    }
+    const checkEquals = dataCount <= 1;
+    let lastDataIdx = -1;
+    if (this._versioning != null && dataCount > 1) {
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i][0] === DATA) {
+          lastDataIdx = i;
+          break;
         }
-        this._depSettledBits.add(index);
-        if (this._allDirtySettled()) {
-          this._depDirtyBits.clear();
-          this._depSettledBits.clear();
-          if (!this._running) {
-            if (this._depValuesDifferFromTracked()) {
-              this._runFn();
+      }
+    }
+    for (let i = 0; i < messages.length; i++) {
+      const m = messages[i];
+      const t = m[0];
+      if (t === DATA) {
+        if (m.length >= 2) {
+          let unchanged = false;
+          if (checkEquals && this._cached !== void 0) {
+            try {
+              unchanged = this._equals(this._cached, m[1]);
+            } catch (err) {
+              equalsError = this._wrapFnError("equals threw", err);
+              abortedAt = i;
+              break;
+            }
+          }
+          if (unchanged) {
+            if (rewritten == null) rewritten = messages.slice(0, i);
+            rewritten.push(RESOLVED_MSG);
+            this._status = "resolved";
+            continue;
+          }
+          this._cached = m[1];
+          if (this._versioning != null) {
+            if (lastDataIdx < 0 || i === lastDataIdx) {
+              advanceVersion(this._versioning, m[1], this._hashFn);
             }
           }
         }
-        continue;
-      }
-      if (t === COMPLETE) {
-        this._depCompleteBits.add(index);
-        this._depDirtyBits.delete(index);
-        this._depSettledBits.delete(index);
-        if (this._allDirtySettled()) {
-          this._depDirtyBits.clear();
-          this._depSettledBits.clear();
-          if (!this._running) this._runFn();
-        }
-        if (this._autoComplete && this._depCompleteBits.size >= this._deps.length && this._deps.length > 0) {
-          this._downInternal([[COMPLETE]]);
+        this._status = "settled";
+        if (rewritten != null) rewritten.push(m);
+      } else {
+        if (rewritten != null) rewritten.push(m);
+        if (t === DIRTY) {
+          this._status = "dirty";
+        } else if (t === RESOLVED) {
+          this._status = "resolved";
+        } else if (t === COMPLETE) {
+          this._status = "completed";
+        } else if (t === ERROR) {
+          this._status = "errored";
+        } else if (t === INVALIDATE) {
+          this._cached = void 0;
+          this._status = "dirty";
+          const c = this._cleanup;
+          if (typeof c === "function") {
+            this._cleanup = void 0;
+            try {
+              c();
+            } catch {
+            }
+          }
+        } else if (t === TEARDOWN) {
+          if (this._resetOnTeardown) this._cached = void 0;
+          this._deactivate(
+            /* skipStatusUpdate */
+            true
+          );
+          this._status = "sentinel";
         }
-        continue;
       }
-      if (t === ERROR) {
-        this._downInternal([msg]);
-        continue;
-      }
-      if (t === INVALIDATE || t === TEARDOWN || t === PAUSE || t === RESUME) {
-        this._downInternal([msg]);
-        continue;
-      }
-      this._downInternal([msg]);
     }
+    const base = abortedAt >= 0 ? rewritten ?? messages.slice(0, abortedAt) : rewritten ?? messages;
+    return equalsError != null ? { finalMessages: base, equalsError } : { finalMessages: base };
   }
+  _deliverToSinks = (messages) => {
+    if (this._sinks == null) return;
+    if (typeof this._sinks === "function") {
+      this._sinks(messages);
+      return;
+    }
+    const snapshot = [...this._sinks];
+    for (const sink of snapshot) sink(messages);
+  };
   /**
-   * Update dep masks for a message without triggering `_runFn` — used
-   * during post-rewire drain so the wave state is consistent with the
-   * buffered activation cascade without recursing.
+   * @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.
    */
-  _updateMasksForMessage(index, msg) {
-    const t = msg[0];
-    if (t === DIRTY) {
-      this._depDirtyBits.add(index);
-      this._depSettledBits.delete(index);
-    } else if (t === DATA || t === RESOLVED) {
-      this._depDirtyBits.add(index);
-      this._depSettledBits.add(index);
-    } else if (t === COMPLETE) {
-      this._depCompleteBits.add(index);
-      this._depDirtyBits.delete(index);
-      this._depSettledBits.delete(index);
-    }
-  }
-  _allDirtySettled() {
-    if (this._depDirtyBits.size === 0) return false;
-    for (const idx of this._depDirtyBits) {
-      if (!this._depSettledBits.has(idx)) return false;
+  _dispatchOrAccumulate(messages) {
+    if (isExplicitlyBatching()) {
+      if (this._batchPendingMessages === null) {
+        this._batchPendingMessages = [];
+        registerBatchFlushHook(() => this._flushBatchPending());
+      }
+      for (const m of messages) this._batchPendingMessages.push(m);
+      return;
     }
-    return true;
+    downWithBatch(this._deliverToSinks, messages, this._config.tierOf);
   }
   /**
-   * True if any current dep value differs from what the last `_runFn`
-   * saw via `get()`. Used to suppress redundant re-runs when deferred
-   * handshake messages arrive after `_rewire` for a dep whose value
-   * already matches `_trackedValues`.
+   * @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).
    */
-  _depValuesDifferFromTracked() {
-    for (const dep of this._deps) {
-      const current = dep.get();
-      const tracked = this._trackedValues.get(dep);
-      if (!this._equals(current, tracked)) return true;
-    }
-    return false;
+  _flushBatchPending() {
+    const pending = this._batchPendingMessages;
+    if (pending === null) return;
+    this._batchPendingMessages = null;
+    if (pending.length === 0) return;
+    const framed = this._frameBatch(pending);
+    downWithBatch(this._deliverToSinks, framed, this._config.tierOf);
   }
 };
+var isNodeArray = (value) => Array.isArray(value);
+var isNodeOptionsObject = (value) => typeof value === "object" && value != null && !Array.isArray(value);
+function node(depsOrFn, fnOrOpts, optsArg) {
+  const deps = isNodeArray(depsOrFn) ? depsOrFn : [];
+  const fn = typeof depsOrFn === "function" ? depsOrFn : typeof fnOrOpts === "function" ? fnOrOpts : void 0;
+  let opts = {};
+  if (isNodeArray(depsOrFn)) {
+    opts = (isNodeOptionsObject(fnOrOpts) ? fnOrOpts : optsArg) ?? {};
+  } else if (isNodeOptionsObject(depsOrFn)) {
+    opts = depsOrFn;
+  } else {
+    opts = (isNodeOptionsObject(fnOrOpts) ? fnOrOpts : optsArg) ?? {};
+  }
+  return new NodeImpl(deps, fn, opts);
+}
 
 // src/core/meta.ts
 function resolveDescribeFields(detail, fields) {
@@ -1628,106 +2042,181 @@ function resolveDescribeFields(detail, fields) {
       return /* @__PURE__ */ new Set(["type", "status", "value", "deps", "meta", "v"]);
     case "full":
       return null;
-    // null = include everything
     default:
       return /* @__PURE__ */ new Set(["type", "deps"]);
   }
 }
 
 // src/core/sugar.ts
+function sentinelGuard(batchData, ctx, allowPartial) {
+  if (allowPartial) return false;
+  return batchData.some(
+    (batch2, i) => !(batch2 != null && batch2.length > 0) && ctx.prevData[i] === void 0
+  );
+}
 function state(initial, opts) {
   return node([], { ...opts, initial });
 }
 function producer(fn, opts) {
-  return node(fn, { describeKind: "producer", ...opts });
+  const wrapped = (_data, actions, ctx) => fn(actions, ctx) ?? void 0;
+  return node(wrapped, { describeKind: "producer", ...opts });
 }
 function derived(deps, fn, opts) {
-  return node(deps, fn, { describeKind: "derived", ...opts });
+  const allowPartial = opts?.partial ?? false;
+  const wrapped = (batchData, actions, ctx) => {
+    if (sentinelGuard(batchData, ctx, allowPartial)) {
+      actions.down([[RESOLVED]]);
+      return void 0;
+    }
+    const data = batchData.map(
+      (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+    );
+    actions.emit(fn(data, ctx));
+    return void 0;
+  };
+  return node(deps, wrapped, { describeKind: "derived", ...opts });
 }
 function effect(deps, fn, opts) {
-  return node(deps, fn, { describeKind: "effect", ...opts });
+  const allowPartial = opts?.partial ?? false;
+  const wrapped = (batchData, actions, ctx) => {
+    if (sentinelGuard(batchData, ctx, allowPartial)) {
+      actions.down([[RESOLVED]]);
+      return void 0;
+    }
+    const data = batchData.map(
+      (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+    );
+    return fn(data, actions, ctx) ?? void 0;
+  };
+  return node(deps, wrapped, { describeKind: "effect", ...opts });
+}
+function dynamicNode(allDeps, fn, opts) {
+  const depIndex = /* @__PURE__ */ new Map();
+  allDeps.forEach((d, i) => {
+    depIndex.set(d, i);
+  });
+  return derived(
+    allDeps,
+    // data[i] is already sugar-unwrapped to a scalar by derived()'s wrapper.
+    (data, ctx) => {
+      const track = (dep) => {
+        const i = depIndex.get(dep);
+        if (i == null) {
+          throw new Error(`dynamicNode: untracked dep "${dep.name ?? "<unnamed>"}"`);
+        }
+        return data[i];
+      };
+      return fn(track, ctx);
+    },
+    opts
+  );
+}
+function autoTrackNode(fn, opts) {
+  let implRef;
+  const depIndexMap = /* @__PURE__ */ new Map();
+  const allowPartial = opts?.partial ?? false;
+  const wrappedFn = (batchData, actions, ctx) => {
+    let foundNew = false;
+    const track = (dep) => {
+      const idx = depIndexMap.get(dep);
+      if (idx !== void 0) {
+        if (idx < batchData.length) {
+          const batch2 = batchData[idx];
+          if (batch2 != null && batch2.length > 0) return batch2.at(-1);
+          return ctx.prevData[idx];
+        }
+        return dep.cache;
+      }
+      foundNew = true;
+      const newIdx = implRef._addDep(dep);
+      depIndexMap.set(dep, newIdx);
+      return dep.cache;
+    };
+    if (!allowPartial && depIndexMap.size > 0) {
+      for (const [, idx] of depIndexMap) {
+        if (idx < batchData.length) {
+          const batch2 = batchData[idx];
+          if (!(batch2 != null && batch2.length > 0) && ctx.prevData[idx] === void 0) {
+            actions.down([[RESOLVED]]);
+            return void 0;
+          }
+        }
+      }
+    }
+    try {
+      const result = fn(track, ctx);
+      if (!foundNew) {
+        actions.emit(result);
+        if (ctx.store.__autoTrackLastDiscoveryError != null) {
+          delete ctx.store.__autoTrackLastDiscoveryError;
+        }
+      }
+    } catch (err) {
+      if (!foundNew) throw err;
+      ctx.store.__autoTrackLastDiscoveryError = err;
+    }
+    return void 0;
+  };
+  implRef = new NodeImpl([], wrappedFn, {
+    describeKind: "derived",
+    ...opts
+  });
+  return implRef;
 }
 function pipe(source, ...ops) {
   let current = source;
-  for (const op of ops) {
-    current = op(current);
-  }
+  for (const op of ops) current = op(current);
   return current;
 }
-
-// src/core/timer.ts
-var ResettableTimer = class {
-  _timer;
-  _gen = 0;
-  /** Schedule callback after delayMs. Cancels any pending timer. */
-  start(delayMs, callback) {
-    this.cancel();
-    this._gen += 1;
-    const gen = this._gen;
-    this._timer = setTimeout(() => {
-      this._timer = void 0;
-      if (gen !== this._gen) return;
-      callback();
-    }, delayMs);
-  }
-  /** Cancel the pending timer (if any). */
-  cancel() {
-    if (this._timer !== void 0) {
-      clearTimeout(this._timer);
-      this._timer = void 0;
-    }
-  }
-  /** Whether a timer is currently pending. */
-  get pending() {
-    return this._timer !== void 0;
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CLEANUP_RESULT,
   COMPLETE,
+  COMPLETE_MSG,
+  COMPLETE_ONLY_BATCH,
   DATA,
   DEFAULT_ACTOR,
-  DEFAULT_DOWN,
   DIRTY,
-  DynamicNodeImpl,
+  DIRTY_MSG,
+  DIRTY_ONLY_BATCH,
   ERROR,
+  GraphReFlyConfig,
   GuardDenied,
   INVALIDATE,
+  INVALIDATE_MSG,
+  INVALIDATE_ONLY_BATCH,
+  NodeImpl,
   PAUSE,
   RESOLVED,
+  RESOLVED_MSG,
+  RESOLVED_ONLY_BATCH,
   RESUME,
-  ResettableTimer,
   START,
+  START_MSG,
   TEARDOWN,
+  TEARDOWN_MSG,
+  TEARDOWN_ONLY_BATCH,
   accessHintForGuard,
   advanceVersion,
+  autoTrackNode,
   batch,
-  bridge,
-  cleanupResult,
+  configure,
   createVersioning,
+  defaultConfig,
   defaultHash,
   derived,
   downWithBatch,
   dynamicNode,
   effect,
   isBatching,
-  isKnownMessageType,
-  isLocalOnly,
-  isPhase2Message,
-  isTerminalMessage,
   isV1,
-  knownMessageTypes,
-  messageTier,
   monotonicNs,
   node,
   normalizeActor,
-  partitionForBatch,
   pipe,
   policy,
   policyFromRules,
   producer,
-  propagatesToMeta,
+  registerBuiltins,
   resolveDescribeFields,
   state,
   wallClockNs