@graphrefly/ts 0.0.0

package/dist/chunk-RIIOUTGM.js

@@ -0,0 +1,1857 @@
+import {
+  timer
+} from "./chunk-G4M3NHRJ.js";
+import {
+  initNode,
+  registerBackendStateContributor
+} from "./chunk-PKVBHGBM.js";
+import {
+  Node,
+  node,
+  releaseRuntimeOfNode
+} from "./chunk-I3IHOHCJ.js";
+import {
+  strictCanonicalJsonBytes
+} from "./chunk-4VLAQHZI.js";
+import {
+  depBatch,
+  depCount,
+  depLatest,
+  depTerminal,
+  isTerminalComplete
+} from "./chunk-SWTLEQL6.js";
+import {
+  errorPayload
+} from "./chunk-DK554R7P.js";
+
+// 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 active = true;
+      const dispose = () => {
+        if (!active) return;
+        active = 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 active = true;
+      const dispose = () => {
+        if (!active) return;
+        active = 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/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 active = true;
+      const dispose = () => {
+        if (!active) return;
+        active = 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);
+}
+
+export {
+  reactiveIndex,
+  restoreReactiveIndexFromBackendState,
+  reactiveList,
+  reactiveLog,
+  mergeReactiveLogs,
+  scanLog,
+  reactiveMap,
+  restoreReactiveMapFromBackendState,
+  restoreReactiveList,
+  restoreReactiveLog,
+  restoreReactiveMap,
+  restoreReactiveIndex
+};
+//# sourceMappingURL=chunk-RIIOUTGM.js.map