@graphrefly/ts 0.0.1 → 0.0.2

package/dist/sources/browser.cjs

@@ -145,9 +145,16 @@ function sortedJsonValue(value, seen = /* @__PURE__ */ new Set(), path = "$", st
       }
       for (const key of Object.getOwnPropertyNames(value)) {
         const isIndex = /^(0|[1-9]\d*)$/.test(key) && Number.isSafeInteger(Number(key)) && Number(key) < value.length;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor !== void 0 && ("get" in descriptor || "set" in descriptor)) {
+          throw new TypeError(`stableJsonString: accessor property at ${path}.${key}`);
+        }
         if (key !== "length" && !isIndex) {
           throw new TypeError(`stableJsonString: non-index array property at ${path}.${key}`);
         }
+        if (key !== "length" && descriptor !== void 0 && !descriptor.enumerable) {
+          throw new TypeError(`stableJsonString: non-enumerable array property at ${path}.${key}`);
+        }
       }
       const out2 = [];
       for (let i = 0; i < value.length; i += 1) {
@@ -161,6 +168,15 @@ function sortedJsonValue(value, seen = /* @__PURE__ */ new Set(), path = "$", st
     if (Object.getOwnPropertySymbols(value).length > 0) {
       throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
     }
+    for (const key of Object.getOwnPropertyNames(value)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor !== void 0 && ("get" in descriptor || "set" in descriptor)) {
+        throw new TypeError(`stableJsonString: accessor property at ${path}.${key}`);
+      }
+      if (descriptor !== void 0 && !descriptor.enumerable) {
+        throw new TypeError(`stableJsonString: non-enumerable property at ${path}.${key}`);
+      }
+    }
     const out = /* @__PURE__ */ Object.create(null);
     for (const key of Object.keys(value).sort()) {
       out[key] = sortedJsonValue(
@@ -467,30 +483,6 @@ function drain() {
   if (escaped !== null) throw escaped.e;
 }
 
-// src/batch/batch.ts
-var active = null;
-var boundaryOwner = null;
-function currentBatch() {
-  return active !== null;
-}
-function currentBoundaryBatchToken() {
-  return active ?? boundaryOwner ?? void 0;
-}
-function deferToBatch(target, tier3Wave) {
-  if (active === null) return false;
-  if (!active.deferred.has(target)) active.order.push(target);
-  active.deferred.set(target, tier3Wave);
-  return true;
-}
-function deferAfterBatchForTarget(target, fn) {
-  if (active === null || !active.deferred.has(target)) return false;
-  const owner = active;
-  target.__deferBoundary(() => {
-    if (owner.committed) fn();
-  }, owner);
-  return true;
-}
-
 // src/dispatcher/index.ts
 var PoolTable = class {
   constructor(kind) {
@@ -797,6 +789,586 @@ function makeDepBookkeeping(depCount) {
   };
 }
 
+// src/node/protocol-guards.ts
+function terminalView(t) {
+  return t === void 0 ? false : t;
+}
+function normalizePullDemand(demand) {
+  if (typeof demand !== "object" || demand === null || Array.isArray(demand)) {
+    throw new Error("ctx.up: PULL requires { pullId, params? } demand payload (D269)");
+  }
+  const pullId = demand.pullId;
+  if (typeof pullId !== "string" && typeof pullId !== "symbol") {
+    throw new Error("ctx.up: PULL demand requires a string or symbol pullId (D269)");
+  }
+  const params = demand.params;
+  return params === void 0 ? { pullId } : { pullId, params };
+}
+function validateDownPayloads(msgs) {
+  for (const m of msgs) {
+    if (m[0] === "DATA" && m[1] === void 0) {
+      throw new Error("down: DATA requires a non-SENTINEL payload (R-data-payload)");
+    }
+    if (m[0] === "ERROR" && isInvalidErrorPayload(m[1])) {
+      throw new Error("down: ERROR requires a non-SENTINEL, non-boolean payload (R-data-payload)");
+    }
+  }
+}
+
+// src/node/runtime-accessors.ts
+var constructingCore;
+var constructingEnvironment;
+var ownerTokens = /* @__PURE__ */ new WeakMap();
+var topologyDepsChangedObservers = /* @__PURE__ */ new WeakMap();
+var checkpointReaders = /* @__PURE__ */ new WeakMap();
+var restoreWriters = /* @__PURE__ */ new WeakMap();
+var runtimeReleasers = /* @__PURE__ */ new WeakMap();
+var runtimeQuiescenceReaders = /* @__PURE__ */ new WeakMap();
+var subscriberCountReaders = /* @__PURE__ */ new WeakMap();
+var activationReaders = /* @__PURE__ */ new WeakMap();
+var releasedNodes = /* @__PURE__ */ new WeakSet();
+function withNodeCore(core, create) {
+  const prev = constructingCore;
+  constructingCore = core;
+  try {
+    return create();
+  } finally {
+    constructingCore = prev;
+  }
+}
+function takeConstructingNodeCore() {
+  const core = constructingCore;
+  constructingCore = void 0;
+  return core;
+}
+function withEnvironmentDrivers(environment, create) {
+  const prev = constructingEnvironment;
+  constructingEnvironment = environment;
+  try {
+    return create();
+  } finally {
+    constructingEnvironment = prev;
+  }
+}
+function takeConstructingEnvironmentDrivers() {
+  const environment = constructingEnvironment;
+  constructingEnvironment = void 0;
+  return environment;
+}
+function getNodeOwner(n) {
+  return ownerTokens.get(n);
+}
+function notifyTopologyDepsChanged(node, prevDeps, deps) {
+  topologyDepsChangedObservers.get(node)?.(node, prevDeps, deps);
+}
+
+// src/node/node-context-runtime.ts
+function nodeBuildCtx(self) {
+  const kind = self._slot.handle ? self._slot.dispatcher.poolKind(self._slot.handle.poolId) : "sync";
+  if (kind === "sync") {
+    if (self._syncCtx === null) self._syncCtx = self._makeCtx();
+    self._refreshCtx(self._syncCtx);
+    return self._syncCtx;
+  }
+  return self._makeCtx({
+    waveData: self._dep.waveData.map((waves) => waves.map((w) => [...w])),
+    terminal: self._dep.terminalInput.map(terminalView),
+    latest: [...self._dep.prev]
+  });
+}
+function nodeMakeCtx(self, snapshot) {
+  const ctx = {
+    // Wave-owner boundary (D47): a SYNC fn's emit nests under the public entry that drove
+    // it (cheap inc/dec, no early drain); an ASYNC-pool fn re-enters here from its stashed
+    // ctx at depth 0, so this is the boundary that drains any rewireNext it issued.
+    up: (msgs, towardDep) => {
+      if (self._released) return;
+      enterWave();
+      try {
+        self._up(msgs, towardDep);
+      } finally {
+        exitWave();
+      }
+    },
+    down: (msgs) => {
+      if (self._released) return;
+      enterWave();
+      try {
+        self._down(msgs);
+      } finally {
+        exitWave();
+      }
+    },
+    waveData: snapshot?.waveData ?? self._dep.waveData,
+    terminal: snapshot?.terminal ?? self._dep.terminalInput.map(terminalView),
+    state: self._makeState(),
+    onDeactivation: (fn) => {
+      if (self._released) return;
+      self._hooks.onDeactivation.push(fn);
+    },
+    onInvalidate: (fn) => {
+      if (self._released) return;
+      self._hooks.onInvalidate.push(fn);
+    },
+    environment: () => self._slot.environment,
+    // R-rewire-deferred (D47): defer a self-dep-set mutation to the committed boundary.
+    rewireNext: {
+      subscribeDep: (dep, fn) => self._requestRewireNext({ kind: "add", dep, fn }),
+      unsubscribeDep: (dep, fn) => self._requestRewireNext({ kind: "remove", dep, fn }),
+      replaceDeps: (deps, fn) => self._requestRewireNext({ kind: "set", deps, fn })
+    },
+    // R-up-routing / R-pull (D269): deferred up — route a control/demand wave (e.g. PULL)
+    // up the declared cone at the committed boundary. The SELF-demand path: an
+    // immediate ctx.up whose delivery loops back re-enters this fn (D37 / R-reentrancy).
+    upNext: (msgs, towardDep) => self._requestUpNext(msgs, towardDep),
+    ...self._control.activePull === void 0 ? {} : { pull: self._control.activePull },
+    [CTX_DEP_CACHE]: { latest: snapshot?.latest ?? self._dep.prev },
+    [CTX_NODE_BINDING]: {
+      dispatcher: self._slot.dispatcher,
+      create: (factory) => withEnvironmentDrivers(self._slot.environment, () => withNodeCore(self._core, factory))
+    }
+  };
+  if (self._slot.dynamic) {
+    ctx.track = (i) => ctx[CTX_DEP_CACHE]?.latest[i];
+  }
+  return ctx;
+}
+function nodeRefreshCtx(self, ctx) {
+  ctx.waveData = self._dep.waveData;
+  ctx.terminal = self._dep.terminalInput.map(terminalView);
+  if (self._control.activePull === void 0) {
+    delete ctx.pull;
+  } else {
+    ctx.pull = self._control.activePull;
+  }
+  ctx[CTX_DEP_CACHE] = { latest: self._dep.prev };
+}
+function nodeMakeState(self) {
+  return {
+    get: () => self._privateState.value,
+    set: (v) => {
+      self._privateState.value = v;
+    },
+    persist: (on = true) => {
+      self._privateState.persist = on;
+    }
+  };
+}
+
+// src/node/node-input-runtime.ts
+function nodeRecordDepProjection(self, idx, delivery) {
+  const token = delivery?.wave ?? {};
+  if (self._dep.waveTokens[idx] !== token) {
+    self._dep.waveData[idx].push([]);
+    self._dep.waveTokens[idx] = token;
+  }
+  return self._dep.waveData[idx][self._dep.waveData[idx].length - 1];
+}
+function nodeDepProjectionHasData(self, idx) {
+  const projection = self._dep.waveData[idx][self._dep.waveData[idx].length - 1];
+  return projection?.some((v) => v !== SENTINEL) ?? false;
+}
+function nodeReceiveFromDep(self, idx, msg, delivery) {
+  if (self._released) return;
+  const t = msg[0];
+  if (t === "START") return;
+  const isLastInDeliveredWave = delivery?.last ?? true;
+  if (self._value.terminal !== void 0) {
+    if (t === "TEARDOWN") self._down([["TEARDOWN"]]);
+    return;
+  }
+  if (t === "INVALIDATE") {
+    const projection = self._recordDepProjection(idx, delivery);
+    projection.push(SENTINEL);
+    if (projection.some((v) => v !== SENTINEL) && isLastInDeliveredWave) self._maybeRun();
+    self._dep.prev[idx] = SENTINEL;
+    self._dep.hasData[idx] = false;
+    self._dep.batch[idx] = null;
+    if (self._dep.dirty[idx]) {
+      self._dep.dirty[idx] = false;
+      self._wave.pending--;
+    }
+    if (self._control.pausedDepWaveOccurred && self._dep.batch.every((b) => b === null)) {
+      self._control.pausedDepWaveOccurred = false;
+    }
+    const hadData = self._value.hasData;
+    self._invalidate();
+    if (self._wave.pending === 0 && self._wave.emittedDirtyThisWave) {
+      if (!hadData) self._down([["RESOLVED"]]);
+      else self._wave.emittedDirtyThisWave = false;
+    }
+    self._fireOwedDemandIfReady();
+    return;
+  }
+  if (isTerminal(t)) {
+    const isError = t === "ERROR";
+    const errPayload = isError ? msg[1] : void 0;
+    self._dep.terminal[idx] = isError ? errPayload : true;
+    self._dep.terminalInput[idx] = isError ? errPayload : true;
+    self._releaseDepDirty(idx);
+    const ranValueBeforeTerminal = self._depProjectionHasData(idx) && isLastInDeliveredWave;
+    if (ranValueBeforeTerminal) self._maybeRun();
+    if (isError && self._slot.errorWhenDepsError) {
+      self._down([["ERROR", errPayload]]);
+    } else if (self._slot.terminalAsRealInput) {
+      if (ranValueBeforeTerminal) {
+        self._fireOwedDemandIfReady();
+        return;
+      }
+      self._maybeRun();
+    } else if (self._slot.completeWhenDepsComplete && self._allDepsTerminal()) {
+      self._down([["COMPLETE"]]);
+    } else {
+      self._settleAfterAbsorbedTerminal();
+    }
+    self._fireOwedDemandIfReady();
+    return;
+  }
+  if (t === "TEARDOWN") {
+    self._down([["TEARDOWN"]]);
+    return;
+  }
+  if (t === "DIRTY") {
+    if (!self._dep.dirty[idx]) {
+      self._dep.dirty[idx] = true;
+      self._wave.pending++;
+      self._dep.tier[idx] = 2;
+      self._markDirty();
+    }
+    return;
+  }
+  if (t === "DATA") {
+    const v = msg[1];
+    self._recordDepProjection(idx, delivery).push(v);
+    const b = self._dep.batch[idx];
+    if (b === null) self._dep.batch[idx] = [v];
+    else b.push(v);
+    self._dep.prev[idx] = v;
+    self._dep.hasData[idx] = true;
+    self._dep.tier[idx] = 3;
+    if (self._dep.dirty[idx]) {
+      self._dep.dirty[idx] = false;
+      self._wave.pending--;
+    }
+    if (isLastInDeliveredWave) self._maybeRun();
+    self._fireOwedDemandIfReady();
+    return;
+  }
+  if (t === "RESOLVED") {
+    self._recordDepProjection(idx, delivery);
+    self._dep.tier[idx] = 3;
+    if (self._dep.dirty[idx]) {
+      self._dep.dirty[idx] = false;
+      self._wave.pending--;
+    }
+    if (isLastInDeliveredWave) self._maybeRun();
+    self._fireOwedDemandIfReady();
+    return;
+  }
+}
+function nodeReleaseDepDirty(self, idx) {
+  if (self._dep.dirty[idx]) {
+    self._dep.dirty[idx] = false;
+    self._wave.pending--;
+  }
+}
+function nodeSettleAfterAbsorbedTerminal(self) {
+  if (self._wave.pending !== 0 || !self._wave.emittedDirtyThisWave) return;
+  const sawData = self._dep.batch.some((b) => b !== null && b.length > 0);
+  if (sawData) self._maybeRun();
+  if (self._wave.emittedDirtyThisWave) self._down([["RESOLVED"]]);
+}
+function nodeMarkDirty(self) {
+  self._value.status = "dirty";
+  if (self._isPullQuiet()) return;
+  if (!self._wave.emittedDirtyThisWave) {
+    self._wave.emittedDirtyThisWave = true;
+    self._emitToSubs(["DIRTY"]);
+  }
+}
+function nodeMaybeRun(self) {
+  if (self._wave.inDepMutation) {
+    self._wave.rewireRunPending = true;
+    return;
+  }
+  if (self._slot.pausable === true && (self._isPaused() || self._isPullQuiet())) {
+    self._control.pausedDepWaveOccurred = true;
+    return;
+  }
+  self._tryRun();
+}
+function nodeSettleRewire(self) {
+  if (self._slot.pausable === true && self._isPaused()) {
+    self._control.pausedDepWaveOccurred = true;
+    return;
+  }
+  if (self._wave.pending > 0) return;
+  if (self._slot.handle === null) {
+    self._passthroughEmit();
+    return;
+  }
+  if (!self._wave.hasCalledFnOnce && !(self._slot.partial || self._allDepsSettled())) return;
+  self._markDirty();
+  self._runWave();
+}
+function nodeTryRun(self) {
+  if (self._wave.pending > 0) return;
+  if (self._slot.handle === null) {
+    self._passthroughEmit();
+    return;
+  }
+  if (!self._wave.hasCalledFnOnce) {
+    if (self._slot.partial || self._allDepsSettled()) self._runWave();
+    return;
+  }
+  self._runWave();
+}
+function nodeAllDepsSettled(self) {
+  for (let i = 0; i < self._slot.deps.length; i++) {
+    if (self._dep.hasData[i]) continue;
+    if (self._slot.terminalAsRealInput && self._dep.terminal[i] !== void 0) continue;
+    return false;
+  }
+  return true;
+}
+function nodePassthroughEmit(self) {
+  const b = self._dep.batch[0];
+  if (b !== null && b.length > 0) {
+    self._down([["DATA", b[b.length - 1]]]);
+  } else if (self._wave.emittedDirtyThisWave) {
+    self._down([["RESOLVED"]]);
+  }
+  self._dep.batch[0] = null;
+  self._wave.emittedDirtyThisWave = false;
+}
+function nodeRunWave(self) {
+  if (self._wave.insideRunWave)
+    throw new Error(
+      "synchronous feedback cycle: node fn re-entered its own wave (R-reentrancy / D37)"
+    );
+  self._wave.hasCalledFnOnce = true;
+  self._hooks.onInvalidate = [];
+  self._hooks.onDeactivation = [];
+  const ctx = self._buildCtx();
+  const wasDirty = self._wave.emittedDirtyThisWave;
+  self._wave.emittedSettleThisWave = false;
+  self._wave.insideRunWave = true;
+  try {
+    self._slot.dispatcher.invoke(self._slot.handle, ctx);
+  } finally {
+    self._wave.insideRunWave = false;
+  }
+  if (wasDirty && !self._wave.emittedSettleThisWave && self._value.terminal === void 0 && !self._isAsyncPool()) {
+    self._down([["RESOLVED"]]);
+  }
+  for (let i = 0; i < self._dep.batch.length; i++) {
+    self._dep.batch[i] = null;
+    self._dep.waveData[i] = [];
+    self._dep.waveTokens[i] = void 0;
+    self._dep.terminalInput[i] = void 0;
+  }
+  self._wave.emittedDirtyThisWave = false;
+}
+
+// src/node/node-runtime-host.ts
+function nodeRuntimeHost(node) {
+  return node;
+}
+
+// src/node/node-lifecycle-runtime.ts
+function nodeActivate(self) {
+  self._lifecycle.activated = true;
+  const seedRestoredDeps = self._restoredActivationPending;
+  self._restoredActivationPending = false;
+  self._dep.unsubs = new Array(self._slot.deps.length);
+  self._dep.idxBoxes = new Array(self._slot.deps.length);
+  for (const dep of self._slot.deps) self._subscribeDepAt(dep, { seedRestored: seedRestoredDeps });
+  if (self._slot.deps.length === 0 && self._slot.handle !== null && !self._wave.hasCalledFnOnce) {
+    self._runWave();
+  }
+}
+function nodeSubscribeDepAt(self, depNode, opts = {}) {
+  const idx0 = self._slot.deps.indexOf(depNode);
+  const box = { v: idx0 };
+  let ignoreInitialPush = opts.seedRestored === true;
+  if (ignoreInitialPush && idx0 !== -1) {
+    self._seedRestoredDepAt(idx0, depNode);
+    const dep = nodeRuntimeHost(depNode);
+    if (dep._value.terminal !== void 0 && !dep._slot.resubscribable) {
+      self._dep.unsubs[idx0] = () => {
+      };
+      self._dep.idxBoxes[idx0] = box;
+      return;
+    }
+  }
+  const unsub = depNode.subscribe((msg, delivery) => {
+    if (ignoreInitialPush && delivery === void 0) return;
+    if (ignoreInitialPush) ignoreInitialPush = false;
+    if (box.v === -1) return;
+    self._receiveFromDep(box.v, msg, delivery);
+  });
+  if (ignoreInitialPush && idx0 !== -1 && box.v !== -1) self._seedRestoredDepAt(idx0, depNode);
+  ignoreInitialPush = false;
+  if (idx0 !== -1) {
+    self._dep.unsubs[idx0] = unsub;
+    self._dep.idxBoxes[idx0] = box;
+  }
+}
+function nodeSeedRestoredDepAt(self, idx, depNode) {
+  const dep = nodeRuntimeHost(depNode);
+  const seedData = dep._value.hasData && !dep._slot.pull;
+  self._dep.batch[idx] = null;
+  self._dep.waveData[idx] = [];
+  self._dep.waveTokens[idx] = void 0;
+  self._dep.prev[idx] = seedData ? dep._value.cache : SENTINEL;
+  self._dep.hasData[idx] = seedData;
+  self._dep.dirty[idx] = false;
+  self._dep.tier[idx] = seedData ? 3 : 0;
+  self._dep.terminal[idx] = dep._value.terminal;
+  self._dep.terminalInput[idx] = void 0;
+}
+function nodeDeactivate(self) {
+  self._lifecycle.activated = false;
+  for (const u of self._dep.unsubs) if (u) u();
+  self._dep.unsubs = [];
+  self._dep.idxBoxes = [];
+  for (const fn of self._hooks.onDeactivation) fn();
+  self._hooks.onDeactivation = [];
+  self._hooks.onInvalidate = [];
+  const isCompute = self._slot.handle !== null || self._slot.deps.length > 0;
+  if (isCompute) {
+    self._value.cache = SENTINEL;
+    self._value.hasData = false;
+    self._value.status = "sentinel";
+  }
+  self._resetDepState();
+  self._wave.hasCalledFnOnce = false;
+  self._control.pauseLockset.clear();
+  self._control.pauseBuffer = [];
+  self._control.pausedDepWaveOccurred = false;
+  self._control.demandOwed = void 0;
+  self._control.activePull = void 0;
+  self._control.pullDirtyOwed = false;
+  self._value.replayRing = [];
+  if (!self._privateState.persist) self._privateState.value = SENTINEL;
+}
+function nodeSubscriberCount(self) {
+  return self._lifecycle.subscribers.size;
+}
+function nodeIsRuntimeQuiescentForRelease(self) {
+  return !self._released && self._value.status !== "dirty" && self._value.status !== "pending" && self._wave.pending === 0 && !self._wave.insideRunWave && !self._wave.inDepMutation && !self._wave.rewireRunPending && !self._wave.batchDirtyOwed && self._dep.dirty.every((dirty) => !dirty) && self._control.pauseBuffer.length === 0 && !self._control.pausedDepWaveOccurred && self._control.demandOwed === void 0 && self._control.activePull === void 0 && !self._control.inDeliverDemand && self._control.pauseLockset.size === 0;
+}
+function nodeReleaseRuntime(self) {
+  if (self._released) return;
+  self._released = true;
+  const node = self;
+  releasedNodes.add(node);
+  let releaseError;
+  const recordReleaseError = (error) => {
+    if (releaseError === void 0) releaseError = error;
+  };
+  self._lifecycle.activated = false;
+  for (const u of self._dep.unsubs) {
+    try {
+      u();
+    } catch (error) {
+      recordReleaseError(error);
+    }
+  }
+  for (const fn of self._hooks.onDeactivation) {
+    try {
+      fn();
+    } catch (error) {
+      recordReleaseError(error);
+    }
+  }
+  self._dep.unsubs = [];
+  self._dep.idxBoxes = [];
+  self._lifecycle.subscribers.clear();
+  if (self._slot.handle !== null) {
+    self._slot.dispatcher.unregister(self._slot.handle);
+    self._slot.handle = null;
+  }
+  self._slot.deps = [];
+  self._dep.batch = [];
+  self._dep.waveData = [];
+  self._dep.waveTokens = [];
+  self._dep.prev = [];
+  self._dep.hasData = [];
+  self._dep.dirty = [];
+  self._dep.tier = [];
+  self._dep.terminal = [];
+  self._dep.terminalInput = [];
+  self._value.cache = SENTINEL;
+  self._value.hasData = false;
+  self._value.status = "sentinel";
+  self._value.terminal = void 0;
+  self._value.replayRing = [];
+  self._privateState.value = SENTINEL;
+  self._privateState.persist = false;
+  self._syncCtx = null;
+  self._resetDepState();
+  self._hooks.onDeactivation = [];
+  self._hooks.onInvalidate = [];
+  self._control.pauseLockset.clear();
+  self._control.pauseBuffer = [];
+  self._control.pausedDepWaveOccurred = false;
+  self._control.demandOwed = void 0;
+  self._control.activePull = void 0;
+  self._control.pullDirtyOwed = false;
+  self._restoredActivationPending = false;
+  checkpointReaders.delete(node);
+  restoreWriters.delete(node);
+  runtimeReleasers.delete(node);
+  runtimeQuiescenceReaders.delete(node);
+  subscriberCountReaders.delete(node);
+  activationReaders.delete(node);
+  ownerTokens.delete(node);
+  topologyDepsChangedObservers.delete(node);
+  self._core.releaseSlot(self._id);
+  if (releaseError !== void 0) throw releaseError;
+}
+function nodeResetDepState(self) {
+  const n = self._slot.deps.length;
+  for (let i = 0; i < n; i++) {
+    self._dep.batch[i] = null;
+    self._dep.waveData[i] = [];
+    self._dep.waveTokens[i] = void 0;
+    self._dep.prev[i] = SENTINEL;
+    self._dep.hasData[i] = false;
+    self._dep.dirty[i] = false;
+    self._dep.tier[i] = 0;
+    self._dep.terminal[i] = void 0;
+    self._dep.terminalInput[i] = void 0;
+  }
+  self._wave.pending = 0;
+  self._wave.emittedDirtyThisWave = false;
+}
+
+// src/batch/batch.ts
+var active = null;
+var boundaryOwner = null;
+function currentBatch() {
+  return active !== null;
+}
+function currentBoundaryBatchToken() {
+  return active ?? boundaryOwner ?? void 0;
+}
+function deferToBatch(target, tier3Wave) {
+  if (active === null) return false;
+  if (!active.deferred.has(target)) active.order.push(target);
+  active.deferred.set(target, tier3Wave);
+  return true;
+}
+function deferAfterBatchForTarget(target, fn) {
+  if (active === null || !active.deferred.has(target)) return false;
+  const owner = active;
+  target.__deferBoundary(() => {
+    if (owner.committed) fn();
+  }, owner);
+  return true;
+}
+
 // src/node/versioning.ts
 var ABSENT_V1_SEED = Object.freeze({
   "@graphrefly/node-version": "v1-absent"
@@ -875,67 +1447,532 @@ function restoredV1Cid(policy, hasData, cache) {
   return computeV1Cid(policy, hasData ? cache : ABSENT_V1_SEED);
 }
 
-// src/node/node.ts
-var constructingCore;
-var constructingEnvironment;
-var ownerTokens = /* @__PURE__ */ new WeakMap();
-var topologyDepsChangedObservers = /* @__PURE__ */ new WeakMap();
-var checkpointReaders = /* @__PURE__ */ new WeakMap();
-var restoreWriters = /* @__PURE__ */ new WeakMap();
-var runtimeReleasers = /* @__PURE__ */ new WeakMap();
-var runtimeQuiescenceReaders = /* @__PURE__ */ new WeakMap();
-var subscriberCountReaders = /* @__PURE__ */ new WeakMap();
-var activationReaders = /* @__PURE__ */ new WeakMap();
-var releasedNodes = /* @__PURE__ */ new WeakSet();
-function withNodeCore(core, create) {
-  const prev = constructingCore;
-  constructingCore = core;
-  try {
-    return create();
-  } finally {
-    constructingCore = prev;
+// src/node/node-output-runtime.ts
+function nodeDown(self, msgs) {
+  if (self._released) return;
+  validateDownPayloads(msgs);
+  const deliveryWave = {};
+  const assertVersionDataCompatible = (wave) => {
+    for (const m of wave) {
+      if (m[0] === "DATA") assertNodeVersionDataCompatible(self._version.policy, m[1]);
+    }
+  };
+  const snapshotVersionData = (wave) => wave.map(
+    (m) => m[0] === "DATA" ? ["DATA", snapshotNodeVersionData(self._version.policy, m[1])] : m
+  );
+  assertVersionDataCompatible(msgs);
+  if (self._value.terminal !== void 0) {
+    if (!msgs.some((m) => m[0] === "TEARDOWN")) return;
+    self._value.hasTorndown = true;
+    if (self._slot.resetOnTeardown) {
+      self._value.cache = SENTINEL;
+      self._value.hasData = false;
+    }
+    self._emitToSubs(["TEARDOWN"], { wave: deliveryWave, last: true });
+    return;
   }
-}
-function withEnvironmentDrivers(environment, create) {
-  const prev = constructingEnvironment;
-  constructingEnvironment = environment;
-  try {
-    return create();
-  } finally {
-    constructingEnvironment = prev;
+  let sorted = [...msgs].sort((a, b) => messageTier(a[0]) - messageTier(b[0]));
+  const firstInvalidate = sorted.findIndex((m) => m[0] === "INVALIDATE");
+  if (firstInvalidate !== -1) {
+    sorted = sorted.filter((m, i) => m[0] !== "INVALIDATE" || i === firstInvalidate);
+  }
+  const hasTeardown = sorted.some((m) => m[0] === "TEARDOWN");
+  const hasTerminal = sorted.some((m) => m[0] === "COMPLETE" || m[0] === "ERROR");
+  if (hasTeardown && !hasTerminal && self._value.terminal === void 0 && !self._value.hasTorndown) {
+    sorted = [["COMPLETE"], ...sorted];
+  }
+  if (!self._wave.insideRunWave && currentBatch()) {
+    const deferred = snapshotVersionData(sorted.filter((m) => isDeferredTier(m[0])));
+    if (deferred.length > 0) {
+      if (!self._wave.emittedDirtyThisWave) {
+        self._wave.emittedDirtyThisWave = true;
+        self._value.status = "dirty";
+        self._emitToSubs(["DIRTY"], { wave: deliveryWave, last: false });
+      }
+      self._wave.batchDirtyOwed = true;
+      deferToBatch(self, deferred);
+      return;
+    }
   }
-}
-function getNodeOwner(n) {
-  return ownerTokens.get(n);
-}
-function notifyTopologyDepsChanged(node, prevDeps, deps) {
-  topologyDepsChangedObservers.get(node)?.(node, prevDeps, deps);
-}
-function terminalView(t) {
-  return t === void 0 ? false : t;
-}
-function normalizePullDemand(demand) {
-  if (typeof demand !== "object" || demand === null || Array.isArray(demand)) {
-    throw new Error("ctx.up: PULL requires { pullId, params? } demand payload (D269)");
+  if (self._shouldBufferOnPause()) {
+    const buffered = snapshotVersionData(sorted.filter((m) => isPauseBufferedTier(m[0])));
+    if (buffered.length > 0) {
+      self._wave.emittedSettleThisWave = true;
+      self._control.pauseBuffer.push(buffered);
+    }
+    sorted = sorted.filter((m) => !isPauseBufferedTier(m[0]));
+    if (sorted.length === 0) return;
   }
-  const pullId = demand.pullId;
-  if (typeof pullId !== "string" && typeof pullId !== "symbol") {
-    throw new Error("ctx.up: PULL demand requires a string or symbol pullId (D269)");
+  let dataCount = 0;
+  let hasTier3 = false;
+  let hasResolved = false;
+  for (const m of sorted) {
+    if (m[0] === "DATA") dataCount++;
+    if (m[0] === "RESOLVED") hasResolved = true;
+    if (isValueTier(m[0])) hasTier3 = true;
   }
-  const params = demand.params;
-  return params === void 0 ? { pullId } : { pullId, params };
+  if (dataCount >= 1 && hasResolved) {
+    throw new Error(
+      "down: a wave cannot mix DATA and RESOLVED (tier-3 exclusivity, R-resolved-undirty)"
+    );
+  }
+  const plannedVersions = new Array(sorted.length);
+  if (dataCount > 0) {
+    let plannedVersion = self._version.value;
+    for (let i = 0; i < sorted.length; i++) {
+      const m = sorted[i];
+      if (m[0] !== "DATA") continue;
+      plannedVersion = advanceNodeVersion(plannedVersion, self._version.policy, m[1]);
+      plannedVersions[i] = plannedVersion;
+    }
+  }
+  if (hasTier3 && (!self._wave.insideRunWave || self._control.pullDirtyOwed) && !self._wave.emittedDirtyThisWave) {
+    self._wave.emittedDirtyThisWave = true;
+    self._value.status = "dirty";
+    self._emitToSubs(["DIRTY"], { wave: deliveryWave, last: false });
+  }
+  for (let i = 0; i < sorted.length; i++) {
+    const m = sorted[i];
+    const delivery = { wave: deliveryWave, last: i === sorted.length - 1 };
+    if (isDeferredTier(m[0])) self._wave.emittedSettleThisWave = true;
+    if (m[0] === "DIRTY") {
+      if (!self._wave.emittedDirtyThisWave) {
+        self._wave.emittedDirtyThisWave = true;
+        self._value.status = "dirty";
+        self._emitToSubs(["DIRTY"], delivery);
+      }
+      continue;
+    }
+    if (m[0] === "DATA") {
+      const v = m[1];
+      self._value.cache = v;
+      self._value.hasData = true;
+      self._value.status = "settled";
+      self._version.value = plannedVersions[i];
+      if (self._slot.replayN > 0) {
+        self._value.replayRing.push(v);
+        if (self._value.replayRing.length > self._slot.replayN) self._value.replayRing.shift();
+      }
+      self._emitToSubs(["DATA", v], delivery);
+      continue;
+    }
+    if (m[0] === "RESOLVED") {
+      self._value.status = self._value.hasData ? "resolved" : "sentinel";
+      self._emitToSubs(["RESOLVED"], delivery);
+      continue;
+    }
+    if (m[0] === "INVALIDATE") {
+      self._invalidate(delivery);
+      continue;
+    }
+    if (m[0] === "COMPLETE") {
+      if (self._value.terminal !== void 0) continue;
+      self._value.terminal = true;
+      self._control.pauseBuffer = [];
+      self._value.status = "completed";
+      self._emitToSubs(["COMPLETE"], delivery);
+      continue;
+    }
+    if (m[0] === "ERROR") {
+      if (self._value.terminal !== void 0) continue;
+      self._value.terminal = m[1];
+      self._control.pauseBuffer = [];
+      self._value.status = "errored";
+      self._emitToSubs(["ERROR", m[1]], delivery);
+      continue;
+    }
+    if (m[0] === "TEARDOWN") {
+      self._value.hasTorndown = true;
+      if (self._slot.resetOnTeardown) {
+        self._value.cache = SENTINEL;
+        self._value.hasData = false;
+      }
+      self._emitToSubs(["TEARDOWN"], delivery);
+    }
+  }
+  if (!self._wave.insideRunWave) self._wave.emittedDirtyThisWave = false;
 }
-function validateDownPayloads(msgs) {
+function nodeUp(self, msgs, towardDep, route) {
+  if (self._released) return;
+  const routeState = route ?? { demandFired: /* @__PURE__ */ new Map() };
   for (const m of msgs) {
-    if (m[0] === "DATA" && m[1] === void 0) {
-      throw new Error("down: DATA requires a non-SENTINEL payload (R-data-payload)");
+    if (!isUpAllowed(m[0])) {
+      throw new Error(
+        `ctx.up: ${m[0]} is down-only (tier ${messageTier(m[0])}); up carries control tiers only (R-ctx-up)`
+      );
     }
-    if (m[0] === "ERROR" && isInvalidErrorPayload(m[1])) {
-      throw new Error("down: ERROR requires a non-SENTINEL, non-boolean payload (R-data-payload)");
+  }
+  for (const m of msgs) {
+    if (m[0] === "PAUSE") {
+      self._pauseAcquire(m[1]);
+    } else if (m[0] === "RESUME") {
+      if (self._control.pauseLockset.has(m[1])) {
+        self._pauseRelease(m[1]);
+      } else {
+        self._forwardUp(m, towardDep, routeState);
+      }
+    } else if (m[0] === "PULL") {
+      const demand = normalizePullDemand(m[1]);
+      if (self._slot.pull && demand.pullId === self._slot.pullLock) {
+        if (!self._markDemandRouted(demand.pullId, routeState)) self._onDemand(demand);
+      } else {
+        self._forwardUp(["PULL", demand], towardDep, routeState);
+      }
+    } else if (self._slot.deps.length === 0) {
+      if (m[0] === "INVALIDATE") self._down([["INVALIDATE"]]);
+    } else {
+      self._forwardUp(m, towardDep, routeState);
+    }
+  }
+}
+function nodeMarkDemandRouted(self, lockId, route) {
+  let holders = route.demandFired.get(lockId);
+  if (holders === void 0) {
+    holders = /* @__PURE__ */ new Set();
+    route.demandFired.set(lockId, holders);
+  }
+  const node = self;
+  if (holders.has(node)) return true;
+  holders.add(node);
+  return false;
+}
+function nodeForwardUp(self, m, towardDep, route) {
+  if (self._slot.deps.length === 0) return;
+  if (towardDep !== void 0) {
+    const d = self._slot.deps[towardDep];
+    if (d !== void 0) nodeRuntimeHost(d)._up([m], void 0, route);
+  } else {
+    for (const dep of self._slot.deps) nodeRuntimeHost(dep)._up([m], void 0, route);
+  }
+}
+function nodeIsPaused(self) {
+  return self._control.pauseLockset.size > 0;
+}
+function nodeHasBoundaryPauseLock(self) {
+  if (self._slot.pausable === false) return false;
+  return self._control.pauseLockset.size > 0;
+}
+function nodeIsAsyncPool(self) {
+  return self._slot.handle !== null && self._slot.dispatcher.poolKind(self._slot.handle.poolId) === "async";
+}
+function nodePauseAcquire(self, lockId) {
+  self._control.pauseLockset.add(lockId);
+}
+function nodePauseRelease(self, lockId) {
+  if (!self._control.pauseLockset.has(lockId)) return;
+  self._control.pauseLockset.delete(lockId);
+  if (self._slot.pull && self._control.demandOwed !== void 0) self._fireOwedDemandIfReady();
+  if (self._hasBoundaryPauseLock()) return;
+  scheduleBoundaryDrain(self._core);
+  if (self._slot.pull) return;
+  self._onResume();
+}
+function nodeOnResume(self) {
+  if (self._value.terminal !== void 0) {
+    self._control.pauseBuffer = [];
+    self._control.pausedDepWaveOccurred = false;
+    self._control.demandOwed = void 0;
+    self._control.activePull = void 0;
+    self._control.pullDirtyOwed = false;
+    return;
+  }
+  if (self._control.pauseBuffer.length > 0) {
+    const buf = self._control.pauseBuffer;
+    self._control.pauseBuffer = [];
+    for (const wave of buf) self._down(wave);
+  }
+  if (self._control.pausedDepWaveOccurred) {
+    self._control.pausedDepWaveOccurred = false;
+    self._tryRun();
+  }
+}
+function nodeCanFireDemand(self) {
+  if (self._value.terminal !== void 0 || self._wave.pending > 0) return false;
+  return self._control.pauseLockset.size === 0;
+}
+function nodeDeliverPullDemand(self, demand) {
+  self._control.demandOwed = void 0;
+  self._control.activePull = demand;
+  self._control.inDeliverDemand = true;
+  try {
+    self._firePullDemand();
+  } finally {
+    self._control.activePull = void 0;
+    self._control.inDeliverDemand = false;
+  }
+}
+function nodeOnDemand(self, demand) {
+  if (self._control.inDeliverDemand) return;
+  if (self._canFireDemand()) self._deliverPullDemand(demand);
+  else self._control.demandOwed = demand;
+}
+function nodeFirePullDemand(self) {
+  let drainedBuffer = false;
+  if (self._control.pauseBuffer.length > 0) {
+    const buf = self._control.pauseBuffer;
+    self._control.pauseBuffer = [];
+    for (const wave of buf) self._down(wave);
+    drainedBuffer = true;
+  }
+  if (drainedBuffer) return;
+  if (self._control.pausedDepWaveOccurred) {
+    const gated = self._slot.handle !== null && !self._wave.hasCalledFnOnce && !(self._slot.partial || self._allDepsSettled());
+    if (self._wave.pending > 0 || gated) return;
+    self._control.pausedDepWaveOccurred = false;
+    self._wave.emittedDirtyThisWave = false;
+    self._control.pullDirtyOwed = true;
+    try {
+      self._tryRun();
+    } finally {
+      self._control.pullDirtyOwed = false;
+    }
+    return;
+  }
+  if (self._slot.handle !== null) {
+    if (!self._wave.hasCalledFnOnce && !(self._slot.partial || self._allDepsSettled())) return;
+    self._wave.emittedDirtyThisWave = false;
+    self._control.pullDirtyOwed = true;
+    try {
+      self._runWave();
+    } finally {
+      self._control.pullDirtyOwed = false;
+    }
+  }
+}
+function nodeFireOwedDemandIfReady(self) {
+  if (self._control.inDeliverDemand) return;
+  if (self._slot.pull && self._control.demandOwed !== void 0 && self._canFireDemand()) {
+    self._deliverPullDemand(self._control.demandOwed);
+  }
+}
+function nodeShouldBufferOnPause(self) {
+  if (self._slot.pausable === false) return false;
+  if (!self._isPaused() && !self._isPullQuiet()) return false;
+  if (self._slot.pausable === "resumeAll") return true;
+  if (!self._wave.insideRunWave && self._isAsyncPool() && self._slot.deps.length > 0) return true;
+  return false;
+}
+function nodeInvalidate(self, delivery) {
+  if (!self._value.hasData) return;
+  self._value.cache = SENTINEL;
+  self._value.hasData = false;
+  self._value.status = "sentinel";
+  self._value.replayRing = [];
+  for (const fn of self._hooks.onInvalidate) fn();
+  self._emitToSubs(["INVALIDATE"], delivery);
+}
+function nodeAllDepsTerminal(self) {
+  if (self._slot.deps.length === 0) return false;
+  for (const tm of self._dep.terminal) if (tm === void 0) return false;
+  return true;
+}
+function nodeResetLifecycle(self) {
+  for (const u of self._dep.unsubs) if (u) u();
+  self._dep.unsubs = [];
+  self._dep.idxBoxes = [];
+  self._lifecycle.subscribers.clear();
+  self._lifecycle.activated = false;
+  self._value.terminal = void 0;
+  self._value.hasTorndown = false;
+  self._wave.hasCalledFnOnce = false;
+  self._resetDepState();
+  self._control.pauseLockset.clear();
+  self._control.pauseBuffer = [];
+  self._control.pausedDepWaveOccurred = false;
+  self._control.demandOwed = void 0;
+  self._control.activePull = void 0;
+  self._control.pullDirtyOwed = false;
+  self._value.replayRing = [];
+  const isCompute = self._slot.handle !== null || self._slot.deps.length > 0;
+  if (isCompute) {
+    self._value.cache = SENTINEL;
+    self._value.hasData = false;
+    self._value.status = "sentinel";
+  } else {
+    self._value.status = self._value.hasData ? "settled" : "sentinel";
+  }
+  if (!self._privateState.persist) self._privateState.value = SENTINEL;
+}
+function nodeEmitToSubs(self, msg, delivery) {
+  if (self._released) return;
+  const subs = [...self._lifecycle.subscribers];
+  for (const sink of subs) sink(msg, delivery);
+}
+function nodeCommitBatchedWave(self, wave) {
+  self._wave.batchDirtyOwed = false;
+  self._down(wave);
+}
+function nodeRollbackBatched(self) {
+  if (self._wave.batchDirtyOwed) {
+    self._wave.batchDirtyOwed = false;
+    self._wave.emittedDirtyThisWave = false;
+    self._value.status = self._value.hasData ? "settled" : "sentinel";
+    self._emitToSubs(["RESOLVED"]);
+  }
+}
+function nodeDeferBoundary(self, fn, batchToken) {
+  deferRewire(self._core, fn, {
+    batchToken,
+    isReady: () => !self._hasBoundaryPauseLock()
+  });
+}
+
+// src/node/node-rewire-runtime.ts
+function nodeRequestRewireNext(self, op) {
+  deferRewire(self._core, () => self._applyRewireNext(op), {
+    batchToken: currentBoundaryBatchToken(),
+    isReady: () => !self._hasBoundaryPauseLock()
+  });
+}
+function nodeRequestUpNext(self, msgs, towardDep) {
+  deferRewire(
+    self._core,
+    () => {
+      if (!self._released) self._up(msgs, towardDep);
+    },
+    {
+      batchToken: currentBoundaryBatchToken(),
+      isReady: () => !self._hasBoundaryPauseLock()
+    }
+  );
+}
+function nodeApplyRewireNext(self, op) {
+  if (self._released) return;
+  try {
+    if (op.kind === "add") {
+      const next = self._slot.deps.includes(op.dep) ? [...self._slot.deps] : [...self._slot.deps, op.dep];
+      self._rewire(next, op.fn, { allowTerminalOwner: true });
+    } else if (op.kind === "remove") {
+      self._rewire(
+        self._slot.deps.filter((d) => d !== op.dep),
+        op.fn,
+        { allowTerminalOwner: true }
+      );
+    } else {
+      self._rewire(self._dedupDeps(op.deps), op.fn, { allowTerminalOwner: true });
     }
+  } catch (e) {
+    self._down([["ERROR", errorPayload(e, "rewireNext op failed")]]);
   }
 }
-var Node = class {
+function nodeRewire(self, newDeps, fn, opts = {}) {
+  const node = self;
+  if (self._value.terminal !== void 0 && !opts.allowTerminalOwner)
+    throw new Error(
+      "rewire: node is terminal (completed/errored) \u2014 cannot rewire (R-rewire / D42)"
+    );
+  if (self._wave.insideRunWave)
+    throw new Error(
+      "rewire: mid-fn topology mutation \u2014 a fn mutating its own deps mid-wave is the feedback cycle (R-rewire / D37)"
+    );
+  if (self._wave.inDepMutation)
+    throw new Error(
+      "rewire: reentrant dep mutation \u2014 another replaceDeps/subscribeDep/unsubscribeDep is in flight (R-rewire)"
+    );
+  if (newDeps.includes(node)) throw new Error("rewire: self-dependency rejected (R-rewire / D42)");
+  const oldDeps = self._slot.deps;
+  const added = newDeps.filter((d) => !oldDeps.includes(d));
+  for (const d of added) {
+    if (self._reachableUpstream(d, node))
+      throw new Error(
+        "rewire: would create a cycle \u2014 dep already transitively depends on this node (R-rewire / D42)"
+      );
+    const dep = nodeRuntimeHost(d);
+    if (dep._value.terminal !== void 0 && !dep._slot.resubscribable)
+      throw new Error(
+        "rewire: cannot add a non-resubscribable terminal dep \u2014 would wedge (R-rewire / D42)"
+      );
+    self._assertRewireDepOwner(d);
+  }
+  if (deferAfterBatchForTarget(node, () => {
+    self._rewire(newDeps, fn, { ...opts, allowTerminalOwner: true });
+  })) {
+    return true;
+  }
+  if (!self._lifecycle.activated) self._restoredActivationPending = false;
+  self._wave.inDepMutation = true;
+  self._wave.rewireRunPending = false;
+  let zeroDepUnDirty = false;
+  try {
+    const oldHandle = self._slot.handle;
+    self._slot.handle = self._slot.dispatcher.register(fn, self._slot.pool);
+    if (oldHandle !== null) self._slot.dispatcher.unregister(oldHandle);
+    const removed = oldDeps.filter((d) => !newDeps.includes(d));
+    let removedDirtyContributor = false;
+    for (const d of removed) {
+      const oldIdx = oldDeps.indexOf(d);
+      if (self._dep.dirty[oldIdx]) {
+        removedDirtyContributor = true;
+        self._wave.pending--;
+      }
+      if (self._lifecycle.activated) {
+        const box = self._dep.idxBoxes[oldIdx];
+        if (box) box.v = -1;
+        const unsub = self._dep.unsubs[oldIdx];
+        if (unsub) unsub();
+      }
+    }
+    const n = newDeps.length;
+    const newBatch = new Array(n).fill(null);
+    const newPrev = new Array(n).fill(SENTINEL);
+    const newHasData = new Array(n).fill(false);
+    const newDirty = new Array(n).fill(false);
+    const newTier = new Array(n).fill(0);
+    const newTerminal = new Array(n).fill(void 0);
+    const newTerminalInput = new Array(n).fill(void 0);
+    const newUnsubs = new Array(n);
+    const newBoxes = new Array(n);
+    for (let j = 0; j < n; j++) {
+      const oldIdx = oldDeps.indexOf(newDeps[j]);
+      if (oldIdx !== -1) {
+        newBatch[j] = self._dep.batch[oldIdx];
+        newPrev[j] = self._dep.prev[oldIdx];
+        newHasData[j] = self._dep.hasData[oldIdx];
+        newDirty[j] = self._dep.dirty[oldIdx];
+        newTier[j] = self._dep.tier[oldIdx];
+        newTerminal[j] = self._dep.terminal[oldIdx];
+        newUnsubs[j] = self._dep.unsubs[oldIdx];
+        const box = self._dep.idxBoxes[oldIdx];
+        if (box) box.v = j;
+        newBoxes[j] = box;
+      }
+    }
+    self._slot.deps = newDeps;
+    self._dep.batch = newBatch;
+    self._dep.prev = newPrev;
+    self._dep.hasData = newHasData;
+    self._dep.dirty = newDirty;
+    self._dep.tier = newTier;
+    self._dep.terminal = newTerminal;
+    self._dep.terminalInput = newTerminalInput;
+    self._dep.unsubs = newUnsubs;
+    self._dep.idxBoxes = newBoxes;
+    self._dep.waveData = newDeps.map(() => []);
+    self._dep.waveTokens = new Array(newDeps.length).fill(void 0);
+    self._syncCtx = null;
+    if (self._lifecycle.activated) {
+      for (const d of added) self._subscribeDepAt(d);
+    }
+    notifyTopologyDepsChanged(node, oldDeps, newDeps);
+    if (removedDirtyContributor && self._wave.pending === 0 && self._value.status === "dirty") {
+      if (newDeps.length > 0) self._wave.rewireRunPending = true;
+      else zeroDepUnDirty = true;
+    }
+  } finally {
+    self._wave.inDepMutation = false;
+  }
+  if (self._wave.rewireRunPending) {
+    self._wave.rewireRunPending = false;
+    self._settleRewire();
+  } else if (zeroDepUnDirty) {
+    if (self._wave.emittedDirtyThisWave) self._down([["RESOLVED"]]);
+    else self._value.status = self._value.hasData ? "settled" : "sentinel";
+  }
+  return false;
+}
+
+// src/node/node.ts
+var Node = class _Node {
   _core;
   _id;
   _slot;
@@ -956,12 +1993,56 @@ var Node = class {
   set _syncCtx(ctx) {
     this._syncCtxState.value = ctx;
   }
+  static _retainIndirectRuntimeMethods(node) {
+    void node._dep;
+    void node._hooks;
+    void node._restoredActivationPending;
+    void node._requestRewireNext;
+    void node._requestUpNext;
+    void node._applyRewireNext;
+    void node._reachableUpstream;
+    void node._assertRewireDepOwner;
+    void node._subscribeDepAt;
+    void node._seedRestoredDepAt;
+    void node._recordDepProjection;
+    void node._depProjectionHasData;
+    void node._receiveFromDep;
+    void node._releaseDepDirty;
+    void node._settleAfterAbsorbedTerminal;
+    void node._markDirty;
+    void node._maybeRun;
+    void node._settleRewire;
+    void node._tryRun;
+    void node._allDepsSettled;
+    void node._passthroughEmit;
+    void node._runWave;
+    void node._buildCtx;
+    void node._makeCtx;
+    void node._refreshCtx;
+    void node._makeState;
+    void node._markDemandRouted;
+    void node._forwardUp;
+    void node._isPullQuiet;
+    void node._isPaused;
+    void node._hasBoundaryPauseLock;
+    void node._isAsyncPool;
+    void node._pauseAcquire;
+    void node._pauseRelease;
+    void node._onResume;
+    void node._canFireDemand;
+    void node._deliverPullDemand;
+    void node._onDemand;
+    void node._firePullDemand;
+    void node._fireOwedDemandIfReady;
+    void node._shouldBufferOnPause;
+    void node._invalidate;
+    void node._allDepsTerminal;
+    void node._emitToSubs;
+  }
   constructor(deps, handleOrFn, opts = {}) {
-    const core = constructingCore;
-    constructingCore = void 0;
+    const core = takeConstructingNodeCore();
     const dispatcher = opts.dispatcher ?? defaultDispatcher;
-    const environment = constructingEnvironment ?? EnvironmentDrivers.empty();
-    constructingEnvironment = void 0;
+    const environment = takeConstructingEnvironmentDrivers() ?? EnvironmentDrivers.empty();
     const pool = opts.pool ?? "sync";
     const pausable = opts.pausable ?? true;
     const pullLock = opts.pullId;
@@ -1132,6 +2213,7 @@ var Node = class {
     runtimeQuiescenceReaders.set(this, () => this._isRuntimeQuiescentForRelease());
     subscriberCountReaders.set(this, () => this._subscriberCount());
     activationReaders.set(this, () => this._lifecycle.activated);
+    _Node._retainIndirectRuntimeMethods(this);
   }
   /** R-pull (D55/D272): true while a pull node is not serving a PULL demand pulse. */
   _isPullQuiet() {
@@ -1236,58 +2318,6 @@ var Node = class {
       exitWave();
     }
   }
-  // ── deferred self-rewire (R-rewire-deferred / D47): ctx.rewireNext drain support ──
-  /**
-   * Enqueue a deferred self-rewire op (issued from this node's fn via `ctx.rewireNext`).
-   * Applied at the committed wave boundary (boundary.ts drain), never in place — the in-fn
-   * immediate path (`subscribeDep`/`replaceDeps`/`unsubscribeDep`) still throws mid-run (D37/R-reentrancy).
-   */
-  _requestRewireNext(op) {
-    deferRewire(this._core, () => this._applyRewireNext(op), {
-      batchToken: currentBoundaryBatchToken(),
-      isReady: () => !this._hasBoundaryPauseLock()
-    });
-  }
-  /**
-   * Enqueue a deferred up-going control/demand wave (R-up-routing / R-pull / D269): at the committed wave
-   * boundary, route `msgs` up from THIS node (broadcast, or up the single `towardDep` edge). The
-   * deferred form of `ctx.up` — the SELF-demand path: a consumer issues `ctx.upNext([[PULL,
-   * { pullId }]])` to demand a dep it ALSO reads; the demand applies at the boundary (not mid-fn), so
-   * the pull node's delivery loops back as a FRESH wave rather than re-entering the consumer (D37 /
-   * R-reentrancy). Rides the same R-rewire-deferred (D47) drain as ctx.rewireNext.
-   */
-  _requestUpNext(msgs, towardDep) {
-    deferRewire(
-      this._core,
-      () => {
-        if (!this._released) this._up(msgs, towardDep);
-      },
-      {
-        batchToken: currentBoundaryBatchToken(),
-        isReady: () => !this._hasBoundaryPauseLock()
-      }
-    );
-  }
-  /** Apply one queued self-rewire at the boundary (drain thunk). */
-  _applyRewireNext(op) {
-    if (this._released) return;
-    try {
-      if (op.kind === "add") {
-        const next = this._slot.deps.includes(op.dep) ? [...this._slot.deps] : [...this._slot.deps, op.dep];
-        this._rewire(next, op.fn, { allowTerminalOwner: true });
-      } else if (op.kind === "remove") {
-        this._rewire(
-          this._slot.deps.filter((d) => d !== op.dep),
-          op.fn,
-          { allowTerminalOwner: true }
-        );
-      } else {
-        this._rewire(this._dedupDeps(op.deps), op.fn, { allowTerminalOwner: true });
-      }
-    } catch (e) {
-      this._down([["ERROR", errorPayload(e, "rewireNext op failed")]]);
-    }
-  }
   // ── rewire (R-rewire / D42): intra-graph runtime topology mutation ──
   /**
    * Replace this node's deps atomically (surgical, Option-C). Requires an explicit
@@ -1315,6 +2345,15 @@ var Node = class {
       fn
     );
   }
+  _requestRewireNext(op) {
+    nodeRequestRewireNext(nodeRuntimeHost(this), op);
+  }
+  _requestUpNext(msgs, towardDep) {
+    nodeRequestUpNext(nodeRuntimeHost(this), msgs, towardDep);
+  }
+  _applyRewireNext(op) {
+    nodeApplyRewireNext(nodeRuntimeHost(this), op);
+  }
   _dedupDeps(deps) {
     const seen = /* @__PURE__ */ new Set();
     const out = [];
@@ -1325,7 +2364,6 @@ var Node = class {
       }
     return out;
   }
-  /** Is `target` reachable upstream from `from` (following deps)? Cycle-prevention DFS. */
   _reachableUpstream(from, target) {
     const seen = /* @__PURE__ */ new Set();
     const stack = [from];
@@ -1335,1057 +2373,171 @@ var Node = class {
       if (n === target) return true;
       if (seen.has(n)) continue;
       seen.add(n);
-      for (const d of n._slot.deps) stack.push(d);
+      for (const d of nodeRuntimeHost(n)._slot.deps) stack.push(d);
     }
     return false;
   }
   _assertRewireDepOwner(dep) {
     const selfOwner = getNodeOwner(this);
     const depOwner = getNodeOwner(dep);
-    if (selfOwner !== void 0 && depOwner !== void 0 && selfOwner !== depOwner) {
+    if (selfOwner !== void 0 && depOwner !== void 0 && selfOwner !== depOwner)
       throw new Error(
         "rewire: dep belongs to a different graph; cross-graph deps require a wire bridge (D22 / R-graph-domain)"
       );
-    }
   }
   _rewire(newDeps, fn, opts = {}) {
-    if (this._value.terminal !== void 0 && !opts.allowTerminalOwner)
-      throw new Error(
-        "rewire: node is terminal (completed/errored) \u2014 cannot rewire (R-rewire / D42)"
-      );
-    if (this._wave.insideRunWave)
-      throw new Error(
-        "rewire: mid-fn topology mutation \u2014 a fn mutating its own deps mid-wave is the feedback cycle (R-rewire / D37)"
-      );
-    if (this._wave.inDepMutation)
-      throw new Error(
-        "rewire: reentrant dep mutation \u2014 another replaceDeps/subscribeDep/unsubscribeDep is in flight (R-rewire)"
-      );
-    if (newDeps.includes(this))
-      throw new Error("rewire: self-dependency rejected (R-rewire / D42)");
-    const oldDeps = this._slot.deps;
-    const added = newDeps.filter((d) => !oldDeps.includes(d));
-    for (const d of added) {
-      if (this._reachableUpstream(d, this))
-        throw new Error(
-          "rewire: would create a cycle \u2014 dep already transitively depends on this node (R-rewire / D42)"
-        );
-      if (d._value.terminal !== void 0 && !d._slot.resubscribable)
-        throw new Error(
-          "rewire: cannot add a non-resubscribable terminal dep \u2014 would wedge (R-rewire / D42)"
-        );
-      this._assertRewireDepOwner(d);
-    }
-    if (deferAfterBatchForTarget(this, () => {
-      this._rewire(newDeps, fn, { ...opts, allowTerminalOwner: true });
-    })) {
-      return true;
-    }
-    if (!this._lifecycle.activated) this._restoredActivationPending = false;
-    this._wave.inDepMutation = true;
-    this._wave.rewireRunPending = false;
-    let zeroDepUnDirty = false;
-    try {
-      const oldHandle = this._slot.handle;
-      this._slot.handle = this._slot.dispatcher.register(fn, this._slot.pool);
-      if (oldHandle !== null) this._slot.dispatcher.unregister(oldHandle);
-      const removed = oldDeps.filter((d) => !newDeps.includes(d));
-      let removedDirtyContributor = false;
-      for (const d of removed) {
-        const oldIdx = oldDeps.indexOf(d);
-        if (this._dep.dirty[oldIdx]) {
-          removedDirtyContributor = true;
-          this._wave.pending--;
-        }
-        if (this._lifecycle.activated) {
-          const box = this._dep.idxBoxes[oldIdx];
-          if (box) box.v = -1;
-          const unsub = this._dep.unsubs[oldIdx];
-          if (unsub) unsub();
-        }
-      }
-      const n = newDeps.length;
-      const newBatch = new Array(n).fill(null);
-      const newPrev = new Array(n).fill(SENTINEL);
-      const newHasData = new Array(n).fill(false);
-      const newDirty = new Array(n).fill(false);
-      const newTier = new Array(n).fill(0);
-      const newTerminal = new Array(n).fill(void 0);
-      const newTerminalInput = new Array(n).fill(void 0);
-      const newUnsubs = new Array(n);
-      const newBoxes = new Array(n);
-      for (let j = 0; j < n; j++) {
-        const oldIdx = oldDeps.indexOf(newDeps[j]);
-        if (oldIdx !== -1) {
-          newBatch[j] = this._dep.batch[oldIdx];
-          newPrev[j] = this._dep.prev[oldIdx];
-          newHasData[j] = this._dep.hasData[oldIdx];
-          newDirty[j] = this._dep.dirty[oldIdx];
-          newTier[j] = this._dep.tier[oldIdx];
-          newTerminal[j] = this._dep.terminal[oldIdx];
-          newUnsubs[j] = this._dep.unsubs[oldIdx];
-          const box = this._dep.idxBoxes[oldIdx];
-          if (box) box.v = j;
-          newBoxes[j] = box;
-        }
-      }
-      this._slot.deps = newDeps;
-      this._dep.batch = newBatch;
-      this._dep.prev = newPrev;
-      this._dep.hasData = newHasData;
-      this._dep.dirty = newDirty;
-      this._dep.tier = newTier;
-      this._dep.terminal = newTerminal;
-      this._dep.terminalInput = newTerminalInput;
-      this._dep.unsubs = newUnsubs;
-      this._dep.idxBoxes = newBoxes;
-      this._dep.waveData = newDeps.map(() => []);
-      this._dep.waveTokens = new Array(newDeps.length).fill(void 0);
-      this._syncCtx = null;
-      if (this._lifecycle.activated) {
-        for (const d of added) this._subscribeDepAt(d);
-      }
-      notifyTopologyDepsChanged(this, oldDeps, newDeps);
-      if (removedDirtyContributor && this._wave.pending === 0 && this._value.status === "dirty") {
-        if (newDeps.length > 0) this._wave.rewireRunPending = true;
-        else zeroDepUnDirty = true;
-      }
-    } finally {
-      this._wave.inDepMutation = false;
-    }
-    if (this._wave.rewireRunPending) {
-      this._wave.rewireRunPending = false;
-      this._settleRewire();
-    } else if (zeroDepUnDirty) {
-      if (this._wave.emittedDirtyThisWave) this._down([["RESOLVED"]]);
-      else this._value.status = this._value.hasData ? "settled" : "sentinel";
-    }
-    return false;
+    return nodeRewire(nodeRuntimeHost(this), newDeps, fn, opts);
   }
   // ── activation / deactivation (lazy; R-rom-ram) ──
   _activate() {
-    this._lifecycle.activated = true;
-    const seedRestoredDeps = this._restoredActivationPending;
-    this._restoredActivationPending = false;
-    this._dep.unsubs = new Array(this._slot.deps.length);
-    this._dep.idxBoxes = new Array(this._slot.deps.length);
-    for (const dep of this._slot.deps)
-      this._subscribeDepAt(dep, { seedRestored: seedRestoredDeps });
-    if (this._slot.deps.length === 0 && this._slot.handle !== null && !this._wave.hasCalledFnOnce) {
-      this._runWave();
-    }
-  }
-  /**
-   * Subscribe to a dep. The dispatch callback reads the dep's CURRENT index from a
-   * mutable box (O(1)); a surgical rewire that reorders kept deps just updates the box
-   * (R-rewire Option-C / D42) — no re-subscribe, no per-message indexOf scan. A removed
-   * dep's box is set to -1 so any stale in-flight callback drops (drain).
-   */
-  _subscribeDepAt(depNode, opts = {}) {
-    const idx0 = this._slot.deps.indexOf(depNode);
-    const box = { v: idx0 };
-    let ignoreInitialPush = opts.seedRestored === true;
-    if (ignoreInitialPush && idx0 !== -1) {
-      this._seedRestoredDepAt(idx0, depNode);
-      if (depNode._value.terminal !== void 0 && !depNode._slot.resubscribable) {
-        this._dep.unsubs[idx0] = () => {
-        };
-        this._dep.idxBoxes[idx0] = box;
-        return;
-      }
-    }
-    const unsub = depNode.subscribe((msg, delivery) => {
-      if (ignoreInitialPush && delivery === void 0) return;
-      if (ignoreInitialPush) ignoreInitialPush = false;
-      if (box.v === -1) return;
-      this._receiveFromDep(box.v, msg, delivery);
-    });
-    if (ignoreInitialPush && idx0 !== -1 && box.v !== -1) this._seedRestoredDepAt(idx0, depNode);
-    ignoreInitialPush = false;
-    if (idx0 !== -1) {
-      this._dep.unsubs[idx0] = unsub;
-      this._dep.idxBoxes[idx0] = box;
-    }
-  }
-  _seedRestoredDepAt(idx, depNode) {
-    const seedData = depNode._value.hasData && !depNode._slot.pull;
-    this._dep.batch[idx] = null;
-    this._dep.waveData[idx] = [];
-    this._dep.waveTokens[idx] = void 0;
-    this._dep.prev[idx] = seedData ? depNode._value.cache : SENTINEL;
-    this._dep.hasData[idx] = seedData;
-    this._dep.dirty[idx] = false;
-    this._dep.tier[idx] = seedData ? 3 : 0;
-    this._dep.terminal[idx] = depNode._value.terminal;
-    this._dep.terminalInput[idx] = void 0;
+    nodeActivate(nodeRuntimeHost(this));
   }
   _deactivate() {
-    this._lifecycle.activated = false;
-    for (const u of this._dep.unsubs) if (u) u();
-    this._dep.unsubs = [];
-    this._dep.idxBoxes = [];
-    for (const fn of this._hooks.onDeactivation) fn();
-    this._hooks.onDeactivation = [];
-    this._hooks.onInvalidate = [];
-    const isCompute = this._slot.handle !== null || this._slot.deps.length > 0;
-    if (isCompute) {
-      this._value.cache = SENTINEL;
-      this._value.hasData = false;
-      this._value.status = "sentinel";
-    }
-    this._resetDepState();
-    this._wave.hasCalledFnOnce = false;
-    this._control.pauseLockset.clear();
-    this._control.pauseBuffer = [];
-    this._control.pausedDepWaveOccurred = false;
-    this._control.demandOwed = void 0;
-    this._control.activePull = void 0;
-    this._control.pullDirtyOwed = false;
-    this._value.replayRing = [];
-    if (!this._privateState.persist) this._privateState.value = SENTINEL;
+    nodeDeactivate(nodeRuntimeHost(this));
   }
   _assertNotReleased(op) {
     if (this._released)
       throw new Error(`${op}: node has been released from its graph lifecycle (D122)`);
   }
   _subscriberCount() {
-    return this._lifecycle.subscribers.size;
+    return nodeSubscriberCount(nodeRuntimeHost(this));
   }
   _isRuntimeQuiescentForRelease() {
-    return !this._released && this._value.status !== "dirty" && this._value.status !== "pending" && this._wave.pending === 0 && !this._wave.insideRunWave && !this._wave.inDepMutation && !this._wave.rewireRunPending && !this._wave.batchDirtyOwed && this._dep.dirty.every((dirty) => !dirty) && this._control.pauseBuffer.length === 0 && !this._control.pausedDepWaveOccurred && this._control.demandOwed === void 0 && this._control.activePull === void 0 && !this._control.inDeliverDemand && this._control.pauseLockset.size === 0;
+    return nodeIsRuntimeQuiescentForRelease(nodeRuntimeHost(this));
   }
   _releaseRuntime() {
-    if (this._released) return;
-    this._released = true;
-    releasedNodes.add(this);
-    let releaseError;
-    const recordReleaseError = (error) => {
-      if (releaseError === void 0) releaseError = error;
-    };
-    this._lifecycle.activated = false;
-    for (const u of this._dep.unsubs) {
-      try {
-        u();
-      } catch (error) {
-        recordReleaseError(error);
-      }
-    }
-    for (const fn of this._hooks.onDeactivation) {
-      try {
-        fn();
-      } catch (error) {
-        recordReleaseError(error);
-      }
-    }
-    this._dep.unsubs = [];
-    this._dep.idxBoxes = [];
-    this._lifecycle.subscribers.clear();
-    if (this._slot.handle !== null) {
-      this._slot.dispatcher.unregister(this._slot.handle);
-      this._slot.handle = null;
-    }
-    this._slot.deps = [];
-    this._dep.batch = [];
-    this._dep.waveData = [];
-    this._dep.waveTokens = [];
-    this._dep.prev = [];
-    this._dep.hasData = [];
-    this._dep.dirty = [];
-    this._dep.tier = [];
-    this._dep.terminal = [];
-    this._dep.terminalInput = [];
-    this._value.cache = SENTINEL;
-    this._value.hasData = false;
-    this._value.status = "sentinel";
-    this._value.terminal = void 0;
-    this._value.replayRing = [];
-    this._privateState.value = SENTINEL;
-    this._privateState.persist = false;
-    this._syncCtx = null;
-    this._resetDepState();
-    this._hooks.onDeactivation = [];
-    this._hooks.onInvalidate = [];
-    this._control.pauseLockset.clear();
-    this._control.pauseBuffer = [];
-    this._control.pausedDepWaveOccurred = false;
-    this._control.demandOwed = void 0;
-    this._control.activePull = void 0;
-    this._control.pullDirtyOwed = false;
-    this._restoredActivationPending = false;
-    checkpointReaders.delete(this);
-    restoreWriters.delete(this);
-    runtimeReleasers.delete(this);
-    runtimeQuiescenceReaders.delete(this);
-    subscriberCountReaders.delete(this);
-    activationReaders.delete(this);
-    ownerTokens.delete(this);
-    topologyDepsChangedObservers.delete(this);
-    this._core.releaseSlot(this._id);
-    if (releaseError !== void 0) throw releaseError;
+    nodeReleaseRuntime(nodeRuntimeHost(this));
   }
   _resetDepState() {
-    const n = this._slot.deps.length;
-    for (let i = 0; i < n; i++) {
-      this._dep.batch[i] = null;
-      this._dep.waveData[i] = [];
-      this._dep.waveTokens[i] = void 0;
-      this._dep.prev[i] = SENTINEL;
-      this._dep.hasData[i] = false;
-      this._dep.dirty[i] = false;
-      this._dep.tier[i] = 0;
-      this._dep.terminal[i] = void 0;
-      this._dep.terminalInput[i] = void 0;
-    }
-    this._wave.pending = 0;
-    this._wave.emittedDirtyThisWave = false;
-  }
-  // ── upstream wave receive (two-phase + diamond) ──
+    nodeResetDepState(nodeRuntimeHost(this));
+  }
+  _subscribeDepAt(depNode, opts = {}) {
+    nodeSubscribeDepAt(nodeRuntimeHost(this), depNode, opts);
+  }
+  _seedRestoredDepAt(idx, depNode) {
+    nodeSeedRestoredDepAt(nodeRuntimeHost(this), idx, depNode);
+  }
   _recordDepProjection(idx, delivery) {
-    const token = delivery?.wave ?? {};
-    if (this._dep.waveTokens[idx] !== token) {
-      this._dep.waveData[idx].push([]);
-      this._dep.waveTokens[idx] = token;
-    }
-    return this._dep.waveData[idx][this._dep.waveData[idx].length - 1];
+    return nodeRecordDepProjection(nodeRuntimeHost(this), idx, delivery);
   }
   _depProjectionHasData(idx) {
-    const projection = this._dep.waveData[idx][this._dep.waveData[idx].length - 1];
-    return projection?.some((v) => v !== SENTINEL) ?? false;
+    return nodeDepProjectionHasData(nodeRuntimeHost(this), idx);
   }
   _receiveFromDep(idx, msg, delivery) {
-    if (this._released) return;
-    const t = msg[0];
-    if (t === "START") return;
-    const isLastInDeliveredWave = delivery?.last ?? true;
-    if (this._value.terminal !== void 0) {
-      if (t === "TEARDOWN") this._down([["TEARDOWN"]]);
-      return;
-    }
-    if (t === "INVALIDATE") {
-      const projection = this._recordDepProjection(idx, delivery);
-      projection.push(SENTINEL);
-      if (projection.some((v) => v !== SENTINEL) && isLastInDeliveredWave) this._maybeRun();
-      this._dep.prev[idx] = SENTINEL;
-      this._dep.hasData[idx] = false;
-      this._dep.batch[idx] = null;
-      if (this._dep.dirty[idx]) {
-        this._dep.dirty[idx] = false;
-        this._wave.pending--;
-      }
-      if (this._control.pausedDepWaveOccurred && this._dep.batch.every((b) => b === null)) {
-        this._control.pausedDepWaveOccurred = false;
-      }
-      const hadData = this._value.hasData;
-      this._invalidate();
-      if (this._wave.pending === 0 && this._wave.emittedDirtyThisWave) {
-        if (!hadData) this._down([["RESOLVED"]]);
-        else this._wave.emittedDirtyThisWave = false;
-      }
-      this._fireOwedDemandIfReady();
-      return;
-    }
-    if (isTerminal(t)) {
-      const isError = t === "ERROR";
-      const errPayload = isError ? msg[1] : void 0;
-      this._dep.terminal[idx] = isError ? errPayload : true;
-      this._dep.terminalInput[idx] = isError ? errPayload : true;
-      this._releaseDepDirty(idx);
-      const ranValueBeforeTerminal = this._depProjectionHasData(idx) && isLastInDeliveredWave;
-      if (ranValueBeforeTerminal) this._maybeRun();
-      if (isError && this._slot.errorWhenDepsError) {
-        this._down([["ERROR", errPayload]]);
-      } else if (this._slot.terminalAsRealInput) {
-        if (ranValueBeforeTerminal) {
-          this._fireOwedDemandIfReady();
-          return;
-        }
-        this._maybeRun();
-      } else if (this._slot.completeWhenDepsComplete && this._allDepsTerminal()) {
-        this._down([["COMPLETE"]]);
-      } else {
-        this._settleAfterAbsorbedTerminal();
-      }
-      this._fireOwedDemandIfReady();
-      return;
-    }
-    if (t === "TEARDOWN") {
-      this._down([["TEARDOWN"]]);
-      return;
-    }
-    if (t === "DIRTY") {
-      if (!this._dep.dirty[idx]) {
-        this._dep.dirty[idx] = true;
-        this._wave.pending++;
-        this._dep.tier[idx] = 2;
-        this._markDirty();
-      }
-      return;
-    }
-    if (t === "DATA") {
-      const v = msg[1];
-      this._recordDepProjection(idx, delivery).push(v);
-      const b = this._dep.batch[idx];
-      if (b === null) this._dep.batch[idx] = [v];
-      else b.push(v);
-      this._dep.prev[idx] = v;
-      this._dep.hasData[idx] = true;
-      this._dep.tier[idx] = 3;
-      if (this._dep.dirty[idx]) {
-        this._dep.dirty[idx] = false;
-        this._wave.pending--;
-      }
-      if (isLastInDeliveredWave) this._maybeRun();
-      this._fireOwedDemandIfReady();
-      return;
-    }
-    if (t === "RESOLVED") {
-      this._recordDepProjection(idx, delivery);
-      this._dep.tier[idx] = 3;
-      if (this._dep.dirty[idx]) {
-        this._dep.dirty[idx] = false;
-        this._wave.pending--;
-      }
-      if (isLastInDeliveredWave) this._maybeRun();
-      this._fireOwedDemandIfReady();
-      return;
-    }
+    nodeReceiveFromDep(nodeRuntimeHost(this), idx, msg, delivery);
   }
-  /**
-   * R-terminal-settles-dirty (B35): release a dep's outstanding in-wave DIRTY contribution.
-   * A settle-class event for that dep (DATA/RESOLVED inline above, INVALIDATE, and now
-   * COMPLETE/ERROR) clears its dirty flag + decrements _pending. No-op if the dep already
-   * settled this wave (DATA/RESOLVED ran first) — so the normal DATA-then-COMPLETE flow is
-   * unaffected. This makes the exactly-one-settle invariant a single, shared step.
-   */
   _releaseDepDirty(idx) {
-    if (this._dep.dirty[idx]) {
-      this._dep.dirty[idx] = false;
-      this._wave.pending--;
-    }
+    nodeReleaseDepDirty(nodeRuntimeHost(this), idx);
   }
-  /**
-   * R-terminal-settles-dirty (B35): settle a node whose dirtied dep was released by an ABSORBED
-   * terminal that is NOT a real input (a plain derived/effect — the common default-node case when
-   * one of several deps completes while others stay live). Runs only when the release drained
-   * _pending while the node still owes a downstream settle (it broadcast DIRTY this wave):
-   *   - if some OTHER dep delivered real DATA this wave (a value occurred) → recompute (→ DATA);
-   *   - else the terminal's signalled change did not materialise (no value) → one undirty RESOLVED
-   *     (R-resolved-undirty), keeping the cache (a terminal, unlike INVALIDATE, leaves the value).
-   * A terminalAsRealInput node instead recomputes unconditionally (its fn reads the terminal).
-   */
   _settleAfterAbsorbedTerminal() {
-    if (this._wave.pending !== 0 || !this._wave.emittedDirtyThisWave) return;
-    const sawData = this._dep.batch.some((b) => b !== null && b.length > 0);
-    if (sawData) this._maybeRun();
-    if (this._wave.emittedDirtyThisWave) this._down([["RESOLVED"]]);
+    nodeSettleAfterAbsorbedTerminal(nodeRuntimeHost(this));
   }
   _markDirty() {
-    this._value.status = "dirty";
-    if (this._isPullQuiet()) return;
-    if (!this._wave.emittedDirtyThisWave) {
-      this._wave.emittedDirtyThisWave = true;
-      this._emitToSubs(["DIRTY"]);
-    }
+    nodeMarkDirty(nodeRuntimeHost(this));
   }
   _maybeRun() {
-    if (this._wave.inDepMutation) {
-      this._wave.rewireRunPending = true;
-      return;
-    }
-    if (this._slot.pausable === true && (this._isPaused() || this._isPullQuiet())) {
-      this._control.pausedDepWaveOccurred = true;
-      return;
-    }
-    this._tryRun();
+    nodeMaybeRun(nodeRuntimeHost(this));
   }
-  /**
-   * R-rewire atomic settle (after a rewire that warrants a recompute): emit a proper
-   * two-phase DIRTY→DATA wave (R-dirty-before-data — a rewire-triggered settle is a wave),
-   * once, with every added dep already wired. Mirrors _maybeRun/_tryRun's pause + gate +
-   * pending guards, then injects the phase-1 DIRTY the added dep's [START,DATA] handshake
-   * did not carry.
-   */
   _settleRewire() {
-    if (this._slot.pausable === true && this._isPaused()) {
-      this._control.pausedDepWaveOccurred = true;
-      return;
-    }
-    if (this._wave.pending > 0) return;
-    if (this._slot.handle === null) {
-      this._passthroughEmit();
-      return;
-    }
-    if (!this._wave.hasCalledFnOnce && !(this._slot.partial || this._allDepsSettled())) return;
-    this._markDirty();
-    this._runWave();
+    nodeSettleRewire(nodeRuntimeHost(this));
   }
   _tryRun() {
-    if (this._wave.pending > 0) return;
-    if (this._slot.handle === null) {
-      this._passthroughEmit();
-      return;
-    }
-    if (!this._wave.hasCalledFnOnce) {
-      if (this._slot.partial || this._allDepsSettled()) this._runWave();
-      return;
-    }
-    this._runWave();
+    nodeTryRun(nodeRuntimeHost(this));
   }
   _allDepsSettled() {
-    for (let i = 0; i < this._slot.deps.length; i++) {
-      if (this._dep.hasData[i]) continue;
-      if (this._slot.terminalAsRealInput && this._dep.terminal[i] !== void 0) continue;
-      return false;
-    }
-    return true;
+    return nodeAllDepsSettled(nodeRuntimeHost(this));
   }
   _passthroughEmit() {
-    const b = this._dep.batch[0];
-    if (b !== null && b.length > 0) {
-      this._down([["DATA", b[b.length - 1]]]);
-    } else if (this._wave.emittedDirtyThisWave) {
-      this._down([["RESOLVED"]]);
-    }
-    this._dep.batch[0] = null;
-    this._wave.emittedDirtyThisWave = false;
+    nodePassthroughEmit(nodeRuntimeHost(this));
   }
   _runWave() {
-    if (this._wave.insideRunWave)
-      throw new Error(
-        "synchronous feedback cycle: node fn re-entered its own wave (R-reentrancy / D37)"
-      );
-    this._wave.hasCalledFnOnce = true;
-    this._hooks.onInvalidate = [];
-    this._hooks.onDeactivation = [];
-    const ctx = this._buildCtx();
-    const wasDirty = this._wave.emittedDirtyThisWave;
-    this._wave.emittedSettleThisWave = false;
-    this._wave.insideRunWave = true;
-    try {
-      this._slot.dispatcher.invoke(this._slot.handle, ctx);
-    } finally {
-      this._wave.insideRunWave = false;
-    }
-    if (wasDirty && !this._wave.emittedSettleThisWave && this._value.terminal === void 0 && !this._isAsyncPool()) {
-      this._down([["RESOLVED"]]);
-    }
-    for (let i = 0; i < this._dep.batch.length; i++) {
-      this._dep.batch[i] = null;
-      this._dep.waveData[i] = [];
-      this._dep.waveTokens[i] = void 0;
-      this._dep.terminalInput[i] = void 0;
-    }
-    this._wave.emittedDirtyThisWave = false;
+    nodeRunWave(nodeRuntimeHost(this));
   }
-  // ── ctx construction (L3-Q5: sync = node-stable reused ctx; async = per-invocation) ──
   _buildCtx() {
-    const kind = this._slot.handle ? this._slot.dispatcher.poolKind(this._slot.handle.poolId) : "sync";
-    if (kind === "sync") {
-      if (this._syncCtx === null) this._syncCtx = this._makeCtx();
-      this._refreshCtx(this._syncCtx);
-      return this._syncCtx;
-    }
-    return this._makeCtx({
-      waveData: this._dep.waveData.map((waves) => waves.map((w) => [...w])),
-      terminal: this._dep.terminalInput.map(terminalView),
-      latest: [...this._dep.prev]
-    });
+    return nodeBuildCtx(nodeRuntimeHost(this));
   }
   _makeCtx(snapshot) {
-    const ctx = {
-      // Wave-owner boundary (D47): a SYNC fn's emit nests under the public entry that drove
-      // it (cheap inc/dec, no early drain); an ASYNC-pool fn re-enters here from its stashed
-      // ctx at depth 0, so this is the boundary that drains any rewireNext it issued.
-      up: (msgs, towardDep) => {
-        if (this._released) return;
-        enterWave();
-        try {
-          this._up(msgs, towardDep);
-        } finally {
-          exitWave();
-        }
-      },
-      down: (msgs) => {
-        if (this._released) return;
-        enterWave();
-        try {
-          this._down(msgs);
-        } finally {
-          exitWave();
-        }
-      },
-      waveData: snapshot?.waveData ?? this._dep.waveData,
-      terminal: snapshot?.terminal ?? this._dep.terminalInput.map(terminalView),
-      state: this._makeState(),
-      onDeactivation: (fn) => {
-        if (this._released) return;
-        this._hooks.onDeactivation.push(fn);
-      },
-      onInvalidate: (fn) => {
-        if (this._released) return;
-        this._hooks.onInvalidate.push(fn);
-      },
-      environment: () => this._slot.environment,
-      // R-rewire-deferred (D47): defer a self-dep-set mutation to the committed boundary.
-      rewireNext: {
-        subscribeDep: (dep, fn) => this._requestRewireNext({ kind: "add", dep, fn }),
-        unsubscribeDep: (dep, fn) => this._requestRewireNext({ kind: "remove", dep, fn }),
-        replaceDeps: (deps, fn) => this._requestRewireNext({ kind: "set", deps, fn })
-      },
-      // R-up-routing / R-pull (D269): deferred up — route a control/demand wave (e.g. PULL)
-      // up the declared cone at the committed boundary. The SELF-demand path: an
-      // immediate ctx.up whose delivery loops back re-enters this fn (D37 / R-reentrancy).
-      upNext: (msgs, towardDep) => this._requestUpNext(msgs, towardDep),
-      ...this._control.activePull === void 0 ? {} : { pull: this._control.activePull },
-      [CTX_DEP_CACHE]: { latest: snapshot?.latest ?? this._dep.prev },
-      [CTX_NODE_BINDING]: {
-        dispatcher: this._slot.dispatcher,
-        create: (factory) => withEnvironmentDrivers(this._slot.environment, () => withNodeCore(this._core, factory))
-      }
-    };
-    if (this._slot.dynamic) {
-      ctx.track = (i) => ctx[CTX_DEP_CACHE]?.latest[i];
-    }
-    return ctx;
+    return nodeMakeCtx(nodeRuntimeHost(this), snapshot);
   }
   _refreshCtx(ctx) {
-    ctx.waveData = this._dep.waveData;
-    ctx.terminal = this._dep.terminalInput.map(terminalView);
-    if (this._control.activePull === void 0) {
-      delete ctx.pull;
-    } else {
-      ctx.pull = this._control.activePull;
-    }
-    ctx[CTX_DEP_CACHE] = { latest: this._dep.prev };
+    nodeRefreshCtx(nodeRuntimeHost(this), ctx);
   }
   _makeState() {
-    return {
-      get: () => this._privateState.value,
-      set: (v) => {
-        this._privateState.value = v;
-      },
-      persist: (on = true) => {
-        this._privateState.persist = on;
-      }
-    };
+    return nodeMakeState(nodeRuntimeHost(this));
   }
   // ── downstream emission pipeline (the unified waist) ──
   _down(msgs) {
-    if (this._released) return;
-    validateDownPayloads(msgs);
-    const deliveryWave = {};
-    const assertVersionDataCompatible = (wave) => {
-      for (const m of wave) {
-        if (m[0] === "DATA") assertNodeVersionDataCompatible(this._version.policy, m[1]);
-      }
-    };
-    const snapshotVersionData = (wave) => wave.map(
-      (m) => m[0] === "DATA" ? ["DATA", snapshotNodeVersionData(this._version.policy, m[1])] : m
-    );
-    assertVersionDataCompatible(msgs);
-    if (this._value.terminal !== void 0) {
-      if (!msgs.some((m) => m[0] === "TEARDOWN")) return;
-      this._value.hasTorndown = true;
-      if (this._slot.resetOnTeardown) {
-        this._value.cache = SENTINEL;
-        this._value.hasData = false;
-      }
-      this._emitToSubs(["TEARDOWN"], { wave: deliveryWave, last: true });
-      return;
-    }
-    let sorted = [...msgs].sort((a, b) => messageTier(a[0]) - messageTier(b[0]));
-    const firstInvalidate = sorted.findIndex((m) => m[0] === "INVALIDATE");
-    if (firstInvalidate !== -1) {
-      sorted = sorted.filter((m, i) => m[0] !== "INVALIDATE" || i === firstInvalidate);
-    }
-    const hasTeardown = sorted.some((m) => m[0] === "TEARDOWN");
-    const hasTerminal = sorted.some((m) => m[0] === "COMPLETE" || m[0] === "ERROR");
-    if (hasTeardown && !hasTerminal && this._value.terminal === void 0 && !this._value.hasTorndown) {
-      sorted = [["COMPLETE"], ...sorted];
-    }
-    if (!this._wave.insideRunWave && currentBatch()) {
-      const deferred = snapshotVersionData(sorted.filter((m) => isDeferredTier(m[0])));
-      if (deferred.length > 0) {
-        if (!this._wave.emittedDirtyThisWave) {
-          this._wave.emittedDirtyThisWave = true;
-          this._value.status = "dirty";
-          this._emitToSubs(["DIRTY"], { wave: deliveryWave, last: false });
-        }
-        this._wave.batchDirtyOwed = true;
-        deferToBatch(this, deferred);
-        return;
-      }
-    }
-    if (this._shouldBufferOnPause()) {
-      const buffered = snapshotVersionData(sorted.filter((m) => isPauseBufferedTier(m[0])));
-      if (buffered.length > 0) {
-        this._wave.emittedSettleThisWave = true;
-        this._control.pauseBuffer.push(buffered);
-      }
-      sorted = sorted.filter((m) => !isPauseBufferedTier(m[0]));
-      if (sorted.length === 0) return;
-    }
-    let dataCount = 0;
-    let hasTier3 = false;
-    let hasResolved = false;
-    for (const m of sorted) {
-      if (m[0] === "DATA") dataCount++;
-      if (m[0] === "RESOLVED") hasResolved = true;
-      if (isValueTier(m[0])) hasTier3 = true;
-    }
-    if (dataCount >= 1 && hasResolved) {
-      throw new Error(
-        "down: a wave cannot mix DATA and RESOLVED (tier-3 exclusivity, R-resolved-undirty)"
-      );
-    }
-    const plannedVersions = new Array(sorted.length);
-    if (dataCount > 0) {
-      let plannedVersion = this._version.value;
-      for (let i = 0; i < sorted.length; i++) {
-        const m = sorted[i];
-        if (m[0] !== "DATA") continue;
-        plannedVersion = advanceNodeVersion(plannedVersion, this._version.policy, m[1]);
-        plannedVersions[i] = plannedVersion;
-      }
-    }
-    if (hasTier3 && (!this._wave.insideRunWave || this._control.pullDirtyOwed) && !this._wave.emittedDirtyThisWave) {
-      this._wave.emittedDirtyThisWave = true;
-      this._value.status = "dirty";
-      this._emitToSubs(["DIRTY"], { wave: deliveryWave, last: false });
-    }
-    for (let i = 0; i < sorted.length; i++) {
-      const m = sorted[i];
-      const delivery = { wave: deliveryWave, last: i === sorted.length - 1 };
-      if (isDeferredTier(m[0])) this._wave.emittedSettleThisWave = true;
-      if (m[0] === "DIRTY") {
-        if (!this._wave.emittedDirtyThisWave) {
-          this._wave.emittedDirtyThisWave = true;
-          this._value.status = "dirty";
-          this._emitToSubs(["DIRTY"], delivery);
-        }
-        continue;
-      }
-      if (m[0] === "DATA") {
-        const v = m[1];
-        this._value.cache = v;
-        this._value.hasData = true;
-        this._value.status = "settled";
-        this._version.value = plannedVersions[i];
-        if (this._slot.replayN > 0) {
-          this._value.replayRing.push(v);
-          if (this._value.replayRing.length > this._slot.replayN) this._value.replayRing.shift();
-        }
-        this._emitToSubs(["DATA", v], delivery);
-        continue;
-      }
-      if (m[0] === "RESOLVED") {
-        this._value.status = this._value.hasData ? "resolved" : "sentinel";
-        this._emitToSubs(["RESOLVED"], delivery);
-        continue;
-      }
-      if (m[0] === "INVALIDATE") {
-        this._invalidate(delivery);
-        continue;
-      }
-      if (m[0] === "COMPLETE") {
-        if (this._value.terminal !== void 0) continue;
-        this._value.terminal = true;
-        this._control.pauseBuffer = [];
-        this._value.status = "completed";
-        this._emitToSubs(["COMPLETE"], delivery);
-        continue;
-      }
-      if (m[0] === "ERROR") {
-        if (this._value.terminal !== void 0) continue;
-        this._value.terminal = m[1];
-        this._control.pauseBuffer = [];
-        this._value.status = "errored";
-        this._emitToSubs(["ERROR", m[1]], delivery);
-        continue;
-      }
-      if (m[0] === "TEARDOWN") {
-        this._value.hasTorndown = true;
-        if (this._slot.resetOnTeardown) {
-          this._value.cache = SENTINEL;
-          this._value.hasData = false;
-        }
-        this._emitToSubs(["TEARDOWN"], delivery);
-      }
-    }
-    if (!this._wave.insideRunWave) this._wave.emittedDirtyThisWave = false;
+    nodeDown(nodeRuntimeHost(this), msgs);
   }
   _up(msgs, towardDep, route) {
-    if (this._released) return;
-    const routeState = route ?? { demandFired: /* @__PURE__ */ new Map() };
-    for (const m of msgs) {
-      if (!isUpAllowed(m[0])) {
-        throw new Error(
-          `ctx.up: ${m[0]} is down-only (tier ${messageTier(m[0])}); up carries control tiers only (R-ctx-up)`
-        );
-      }
-    }
-    for (const m of msgs) {
-      if (m[0] === "PAUSE") {
-        this._pauseAcquire(m[1]);
-      } else if (m[0] === "RESUME") {
-        if (this._control.pauseLockset.has(m[1])) {
-          this._pauseRelease(m[1]);
-        } else {
-          this._forwardUp(m, towardDep, routeState);
-        }
-      } else if (m[0] === "PULL") {
-        const demand = normalizePullDemand(m[1]);
-        if (this._slot.pull && demand.pullId === this._slot.pullLock) {
-          if (!this._markDemandRouted(demand.pullId, routeState)) this._onDemand(demand);
-        } else {
-          this._forwardUp(["PULL", demand], towardDep, routeState);
-        }
-      } else if (this._slot.deps.length === 0) {
-        if (m[0] === "INVALIDATE") this._down([["INVALIDATE"]]);
-      } else {
-        this._forwardUp(m, towardDep, routeState);
-      }
-    }
+    nodeUp(nodeRuntimeHost(this), msgs, towardDep, route);
   }
   _markDemandRouted(lockId, route) {
-    let holders = route.demandFired.get(lockId);
-    if (holders === void 0) {
-      holders = /* @__PURE__ */ new Set();
-      route.demandFired.set(lockId, holders);
-    }
-    if (holders.has(this)) return true;
-    holders.add(this);
-    return false;
+    return nodeMarkDemandRouted(nodeRuntimeHost(this), lockId, route);
   }
-  /**
-   * Forward one up-going control message toward deps (R-up-routing): up the single declared edge
-   * `towardDep` (directed — prunes other branches; only meaningful on the issuer's FIRST hop) or
-   * broadcast up ALL deps. A depless source has no deps → the message DROPS here (the terminus —
-   * e.g. a cone-routed PULL whose pullId no node up this cone holds, R-up-at-source). Recursive
-   * forwarding carries the same per-wave route state and no `towardDep` → broadcast beyond the
-   * first hop.
-   */
   _forwardUp(m, towardDep, route) {
-    if (this._slot.deps.length === 0) return;
-    if (towardDep !== void 0) {
-      const d = this._slot.deps[towardDep];
-      if (d !== void 0) d._up([m], void 0, route);
-    } else {
-      for (const dep of this._slot.deps) dep._up([m], void 0, route);
-    }
+    nodeForwardUp(nodeRuntimeHost(this), m, towardDep, route);
   }
-  // ── PAUSE/RESUME lockset (R-pause-lockset) + modes (R-pause-modes) ──
   _isPaused() {
-    return this._control.pauseLockset.size > 0;
+    return nodeIsPaused(nodeRuntimeHost(this));
   }
   _hasBoundaryPauseLock() {
-    if (this._slot.pausable === false) return false;
-    return this._control.pauseLockset.size > 0;
+    return nodeHasBoundaryPauseLock(nodeRuntimeHost(this));
   }
   _isAsyncPool() {
-    return this._slot.handle !== null && this._slot.dispatcher.poolKind(this._slot.handle.poolId) === "async";
+    return nodeIsAsyncPool(nodeRuntimeHost(this));
   }
   _pauseAcquire(lockId) {
-    this._control.pauseLockset.add(lockId);
+    nodePauseAcquire(nodeRuntimeHost(this), lockId);
   }
   _pauseRelease(lockId) {
-    if (!this._control.pauseLockset.has(lockId)) return;
-    this._control.pauseLockset.delete(lockId);
-    if (this._slot.pull && this._control.demandOwed !== void 0) this._fireOwedDemandIfReady();
-    if (this._hasBoundaryPauseLock()) return;
-    scheduleBoundaryDrain(this._core);
-    if (this._slot.pull) return;
-    this._onResume();
+    nodePauseRelease(nodeRuntimeHost(this), lockId);
   }
   _onResume() {
-    if (this._value.terminal !== void 0) {
-      this._control.pauseBuffer = [];
-      this._control.pausedDepWaveOccurred = false;
-      this._control.demandOwed = void 0;
-      this._control.activePull = void 0;
-      this._control.pullDirtyOwed = false;
-      return;
-    }
-    if (this._control.pauseBuffer.length > 0) {
-      const buf = this._control.pauseBuffer;
-      this._control.pauseBuffer = [];
-      for (const wave of buf) this._down(wave);
-    }
-    if (this._control.pausedDepWaveOccurred) {
-      this._control.pausedDepWaveOccurred = false;
-      this._tryRun();
-    }
+    nodeOnResume(nodeRuntimeHost(this));
   }
-  /**
-   * R-pull (D269): can this pull node fire a demand NOW? — not terminal, settle-ready (_pending===0),
-   * and no OTHER (non-pullId) lock holds it paused. The gate that decides fire-now vs OWE.
-   */
   _canFireDemand() {
-    if (this._value.terminal !== void 0 || this._wave.pending > 0) return false;
-    return this._control.pauseLockset.size === 0;
+    return nodeCanFireDemand(nodeRuntimeHost(this));
   }
-  /**
-   * R-pull (D269/D272): deliver ONE demand pulse — install activePull so the demand wave may
-   * emit, fire it, then clear activePull so the node is quiet again (1:1).
-   */
   _deliverPullDemand(demand) {
-    this._control.demandOwed = void 0;
-    this._control.activePull = demand;
-    this._control.inDeliverDemand = true;
-    try {
-      this._firePullDemand();
-    } finally {
-      this._control.activePull = void 0;
-      this._control.inDeliverDemand = false;
-    }
+    nodeDeliverPullDemand(nodeRuntimeHost(this), demand);
   }
-  /**
-   * R-pull (D269): a cone-routed PULL of THIS node's pullId arrived (R-up-routing) = a DEMAND.
-   * Fire immediately if able; else OWE it — pin-5 (a dep DIRTY in flight, _pending>0) or F4/F5 (an
-   * external PAUSE lock co-holds the node) — and fire when the node next becomes able. A demand
-   * arriving WHILE a delivery is in flight (synchronous re-entry) is DROPPED (1:1, QA guard).
-   */
   _onDemand(demand) {
-    if (this._control.inDeliverDemand) return;
-    if (this._canFireDemand()) this._deliverPullDemand(demand);
-    else this._control.demandOwed = demand;
+    nodeOnDemand(nodeRuntimeHost(this), demand);
   }
-  /**
-   * R-pull (D55): service ONE demand. Delivery content = the orthogonal pausable mode:
-   *   - 'resumeAll' → drain the buffered BACKLOG (each `_down` re-synthesizes a leading DIRTY, so
-   *     the per-entry replay is DIRTY-before-DATA — R-pause-modes per-entry arrival order);
-   *   - true → deliver the coalesced LATEST as ONE DIRTY-before-DATA wave (pin 2: the quiet absorb
-   *     suppressed the dep's original DIRTY, so the demand wave restores it before the value).
-   * Neither branch fires when nothing changed since the last demand → the demand is SILENT.
-   * Called by `_deliverPullDemand` only when settle-ready; the caller has released the pullId, so
-   * `_markDirty` relays the leading DIRTY (not absorbed).
-   */
   _firePullDemand() {
-    let drainedBuffer = false;
-    if (this._control.pauseBuffer.length > 0) {
-      const buf = this._control.pauseBuffer;
-      this._control.pauseBuffer = [];
-      for (const wave of buf) this._down(wave);
-      drainedBuffer = true;
-    }
-    if (drainedBuffer) return;
-    if (this._control.pausedDepWaveOccurred) {
-      const gated = this._slot.handle !== null && !this._wave.hasCalledFnOnce && !(this._slot.partial || this._allDepsSettled());
-      if (this._wave.pending > 0 || gated) return;
-      this._control.pausedDepWaveOccurred = false;
-      this._wave.emittedDirtyThisWave = false;
-      this._control.pullDirtyOwed = true;
-      try {
-        this._tryRun();
-      } finally {
-        this._control.pullDirtyOwed = false;
-      }
-      return;
-    }
-    if (this._slot.handle !== null) {
-      if (!this._wave.hasCalledFnOnce && !(this._slot.partial || this._allDepsSettled())) return;
-      this._wave.emittedDirtyThisWave = false;
-      this._control.pullDirtyOwed = true;
-      try {
-        this._runWave();
-      } finally {
-        this._control.pullDirtyOwed = false;
-      }
-    }
+    nodeFirePullDemand(nodeRuntimeHost(this));
   }
-  /**
-   * R-pull (D269): fire a demand that was OWED (deferred at demand time) once the node becomes
-   * able — called from the dep-settle arms (DATA/RESOLVED/INVALIDATE/terminal drain _pending, pin-5
-   * + B1/F6) and from `_pauseRelease` (an external PAUSE lock releases, F4/F5).
-   */
   _fireOwedDemandIfReady() {
-    if (this._control.inDeliverDemand) return;
-    if (this._slot.pull && this._control.demandOwed !== void 0 && this._canFireDemand()) {
-      this._deliverPullDemand(this._control.demandOwed);
-    }
+    nodeFireOwedDemandIfReady(nodeRuntimeHost(this));
   }
-  /** Should an outgoing settle slice be deferred into the pause buffer? */
   _shouldBufferOnPause() {
-    if (this._slot.pausable === false) return false;
-    if (!this._isPaused() && !this._isPullQuiet()) return false;
-    if (this._slot.pausable === "resumeAll") return true;
-    if (!this._wave.insideRunWave && this._isAsyncPool() && this._slot.deps.length > 0) return true;
-    return false;
+    return nodeShouldBufferOnPause(nodeRuntimeHost(this));
   }
-  /** R-invalidate-idempotent: clear cache + flush + cascade; no-op if nothing cached. */
   _invalidate(delivery) {
-    if (!this._value.hasData) return;
-    this._value.cache = SENTINEL;
-    this._value.hasData = false;
-    this._value.status = "sentinel";
-    this._value.replayRing = [];
-    for (const fn of this._hooks.onInvalidate) fn();
-    this._emitToSubs(["INVALIDATE"], delivery);
-  }
-  // B42 (R-deps-terminal): ALL deps TERMINAL = every dep has reached COMPLETE *or* an ABSORBED
-  // ERROR. Block only on a LIVE dep (_depTerminal[i] === undefined); an errored dep (terminal = the
-  // error payload, which R-data-payload guarantees is !== undefined and non-boolean) COUNTS as
-  // terminal-done. Was
-  // `tm !== true`, which wedged a node whose errorWhenDepsError:false dep ERRORed (it never
-  // auto-completed even after every other dep completed). Drives the completeWhenDepsComplete cascade.
+    nodeInvalidate(nodeRuntimeHost(this), delivery);
+  }
   _allDepsTerminal() {
-    if (this._slot.deps.length === 0) return false;
-    for (const tm of this._dep.terminal) if (tm === void 0) return false;
-    return true;
+    return nodeAllDepsTerminal(nodeRuntimeHost(this));
+  }
+  _emitToSubs(msg, delivery) {
+    nodeEmitToSubs(nodeRuntimeHost(this), msg, delivery);
   }
   /** R-terminal: resubscribable reset clears terminal + dep state + re-arms the gate. */
   _resetLifecycle() {
-    for (const u of this._dep.unsubs) if (u) u();
-    this._dep.unsubs = [];
-    this._dep.idxBoxes = [];
-    this._lifecycle.subscribers.clear();
-    this._lifecycle.activated = false;
-    this._value.terminal = void 0;
-    this._value.hasTorndown = false;
-    this._wave.hasCalledFnOnce = false;
-    this._resetDepState();
-    this._control.pauseLockset.clear();
-    this._control.pauseBuffer = [];
-    this._control.pausedDepWaveOccurred = false;
-    this._control.demandOwed = void 0;
-    this._control.activePull = void 0;
-    this._control.pullDirtyOwed = false;
-    this._value.replayRing = [];
-    const isCompute = this._slot.handle !== null || this._slot.deps.length > 0;
-    if (isCompute) {
-      this._value.cache = SENTINEL;
-      this._value.hasData = false;
-      this._value.status = "sentinel";
-    } else {
-      this._value.status = this._value.hasData ? "settled" : "sentinel";
-    }
-    if (!this._privateState.persist) this._privateState.value = SENTINEL;
-  }
-  _emitToSubs(msg, delivery) {
-    if (this._released) return;
-    const subs = [...this._lifecycle.subscribers];
-    for (const sink of subs) sink(msg, delivery);
+    nodeResetLifecycle(nodeRuntimeHost(this));
   }
   /** Batch commit (R-batch-coalesce): deliver the deferred tier-3 wave now. */
   __commitBatchedWave(wave) {
-    this._wave.batchDirtyOwed = false;
-    this._down(wave);
+    nodeCommitBatchedWave(nodeRuntimeHost(this), wave);
   }
   /** Batch rollback: balance the immediate DIRTY with a RESOLVED so downstream un-dirties. */
   __rollbackBatched() {
-    if (this._wave.batchDirtyOwed) {
-      this._wave.batchDirtyOwed = false;
-      this._wave.emittedDirtyThisWave = false;
-      this._value.status = this._value.hasData ? "settled" : "sentinel";
-      this._emitToSubs(["RESOLVED"]);
-    }
+    nodeRollbackBatched(nodeRuntimeHost(this));
   }
   /** B49: enqueue a committed-boundary task on this node's graph-local core. */
   __deferBoundary(fn, batchToken) {
-    deferRewire(this._core, fn, {
-      batchToken,
-      isReady: () => !this._hasBoundaryPauseLock()
-    });
+    nodeDeferBoundary(nodeRuntimeHost(this), fn, batchToken);
   }
 };
 
@@ -2584,18 +2736,90 @@ function parseCron(expr) {
     daysOfWeek: parseCronField(parts[4], 0, 6)
   };
 }
-function matchesCron(schedule, date) {
-  return schedule.minutes.has(date.getMinutes()) && schedule.hours.has(date.getHours()) && schedule.daysOfMonth.has(date.getDate()) && schedule.months.has(date.getMonth() + 1) && schedule.daysOfWeek.has(date.getDay());
+function matchesCron(schedule, date, opts = {}) {
+  const fields = cronWallClockFields(date, opts.timezone);
+  return schedule.minutes.has(fields.minute) && schedule.hours.has(fields.hour) && schedule.daysOfMonth.has(fields.day) && schedule.months.has(fields.month) && schedule.daysOfWeek.has(fields.dayOfWeek);
+}
+function cronMinuteKey(date, timezone) {
+  const fields = cronWallClockFields(date, timezone);
+  return `${fields.year}-${fields.month}-${fields.day}-${fields.hour}-${fields.minute}`;
 }
-function cronMinuteKey(date) {
-  return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}-${date.getHours()}-${date.getMinutes()}`;
+function cronDayKey(date, timezone) {
+  const fields = cronWallClockFields(date, timezone);
+  return `${fields.year}-${fields.month}-${fields.day}`;
+}
+function cronWallClockFields(date, timezone) {
+  if (timezone === void 0) {
+    return {
+      year: date.getFullYear(),
+      month: date.getMonth() + 1,
+      day: date.getDate(),
+      hour: date.getHours(),
+      minute: date.getMinutes(),
+      dayOfWeek: date.getDay()
+    };
+  }
+  const parts = timezoneFormatter(timezone).formatToParts(date);
+  const values = {};
+  for (const part of parts) {
+    if (part.type === "year" || part.type === "month" || part.type === "day" || part.type === "hour" || part.type === "minute") {
+      values[part.type] = Number.parseInt(part.value, 10);
+    }
+  }
+  const year = values.year;
+  const month = values.month;
+  const day = values.day;
+  const hour = values.hour;
+  const minute = values.minute;
+  if (year === void 0 || month === void 0 || day === void 0 || hour === void 0 || minute === void 0) {
+    throw new Error(`fromCron: timezone projection failed for ${timezone}`);
+  }
+  return {
+    year,
+    month,
+    day,
+    hour,
+    minute,
+    dayOfWeek: new Date(Date.UTC(year, month - 1, day)).getUTCDay()
+  };
+}
+var TIMEZONE_FORMATTERS = /* @__PURE__ */ new Map();
+function timezoneFormatter(timezone) {
+  const existing = TIMEZONE_FORMATTERS.get(timezone);
+  if (existing !== void 0) return existing;
+  assertNonEmptyString(timezone, "fromCron: timezone");
+  try {
+    const formatter = new Intl.DateTimeFormat("en-US-u-ca-gregory-nu-latn", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23"
+    });
+    formatter.format(/* @__PURE__ */ new Date(0));
+    TIMEZONE_FORMATTERS.set(timezone, formatter);
+    return formatter;
+  } catch (error) {
+    throw new RangeError(
+      `fromCron: unsupported IANA timezone '${timezone}' (${error instanceof Error ? error.message : String(error)})`
+    );
+  }
 }
 function dateToTimestampNs(date) {
   return (BigInt(date.getTime()) * 1000000n).toString();
 }
 function fromCron(expr, opts = {}) {
   const schedule = parseCron(expr);
-  const { tickMs = 6e4, output = "timestamp_ns", signal } = opts;
+  const { tickMs = 6e4, output = "timestamp_ns", signal, timezone } = opts;
+  if (opts.dst?.nonexistent !== void 0 && opts.dst.nonexistent !== "skip") {
+    throw new RangeError("fromCron: dst.nonexistent currently supports only 'skip'");
+  }
+  if (opts.dst?.repeated !== void 0 && opts.dst.repeated !== "once") {
+    throw new RangeError("fromCron: dst.repeated currently supports only 'once'");
+  }
+  if (timezone !== void 0) timezoneFormatter(timezone);
   if (!Number.isFinite(tickMs) || tickMs <= 0) {
     throw new RangeError("fromCron: tickMs must be a positive finite number");
   }
@@ -2604,6 +2828,8 @@ function fromCron(expr, opts = {}) {
     (ctx) => {
       let done = false;
       let lastFiredKey;
+      let firedTimezoneDay;
+      const firedTimezoneMinutes = /* @__PURE__ */ new Set();
       let intervalId;
       const cleanup = () => {
         done = true;
@@ -2624,9 +2850,18 @@ function fromCron(expr, opts = {}) {
       const check = () => {
         if (done) return;
         const now = /* @__PURE__ */ new Date();
-        const key = cronMinuteKey(now);
-        if (key !== lastFiredKey && matchesCron(schedule, now)) {
+        const key = cronMinuteKey(now, timezone);
+        const alreadyFired = timezone === void 0 ? key === lastFiredKey : firedTimezoneMinutes.has(key);
+        if (!alreadyFired && matchesCron(schedule, now, { timezone })) {
           lastFiredKey = key;
+          if (timezone !== void 0) {
+            const dayKey = cronDayKey(now, timezone);
+            if (dayKey !== firedTimezoneDay) {
+              firedTimezoneDay = dayKey;
+              firedTimezoneMinutes.clear();
+            }
+            firedTimezoneMinutes.add(key);
+          }
           emitNow(now);
         }
       };