@graphrefly/ts 0.0.0

package/dist/composition/index.cjs

@@ -0,0 +1,2505 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/composition/index.ts
+var composition_exports = {};
+__export(composition_exports, {
+  pipe: () => pipe,
+  stratify: () => stratify,
+  stratifyBranch: () => stratifyBranch,
+  topologyDiff: () => topologyDiff
+});
+module.exports = __toCommonJS(composition_exports);
+
+// src/protocol/messages.ts
+var SENTINEL = void 0;
+function isInvalidErrorPayload(v) {
+  return v === SENTINEL || typeof v === "boolean";
+}
+function errorPayload(reason, fallback = "error without a valid payload") {
+  return isInvalidErrorPayload(reason) ? new Error(fallback) : reason;
+}
+var TIER_START = 0;
+var TIER_CONTROL = 1;
+var TIER_NOTIFICATION = 2;
+var TIER_VALUE = 3;
+var TIER_SETTLE = 4;
+var TIER_TERMINAL = 5;
+var TIER_TEARDOWN = 6;
+var TIER = {
+  START: TIER_START,
+  PAUSE: TIER_CONTROL,
+  RESUME: TIER_CONTROL,
+  DIRTY: TIER_NOTIFICATION,
+  DATA: TIER_VALUE,
+  RESOLVED: TIER_VALUE,
+  INVALIDATE: TIER_SETTLE,
+  COMPLETE: TIER_TERMINAL,
+  ERROR: TIER_TERMINAL,
+  TEARDOWN: TIER_TEARDOWN
+};
+function messageTier(t) {
+  return TIER[t];
+}
+function isDeferredTier(t) {
+  return TIER[t] >= TIER_VALUE;
+}
+function isValueTier(t) {
+  return TIER[t] === TIER_VALUE;
+}
+function isPauseBufferedTier(t) {
+  const tier = TIER[t];
+  return tier === TIER_VALUE || tier === TIER_SETTLE;
+}
+function isTerminal(t) {
+  return TIER[t] === TIER_TERMINAL;
+}
+function isUpAllowed(t) {
+  const tier = TIER[t];
+  return tier !== TIER_VALUE && tier !== TIER_TERMINAL;
+}
+
+// src/ctx/types.ts
+var CTX_DEP_CACHE = /* @__PURE__ */ Symbol("graphrefly.ctx.depCache");
+var CTX_NODE_BINDING = /* @__PURE__ */ Symbol("graphrefly.ctx.nodeBinding");
+function isTerminalNone(t) {
+  return t === false || t === void 0;
+}
+function isTerminalComplete(t) {
+  return t === true;
+}
+function isTerminalError(t) {
+  return !isTerminalNone(t) && !isTerminalComplete(t);
+}
+function terminalErrorValue(t) {
+  return isTerminalError(t) ? t : void 0;
+}
+function depWaves(ctx, depIndex) {
+  return ctx.waveData[depIndex] ?? [];
+}
+function depBatch(ctx, depIndex) {
+  const waves = depWaves(ctx, depIndex);
+  if (waves.length === 0) return null;
+  const flattened = waves.flat().filter((v) => v !== SENTINEL);
+  return flattened.length === 0 ? [] : flattened;
+}
+function depLatest(ctx, depIndex) {
+  return ctx[CTX_DEP_CACHE]?.latest[depIndex];
+}
+function depTerminal(ctx, depIndex) {
+  const t = ctx.terminal[depIndex];
+  return t === void 0 ? false : t;
+}
+
+// src/batch/boundary.ts
+var depth = 0;
+var pendingCores = [];
+var pendingHead = 0;
+function enterWave() {
+  depth++;
+}
+function exitWave() {
+  depth--;
+  if (depth === 0 && pendingHead < pendingCores.length) drain();
+}
+function deferRewire(core, apply, options = {}) {
+  core.enqueueBoundaryTask({ apply, batchToken: options.batchToken, isReady: options.isReady });
+  pendingCores.push(core);
+}
+function scheduleBoundaryDrain(core) {
+  for (let i = 0; i < core.boundaryTaskCount(); i++) pendingCores.push(core);
+  if (depth === 0 && pendingHead < pendingCores.length) drain();
+}
+function drain() {
+  let escaped = null;
+  while (pendingHead < pendingCores.length) {
+    const core = pendingCores[pendingHead++];
+    const task = core.shiftBoundaryTask();
+    if (task === void 0) continue;
+    if (task.batchToken !== void 0) {
+      const committed = task.batchToken.committed === true;
+      if (!committed) continue;
+    }
+    if (task.isReady !== void 0 && !task.isReady()) {
+      core.unshiftBoundaryTask(task);
+      continue;
+    }
+    depth++;
+    try {
+      task.apply();
+    } catch (e) {
+      if (escaped === null) escaped = { e };
+    } finally {
+      depth--;
+    }
+  }
+  pendingCores.length = 0;
+  pendingHead = 0;
+  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) {
+    this.kind = kind;
+  }
+  fns = [];
+  free = [];
+  register(fn) {
+    const reused = this.free.pop();
+    if (reused !== void 0) {
+      this.fns[reused] = fn;
+      return reused;
+    }
+    const id = this.fns.length;
+    this.fns.push(fn);
+    return id;
+  }
+  unregister(handleId) {
+    if (this.fns[handleId] === void 0) return;
+    this.fns[handleId] = void 0;
+    this.free.push(handleId);
+  }
+  invoke(handleId, ctx) {
+    this.fns[handleId](ctx);
+  }
+};
+var statKey = (h) => `${h.poolId}:${h.handleId}`;
+var Dispatcher = class {
+  pools = [];
+  syncPoolId;
+  asyncPoolId;
+  // opt-in profile recorder (default OFF → zero overhead, F-PERF).
+  _recording = false;
+  _stats = /* @__PURE__ */ new Map();
+  _totalInvokes = 0;
+  constructor() {
+    this.syncPoolId = this.addPool(new PoolTable("sync"));
+    this.asyncPoolId = this.addPool(new PoolTable("async"));
+  }
+  /** Turn the profile recorder on/off (D39). Off = zero overhead on invoke. */
+  setRecording(on) {
+    this._recording = on;
+  }
+  /** Reset accumulated profiling counters. */
+  clearStats() {
+    this._stats.clear();
+    this._totalInvokes = 0;
+  }
+  /** Read a handle's accumulated counters (undefined if it never ran while recording). */
+  statFor(handle) {
+    return this._stats.get(statKey(handle));
+  }
+  /** Total fn invocations recorded across the dispatcher. */
+  get totalInvokes() {
+    return this._totalInvokes;
+  }
+  addPool(pool) {
+    const id = this.pools.length;
+    this.pools.push(pool);
+    return id;
+  }
+  /** Register a fn in a pool, returning its Handle. Default pool = sync (R-sync-core). */
+  register(fn, pool = "sync") {
+    const poolId = pool === "sync" ? this.syncPoolId : pool === "async" ? this.asyncPoolId : pool;
+    const handleId = this.pools[poolId].register(fn);
+    return { poolId, handleId };
+  }
+  /**
+   * Release a handle (B15): frees the pool slot (closure GC'd, id reusable) and drops any
+   * accumulated profile stat so a reused id never inherits the previous tenant's counters.
+   * Called on rewire fn-swap (node._rewire) — the old handle is dropped before the node
+   * adopts the new one. Idempotent. NOT called on deactivate (a node's handle survives
+   * activate↔deactivate and is reused on reactivation; only a rewire swaps it).
+   */
+  unregister(handle) {
+    this.pools[handle.poolId].unregister(handle.handleId);
+    this._stats.delete(statKey(handle));
+  }
+  /** Uniform sync-void invoke (R-sync-core / R-dispatch-all). */
+  invoke(handle, ctx) {
+    if (!this._recording) {
+      this.pools[handle.poolId].invoke(handle.handleId, ctx);
+      return;
+    }
+    this._totalInvokes++;
+    const t0 = performance.now();
+    try {
+      this.pools[handle.poolId].invoke(handle.handleId, ctx);
+    } finally {
+      const dur = (performance.now() - t0) * 1e6;
+      const key = statKey(handle);
+      const s = this._stats.get(key) ?? {
+        invokes: 0,
+        totalDurationNs: 0,
+        lastDurationNs: 0
+      };
+      s.invokes++;
+      s.lastDurationNs = dur;
+      s.totalDurationNs += dur;
+      this._stats.set(key, s);
+    }
+  }
+  poolKind(poolId) {
+    return this.pools[poolId].kind;
+  }
+};
+var defaultDispatcher = new Dispatcher();
+
+// src/graph/environment.ts
+var EnvironmentDrivers = class _EnvironmentDrivers {
+  process;
+  http;
+  sse;
+  websocket;
+  webhook;
+  constructor(init = {}) {
+    this.process = init.process;
+    this.http = init.http;
+    this.sse = init.sse;
+    this.websocket = init.websocket;
+    this.webhook = init.webhook;
+    Object.freeze(this);
+  }
+  static empty() {
+    return EMPTY_ENVIRONMENT;
+  }
+  withProcess(driver) {
+    return new _EnvironmentDrivers({ ...this, process: driver });
+  }
+  withHttp(driver) {
+    return new _EnvironmentDrivers({ ...this, http: driver });
+  }
+  withSse(driver) {
+    return new _EnvironmentDrivers({ ...this, sse: driver });
+  }
+  withWebSocket(driver) {
+    return new _EnvironmentDrivers({ ...this, websocket: driver });
+  }
+  withWebhook(driver) {
+    return new _EnvironmentDrivers({ ...this, webhook: driver });
+  }
+  processDriver() {
+    return this.process;
+  }
+  httpDriver() {
+    return this.http;
+  }
+  sseDriver() {
+    return this.sse;
+  }
+  webSocketDriver() {
+    return this.websocket;
+  }
+  webhookDriver() {
+    return this.webhook;
+  }
+};
+var EMPTY_ENVIRONMENT = new EnvironmentDrivers();
+
+// src/node/core.ts
+var NodeCore = class {
+  nextId = 0;
+  slots = [];
+  values = [];
+  waves = [];
+  controls = [];
+  lifecycles = [];
+  depStates = [];
+  privateStates = [];
+  hooks = [];
+  syncCtxs = [];
+  versionStates = [];
+  boundary = { queue: [], head: 0 };
+  createSlot(slot, state) {
+    const id = this.nextId++;
+    const full = { ...slot, id };
+    this.slots[id] = full;
+    this.depStates[id] = state.dep;
+    this.lifecycles[id] = state.lifecycle;
+    this.values[id] = state.value;
+    this.waves[id] = state.wave;
+    this.controls[id] = state.control;
+    this.privateStates[id] = state.privateState;
+    this.hooks[id] = state.hooks;
+    this.syncCtxs[id] = state.syncCtx;
+    this.versionStates[id] = state.version;
+    return { id, slot: full };
+  }
+  get(id) {
+    const slot = this.slots[id];
+    if (slot === void 0) throw new Error("NodeCore: unknown node slot");
+    return slot;
+  }
+  getValue(id) {
+    const value = this.values[id];
+    if (value === void 0) throw new Error("NodeCore: unknown node value state");
+    return value;
+  }
+  getWave(id) {
+    const wave = this.waves[id];
+    if (wave === void 0) throw new Error("NodeCore: unknown node wave state");
+    return wave;
+  }
+  getControl(id) {
+    const control = this.controls[id];
+    if (control === void 0) throw new Error("NodeCore: unknown node control state");
+    return control;
+  }
+  getLifecycle(id) {
+    const lifecycle = this.lifecycles[id];
+    if (lifecycle === void 0) throw new Error("NodeCore: unknown node lifecycle state");
+    return lifecycle;
+  }
+  getDep(id) {
+    const dep = this.depStates[id];
+    if (dep === void 0) throw new Error("NodeCore: unknown node dep state");
+    return dep;
+  }
+  getPrivateState(id) {
+    const state = this.privateStates[id];
+    if (state === void 0) throw new Error("NodeCore: unknown node private state");
+    return state;
+  }
+  getHooks(id) {
+    const hooks = this.hooks[id];
+    if (hooks === void 0) throw new Error("NodeCore: unknown node cleanup hooks");
+    return hooks;
+  }
+  getSyncCtx(id) {
+    const state = this.syncCtxs[id];
+    if (state === void 0) throw new Error("NodeCore: unknown node ctx state");
+    return state;
+  }
+  getVersion(id) {
+    const state = this.versionStates[id];
+    if (state === void 0) throw new Error("NodeCore: unknown node version state");
+    return state;
+  }
+  /** @internal D122: release graph-owned ephemeral node runtime state from core retention. */
+  releaseSlot(id) {
+    this.slots[id] = void 0;
+    this.depStates[id] = void 0;
+    this.lifecycles[id] = void 0;
+    this.values[id] = void 0;
+    this.waves[id] = void 0;
+    this.controls[id] = void 0;
+    this.privateStates[id] = void 0;
+    this.hooks[id] = void 0;
+    this.syncCtxs[id] = void 0;
+    this.versionStates[id] = void 0;
+  }
+  /** @internal B49: graph-local deferred-boundary queue (rewireNext/upNext/batch-after-commit). */
+  enqueueBoundaryTask(task) {
+    this.boundary.queue.push(task);
+  }
+  /** @internal */
+  hasBoundaryTasks() {
+    return this.boundary.head < this.boundary.queue.length;
+  }
+  /** @internal */
+  boundaryTaskCount() {
+    return this.boundary.queue.length - this.boundary.head;
+  }
+  /** @internal */
+  shiftBoundaryTask() {
+    if (!this.hasBoundaryTasks()) {
+      this.boundary.queue = [];
+      this.boundary.head = 0;
+      return void 0;
+    }
+    const task = this.boundary.queue[this.boundary.head++];
+    if (!this.hasBoundaryTasks()) {
+      this.boundary.queue = [];
+      this.boundary.head = 0;
+    }
+    return task;
+  }
+  /** @internal Put a not-yet-ready task back at this core's FIFO head. */
+  unshiftBoundaryTask(task) {
+    const remaining = this.boundary.queue.slice(this.boundary.head);
+    this.boundary.queue = [task, ...remaining];
+    this.boundary.head = 0;
+  }
+  /** @internal D110: discard all pending tasks caused by an uncommitted batch. */
+  dropBoundaryTasksForBatch(batchToken) {
+    const remaining = this.boundary.queue.slice(this.boundary.head).filter((task) => task.batchToken !== batchToken);
+    this.boundary.queue = remaining;
+    this.boundary.head = 0;
+  }
+};
+function makeDepBookkeeping(depCount) {
+  return {
+    batch: new Array(depCount).fill(null),
+    waveData: Array.from({ length: depCount }, () => []),
+    waveTokens: new Array(depCount).fill(void 0),
+    prev: new Array(depCount).fill(SENTINEL),
+    hasData: new Array(depCount).fill(false),
+    dirty: new Array(depCount).fill(false),
+    tier: new Array(depCount).fill(0),
+    terminal: new Array(depCount).fill(void 0),
+    terminalInput: new Array(depCount).fill(void 0),
+    unsubs: [],
+    idxBoxes: []
+  };
+}
+
+// src/json/codec.ts
+var JS_MIN_NORMAL_NUMBER = 2 ** -1022;
+function assertStableJsonNumber(value, path) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`stableJsonString: non-finite number at ${path}`);
+  }
+}
+function assertStrictJsonNumber(value, path) {
+  assertStableJsonNumber(value, path);
+  if (Object.is(value, -0)) {
+    throw new TypeError(`stableJsonString: non-canonical number at ${path}`);
+  }
+  const abs = Math.abs(value);
+  if (abs > 0 && abs < JS_MIN_NORMAL_NUMBER) {
+    throw new TypeError(`stableJsonString: subnormal number at ${path}`);
+  }
+  if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    throw new TypeError(`stableJsonString: integer outside safe range at ${path}`);
+  }
+}
+function sortedJsonValue(value, seen = /* @__PURE__ */ new Set(), path = "$", strictNumbers = false) {
+  if (value === null) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (strictNumbers) assertStrictJsonNumber(value, path);
+    else assertStableJsonNumber(value, path);
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`stableJsonString: value at ${path} is not JSON-encodable`);
+  }
+  if (seen.has(value)) throw new TypeError(`stableJsonString: circular reference at ${path}`);
+  const proto = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) {
+    throw new TypeError(`stableJsonString: non-plain object at ${path}`);
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.getOwnPropertySymbols(value).length > 0) {
+        throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+      }
+      for (const key of Object.getOwnPropertyNames(value)) {
+        const isIndex = /^(0|[1-9]\d*)$/.test(key) && Number.isSafeInteger(Number(key)) && Number(key) < value.length;
+        if (key !== "length" && !isIndex) {
+          throw new TypeError(`stableJsonString: non-index array property at ${path}.${key}`);
+        }
+      }
+      const out2 = [];
+      for (let i = 0; i < value.length; i += 1) {
+        if (!(i in value)) {
+          throw new TypeError(`stableJsonString: sparse array hole at ${path}[${i}]`);
+        }
+        out2.push(sortedJsonValue(value[i], seen, `${path}[${i}]`, strictNumbers));
+      }
+      return out2;
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+    }
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortedJsonValue(
+        value[key],
+        seen,
+        `${path}.${key}`,
+        strictNumbers
+      );
+    }
+    return out;
+  } finally {
+    seen.delete(value);
+  }
+}
+function stableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value));
+}
+function strictStableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value, /* @__PURE__ */ new Set(), "$", true));
+}
+function jsonCodecFor() {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  return {
+    encode(value) {
+      return encoder.encode(stableJsonString(value));
+    },
+    decode(bytes) {
+      return JSON.parse(decoder.decode(bytes));
+    }
+  };
+}
+var jsonCodec = jsonCodecFor();
+function bytesEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i += 1) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function hasUnpairedSurrogate(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        i += 1;
+        continue;
+      }
+      return true;
+    }
+    if (code >= 56320 && code <= 57343) return true;
+  }
+  return false;
+}
+function assertNoUnpairedSurrogates(value, seen = /* @__PURE__ */ new Set(), path = "$") {
+  if (typeof value === "string") {
+    if (hasUnpairedSurrogate(value)) {
+      throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}`);
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  if (seen.has(value)) return;
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i += 1) {
+        assertNoUnpairedSurrogates(value[i], seen, `${path}[${i}]`);
+      }
+      return;
+    }
+    for (const key of Object.keys(value)) {
+      if (hasUnpairedSurrogate(key)) {
+        throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}.${key}`);
+      }
+      assertNoUnpairedSurrogates(value[key], seen, `${path}.${key}`);
+    }
+  } finally {
+    seen.delete(value);
+  }
+}
+function assertNoDuplicateJsonObjectKeys(text) {
+  let index = 0;
+  function fail(message) {
+    throw new TypeError(`strictJsonCodec: ${message}`);
+  }
+  function skipWhitespace() {
+    while (/\s/.test(text[index] ?? "")) index += 1;
+  }
+  function readJsonString() {
+    const start = index;
+    index += 1;
+    while (index < text.length) {
+      const ch = text[index];
+      if (ch === '"') {
+        index += 1;
+        try {
+          return JSON.parse(text.slice(start, index));
+        } catch {
+          fail("malformed JSON string");
+        }
+      }
+      if (ch === "\\") {
+        index += 2;
+        continue;
+      }
+      index += 1;
+    }
+    fail("unterminated JSON string");
+  }
+  function consumeLiteral(literal) {
+    if (text.slice(index, index + literal.length) !== literal) {
+      fail(`malformed JSON near byte ${index}`);
+    }
+    index += literal.length;
+  }
+  function consumeNumber() {
+    const match = /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?/.exec(text.slice(index));
+    if (!match) fail(`malformed JSON number near byte ${index}`);
+    index += match[0].length;
+  }
+  function parseValue(path) {
+    skipWhitespace();
+    const ch = text[index];
+    if (ch === "{") {
+      parseObject(path);
+      return;
+    }
+    if (ch === "[") {
+      parseArray(path);
+      return;
+    }
+    if (ch === '"') {
+      readJsonString();
+      return;
+    }
+    if (ch === "t") {
+      consumeLiteral("true");
+      return;
+    }
+    if (ch === "f") {
+      consumeLiteral("false");
+      return;
+    }
+    if (ch === "n") {
+      consumeLiteral("null");
+      return;
+    }
+    if (ch === "-" || ch !== void 0 && ch >= "0" && ch <= "9") {
+      consumeNumber();
+      return;
+    }
+    fail(`malformed JSON near byte ${index}`);
+  }
+  function parseObject(path) {
+    const keys = /* @__PURE__ */ new Set();
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "}") {
+      index += 1;
+      return;
+    }
+    while (index < text.length) {
+      skipWhitespace();
+      if (text[index] !== '"') fail(`expected object key near byte ${index}`);
+      const key = readJsonString();
+      if (keys.has(key)) {
+        throw new TypeError(
+          `strictJsonCodec: duplicate object key ${JSON.stringify(key)} at ${path}`
+        );
+      }
+      keys.add(key);
+      skipWhitespace();
+      if (text[index] !== ":") fail(`expected ':' after object key near byte ${index}`);
+      index += 1;
+      parseValue(`${path}.${key}`);
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "}") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or '}' near byte ${index}`);
+    }
+    fail("unterminated JSON object");
+  }
+  function parseArray(path) {
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "]") {
+      index += 1;
+      return;
+    }
+    let item = 0;
+    while (index < text.length) {
+      parseValue(`${path}[${item}]`);
+      item += 1;
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "]") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or ']' near byte ${index}`);
+    }
+    fail("unterminated JSON array");
+  }
+  parseValue("$");
+  skipWhitespace();
+  if (index !== text.length) fail(`trailing JSON token near byte ${index}`);
+}
+function strictJsonCodecFor() {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  return {
+    encode(value) {
+      assertNoUnpairedSurrogates(value);
+      return encoder.encode(strictStableJsonString(value));
+    },
+    decode(bytes) {
+      const text = decoder.decode(bytes);
+      assertNoDuplicateJsonObjectKeys(text);
+      const decoded = JSON.parse(text);
+      assertNoUnpairedSurrogates(decoded);
+      const canonical = encoder.encode(strictStableJsonString(decoded));
+      if (!bytesEqual(bytes, canonical)) {
+        throw new TypeError("strictJsonCodec: bytes are not canonical stable JSON");
+      }
+      return decoded;
+    }
+  };
+}
+var strictJsonCodec = strictJsonCodecFor();
+function strictCanonicalJsonBytes(value) {
+  return strictJsonCodec.encode(value);
+}
+
+// src/node/versioning.ts
+var ABSENT_V1_SEED = Object.freeze({
+  "@graphrefly/node-version": "v1-absent"
+});
+function fnv1a64(input) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  for (const byte of input) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * prime);
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function defaultNodeVersionHash(bytes) {
+  return `fnv1a64:${fnv1a64(bytes)}`;
+}
+function computeV1Cid(policy, value) {
+  return policy.hash(strictCanonicalJsonBytes(value));
+}
+function assertNodeVersionDataCompatible(policy, value) {
+  if (!policy.enabled || policy.level === 0) return;
+  strictCanonicalJsonBytes(value);
+}
+function snapshotNodeVersionData(policy, value) {
+  if (!policy.enabled || policy.level === 0) return value;
+  const bytes = strictCanonicalJsonBytes(value);
+  return strictJsonCodec.decode(bytes);
+}
+function resolveNodeVersioningPolicy(policy) {
+  if (policy === false) return { enabled: false };
+  if (policy === void 0 || policy === 0) return { enabled: true, level: 0 };
+  if (policy === 1) return { enabled: true, level: 1, hash: defaultNodeVersionHash };
+  if (typeof policy === "object" && policy !== null) {
+    if (policy.level === 0) return { enabled: true, level: 0 };
+    if (policy.level === 1) {
+      return { enabled: true, level: 1, hash: policy.hash ?? defaultNodeVersionHash };
+    }
+  }
+  throw new Error("node: versioning level must be 0 or 1; V2/V3 are not locked yet (D109)");
+}
+function createNodeVersion(policy, initialValue = ABSENT_V1_SEED) {
+  if (!policy.enabled) return void 0;
+  if (policy.level === 0) return Object.freeze({ level: 0, counter: 0 });
+  return Object.freeze({
+    level: 1,
+    counter: 0,
+    cid: computeV1Cid(policy, initialValue),
+    prev: null
+  });
+}
+function advanceNodeVersion(current, policy, value) {
+  if (!policy.enabled) return void 0;
+  if (current === void 0) return createNodeVersion(policy, value);
+  if (policy.level === 0) {
+    return Object.freeze({ level: 0, counter: current.counter + 1 });
+  }
+  const previous = current.level === 1 ? current.cid : null;
+  return Object.freeze({
+    level: 1,
+    counter: current.counter + 1,
+    cid: computeV1Cid(policy, value),
+    prev: previous
+  });
+}
+function cloneNodeVersion(version) {
+  if (version === void 0) return void 0;
+  if (version.level === 0) return Object.freeze({ level: 0, counter: version.counter });
+  return Object.freeze({
+    level: 1,
+    counter: version.counter,
+    cid: version.cid,
+    prev: version.prev
+  });
+}
+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;
+  }
+}
+function withEnvironmentDrivers(environment, create) {
+  const prev = constructingEnvironment;
+  constructingEnvironment = environment;
+  try {
+    return create();
+  } finally {
+    constructingEnvironment = prev;
+  }
+}
+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 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)");
+    }
+  }
+}
+var Node = class {
+  _core;
+  _id;
+  _slot;
+  _dep;
+  _value;
+  _wave;
+  _control;
+  _lifecycle;
+  _privateState;
+  _hooks;
+  _syncCtxState;
+  _version;
+  _restoredActivationPending = false;
+  _released = false;
+  get _syncCtx() {
+    return this._syncCtxState.value;
+  }
+  set _syncCtx(ctx) {
+    this._syncCtxState.value = ctx;
+  }
+  constructor(deps, handleOrFn, opts = {}) {
+    const core = constructingCore;
+    constructingCore = void 0;
+    const dispatcher = opts.dispatcher ?? defaultDispatcher;
+    const environment = constructingEnvironment ?? EnvironmentDrivers.empty();
+    constructingEnvironment = void 0;
+    const pool = opts.pool ?? "sync";
+    const pausable = opts.pausable ?? true;
+    const pullLock = opts.pullId;
+    const pull = opts.pullId !== void 0;
+    if (pull && pausable === false)
+      throw new Error(
+        "node: pullId is incompatible with pausable:false \u2014 a pull node is demanded via RESUME, which pausable:false ignores (R-pull / R-pause-modes / D55,D59)"
+      );
+    let handle;
+    if (handleOrFn === null) handle = null;
+    else if (typeof handleOrFn === "function") handle = dispatcher.register(handleOrFn, pool);
+    else handle = handleOrFn;
+    const n = deps.length;
+    const dep = makeDepBookkeeping(n);
+    const versioning = resolveNodeVersioningPolicy(opts.versioning);
+    const value = {
+      cache: SENTINEL,
+      hasData: false,
+      status: "sentinel",
+      terminal: void 0,
+      hasTorndown: false,
+      replayRing: []
+    };
+    if (opts.initial !== void 0) {
+      value.cache = opts.initial;
+      value.hasData = true;
+      value.status = "settled";
+    }
+    const pauseLockset = /* @__PURE__ */ new Set();
+    if (pull) pauseLockset.add(pullLock);
+    this._core = core ?? new NodeCore();
+    const created = this._core.createSlot(
+      {
+        deps,
+        handle,
+        pool,
+        dispatcher,
+        environment,
+        partial: opts.partial ?? false,
+        terminalAsRealInput: opts.terminalAsRealInput ?? false,
+        completeWhenDepsComplete: opts.completeWhenDepsComplete ?? true,
+        errorWhenDepsError: opts.errorWhenDepsError ?? true,
+        resubscribable: opts.resubscribable ?? false,
+        resetOnTeardown: opts.resetOnTeardown ?? false,
+        pausable,
+        pull,
+        pullLock,
+        replayN: opts.replayBuffer ?? 0,
+        dynamic: opts.dynamic ?? false,
+        name: opts.name,
+        factory: opts.factory
+      },
+      {
+        dep,
+        lifecycle: { subscribers: /* @__PURE__ */ new Set(), activated: false },
+        value,
+        wave: {
+          pending: 0,
+          hasCalledFnOnce: false,
+          emittedDirtyThisWave: false,
+          emittedSettleThisWave: false,
+          insideRunWave: false,
+          inDepMutation: false,
+          rewireRunPending: false,
+          batchDirtyOwed: false
+        },
+        control: {
+          pauseLockset,
+          pausedDepWaveOccurred: false,
+          pauseBuffer: [],
+          demandOwed: false,
+          inDeliverDemand: false
+        },
+        privateState: { value: SENTINEL, persist: false },
+        hooks: { onDeactivation: [], onInvalidate: [] },
+        syncCtx: { value: null },
+        version: {
+          policy: versioning,
+          value: createNodeVersion(
+            versioning,
+            opts.initial !== void 0 ? opts.initial : void 0
+          )
+        }
+      }
+    );
+    this._id = created.id;
+    this._slot = this._core.get(this._id);
+    this._dep = this._core.getDep(this._id);
+    this._value = this._core.getValue(this._id);
+    this._wave = this._core.getWave(this._id);
+    this._control = this._core.getControl(this._id);
+    this._lifecycle = this._core.getLifecycle(this._id);
+    this._privateState = this._core.getPrivateState(this._id);
+    this._hooks = this._core.getHooks(this._id);
+    this._syncCtxState = this._core.getSyncCtx(this._id);
+    this._version = this._core.getVersion(this._id);
+    checkpointReaders.set(this, () => ({
+      cache: this._value.cache,
+      hasData: this._value.hasData,
+      terminal: this._value.terminal,
+      activated: this._lifecycle.activated,
+      hasCalledFnOnce: this._wave.hasCalledFnOnce,
+      ctxState: {
+        value: this._privateState.value,
+        persist: this._privateState.persist
+      },
+      version: cloneNodeVersion(this._version.value),
+      handle: this._slot.handle
+    }));
+    restoreWriters.set(this, (state) => {
+      this._assertNotReleased("restoreGraph");
+      this._value.cache = state.cache;
+      this._value.hasData = state.hasData;
+      this._value.status = state.status;
+      this._value.terminal = state.terminal;
+      this._value.hasTorndown = false;
+      this._value.replayRing = [];
+      this._wave.hasCalledFnOnce = state.hasCalledFnOnce;
+      this._wave.emittedDirtyThisWave = false;
+      this._wave.emittedSettleThisWave = false;
+      this._wave.pending = 0;
+      this._wave.insideRunWave = false;
+      this._wave.inDepMutation = false;
+      this._wave.rewireRunPending = false;
+      this._wave.batchDirtyOwed = false;
+      this._control.pauseBuffer = [];
+      this._control.pausedDepWaveOccurred = false;
+      this._control.demandOwed = false;
+      this._control.inDeliverDemand = false;
+      this._control.pauseLockset.clear();
+      if (this._slot.pull) this._control.pauseLockset.add(this._slot.pullLock);
+      this._privateState.value = state.ctxState.value;
+      this._privateState.persist = state.ctxState.persist;
+      if (state.version === false) {
+        this._version.policy = { enabled: false };
+        this._version.value = void 0;
+      } else if (state.version.level === 0) {
+        this._version.policy = { enabled: true, level: 0 };
+        this._version.value = cloneNodeVersion(state.version);
+      } else {
+        if (!this._version.policy.enabled || this._version.policy.level !== 1) {
+          throw new Error(
+            `restoreGraph: checkpoint node version level ${state.version.level} requires matching node versioning policy`
+          );
+        }
+        if (!state.hasData && state.version.counter > 0) {
+          throw new Error(
+            "restoreGraph: checkpoint node version cid cannot be verified without current DATA under V1 versioning (D109)"
+          );
+        }
+        const expectedCid = restoredV1Cid(this._version.policy, state.hasData, state.cache);
+        if (expectedCid !== state.version.cid) {
+          throw new Error(
+            "restoreGraph: checkpoint node version cid does not match the selected node versioning hash policy (D109)"
+          );
+        }
+        this._version.value = cloneNodeVersion(state.version);
+      }
+      this._syncCtx = null;
+      this._resetDepState();
+      this._lifecycle.activated = false;
+      this._lifecycle.subscribers.clear();
+      this._restoredActivationPending = true;
+    });
+    runtimeReleasers.set(this, () => this._releaseRuntime());
+    runtimeQuiescenceReaders.set(this, () => this._isRuntimeQuiescentForRelease());
+    subscriberCountReaders.set(this, () => this._subscriberCount());
+    activationReaders.set(this, () => this._lifecycle.activated);
+  }
+  /** R-pull (D55): true while a pull node is quiet (holds its own pullId/demand lock). */
+  _isPullQuiet() {
+    return this._slot.pull && this._control.pauseLockset.has(this._slot.pullLock);
+  }
+  /**
+   * R-pull (D55/D59): this pull node's pullId (pure data, like {@link cache}/{@link handle} — never
+   * triggers computation). A consumer demands one delivery by cone-routing a RESUME of it (no node
+   * reference): `ctx.up([["RESUME", pullId]])` (immediate; loops back → D37 for a self-read dep) or
+   * `ctx.upNext([["RESUME", pullId]])` (boundary-deferred self-demand, R-up-routing/R-rewire-deferred).
+   * Undefined for a non-pull node. The author writes the pullId verbatim, so this getter is mainly
+   * for inspection/describe; routing matches by the pullId value carried in the RESUME, by identity.
+   */
+  get pullId() {
+    return this._slot.pullLock;
+  }
+  get cache() {
+    return this._value.cache;
+  }
+  get status() {
+    return this._value.status;
+  }
+  get version() {
+    return cloneNodeVersion(this._version.value);
+  }
+  get name() {
+    return this._slot.name;
+  }
+  /** R-describe/D51: real factory name for a standalone graph-less node (a runtime *Map inner). */
+  get factory() {
+    return this._slot.factory;
+  }
+  /**
+   * The node's CURRENT/LIVE deps (R-describe / R-edges-derived / D51) — readonly view of the
+   * live `_deps`, which a rewire (C-8 / C-11) mutates. The graph's describe() reads this (NOT a
+   * construction-time snapshot) so every edge corresponds to a real current subscription (D3).
+   * Inspection-only, like cache/status; never triggers computation.
+   */
+  get deps() {
+    return this._slot.deps;
+  }
+  /**
+   * The fn handle (pure data `(poolId, handleId)`, D7) or null for state/passthrough
+   * nodes. Inspection-only (L1.6 handle is referenceable/inspectable) — lets the graph
+   * layer key a dispatcher-backed profile recorder WITHOUT putting counters on the node
+   * (R-node-thin / D39).
+   */
+  get handle() {
+    return this._slot.handle;
+  }
+  /** R-push-subscribe: a new sink receives START, then cached DATA (or DIRTY if dirty). */
+  subscribe(sink) {
+    this._assertNotReleased("subscribe");
+    enterWave();
+    try {
+      if (this._value.terminal !== void 0) {
+        if (this._slot.resubscribable) {
+          this._restoredActivationPending = false;
+          this._resetLifecycle();
+        } else
+          throw new Error(
+            "subscribe: node is non-resubscribable and has terminated; the stream is permanently over (R-terminal / R2.2.7.b)"
+          );
+      }
+      this._lifecycle.subscribers.add(sink);
+      sink(["START"]);
+      if (this._slot.replayN > 0 && this._value.replayRing.length > 0) {
+        for (const v of this._value.replayRing) sink(["DATA", v]);
+      } else if (this._value.hasData && !this._slot.pull) {
+        sink(["DATA", this._value.cache]);
+      } else if (this._value.status === "dirty" && !this._slot.pull) {
+        sink(["DIRTY"]);
+      }
+      if (!this._lifecycle.activated) this._activate();
+      return () => {
+        if (!this._lifecycle.subscribers.delete(sink)) return;
+        if (this._lifecycle.subscribers.size === 0) this._deactivate();
+      };
+    } finally {
+      exitWave();
+    }
+  }
+  /** External emission toward sinks (state-node push, or async late-emit). One call = one wave. */
+  down(msgs) {
+    this._assertNotReleased("down");
+    enterWave();
+    try {
+      this._down(msgs);
+    } finally {
+      exitWave();
+    }
+  }
+  /**
+   * Emit upstream toward deps — control tiers only (R-ctx-up). `towardDep` (a dep index) routes up
+   * ONE declared edge (R-up-routing directed-up); omitted = broadcast up all deps.
+   */
+  up(msgs, towardDep) {
+    this._assertNotReleased("up");
+    enterWave();
+    try {
+      this._up(msgs, towardDep);
+    } finally {
+      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 wave (R-up-routing / R-pull / D59): 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([[RESUME,
+   * 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
+   * `fn` (SD-1 fn-deps pairing — user fns read dep input positionally). Kept deps
+   * keep their subscription + per-dep state; only removed deps unsubscribe and only
+   * added deps fresh-subscribe (push-on-subscribe for an added cached dep). The
+   * first-run gate and cache are PRESERVED (R-rewire Q2/Q7). Intra-graph only (D22).
+   */
+  replaceDeps(newDeps, fn) {
+    this._assertNotReleased("replaceDeps");
+    this._rewire(this._dedupDeps(newDeps), fn);
+  }
+  /** Subscribe to one dep (special case of replaceDeps); returns its index. fn required (SD-1). */
+  subscribeDep(depNode, fn) {
+    this._assertNotReleased("subscribeDep");
+    const next = this._slot.deps.includes(depNode) ? [...this._slot.deps] : [...this._slot.deps, depNode];
+    const deferred = this._rewire(next, fn);
+    return deferred ? next.indexOf(depNode) : this._slot.deps.indexOf(depNode);
+  }
+  /** Unsubscribe from one dep (special case of replaceDeps); idempotent if absent (fn swap still applies). */
+  unsubscribeDep(depNode, fn) {
+    this._assertNotReleased("unsubscribeDep");
+    this._rewire(
+      this._slot.deps.filter((d) => d !== depNode),
+      fn
+    );
+  }
+  _dedupDeps(deps) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const d of deps)
+      if (!seen.has(d)) {
+        seen.add(d);
+        out.push(d);
+      }
+    return out;
+  }
+  /** Is `target` reachable upstream from `from` (following deps)? Cycle-prevention DFS. */
+  _reachableUpstream(from, target) {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [from];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n === void 0) continue;
+      if (n === target) return true;
+      if (seen.has(n)) continue;
+      seen.add(n);
+      for (const d of 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) {
+      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;
+  }
+  // ── activation / deactivation (lazy; R-rom-ram) ──
+  _activate() {
+    this._lifecycle.activated = true;
+    const seedRestoredDeps = this._restoredActivationPending;
+    this._restoredActivationPending = false;
+    if (this._slot.pull) this._control.pauseLockset.add(this._slot.pullLock);
+    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;
+  }
+  _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 = false;
+    this._value.replayRing = [];
+    if (!this._privateState.persist) this._privateState.value = SENTINEL;
+  }
+  _assertNotReleased(op) {
+    if (this._released)
+      throw new Error(`${op}: node has been released from its graph lifecycle (D122)`);
+  }
+  _subscriberCount() {
+    return this._lifecycle.subscribers.size;
+  }
+  _isRuntimeQuiescentForRelease() {
+    const allowedPullQuietLock = this._slot.pull && this._control.pauseLockset.size === 1 && this._control.pauseLockset.has(this._slot.pullLock);
+    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 && !this._control.inDeliverDemand && (this._control.pauseLockset.size === 0 || allowedPullQuietLock);
+  }
+  _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 = 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;
+  }
+  _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) ──
+  _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];
+  }
+  _depProjectionHasData(idx) {
+    const projection = this._dep.waveData[idx][this._dep.waveData[idx].length - 1];
+    return projection?.some((v) => v !== SENTINEL) ?? false;
+  }
+  _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;
+    }
+  }
+  /**
+   * 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--;
+    }
+  }
+  /**
+   * 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"]]);
+  }
+  _markDirty() {
+    this._value.status = "dirty";
+    if (this._isPullQuiet()) return;
+    if (!this._wave.emittedDirtyThisWave) {
+      this._wave.emittedDirtyThisWave = true;
+      this._emitToSubs(["DIRTY"]);
+    }
+  }
+  _maybeRun() {
+    if (this._wave.inDepMutation) {
+      this._wave.rewireRunPending = true;
+      return;
+    }
+    if (this._slot.pausable === true && this._isPaused()) {
+      this._control.pausedDepWaveOccurred = true;
+      return;
+    }
+    this._tryRun();
+  }
+  /**
+   * 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();
+  }
+  _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();
+  }
+  _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;
+  }
+  _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;
+  }
+  _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;
+  }
+  // ── 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]
+    });
+  }
+  _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 (D59): deferred up — route a control wave (e.g. a RESUME pull
+      // DEMAND) 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),
+      [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;
+  }
+  _refreshCtx(ctx) {
+    ctx.waveData = this._dep.waveData;
+    ctx.terminal = this._dep.terminalInput.map(terminalView);
+    ctx[CTX_DEP_CACHE] = { latest: this._dep.prev };
+  }
+  _makeState() {
+    return {
+      get: () => this._privateState.value,
+      set: (v) => {
+        this._privateState.value = v;
+      },
+      persist: (on = true) => {
+        this._privateState.persist = on;
+      }
+    };
+  }
+  // ── 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._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;
+  }
+  _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._slot.pull && m[1] === this._slot.pullLock) {
+          if (!this._markDemandRouted(m[1], routeState)) this._onDemand();
+        } else if (this._control.pauseLockset.has(m[1])) {
+          this._pauseRelease(m[1]);
+        } else {
+          this._forwardUp(m, towardDep, routeState);
+        }
+      } else if (this._slot.deps.length === 0) {
+        if (m[0] === "INVALIDATE") this._down([["INVALIDATE"]]);
+      } else {
+        this._forwardUp(m, towardDep, routeState);
+      }
+    }
+  }
+  _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;
+  }
+  /**
+   * 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 RESUME 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);
+    }
+  }
+  // ── PAUSE/RESUME lockset (R-pause-lockset) + modes (R-pause-modes) ──
+  _isPaused() {
+    return this._control.pauseLockset.size > 0;
+  }
+  _hasBoundaryPauseLock() {
+    if (this._slot.pausable === false) return false;
+    let locks = this._control.pauseLockset.size;
+    if (this._slot.pull && this._control.pauseLockset.has(this._slot.pullLock)) locks--;
+    return locks > 0;
+  }
+  _isAsyncPool() {
+    return this._slot.handle !== null && this._slot.dispatcher.poolKind(this._slot.handle.poolId) === "async";
+  }
+  _pauseAcquire(lockId) {
+    this._control.pauseLockset.add(lockId);
+  }
+  _pauseRelease(lockId) {
+    if (!this._control.pauseLockset.has(lockId)) return;
+    this._control.pauseLockset.delete(lockId);
+    if (this._slot.pull && this._control.demandOwed) this._fireOwedDemandIfReady();
+    if (this._hasBoundaryPauseLock()) return;
+    scheduleBoundaryDrain(this._core);
+    if (this._control.pauseLockset.size > 0) return;
+    this._onResume();
+  }
+  _onResume() {
+    if (this._value.terminal !== void 0) {
+      this._control.pauseBuffer = [];
+      this._control.pausedDepWaveOccurred = false;
+      this._control.demandOwed = 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();
+    }
+  }
+  /**
+   * R-pull (D59): 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;
+    const own = this._control.pauseLockset.has(this._slot.pullLock) ? 1 : 0;
+    return this._control.pauseLockset.size <= own;
+  }
+  /**
+   * R-pull (D59): deliver ONE demand pulse — release the pullId so the demand wave RELAYS (not
+   * absorbed), fire it, then RE-QUIET (1:1). The pullId re-add + the re-entrancy flag are in a
+   * `finally` so a throwing pull fn (graph-less node, no D30 catch) cannot leave the node
+   * permanently non-quiet (the wedge-fix silently disabled) — QA-found robustness fix.
+   */
+  _deliverPullDemand() {
+    this._control.demandOwed = false;
+    this._control.inDeliverDemand = true;
+    this._control.pauseLockset.delete(this._slot.pullLock);
+    try {
+      this._firePullDemand();
+    } finally {
+      this._control.pauseLockset.add(this._slot.pullLock);
+      this._control.inDeliverDemand = false;
+    }
+  }
+  /**
+   * R-pull (D59): a cone-routed RESUME 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() {
+    if (this._control.inDeliverDemand) return;
+    if (this._canFireDemand()) this._deliverPullDemand();
+    else this._control.demandOwed = true;
+  }
+  /**
+   * 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() {
+    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) {
+      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._markDirty();
+      this._tryRun();
+    }
+  }
+  /**
+   * R-pull (D55/D59): 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 && this._canFireDemand())
+      this._deliverPullDemand();
+  }
+  /** Should an outgoing settle slice be deferred into the pause buffer? */
+  _shouldBufferOnPause() {
+    if (this._slot.pausable === false) return false;
+    if (!this._isPaused()) return false;
+    if (this._slot.pausable === "resumeAll") return true;
+    if (!this._wave.insideRunWave && this._isAsyncPool() && this._slot.deps.length > 0) return true;
+    return false;
+  }
+  /** 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.
+  _allDepsTerminal() {
+    if (this._slot.deps.length === 0) return false;
+    for (const tm of this._dep.terminal) if (tm === void 0) return false;
+    return true;
+  }
+  /** 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 = 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);
+  }
+  /** Batch commit (R-batch-coalesce): deliver the deferred tier-3 wave now. */
+  __commitBatchedWave(wave) {
+    this._wave.batchDirtyOwed = false;
+    this._down(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"]);
+    }
+  }
+  /** B49: enqueue a committed-boundary task on this node's graph-local core. */
+  __deferBoundary(fn, batchToken) {
+    deferRewire(this._core, fn, {
+      batchToken,
+      isReady: () => !this._hasBoundaryPauseLock()
+    });
+  }
+};
+
+// src/graph/operators.ts
+function initNode(op, deps, opts = {}) {
+  return makeInitNode(op, deps, opts);
+}
+function makeInitNode(op, deps, opts) {
+  const body = operatorNodeFn(op);
+  return new Node([...deps], body, { factory: op.factory, ...op.opts, ...opts });
+}
+function operatorNodeFn(op) {
+  return (ctx) => {
+    try {
+      op.body(ctx);
+    } catch (e) {
+      ctx.down([["ERROR", errorPayload(e, "operator threw without a valid error payload")]]);
+    }
+  };
+}
+
+// src/graph/composition.ts
+function metaEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a == null || b == null || typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (!metaEqual(a[i], b[i])) return false;
+    return true;
+  }
+  const ak = Object.keys(a).sort();
+  const bk = Object.keys(b).sort();
+  if (ak.length !== bk.length) return false;
+  for (let i = 0; i < ak.length; i++) {
+    if (ak[i] !== bk[i]) return false;
+    if (!metaEqual(a[ak[i]], b[bk[i]]))
+      return false;
+  }
+  return true;
+}
+function edgeKey(e) {
+  return `${e.from}\0${e.to}`;
+}
+function cloneNode(n) {
+  return {
+    ...n,
+    deps: [...n.deps],
+    ...n.meta ? { meta: { ...n.meta } } : {}
+  };
+}
+function flattenSnapshot(snap) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const subgraphs = /* @__PURE__ */ new Set();
+  const visit = (s, indexPath = "") => {
+    for (const n of s.nodes) nodes.set(n.id, n);
+    for (const e of s.edges) edges.set(edgeKey(e), e);
+    s.subgraphs?.forEach((child, i) => {
+      const prefixed = child.nodes.find((n) => n.id.includes("::"))?.id;
+      const key = prefixed?.slice(0, prefixed.lastIndexOf("::")) ?? (child.name ? `${indexPath}${child.name}` : `${indexPath}${i}`);
+      subgraphs.add(key);
+      visit(child, `${key}/`);
+    });
+  };
+  visit(snap);
+  return { nodes, edges, subgraphs };
+}
+function topologyDiff(prev, next) {
+  const p = flattenSnapshot(prev);
+  const n = flattenSnapshot(next);
+  const events = [];
+  for (const path of [...n.subgraphs].filter((x) => !p.subgraphs.has(x)).sort())
+    events.push({ type: "subgraph-mounted", path });
+  for (const id of [...n.nodes.keys()].filter((x) => !p.nodes.has(x)).sort()) {
+    events.push({ type: "node-added", id, node: cloneNode(n.nodes.get(id)) });
+  }
+  for (const id of [...n.nodes.keys()].filter((x) => p.nodes.has(x)).sort()) {
+    const prevMeta = p.nodes.get(id)?.meta ?? {};
+    const nextMeta = n.nodes.get(id)?.meta ?? {};
+    if (!metaEqual(prevMeta, nextMeta)) {
+      events.push({
+        type: "node-meta-changed",
+        id,
+        prevMeta: { ...prevMeta },
+        nextMeta: { ...nextMeta }
+      });
+    }
+  }
+  for (const [k, e] of [...n.edges.entries()].sort()) {
+    if (!p.edges.has(k)) events.push({ type: "edge-added", from: e.from, to: e.to });
+  }
+  for (const [k, e] of [...p.edges.entries()].sort()) {
+    if (!n.edges.has(k)) events.push({ type: "edge-removed", from: e.from, to: e.to });
+  }
+  for (const id of [...p.nodes.keys()].filter((x) => !n.nodes.has(x)).sort())
+    events.push({ type: "node-removed", id });
+  for (const path of [...p.subgraphs].filter((x) => !n.subgraphs.has(x)).sort())
+    events.push({ type: "subgraph-unmounted", path });
+  return { events };
+}
+function pipe(g, source, ...ops) {
+  let current = source;
+  for (const op of ops) current = g.initNode(op, [current]);
+  return current;
+}
+function stratifyBranch(source, rules, classifier, opts = {}) {
+  const op = stratifyBranchOperator(classifier);
+  return initNode(op, [source, rules], opts);
+}
+function stratifyBranchOperator(classifier) {
+  return {
+    factory: "stratifyBranch",
+    opts: {
+      completeWhenDepsComplete: false,
+      errorWhenDepsError: false,
+      terminalAsRealInput: true
+    },
+    body: (ctx) => {
+      const sourceBatch = depBatch(ctx, 0);
+      const sourceTerminal = depTerminal(ctx, 0);
+      const rules = depLatest(ctx, 1);
+      if (rules !== void 0 && sourceBatch !== null) {
+        for (const value of sourceBatch) {
+          if (classifier(rules, value)) ctx.down([["DATA", value]]);
+        }
+      }
+      if (isTerminalComplete(sourceTerminal)) {
+        ctx.down([["COMPLETE"]]);
+      } else if (isTerminalError(sourceTerminal)) {
+        ctx.down([["ERROR", terminalErrorValue(sourceTerminal)]]);
+      }
+    }
+  };
+}
+function stratify(g, source, rules, classifier, opts = {}) {
+  const prefix = opts.prefix ?? "branch";
+  const seen = /* @__PURE__ */ new Set();
+  for (const { name } of rules) {
+    if (seen.has(name)) throw new Error(`stratify: duplicate rule name '${name}'`);
+    seen.add(name);
+  }
+  const { meta: rulesMeta, ...rulesOpts } = opts.rules ?? {};
+  const rulesNode = g.state([...rules], {
+    ...rulesOpts,
+    name: rulesOpts.name ?? `${prefix}/rules`,
+    meta: { ...rulesMeta ?? {}, kind: "stratify_rules" }
+  });
+  const branches = {};
+  for (const rule of rules) {
+    const op = stratifyBranchOperator((all, value) => {
+      const current = all.find((r) => r.name === rule.name);
+      return current === void 0 ? false : classifier(current.rule, value);
+    });
+    const { meta: branchMeta, ...branchOpts } = opts.branches?.[rule.name] ?? {};
+    branches[rule.name] = g.initNode(op, [source, rulesNode], {
+      ...branchOpts,
+      name: branchOpts.name ?? `${prefix}/${rule.name}`,
+      meta: { ...rule.meta ?? {}, ...branchMeta ?? {}, branch: rule.name }
+    });
+  }
+  return { rules: rulesNode, branches };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pipe,
+  stratify,
+  stratifyBranch,
+  topologyDiff
+});
+//# sourceMappingURL=index.cjs.map