@graphrefly/graphrefly 0.18.0 → 0.20.0

package/dist/core/index.cjs

@@ -34,6 +34,7 @@ __export(core_exports, {
   RESOLVED: () => RESOLVED,
   RESUME: () => RESUME,
   ResettableTimer: () => ResettableTimer,
+  START: () => START,
   TEARDOWN: () => TEARDOWN,
   accessHintForGuard: () => accessHintForGuard,
   advanceVersion: () => advanceVersion,
@@ -48,6 +49,7 @@ __export(core_exports, {
   effect: () => effect,
   isBatching: () => isBatching,
   isKnownMessageType: () => isKnownMessageType,
+  isLocalOnly: () => isLocalOnly,
   isPhase2Message: () => isPhase2Message,
   isTerminalMessage: () => isTerminalMessage,
   isV1: () => isV1,
@@ -81,6 +83,7 @@ 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");
@@ -91,6 +94,7 @@ 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,
@@ -101,16 +105,18 @@ var knownMessageTypes = [
   COMPLETE,
   ERROR
 ];
+var knownMessageSet = new Set(knownMessageTypes);
 function isKnownMessageType(t) {
-  return knownMessageTypes.includes(t);
+  return knownMessageSet.has(t);
 }
 function messageTier(t) {
-  if (t === DIRTY || t === INVALIDATE) return 0;
-  if (t === PAUSE || t === RESUME) return 1;
-  if (t === DATA || t === RESOLVED) return 2;
-  if (t === COMPLETE || t === ERROR) return 3;
-  if (t === TEARDOWN) return 4;
-  return 0;
+  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];
@@ -119,6 +125,10 @@ function isPhase2Message(msg) {
 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;
 }
@@ -279,14 +289,14 @@ function _downSequential(sink, messages, phase = 2) {
   const dataQueue = phase === 3 ? pendingPhase3 : pendingPhase2;
   for (const msg of messages) {
     const tier = messageTier(msg[0]);
-    if (tier === 2) {
+    if (tier === 3) {
       if (isBatching()) {
         const m = msg;
         dataQueue.push(() => sink([m]));
       } else {
         sink([msg]);
       }
-    } else if (tier >= 3) {
+    } else if (tier >= 4) {
       if (isBatching()) {
         const m = msg;
         pendingPhase3.push(() => sink([m]));
@@ -299,14 +309,6 @@ function _downSequential(sink, messages, phase = 2) {
   }
 }
 
-// src/core/clock.ts
-function monotonicNs() {
-  return Math.trunc(performance.now() * 1e6);
-}
-function wallClockNs() {
-  return Date.now() * 1e6;
-}
-
 // src/core/guard.ts
 var GuardDenied = class extends Error {
   actor;
@@ -405,6 +407,14 @@ 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/core/versioning.ts
 var import_node_crypto = require("crypto");
 function canonicalizeForHash(value) {
@@ -460,10 +470,29 @@ function isV1(info) {
   return "cid" in info;
 }
 
-// src/core/node.ts
+// src/core/node-base.ts
 var NO_VALUE = /* @__PURE__ */ Symbol.for("graphrefly/NO_VALUE");
 var CLEANUP_RESULT = /* @__PURE__ */ Symbol.for("graphrefly/CLEANUP_RESULT");
-function createIntBitSet() {
+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;
   return {
     set(i) {
@@ -476,7 +505,8 @@ function createIntBitSet() {
       return (bits & 1 << i) !== 0;
     },
     covers(other) {
-      return (bits & other._bits()) === other._bits();
+      const otherBits = other._bits();
+      return (bits & otherBits) === otherBits;
     },
     any() {
       return bits !== 0;
@@ -484,6 +514,9 @@ function createIntBitSet() {
     reset() {
       bits = 0;
     },
+    setAll() {
+      bits = fullMask;
+    },
     _bits() {
       return bits;
     }
@@ -491,6 +524,8 @@ function createIntBitSet() {
 }
 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);
@@ -517,135 +552,103 @@ function createArrayBitSet(size) {
     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 createBitSet(size) {
-  return size <= 31 ? createIntBitSet() : createArrayBitSet(size);
-}
-var isNodeArray = (value) => Array.isArray(value);
-var isNodeOptions = (value) => typeof value === "object" && value != null && !Array.isArray(value);
-function cleanupResult(cleanup, ...args) {
-  const r = { [CLEANUP_RESULT]: true, cleanup };
-  if (args.length > 0) r.value = args[0];
-  return r;
+  return size <= 31 ? createIntBitSet(size) : createArrayBitSet(size);
 }
-var isCleanupResult = (value) => typeof value === "object" && value !== null && CLEANUP_RESULT in value;
-var isCleanupFn = (value) => typeof value === "function";
-var 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;
-};
-var NodeImpl = class {
-  // --- Configuration (set once, never reassigned) ---
+var NodeBase = class {
+  // --- Identity (set once) ---
   _optsName;
   _registryName;
-  /** @internal — read by {@link describeNode} before inference. */
+  /** @internal Read by `describeNode` before inference. */
   _describeKind;
   meta;
-  _deps;
-  _fn;
-  _opts;
+  // --- Options ---
   _equals;
+  _resubscribable;
+  _resetOnTeardown;
+  _onResubscribe;
   _onMessage;
-  /** @internal — read by {@link describeNode} for `accessHintForGuard`. */
+  /** @internal Read by `describeNode` for `accessHintForGuard`. */
   _guard;
+  /** @internal Subclasses update this through {@link _recordMutation}. */
   _lastMutation;
-  _hasDeps;
-  _autoComplete;
-  _isSingleDep;
-  // --- Mutable state ---
+  // --- Versioning ---
+  _hashFn;
+  _versioning;
+  // --- Lifecycle state ---
+  /** @internal Read by `describeNode` and `graph.ts`. */
   _cached;
+  /** @internal Read externally via `get status()`. */
   _status;
   _terminal = false;
-  _connected = false;
-  _producerStarted = false;
-  _connecting = false;
-  _manualEmitUsed = false;
+  _active = false;
+  // --- Sink storage ---
+  /** @internal Read by `graph/profile.ts` for subscriber counts. */
   _sinkCount = 0;
   _singleDepSinkCount = 0;
-  // --- Object/collection state ---
-  _depDirtyMask;
-  _depSettledMask;
-  _depCompleteMask;
-  _allDepsCompleteMask;
-  _lastDepValues;
-  _cleanup;
-  _sinks = null;
   _singleDepSinks = /* @__PURE__ */ new WeakSet();
-  _upstreamUnsubs = [];
+  _sinks = null;
+  // --- Actions + bound helpers ---
   _actions;
   _boundDownToSinks;
+  // --- Inspector hook (Graph observability) ---
   _inspectorHook;
-  _versioning;
-  _hashFn;
-  constructor(deps, fn, opts) {
-    this._deps = deps;
-    this._fn = fn;
-    this._opts = opts;
+  constructor(opts) {
     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._guard = opts.guard;
-    this._hasDeps = deps.length > 0;
-    this._autoComplete = opts.completeWhenDepsComplete ?? true;
-    this._isSingleDep = deps.length === 1 && fn != null;
     this._cached = "initial" in opts ? opts.initial : NO_VALUE;
-    this._status = this._hasDeps ? "disconnected" : "settled";
+    this._status = "disconnected";
     this._hashFn = opts.versioningHash ?? defaultHash;
     this._versioning = opts.versioning != null ? createVersioning(opts.versioning, this._cached === NO_VALUE ? void 0 : this._cached, {
       id: opts.versioningId,
       hash: this._hashFn
     }) : void 0;
-    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);
     const meta = {};
     for (const [k, v] of Object.entries(opts.meta ?? {})) {
-      meta[k] = node({
-        initial: v,
-        name: `${opts.name ?? "node"}:meta:${k}`,
-        describeKind: "state",
-        ...opts.guard != null ? { guard: opts.guard } : {}
-      });
+      meta[k] = this._createMetaNode(k, v, opts);
     }
     Object.freeze(meta);
     this.meta = meta;
     const self = this;
     this._actions = {
       down(messages) {
-        self._manualEmitUsed = true;
+        self._onManualEmit();
         self._downInternal(messages);
       },
       emit(value) {
-        self._manualEmitUsed = true;
+        self._onManualEmit();
         self._downAutoValue(value);
       },
       up(messages) {
         self._upInternal(messages);
       }
     };
-    this.down = this.down.bind(this);
-    this.up = this.up.bind(this);
     this._boundDownToSinks = this._downToSinks.bind(this);
   }
+  /**
+   * Subclass hook invoked by `actions.down` / `actions.emit`. Default no-op;
+   * {@link NodeImpl} overrides to set `_manualEmitUsed`.
+   */
+  _onManualEmit() {
+  }
+  // --- Identity getters ---
   get name() {
     return this._registryName ?? this._optsName;
   }
-  /**
-   * When a node is registered with {@link Graph.add} without an options `name`,
-   * the graph assigns the registry local name for introspection (parity with graphrefly-py).
-   */
+  /** @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;
@@ -663,7 +666,10 @@ var NodeImpl = class {
       }
     };
   }
-  // --- Public interface (Node<T>) ---
+  /** @internal Used by subclasses to surface inspector events. */
+  _emitInspectorHook(event) {
+    this._inspectorHook?.(event);
+  }
   get status() {
     return this._status;
   }
@@ -673,15 +679,7 @@ var NodeImpl = class {
   get v() {
     return this._versioning;
   }
-  /**
-   * Retroactively apply versioning to a node that was created without it.
-   * No-op if versioning is already enabled.
-   *
-   * Version starts at 0 regardless of prior DATA emissions — it tracks
-   * changes from the moment versioning is enabled, not historical ones.
-   *
-   * @internal — used by {@link Graph.setVersioning}.
-   */
+  /** @internal Used by `Graph.setVersioning` to retroactively apply versioning. */
   _applyVersioning(level, opts) {
     if (this._versioning != null) return;
     this._hashFn = opts?.hash ?? this._hashFn;
@@ -701,6 +699,7 @@ var NodeImpl = class {
     if (this._guard == null) return true;
     return this._guard(normalizeActor(actor), "observe");
   }
+  // --- Public transport ---
   get() {
     return this._cached === NO_VALUE ? void 0 : this._cached;
   }
@@ -713,43 +712,25 @@ var NodeImpl = class {
       if (!this._guard(actor, action)) {
         throw new GuardDenied({ actor, action, nodeName: this.name });
       }
-      this._lastMutation = { actor, timestamp_ns: wallClockNs() };
+      this._recordMutation(actor);
     }
     this._downInternal(messages);
   }
-  _downInternal(messages) {
-    if (messages.length === 0) return;
-    let lifecycleMessages = messages;
-    let sinkMessages = messages;
-    if (this._terminal && !this._opts.resubscribable) {
-      const terminalPassthrough = messages.filter((m) => m[0] === TEARDOWN || m[0] === INVALIDATE);
-      if (terminalPassthrough.length === 0) return;
-      lifecycleMessages = terminalPassthrough;
-      sinkMessages = terminalPassthrough;
-    }
-    this._handleLocalLifecycle(lifecycleMessages);
-    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;
-        }
-      }
-      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);
-        }
-        return;
-      }
-    }
-    downWithBatch(this._boundDownToSinks, sinkMessages);
+  /** @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.
+   */
+  _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);
@@ -757,17 +738,21 @@ var NodeImpl = class {
         throw new GuardDenied({ actor, action: "observe", nodeName: this.name });
       }
     }
-    if (this._terminal && this._opts.resubscribable) {
+    if (this._terminal && this._resubscribable) {
       this._terminal = false;
       this._cached = NO_VALUE;
-      this._status = this._hasDeps ? "disconnected" : "settled";
-      this._opts.onResubscribe?.();
+      this._status = "disconnected";
+      this._onResubscribe?.();
     }
     this._sinkCount += 1;
     if (hints?.singleDep) {
       this._singleDepSinkCount += 1;
       this._singleDepSinks.add(sink);
     }
+    if (!this._terminal) {
+      const startMessages = this._cached === NO_VALUE ? [[START]] : [[START], [DATA, this._cached]];
+      downWithBatch(sink, startMessages);
+    }
     if (this._sinks == null) {
       this._sinks = sink;
     } else if (typeof this._sinks === "function") {
@@ -775,10 +760,12 @@ var NodeImpl = class {
     } else {
       this._sinks.add(sink);
     }
-    if (this._hasDeps) {
-      this._connectUpstream();
-    } else if (this._fn) {
-      this._startProducer();
+    if (this._sinkCount === 1 && !this._terminal) {
+      this._active = true;
+      this._onActivate();
+    }
+    if (!this._terminal && this._status === "disconnected" && this._cached === NO_VALUE) {
+      this._status = "pending";
     }
     let removed = false;
     return () => {
@@ -802,39 +789,49 @@ var NodeImpl = class {
         }
       }
       if (this._sinks == null) {
-        this._disconnectUpstream();
-        this._stopProducer();
+        this._onDeactivate();
       }
     };
   }
-  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._lastMutation = { actor, timestamp_ns: wallClockNs() };
+  // --- Down pipeline ---
+  /**
+   * Core outgoing dispatch. Applies terminal filter + local lifecycle
+   * update, then hands messages to `downWithBatch` for tier-aware delivery.
+   */
+  _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;
     }
-    for (const dep of this._deps) {
-      if (options === void 0) {
-        dep.up?.(messages);
-      } else {
-        dep.up?.(messages, options);
+    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;
+        }
+      }
+      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);
+        }
+        return;
       }
     }
+    downWithBatch(this._boundDownToSinks, sinkMessages);
   }
-  _upInternal(messages) {
-    if (!this._hasDeps) return;
-    for (const dep of this._deps) {
-      dep.up?.(messages, { internal: true });
-    }
-  }
-  unsubscribe() {
-    if (!this._hasDeps) return;
-    this._disconnectUpstream();
+  _canSkipDirty() {
+    return this._sinkCount === 1 && this._singleDepSinkCount === 1;
   }
-  // --- Private methods (prototype, _ prefix) ---
   _downToSinks(messages) {
     if (this._sinks == null) return;
     if (typeof this._sinks === "function") {
@@ -846,6 +843,11 @@ var NodeImpl = class {
       sink(messages);
     }
   }
+  /**
+   * Update `_cached`, `_status`, `_terminal` from message batch before
+   * delivery. Subclass hooks `_onInvalidate` / `_onTeardown` let
+   * {@link NodeImpl} clear `_lastDepValues` and invoke cleanup fns.
+   */
   _handleLocalLifecycle(messages) {
     for (const m of messages) {
       const t = m[0];
@@ -859,28 +861,22 @@ var NodeImpl = class {
         }
       }
       if (t === INVALIDATE) {
-        const cleanupFn = this._cleanup;
-        this._cleanup = void 0;
-        cleanupFn?.();
+        this._onInvalidate();
         this._cached = NO_VALUE;
-        this._lastDepValues = void 0;
       }
       this._status = statusAfterMessage(this._status, m);
       if (t === COMPLETE || t === ERROR) {
         this._terminal = true;
       }
       if (t === TEARDOWN) {
-        if (this._opts.resetOnTeardown) {
+        if (this._resetOnTeardown) {
           this._cached = NO_VALUE;
         }
-        const teardownCleanup = this._cleanup;
-        this._cleanup = void 0;
-        teardownCleanup?.();
+        this._onTeardown();
         try {
           this._propagateToMeta(t);
         } finally {
-          this._disconnectUpstream();
-          this._stopProducer();
+          this._onDeactivate();
         }
       }
       if (t !== TEARDOWN && propagatesToMeta(t)) {
@@ -888,7 +884,20 @@ var NodeImpl = class {
       }
     }
   }
-  /** Propagate a signal to all companion meta nodes (best-effort). */
+  /**
+   * 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 {
@@ -897,9 +906,10 @@ var NodeImpl = class {
       }
     }
   }
-  _canSkipDirty() {
-    return this._sinkCount === 1 && this._singleDepSinkCount === 1;
-  }
+  /**
+   * Frame a computed value into the right protocol messages and dispatch
+   * via `_downInternal`. Used by `_runFn` and `actions.emit`.
+   */
   _downAutoValue(value) {
     const wasDirty = this._status === "dirty";
     let unchanged;
@@ -907,7 +917,9 @@ var NodeImpl = class {
       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 });
+      const wrapped = new Error(`Node "${this.name}": equals threw: ${eqMsg}`, {
+        cause: eqErr
+      });
       this._downInternal([[ERROR, wrapped]]);
       return;
     }
@@ -917,89 +929,173 @@ var NodeImpl = class {
     }
     this._downInternal(wasDirty ? [[DATA, value]] : [[DIRTY], [DATA, value]]);
   }
-  _runFn() {
-    if (!this._fn) return;
-    if (this._terminal && !this._opts.resubscribable) return;
-    if (this._connecting) 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;
-      this._cleanup = void 0;
-      prevCleanup?.();
-      this._manualEmitUsed = false;
-      this._lastDepValues = depValues;
-      this._inspectorHook?.({ 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;
-        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]]);
-    }
-  }
-  _onDepDirty(index) {
-    const wasDirty = this._depDirtyMask.has(index);
-    this._depDirtyMask.set(index);
-    this._depSettledMask.clear(index);
-    if (!wasDirty) {
-      this._downInternal([[DIRTY]]);
+};
+
+// 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);
   }
-  _onDepSettled(index) {
-    if (!this._depDirtyMask.has(index)) {
-      this._onDepDirty(index);
+  // --- 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);
     }
-    this._depSettledMask.set(index);
-    if (this._depDirtyMask.any() && this._depSettledMask.covers(this._depDirtyMask)) {
-      this._depDirtyMask.reset();
-      this._depSettledMask.reset();
+    for (const dep of this._deps) {
+      if (options === void 0) {
+        dep.up?.(messages);
+      } else {
+        dep.up?.(messages, options);
+      }
+    }
+  }
+  _upInternal(messages) {
+    if (!this._hasDeps) return;
+    for (const dep of this._deps) {
+      dep.up?.(messages, { internal: true });
+    }
+  }
+  unsubscribe() {
+    if (!this._hasDeps) return;
+    this._disconnectUpstream();
+  }
+  // --- Activation (first-subscriber / last-subscriber hooks) ---
+  _onActivate() {
+    if (this._hasDeps) {
+      this._connectUpstream();
+      return;
+    }
+    if (this._fn) {
       this._runFn();
+      return;
     }
   }
-  _maybeCompleteFromDeps() {
-    if (this._autoComplete && this._deps.length > 0 && this._depCompleteMask.covers(this._allDepsCompleteMask)) {
-      this._downInternal([[COMPLETE]]);
+  _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";
+    }
+  }
+  // --- 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();
+    }
+  }
+  _disconnectUpstream() {
+    if (this._upstreamUnsubs.length === 0) return;
+    for (const unsub of this._upstreamUnsubs.splice(0)) {
+      unsub();
     }
+    this._depDirtyMask.reset();
+    this._depSettledMask.reset();
+    this._depCompleteMask.reset();
   }
+  // --- Wave handling ---
   _handleDepMessages(index, messages) {
     for (const msg of messages) {
-      this._inspectorHook?.({ kind: "dep_message", depIndex: index, message: msg });
+      this._emitInspectorHook({ kind: "dep_message", depIndex: index, message: msg });
       const t = msg[0];
       if (this._onMessage) {
         try {
-          if (this._onMessage(msg, index, this._actions)) continue;
+          const consumed = this._onMessage(msg, index, this._actions);
+          if (consumed) {
+            if (t === START) {
+              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}`, {
@@ -1009,6 +1105,7 @@ var NodeImpl = class {
           return;
         }
       }
+      if (messageTier(t) < 1) continue;
       if (!this._fn) {
         if (t === COMPLETE && this._deps.length > 1) {
           this._depCompleteMask.set(index);
@@ -1052,53 +1149,85 @@ var NodeImpl = class {
       this._downInternal([msg]);
     }
   }
-  _connectUpstream() {
-    if (!this._hasDeps || this._connected) return;
-    this._connected = true;
-    this._depDirtyMask.reset();
-    this._depSettledMask.reset();
-    this._depCompleteMask.reset();
-    this._status = "settled";
-    const subHints = this._isSingleDep ? { singleDep: true } : void 0;
-    this._connecting = true;
-    try {
-      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)
-        );
-      }
-    } finally {
-      this._connecting = false;
+  _onDepDirty(index) {
+    const wasDirty = this._depDirtyMask.has(index);
+    this._depDirtyMask.set(index);
+    this._depSettledMask.clear(index);
+    if (!wasDirty) {
+      this._downInternal([[DIRTY]]);
     }
-    if (this._fn) {
+  }
+  _onDepSettled(index) {
+    if (!this._depDirtyMask.has(index)) {
+      this._onDepDirty(index);
+    }
+    this._depSettledMask.set(index);
+    if (this._depDirtyMask.any() && this._depSettledMask.covers(this._depDirtyMask)) {
+      this._depDirtyMask.reset();
+      this._depSettledMask.reset();
       this._runFn();
     }
   }
-  _stopProducer() {
-    if (!this._producerStarted) return;
-    this._producerStarted = false;
-    const producerCleanup = this._cleanup;
-    this._cleanup = void 0;
-    producerCleanup?.();
-  }
-  _startProducer() {
-    if (this._deps.length !== 0 || !this._fn || this._producerStarted) return;
-    this._producerStarted = true;
-    this._runFn();
+  _maybeCompleteFromDeps() {
+    if (this._autoComplete && this._deps.length > 0 && this._depCompleteMask.covers(this._allDepsCompleteMask)) {
+      this._downInternal([[COMPLETE]]);
+    }
   }
-  _disconnectUpstream() {
-    if (!this._connected) return;
-    for (const unsub of this._upstreamUnsubs.splice(0)) {
-      unsub();
+  // --- Fn execution ---
+  _runFn() {
+    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;
+      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;
+        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]]);
     }
-    this._connected = false;
-    this._depDirtyMask.reset();
-    this._depSettledMask.reset();
-    this._depCompleteMask.reset();
-    this._status = "disconnected";
   }
 };
+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;
@@ -1165,230 +1294,47 @@ function bridge(from, to, opts) {
 }
 
 // src/core/dynamic-node.ts
+var MAX_RERUN = 16;
 function dynamicNode(fn, opts) {
   return new DynamicNodeImpl(fn, opts ?? {});
 }
-var DynamicNodeImpl = class {
-  _optsName;
-  _registryName;
-  _describeKind;
-  meta;
+var DynamicNodeImpl = class extends NodeBase {
   _fn;
-  _equals;
-  _resubscribable;
-  _resetOnTeardown;
   _autoComplete;
-  _onMessage;
-  _onResubscribe;
-  /** @internal — read by {@link describeNode} for `accessHintForGuard`. */
-  _guard;
-  _lastMutation;
-  _inspectorHook;
-  // Sink tracking
-  _sinkCount = 0;
-  _singleDepSinkCount = 0;
-  _singleDepSinks = /* @__PURE__ */ new WeakSet();
-  // Actions object (for onMessage handler)
-  _actions;
-  _boundDownToSinks;
-  // Mutable state
-  _cached = NO_VALUE;
-  _status = "disconnected";
-  _terminal = false;
-  _connected = false;
-  _rewiring = false;
-  // re-entrancy guard
   // Dynamic deps tracking
+  /** @internal Read by `describeNode`. */
   _deps = [];
   _depUnsubs = [];
   _depIndexMap = /* @__PURE__ */ new Map();
-  // node → index in _deps
-  _dirtyBits = /* @__PURE__ */ new Set();
-  _settledBits = /* @__PURE__ */ new Set();
-  _completeBits = /* @__PURE__ */ new Set();
-  // Sinks
-  _sinks = null;
+  _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._optsName = opts.name;
-    this._describeKind = opts.describeKind;
-    this._equals = opts.equals ?? Object.is;
-    this._resubscribable = opts.resubscribable ?? false;
-    this._resetOnTeardown = opts.resetOnTeardown ?? false;
     this._autoComplete = opts.completeWhenDepsComplete ?? true;
-    this._onMessage = opts.onMessage;
-    this._onResubscribe = opts.onResubscribe;
-    this._guard = opts.guard;
-    this._inspectorHook = void 0;
-    const meta = {};
-    for (const [k, v] of Object.entries(opts.meta ?? {})) {
-      meta[k] = node({
-        initial: v,
-        name: `${opts.name ?? "dynamicNode"}:meta:${k}`,
-        describeKind: "state",
-        ...opts.guard != null ? { guard: opts.guard } : {}
-      });
-    }
-    Object.freeze(meta);
-    this.meta = meta;
-    const self = this;
-    this._actions = {
-      down(messages) {
-        self._downInternal(messages);
-      },
-      emit(value) {
-        self._downAutoValue(value);
-      },
-      up(messages) {
-        for (const dep of self._deps) {
-          dep.up?.(messages, { internal: true });
-        }
-      }
-    };
-    this._boundDownToSinks = this._downToSinks.bind(this);
-  }
-  get name() {
-    return this._registryName ?? this._optsName;
-  }
-  /** @internal */
-  _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;
-      }
-    };
-  }
-  get status() {
-    return this._status;
+    this.down = this.down.bind(this);
+    this.up = this.up.bind(this);
   }
-  get lastMutation() {
-    return this._lastMutation;
+  _createMetaNode(key, initialValue, opts) {
+    return node({
+      initial: initialValue,
+      name: `${opts.name ?? "dynamicNode"}:meta:${key}`,
+      describeKind: "state",
+      ...opts.guard != null ? { guard: opts.guard } : {}
+    });
   }
-  /** Versioning not yet supported on DynamicNodeImpl. */
+  /** Versioning not supported on DynamicNodeImpl (override base). */
   get v() {
     return void 0;
   }
-  hasGuard() {
-    return this._guard != null;
-  }
-  allowsObserve(actor) {
-    if (this._guard == null) return true;
-    return this._guard(normalizeActor(actor), "observe");
-  }
-  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._lastMutation = { actor, timestamp_ns: wallClockNs() };
-    }
-    this._downInternal(messages);
-  }
-  _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;
-        }
-      }
-      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);
-        }
-        return;
-      }
-    }
-    downWithBatch(this._boundDownToSinks, sinkMessages);
-  }
-  _canSkipDirty() {
-    return this._sinkCount === 1 && this._singleDepSinkCount === 1;
-  }
-  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 });
-      }
-    }
-    if (this._terminal && this._resubscribable) {
-      this._terminal = false;
-      this._cached = NO_VALUE;
-      this._status = "disconnected";
-      this._onResubscribe?.();
-    }
-    this._sinkCount += 1;
-    if (hints?.singleDep) {
-      this._singleDepSinkCount += 1;
-      this._singleDepSinks.add(sink);
-    }
-    if (this._sinks == null) {
-      this._sinks = sink;
-    } else if (typeof this._sinks === "function") {
-      this._sinks = /* @__PURE__ */ new Set([this._sinks, sink]);
-    } else {
-      this._sinks.add(sink);
-    }
-    if (!this._connected) {
-      this._connect();
-    }
-    let removed = false;
-    return () => {
-      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._disconnect();
-      }
-    };
-  }
+  // --- Up / unsubscribe ---
   up(messages, options) {
     if (this._deps.length === 0) return;
     if (!options?.internal && this._guard != null) {
@@ -1396,221 +1342,227 @@ var DynamicNodeImpl = class {
       if (!this._guard(actor, "write")) {
         throw new GuardDenied({ actor, action: "write", nodeName: this.name });
       }
-      this._lastMutation = { actor, timestamp_ns: wallClockNs() };
+      this._recordMutation(actor);
     }
     for (const dep of this._deps) {
       dep.up?.(messages, options);
     }
   }
-  unsubscribe() {
-    this._disconnect();
-  }
-  // --- Private methods ---
-  _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);
-    }
-  }
-  _handleLocalLifecycle(messages) {
-    for (const m of messages) {
-      const t = m[0];
-      if (t === DATA) this._cached = m[1];
-      if (t === INVALIDATE) {
-        this._cached = NO_VALUE;
-        this._status = "dirty";
-      }
-      if (t === DATA) {
-        this._status = "settled";
-      } else if (t === RESOLVED) {
-        this._status = "resolved";
-      } else if (t === DIRTY) {
-        this._status = "dirty";
-      } else if (t === COMPLETE) {
-        this._status = "completed";
-        this._terminal = true;
-      } else if (t === ERROR) {
-        this._status = "errored";
-        this._terminal = true;
-      }
-      if (t === TEARDOWN) {
-        if (this._resetOnTeardown) this._cached = NO_VALUE;
-        try {
-          this._propagateToMeta(t);
-        } finally {
-          this._disconnect();
-        }
-      }
-      if (t !== TEARDOWN && propagatesToMeta(t)) {
-        this._propagateToMeta(t);
-      }
-    }
-  }
-  /** Propagate a signal to all companion meta nodes (best-effort). */
-  _propagateToMeta(t) {
-    for (const metaNode of Object.values(this.meta)) {
-      try {
-        metaNode.down([[t]], { internal: true });
-      } catch {
-      }
+  _upInternal(messages) {
+    for (const dep of this._deps) {
+      dep.up?.(messages, { internal: true });
     }
   }
-  _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;
-    }
-    if (unchanged) {
-      this._downInternal(wasDirty ? [[RESOLVED]] : [[DIRTY], [RESOLVED]]);
-      return;
-    }
-    this._cached = value;
-    this._downInternal(wasDirty ? [[DATA, value]] : [[DIRTY], [DATA, value]]);
+  unsubscribe() {
+    this._disconnect();
   }
-  _connect() {
-    if (this._connected) return;
-    this._connected = true;
-    this._status = "settled";
-    this._dirtyBits.clear();
-    this._settledBits.clear();
-    this._completeBits.clear();
+  // --- Activation hooks ---
+  _onActivate() {
     this._runFn();
   }
+  _doDeactivate() {
+    this._disconnect();
+  }
   _disconnect() {
-    if (!this._connected) return;
     for (const unsub of this._depUnsubs) unsub();
     this._depUnsubs = [];
     this._deps = [];
     this._depIndexMap.clear();
-    this._dirtyBits.clear();
-    this._settledBits.clear();
-    this._completeBits.clear();
-    this._connected = false;
+    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._rewiring) return;
-    const trackedDeps = [];
-    const trackedSet = /* @__PURE__ */ new Set();
-    const get = (dep) => {
-      if (!trackedSet.has(dep)) {
-        trackedSet.add(dep);
-        trackedDeps.push(dep);
-      }
-      return dep.get();
-    };
+    if (this._running) return;
+    this._running = true;
+    this._rerunCount = 0;
+    let result;
     try {
-      const depValues = [];
-      for (const dep of this._deps) {
-        depValues.push(dep.get());
+      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());
+          }
+          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;
+              }
+            }
+          }
+          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;
       }
-      this._inspectorHook?.({ kind: "run", depValues });
-      const result = this._fn(get);
-      this._rewire(trackedDeps);
-      if (result === void 0) return;
-      this._downAutoValue(result);
-    } catch (err) {
-      this._downInternal([[ERROR, err]]);
+    } finally {
+      this._running = false;
     }
+    this._downAutoValue(result);
   }
   _rewire(newDeps) {
-    this._rewiring = true;
-    try {
-      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);
-        }
+    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);
       }
-      for (const [dep, oldIdx] of oldMap) {
-        if (!newMap.has(dep)) {
-          this._depUnsubs[oldIdx]();
-        }
+    }
+    for (const [dep, oldIdx] of oldMap) {
+      if (!newMap.has(dep)) {
+        this._depUnsubs[oldIdx]();
       }
-      this._deps = newDeps;
-      this._depUnsubs = newUnsubs;
-      this._depIndexMap = newMap;
-      this._dirtyBits.clear();
-      this._settledBits.clear();
-      const newCompleteBits = /* @__PURE__ */ new Set();
-      for (const oldIdx of this._completeBits) {
-        const dep = [...oldMap.entries()].find(([, idx]) => idx === oldIdx)?.[0];
-        if (dep && newMap.has(dep)) {
+    }
+    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;
         }
       }
-      this._completeBits = newCompleteBits;
-    } finally {
-      this._rewiring = false;
     }
+    this._depCompleteBits = newCompleteBits;
   }
+  // --- Dep message handling ---
   _handleDepMessages(index, messages) {
-    if (this._rewiring) return;
+    if (this._rewiring) {
+      this._bufferedDepMessages.push({ index, msgs: messages });
+      return;
+    }
     for (const msg of messages) {
-      this._inspectorHook?.({ kind: "dep_message", depIndex: index, message: msg });
+      this._emitInspectorHook({ kind: "dep_message", depIndex: index, message: msg });
       const t = msg[0];
       if (this._onMessage) {
         try {
           if (this._onMessage(msg, index, this._actions)) continue;
         } catch (err) {
-          this._downInternal([[ERROR, 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 (t === DIRTY) {
-        this._dirtyBits.add(index);
-        this._settledBits.delete(index);
-        if (this._dirtyBits.size === 1) {
-          downWithBatch(this._boundDownToSinks, [[DIRTY]]);
+        const wasEmpty = this._depDirtyBits.size === 0;
+        this._depDirtyBits.add(index);
+        this._depSettledBits.delete(index);
+        if (wasEmpty) {
+          this._downInternal([[DIRTY]]);
         }
         continue;
       }
       if (t === DATA || t === RESOLVED) {
-        if (!this._dirtyBits.has(index)) {
-          this._dirtyBits.add(index);
-          downWithBatch(this._boundDownToSinks, [[DIRTY]]);
+        if (!this._depDirtyBits.has(index)) {
+          const wasEmpty = this._depDirtyBits.size === 0;
+          this._depDirtyBits.add(index);
+          if (wasEmpty) {
+            this._downInternal([[DIRTY]]);
+          }
         }
-        this._settledBits.add(index);
+        this._depSettledBits.add(index);
         if (this._allDirtySettled()) {
-          this._dirtyBits.clear();
-          this._settledBits.clear();
-          this._runFn();
+          this._depDirtyBits.clear();
+          this._depSettledBits.clear();
+          if (!this._running) {
+            if (this._depValuesDifferFromTracked()) {
+              this._runFn();
+            }
+          }
         }
         continue;
       }
       if (t === COMPLETE) {
-        this._completeBits.add(index);
-        this._dirtyBits.delete(index);
-        this._settledBits.delete(index);
+        this._depCompleteBits.add(index);
+        this._depDirtyBits.delete(index);
+        this._depSettledBits.delete(index);
         if (this._allDirtySettled()) {
-          this._dirtyBits.clear();
-          this._settledBits.clear();
-          this._runFn();
+          this._depDirtyBits.clear();
+          this._depSettledBits.clear();
+          if (!this._running) this._runFn();
         }
-        if (this._autoComplete && this._completeBits.size >= this._deps.length && this._deps.length > 0) {
+        if (this._autoComplete && this._depCompleteBits.size >= this._deps.length && this._deps.length > 0) {
           this._downInternal([[COMPLETE]]);
         }
         continue;
@@ -1626,13 +1578,46 @@ var DynamicNodeImpl = class {
       this._downInternal([msg]);
     }
   }
+  /**
+   * 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.
+   */
+  _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._dirtyBits.size === 0) return false;
-    for (const idx of this._dirtyBits) {
-      if (!this._settledBits.has(idx)) return false;
+    if (this._depDirtyBits.size === 0) return false;
+    for (const idx of this._depDirtyBits) {
+      if (!this._depSettledBits.has(idx)) return false;
     }
     return true;
   }
+  /**
+   * 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`.
+   */
+  _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;
+  }
 };
 
 // src/core/meta.ts
@@ -1659,8 +1644,8 @@ function producer(fn, opts) {
 function derived(deps, fn, opts) {
   return node(deps, fn, { describeKind: "derived", ...opts });
 }
-function effect(deps, fn) {
-  return node(deps, fn, { describeKind: "effect" });
+function effect(deps, fn, opts) {
+  return node(deps, fn, { describeKind: "effect", ...opts });
 }
 function pipe(source, ...ops) {
   let current = source;
@@ -1713,6 +1698,7 @@ var ResettableTimer = class {
   RESOLVED,
   RESUME,
   ResettableTimer,
+  START,
   TEARDOWN,
   accessHintForGuard,
   advanceVersion,
@@ -1727,6 +1713,7 @@ var ResettableTimer = class {
   effect,
   isBatching,
   isKnownMessageType,
+  isLocalOnly,
   isPhase2Message,
   isTerminalMessage,
   isV1,