@graphrefly/ts 0.0.0

package/dist/chunk-Y3ZLRGHC.js

@@ -0,0 +1,1482 @@
+import {
+  tieredReadThrough
+} from "./chunk-Z2ANQ6JW.js";
+import {
+  graph,
+  restoreNodeInGraph,
+  restoreStateNodeInGraph
+} from "./chunk-2ILL7HQI.js";
+import {
+  hasKvVersioned
+} from "./chunk-DKP56CSW.js";
+import {
+  reactiveList,
+  reactiveLog,
+  restoreReactiveIndexFromBackendState,
+  restoreReactiveMapFromBackendState
+} from "./chunk-RIIOUTGM.js";
+import {
+  timer
+} from "./chunk-G4M3NHRJ.js";
+import {
+  GRAPH_CHECKPOINT_VERSION,
+  map,
+  operatorNodeFn,
+  take,
+  toCheckpointJson
+} from "./chunk-PKVBHGBM.js";
+import {
+  restoreStateOfNode,
+  validateNodeVersionJson
+} from "./chunk-I3IHOHCJ.js";
+import {
+  strictCanonicalJsonBytes
+} from "./chunk-4VLAQHZI.js";
+import {
+  depBatch,
+  depLatest
+} from "./chunk-SWTLEQL6.js";
+import {
+  SENTINEL,
+  errorPayload
+} from "./chunk-DK554R7P.js";
+
+// src/graph/cascading-cache.ts
+function reactiveCascadingCache(opts) {
+  const {
+    graph: g,
+    request,
+    policy,
+    invalidate,
+    tiers,
+    tierNames,
+    promoteTo,
+    load,
+    name,
+    meta
+  } = opts;
+  const eventDeps = [request];
+  const policyIndex = policy === void 0 ? -1 : eventDeps.push(policy) - 1;
+  const invalidateIndex = invalidate === void 0 ? -1 : eventDeps.push(invalidate) - 1;
+  const baseName = name ?? "reactiveCascadingCache";
+  const eventOpts = {
+    name: `${baseName}.events`,
+    meta,
+    partial: true,
+    pool: "async"
+  };
+  const events = g.node(
+    eventDeps,
+    (ctx) => {
+      const st = ctx.state.get() ?? {
+        seq: 0,
+        active: true,
+        dropBeforeSeq: 0
+      };
+      st.active = true;
+      ctx.onDeactivation(() => {
+        st.active = false;
+        st.seq += 1;
+        st.dropBeforeSeq = st.seq;
+      });
+      const requestBatch = depBatch(ctx, 0);
+      const invalidateBatch = invalidateIndex === -1 ? null : depBatch(ctx, invalidateIndex);
+      const policyBatch = policyIndex === -1 ? null : depBatch(ctx, policyIndex);
+      const currentPolicy = policyIndex === -1 ? void 0 : depLatest(ctx, policyIndex);
+      if (requestBatch !== null) {
+        for (const key of requestBatch) {
+          startLookup(ctx, st, {
+            kind: "request",
+            key,
+            tiers,
+            tierNames,
+            load,
+            promoteTo: currentPolicy?.promoteTo ?? promoteTo ?? false
+          });
+        }
+      }
+      if (invalidateBatch !== null) {
+        for (const key of invalidateBatch) {
+          startLookup(ctx, st, {
+            kind: "invalidate",
+            key,
+            tiers,
+            tierNames,
+            load,
+            promoteTo: currentPolicy?.promoteTo ?? promoteTo ?? false
+          });
+        }
+      }
+      if (requestBatch === null && invalidateBatch === null && policyBatch !== null) {
+        const key = st.latestKey;
+        if (key !== void 0) {
+          startLookup(ctx, st, {
+            kind: "request",
+            key,
+            tiers,
+            tierNames,
+            load,
+            promoteTo: currentPolicy?.promoteTo ?? promoteTo ?? false
+          });
+        }
+      }
+      ctx.state.set(st);
+    },
+    eventOpts
+  );
+  const status = g.node(
+    [events],
+    (ctx) => {
+      const st = ctx.state.get() ?? { seq: 0 };
+      const batch = depBatch(ctx, 0);
+      if (batch === null) return;
+      for (const event of batch) {
+        if (event.kind === "request" || event.kind === "invalidate") {
+          st.seq = event.requestSeq;
+          ctx.down([["DATA", { kind: "loading", key: event.key, requestSeq: event.requestSeq }]]);
+          continue;
+        }
+        if (event.requestSeq !== st.seq) continue;
+        if (event.kind === "fill") {
+          if (event.status === "hit") {
+            ctx.down([
+              [
+                "DATA",
+                {
+                  kind: "hit",
+                  key: event.key,
+                  requestSeq: event.requestSeq,
+                  tier: event.tier
+                }
+              ]
+            ]);
+          } else if (event.status === "miss") {
+            ctx.down([["DATA", { kind: "miss", key: event.key, requestSeq: event.requestSeq }]]);
+          } else {
+            ctx.down([
+              [
+                "DATA",
+                {
+                  kind: "error",
+                  key: event.key,
+                  requestSeq: event.requestSeq,
+                  error: event.error
+                }
+              ]
+            ]);
+          }
+        } else if (event.kind === "error") {
+          ctx.down([
+            [
+              "DATA",
+              {
+                kind: "error",
+                key: event.key,
+                requestSeq: event.requestSeq,
+                error: event.error
+              }
+            ]
+          ]);
+        }
+      }
+      ctx.state.set(st);
+    },
+    {
+      name: `${baseName}.status`,
+      initial: { kind: "idle" },
+      meta,
+      partial: true
+    }
+  );
+  const value = g.node(
+    [events],
+    (ctx) => {
+      const st = ctx.state.get() ?? { seq: 0 };
+      const batch = depBatch(ctx, 0);
+      if (batch === null) return;
+      for (const event of batch) {
+        if (event.kind === "request") {
+          st.seq = event.requestSeq;
+          continue;
+        }
+        if (event.kind === "invalidate") {
+          st.seq = event.requestSeq;
+          ctx.down([["INVALIDATE"]]);
+          continue;
+        }
+        if (event.kind !== "fill" || event.requestSeq !== st.seq) continue;
+        if (event.status === "hit" && event.value !== void 0) {
+          ctx.down([["DATA", event.value]]);
+        } else {
+          ctx.down([["INVALIDATE"]]);
+        }
+      }
+      ctx.state.set(st);
+    },
+    {
+      name: `${baseName}.value`,
+      meta,
+      partial: true
+    }
+  );
+  return { value, status, events };
+}
+function startLookup(ctx, st, opts) {
+  const requestSeq = st.seq + 1;
+  st.seq = requestSeq;
+  st.latestKey = opts.key;
+  ctx.down([["DATA", { kind: opts.kind, key: opts.key, requestSeq }]]);
+  tieredReadThrough({
+    key: opts.key,
+    tiers: opts.tiers,
+    tierNames: opts.tierNames,
+    load: opts.load === void 0 ? void 0 : (key) => opts.load?.(key),
+    promoteTo: false
+  }).then(
+    (result) => {
+      promoteFresh(ctx, st, requestSeq, {
+        key: opts.key,
+        tiers: opts.tiers,
+        tierNames: opts.tierNames,
+        promoteTo: opts.promoteTo,
+        result
+      });
+    },
+    (error) => {
+      if (!isLiveRequest(st, requestSeq)) return;
+      ctx.down([
+        [
+          "DATA",
+          {
+            kind: "error",
+            key: opts.key,
+            requestSeq,
+            stage: "lookup",
+            error: errorPayload(error)
+          }
+        ]
+      ]);
+    }
+  );
+}
+function promoteFresh(ctx, st, requestSeq, opts, promotions = [], offset = 0) {
+  if (!isLiveRequest(st, requestSeq)) return;
+  const { result } = opts;
+  const sourceIndex = result.hitTier?.index === -1 ? opts.tiers.length : result.hitTier?.index;
+  const targets = result.value === void 0 || sourceIndex === void 0 ? [] : buildPromotionTargets(opts.tiers.length, sourceIndex, opts.promoteTo);
+  if (st.seq !== requestSeq || offset >= targets.length) {
+    const messages = eventsFromResult(opts.key, requestSeq, result, promotions);
+    if (messages.length > 0) ctx.down(messages);
+    return;
+  }
+  const index = targets[offset];
+  const tier = { index, name: opts.tierNames?.[index] };
+  try {
+    const target = opts.tiers[index];
+    const generation = generationForTier(result.facts, index);
+    const write = hasKvVersioned(target) && generation !== void 0 ? target.setIfMatch(opts.key, result.value, generation) : target.set(opts.key, result.value).then(() => true);
+    write.then(
+      (ok) => {
+        promotions.push({ tier, ok });
+        promoteFresh(ctx, st, requestSeq, opts, promotions, offset + 1);
+      },
+      (error) => {
+        promotions.push({ tier, ok: false, error });
+        promoteFresh(ctx, st, requestSeq, opts, promotions, offset + 1);
+      }
+    );
+  } catch (error) {
+    promotions.push({ tier, ok: false, error });
+    promoteFresh(ctx, st, requestSeq, opts, promotions, offset + 1);
+  }
+}
+function generationForTier(facts, index) {
+  return facts.find((fact) => fact.tier.index === index)?.generation;
+}
+function isLiveRequest(st, requestSeq) {
+  return st.active && requestSeq >= st.dropBeforeSeq;
+}
+function buildPromotionTargets(tierCount, hitIndex, promoteTo) {
+  if (promoteTo === false || tierCount <= 0) return [];
+  const maxPromote = Math.max(0, Math.min(hitIndex, tierCount));
+  if (promoteTo === void 0) return [...Array(maxPromote).keys()];
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const index of promoteTo) {
+    if (!Number.isSafeInteger(index) || index < 0 || index >= tierCount || index >= maxPromote) {
+      continue;
+    }
+    if (!seen.has(index)) {
+      seen.add(index);
+      normalized.push(index);
+    }
+  }
+  return normalized;
+}
+function eventsFromResult(key, requestSeq, result, promotions = result.promotions) {
+  const out = [];
+  let firstError;
+  for (const fact of result.facts) {
+    const lookupEvent = {
+      kind: "lookup",
+      key,
+      requestSeq,
+      outcome: fact.kind,
+      tier: fact.tier,
+      value: fact.value,
+      error: fact.error
+    };
+    out.push(["DATA", lookupEvent]);
+    if (fact.kind === "error") {
+      firstError ??= fact.error;
+      out.push([
+        "DATA",
+        {
+          kind: "error",
+          key,
+          requestSeq,
+          stage: "lookup",
+          tier: fact.tier,
+          error: fact.error
+        }
+      ]);
+    }
+  }
+  for (const promotion of promotions) {
+    out.push([
+      "DATA",
+      {
+        kind: "promotion",
+        key,
+        requestSeq,
+        tier: promotion.tier,
+        ok: promotion.ok,
+        error: promotion.error
+      }
+    ]);
+    if (!promotion.ok) {
+      firstError ??= promotion.error;
+      if (promotion.error !== void 0) {
+        out.push([
+          "DATA",
+          {
+            kind: "error",
+            key,
+            requestSeq,
+            stage: "promotion",
+            tier: promotion.tier,
+            error: promotion.error
+          }
+        ]);
+      }
+    }
+  }
+  out.push([
+    "DATA",
+    {
+      kind: "fill",
+      key,
+      requestSeq,
+      status: result.status,
+      value: result.value,
+      tier: result.hitTier,
+      error: firstError
+    }
+  ]);
+  return out;
+}
+
+// src/graph/diagnostics.ts
+function compareCodeUnit(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function assertMaxDepth(caller, maxDepth) {
+  if (maxDepth !== void 0 && (!Number.isInteger(maxDepth) || maxDepth < 0)) {
+    throw new Error(`${caller}: maxDepth must be an integer >= 0`);
+  }
+}
+function addEdge(map2, from, to) {
+  let set = map2.get(from);
+  if (set === void 0) {
+    set = /* @__PURE__ */ new Set();
+    map2.set(from, set);
+  }
+  set.add(to);
+}
+function flattenSnapshots(snapshot) {
+  const out = [];
+  const stack = [snapshot];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    out.push(cur);
+    if (cur.subgraphs) {
+      for (let i = cur.subgraphs.length - 1; i >= 0; i -= 1) stack.push(cur.subgraphs[i]);
+    }
+  }
+  return out;
+}
+function indexSnapshot(snapshot) {
+  const nodes = /* @__PURE__ */ new Map();
+  const outgoing = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  for (const snap of flattenSnapshots(snapshot)) {
+    for (const n of snap.nodes) {
+      nodes.set(n.id, n);
+      if (!outgoing.has(n.id)) outgoing.set(n.id, /* @__PURE__ */ new Set());
+      if (!incoming.has(n.id)) incoming.set(n.id, /* @__PURE__ */ new Set());
+    }
+  }
+  for (const n of nodes.values()) {
+    for (const dep of n.deps) {
+      if (!dep || !nodes.has(dep)) continue;
+      addEdge(outgoing, dep, n.id);
+      addEdge(incoming, n.id, dep);
+    }
+  }
+  for (const snap of flattenSnapshots(snapshot)) {
+    for (const edge of snap.edges) {
+      if (!edge.from || !edge.to) continue;
+      if (!nodes.has(edge.from) || !nodes.has(edge.to)) continue;
+      addEdge(outgoing, edge.from, edge.to);
+      addEdge(incoming, edge.to, edge.from);
+    }
+  }
+  return { nodes, outgoing, incoming };
+}
+function adjacent(idx, id, direction, both) {
+  return both === true ? /* @__PURE__ */ new Set([...idx.incoming.get(id) ?? [], ...idx.outgoing.get(id) ?? []]) : direction === "upstream" ? idx.incoming.get(id) ?? /* @__PURE__ */ new Set() : idx.outgoing.get(id) ?? /* @__PURE__ */ new Set();
+}
+function reachable(snapshot, from, direction, options = {}) {
+  if (!options.both && direction !== "upstream" && direction !== "downstream") {
+    throw new Error(`reachable: direction must be "upstream" or "downstream"`);
+  }
+  assertMaxDepth("reachable", options.maxDepth);
+  const empty = { paths: [], depths: {}, truncated: false };
+  if (from === "") return options.withDetail ? empty : empty.paths;
+  const idx = indexSnapshot(snapshot);
+  if (!idx.nodes.has(from)) return options.withDetail ? empty : empty.paths;
+  if (options.maxDepth === 0) {
+    const truncated2 = adjacent(idx, from, direction, options.both).size > 0;
+    return options.withDetail ? { ...empty, truncated: truncated2 } : empty.paths;
+  }
+  const depths = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set([from]);
+  const queue = [{ id: from, depth: 0 }];
+  let truncated = false;
+  for (let head = 0; head < queue.length; head += 1) {
+    const cur = queue[head];
+    const next = adjacent(idx, cur.id, direction, options.both);
+    if (options.maxDepth !== void 0 && cur.depth >= options.maxDepth) {
+      if (next.size > 0) truncated = true;
+      continue;
+    }
+    for (const id of next) {
+      if (seen.has(id)) continue;
+      seen.add(id);
+      const depth = cur.depth + 1;
+      depths.set(id, depth);
+      queue.push({ id, depth });
+    }
+  }
+  const paths = [...depths.keys()].sort(compareCodeUnit);
+  if (!options.withDetail) return paths;
+  return {
+    paths,
+    depths: Object.fromEntries([...depths.entries()].sort(([a], [b]) => compareCodeUnit(a, b))),
+    truncated
+  };
+}
+function depIndices(next, prevId) {
+  if (next === void 0) return void 0;
+  const indices = [];
+  for (let i = 0; i < next.deps.length; i += 1) {
+    if (next.deps[i] === prevId) indices.push(i);
+  }
+  return indices.length > 0 ? indices : void 0;
+}
+function stepFor(node, hop, edgeToNext) {
+  const indices = edgeToNext ? depIndices(edgeToNext.next, edgeToNext.prevId) : void 0;
+  const out = {
+    id: node.id,
+    factory: node.factory,
+    status: node.status,
+    hop
+  };
+  if ("value" in node) out.value = node.value;
+  if (indices !== void 0) {
+    out.depIndex = indices[0];
+    if (indices.length > 1) out.depIndices = indices;
+  }
+  return out;
+}
+function makeChain(from, to, reason, steps) {
+  const found = reason === "ok";
+  const text = found ? steps.map((s) => s.id).join(" -> ") : `explainPath: ${reason} from '${from}' to '${to}'`;
+  return {
+    from,
+    to,
+    found,
+    reason,
+    steps,
+    text,
+    toJSON: () => ({ from, to, found, reason, steps })
+  };
+}
+function shortestPath(idx, from, to, maxDepth) {
+  const pred = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set([from]);
+  const queue = [{ id: from, depth: 0 }];
+  let truncated = false;
+  for (let head = 0; head < queue.length; head += 1) {
+    const cur = queue[head];
+    const next = idx.outgoing.get(cur.id) ?? /* @__PURE__ */ new Set();
+    if (maxDepth !== void 0 && cur.depth >= maxDepth) {
+      if (next.size > 0) truncated = true;
+      continue;
+    }
+    for (const id of next) {
+      if (seen.has(id)) continue;
+      seen.add(id);
+      pred.set(id, cur.id);
+      if (id === to) {
+        const path = [to];
+        let p = to;
+        while (p !== from) {
+          p = pred.get(p);
+          path.push(p);
+        }
+        path.reverse();
+        return { path, truncated };
+      }
+      queue.push({ id, depth: cur.depth + 1 });
+    }
+  }
+  return truncated ? { path: [], truncated: true } : void 0;
+}
+function shortestCycle(idx, from, maxDepth) {
+  const first = idx.outgoing.get(from) ?? /* @__PURE__ */ new Set();
+  if (maxDepth === 0) return first.size > 0 ? { path: [], truncated: true } : void 0;
+  const queue = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of first) {
+    if (id === from) return { path: [from, from], truncated: false };
+    seen.add(id);
+    queue.push({ id, depth: 1, path: [from, id] });
+  }
+  let truncated = false;
+  for (let head = 0; head < queue.length; head += 1) {
+    const cur = queue[head];
+    const next = idx.outgoing.get(cur.id) ?? /* @__PURE__ */ new Set();
+    if (maxDepth !== void 0 && cur.depth >= maxDepth) {
+      if (next.size > 0) truncated = true;
+      continue;
+    }
+    for (const id of next) {
+      if (id === from) return { path: [...cur.path, from], truncated: false };
+      if (seen.has(id)) continue;
+      seen.add(id);
+      queue.push({ id, depth: cur.depth + 1, path: [...cur.path, id] });
+    }
+  }
+  return truncated ? { path: [], truncated: true } : void 0;
+}
+function materializePath(idx, path) {
+  return path.map((id, i) => {
+    const node = idx.nodes.get(id);
+    const next = path[i + 1] ? idx.nodes.get(path[i + 1]) : void 0;
+    return stepFor(node, i, next ? { next, prevId: id } : void 0);
+  });
+}
+function explainPath(snapshot, from, to, options = {}) {
+  assertMaxDepth("explainPath", options.maxDepth);
+  const idx = indexSnapshot(snapshot);
+  if (!idx.nodes.has(from)) return makeChain(from, to, "no-such-from", []);
+  if (!idx.nodes.has(to)) return makeChain(from, to, "no-such-to", []);
+  if (options.maxDepth === 0 && from !== to) return makeChain(from, to, "no-path", []);
+  if (from === to && options.findCycle !== true) {
+    return makeChain(from, to, "ok", [stepFor(idx.nodes.get(from), 0)]);
+  }
+  if (from === to && options.findCycle === true) {
+    const cycle = shortestCycle(idx, from, options.maxDepth);
+    if (cycle !== void 0 && cycle.path.length > 0) {
+      return makeChain(from, to, "ok", materializePath(idx, cycle.path));
+    }
+    if (cycle?.truncated) return makeChain(from, to, "max-depth-exceeded", []);
+    return makeChain(from, to, "ok", [stepFor(idx.nodes.get(from), 0)]);
+  }
+  const found = shortestPath(idx, from, to, options.maxDepth);
+  if (found !== void 0 && found.path.length > 0) {
+    return makeChain(from, to, "ok", materializePath(idx, found.path));
+  }
+  return makeChain(from, to, found?.truncated ? "max-depth-exceeded" : "no-path", []);
+}
+function validateNoIslands(snapshot) {
+  const idx = indexSnapshot(snapshot);
+  const orphans = [];
+  for (const node of idx.nodes.values()) {
+    const hasDeps = node.deps.length > 0 || (idx.incoming.get(node.id)?.size ?? 0) > 0;
+    const hasDependents = (idx.outgoing.get(node.id)?.size ?? 0) > 0;
+    if (!hasDeps && !hasDependents && !node.id.startsWith("__internal__/")) {
+      orphans.push({ id: node.id, factory: node.factory });
+    }
+  }
+  orphans.sort((a, b) => compareCodeUnit(a.id, b.id));
+  return {
+    ok: orphans.length === 0,
+    orphans,
+    summary() {
+      if (orphans.length === 0) return "validateNoIslands: ok (no islands)";
+      const head = orphans.slice(0, 3).map((o) => `${o.id} (${o.factory})`).join(", ");
+      return `validateNoIslands: ${orphans.length} island node(s) - ${head}${orphans.length > 3 ? ", ..." : ""}`;
+    }
+  };
+}
+
+// src/graph/inspect.ts
+function filterObserve(stream, predicate) {
+  return {
+    subscribe(sink) {
+      return stream.subscribe((event) => {
+        if (predicate(event)) {
+          sink(event);
+        }
+      });
+    }
+  };
+}
+function sameObserveEvent(prev, next) {
+  return prev.path === next.path && prev.tier === next.tier && prev.msg[0] === next.msg[0] && Object.is(messagePayload(prev.msg), messagePayload(next.msg));
+}
+function messagePayload(msg) {
+  return msg.length > 1 ? msg[1] : void 0;
+}
+function coalesceObserve(stream, equals = sameObserveEvent) {
+  return {
+    subscribe(sink) {
+      let previous;
+      return stream.subscribe((event) => {
+        if (previous && equals(previous, event)) {
+          return;
+        }
+        previous = event;
+        sink(event);
+      });
+    }
+  };
+}
+
+// src/graph/restore.ts
+var stateRestoreDescriptor = {
+  ref: "state",
+  validateConfig(config, configVersion) {
+    if (config !== void 0 || configVersion !== void 0) {
+      throw new Error("restoreGraph: built-in state descriptor does not accept config");
+    }
+    return void 0;
+  },
+  create(ctx) {
+    if (ctx.deps.length !== 0) {
+      throw new Error(`restoreGraph: state node '${ctx.checkpoint.id}' cannot restore deps`);
+    }
+    return ctx.registerState({
+      name: ctx.name,
+      meta: ctx.checkpoint.meta
+    });
+  }
+};
+function objectConfig(config, ref) {
+  if (config === void 0 || config === null || Array.isArray(config) || typeof config !== "object") {
+    throw new Error(`restoreGraph: '${ref}' descriptor requires object config`);
+  }
+  return config;
+}
+function finiteNumber(value, ref, key) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`restoreGraph: '${ref}' config.${key} must be a finite number`);
+  }
+  return value;
+}
+var takeRestoreDescriptor = {
+  ref: "take",
+  validateConfig(config, configVersion) {
+    if (configVersion !== void 0) {
+      throw new Error("restoreGraph: built-in take descriptor does not accept configVersion");
+    }
+    return { n: finiteNumber(objectConfig(config, "take").n, "take", "n") };
+  },
+  create(ctx) {
+    if (ctx.deps.length !== 1) {
+      throw new Error(`restoreGraph: take node '${ctx.checkpoint.id}' requires exactly one dep`);
+    }
+    const op = take(ctx.config.n);
+    return ctx.registerNode("take", ctx.deps, operatorNodeFn(op), {
+      name: ctx.name,
+      meta: ctx.checkpoint.meta,
+      restore: op.restore
+    });
+  }
+};
+var mapRestoreDescriptor = {
+  ref: "map",
+  validateConfig(config, configVersion) {
+    if (configVersion !== void 0) {
+      throw new Error("restoreGraph: built-in map descriptor does not accept configVersion");
+    }
+    const obj = objectConfig(config, "map");
+    if (typeof obj.fn !== "string") {
+      throw new Error("restoreGraph: 'map' config.fn must be a string definition ref");
+    }
+    return { fn: obj.fn };
+  },
+  create(ctx) {
+    if (ctx.deps.length !== 1) {
+      throw new Error(`restoreGraph: map node '${ctx.checkpoint.id}' requires exactly one dep`);
+    }
+    const definition = ctx.resolveDefinition(ctx.config.fn);
+    const op = map(definition);
+    return ctx.registerNode("map", ctx.deps, operatorNodeFn(op), {
+      name: ctx.name,
+      meta: ctx.checkpoint.meta,
+      restore: op.restore
+    });
+  }
+};
+var timerRestoreDescriptor = {
+  ref: "timer",
+  validateConfig(config, configVersion) {
+    if (configVersion !== void 0) {
+      throw new Error("restoreGraph: built-in timer descriptor does not accept configVersion");
+    }
+    return { ms: finiteNumber(objectConfig(config, "timer").ms, "timer", "ms") };
+  },
+  create(ctx) {
+    if (ctx.deps.length !== 0) {
+      throw new Error(`restoreGraph: timer node '${ctx.checkpoint.id}' cannot restore deps`);
+    }
+    const op = timer(ctx.config.ms);
+    return ctx.registerNode("timer", ctx.deps, operatorNodeFn(op), {
+      name: ctx.name,
+      meta: ctx.checkpoint.meta,
+      restore: op.restore,
+      ...op.opts
+    });
+  }
+};
+var restoredCollections = /* @__PURE__ */ new WeakMap();
+function restoredCollectionMap(graph2) {
+  let map2 = restoredCollections.get(graph2);
+  if (map2 === void 0) {
+    map2 = /* @__PURE__ */ new Map();
+    restoredCollections.set(graph2, map2);
+  }
+  return map2;
+}
+function clearRestoredCollectionMap(graph2) {
+  restoredCollections.delete(graph2);
+}
+function collectionBaseId(id, suffix, ref) {
+  if (!id.endsWith(suffix)) {
+    throw new Error(`restoreGraph: '${ref}' node '${id}' must end with '${suffix}'`);
+  }
+  const base = id.slice(0, -suffix.length);
+  if (base.length === 0) {
+    throw new Error(`restoreGraph: '${ref}' node '${id}' has no collection name`);
+  }
+  return base;
+}
+function noCollectionConfig(config, configVersion, ref) {
+  if (config !== void 0 || configVersion !== void 0) {
+    throw new Error(`restoreGraph: '${ref}' descriptor does not accept config`);
+  }
+  return void 0;
+}
+function backendArray(checkpoint, ref) {
+  const state = checkpoint.backendState;
+  if (!Array.isArray(state)) {
+    throw new Error(`restoreGraph: '${ref}' node '${checkpoint.id}' requires array backendState`);
+  }
+  return state;
+}
+function primitiveJsonKey(value, path) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  throw new Error(`restoreGraph: ${path} must be a JSON primitive primary key`);
+}
+function indexRows(checkpoint, ref) {
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [i, row] of backendArray(checkpoint, ref).entries()) {
+    const path = `${checkpoint.id}.backendState[${i}]`;
+    if (row === null || Array.isArray(row) || typeof row !== "object") {
+      throw new Error(`restoreGraph: ${path} must be an index row object`);
+    }
+    if (!Object.hasOwn(row, "primary") || !Object.hasOwn(row, "secondary") || !Object.hasOwn(row, "value")) {
+      throw new Error(`restoreGraph: ${path} must contain primary, secondary, and value`);
+    }
+    const obj = row;
+    const primary = primitiveJsonKey(obj.primary, `${path}.primary`);
+    const stablePrimary = JSON.stringify(primary);
+    if (seen.has(stablePrimary)) {
+      throw new Error(`restoreGraph: ${path}.primary duplicates an earlier index row`);
+    }
+    seen.add(stablePrimary);
+    rows.push({
+      primary,
+      secondary: obj.secondary,
+      value: obj.value
+    });
+  }
+  return rows;
+}
+function stableJsonKey(value) {
+  return Array.from(strictCanonicalJsonBytes(value)).join(",");
+}
+function mapEntries(checkpoint, ref) {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [i, entry] of backendArray(checkpoint, ref).entries()) {
+    const path = `${checkpoint.id}.backendState[${i}]`;
+    if (!Array.isArray(entry) || entry.length !== 2) {
+      throw new Error(`restoreGraph: ${path} must be a [key, value] map entry`);
+    }
+    const key = entry[0];
+    const stableKey = stableJsonKey(key);
+    if (seen.has(stableKey)) {
+      throw new Error(`restoreGraph: ${path}[0] duplicates an earlier map key`);
+    }
+    seen.add(stableKey);
+    entries.push([key, entry[1]]);
+  }
+  return entries;
+}
+function restoredList(ctx, ref) {
+  const base = collectionBaseId(ctx.id, ".delta", ref);
+  if (ctx.deps.length !== 0) {
+    throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' cannot restore deps`);
+  }
+  const collection = reactiveList(backendArray(ctx.checkpoint, ref), {
+    graph: ctx.graph,
+    name: base
+  });
+  restoredCollectionMap(ctx.graph).set(base, { kind: "reactiveList", collection });
+  return collection;
+}
+function restoredIndex(ctx, ref) {
+  const base = collectionBaseId(ctx.id, ".delta", ref);
+  if (ctx.deps.length !== 0) {
+    throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' cannot restore deps`);
+  }
+  const rows = indexRows(ctx.checkpoint, ref);
+  const collection = restoreReactiveIndexFromBackendState(rows, {
+    graph: ctx.graph,
+    name: base
+  });
+  restoredCollectionMap(ctx.graph).set(base, { kind: "reactiveIndex", collection });
+  return collection;
+}
+function restoredLog(ctx, ref) {
+  const base = collectionBaseId(ctx.id, ".delta", ref);
+  if (ctx.deps.length !== 0) {
+    throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' cannot restore deps`);
+  }
+  const state = backendArray(ctx.checkpoint, ref);
+  if (ctx.config.maxSize !== void 0 && state.length > ctx.config.maxSize) {
+    throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' backendState exceeds config.maxSize`);
+  }
+  const collection = reactiveLog(state, {
+    graph: ctx.graph,
+    name: base,
+    ...ctx.config.maxSize !== void 0 ? { maxSize: ctx.config.maxSize } : {}
+  });
+  restoredCollectionMap(ctx.graph).set(base, { kind: "reactiveLog", collection });
+  return collection;
+}
+function restoredMapNode(ctx, ref) {
+  const base = collectionBaseId(ctx.id, ".intent", ref);
+  if (ctx.deps.length !== 0) {
+    throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' cannot restore deps`);
+  }
+  const entries = mapEntries(ctx.checkpoint, ref);
+  const collection = restoreReactiveMapFromBackendState(entries, {
+    graph: ctx.graph,
+    name: base
+  });
+  restoredCollectionMap(ctx.graph).set(base, { kind: "reactiveMap", collection });
+  const node = ctx.graph.find(ctx.id);
+  if (node === void 0) {
+    throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' was not restored`);
+  }
+  return node;
+}
+function existingMapNode(ctx, ref, suffix) {
+  const base = collectionBaseId(ctx.id, suffix, ref);
+  const item = restoredCollectionMap(ctx.graph).get(base);
+  if (item === void 0 || item.kind !== "reactiveMap") {
+    throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' is missing restored '${base}.intent'`);
+  }
+  const node = ctx.graph.find(ctx.id);
+  if (node === void 0) {
+    throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' was not restored`);
+  }
+  return node;
+}
+function existingCollection(ctx, ref, kind) {
+  const base = collectionBaseId(ctx.id, ".snapshot", ref);
+  if (ctx.deps.length !== 1) {
+    throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' requires exactly one dep`);
+  }
+  const item = restoredCollectionMap(ctx.graph).get(base);
+  if (item === void 0 || item.kind !== kind) {
+    throw new Error(`restoreGraph: '${ref}' node '${ctx.id}' is missing restored '${base}.delta'`);
+  }
+  return item;
+}
+function validateLogConfig(config, configVersion, ref) {
+  if (configVersion !== void 0) {
+    throw new Error(`restoreGraph: '${ref}' descriptor does not accept configVersion`);
+  }
+  if (config === void 0) return {};
+  const obj = objectConfig(config, ref);
+  if (obj.maxSize === void 0) return {};
+  const maxSize = finiteNumber(obj.maxSize, ref, "maxSize");
+  if (!Number.isInteger(maxSize) || maxSize < 1) {
+    throw new Error(`restoreGraph: '${ref}' config.maxSize must be a positive integer`);
+  }
+  return { maxSize };
+}
+var reactiveListDeltaRestoreDescriptor = {
+  ref: "reactiveList.delta",
+  validateConfig(config, configVersion) {
+    return noCollectionConfig(config, configVersion, "reactiveList.delta");
+  },
+  create(ctx) {
+    return restoredList(ctx, "reactiveList.delta").delta;
+  }
+};
+var reactiveListSnapshotRestoreDescriptor = {
+  ref: "reactiveList.snapshot",
+  validateConfig(config, configVersion) {
+    return noCollectionConfig(config, configVersion, "reactiveList.snapshot");
+  },
+  create(ctx) {
+    return existingCollection(ctx, "reactiveList.snapshot", "reactiveList").collection.snapshot;
+  }
+};
+var reactiveIndexDeltaRestoreDescriptor = {
+  ref: "reactiveIndex.delta",
+  validateConfig(config, configVersion) {
+    return noCollectionConfig(config, configVersion, "reactiveIndex.delta");
+  },
+  create(ctx) {
+    return restoredIndex(ctx, "reactiveIndex.delta").delta;
+  }
+};
+var reactiveIndexSnapshotRestoreDescriptor = {
+  ref: "reactiveIndex.snapshot",
+  validateConfig(config, configVersion) {
+    return noCollectionConfig(config, configVersion, "reactiveIndex.snapshot");
+  },
+  create(ctx) {
+    return existingCollection(ctx, "reactiveIndex.snapshot", "reactiveIndex").collection.snapshot;
+  }
+};
+var reactiveLogDeltaRestoreDescriptor = {
+  ref: "reactiveLog.delta",
+  validateConfig(config, configVersion) {
+    return validateLogConfig(config, configVersion, "reactiveLog.delta");
+  },
+  create(ctx) {
+    return restoredLog(ctx, "reactiveLog.delta").delta;
+  }
+};
+var reactiveLogSnapshotRestoreDescriptor = {
+  ref: "reactiveLog.snapshot",
+  validateConfig(config, configVersion) {
+    return validateLogConfig(config, configVersion, "reactiveLog.snapshot");
+  },
+  create(ctx) {
+    return existingCollection(ctx, "reactiveLog.snapshot", "reactiveLog").collection.snapshot;
+  }
+};
+var reactiveMapIntentRestoreDescriptor = {
+  ref: "reactiveMap.intent",
+  validateConfig(config, configVersion) {
+    return noCollectionConfig(config, configVersion, "reactiveMap.intent");
+  },
+  create(ctx) {
+    return restoredMapNode(ctx, "reactiveMap.intent");
+  }
+};
+var reactiveMapApplyRestoreDescriptor = {
+  ref: "reactiveMap.apply",
+  validateConfig(config, configVersion) {
+    return noCollectionConfig(config, configVersion, "reactiveMap.apply");
+  },
+  create(ctx) {
+    return existingMapNode(ctx, "reactiveMap.apply", ".apply");
+  }
+};
+var reactiveMapSnapshotPrepRestoreDescriptor = {
+  ref: "reactiveMap.snapshotPrep",
+  validateConfig(config, configVersion) {
+    return noCollectionConfig(config, configVersion, "reactiveMap.snapshotPrep");
+  },
+  create(ctx) {
+    return existingMapNode(ctx, "reactiveMap.snapshotPrep", ".snapshotPrep");
+  }
+};
+var reactiveMapDeltaRestoreDescriptor = {
+  ref: "reactiveMap.delta",
+  validateConfig(config, configVersion) {
+    return noCollectionConfig(config, configVersion, "reactiveMap.delta");
+  },
+  create(ctx) {
+    return existingMapNode(ctx, "reactiveMap.delta", ".delta");
+  }
+};
+var reactiveMapSnapshotRestoreDescriptor = {
+  ref: "reactiveMap.snapshot",
+  validateConfig(config, configVersion) {
+    return noCollectionConfig(config, configVersion, "reactiveMap.snapshot");
+  },
+  create(ctx) {
+    return existingMapNode(ctx, "reactiveMap.snapshot", ".snapshot");
+  }
+};
+var defaultRestoreRegistry = {
+  state: stateRestoreDescriptor,
+  map: mapRestoreDescriptor,
+  take: takeRestoreDescriptor,
+  timer: timerRestoreDescriptor,
+  "reactiveList.delta": reactiveListDeltaRestoreDescriptor,
+  "reactiveList.snapshot": reactiveListSnapshotRestoreDescriptor,
+  "reactiveIndex.delta": reactiveIndexDeltaRestoreDescriptor,
+  "reactiveIndex.snapshot": reactiveIndexSnapshotRestoreDescriptor,
+  "reactiveLog.delta": reactiveLogDeltaRestoreDescriptor,
+  "reactiveLog.snapshot": reactiveLogSnapshotRestoreDescriptor,
+  "reactiveMap.intent": reactiveMapIntentRestoreDescriptor,
+  "reactiveMap.apply": reactiveMapApplyRestoreDescriptor,
+  "reactiveMap.snapshotPrep": reactiveMapSnapshotPrepRestoreDescriptor,
+  "reactiveMap.delta": reactiveMapDeltaRestoreDescriptor,
+  "reactiveMap.snapshot": reactiveMapSnapshotRestoreDescriptor
+};
+function registryGet(registry, ref) {
+  return registry instanceof Map ? registry.get(ref) : registry[ref];
+}
+function isRestoreDescriptor(entry) {
+  return entry !== void 0 && "create" in entry;
+}
+function isRestoreDefinition(entry) {
+  return entry !== void 0 && "kind" in entry && entry.kind === "definition";
+}
+function assertString(value, label) {
+  if (typeof value !== "string") throw new Error(`restoreGraph: ${label} must be a string`);
+  return value;
+}
+function assertStatus(value, id) {
+  if (value !== "sentinel" && value !== "pending" && value !== "dirty" && value !== "settled" && value !== "resolved" && value !== "completed" && value !== "errored") {
+    throw new Error(`restoreGraph: node '${id}' has invalid status '${value}'`);
+  }
+  if (value === "pending" || value === "dirty") {
+    throw new Error(
+      `restoreGraph: node '${id}' has non-quiescent status '${value}' that cannot be checkpoint-restored yet`
+    );
+  }
+  return value;
+}
+function checkpointDataValue(value, id) {
+  if (value.kind === "SENTINEL") return { cache: SENTINEL, hasData: false };
+  if (value.kind === "DATA") return { cache: value.data, hasData: true };
+  throw new Error(`restoreGraph: node '${id}' has invalid checkpoint value`);
+}
+function checkpointTerminal(value, id) {
+  if (value.kind === "none") return void 0;
+  if (value.kind === "COMPLETE") return true;
+  if (value.kind === "ERROR") return value.error;
+  throw new Error(`restoreGraph: node '${id}' has invalid terminal state`);
+}
+function prepareRuntime(node) {
+  const nonAuthoritativeCollectionHelper = isCollectionHelperNonAuthoritative(node);
+  const value = nonAuthoritativeCollectionHelper ? { cache: SENTINEL, hasData: false } : checkpointDataValue(node.value, node.id);
+  const terminal = checkpointTerminal(node.terminal, node.id);
+  const status = assertStatus(node.status, node.id);
+  if (terminal === true && status !== "completed") {
+    throw new Error(`restoreGraph: node '${node.id}' COMPLETE terminal requires completed status`);
+  }
+  if (terminal !== void 0 && terminal !== true && status !== "errored") {
+    throw new Error(`restoreGraph: node '${node.id}' ERROR terminal requires errored status`);
+  }
+  if (terminal === void 0 && (status === "completed" || status === "errored")) {
+    throw new Error(`restoreGraph: node '${node.id}' terminal status requires terminal state`);
+  }
+  if (typeof node.lifecycle.activated !== "boolean") {
+    throw new Error(`restoreGraph: node '${node.id}' lifecycle.activated must be boolean`);
+  }
+  if (typeof node.lifecycle.hasCalledFnOnce !== "boolean") {
+    throw new Error(`restoreGraph: node '${node.id}' lifecycle.hasCalledFnOnce must be boolean`);
+  }
+  if (typeof node.ctxState.persist !== "boolean") {
+    throw new Error(`restoreGraph: node '${node.id}' ctxState.persist must be boolean`);
+  }
+  const ctxState = nonAuthoritativeCollectionHelper ? { cache: SENTINEL, hasData: false } : checkpointDataValue(node.ctxState.value, `${node.id}.ctxState`);
+  const version = node.version === void 0 ? false : validateNodeVersionJson(node.version, `${node.id}.version`);
+  return {
+    cache: value.cache,
+    hasData: value.hasData,
+    status,
+    terminal,
+    hasCalledFnOnce: node.lifecycle.hasCalledFnOnce,
+    ctxState: { value: ctxState.cache, persist: node.ctxState.persist },
+    version
+  };
+}
+function isCollectionHelperNonAuthoritative(node) {
+  if (node.factory.kind !== "registry-ref") return false;
+  return node.factory.ref === "reactiveList.delta" || node.factory.ref === "reactiveList.snapshot" || node.factory.ref === "reactiveIndex.delta" || node.factory.ref === "reactiveIndex.snapshot" || node.factory.ref === "reactiveLog.delta" || node.factory.ref === "reactiveLog.snapshot" || node.factory.ref === "reactiveMap.intent" || node.factory.ref === "reactiveMap.apply" || node.factory.ref === "reactiveMap.delta" || node.factory.ref === "reactiveMap.snapshotPrep" || node.factory.ref === "reactiveMap.snapshot";
+}
+function validateFactory(factory, registry, id) {
+  if (factory.kind === "local-only") {
+    throw new Error(
+      `restoreGraph: node '${id}' uses local-only factory '${factory.name}' (${factory.reason})`
+    );
+  }
+  const ref = assertString(factory.ref, `factory ref for node '${id}'`);
+  const entry = registryGet(registry, ref);
+  if (!isRestoreDescriptor(entry)) {
+    throw new Error(`restoreGraph: missing registry descriptor for '${ref}' (node '${id}')`);
+  }
+  const descriptor = entry;
+  if (descriptor.ref !== ref) {
+    throw new Error(
+      `restoreGraph: registry descriptor for '${ref}' reports ref '${descriptor.ref}'`
+    );
+  }
+  if (factory.config !== void 0) toCheckpointJson(factory.config, `${id}.factory.config`);
+  if (factory.configVersion !== void 0)
+    toCheckpointJson(factory.configVersion, `${id}.factory.configVersion`);
+  return descriptor;
+}
+function resolveDefinition(registry, ref, nodeId) {
+  const entry = registryGet(registry, ref);
+  if (!isRestoreDefinition(entry)) {
+    throw new Error(`restoreGraph: missing function definition for '${ref}' (node '${nodeId}')`);
+  }
+  return entry;
+}
+function prepareCheckpoint(checkpoint, registry, path = "checkpoint", mountAt) {
+  if (checkpoint.version !== GRAPH_CHECKPOINT_VERSION) {
+    throw new Error(`restoreGraph: unsupported checkpoint version at ${path}`);
+  }
+  toCheckpointJson(checkpoint, path);
+  const nodes = /* @__PURE__ */ new Map();
+  const localIds = /* @__PURE__ */ new Set();
+  for (const node of checkpoint.nodes) {
+    assertString(node.id, `${path}.nodes[].id`);
+    if (nodes.has(node.id)) throw new Error(`restoreGraph: duplicate node id '${node.id}'`);
+    if (mountAt !== void 0 && node.id.startsWith(`${mountAt}::`)) {
+      throw new Error(
+        `restoreGraph: mounted checkpoint at '${mountAt}' must use child-local node id '${node.id.slice(`${mountAt}::`.length)}', not '${node.id}'`
+      );
+    }
+    const id = node.id;
+    if (localIds.has(id)) {
+      throw new Error(`restoreGraph: duplicate restored local node id '${id}'`);
+    }
+    localIds.add(id);
+    const factory = node.factory;
+    const descriptor = validateFactory(factory, registry, node.id);
+    const rawConfig = factory.kind === "registry-ref" ? factory.config : void 0;
+    const configVersion = factory.kind === "registry-ref" ? factory.configVersion : void 0;
+    const config = descriptor.validateConfig ? descriptor.validateConfig(rawConfig, configVersion, node) : rawConfig;
+    assertStatus(node.status, node.id);
+    nodes.set(node.id, {
+      checkpoint: node,
+      localId: id,
+      descriptor,
+      config,
+      runtime: prepareRuntime(node),
+      deps: node.deps.map((dep, i) => assertString(dep, `${node.id}.deps[${i}]`))
+    });
+  }
+  for (const prepared of nodes.values()) {
+    for (const dep of prepared.deps) {
+      if (!nodes.has(dep)) {
+        throw new Error(`restoreGraph: node '${prepared.checkpoint.id}' has missing dep '${dep}'`);
+      }
+    }
+  }
+  const edgeKeys = /* @__PURE__ */ new Set();
+  for (const edge of checkpoint.edges) {
+    const edgeKey = `${edge.from}\0${edge.to}`;
+    if (edgeKeys.has(edgeKey)) {
+      throw new Error(`restoreGraph: duplicate edge '${edge.from}' -> '${edge.to}'`);
+    }
+    edgeKeys.add(edgeKey);
+    if (!nodes.has(edge.from) || !nodes.has(edge.to)) {
+      throw new Error(
+        `restoreGraph: edge '${edge.from}' -> '${edge.to}' references a missing node`
+      );
+    }
+    const target = nodes.get(edge.to);
+    if (!target.deps.includes(edge.from)) {
+      throw new Error(
+        `restoreGraph: edge '${edge.from}' -> '${edge.to}' is not present in target deps`
+      );
+    }
+  }
+  for (const prepared of nodes.values()) {
+    for (const dep of prepared.deps) {
+      if (!edgeKeys.has(`${dep}\0${prepared.checkpoint.id}`)) {
+        throw new Error(
+          `restoreGraph: node '${prepared.checkpoint.id}' dep '${dep}' is missing its edge`
+        );
+      }
+    }
+  }
+  const mountPaths = /* @__PURE__ */ new Set();
+  const mounts = [];
+  for (const mount of checkpoint.mounts ?? []) {
+    const at = assertString(mount.at, `${path}.mounts[].at`);
+    if (at.length === 0) throw new Error("restoreGraph: mount path must not be empty");
+    if (mountPaths.has(at)) throw new Error(`restoreGraph: duplicate mount path '${at}'`);
+    mountPaths.add(at);
+    mounts.push({
+      at,
+      prepared: prepareCheckpoint(mount.checkpoint, registry, `${path}.mounts.${at}`, at)
+    });
+  }
+  return { checkpoint, nodes, mounts };
+}
+function constructPrepared(prepared, registry, dispatcher, versioning) {
+  const out = graph({ name: prepared.checkpoint.name, dispatcher, versioning });
+  try {
+    const built = /* @__PURE__ */ new Map();
+    const visiting = /* @__PURE__ */ new Set();
+    const buildNode = (id) => {
+      const existing = built.get(id);
+      if (existing) return existing;
+      const item = prepared.nodes.get(id);
+      if (item === void 0) throw new Error(`restoreGraph: missing prepared node '${id}'`);
+      if (visiting.has(id)) throw new Error(`restoreGraph: dependency cycle at '${id}'`);
+      visiting.add(id);
+      const deps = item.deps.map(buildNode);
+      const node = item.descriptor.create({
+        graph: out,
+        id: item.localId,
+        name: item.checkpoint.name,
+        deps,
+        config: item.config,
+        configVersion: item.checkpoint.factory.kind === "registry-ref" ? item.checkpoint.factory.configVersion : void 0,
+        checkpoint: item.checkpoint,
+        resolveDefinition: (ref) => resolveDefinition(registry, ref, item.checkpoint.id),
+        registerState: (opts) => restoreStateNodeInGraph(out, item.localId, opts),
+        registerNode: (factory, nodeDeps, fn, opts) => restoreNodeInGraph(out, item.localId, factory, nodeDeps, fn, opts)
+      });
+      if (out.find(item.localId) !== node) {
+        throw new Error(
+          `restoreGraph: descriptor '${item.descriptor.ref}' did not register node '${item.localId}'`
+        );
+      }
+      if (node.deps.length !== deps.length || node.deps.some((dep, i) => dep !== deps[i])) {
+        throw new Error(
+          `restoreGraph: descriptor '${item.descriptor.ref}' registered node '${item.localId}' with deps that do not match the checkpoint`
+        );
+      }
+      built.set(id, node);
+      visiting.delete(id);
+      return node;
+    };
+    for (const id of prepared.nodes.keys()) buildNode(id);
+    for (const mount of prepared.mounts) {
+      out.mount(constructPrepared(mount.prepared, registry, dispatcher, versioning), {
+        at: mount.at
+      });
+    }
+    for (const [id, node] of built) {
+      const runtime = prepared.nodes.get(id).runtime;
+      restoreStateOfNode(node, {
+        cache: runtime.cache,
+        hasData: runtime.hasData,
+        status: runtime.status,
+        terminal: runtime.terminal,
+        hasCalledFnOnce: runtime.hasCalledFnOnce,
+        ctxState: runtime.ctxState,
+        version: runtime.version
+      });
+    }
+  } finally {
+    clearRestoredCollectionMap(out);
+  }
+  return out;
+}
+function restoreGraph(checkpoint, options) {
+  if (options == null || options.registry === void 0) {
+    throw new Error("restoreGraph: registry is required");
+  }
+  if (!(options.registry instanceof Map) && (typeof options.registry !== "object" || options.registry === null)) {
+    throw new Error("restoreGraph: registry must be a Map or object");
+  }
+  for (const key of Object.keys(options)) {
+    if (key !== "registry" && key !== "dispatcher" && key !== "versioning") {
+      throw new Error(`restoreGraph: unknown option '${key}'`);
+    }
+  }
+  const prepared = prepareCheckpoint(checkpoint, options.registry);
+  return constructPrepared(prepared, options.registry, options.dispatcher, options.versioning);
+}
+
+// src/graph/worker.ts
+function workerDerived(graph2, deps, opts) {
+  if (typeof opts.prepare !== "function") {
+    throw new TypeError("workerDerived: prepare must be a function");
+  }
+  if (typeof opts.compute !== "function") {
+    throw new TypeError("workerDerived: compute must be a function");
+  }
+  if (opts.backend === void 0 || typeof opts.backend.run !== "function") {
+    throw new TypeError("workerDerived: backend is required");
+  }
+  let latestInvocation = 0;
+  let cancelActive;
+  const fn = (ctx) => {
+    cancelActive?.();
+    cancelActive = void 0;
+    latestInvocation += 1;
+    const invocation = latestInvocation;
+    let input;
+    try {
+      input = opts.prepare(ctx);
+    } catch (error) {
+      ctx.down([["ERROR", errorPayload(error, "workerDerived prepare failed")]]);
+      return;
+    }
+    if (input === void 0) {
+      ctx.down([["RESOLVED"]]);
+      return;
+    }
+    const ownedInput = cloneWorkerInput(input);
+    if (!ownedInput.ok) {
+      ctx.down([["ERROR", errorPayload(new Error(ownedInput.message), ownedInput.message)]]);
+      return;
+    }
+    let live = true;
+    let cancel;
+    let canceled = false;
+    let submitting = true;
+    let settled = false;
+    let synchronousSettlementError;
+    const cancelThis = () => {
+      if (canceled) return;
+      canceled = true;
+      live = false;
+      cancel?.();
+      cancel = void 0;
+    };
+    cancelActive = cancelThis;
+    ctx.onDeactivation(() => {
+      cancelThis();
+      if (cancelActive === cancelThis) cancelActive = void 0;
+    });
+    const assertNotSynchronousCompletion = () => {
+      if (submitting) {
+        synchronousSettlementError = new Error(
+          "workerDerived: backend completions must arrive after backend.run returns"
+        );
+        throw synchronousSettlementError;
+      }
+    };
+    const clearAcceptedSettlement = () => {
+      cancelActive = void 0;
+      cancel = void 0;
+      live = false;
+    };
+    const settle = (settlement) => {
+      if (settled) return;
+      settled = true;
+      assertNotSynchronousCompletion();
+      if (!live || invocation !== latestInvocation) return;
+      clearAcceptedSettlement();
+      if (settlement.ok) {
+        ctx.down([["DATA", settlement.value]]);
+      } else {
+        ctx.down([["ERROR", errorPayload(settlement.error, "workerDerived compute failed")]]);
+      }
+    };
+    let thrown = false;
+    let thrownError;
+    try {
+      cancel = opts.backend.run(
+        {
+          input: ownedInput.value,
+          compute: opts.compute
+        },
+        settle
+      ) ?? void 0;
+    } catch (error) {
+      thrown = true;
+      thrownError = error;
+    } finally {
+      submitting = false;
+    }
+    if (synchronousSettlementError !== void 0) {
+      if (live && invocation === latestInvocation) {
+        ctx.down([
+          ["ERROR", errorPayload(synchronousSettlementError, "workerDerived compute failed")]
+        ]);
+      }
+      cancelThis();
+      if (cancelActive === cancelThis) cancelActive = void 0;
+      return;
+    }
+    if (thrown) {
+      if (live && invocation === latestInvocation) {
+        ctx.down([["ERROR", errorPayload(thrownError, "workerDerived compute failed")]]);
+      }
+      cancelThis();
+      if (cancelActive === cancelThis) cancelActive = void 0;
+    }
+  };
+  return graph2.node(deps, fn, {
+    name: opts.name ?? "workerDerived",
+    factory: "workerDerived",
+    pool: "async",
+    completeWhenDepsComplete: false,
+    errorWhenDepsError: false
+  });
+}
+function cloneWorkerInput(input) {
+  if (typeof input === "function" || typeof input === "symbol") {
+    return { ok: false, message: "workerDerived: input must be owned and cloneable" };
+  }
+  if (typeof input !== "object" || input === null) return { ok: true, value: input };
+  if (typeof globalThis.structuredClone !== "function") {
+    return { ok: false, message: "workerDerived: structuredClone is required for object inputs" };
+  }
+  try {
+    return { ok: true, value: globalThis.structuredClone(input) };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      message: `workerDerived: input must be owned and cloneable (${message})`
+    };
+  }
+}
+
+export {
+  reactiveCascadingCache,
+  reachable,
+  explainPath,
+  validateNoIslands,
+  filterObserve,
+  coalesceObserve,
+  stateRestoreDescriptor,
+  takeRestoreDescriptor,
+  mapRestoreDescriptor,
+  timerRestoreDescriptor,
+  defaultRestoreRegistry,
+  restoreGraph,
+  workerDerived
+};
+//# sourceMappingURL=chunk-Y3ZLRGHC.js.map