@graphrefly/ts 0.0.0

package/dist/data-structures/index.cjs

@@ -0,0 +1,4277 @@
+"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/data-structures/index.ts
+var data_structures_exports = {};
+__export(data_structures_exports, {
+  mergeReactiveLogs: () => mergeReactiveLogs,
+  reactiveIndex: () => reactiveIndex,
+  reactiveList: () => reactiveList,
+  reactiveLog: () => reactiveLog,
+  reactiveMap: () => reactiveMap,
+  restoreReactiveIndex: () => restoreReactiveIndex,
+  restoreReactiveList: () => restoreReactiveList,
+  restoreReactiveLog: () => restoreReactiveLog,
+  restoreReactiveMap: () => restoreReactiveMap,
+  scanLog: () => scanLog
+});
+module.exports = __toCommonJS(data_structures_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 isTerminalComplete(t) {
+  return t === true;
+}
+function depCount(ctx) {
+  return ctx.waveData.length;
+}
+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(depCount2) {
+  return {
+    batch: new Array(depCount2).fill(null),
+    waveData: Array.from({ length: depCount2 }, () => []),
+    waveTokens: new Array(depCount2).fill(void 0),
+    prev: new Array(depCount2).fill(SENTINEL),
+    hasData: new Array(depCount2).fill(false),
+    dirty: new Array(depCount2).fill(false),
+    tier: new Array(depCount2).fill(0),
+    terminal: new Array(depCount2).fill(void 0),
+    terminalInput: new Array(depCount2).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(node2, prevDeps, deps) {
+  topologyDepsChangedObservers.get(node2)?.(node2, prevDeps, deps);
+}
+function releaseRuntimeOfNode(n) {
+  runtimeReleasers.get(n)?.();
+}
+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()
+    });
+  }
+};
+function node(deps = [], handleOrFn = null, opts = {}) {
+  return new Node(deps, handleOrFn, opts);
+}
+
+// src/graph/checkpoint.ts
+function toCheckpointJson(value, path = "$") {
+  try {
+    return strictJsonCodec.decode(strictJsonCodec.encode(value));
+  } catch (cause) {
+    throw new TypeError(`checkpoint: value at ${path} is not strict JSON compatible`, {
+      cause
+    });
+  }
+}
+var backendStateContributors = /* @__PURE__ */ new WeakMap();
+function registerBackendStateContributor(node2, contributor) {
+  backendStateContributors.set(node2, contributor);
+}
+
+// src/graph/data-structures/core.ts
+function validateViewCacheMaxEntries(policy) {
+  const maxEntries = policy?.maxEntries;
+  if (maxEntries === void 0) return void 0;
+  if (!Number.isInteger(maxEntries) || maxEntries < 0) {
+    throw new RangeError(`viewCache.maxEntries must be a non-negative integer (got ${maxEntries})`);
+  }
+  return maxEntries;
+}
+var ViewMemoCache = class {
+  maxEntries;
+  equals;
+  memo = [];
+  live = /* @__PURE__ */ new Set();
+  constructor(policy, equals = Object.is) {
+    this.maxEntries = validateViewCacheMaxEntries(policy);
+    this.equals = equals;
+  }
+  get(key) {
+    const index = this.memo.findIndex((entry2) => this.equals(entry2.key, key));
+    if (index < 0) return void 0;
+    const [entry] = this.memo.splice(index, 1);
+    if (entry === void 0) return void 0;
+    this.memo.push(entry);
+    return entry.value;
+  }
+  set(key, value) {
+    this.deleteValue(value);
+    this.live.add(value);
+    if (this.maxEntries === 0) return;
+    this.memo.push({ key, value });
+    while (this.maxEntries !== void 0 && this.memo.length > this.maxEntries) {
+      this.memo.shift();
+    }
+  }
+  deleteValue(value) {
+    for (let i = this.memo.length - 1; i >= 0; i -= 1) {
+      if (this.memo[i]?.value === value) this.memo.splice(i, 1);
+    }
+    this.live.delete(value);
+  }
+  disposeAll() {
+    for (const view of [...this.live]) view.dispose();
+    this.memo.length = 0;
+    this.live.clear();
+  }
+};
+function lightReactiveView(parentDelta, opts) {
+  const { dispatcher, factory, graph, materializeSnapshot, name, onDispose } = opts;
+  const base = dispatcher ? { dispatcher } : {};
+  const group = graph?.topologyGroup({ name: name ?? factory });
+  const deltaBody = (ctx) => {
+    for (const change of depBatch(ctx, 0) ?? []) {
+      ctx.down([["DATA", change]]);
+    }
+  };
+  const delta = group ? group.node([parentDelta], deltaBody, {
+    factory: `${factory}.delta`,
+    name: name ? `${name}.delta` : void 0,
+    meta: { kind: "collection_view_delta", factory },
+    partial: true
+  }) : new Node([parentDelta], deltaBody, {
+    ...base,
+    factory: `${factory}.delta`,
+    name: name ? `${name}.delta` : void 0,
+    partial: true
+  });
+  const pullId = /* @__PURE__ */ Symbol(name ? `${name}.snapshot` : `${factory}.snapshot`);
+  const snapshotBody = (ctx) => {
+    try {
+      ctx.down([["DATA", materializeSnapshot()]]);
+    } catch (e) {
+      ctx.down([["ERROR", errorPayload(e, `${factory}.snapshot materializer failed`)]]);
+    }
+  };
+  const snapshot = group ? group.node([delta], snapshotBody, {
+    factory: `${factory}.snapshot`,
+    name: name ? `${name}.snapshot` : void 0,
+    meta: { kind: "collection_view_snapshot", factory },
+    partial: true,
+    pullId
+  }) : new Node([delta], snapshotBody, {
+    ...base,
+    factory: `${factory}.snapshot`,
+    name: name ? `${name}.snapshot` : void 0,
+    partial: true,
+    pullId
+  });
+  let disposed = false;
+  return {
+    delta,
+    snapshot,
+    pullId,
+    dispose() {
+      if (disposed) return;
+      if (group) {
+        group.release({ reason: factory });
+      } else {
+        releaseRuntimeOfNode(delta);
+        releaseRuntimeOfNode(snapshot);
+      }
+      disposed = true;
+      onDispose?.();
+    }
+  };
+}
+function collectionCore(backend, factory, opts = {}, restore) {
+  const { name, dispatcher, graph } = opts;
+  const base = dispatcher ? { dispatcher } : {};
+  let bindSeq = 0;
+  const delta = graph ? graph.node([], null, {
+    factory: `${factory}.delta`,
+    name: name ? `${name}.delta` : void 0,
+    meta: { kind: "collection_delta", collection: factory },
+    ...restore ? { restore: { ref: restore.deltaRef, config: restore.config } } : {}
+  }) : new Node([], null, {
+    ...base,
+    factory: `${factory}.delta`,
+    name: name ? `${name}.delta` : void 0
+  });
+  const pullId = /* @__PURE__ */ Symbol(name ? `${name}.snapshot` : `${factory}.snapshot`);
+  const snapFn = (ctx) => {
+    ctx.down([["DATA", backend.snapshot()]]);
+  };
+  const snapshot = graph ? graph.node([delta], snapFn, {
+    pullId,
+    partial: true,
+    factory: `${factory}.snapshot`,
+    name: name ? `${name}.snapshot` : void 0,
+    meta: { kind: "collection_snapshot", collection: factory },
+    ...restore ? { restore: { ref: restore.snapshotRef, config: restore.config } } : {}
+  }) : new Node([delta], snapFn, {
+    ...base,
+    pullId,
+    partial: true,
+    factory: `${factory}.snapshot`,
+    name: name ? `${name}.snapshot` : void 0
+  });
+  if (restore !== void 0) {
+    registerBackendStateContributor(delta, restore.backendState);
+  }
+  function emit(change) {
+    delta.down([["DATA", change]]);
+  }
+  function bindSource(src, apply) {
+    if (graph === void 0)
+      throw new Error(
+        "collectionCore.bindSource requires options.graph so the input fold is describe-visible (D61)"
+      );
+    const op = {
+      factory: `${factory}.bindSource`,
+      body: (ctx) => {
+        const b = depBatch(ctx, 0);
+        try {
+          if (b) for (const v of b) apply(v);
+        } catch (e) {
+          ctx.down([["ERROR", errorPayload(e, "collectionCore.bindSource failed")]]);
+        }
+      }
+    };
+    const folder = graph.initNode(op, [src], {
+      name: name ? `${name}.bind#${bindSeq++}` : void 0,
+      meta: { kind: "collection_bind_source", collection: factory }
+    });
+    return graph.retain(folder, { reason: `${factory}.bindSource` });
+  }
+  return { delta, snapshot, pullId, emit, bindSource };
+}
+
+// src/graph/data-structures/reactive-index.ts
+function cmpOrd(a, b) {
+  if (a === b) return 0;
+  const ta = typeof a;
+  if (ta === typeof b && (ta === "number" || ta === "string" || ta === "boolean" || ta === "bigint")) {
+    const ax = a;
+    const bx = b;
+    return ax < bx ? -1 : ax > bx ? 1 : 0;
+  }
+  return String(a).localeCompare(String(b));
+}
+function compareRows(a, b) {
+  const c = cmpOrd(a.secondary, b.secondary);
+  return c !== 0 ? c : cmpOrd(a.primary, b.primary);
+}
+function bisectLeft(rows, row) {
+  let lo = 0;
+  let hi = rows.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (compareRows(rows[mid], row) < 0) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+var IndexBackend = class {
+  _version = 0;
+  buf = [];
+  byKey = /* @__PURE__ */ new Map();
+  trackLru;
+  constructor(trackLru, initialRows = []) {
+    this.trackLru = trackLru;
+    for (const row of initialRows) {
+      this.upsert(row.primary, row.secondary, row.value);
+    }
+    this._version = 0;
+  }
+  get version() {
+    return this._version;
+  }
+  get size() {
+    return this.buf.length;
+  }
+  has(primary) {
+    const row = this.byKey.get(primary);
+    if (row === void 0) return false;
+    this.touchLru(row);
+    return true;
+  }
+  get(primary) {
+    const row = this.byKey.get(primary);
+    if (row === void 0) return void 0;
+    this.touchLru(row);
+    return row.value;
+  }
+  touchLru(row) {
+    if (!this.trackLru) return;
+    this.byKey.delete(row.primary);
+    this.byKey.set(row.primary, row);
+  }
+  removeRow(row) {
+    const start = bisectLeft(this.buf, row);
+    for (let i = start; i < this.buf.length && compareRows(this.buf[i], row) === 0; i++) {
+      if (this.buf[i] === row) {
+        this.buf.splice(i, 1);
+        return;
+      }
+    }
+    const fallback = this.buf.indexOf(row);
+    if (fallback >= 0) {
+      this.buf.splice(fallback, 1);
+      return;
+    }
+    throw new Error("reactiveIndex: internal row index desynchronized");
+  }
+  upsert(primary, secondary, value) {
+    const existing = this.byKey.get(primary);
+    const row = { primary, secondary, value };
+    if (existing !== void 0) {
+      this.removeRow(existing);
+      this.byKey.delete(primary);
+    }
+    this.buf.splice(bisectLeft(this.buf, row), 0, row);
+    this.byKey.set(primary, row);
+    this._version += 1;
+    return existing === void 0;
+  }
+  delete(primary) {
+    const existing = this.byKey.get(primary);
+    if (existing === void 0) return false;
+    this.removeRow(existing);
+    this.byKey.delete(primary);
+    this._version += 1;
+    return true;
+  }
+  clear() {
+    const n = this.buf.length;
+    if (n === 0) return 0;
+    this.buf.length = 0;
+    this.byKey.clear();
+    this._version += 1;
+    return n;
+  }
+  rangeByPrimary(start, end) {
+    if (cmpOrd(start, end) >= 0) return [];
+    const rows = [...this.byKey.entries()].filter(
+      ([p]) => cmpOrd(p, start) >= 0 && cmpOrd(p, end) < 0
+    );
+    rows.sort(([a], [b]) => cmpOrd(a, b));
+    return rows.map(([, r]) => r.value);
+  }
+  evictOneForCapacity(order, maxSize) {
+    if (maxSize === void 0) return void 0;
+    if (!Number.isInteger(maxSize) || maxSize < 1)
+      throw new RangeError(`reactiveIndex: maxSize must be a positive integer (got ${maxSize})`);
+    const overflow = this.buf.length - maxSize;
+    if (overflow <= 0) return void 0;
+    switch (order) {
+      case "secondary": {
+        const row = this.buf[0];
+        if (row === void 0) return void 0;
+        this.buf.shift();
+        this.byKey.delete(row.primary);
+        this._version += 1;
+        return row.primary;
+      }
+      case "primary": {
+        let victim;
+        for (const key of this.byKey.keys()) {
+          if (victim === void 0 || cmpOrd(key, victim) < 0) victim = key;
+        }
+        if (victim === void 0) return void 0;
+        const row = this.byKey.get(victim);
+        if (row !== void 0) this.removeRow(row);
+        this.byKey.delete(victim);
+        this._version += 1;
+        return victim;
+      }
+      case "lru": {
+        const oldest = this.byKey.keys().next().value;
+        if (oldest === void 0) return void 0;
+        const row = this.byKey.get(oldest);
+        if (row !== void 0) this.removeRow(row);
+        this.byKey.delete(oldest);
+        this._version += 1;
+        return oldest;
+      }
+      default: {
+        throw new Error(`reactiveIndex: unknown capacity order '${String(order)}'`);
+      }
+    }
+  }
+  snapshot() {
+    return [...this.buf];
+  }
+  toPrimaryMap() {
+    const m = /* @__PURE__ */ new Map();
+    for (const r of this.buf) m.set(r.primary, r.value);
+    return m;
+  }
+};
+function assertCheckpointableIndexRows(rows) {
+  for (const [i, row] of rows.entries()) {
+    const primary = row.primary;
+    if (primary === null || typeof primary === "string" || typeof primary === "number" || typeof primary === "boolean") {
+      continue;
+    }
+    throw new TypeError(
+      `reactiveIndex checkpoint backendState[${i}].primary must be a JSON primitive primary key for D160 restore`
+    );
+  }
+}
+function reactiveIndex(options = {}) {
+  return createReactiveIndex(options);
+}
+function restoreReactiveIndexFromBackendState(initialRows, options = {}) {
+  return createReactiveIndex(options, initialRows);
+}
+function createReactiveIndex(options = {}, initialRows = []) {
+  const { capacity, graph, dispatcher, name } = options;
+  const lruEnabled = capacity?.order === "lru";
+  const backend = new IndexBackend(lruEnabled, initialRows);
+  const core = collectionCore(
+    backend,
+    "reactiveIndex",
+    options,
+    graph !== void 0 && name !== void 0 && capacity === void 0 ? {
+      deltaRef: "reactiveIndex.delta",
+      snapshotRef: "reactiveIndex.snapshot",
+      backendState: () => {
+        const rows = backend.snapshot();
+        assertCheckpointableIndexRows(rows);
+        return rows;
+      }
+    } : void 0
+  );
+  const binds = [];
+  const base = dispatcher ? { dispatcher } : {};
+  const bindDeps = /* @__PURE__ */ new WeakSet();
+  const rangeMemo = new ViewMemoCache(options.viewCache, ([aStart, aEnd], [bStart, bEnd]) => {
+    return cmpOrd(aStart, bStart) === 0 && cmpOrd(aEnd, bEnd) === 0;
+  });
+  let bindSeq = 0;
+  let rangeSeq = 0;
+  let capacityPolicy;
+  let apply;
+  let releaseApply = () => {
+  };
+  function isNodeOpt(x) {
+    return x instanceof Node;
+  }
+  function validateMaxSize(v) {
+    if (!Number.isFinite(v) || !Number.isInteger(v) || v < 1)
+      throw new RangeError(`reactiveIndex: maxSize must be a positive integer (got ${v})`);
+    return v;
+  }
+  function enforceCapacity() {
+    if (currentCapacityOrder === void 0) return;
+    for (; ; ) {
+      const primary = backend.evictOneForCapacity(currentCapacityOrder, currentMaxSize);
+      if (primary === void 0) return;
+      core.emit({ kind: "delete", primary });
+    }
+  }
+  const applyBody = (ctx) => {
+    const deps = apply?.deps ?? [];
+    for (let i = 0; i < depCount(ctx); i++) {
+      const dep = deps[i];
+      if (dep === capacityPolicy) {
+        const latest = depLatest(ctx, i);
+        if (latest !== void 0) currentMaxSize = validateMaxSize(latest);
+        continue;
+      }
+      if (dep && bindDeps.has(dep)) {
+        for (const r of depBatch(ctx, i) ?? []) {
+          backend.upsert(r.primary, r.secondary, r.value);
+          core.emit({ kind: "upsert", primary: r.primary, secondary: r.secondary, value: r.value });
+          enforceCapacity();
+        }
+      }
+    }
+    enforceCapacity();
+  };
+  function ensureApply() {
+    if (apply !== void 0) return apply;
+    const op = {
+      factory: "reactiveIndex.capacityPolicy",
+      body: applyBody,
+      opts: { partial: true }
+    };
+    const deps = capacityPolicy ? [capacityPolicy] : [];
+    apply = graph ? graph.initNode(op, deps, {
+      name: name ? `${name}.capacityPolicy` : void 0,
+      meta: { kind: "collection_policy_apply", collection: "reactiveIndex" }
+    }) : new Node(deps, op.body, {
+      ...base,
+      factory: "reactiveIndex.capacityPolicy",
+      partial: true,
+      name: name ? `${name}.capacityPolicy` : void 0
+    });
+    releaseApply = graph ? graph.retain(apply, { reason: "reactiveIndex.capacityPolicy" }) : apply.subscribe(() => {
+    });
+    return apply;
+  }
+  let currentMaxSize;
+  const currentCapacityOrder = capacity?.order;
+  if (capacity !== void 0) {
+    if (currentCapacityOrder !== "secondary" && currentCapacityOrder !== "primary" && currentCapacityOrder !== "lru") {
+      throw new Error("reactiveIndex: capacity.order must be one of secondary|primary|lru (D73)");
+    }
+    const maxSize = capacity.maxSize;
+    if (isNodeOpt(maxSize) && graph === void 0) {
+      throw new Error(
+        "reactiveIndex capacity.maxSize Node option requires options.graph so the policy edge is describe-visible (D73)"
+      );
+    }
+    capacityPolicy = isNodeOpt(maxSize) ? maxSize : graph ? graph.initNode(
+      {
+        factory: "reactiveIndex.maxSizePolicy",
+        body: () => {
+        },
+        opts: { initial: validateMaxSize(maxSize) }
+      },
+      [],
+      {
+        name: name ? `${name}.maxSizePolicy` : void 0,
+        meta: { kind: "collection_policy", collection: "reactiveIndex", policy: "maxSize" }
+      }
+    ) : void 0;
+    if (!isNodeOpt(maxSize)) currentMaxSize = validateMaxSize(maxSize);
+    if (capacityPolicy instanceof Node) ensureApply();
+  }
+  let byPrimaryNode;
+  function getByPrimary() {
+    if (byPrimaryNode === void 0) {
+      byPrimaryNode = node(
+        [core.delta],
+        (ctx) => {
+          ctx.down([["DATA", backend.toPrimaryMap()]]);
+        },
+        { factory: "reactiveIndex.byPrimary", partial: true }
+      );
+    }
+    return byPrimaryNode;
+  }
+  function getRange(start, end) {
+    const key = [start, end];
+    const hit = rangeMemo.get(key);
+    if (hit !== void 0) return hit;
+    const materialize = () => backend.rangeByPrimary(start, end);
+    let view;
+    view = lightReactiveView(core.delta, {
+      ...options,
+      factory: "reactiveIndex.range",
+      name: name ? `${name}.range#${rangeSeq++}` : void 0,
+      materializeSnapshot: materialize,
+      onDispose: () => {
+        rangeMemo.deleteValue(view);
+      }
+    });
+    rangeMemo.set(key, view);
+    return view;
+  }
+  return {
+    delta: core.delta,
+    snapshot: core.snapshot,
+    pullId: core.pullId,
+    get size() {
+      return backend.size;
+    },
+    has(primary) {
+      return backend.has(primary);
+    },
+    get(primary) {
+      return backend.get(primary);
+    },
+    rangeByPrimary(start, end) {
+      return backend.rangeByPrimary(start, end);
+    },
+    range(start, end) {
+      return getRange(start, end);
+    },
+    toArray() {
+      return backend.snapshot();
+    },
+    toPrimaryMap() {
+      return backend.toPrimaryMap();
+    },
+    get byPrimary() {
+      return getByPrimary();
+    },
+    upsert(primary, secondary, value) {
+      const inserted = backend.upsert(primary, secondary, value);
+      core.emit({ kind: "upsert", primary, secondary, value });
+      enforceCapacity();
+      return inserted;
+    },
+    upsertMany(rows) {
+      for (const r of rows) {
+        backend.upsert(r.primary, r.secondary, r.value);
+        core.emit({ kind: "upsert", primary: r.primary, secondary: r.secondary, value: r.value });
+        enforceCapacity();
+      }
+    },
+    delete(primary) {
+      if (backend.delete(primary)) core.emit({ kind: "delete", primary });
+    },
+    deleteMany(primaries) {
+      const removed = [];
+      for (const p of primaries) if (backend.delete(p)) removed.push(p);
+      if (removed.length > 0) core.emit({ kind: "deleteMany", primaries: removed });
+    },
+    clear() {
+      const count = backend.clear();
+      if (count > 0) core.emit({ kind: "clear", count });
+    },
+    upsertFrom(src) {
+      if (graph === void 0)
+        throw new Error(
+          "reactiveIndex.upsertFrom requires options.graph so the input fold is describe-visible (D61)"
+        );
+      const op = {
+        factory: "reactiveIndex.bindSource",
+        body: (ctx) => {
+          try {
+            for (const r of depBatch(ctx, 0) ?? []) {
+              ctx.down([["DATA", r]]);
+            }
+          } catch (e) {
+            ctx.down([["ERROR", errorPayload(e, "reactiveIndex.bindSource failed")]]);
+          }
+        }
+      };
+      const folder = graph.initNode(op, [src], {
+        name: name ? `${name}.bind#${bindSeq++}` : void 0,
+        meta: { kind: "collection_bind_source", collection: "reactiveIndex" }
+      });
+      bindDeps.add(folder);
+      const applyNode = ensureApply();
+      applyNode.subscribeDep(folder, applyBody);
+      let active2 = true;
+      const dispose = () => {
+        if (!active2) return;
+        active2 = false;
+        applyNode.unsubscribeDep(folder, applyBody);
+      };
+      binds.push(dispose);
+      return dispose;
+    },
+    dispose() {
+      for (const d of binds) d();
+      binds.length = 0;
+      releaseApply();
+      rangeMemo.disposeAll();
+    }
+  };
+}
+
+// src/graph/policies/collection.ts
+var PolicyInputs = class {
+  deps;
+  constructor(initial = []) {
+    this.deps = [...initial];
+  }
+  add(node2) {
+    if (node2 === void 0) return missingPolicyReader();
+    const index = this.deps.push(node2) - 1;
+    return policyReader(index);
+  }
+};
+function missingPolicyReader() {
+  return {
+    index: -1,
+    read: (_ctx, current) => current
+  };
+}
+function policyReader(index) {
+  return {
+    index,
+    read(ctx, current) {
+      const latest = depLatest(ctx, index);
+      return latest === void 0 ? current : latest;
+    }
+  };
+}
+function lruKeys(keys) {
+  return {
+    keys: () => keys
+  };
+}
+function trimHeadOverflow(items, config) {
+  const { maxSize } = config;
+  if (maxSize === void 0) return [];
+  if (!Number.isInteger(maxSize) || maxSize < 1)
+    throw new RangeError(`maxSize must be a positive integer (got ${maxSize})`);
+  const size = "size" in config ? config.size : Array.isArray(items) ? items.length : void 0;
+  if (size === void 0) throw new Error("trimHeadOverflow requires size for non-array iterables");
+  const overflow = size - maxSize;
+  if (overflow <= 0) return [];
+  if (Array.isArray(items) && !("size" in config)) return items.splice(0, overflow);
+  const victims = [];
+  for (const item of items) {
+    victims.push(item);
+    if (victims.length === overflow) break;
+  }
+  return victims;
+}
+function deadlines() {
+  return new MinDeadlineHeap();
+}
+var MinDeadlineHeap = class {
+  items = [];
+  get size() {
+    return this.items.length;
+  }
+  push(item) {
+    this.items.push(item);
+    this.up(this.items.length - 1);
+  }
+  peek() {
+    return this.items[0];
+  }
+  pop() {
+    const top = this.items[0];
+    const last = this.items.pop();
+    if (top !== void 0 && last !== void 0 && this.items.length > 0) {
+      this.items[0] = last;
+      this.down(0);
+    }
+    return top;
+  }
+  up(i) {
+    while (i > 0) {
+      const p = i - 1 >> 1;
+      if (this.items[p].expiresAt <= this.items[i].expiresAt)
+        return;
+      [this.items[p], this.items[i]] = [
+        this.items[i],
+        this.items[p]
+      ];
+      i = p;
+    }
+  }
+  down(i) {
+    for (; ; ) {
+      const left = i * 2 + 1;
+      const right = left + 1;
+      let smallest = i;
+      if (left < this.items.length && this.expiresAt(left) < this.expiresAt(smallest))
+        smallest = left;
+      if (right < this.items.length && this.expiresAt(right) < this.expiresAt(smallest))
+        smallest = right;
+      if (smallest === i) return;
+      [this.items[i], this.items[smallest]] = [
+        this.items[smallest],
+        this.items[i]
+      ];
+      i = smallest;
+    }
+  }
+  expiresAt(i) {
+    return this.items[i].expiresAt;
+  }
+};
+function selectRetentionVictims(scoredEntries, config) {
+  const { maxSize } = config;
+  if (maxSize === void 0) return [];
+  if (!Number.isInteger(maxSize) || maxSize < 0)
+    throw new RangeError(`retention maxSize must be a non-negative integer (got ${maxSize})`);
+  const overflow = scoredEntries.length - maxSize;
+  if (overflow <= 0) return [];
+  return scoredEntries.map((item, index) => {
+    if (!Number.isFinite(item.score))
+      throw new RangeError(`retention score must be finite (got ${item.score})`);
+    return { ...item, index };
+  }).sort((a, b) => a.score - b.score || a.index - b.index).slice(0, overflow).map((item) => item.entry);
+}
+
+// src/graph/data-structures/reactive-list.ts
+var ListBackend = class {
+  _version = 0;
+  buf;
+  constructor(initial, maxSize) {
+    this.buf = initial ? [...initial] : [];
+    trimHeadOverflow(this.buf, { maxSize });
+  }
+  get version() {
+    return this._version;
+  }
+  get size() {
+    return this.buf.length;
+  }
+  at(index) {
+    if (!Number.isInteger(index)) return void 0;
+    const i = index >= 0 ? index : this.buf.length + index;
+    return i < 0 || i >= this.buf.length ? void 0 : this.buf[i];
+  }
+  snapshot() {
+    return [...this.buf];
+  }
+  append(value) {
+    this.buf.push(value);
+    this._version += 1;
+  }
+  appendMany(values) {
+    if (values.length === 0) return;
+    for (const v of values) this.buf.push(v);
+    this._version += 1;
+  }
+  insert(index, value) {
+    if (!Number.isInteger(index) || index < 0 || index > this.buf.length)
+      throw new RangeError(`insert: index ${index} out of range [0, ${this.buf.length}]`);
+    this.buf.splice(index, 0, value);
+    this._version += 1;
+  }
+  insertMany(index, values) {
+    if (!Number.isInteger(index) || index < 0 || index > this.buf.length)
+      throw new RangeError(`insertMany: index ${index} out of range [0, ${this.buf.length}]`);
+    if (values.length === 0) return;
+    this.buf.splice(index, 0, ...values);
+    this._version += 1;
+  }
+  pop(index) {
+    if (this.buf.length === 0) throw new RangeError("pop from empty list");
+    if (!Number.isInteger(index)) throw new RangeError(`pop: index ${index} must be an integer`);
+    const i = index >= 0 ? index : this.buf.length + index;
+    if (i < 0 || i >= this.buf.length) throw new RangeError(`pop: index ${index} out of range`);
+    const [v] = this.buf.splice(i, 1);
+    this._version += 1;
+    return v;
+  }
+  clear() {
+    const n = this.buf.length;
+    if (n === 0) return 0;
+    this.buf.length = 0;
+    this._version += 1;
+    return n;
+  }
+  enforceMaxSize(maxSize) {
+    const removed = trimHeadOverflow(this.buf, { maxSize }).length;
+    if (removed > 0) this._version += 1;
+    return removed;
+  }
+};
+function reactiveList(initial, options = {}) {
+  const { maxSize, graph, dispatcher } = options;
+  const base = dispatcher ? { dispatcher } : {};
+  function isNodeOpt(x) {
+    return x instanceof Node;
+  }
+  function validateMaxSize(v) {
+    if (!Number.isFinite(v) || !Number.isInteger(v) || v < 1)
+      throw new RangeError(`reactiveList: maxSize must be a positive integer (got ${v})`);
+    return v;
+  }
+  const initialMaxSize = isNodeOpt(maxSize) ? void 0 : maxSize;
+  const backend = new ListBackend(
+    initial,
+    initialMaxSize === void 0 ? void 0 : validateMaxSize(initialMaxSize)
+  );
+  const restorable = graph !== void 0 && options.name !== void 0 && maxSize === void 0;
+  const core = collectionCore(
+    backend,
+    "reactiveList",
+    options,
+    restorable ? {
+      deltaRef: "reactiveList.delta",
+      snapshotRef: "reactiveList.snapshot",
+      backendState: () => backend.snapshot()
+    } : void 0
+  );
+  const binds = [];
+  const bindDeps = /* @__PURE__ */ new WeakSet();
+  let bindSeq = 0;
+  let capacityPolicy;
+  let apply;
+  let releaseApply = () => {
+  };
+  let currentMaxSize = initialMaxSize;
+  function emitTrimmed(n) {
+    if (n > 0) core.emit({ kind: "trimHead", n });
+  }
+  function enforceCapacity() {
+    emitTrimmed(backend.enforceMaxSize(currentMaxSize));
+  }
+  const applyBody = (ctx) => {
+    const deps = apply?.deps ?? [];
+    for (let i = 0; i < depCount(ctx); i++) {
+      const dep = deps[i];
+      if (dep === capacityPolicy) {
+        const latest = depLatest(ctx, i);
+        if (latest !== void 0) currentMaxSize = validateMaxSize(latest);
+        continue;
+      }
+      if (dep && bindDeps.has(dep)) {
+        for (const value of depBatch(ctx, i) ?? []) {
+          backend.append(value);
+          core.emit({ kind: "append", value });
+          enforceCapacity();
+        }
+      }
+    }
+    enforceCapacity();
+  };
+  function ensureApply() {
+    if (apply !== void 0) return apply;
+    const op = {
+      factory: "reactiveList.capacityPolicy",
+      body: applyBody,
+      opts: { partial: true }
+    };
+    const deps = capacityPolicy ? [capacityPolicy] : [];
+    apply = graph ? graph.initNode(op, deps, {
+      name: options.name ? `${options.name}.capacityPolicy` : void 0,
+      meta: { kind: "collection_policy_apply", collection: "reactiveList" }
+    }) : new Node(deps, op.body, {
+      ...base,
+      factory: "reactiveList.capacityPolicy",
+      partial: true,
+      name: options.name ? `${options.name}.capacityPolicy` : void 0
+    });
+    releaseApply = graph ? graph.retain(apply, { reason: "reactiveList.capacityPolicy" }) : apply.subscribe(() => {
+    });
+    return apply;
+  }
+  function constPolicyNode(value) {
+    const op = {
+      factory: "reactiveList.maxSizePolicy",
+      body: () => {
+      },
+      opts: { initial: value }
+    };
+    if (graph) {
+      return graph.initNode(op, [], {
+        name: options.name ? `${options.name}.maxSizePolicy` : void 0,
+        meta: { kind: "collection_policy", collection: "reactiveList", policy: "maxSize" }
+      });
+    }
+    return new Node([], null, {
+      ...base,
+      initial: value,
+      factory: "reactiveList.maxSizePolicy",
+      name: options.name ? `${options.name}.maxSizePolicy` : void 0
+    });
+  }
+  if (maxSize !== void 0) {
+    if (isNodeOpt(maxSize) && graph === void 0)
+      throw new Error(
+        "reactiveList maxSize Node option requires options.graph so the policy edge is describe-visible (D72)"
+      );
+    capacityPolicy = isNodeOpt(maxSize) ? maxSize : graph ? constPolicyNode(validateMaxSize(maxSize)) : void 0;
+    if (capacityPolicy !== void 0) ensureApply();
+  }
+  return {
+    delta: core.delta,
+    snapshot: core.snapshot,
+    pullId: core.pullId,
+    get size() {
+      return backend.size;
+    },
+    at(index) {
+      return backend.at(index);
+    },
+    toArray() {
+      return backend.snapshot();
+    },
+    append(value) {
+      backend.append(value);
+      core.emit({ kind: "append", value });
+      enforceCapacity();
+    },
+    appendMany(values) {
+      if (values.length === 0) return;
+      const copy = [...values];
+      backend.appendMany(copy);
+      core.emit({ kind: "appendMany", values: copy });
+      enforceCapacity();
+    },
+    insert(index, value) {
+      backend.insert(index, value);
+      core.emit({ kind: "insert", index, value });
+      enforceCapacity();
+    },
+    insertMany(index, values) {
+      if (values.length === 0) {
+        backend.insertMany(index, values);
+        return;
+      }
+      const copy = [...values];
+      backend.insertMany(index, copy);
+      core.emit({ kind: "insertMany", index, values: copy });
+      enforceCapacity();
+    },
+    pop(index = -1) {
+      const resolved = index < 0 ? backend.size + index : index;
+      const value = backend.pop(index);
+      core.emit({ kind: "pop", index: resolved, value });
+      return value;
+    },
+    clear() {
+      const count = backend.clear();
+      if (count > 0) core.emit({ kind: "clear", count });
+    },
+    appendFrom(src) {
+      if (graph === void 0)
+        throw new Error(
+          "reactiveList.appendFrom requires options.graph so the input fold is describe-visible (D61)"
+        );
+      const op = {
+        factory: "reactiveList.bindSource",
+        body: (ctx) => {
+          try {
+            for (const value of depBatch(ctx, 0) ?? []) {
+              ctx.down([["DATA", value]]);
+            }
+          } catch (e) {
+            ctx.down([["ERROR", errorPayload(e, "reactiveList.bindSource failed")]]);
+          }
+        }
+      };
+      const folder = graph.initNode(op, [src], {
+        name: options.name ? `${options.name}.bind#${bindSeq++}` : void 0,
+        meta: { kind: "collection_bind_source", collection: "reactiveList" }
+      });
+      bindDeps.add(folder);
+      const applyNode = ensureApply();
+      applyNode.subscribeDep(folder, applyBody);
+      let active2 = true;
+      const dispose = () => {
+        if (!active2) return;
+        active2 = false;
+        applyNode.unsubscribeDep(folder, applyBody);
+      };
+      binds.push(dispose);
+      return dispose;
+    },
+    dispose() {
+      for (const d of binds) d();
+      binds.length = 0;
+      releaseApply();
+    }
+  };
+}
+
+// src/graph/data-structures/reactive-log.ts
+var LogBackend = class {
+  _version = 0;
+  buf;
+  maxSize;
+  constructor(initial, maxSize) {
+    if (maxSize !== void 0 && maxSize < 1)
+      throw new RangeError("reactiveLog: maxSize must be >= 1");
+    this.maxSize = maxSize;
+    this.buf = initial ? [...initial] : [];
+    trimHeadOverflow(this.buf, { maxSize });
+  }
+  get version() {
+    return this._version;
+  }
+  get size() {
+    return this.buf.length;
+  }
+  at(index) {
+    if (!Number.isInteger(index)) return void 0;
+    const i = index >= 0 ? index : this.buf.length + index;
+    return i < 0 || i >= this.buf.length ? void 0 : this.buf[i];
+  }
+  snapshot() {
+    return [...this.buf];
+  }
+  append(value) {
+    this.buf.push(value);
+    trimHeadOverflow(this.buf, { maxSize: this.maxSize });
+    this._version += 1;
+  }
+  appendMany(values) {
+    if (values.length === 0) return;
+    for (const v of values) this.buf.push(v);
+    trimHeadOverflow(this.buf, { maxSize: this.maxSize });
+    this._version += 1;
+  }
+  clear() {
+    const n = this.buf.length;
+    if (n === 0) return 0;
+    this.buf.length = 0;
+    this._version += 1;
+    return n;
+  }
+  trimHead(n) {
+    if (!Number.isInteger(n) || n < 0)
+      throw new RangeError(`trimHead: n must be a non-negative integer (got ${n})`);
+    if (n === 0 || this.buf.length === 0) return 0;
+    const removed = Math.min(n, this.buf.length);
+    this.buf.splice(0, removed);
+    this._version += 1;
+    return removed;
+  }
+};
+function rejectUndefined(value, ctx) {
+  if (value === void 0)
+    throw new TypeError(
+      `${ctx}: undefined is the substrate SENTINEL, not a valid value \u2014 use null`
+    );
+}
+function reactiveLog(initial, options = {}) {
+  const { maxSize, viewCache, ...coreOpts } = options;
+  const base = coreOpts.dispatcher ? { dispatcher: coreOpts.dispatcher } : {};
+  const backend = new LogBackend(initial, maxSize);
+  const restoreConfig = coreOpts.graph !== void 0 && coreOpts.name !== void 0 ? {
+    ...maxSize !== void 0 ? { maxSize } : {}
+  } : void 0;
+  const core = collectionCore(
+    backend,
+    "reactiveLog",
+    coreOpts,
+    restoreConfig !== void 0 ? {
+      deltaRef: "reactiveLog.delta",
+      snapshotRef: "reactiveLog.snapshot",
+      config: restoreConfig,
+      backendState: () => backend.snapshot()
+    } : void 0
+  );
+  const binds = [];
+  const tailMemo = /* @__PURE__ */ new Map();
+  const sliceMemo = /* @__PURE__ */ new Map();
+  const pageMemo = new ViewMemoCache(viewCache);
+  let pageSeq = 0;
+  return {
+    delta: core.delta,
+    snapshot: core.snapshot,
+    pullId: core.pullId,
+    get size() {
+      return backend.size;
+    },
+    at(index) {
+      return backend.at(index);
+    },
+    toArray() {
+      return backend.snapshot();
+    },
+    append(value) {
+      rejectUndefined(value, "reactiveLog.append");
+      backend.append(value);
+      core.emit({ kind: "append", value });
+    },
+    appendMany(values) {
+      if (values.length === 0) return;
+      for (const v of values) rejectUndefined(v, "reactiveLog.appendMany");
+      const copy = [...values];
+      backend.appendMany(copy);
+      core.emit({ kind: "appendMany", values: copy });
+    },
+    clear() {
+      const count = backend.clear();
+      if (count > 0) core.emit({ kind: "clear", count });
+    },
+    trimHead(n) {
+      const removed = backend.trimHead(n);
+      if (removed > 0) core.emit({ kind: "trimHead", n: removed });
+    },
+    tail(n) {
+      if (!Number.isInteger(n) || n < 0)
+        throw new RangeError(`tail: n must be a non-negative integer (got ${n})`);
+      const hit = tailMemo.get(n);
+      if (hit !== void 0) return hit;
+      const tnode = node(
+        [core.delta],
+        (ctx) => {
+          const all = backend.snapshot();
+          ctx.down([["DATA", n === 0 ? [] : all.slice(Math.max(0, all.length - n))]]);
+        },
+        { ...base, factory: "reactiveLog.tail", partial: true }
+      );
+      tailMemo.set(n, tnode);
+      return tnode;
+    },
+    slice(start, stop) {
+      if (!Number.isInteger(start) || start < 0) {
+        throw new RangeError(`slice: start must be a non-negative integer (got ${start})`);
+      }
+      if (stop !== void 0 && (!Number.isInteger(stop) || stop < 0)) {
+        throw new RangeError(`slice: stop must be a non-negative integer (got ${stop})`);
+      }
+      const key = `${start}:${stop ?? ""}`;
+      const hit = sliceMemo.get(key);
+      if (hit !== void 0) return hit;
+      const snode = node(
+        [core.delta],
+        (ctx) => {
+          ctx.down([["DATA", backend.snapshot().slice(start, stop)]]);
+        },
+        { ...base, factory: "reactiveLog.slice", partial: true }
+      );
+      sliceMemo.set(key, snode);
+      return snode;
+    },
+    page(offset, limit) {
+      if (!Number.isInteger(offset) || offset < 0) {
+        throw new RangeError(`page: offset must be a non-negative integer (got ${offset})`);
+      }
+      if (!Number.isInteger(limit) || limit < 0) {
+        throw new RangeError(`page: limit must be a non-negative integer (got ${limit})`);
+      }
+      const key = `${offset}:${limit}`;
+      const hit = pageMemo.get(key);
+      if (hit !== void 0) return hit;
+      const materialize = () => backend.snapshot().slice(offset, offset + limit);
+      let view;
+      view = lightReactiveView(core.delta, {
+        ...coreOpts,
+        factory: "reactiveLog.page",
+        name: coreOpts.name ? `${coreOpts.name}.page#${pageSeq++}` : void 0,
+        materializeSnapshot: materialize,
+        onDispose: () => {
+          pageMemo.deleteValue(view);
+        }
+      });
+      pageMemo.set(key, view);
+      return view;
+    },
+    scan(initial2, step) {
+      return node(
+        [core.delta],
+        (ctx) => {
+          const st = ctx.state.get() ?? {
+            acc: initial2,
+            processed: 0
+          };
+          const all = backend.snapshot();
+          if (all.length < st.processed || maxSize !== void 0 && all.length <= st.processed) {
+            let acc = initial2;
+            for (const v of all) acc = step(acc, v);
+            st.acc = acc;
+            st.processed = all.length;
+          } else {
+            for (let i = st.processed; i < all.length; i++) st.acc = step(st.acc, all[i]);
+            st.processed = all.length;
+          }
+          ctx.state.set(st);
+          ctx.down([["DATA", st.acc]]);
+        },
+        { ...base, factory: "reactiveLog.scan", partial: true }
+      );
+    },
+    attach(src) {
+      const dispose = core.bindSource(src, (value) => {
+        rejectUndefined(value, "reactiveLog.attach");
+        backend.append(value);
+        core.emit({ kind: "append", value });
+      });
+      binds.push(dispose);
+      return dispose;
+    },
+    dispose() {
+      for (const d of binds) d();
+      binds.length = 0;
+      tailMemo.clear();
+      sliceMemo.clear();
+      pageMemo.disposeAll();
+    }
+  };
+}
+function mergeReactiveLogs(logs) {
+  const deps = logs.map((l) => l.delta);
+  return node(
+    deps,
+    (ctx) => {
+      for (let i = 0; i < depCount(ctx); i++) {
+        const b = depBatch(ctx, i);
+        if (b) for (const c of b) ctx.down([["DATA", c]]);
+      }
+    },
+    { factory: "mergeReactiveLogs", partial: true }
+  );
+}
+function scanLog(log, initial, step) {
+  return log.scan(initial, step);
+}
+
+// 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/sources.ts
+function source(factory, setup, opts) {
+  return {
+    factory,
+    opts,
+    body: (ctx) => {
+      let cleanup;
+      let deactivated = false;
+      ctx.onDeactivation(() => {
+        deactivated = true;
+        if (typeof cleanup === "function") cleanup();
+      });
+      const maybeCleanup = setup(ctx);
+      cleanup = typeof maybeCleanup === "function" ? maybeCleanup : void 0;
+      if (deactivated && typeof cleanup === "function") cleanup();
+    }
+  };
+}
+function timerSource(factory, ms, opts) {
+  const { period, signal } = opts ?? {};
+  const op = source(
+    factory,
+    (ctx) => {
+      let done = false;
+      let count = 0;
+      let t;
+      let iv;
+      const cleanup = () => {
+        done = true;
+        if (t !== void 0) clearTimeout(t);
+        if (iv !== void 0) clearInterval(iv);
+        signal?.removeEventListener("abort", onAbort);
+      };
+      const onAbort = () => {
+        if (done) return;
+        cleanup();
+        ctx.down([["ERROR", errorPayload(signal?.reason)]]);
+      };
+      const finish = () => {
+        if (done) return;
+        if (period != null) {
+          ctx.down([["DATA", count++]]);
+          iv = setInterval(() => {
+            if (done) return;
+            ctx.down([["DATA", count++]]);
+          }, period);
+        } else {
+          done = true;
+          signal?.removeEventListener("abort", onAbort);
+          ctx.down([["DATA", count++], ["COMPLETE"]]);
+        }
+      };
+      if (signal?.aborted) {
+        onAbort();
+        return;
+      }
+      signal?.addEventListener("abort", onAbort, { once: true });
+      t = setTimeout(finish, ms);
+      return cleanup;
+    },
+    { pool: "sync", pausable: false }
+  );
+  if (factory === "timer" && period === void 0 && signal === void 0) {
+    return { ...op, restore: { ref: "timer", config: { ms: toCheckpointJson(ms, "timer.ms") } } };
+  }
+  return op;
+}
+function timer(ms, opts) {
+  return timerSource("timer", ms, opts);
+}
+
+// src/graph/data-structures/reactive-map.ts
+function strictJsonIdentity(value) {
+  return Array.from(strictCanonicalJsonBytes(value)).join(",");
+}
+var MapBackend = class {
+  _version = 0;
+  store = /* @__PURE__ */ new Map();
+  now;
+  constructor(opts) {
+    this.now = opts.now ?? Date.now;
+  }
+  get version() {
+    return this._version;
+  }
+  get size() {
+    return this.store.size;
+  }
+  nowMs() {
+    return this.now();
+  }
+  expiresAtOf(key) {
+    return this.store.get(key)?.expiresAt;
+  }
+  isExpired(e) {
+    return e.expiresAt !== void 0 && this.now() >= e.expiresAt;
+  }
+  resolveExpiresAt(ttl) {
+    if (ttl === void 0) return void 0;
+    if (!Number.isFinite(ttl) || ttl <= 0)
+      throw new RangeError(`reactiveMap: ttl must be a positive finite number (got ${ttl})`);
+    return this.now() + ttl;
+  }
+  deleteExpired(key, e) {
+    this.store.delete(key);
+    this._version += 1;
+    return [[key, e.value]];
+  }
+  /** Read without materializing expiry. Caller routes expired deletes through the apply node (D68). */
+  lookup(key) {
+    const e = this.store.get(key);
+    if (e === void 0) return { found: false };
+    if (this.isExpired(e)) return { found: false, expired: true, previous: e.value };
+    this.store.delete(key);
+    this.store.set(key, e);
+    return { found: true, value: e.value };
+  }
+  /** Set; returns the entries evicted by LRU overflow (the caller emits their delete deltas). */
+  set(key, value, expiresAt) {
+    if (this.store.has(key)) this.store.delete(key);
+    this.store.set(key, { value, expiresAt });
+    this._version += 1;
+  }
+  enforceLru(maxSize) {
+    const evicted = [];
+    for (const oldest of trimHeadOverflow(lruKeys(this.store.keys()).keys(), {
+      maxSize,
+      size: this.store.size
+    })) {
+      const e = this.store.get(oldest);
+      if (e !== void 0) evicted.push([oldest, e.value]);
+      this.store.delete(oldest);
+    }
+    if (evicted.length > 0) this._version += 1;
+    return evicted;
+  }
+  enforceRetention(policy) {
+    if (policy === void 0 || policy.maxSize === void 0) return [];
+    const scored = [];
+    for (const [key, entry] of this.store) {
+      if (!this.isExpired(entry)) {
+        scored.push({
+          entry: [key, entry.value],
+          score: policy.score({ key, value: entry.value })
+        });
+      }
+    }
+    const archived = selectRetentionVictims(scored, { maxSize: policy.maxSize });
+    for (const [key] of archived) this.store.delete(key);
+    if (archived.length > 0) this._version += 1;
+    return archived.map(([key, value]) => [key, value]);
+  }
+  delete(key) {
+    const e = this.store.get(key);
+    if (e === void 0) return { found: false };
+    this.store.delete(key);
+    this._version += 1;
+    return { found: true, value: e.value };
+  }
+  clear() {
+    const n = this.store.size;
+    if (n === 0) return 0;
+    this.store.clear();
+    this._version += 1;
+    return n;
+  }
+  pruneExpired() {
+    const removed = [];
+    for (const [k, e] of this.store) {
+      if (this.isExpired(e)) {
+        this.store.delete(k);
+        removed.push([k, e.value]);
+      }
+    }
+    if (removed.length > 0) this._version += 1;
+    return removed;
+  }
+  pruneKeyIfExpired(key) {
+    const e = this.store.get(key);
+    if (e === void 0 || !this.isExpired(e)) return [];
+    return this.deleteExpired(key, e);
+  }
+  /** Fresh snapshot of live entries. Does not prune; callers choose whether to materialize expiry. */
+  snapshot() {
+    const out = /* @__PURE__ */ new Map();
+    for (const [k, e] of this.store) if (!this.isExpired(e)) out.set(k, e.value);
+    return out;
+  }
+  /** D160 checkpoint payload: exact restorable map entries, excluding TTL-bearing state. */
+  checkpointEntries() {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const [key, entry] of this.store) {
+      if (entry.expiresAt !== void 0) {
+        throw new TypeError(
+          "reactiveMap checkpoint backendState cannot preserve per-entry TTL; persist the map externally or clear TTL state before graph checkpoint (D160)"
+        );
+      }
+      const stableKey = strictJsonIdentity(key);
+      if (seen.has(stableKey)) {
+        throw new TypeError(
+          "reactiveMap checkpoint backendState contains duplicate strict-JSON keys (D160)"
+        );
+      }
+      seen.add(stableKey);
+      out.push([key, entry.value]);
+    }
+    return out;
+  }
+};
+function reactiveMap(options = {}) {
+  return createReactiveMap(options);
+}
+function restoreReactiveMapFromBackendState(initialEntries, options = {}) {
+  return createReactiveMap(options, initialEntries);
+}
+function createReactiveMap(options = {}, initialEntries = []) {
+  const { maxSize, defaultTtl, retention, viewCache, now, name, dispatcher, graph } = options;
+  const backend = new MapBackend({ now });
+  for (const [key, value] of initialEntries) backend.set(key, value);
+  const base = dispatcher ? { dispatcher } : {};
+  const restorable = graph !== void 0 && name !== void 0 && maxSize === void 0 && defaultTtl === void 0 && retention === void 0;
+  function isNodeOpt(x) {
+    return x instanceof Node;
+  }
+  function validateMaxSize(v) {
+    if (!Number.isFinite(v) || !Number.isInteger(v) || v < 1)
+      throw new RangeError(`reactiveMap: maxSize must be a positive integer (got ${v})`);
+    return v;
+  }
+  function validateTtl(v) {
+    if (!Number.isFinite(v) || v <= 0)
+      throw new RangeError(`reactiveMap: defaultTtl must be a positive finite number (got ${v})`);
+    return v;
+  }
+  function validateRetentionMaxSize(v) {
+    if (!Number.isFinite(v) || !Number.isInteger(v) || v < 0)
+      throw new RangeError(
+        `reactiveMap: retention.maxSize must be a non-negative integer (got ${v})`
+      );
+    return v;
+  }
+  if (retention !== void 0 && typeof retention.score !== "function")
+    throw new TypeError("reactiveMap: retention.score must be a function");
+  function constPolicyNode(label, value) {
+    const op = {
+      factory: `reactiveMap.${label}`,
+      body: () => {
+      },
+      opts: { initial: value }
+    };
+    if (graph) {
+      return graph.initNode(op, [], {
+        name: name ? `${name}.${label}` : void 0,
+        meta: { kind: "collection_policy", collection: "reactiveMap", policy: label }
+      });
+    }
+    return new Node([], null, {
+      ...base,
+      initial: value,
+      factory: `reactiveMap.${label}`,
+      name: name ? `${name}.${label}` : void 0
+    });
+  }
+  function policyNode(label, opt, validate) {
+    if (opt === void 0) return void 0;
+    if (isNodeOpt(opt)) {
+      if (graph === void 0)
+        throw new Error(
+          `reactiveMap ${label} Node option requires options.graph so the policy edge is describe-visible (${label === "retentionPolicy" ? "D72" : "D68"})`
+        );
+      return opt;
+    }
+    return constPolicyNode(label, validate(opt));
+  }
+  const intentOp = {
+    factory: "reactiveMap.intent",
+    body: () => {
+    }
+  };
+  const intent = graph ? graph.initNode(intentOp, [], {
+    name: name ? `${name}.intent` : void 0,
+    meta: { kind: "collection_intent", collection: "reactiveMap" },
+    ...restorable ? { restore: { ref: "reactiveMap.intent" } } : {}
+  }) : new Node([], null, {
+    ...base,
+    factory: "reactiveMap.intent",
+    name: name ? `${name}.intent` : void 0
+  });
+  const lruPolicy = policyNode("lruPolicy", maxSize, validateMaxSize);
+  const ttlPolicy = policyNode("ttlPolicy", defaultTtl, validateTtl);
+  const retentionPolicy = policyNode(
+    "retentionPolicy",
+    retention?.maxSize,
+    validateRetentionMaxSize
+  );
+  let currentMaxSize = isNodeOpt(maxSize) ? void 0 : maxSize;
+  let currentDefaultTtl = isNodeOpt(defaultTtl) ? void 0 : defaultTtl;
+  let currentRetentionMaxSize = isNodeOpt(retention?.maxSize) ? void 0 : retention?.maxSize === void 0 ? void 0 : validateRetentionMaxSize(retention.maxSize);
+  const ttlHeap = deadlines();
+  let ttlTimer = null;
+  let ttlTimerDue;
+  const bindDeps = /* @__PURE__ */ new WeakSet();
+  let bindSeq = 0;
+  let apply;
+  const selectMemo = new ViewMemoCache(viewCache);
+  let selectSeq = 0;
+  const policyInputs = new PolicyInputs([intent]);
+  const lruReader = policyInputs.add(lruPolicy);
+  const ttlReader = policyInputs.add(ttlPolicy);
+  const retentionReader = policyInputs.add(retentionPolicy);
+  function emitExpired(ctx, entries) {
+    for (const [key, previous] of entries)
+      ctx.down([["DATA", { kind: "delete", key, previous, reason: "expired" }]]);
+  }
+  function emitLruEvicted(ctx, entries) {
+    for (const [key, previous] of entries)
+      ctx.down([["DATA", { kind: "delete", key, previous, reason: "lru-evict" }]]);
+  }
+  function emitArchived(ctx, entries) {
+    for (const [key, previous] of entries)
+      ctx.down([["DATA", { kind: "delete", key, previous, reason: "archived" }]]);
+  }
+  function nextValidExpiry() {
+    for (; ; ) {
+      const top = ttlHeap.peek();
+      if (top === void 0) return void 0;
+      if (backend.expiresAtOf(top.key) === top.expiresAt) return top;
+      ttlHeap.pop();
+    }
+  }
+  function scheduleTtl(ctx, body) {
+    for (; ; ) {
+      const next = nextValidExpiry();
+      if (next === void 0) {
+        if (ttlTimer) ctx.rewireNext.unsubscribeDep(ttlTimer, body);
+        ttlTimer = null;
+        ttlTimerDue = void 0;
+        return;
+      }
+      if (next.expiresAt <= backend.nowMs()) {
+        emitExpired(ctx, backend.pruneExpired());
+        continue;
+      }
+      if (ttlTimerDue === next.expiresAt) return;
+      if (ttlTimer) ctx.rewireNext.unsubscribeDep(ttlTimer, body);
+      ttlTimerDue = next.expiresAt;
+      ttlTimer = initNode(timer(Math.max(0, next.expiresAt - backend.nowMs())), [], base);
+      ctx.rewireNext.subscribeDep(ttlTimer, body);
+      return;
+    }
+  }
+  function applyIntent(ctx, intentValue) {
+    if (intentValue.kind === "set") {
+      const ttl = intentValue.ttl ?? currentDefaultTtl;
+      const expiresAt = backend.resolveExpiresAt(ttl);
+      backend.set(intentValue.key, intentValue.value, expiresAt);
+      if (expiresAt !== void 0) ttlHeap.push({ key: intentValue.key, expiresAt });
+      ctx.down([["DATA", { kind: "set", key: intentValue.key, value: intentValue.value }]]);
+      emitLruEvicted(ctx, backend.enforceLru(currentMaxSize));
+      emitArchived(
+        ctx,
+        backend.enforceRetention(
+          retention ? { maxSize: currentRetentionMaxSize, score: retention.score } : void 0
+        )
+      );
+      return;
+    }
+    if (intentValue.kind === "delete") {
+      const previous = backend.delete(intentValue.key);
+      if (previous.found)
+        ctx.down([
+          [
+            "DATA",
+            { kind: "delete", key: intentValue.key, previous: previous.value, reason: "explicit" }
+          ]
+        ]);
+      return;
+    }
+    if (intentValue.kind === "clear") {
+      const count = backend.clear();
+      if (count > 0) ctx.down([["DATA", { kind: "clear", count }]]);
+      return;
+    }
+    if (intentValue.kind === "pruneExpired") {
+      emitExpired(ctx, backend.pruneExpired());
+      return;
+    }
+    emitExpired(ctx, backend.pruneKeyIfExpired(intentValue.key));
+  }
+  const applyBody = (ctx) => {
+    const nextMaxSize = lruReader.read(ctx, currentMaxSize);
+    currentMaxSize = nextMaxSize === void 0 ? void 0 : validateMaxSize(nextMaxSize);
+    const nextTtl = ttlReader.read(ctx, currentDefaultTtl);
+    currentDefaultTtl = nextTtl === void 0 ? void 0 : validateTtl(nextTtl);
+    const nextRetentionMaxSize = retentionReader.read(ctx, currentRetentionMaxSize);
+    currentRetentionMaxSize = nextRetentionMaxSize === void 0 ? void 0 : validateRetentionMaxSize(nextRetentionMaxSize);
+    for (const item of depBatch(ctx, 0) ?? []) {
+      applyIntent(ctx, item);
+    }
+    const deps = apply.deps;
+    for (let i = 1; i < depCount(ctx); i++) {
+      if (i === lruReader.index || i === ttlReader.index || i === retentionReader.index) continue;
+      const dep = deps[i];
+      if (dep && bindDeps.has(dep)) {
+        for (const item of depBatch(ctx, i) ?? []) {
+          applyIntent(ctx, item);
+        }
+        continue;
+      }
+      if (dep === ttlTimer && ((depBatch(ctx, i)?.length ?? 0) > 0 || isTerminalComplete(depTerminal(ctx, i)))) {
+        if (ttlTimer) ctx.rewireNext.unsubscribeDep(ttlTimer, applyBody);
+        ttlTimer = null;
+        ttlTimerDue = void 0;
+        emitExpired(ctx, backend.pruneExpired());
+      }
+    }
+    emitLruEvicted(ctx, backend.enforceLru(currentMaxSize));
+    emitArchived(
+      ctx,
+      backend.enforceRetention(
+        retention ? { maxSize: currentRetentionMaxSize, score: retention.score } : void 0
+      )
+    );
+    scheduleTtl(ctx, applyBody);
+  };
+  const applyOp = {
+    factory: "reactiveMap.apply",
+    body: applyBody,
+    opts: { partial: true }
+  };
+  apply = graph ? graph.initNode(applyOp, policyInputs.deps, {
+    name: name ? `${name}.apply` : void 0,
+    meta: { kind: "collection_policy_apply", collection: "reactiveMap" },
+    ...restorable ? { restore: { ref: "reactiveMap.apply" } } : {}
+  }) : initNode(applyOp, policyInputs.deps, {
+    ...base,
+    name: name ? `${name}.apply` : void 0
+  });
+  const pullId = /* @__PURE__ */ Symbol(name ? `${name}.snapshot` : "reactiveMap.snapshot");
+  const snapshotPrepOp = {
+    factory: "reactiveMap.snapshotPrep",
+    body: (ctx) => {
+      const expired = backend.pruneExpired().map(
+        ([key, previous]) => ({
+          kind: "delete",
+          key,
+          previous,
+          reason: "expired"
+        })
+      );
+      ctx.down([["DATA", { snapshot: backend.snapshot(), expired }]]);
+    },
+    opts: {
+      ...base,
+      pullId,
+      partial: true
+    }
+  };
+  const snapshotPrep = graph ? graph.initNode(snapshotPrepOp, [apply], {
+    name: name ? `${name}.snapshotPrep` : void 0,
+    meta: { kind: "collection_snapshot_prep", collection: "reactiveMap" },
+    ...restorable ? { restore: { ref: "reactiveMap.snapshotPrep" } } : {}
+  }) : initNode(snapshotPrepOp, [apply], {
+    ...base,
+    name: name ? `${name}.snapshotPrep` : void 0
+  });
+  const deltaOp = {
+    factory: "reactiveMap.delta",
+    body: (ctx) => {
+      for (const change of depBatch(ctx, 0) ?? []) {
+        ctx.down([["DATA", change]]);
+      }
+      for (const prep of depBatch(ctx, 1) ?? []) {
+        for (const change of prep.expired) ctx.down([["DATA", change]]);
+      }
+    },
+    opts: { partial: true }
+  };
+  const delta = graph ? graph.initNode(deltaOp, [apply, snapshotPrep], {
+    name: name ? `${name}.delta` : void 0,
+    meta: { kind: "collection_delta", collection: "reactiveMap" },
+    ...restorable ? { restore: { ref: "reactiveMap.delta" } } : {}
+  }) : initNode(deltaOp, [apply, snapshotPrep], {
+    ...base,
+    name: name ? `${name}.delta` : void 0
+  });
+  const snapshotOp = {
+    factory: "reactiveMap.snapshot",
+    body: (ctx) => {
+      for (const prep of depBatch(ctx, 0) ?? []) {
+        ctx.down([["DATA", prep.snapshot]]);
+      }
+    },
+    opts: { partial: true }
+  };
+  const snapshot = graph ? graph.initNode(snapshotOp, [snapshotPrep], {
+    name: name ? `${name}.snapshot` : void 0,
+    meta: { kind: "collection_snapshot", collection: "reactiveMap" },
+    ...restorable ? { restore: { ref: "reactiveMap.snapshot" } } : {}
+  }) : initNode(snapshotOp, [snapshotPrep], {
+    ...base,
+    name: name ? `${name}.snapshot` : void 0
+  });
+  if (restorable) {
+    registerBackendStateContributor(intent, () => backend.checkpointEntries());
+  }
+  const releaseApply = graph ? graph.retain(apply, { reason: "reactiveMap.apply" }) : apply.subscribe(() => {
+  });
+  const binds = [];
+  function doSet(key, value, ttl) {
+    if (ttl !== void 0) validateTtl(ttl);
+    intent.down([
+      ["DATA", ttl === void 0 ? { kind: "set", key, value } : { kind: "set", key, value, ttl }]
+    ]);
+  }
+  function read(key) {
+    const r = backend.lookup(key);
+    if (!r.found && r.expired) intent.down([["DATA", { kind: "pruneKey", key }]]);
+    return r;
+  }
+  function selectedSnapshot(predicate) {
+    const out = /* @__PURE__ */ new Map();
+    for (const [key, value] of backend.snapshot()) {
+      if (predicate(value, key)) out.set(key, value);
+    }
+    return out;
+  }
+  function select(predicate) {
+    if (typeof predicate !== "function")
+      throw new TypeError("reactiveMap.select: predicate must be a function");
+    const cached = selectMemo.get(predicate);
+    if (cached !== void 0) return cached;
+    let view;
+    view = lightReactiveView(delta, {
+      dispatcher,
+      graph,
+      factory: "reactiveMap.select",
+      name: name ? `${name}.select#${selectSeq++}` : void 0,
+      materializeSnapshot: () => selectedSnapshot(predicate),
+      onDispose: () => {
+        selectMemo.deleteValue(view);
+      }
+    });
+    selectMemo.set(predicate, view);
+    return view;
+  }
+  return {
+    delta,
+    snapshot,
+    pullId,
+    get size() {
+      return backend.size;
+    },
+    get(key) {
+      const r = read(key);
+      return r.found ? r.value : void 0;
+    },
+    has(key) {
+      return read(key).found;
+    },
+    toMap() {
+      intent.down([["DATA", { kind: "pruneExpired" }]]);
+      return backend.snapshot();
+    },
+    select,
+    set(key, value, opts) {
+      doSet(key, value, opts?.ttl);
+    },
+    setMany(entries, opts) {
+      for (const [k, v] of entries) doSet(k, v, opts?.ttl);
+    },
+    delete(key) {
+      intent.down([["DATA", { kind: "delete", key }]]);
+    },
+    deleteMany(keys) {
+      for (const k of keys) {
+        intent.down([["DATA", { kind: "delete", key: k }]]);
+      }
+    },
+    clear() {
+      intent.down([["DATA", { kind: "clear" }]]);
+    },
+    pruneExpired() {
+      intent.down([["DATA", { kind: "pruneExpired" }]]);
+    },
+    setFrom(src) {
+      if (graph === void 0)
+        throw new Error(
+          "reactiveMap.setFrom requires options.graph so the input fold is describe-visible (D61)"
+        );
+      const op = {
+        factory: "reactiveMap.bindSource",
+        body: (ctx) => {
+          try {
+            for (const [k, v] of depBatch(ctx, 0) ?? []) {
+              ctx.down([["DATA", { kind: "set", key: k, value: v }]]);
+            }
+          } catch (e) {
+            ctx.down([["ERROR", errorPayload(e, "reactiveMap.bindSource failed")]]);
+          }
+        }
+      };
+      const folder = graph.initNode(op, [src], {
+        name: name ? `${name}.bind#${bindSeq++}` : void 0,
+        meta: { kind: "collection_bind_source", collection: "reactiveMap" }
+      });
+      bindDeps.add(folder);
+      apply.subscribeDep(folder, applyBody);
+      let active2 = true;
+      const dispose = () => {
+        if (!active2) return;
+        active2 = false;
+        apply.unsubscribeDep(folder, applyBody);
+      };
+      binds.push(dispose);
+      return dispose;
+    },
+    dispose() {
+      selectMemo.disposeAll();
+      for (const d of binds) d();
+      binds.length = 0;
+      releaseApply();
+    }
+  };
+}
+
+// src/data-structures/persistence.ts
+function isListRestoreState(state) {
+  return !Array.isArray(state);
+}
+function restoreListValues(state) {
+  if (!isListRestoreState(state)) return state;
+  if (state.kind !== "reactiveList") throw new TypeError("restore state kind must be reactiveList");
+  return state.state;
+}
+function isLogRestoreState(state) {
+  return !Array.isArray(state);
+}
+function restoreLogValues(state) {
+  if (!isLogRestoreState(state)) return state;
+  if (state.kind !== "reactiveLog") throw new TypeError("restore state kind must be reactiveLog");
+  return state.state;
+}
+function isMapRestoreState(state) {
+  return !Array.isArray(state);
+}
+function restoreMapEntries(state) {
+  if (!isMapRestoreState(state)) return state;
+  if (state.kind !== "reactiveMap") throw new TypeError("restore state kind must be reactiveMap");
+  return state.state;
+}
+function isIndexRestoreState(state) {
+  return !Array.isArray(state);
+}
+function restoreIndexRows(state) {
+  if (!isIndexRestoreState(state)) return state;
+  if (state.kind !== "reactiveIndex") {
+    throw new TypeError("restore state kind must be reactiveIndex");
+  }
+  return state.state;
+}
+function restoreReactiveList(state, options = {}) {
+  const values = restoreListValues(state);
+  return reactiveList(values, options);
+}
+function restoreReactiveLog(state, options = {}) {
+  const values = restoreLogValues(state);
+  return reactiveLog(values, options);
+}
+function restoreReactiveMap(state, options = {}) {
+  const entries = restoreMapEntries(state);
+  return restoreReactiveMapFromBackendState(entries, options);
+}
+function restoreReactiveIndex(state, options = {}) {
+  const rows = restoreIndexRows(state);
+  return restoreReactiveIndexFromBackendState(rows, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeReactiveLogs,
+  reactiveIndex,
+  reactiveList,
+  reactiveLog,
+  reactiveMap,
+  restoreReactiveIndex,
+  restoreReactiveList,
+  restoreReactiveLog,
+  restoreReactiveMap,
+  scanLog
+});
+//# sourceMappingURL=index.cjs.map