@graphrefly/graphrefly 0.27.0 → 0.29.0

package/dist/chunk-PF7GRZMW.js

@@ -1,2712 +0,0 @@
-import {
-  describeNode,
-  resolveDescribeFields
-} from "./chunk-VYPWMZ6H.js";
-import {
-  ResettableTimer,
-  RingBuffer
-} from "./chunk-7TAQJHQV.js";
-import {
-  GuardDenied,
-  NodeImpl,
-  batch,
-  decodeEnvelope,
-  defaultConfig,
-  encodeEnvelope,
-  isBatching,
-  monotonicNs,
-  producer,
-  state,
-  wallClockNs
-} from "./chunk-PHOUUNK7.js";
-import {
-  COMPLETE,
-  DATA,
-  DIRTY,
-  ERROR,
-  INVALIDATE,
-  PAUSE,
-  RESOLVED,
-  RESUME,
-  TEARDOWN
-} from "./chunk-SX52TAR4.js";
-
-// src/graph/explain.ts
-function explainPath(described, from, to, opts = {}) {
-  const fromExists = from in described.nodes;
-  const toExists = to in described.nodes;
-  if (!fromExists) return makeFailure(from, to, "no-such-from");
-  if (!toExists) return makeFailure(from, to, "no-such-to");
-  const maxDepth = opts.maxDepth;
-  if (maxDepth != null && (!Number.isInteger(maxDepth) || maxDepth < 0)) {
-    throw new Error(`explainPath: maxDepth must be an integer >= 0`);
-  }
-  if (from === to) {
-    if (opts.findCycle === true) {
-      const cycle = findShortestCycle(described, from, opts);
-      if (cycle != null) return cycle;
-    }
-    const step = buildStep(from, described.nodes[from], 0, opts);
-    return makeSuccess(from, to, [step]);
-  }
-  if (maxDepth === 0) return makeFailure(from, to, "no-path");
-  const result = bfsShortestPath(described, from, to, maxDepth);
-  if (!result.found) {
-    return makeFailure(from, to, result.truncated ? "max-depth-exceeded" : "no-path");
-  }
-  return makeSuccess(from, to, materializeSteps(described, result.pathOrder, opts));
-}
-function bfsShortestPath(described, from, to, maxDepth) {
-  const pred = /* @__PURE__ */ new Map();
-  const queue = [{ path: to, depth: 0 }];
-  const visited = /* @__PURE__ */ new Set([to]);
-  let head = 0;
-  let truncated = false;
-  while (head < queue.length) {
-    const cur = queue[head++];
-    if (cur.path === from) break;
-    if (maxDepth != null && cur.depth >= maxDepth) {
-      const node2 = described.nodes[cur.path];
-      if (node2?.deps && node2.deps.length > 0) truncated = true;
-      continue;
-    }
-    const node = described.nodes[cur.path];
-    if (node == null) continue;
-    const deps = node.deps ?? [];
-    const slots = /* @__PURE__ */ new Map();
-    for (let i = 0; i < deps.length; i++) {
-      const dep = deps[i];
-      if (!dep) continue;
-      let arr = slots.get(dep);
-      if (arr == null) {
-        arr = [];
-        slots.set(dep, arr);
-      }
-      arr.push(i);
-    }
-    for (const [dep, indices] of slots) {
-      if (visited.has(dep)) continue;
-      visited.add(dep);
-      pred.set(dep, { from: cur.path, depIndices: indices });
-      queue.push({ path: dep, depth: cur.depth + 1 });
-    }
-  }
-  if (!pred.has(from)) {
-    return { found: false, pathOrder: [], truncated };
-  }
-  const pathOrder = [{ path: from }];
-  let cursor = from;
-  while (cursor !== to) {
-    const p = pred.get(cursor);
-    if (p == null) return { found: false, pathOrder: [], truncated: false };
-    pathOrder[pathOrder.length - 1].depIndices = p.depIndices;
-    pathOrder.push({ path: p.from });
-    cursor = p.from;
-  }
-  return { found: true, pathOrder, truncated: false };
-}
-function findShortestCycle(described, start, opts) {
-  const startNode = described.nodes[start];
-  if (startNode == null) return null;
-  const startDeps = startNode.deps ?? [];
-  const selfSlots = [];
-  for (let i = 0; i < startDeps.length; i++) if (startDeps[i] === start) selfSlots.push(i);
-  if (selfSlots.length > 0) {
-    const step0 = buildStep(start, startNode, 0, opts);
-    step0.dep_index = selfSlots[0];
-    const step1 = buildStep(start, startNode, 1, opts);
-    return makeSuccess(start, start, [step0, step1]);
-  }
-  let best = null;
-  for (let i = 0; i < startDeps.length; i++) {
-    const dep = startDeps[i];
-    if (!dep || dep === start) continue;
-    const sub = bfsShortestPath(described, dep, start, opts.maxDepth);
-    if (!sub.found) continue;
-    if (best == null || sub.pathOrder.length < best.pathOrder.length) {
-      best = sub;
-      best = {
-        found: true,
-        pathOrder: [{ path: start, depIndices: [i] }, ...sub.pathOrder],
-        truncated: false
-      };
-    }
-  }
-  if (best == null) return null;
-  return makeSuccess(start, start, materializeSteps(described, best.pathOrder, opts));
-}
-function materializeSteps(described, pathOrder, opts) {
-  return pathOrder.map((entry, i) => {
-    const node = described.nodes[entry.path];
-    const step = buildStep(entry.path, node, i, opts);
-    if (entry.depIndices != null && entry.depIndices.length > 0) {
-      step.dep_index = entry.depIndices[0];
-      if (entry.depIndices.length > 1) step.dep_indices = [...entry.depIndices];
-    }
-    return step;
-  });
-}
-function buildStep(path, node, hop, opts) {
-  const step = {
-    path,
-    type: node.type,
-    hop
-  };
-  if (node.status !== void 0) step.status = node.status;
-  if ("value" in node) step.value = node.value;
-  if (node.v != null) step.v = node.v;
-  const annotation = opts.annotations?.get(path) ?? node.reason;
-  if (annotation != null) step.reason = annotation;
-  const lastMutation = opts.lastMutations?.get(path) ?? node.lastMutation;
-  if (lastMutation != null) step.lastMutation = lastMutation;
-  return step;
-}
-function makeSuccess(from, to, steps) {
-  return finalize(from, to, true, "ok", steps);
-}
-function makeFailure(from, to, reason) {
-  return finalize(from, to, false, reason, []);
-}
-function finalize(from, to, found, reason, steps) {
-  const text = renderChain(from, to, found, reason, steps);
-  return {
-    from,
-    to,
-    found,
-    reason,
-    steps,
-    text,
-    toJSON() {
-      return { from, to, found, reason, steps };
-    }
-  };
-}
-function renderChain(from, to, found, reason, steps) {
-  if (!found) {
-    switch (reason) {
-      case "no-such-from":
-        return `explainPath: no node named "${from}"`;
-      case "no-such-to":
-        return `explainPath: no node named "${to}"`;
-      case "max-depth-exceeded":
-        return `explainPath: no path from "${from}" to "${to}" within maxDepth`;
-      default:
-        return `explainPath: no path from "${from}" to "${to}"`;
-    }
-  }
-  const lines = [`Causal path: ${from} \u2192 ${to} (${steps.length} step(s))`];
-  for (const step of steps) {
-    const arrow = step.hop === 0 ? "\xB7" : "\u2193";
-    const head = `  ${arrow} ${step.path} (${step.type}${step.status ? `/${step.status}` : ""})`;
-    lines.push(head);
-    if ("value" in step) {
-      lines.push(`      value: ${formatValue(step.value)}`);
-    }
-    if (step.reason != null) {
-      lines.push(`      reason: ${step.reason}`);
-    }
-    if (step.lastMutation != null) {
-      const a = step.lastMutation.actor;
-      lines.push(`      actor: ${a.type}${a.id ? `:${a.id}` : ""}`);
-    }
-  }
-  return lines.join("\n");
-}
-function formatValue(v) {
-  if (v === void 0) return "<sentinel>";
-  if (v === null) return "null";
-  if (typeof v === "string") return JSON.stringify(v);
-  if (typeof v === "number" || typeof v === "boolean" || typeof v === "bigint") return String(v);
-  try {
-    const s = JSON.stringify(v);
-    return s.length > 80 ? `${s.slice(0, 77)}...` : s;
-  } catch {
-    return String(v);
-  }
-}
-
-// src/extra/utils/sizeof.ts
-var OVERHEAD = {
-  object: 56,
-  array: 64,
-  string: 40,
-  // header; content added separately
-  number: 8,
-  boolean: 4,
-  null: 0,
-  undefined: 0,
-  symbol: 40,
-  bigint: 16,
-  // base; scales with digit count (see `_bigintSize`)
-  function: 120,
-  map: 72,
-  set: 72,
-  mapEntry: 40,
-  setEntry: 24,
-  date: 24,
-  regexp: 48,
-  error: 64,
-  url: 80,
-  promise: 48,
-  weakmap: 40,
-  weakset: 40
-};
-var SIZEOF_SYMBOL = /* @__PURE__ */ Symbol.for("sizeof");
-function sizeof(value) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  const seenBuffers = /* @__PURE__ */ new WeakSet();
-  const stack = [value];
-  let total = 0;
-  while (stack.length > 0) {
-    const v = stack.pop();
-    total += _shallowSize(v, seen, seenBuffers, stack);
-  }
-  return total;
-}
-function _shallowSize(value, seen, seenBuffers, stack) {
-  if (value === null || value === void 0) return 0;
-  const t = typeof value;
-  switch (t) {
-    case "number":
-      return OVERHEAD.number;
-    case "boolean":
-      return OVERHEAD.boolean;
-    case "string":
-      return OVERHEAD.string + value.length * 2;
-    case "bigint":
-      return OVERHEAD.bigint + _bigintSize(value);
-    case "symbol":
-      return OVERHEAD.symbol;
-    case "function":
-      if (seen.has(value)) return 0;
-      seen.add(value);
-      return OVERHEAD.function;
-    case "undefined":
-      return 0;
-  }
-  const obj = value;
-  if (seen.has(obj)) return 0;
-  seen.add(obj);
-  const hook = obj[SIZEOF_SYMBOL];
-  if (typeof hook === "function") {
-    try {
-      const reported = hook.call(obj);
-      if (typeof reported === "number" && Number.isFinite(reported)) return reported;
-    } catch {
-    }
-  }
-  if (obj instanceof Date) return OVERHEAD.date;
-  if (obj instanceof RegExp) return OVERHEAD.regexp + obj.source.length * 2;
-  if (obj instanceof Error) {
-    const m = obj.message ? obj.message.length * 2 : 0;
-    const s = obj.stack ? obj.stack.length * 2 : 0;
-    return OVERHEAD.error + m + s;
-  }
-  if (typeof URL !== "undefined" && obj instanceof URL) {
-    return OVERHEAD.url + obj.href.length * 2;
-  }
-  if (typeof Promise !== "undefined" && obj instanceof Promise) {
-    return OVERHEAD.promise;
-  }
-  if (obj instanceof WeakMap) return OVERHEAD.weakmap;
-  if (obj instanceof WeakSet) return OVERHEAD.weakset;
-  if (obj instanceof Map) {
-    let size2 = OVERHEAD.map;
-    for (const [k, v] of obj) {
-      size2 += OVERHEAD.mapEntry;
-      stack.push(k);
-      stack.push(v);
-    }
-    return size2;
-  }
-  if (obj instanceof Set) {
-    let size2 = OVERHEAD.set;
-    for (const v of obj) {
-      size2 += OVERHEAD.setEntry;
-      stack.push(v);
-    }
-    return size2;
-  }
-  if (Array.isArray(obj)) {
-    const size2 = OVERHEAD.array + obj.length * 8;
-    for (const item of obj) stack.push(item);
-    return size2;
-  }
-  if (obj instanceof ArrayBuffer) {
-    if (seenBuffers.has(obj)) return 0;
-    seenBuffers.add(obj);
-    return obj.byteLength;
-  }
-  if (ArrayBuffer.isView(obj)) {
-    const view = obj;
-    if (seenBuffers.has(view.buffer)) return 48;
-    seenBuffers.add(view.buffer);
-    return view.buffer.byteLength + 48;
-  }
-  let size = OVERHEAD.object;
-  const keys = Object.keys(obj);
-  for (const key of keys) {
-    size += OVERHEAD.string + key.length * 2;
-    try {
-      stack.push(obj[key]);
-    } catch {
-    }
-  }
-  return size;
-}
-function _bigintSize(n) {
-  const abs = n < 0n ? -n : n;
-  if (abs === 0n) return 0;
-  const bits = abs.toString(2).length;
-  return Math.ceil(bits / 32) * 8;
-}
-
-// src/graph/profile.ts
-function graphProfile(graph, opts) {
-  const topN = opts?.topN ?? 10;
-  const desc = graph.describe({ detail: "standard" });
-  const targets = [];
-  const collector = graph._collectObserveTargets;
-  if (typeof collector === "function") {
-    collector.call(graph, "", targets);
-  }
-  const pathToNode = /* @__PURE__ */ new Map();
-  for (const [p, n] of targets) pathToNode.set(p, n);
-  const profiles = [];
-  for (const [path, nodeDesc] of Object.entries(desc.nodes)) {
-    const nd = pathToNode.get(path);
-    const impl = nd instanceof NodeImpl ? nd : null;
-    const valueSizeBytes = impl ? sizeof(impl.cache) : 0;
-    const subscriberCount = impl ? impl._sinkCount : 0;
-    const depCount = nodeDesc.deps?.length ?? 0;
-    const isOrphanEffect = nodeDesc.type === "effect" && subscriberCount === 0;
-    const orphanKind = subscriberCount === 0 ? nodeDesc.type === "effect" ? "orphan-effect" : nodeDesc.type === "derived" ? "idle-derived" : nodeDesc.type === "producer" ? "idle-producer" : null : null;
-    profiles.push({
-      path,
-      type: nodeDesc.type,
-      status: nodeDesc.status ?? "unknown",
-      valueSizeBytes,
-      subscriberCount,
-      depCount,
-      isOrphanEffect,
-      orphanKind
-    });
-  }
-  const totalValueSizeBytes = profiles.reduce((sum, p) => sum + p.valueSizeBytes, 0);
-  const topBy = (key, cmp) => [...profiles].sort(cmp ?? ((a, b) => b[key] - a[key])).slice(0, topN);
-  const orphans = profiles.filter((p) => p.orphanKind != null);
-  const orphanEffects = profiles.filter((p) => p.isOrphanEffect);
-  return {
-    nodeCount: profiles.length,
-    edgeCount: desc.edges.length,
-    subgraphCount: desc.subgraphs.length,
-    nodes: profiles,
-    totalValueSizeBytes,
-    hotspots: {
-      byValueSize: topBy("valueSizeBytes"),
-      bySubscriberCount: topBy("subscriberCount"),
-      byDepCount: topBy("depCount")
-    },
-    orphans,
-    orphanEffects
-  };
-}
-
-// src/graph/graph.ts
-var PATH_SEP = "::";
-var GRAPH_META_SEGMENT = "__meta__";
-var SNAPSHOT_VERSION = 1;
-function drainDisposers(set, graphName) {
-  const cap = Math.max(16, set.size * 4);
-  let iterations = 0;
-  while (set.size > 0) {
-    if (iterations++ >= cap) {
-      console.error(
-        `[Graph "${graphName}".destroy] disposer drain exceeded cap (${cap}); ${set.size} disposer(s) discarded`
-      );
-      set.clear();
-      return;
-    }
-    const it = set.values().next();
-    if (it.done) return;
-    const dispose = it.value;
-    set.delete(dispose);
-    try {
-      dispose();
-    } catch (err) {
-      console.error(`[Graph "${graphName}".destroy] disposer threw:`, err);
-    }
-  }
-}
-function computeVersionFingerprint(nodes) {
-  const parts = [];
-  for (const path of Object.keys(nodes).sort()) {
-    const v = nodes[path].v;
-    if (v != null) parts.push(`${path}	${v.id}	${v.version}`);
-  }
-  return parts.join("\n");
-}
-function parseSnapshotEnvelope(data) {
-  if (data.version !== SNAPSHOT_VERSION) {
-    throw new Error(
-      `unsupported snapshot version ${String(data.version)} (expected ${SNAPSHOT_VERSION})`
-    );
-  }
-  for (const key of ["name", "nodes", "edges", "subgraphs"]) {
-    if (!(key in data)) {
-      throw new Error(`snapshot missing required key "${key}"`);
-    }
-  }
-  if (typeof data.name !== "string") {
-    throw new TypeError(`snapshot 'name' must be a string`);
-  }
-  if (typeof data.nodes !== "object" || data.nodes === null || Array.isArray(data.nodes)) {
-    throw new TypeError(`snapshot 'nodes' must be an object`);
-  }
-  if (!Array.isArray(data.edges)) {
-    throw new TypeError(`snapshot 'edges' must be an array`);
-  }
-  if (!Array.isArray(data.subgraphs)) {
-    throw new TypeError(`snapshot 'subgraphs' must be an array`);
-  }
-}
-function deepEqual(a, b) {
-  const seen = /* @__PURE__ */ new WeakMap();
-  const walk = (x, y) => {
-    if (Object.is(x, y)) return true;
-    if (x == null || y == null || typeof x !== "object" || typeof y !== "object") return false;
-    let seenRhs = seen.get(x);
-    if (seenRhs == null) {
-      seenRhs = /* @__PURE__ */ new WeakSet();
-      seen.set(x, seenRhs);
-    }
-    if (seenRhs.has(y)) return true;
-    seenRhs.add(y);
-    const ctorA = x.constructor;
-    const ctorB = y.constructor;
-    if (ctorA !== ctorB) return false;
-    if (x instanceof Date) return x.getTime() === y.getTime();
-    if (x instanceof RegExp)
-      return x.source === y.source && x.flags === y.flags;
-    if (Array.isArray(x)) {
-      const arrB = y;
-      if (x.length !== arrB.length) return false;
-      for (let i = 0; i < x.length; i++) {
-        if (!walk(x[i], arrB[i])) return false;
-      }
-      return true;
-    }
-    if (x instanceof Map) {
-      const mB = y;
-      if (x.size !== mB.size) return false;
-      for (const [k, v] of x) {
-        if (!mB.has(k) || !walk(v, mB.get(k))) return false;
-      }
-      return true;
-    }
-    if (x instanceof Set) {
-      const sB = y;
-      if (x.size !== sB.size) return false;
-      for (const v of x) {
-        let found = false;
-        for (const w of sB) {
-          if (walk(v, w)) {
-            found = true;
-            break;
-          }
-        }
-        if (!found) return false;
-      }
-      return true;
-    }
-    if (ArrayBuffer.isView(x)) {
-      const taA = x;
-      const taB = y;
-      if (taA.length !== taB.length) return false;
-      for (let i = 0; i < taA.length; i++) if (taA[i] !== taB[i]) return false;
-      return true;
-    }
-    const keysA = Object.keys(x);
-    const keysB = Object.keys(y);
-    if (keysA.length !== keysB.length) return false;
-    const setB = new Set(keysB);
-    for (const k of keysA) {
-      if (!setB.has(k)) return false;
-      if (!walk(x[k], y[k])) return false;
-    }
-    return true;
-  };
-  return walk(a, b);
-}
-function sortJsonValue(value) {
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map(sortJsonValue);
-  }
-  const obj = value;
-  const keys = Object.keys(obj).sort();
-  const out = {};
-  for (const k of keys) {
-    out[k] = sortJsonValue(obj[k]);
-  }
-  return out;
-}
-function escapeMermaidLabel(value) {
-  return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
-}
-function escapeD2Label(value) {
-  return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
-}
-function d2DirectionFromGraphDirection(direction) {
-  if (direction === "TD") return "down";
-  if (direction === "BT") return "up";
-  if (direction === "RL") return "left";
-  return "right";
-}
-function collectDiagramArrows(described) {
-  const seen = /* @__PURE__ */ new Set();
-  const arrows = [];
-  function add(from, to) {
-    const key = `${from}\0${to}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    arrows.push([from, to]);
-  }
-  for (const [path, info] of Object.entries(described.nodes)) {
-    const deps = info.deps;
-    if (deps) {
-      for (const dep of deps) add(dep, path);
-    }
-  }
-  for (const edge of described.edges) add(edge.from, edge.to);
-  return arrows;
-}
-function normalizeDiagramDirection(direction) {
-  if (direction === void 0) return "LR";
-  if (direction === "TD" || direction === "LR" || direction === "BT" || direction === "RL") {
-    return direction;
-  }
-  throw new Error(
-    `invalid diagram direction ${String(direction)}; expected one of: TD, LR, BT, RL`
-  );
-}
-function renderDescribeAsJson(d, options) {
-  const includeEdges = options.includeEdges ?? true;
-  const includeSubgraphs = options.includeSubgraphs ?? true;
-  const { expand: _expand, ...rest } = d;
-  const payload = {
-    ...rest,
-    edges: includeEdges ? d.edges : [],
-    subgraphs: includeSubgraphs ? d.subgraphs : []
-  };
-  const text = JSON.stringify(sortJsonValue(payload), null, options.indent ?? 2);
-  options.logger?.(text);
-  return text;
-}
-function renderDescribeAsPretty(d, options) {
-  const includeEdges = options.includeEdges ?? true;
-  const includeSubgraphs = options.includeSubgraphs ?? true;
-  const lines = [];
-  lines.push(`Graph ${d.name}`);
-  lines.push("Nodes:");
-  for (const path of Object.keys(d.nodes).sort()) {
-    const n = d.nodes[path];
-    lines.push(`- ${path} (${n.type}/${n.status}): ${describeData(n.value)}`);
-  }
-  if (includeEdges) {
-    lines.push("Edges:");
-    for (const edge of d.edges) {
-      lines.push(`- ${edge.from} -> ${edge.to}`);
-    }
-  }
-  if (includeSubgraphs) {
-    lines.push("Subgraphs:");
-    for (const sg of d.subgraphs) {
-      lines.push(`- ${sg}`);
-    }
-  }
-  const text = lines.join("\n");
-  options.logger?.(text);
-  return text;
-}
-function renderDescribeAsMermaid(d, options) {
-  const direction = normalizeDiagramDirection(options.direction);
-  const paths = Object.keys(d.nodes).sort();
-  const ids = /* @__PURE__ */ new Map();
-  for (let i = 0; i < paths.length; i += 1) ids.set(paths[i], `n${i}`);
-  const lines = [`flowchart ${direction}`];
-  for (const path of paths) {
-    const id = ids.get(path);
-    lines.push(`  ${id}["${escapeMermaidLabel(path)}"]`);
-  }
-  for (const [from, to] of collectDiagramArrows(d)) {
-    const fromId = ids.get(from);
-    const toId = ids.get(to);
-    if (!fromId || !toId) continue;
-    lines.push(`  ${fromId} --> ${toId}`);
-  }
-  return lines.join("\n");
-}
-function renderDescribeAsD2(d, options) {
-  const direction = normalizeDiagramDirection(options.direction);
-  const paths = Object.keys(d.nodes).sort();
-  const ids = /* @__PURE__ */ new Map();
-  for (let i = 0; i < paths.length; i += 1) ids.set(paths[i], `n${i}`);
-  const lines = [`direction: ${d2DirectionFromGraphDirection(direction)}`];
-  for (const path of paths) {
-    const id = ids.get(path);
-    lines.push(`${id}: "${escapeD2Label(path)}"`);
-  }
-  for (const [from, to] of collectDiagramArrows(d)) {
-    const fromId = ids.get(from);
-    const toId = ids.get(to);
-    if (!fromId || !toId) continue;
-    lines.push(`${fromId} -> ${toId}`);
-  }
-  return lines.join("\n");
-}
-function escapeRegexLiteral(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function globToRegex(pattern) {
-  let re = "^";
-  for (let i = 0; i < pattern.length; i += 1) {
-    const ch = pattern[i];
-    if (ch === "*") {
-      re += ".*";
-      continue;
-    }
-    if (ch === "?") {
-      re += ".";
-      continue;
-    }
-    if (ch === "[") {
-      const end = pattern.indexOf("]", i + 1);
-      if (end <= i + 1) {
-        re += "\\[";
-        continue;
-      }
-      let cls = pattern.slice(i + 1, end);
-      if (cls.startsWith("!")) cls = `^${cls.slice(1)}`;
-      cls = cls.replace(/\\/g, "\\\\");
-      re += `[${cls}]`;
-      i = end;
-      continue;
-    }
-    re += escapeRegexLiteral(ch);
-  }
-  re += "$";
-  return new RegExp(re);
-}
-var OBSERVE_ANSI_THEME = {
-  data: "\x1B[32m",
-  dirty: "\x1B[33m",
-  resolved: "\x1B[36m",
-  invalidate: "\x1B[93m",
-  pause: "\x1B[90m",
-  resume: "\x1B[96m",
-  complete: "\x1B[34m",
-  error: "\x1B[31m",
-  teardown: "\x1B[91m",
-  derived: "\x1B[35m",
-  path: "\x1B[90m",
-  reset: "\x1B[0m"
-};
-var OBSERVE_NO_COLOR_THEME = {
-  data: "",
-  dirty: "",
-  resolved: "",
-  invalidate: "",
-  pause: "",
-  resume: "",
-  complete: "",
-  error: "",
-  teardown: "",
-  derived: "",
-  path: "",
-  reset: ""
-};
-function describeData(value) {
-  if (typeof value === "string") return JSON.stringify(value);
-  if (typeof value === "number" || typeof value === "boolean" || value == null)
-    return String(value);
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "[unserializable]";
-  }
-}
-function resolveObserveTheme(theme) {
-  if (theme === "none") return OBSERVE_NO_COLOR_THEME;
-  if (theme === "ansi" || theme == null) return OBSERVE_ANSI_THEME;
-  return {
-    data: theme.data ?? "",
-    dirty: theme.dirty ?? "",
-    resolved: theme.resolved ?? "",
-    invalidate: theme.invalidate ?? "",
-    pause: theme.pause ?? "",
-    resume: theme.resume ?? "",
-    complete: theme.complete ?? "",
-    error: theme.error ?? "",
-    teardown: theme.teardown ?? "",
-    derived: theme.derived ?? "",
-    path: theme.path ?? "",
-    reset: theme.reset ?? ""
-  };
-}
-function resolveObserveDetail(opts) {
-  if (opts == null) return {};
-  const detail = opts.detail;
-  if (detail === "full") {
-    return {
-      ...opts,
-      structured: opts.structured ?? true,
-      timeline: opts.timeline ?? true,
-      causal: opts.causal ?? true,
-      derived: opts.derived ?? true
-    };
-  }
-  if (detail === "minimal") {
-    return { ...opts, structured: opts.structured ?? true };
-  }
-  return opts;
-}
-function assertNoControlChars(name, graphName, label) {
-  for (let i = 0; i < name.length; i++) {
-    const c = name.charCodeAt(i);
-    if (c < 32 || c === 127) {
-      throw new Error(
-        `Graph "${graphName}": ${label} "${name}" must not contain control character (U+${c.toString(16).padStart(4, "0").toUpperCase()} at index ${i})`
-      );
-    }
-  }
-}
-function assertRegisterableName(name, graphName, label) {
-  if (name === "") {
-    throw new Error(`Graph "${graphName}": ${label} name must be non-empty`);
-  }
-  if (name.includes(PATH_SEP)) {
-    throw new Error(
-      `Graph "${graphName}": ${label} "${name}" must not contain '${PATH_SEP}' (path separator)`
-    );
-  }
-  if (name === GRAPH_META_SEGMENT) {
-    throw new Error(
-      `Graph "${graphName}": ${label} name "${GRAPH_META_SEGMENT}" is reserved for meta companion paths`
-    );
-  }
-  assertNoControlChars(name, graphName, label);
-}
-function splitPath(path, graphName) {
-  if (path === "") {
-    throw new Error(`Graph "${graphName}": resolve path must be non-empty`);
-  }
-  const segments = path.split(PATH_SEP);
-  for (const s of segments) {
-    if (s === "") {
-      throw new Error(`Graph "${graphName}": resolve path has empty segment`);
-    }
-  }
-  return segments;
-}
-function filterMetaMessages(messages, config) {
-  let anyFiltered = false;
-  for (const m of messages) {
-    if (!config.isMetaPassthrough(m[0])) {
-      anyFiltered = true;
-      break;
-    }
-  }
-  if (!anyFiltered) return messages;
-  const kept = messages.filter((m) => config.isMetaPassthrough(m[0]));
-  return kept;
-}
-function teardownMountedGraph(root) {
-  for (const child of root._mounts.values()) {
-    teardownMountedGraph(child);
-  }
-  for (const n of root._nodes.values()) {
-    try {
-      n.down([[TEARDOWN]], { internal: true });
-    } catch {
-    }
-  }
-}
-var Graph = class _Graph {
-  name;
-  opts;
-  /** Protocol config bound to this graph (defaults to `defaultConfig`). */
-  config;
-  /** @internal — exposed for {@link teardownMountedGraph} and cross-graph helpers. */
-  _nodes = /* @__PURE__ */ new Map();
-  /**
-   * @internal Reverse lookup for duplicate-instance detection in
-   * {@link Graph.add} — O(1) replacement for an O(n) scan of `_nodes`.
-   * Weak so nodes can be GC'd after `remove()` even if a caller keeps the
-   * map alive via some unusual pattern.
-   */
-  _nodeToName = /* @__PURE__ */ new WeakMap();
-  /** @internal — exposed for {@link teardownMountedGraph}. */
-  _mounts = /* @__PURE__ */ new Map();
-  /**
-   * @internal Parent graph if this instance is mounted. `undefined` when
-   * this is the root or when the graph has been unmounted. Used for
-   * reparenting rejection + O(depth) ancestor walks.
-   */
-  _parent = void 0;
-  _storageDisposers = /* @__PURE__ */ new Set();
-  _disposers = /* @__PURE__ */ new Set();
-  /**
-   * @internal Lazy `TopologyEvent` producer. Created on first `.topology`
-   * access. Zero cost until something subscribes — producer fn only runs when
-   * the first sink attaches, registering one handler into
-   * {@link Graph._topologyEmitters}.
-   */
-  _topology;
-  /**
-   * @internal Active emit handlers for the topology producer. Each entry is
-   * the closure registered by the producer fn on activation; cleared on
-   * deactivation. `_emitTopology` broadcasts through every entry (there is at
-   * most one per activation cycle of the producer).
-   */
-  _topologyEmitters = /* @__PURE__ */ new Set();
-  /**
-   * @param name - Non-empty graph id (must not contain `::` and must not
-   *   equal the reserved meta segment `__meta__`).
-   * @param opts - See {@link GraphOptions}. Stored frozen on the instance.
-   */
-  constructor(name, opts) {
-    if (name === "") {
-      throw new Error("Graph name must be non-empty");
-    }
-    if (name.includes(PATH_SEP)) {
-      throw new Error(`Graph name must not contain '${PATH_SEP}' (got "${name}")`);
-    }
-    if (name === GRAPH_META_SEGMENT) {
-      throw new Error(`Graph name "${GRAPH_META_SEGMENT}" is reserved for meta companion paths`);
-    }
-    this.name = name;
-    this.opts = Object.freeze({ ...opts ?? {} });
-    this.config = opts?.config ?? defaultConfig;
-    this._traceRing = new RingBuffer(opts?.traceCapacity ?? 1e3);
-    if (opts?.versioning != null) {
-      this.setVersioning(opts.versioning);
-    }
-  }
-  /**
-   * Walk ancestors up through `_parent`. Returns the chain starting at this
-   * instance, ending at the root (a graph with no parent). O(depth).
-   *
-   * @param includeSelf - Include `this` in the chain (default `true`).
-   */
-  ancestors(includeSelf = true) {
-    const out = [];
-    let p = includeSelf ? this : this._parent;
-    while (p != null) {
-      out.push(p);
-      p = p._parent;
-    }
-    return out;
-  }
-  // ——————————————————————————————————————————————————————————————
-  //  Topology companion (structural-change event stream)
-  // ——————————————————————————————————————————————————————————————
-  /**
-   * Reactive stream of structural changes to this graph's own registry
-   * (add / mount / remove). Value mutations live on `observe()`; this
-   * companion only fires when the topology shape changes.
-   *
-   * Lazy: the underlying node is created on first access and activates when
-   * something subscribes. No emission replay — late subscribers do not
-   * receive historical events and should snapshot via {@link Graph.describe}
-   * before listening for incremental changes. Events that fire while the
-   * producer has zero subscribers are dropped (no retention).
-   *
-   * Own-graph only: a parent's `topology` does NOT emit for structural
-   * changes inside a mounted child. Transitive consumers subscribe to each
-   * child's topology separately (recurse through `topology`'s own "added"
-   * events with `nodeKind: "mount"` to discover new children).
-   *
-   * See {@link TopologyEvent} for payload shape.
-   *
-   * @category observability
-   */
-  get topology() {
-    if (this._topology == null) {
-      this._topology = producer(
-        (actions) => {
-          const handler = (event) => {
-            actions.emit(event);
-          };
-          this._topologyEmitters.add(handler);
-          return () => {
-            this._topologyEmitters.delete(handler);
-          };
-        },
-        { name: `${this.name}_topology` }
-      );
-    }
-    return this._topology;
-  }
-  /**
-   * @internal Fire a {@link TopologyEvent} to every active subscriber of
-   * `this.topology`. No-op when the topology node has never been accessed or
-   * currently has no sinks — zero cost for graphs nobody observes.
-   */
-  _emitTopology(event) {
-    if (this._topology == null || this._topologyEmitters.size === 0) return;
-    for (const h of this._topologyEmitters) h(event);
-  }
-  // ——————————————————————————————————————————————————————————————
-  //  Node registry
-  // ——————————————————————————————————————————————————————————————
-  /**
-   * Registers a node under a local name. Fails if the name is already used,
-   * reserved by a mount, the same node instance is already registered, or
-   * the node is torn down.
-   *
-   * Returns the registered node so callers can chain:
-   * `const counter = g.add("counter", state(0))`.
-   *
-   * @param name - Local key (no `::`).
-   * @param node - Node instance to own.
-   */
-  add(name, node) {
-    assertRegisterableName(name, this.name, "add");
-    if (this._mounts.has(name)) {
-      throw new Error(`Graph "${this.name}": name "${name}" is already a mount point`);
-    }
-    if (this._nodes.has(name)) {
-      throw new Error(`Graph "${this.name}": node "${name}" already exists`);
-    }
-    const existingName = this._nodeToName.get(node);
-    if (existingName !== void 0) {
-      throw new Error(
-        `Graph "${this.name}": node instance already registered as "${existingName}"`
-      );
-    }
-    this._nodes.set(name, node);
-    this._nodeToName.set(node, name);
-    this._emitTopology({ kind: "added", name, nodeKind: "node" });
-    return node;
-  }
-  /**
-   * Bulk-apply a minimum versioning level to every currently-registered node
-   * in this graph (roadmap §6.0). `_applyVersioning` is monotonic — nodes
-   * already at a higher level are untouched. The method refuses to run
-   * mid-wave; invoke at setup time before any external subscribers attach.
-   *
-   * **Not** a default-for-future-adds mechanism — that's what
-   * `config.defaultVersioning` is for. Nodes added after this call do NOT
-   * automatically inherit `level`; register new nodes with their own
-   * `opts.versioning` or set `config.defaultVersioning` before construction.
-   *
-   * **Scope:** local only. Does not propagate to mounted subgraphs.
-   *
-   * @param level - `0` for V0, `1` for V1, or `undefined` to no-op.
-   */
-  setVersioning(level) {
-    if (level == null) return;
-    for (const node of this._nodes.values()) {
-      if (node instanceof NodeImpl) {
-        node._applyVersioning(level);
-      }
-    }
-  }
-  /**
-   * Unregisters a node or unmounts a subgraph and sends `[[TEARDOWN]]` to the
-   * removed node or recursively through the mounted subtree (§3.2).
-   *
-   * @param name - Local mount or node name.
-   * @returns Audit record of what was removed: `{kind, nodes, mounts}`.
-   *   `kind: "node"` → `nodes: [name]`, `mounts: []`. `kind: "mount"` →
-   *   `nodes` lists every primary node torn down across the subtree (sorted
-   *   qualified paths relative to the unmounted subgraph) and `mounts` lists
-   *   the mounted subgraphs in depth-first order including `name` itself.
-   */
-  remove(name) {
-    assertRegisterableName(name, this.name, "remove");
-    const child = this._mounts.get(name);
-    if (child) {
-      const audit2 = { kind: "mount", nodes: [], mounts: [] };
-      const targets = [];
-      child._collectObserveTargets("", targets);
-      for (const [p, n] of targets) {
-        if (!p.includes(`${PATH_SEP}${GRAPH_META_SEGMENT}${PATH_SEP}`)) {
-          audit2.nodes.push(p);
-        }
-        void n;
-      }
-      audit2.nodes.sort();
-      audit2.mounts.push(name);
-      audit2.mounts.push(...child._collectSubgraphs(`${name}${PATH_SEP}`));
-      this._mounts.delete(name);
-      child._parent = void 0;
-      teardownMountedGraph(child);
-      this._emitTopology({ kind: "removed", name, nodeKind: "mount", audit: audit2 });
-      return audit2;
-    }
-    const node = this._nodes.get(name);
-    if (!node) {
-      throw new Error(`Graph "${this.name}": unknown node or mount "${name}"`);
-    }
-    this._nodes.delete(name);
-    this._nodeToName.delete(node);
-    node.down([[TEARDOWN]], { internal: true });
-    const audit = { kind: "node", nodes: [name], mounts: [] };
-    this._emitTopology({ kind: "removed", name, nodeKind: "node", audit });
-    return audit;
-  }
-  /**
-   * Bulk remove — invokes {@link Graph.remove} for every local name matching
-   * `filter`. Audit records merge into a single result. Mounted subgraphs
-   * are included via `filter` receiving the mount name; internal subtree
-   * entries are not walked directly (use describe + scan for tree-level
-   * queries).
-   *
-   * @param filter - Predicate or glob. Glob strings support `*` within a
-   *   segment and `**` across segments (same grammar as `restore({only})`).
-   * @returns Combined audit of all nodes + mounts removed.
-   */
-  removeAll(filter) {
-    const match = typeof filter === "function" ? filter : (() => {
-      const re = globToRegex(filter);
-      return (n) => re.test(n);
-    })();
-    const audit = { kind: "mount", nodes: [], mounts: [] };
-    const localNames = [...this._nodes.keys(), ...this._mounts.keys()].filter((n) => match(n));
-    for (const name of localNames) {
-      const sub = this.remove(name);
-      audit.nodes.push(...sub.nodes);
-      audit.mounts.push(...sub.mounts);
-    }
-    audit.nodes.sort();
-    audit.mounts.sort();
-    return audit;
-  }
-  /**
-   * Iterable over locally-registered `[localName, Node]` pairs (sorted).
-   * Does not recurse into mounts.
-   */
-  [Symbol.iterator]() {
-    const sorted = [...this._nodes.keys()].sort();
-    const nodes = this._nodes;
-    let i = 0;
-    return {
-      [Symbol.iterator]() {
-        return this;
-      },
-      next() {
-        if (i >= sorted.length) return { value: void 0, done: true };
-        const name = sorted[i++];
-        return { value: [name, nodes.get(name)], done: false };
-      }
-    };
-  }
-  /**
-   * Returns a node by local name or `::` qualified path.
-   * Local names are looked up directly; paths with `::` delegate to {@link resolve}.
-   *
-   * @param name - Local name or qualified path.
-   */
-  node(name) {
-    if (name === "") {
-      throw new Error(`Graph "${this.name}": node name must be non-empty`);
-    }
-    if (name.includes(PATH_SEP)) {
-      return this.resolve(name);
-    }
-    const n = this._nodes.get(name);
-    if (!n) {
-      throw new Error(`Graph "${this.name}": unknown node "${name}"`);
-    }
-    return n;
-  }
-  /**
-   * Reads `graph.node(name).get()` — accepts `::` qualified paths (§3.2).
-   *
-   * @param name - Local name or qualified path.
-   * @returns Cached value or `undefined`.
-   */
-  get(name) {
-    return this.node(name).cache;
-  }
-  /**
-   * Shorthand for `graph.node(name).down([[DATA, value]], { actor })` — accepts `::` qualified paths (§3.2).
-   *
-   * @param name - Local name or qualified path.
-   * @param value - Next `DATA` payload.
-   * @param options - Optional `actor` and `internal` guard bypass.
-   */
-  set(name, value, options) {
-    const internal = options?.internal === true;
-    this.node(name).down([[DATA, value]], {
-      actor: options?.actor,
-      internal,
-      delivery: "write"
-    });
-  }
-  /**
-   * Atomic multi-node DATA write. Wraps every {@link Graph.set} call in a
-   * single `batch(...)` so downstream dependents see one coalesced wave
-   * instead of N cascading ones.
-   *
-   * @param entries - `{name → value}` map or `[name, value]` pairs.
-   * @param options - Passed to each underlying `set` call (same `actor` + `internal` semantics).
-   */
-  setAll(entries, options) {
-    const iter = Symbol.iterator in entries ? entries : Object.entries(entries);
-    batch(() => {
-      for (const [name, value] of iter) this.set(name, value, options);
-    });
-  }
-  /**
-   * Emit a single `[[INVALIDATE]]` (tier 1) on a node. Thin wrapper over
-   * `node.down([[INVALIDATE]], …)` matching the {@link Graph.set} ergonomics.
-   */
-  invalidate(name, options) {
-    const internal = options?.internal === true;
-    this.node(name).down([[INVALIDATE]], {
-      actor: options?.actor,
-      internal,
-      delivery: "write"
-    });
-  }
-  /**
-   * Emit a single `[[ERROR, err]]` (tier 4) on a node.
-   */
-  error(name, err, options) {
-    const internal = options?.internal === true;
-    this.node(name).down([[ERROR, err]], {
-      actor: options?.actor,
-      internal,
-      delivery: "write"
-    });
-  }
-  /**
-   * Emit a single `[[COMPLETE]]` (tier 4) on a node, declaring the stream
-   * cleanly finished. Distinct from {@link Graph.remove} (which emits
-   * TEARDOWN and unregisters the node).
-   */
-  complete(name, options) {
-    const internal = options?.internal === true;
-    this.node(name).down([[COMPLETE]], {
-      actor: options?.actor,
-      internal,
-      delivery: "write"
-    });
-  }
-  // ——————————————————————————————————————————————————————————————
-  //  Edges (derived on-demand from node `_deps`)
-  // ——————————————————————————————————————————————————————————————
-  /**
-   * Returns the full edge list for this graph tree, derived on demand from
-   * each registered node's `_deps` (no stored registry). Local-only
-   * (non-recursive) by default to match the historical `edges()` surface;
-   * pass `{recursive: true}` to include mounted subgraphs with qualified
-   * paths relative to this graph.
-   *
-   * Use {@link Graph.describe} for full-tree snapshots with edges already
-   * qualified and paired with node metadata.
-   */
-  edges(opts) {
-    const recursive = opts?.recursive === true;
-    const nodeToLocal = /* @__PURE__ */ new Map();
-    if (!recursive) {
-      for (const [localName, n] of this._nodes) nodeToLocal.set(n, localName);
-      const result2 = [];
-      for (const [localName, n] of this._nodes) {
-        if (!(n instanceof NodeImpl)) continue;
-        for (const dep of n._deps) {
-          const from = nodeToLocal.get(dep.node);
-          if (from != null) result2.push([from, localName]);
-        }
-      }
-      result2.sort(
-        (a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0
-      );
-      return result2;
-    }
-    const targets = [];
-    this._collectObserveTargets("", targets);
-    const nodeToPath = /* @__PURE__ */ new Map();
-    for (const [p, n] of targets) nodeToPath.set(n, p);
-    const result = [];
-    for (const [path, n] of targets) {
-      if (!(n instanceof NodeImpl)) continue;
-      for (const dep of n._deps) {
-        const from = nodeToPath.get(dep.node);
-        if (from != null) result.push([from, path]);
-      }
-    }
-    result.sort(
-      (a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0
-    );
-    return result;
-  }
-  // ——————————————————————————————————————————————————————————————
-  //  Composition
-  // ——————————————————————————————————————————————————————————————
-  /**
-   * Embed a child graph at a local mount name (§3.4). Child nodes are reachable via
-   * {@link Graph.resolve} using `::` delimited paths (§3.5). Lifecycle
-   * {@link Graph.signal} visits mounted subgraphs recursively.
-   *
-   * Rejects: same name as existing node or mount, self-mount, mount cycles,
-   * and the same child graph instance mounted twice on one parent.
-   *
-   * @param name - Local mount point.
-   * @param child - Nested `Graph` instance.
-   * @returns The mounted `child`, for chaining.
-   */
-  mount(name, child) {
-    assertRegisterableName(name, this.name, "mount");
-    if (this._nodes.has(name)) {
-      throw new Error(
-        `Graph "${this.name}": cannot mount at "${name}" \u2014 node with that name exists`
-      );
-    }
-    if (this._mounts.has(name)) {
-      throw new Error(`Graph "${this.name}": mount "${name}" already exists`);
-    }
-    if (child === this) {
-      throw new Error(`Graph "${this.name}": cannot mount a graph into itself`);
-    }
-    if (child._parent != null) {
-      throw new Error(
-        `Graph "${this.name}": this child graph is already mounted on "${child._parent.name}"`
-      );
-    }
-    for (let p = this; p != null; p = p._parent) {
-      if (p === child) {
-        throw new Error(`Graph "${this.name}": mount("${name}", \u2026) would create a mount cycle`);
-      }
-    }
-    this._mounts.set(name, child);
-    child._parent = this;
-    this._emitTopology({ kind: "added", name, nodeKind: "mount" });
-    return child;
-  }
-  /**
-   * Look up a node by qualified path (§3.5). Segments are separated by `::`.
-   *
-   * If the first segment equals this graph's {@link Graph.name}, it is stripped
-   * (so `root.resolve("app::a")` works when `root.name === "app"`). The strip
-   * is applied **recursively** when descending into mounted children, so
-   * `child.resolve("child::x")` also works when `child.name === "child"`.
-   *
-   * @param path - Qualified `::` path or local name.
-   * @returns The resolved `Node`.
-   */
-  resolve(path) {
-    const segments = splitPath(path, this.name);
-    return this._resolveFromSegments(segments);
-  }
-  /**
-   * Non-throwing {@link Graph.resolve}. Returns `undefined` instead of
-   * throwing when the path does not resolve to a node.
-   */
-  tryResolve(path) {
-    try {
-      return this.resolve(path);
-    } catch {
-      return void 0;
-    }
-  }
-  _resolveFromSegments(segments) {
-    let seg = segments;
-    if (seg[0] === this.name) {
-      seg = seg.slice(1);
-      if (seg.length === 0) {
-        throw new Error(`Graph "${this.name}": resolve path ends at graph name only`);
-      }
-    }
-    const head = seg[0];
-    const rest = seg.slice(1);
-    if (rest.length === 0) {
-      const n = this._nodes.get(head);
-      if (n) return n;
-      if (this._mounts.has(head)) {
-        throw new Error(
-          `Graph "${this.name}": path ends at subgraph "${head}" \u2014 not a node (GRAPHREFLY-SPEC \xA73.5)`
-        );
-      }
-      throw new Error(`Graph "${this.name}": unknown name "${head}"`);
-    }
-    const localN = this._nodes.get(head);
-    if (localN && rest.length > 0 && rest[0] === GRAPH_META_SEGMENT) {
-      return this._resolveMetaChainFromNode(localN, rest, seg.join(PATH_SEP));
-    }
-    const child = this._mounts.get(head);
-    if (!child) {
-      if (this._nodes.has(head)) {
-        throw new Error(
-          `Graph "${this.name}": "${head}" is a node; trailing path "${rest.join(PATH_SEP)}" is invalid`
-        );
-      }
-      throw new Error(`Graph "${this.name}": unknown mount or node "${head}"`);
-    }
-    return child.resolve(rest.join(PATH_SEP));
-  }
-  /**
-   * Resolve `::__meta__::key` segments from a registered primary node (possibly chained).
-   */
-  _resolveMetaChainFromNode(n, parts, fullPath) {
-    let current = n;
-    let i = 0;
-    const p = [...parts];
-    while (i < p.length) {
-      if (p[i] !== GRAPH_META_SEGMENT) {
-        throw new Error(
-          `Graph "${this.name}": expected ${GRAPH_META_SEGMENT} segment in meta path "${fullPath}"`
-        );
-      }
-      if (i + 1 >= p.length) {
-        throw new Error(
-          `Graph "${this.name}": meta path requires a key after ${GRAPH_META_SEGMENT} in "${fullPath}"`
-        );
-      }
-      const key = p[i + 1];
-      const next = current.meta[key];
-      if (!next) {
-        throw new Error(`Graph "${this.name}": unknown meta "${key}" in path "${fullPath}"`);
-      }
-      current = next;
-      i += 2;
-    }
-    return current;
-  }
-  /**
-   * Deliver a message batch to every registered node in this graph and, recursively,
-   * in mounted child graphs (§3.7). Recurses into mounts first, then delivers to
-   * local nodes (sorted by name). Each {@link Node} receives at most one delivery
-   * per call (deduped by reference).
-   *
-   * **Primary-vs-meta filter asymmetry (intentional):** primary nodes receive the
-   * unfiltered `messages` batch — that's the canonical data-plane flow. Companion
-   * `meta` nodes receive a filtered subset keyed by the per-type `metaPassthrough`
-   * flag on {@link GraphReFlyConfig}. Built-in defaults: PAUSE / RESUME / DATA /
-   * RESOLVED pass through to meta; INVALIDATE / COMPLETE / ERROR / TEARDOWN do
-   * not.
-   *
-   * **Where lifecycle terminals reach meta:**
-   * - **TEARDOWN** — primary's `_emit` cascades to meta children directly (see
-   *   `core/node.ts` "Meta TEARDOWN fan-out" block) so meta is torn down with
-   *   its primary regardless of the signal-level filter.
-   * - **COMPLETE / ERROR / INVALIDATE** — scoped to primaries on the broadcast
-   *   path. Meta companions are an attribution side-channel, not a lifecycle
-   *   participant; address meta directly via `meta.down(...)` if you need to
-   *   forward these. Audit confirmed 2026-04-17: no current meta consumer
-   *   relies on broadcast COMPLETE/ERROR/INVALIDATE delivery.
-   *
-   * @param messages - Batch to deliver to every registered node (and mounts, recursively).
-   * @param options - Optional `actor` / `internal` for transport.
-   */
-  signal(messages, options) {
-    if (options?.internal !== true) {
-      for (const m of messages) {
-        const tier = this.config.messageTier(m[0]);
-        if (tier === 3) {
-          throw new Error(
-            `Graph "${this.name}": Graph.signal() rejects tier-3 messages (DATA / RESOLVED). Broadcast is for control-plane tiers (START / DIRTY / INVALIDATE / PAUSE / RESUME / COMPLETE / ERROR / TEARDOWN). For per-node value writes, use Graph.set or graph.node(name).down(...).`
-          );
-        }
-      }
-    }
-    const errors = [];
-    this._signalDeliver(messages, options ?? {}, /* @__PURE__ */ new Set(), errors);
-    if (errors.length > 0) throw errors[0];
-  }
-  _signalDeliver(messages, opts, vis, errors) {
-    for (const sub of this._mounts.values()) {
-      sub._signalDeliver(messages, opts, vis, errors);
-    }
-    const internal = opts.internal === true;
-    const downOpts = internal ? { internal: true } : { actor: opts.actor, delivery: "signal" };
-    const metaMessages = filterMetaMessages(messages, this.config);
-    for (const localName of [...this._nodes.keys()].sort()) {
-      const n = this._nodes.get(localName);
-      if (vis.has(n)) continue;
-      vis.add(n);
-      try {
-        n.down(messages, downOpts);
-      } catch (err) {
-        if (err instanceof GuardDenied) throw err;
-        errors.push(err);
-      }
-      if (metaMessages.length === 0) continue;
-      this._signalMetaSubtree(n, metaMessages, vis, downOpts, errors);
-    }
-  }
-  _signalMetaSubtree(root, messages, vis, downOpts, errors) {
-    for (const mk of Object.keys(root.meta).sort()) {
-      const mnode = root.meta[mk];
-      if (vis.has(mnode)) continue;
-      vis.add(mnode);
-      try {
-        mnode.down(messages, downOpts);
-      } catch (err) {
-        if (err instanceof GuardDenied) throw err;
-        errors.push(err);
-      }
-      this._signalMetaSubtree(mnode, messages, vis, downOpts, errors);
-    }
-  }
-  describe(options) {
-    const actor = options?.actor;
-    const filter = options?.filter;
-    const includeFields = resolveDescribeFields(options?.detail, options?.fields);
-    const isSpec = options?.format === "spec";
-    const effectiveFields = isSpec ? resolveDescribeFields("minimal") : includeFields;
-    const targets = [];
-    this._collectObserveTargets("", targets);
-    const nodeToPath = /* @__PURE__ */ new Map();
-    for (const [p, n] of targets) {
-      nodeToPath.set(n, p);
-    }
-    const nodes = {};
-    for (const [p, n] of targets) {
-      if (actor != null && !n.allowsObserve(actor)) continue;
-      const raw = describeNode(n, effectiveFields);
-      const deps = n instanceof NodeImpl ? n._deps.map((d) => nodeToPath.get(d.node) ?? d.node.name ?? "") : [];
-      const { name: _name, ...rest } = raw;
-      const entry = { ...rest, deps };
-      if (!isSpec) {
-        const reason = this._annotations.get(p);
-        if (reason != null) entry.reason = reason;
-      }
-      if (filter != null) {
-        if (typeof filter === "function") {
-          const fn = filter;
-          const pass = fn.length >= 2 ? fn(p, entry) : fn(entry);
-          if (!pass) continue;
-        } else {
-          let match = true;
-          for (const [fk, fv] of Object.entries(filter)) {
-            const normalizedKey = fk === "deps_includes" ? "depsIncludes" : fk === "meta_has" ? "metaHas" : fk;
-            if (normalizedKey === "depsIncludes") {
-              if (!entry.deps.includes(String(fv))) {
-                match = false;
-                break;
-              }
-              continue;
-            }
-            if (normalizedKey === "metaHas") {
-              if (!Object.hasOwn(entry.meta ?? {}, String(fv))) {
-                match = false;
-                break;
-              }
-              continue;
-            }
-            if (entry[normalizedKey] !== fv) {
-              match = false;
-              break;
-            }
-          }
-          if (!match) continue;
-        }
-      }
-      nodes[p] = entry;
-    }
-    const nodeKeys = new Set(Object.keys(nodes));
-    let edges = this.edges({ recursive: true }).map(
-      ([from, to]) => ({ from, to })
-    );
-    if (actor != null || filter != null) {
-      edges = edges.filter((e) => nodeKeys.has(e.from) && nodeKeys.has(e.to));
-    }
-    const allSubgraphs = this._collectSubgraphs("");
-    const subgraphs = actor != null || filter != null ? allSubgraphs.filter((sg) => {
-      const prefix = `${sg}${PATH_SEP}`;
-      return [...nodeKeys].some((k) => k === sg || k.startsWith(prefix));
-    }) : allSubgraphs;
-    const graph = this;
-    const baseOpts = options;
-    const struct = {
-      name: this.name,
-      nodes,
-      edges,
-      subgraphs,
-      expand(detailOrFields) {
-        const merged = { ...baseOpts, format: void 0 };
-        if (Array.isArray(detailOrFields)) {
-          merged.fields = detailOrFields;
-          merged.detail = void 0;
-        } else {
-          merged.detail = detailOrFields;
-          merged.fields = void 0;
-        }
-        return graph.describe(merged);
-      }
-    };
-    const opts = options ?? {};
-    const fmt = opts.format;
-    if (fmt === "json") return renderDescribeAsJson(struct, opts);
-    if (fmt === "pretty") return renderDescribeAsPretty(struct, opts);
-    if (fmt === "mermaid") return renderDescribeAsMermaid(struct, opts);
-    if (fmt === "d2") return renderDescribeAsD2(struct, opts);
-    return struct;
-  }
-  _collectSubgraphs(prefix) {
-    const out = [];
-    for (const m of [...this._mounts.keys()].sort()) {
-      const q = prefix === "" ? m : `${prefix}${m}`;
-      out.push(q);
-      out.push(...this._mounts.get(m)._collectSubgraphs(`${q}${PATH_SEP}`));
-    }
-    return out;
-  }
-  /**
-   * Snapshot-based resource profile: per-node stats, orphan effect detection,
-   * memory hotspots. Zero runtime overhead — walks nodes on demand.
-   *
-   * @param opts - Optional `topN` for hotspot limit (default 10).
-   * @returns Aggregate profile with per-node details, hotspots, and orphan effects.
-   */
-  resourceProfile(opts) {
-    return graphProfile(this, opts);
-  }
-  reachable(from, direction, opts = {}) {
-    if (opts.withDetail === true) {
-      return reachable(this.describe(), from, direction, {
-        ...opts,
-        withDetail: true
-      });
-    }
-    return reachable(this.describe(), from, direction, opts);
-  }
-  /**
-   * Causal walkback: shortest dep-chain from `from` to `to`, enriched with
-   * each node's value, status, last-mutation actor, and reasoning annotation
-   * from {@link Graph.trace}. Wraps {@link explainPath} (roadmap §9.2).
-   *
-   * @param from - Upstream node (the cause).
-   * @param to - Downstream node (the effect).
-   * @param opts - Optional `maxDepth` and `findCycle`. When `findCycle:true`
-   *   and `from === to`, returns the shortest cycle through other nodes
-   *   (useful for diagnosing feedback loops, COMPOSITION-GUIDE §7).
-   *   Annotations and lastMutations are collected automatically from the
-   *   live graph.
-   */
-  explain(from, to, opts) {
-    const described = this.describe({ detail: "full" });
-    const annotations = new Map(this._annotations);
-    const lastMutations = /* @__PURE__ */ new Map();
-    for (const [path, n] of Object.entries(described.nodes)) {
-      if (n.lastMutation != null) lastMutations.set(path, n.lastMutation);
-    }
-    return explainPath(described, from, to, {
-      ...opts?.maxDepth != null ? { maxDepth: opts.maxDepth } : {},
-      ...opts?.findCycle === true ? { findCycle: true } : {},
-      annotations,
-      lastMutations
-    });
-  }
-  /**
-   * @internal Collect all qualified paths in this graph tree matching a
-   * glob pattern. Used by scoped autoCheckpoint subscription.
-   */
-  _pathsMatching(glob) {
-    const re = globToRegex(glob);
-    const targets = [];
-    this._collectObserveTargets("", targets);
-    return targets.map(([p]) => p).filter((p) => re.test(p));
-  }
-  _collectObserveTargets(prefix, out) {
-    for (const m of [...this._mounts.keys()].sort()) {
-      const p2 = prefix === "" ? m : `${prefix}${PATH_SEP}${m}`;
-      this._mounts.get(m)._collectObserveTargets(p2, out);
-    }
-    for (const loc of [...this._nodes.keys()].sort()) {
-      const n = this._nodes.get(loc);
-      const p = prefix === "" ? loc : `${prefix}${PATH_SEP}${loc}`;
-      out.push([p, n]);
-      this._appendMetaObserveTargets(p, n, out);
-    }
-  }
-  _appendMetaObserveTargets(basePath, n, out) {
-    for (const mk of Object.keys(n.meta).sort()) {
-      const m = n.meta[mk];
-      const mp = `${basePath}${PATH_SEP}${GRAPH_META_SEGMENT}${PATH_SEP}${mk}`;
-      out.push([mp, m]);
-      this._appendMetaObserveTargets(mp, m, out);
-    }
-  }
-  observe(pathOrOpts, options) {
-    const isPath = typeof pathOrOpts === "string";
-    const rawOpts = isPath ? options : pathOrOpts;
-    const resolved = resolveObserveDetail(rawOpts);
-    const wantsStructured = resolved.structured === true || resolved.timeline === true || resolved.causal === true || resolved.derived === true || resolved.detail === "minimal" || resolved.detail === "full" || resolved.format != null;
-    const actor = resolved.actor;
-    if (isPath) {
-      const path = pathOrOpts;
-      const target = this.resolve(path);
-      if (actor != null && !target.allowsObserve(actor)) {
-        throw new GuardDenied({ actor, action: "observe", nodeName: path });
-      }
-      if (wantsStructured) return this._buildStructuredObserver([[path, target]], resolved, "one");
-      return {
-        subscribe(sink) {
-          return target.subscribe(sink);
-        },
-        up(messages) {
-          try {
-            target.up?.(messages);
-          } catch (err) {
-            if (err instanceof GuardDenied) return;
-            throw err;
-          }
-        }
-      };
-    }
-    const collected = [];
-    this._collectObserveTargets("", collected);
-    collected.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
-    const picked = actor == null ? collected : collected.filter(([, nd]) => nd.allowsObserve(actor));
-    if (wantsStructured) return this._buildStructuredObserver(picked, resolved, "all");
-    return {
-      subscribe: (sink) => {
-        const unsubs = picked.map(
-          ([p, nd]) => nd.subscribe((msgs) => {
-            sink(p, msgs);
-          })
-        );
-        return () => {
-          for (const u of unsubs) u();
-        };
-      },
-      up: (upPath, messages) => {
-        try {
-          const nd = this.resolve(upPath);
-          nd.up?.(messages);
-        } catch (err) {
-          if (err instanceof GuardDenied) return;
-          throw err;
-        }
-      }
-    };
-  }
-  /** Dispatch helper — builds a unified observer + its expand closure. */
-  _buildStructuredObserver(targets, options, mode) {
-    const firstPath = mode === "one" ? targets[0]?.[0] : void 0;
-    const expand = (merged) => {
-      if (mode === "one" && firstPath != null) {
-        const target = this.resolve(firstPath);
-        return this._buildStructuredObserver([[firstPath, target]], merged, "one");
-      }
-      const collected = [];
-      this._collectObserveTargets("", collected);
-      collected.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
-      const actor = merged.actor;
-      const picked = actor == null ? collected : collected.filter(([, nd]) => nd.allowsObserve(actor));
-      return this._buildStructuredObserver(picked, merged, "all");
-    };
-    return this._createObserveResult(targets, options, expand);
-  }
-  /**
-   * Unified observer builder — replaces the four ex-creators
-   * (`_createObserveResult` / `...ForAll` / `_createFallback…`). Accepts a
-   * list of `[path, node]` targets (single-element for one-node observe,
-   * N-element for all-nodes). Inspector hooks attach per-target when
-   * `causal`/`derived` requested AND `config.inspectorEnabled`; otherwise
-   * those fields gracefully drop.
-   *
-   * Events flow through a `recordEvent()` helper so the format logger,
-   * ring-buffer, and async-iterable hooks all share one push path.
-   */
-  _createObserveResult(targets, options, expand) {
-    const timeline = options.timeline === true;
-    const causal = options.causal === true;
-    const derived = options.derived === true;
-    const minimal = options.detail === "minimal";
-    const inspectorOn = this.config.inspectorEnabled;
-    const wantInspector = (causal || derived) && inspectorOn;
-    const maxEvents = options.maxEvents;
-    const ring = maxEvents != null && maxEvents > 0 ? new RingBuffer(maxEvents) : null;
-    const events = [];
-    const listeners = /* @__PURE__ */ new Set();
-    const values = {};
-    const nodeErrored = /* @__PURE__ */ new Set();
-    let dirtyCount = 0;
-    let resolvedCount = 0;
-    let invalidateCount = 0;
-    let pauseCount = 0;
-    let resumeCount = 0;
-    let teardownCount = 0;
-    let anyCompletedCleanly = false;
-    let anyErrored = false;
-    let batchSeq = 0;
-    const lastTriggerDepIndex = /* @__PURE__ */ new Map();
-    const lastRunDepValues = /* @__PURE__ */ new Map();
-    const lastRunDepBatches = /* @__PURE__ */ new Map();
-    const recordEvent = (event) => {
-      if (ring) ring.push(event);
-      else events.push(event);
-      for (const listener of listeners) listener(event);
-    };
-    const baseMeta = () => timeline ? { timestamp_ns: monotonicNs(), in_batch: isBatching(), batch_id: batchSeq } : {};
-    const attachInspector = (target, path) => {
-      if (!wantInspector || !(target instanceof NodeImpl)) return void 0;
-      return target._setInspectorHook((ev) => {
-        if (ev.kind === "dep_message") {
-          lastTriggerDepIndex.set(target, ev.depIndex);
-        } else if (ev.kind === "run") {
-          const effective = ev.batchData.map(
-            (b, i) => b != null && b.length > 0 ? b.at(-1) : ev.prevData[i]
-          );
-          lastRunDepValues.set(target, effective);
-          const batches = ev.batchData.map(
-            (b) => b != null ? [...b] : void 0
-          );
-          lastRunDepBatches.set(target, batches);
-          if (derived) {
-            recordEvent({
-              type: "derived",
-              path,
-              dep_values: effective,
-              dep_batches: batches,
-              ...baseMeta()
-            });
-          }
-        }
-      });
-    };
-    const buildCausal = (target) => {
-      const idx = lastTriggerDepIndex.get(target);
-      const depValues = lastRunDepValues.get(target);
-      if (!causal || depValues == null) return {};
-      const triggerDep = idx != null && idx >= 0 && target instanceof NodeImpl ? target._deps[idx] : void 0;
-      const triggerNode = triggerDep?.node;
-      const tv = triggerNode?.v;
-      const depBatches = lastRunDepBatches.get(target);
-      return {
-        trigger_dep_index: idx,
-        trigger_dep_name: triggerNode?.name,
-        ...tv != null ? { trigger_version: { id: tv.id, version: tv.version } } : {},
-        dep_values: [...depValues],
-        ...depBatches != null ? { dep_batches: depBatches } : {}
-      };
-    };
-    const inspectorDetaches = [];
-    const unsubs = [];
-    for (const [path, target] of targets) {
-      const detach = attachInspector(target, path);
-      if (detach) inspectorDetaches.push(detach);
-      unsubs.push(
-        target.subscribe((msgs) => {
-          batchSeq++;
-          for (const m of msgs) {
-            const t = m[0];
-            const base = baseMeta();
-            if (t === DATA) {
-              values[path] = m[1];
-              recordEvent({
-                type: "data",
-                path,
-                data: m[1],
-                ...base,
-                ...buildCausal(target)
-              });
-            } else if (minimal) {
-              if (t === DIRTY) dirtyCount++;
-              else if (t === RESOLVED) resolvedCount++;
-              else if (t === INVALIDATE) invalidateCount++;
-              else if (t === PAUSE) pauseCount++;
-              else if (t === RESUME) resumeCount++;
-              else if (t === TEARDOWN) teardownCount++;
-              else if (t === COMPLETE && !nodeErrored.has(path)) anyCompletedCleanly = true;
-              else if (t === ERROR) {
-                anyErrored = true;
-                nodeErrored.add(path);
-              }
-            } else if (t === DIRTY) {
-              dirtyCount++;
-              recordEvent({ type: "dirty", path, ...base });
-            } else if (t === RESOLVED) {
-              resolvedCount++;
-              recordEvent({
-                type: "resolved",
-                path,
-                ...base,
-                ...buildCausal(target)
-              });
-            } else if (t === INVALIDATE) {
-              invalidateCount++;
-              recordEvent({ type: "invalidate", path, ...base });
-            } else if (t === PAUSE) {
-              pauseCount++;
-              recordEvent({ type: "pause", path, lockId: m[1], ...base });
-            } else if (t === RESUME) {
-              resumeCount++;
-              recordEvent({ type: "resume", path, lockId: m[1], ...base });
-            } else if (t === COMPLETE) {
-              if (!nodeErrored.has(path)) anyCompletedCleanly = true;
-              recordEvent({ type: "complete", path, ...base });
-            } else if (t === ERROR) {
-              anyErrored = true;
-              nodeErrored.add(path);
-              recordEvent({
-                type: "error",
-                path,
-                data: m[1],
-                ...base
-              });
-            } else if (t === TEARDOWN) {
-              teardownCount++;
-              recordEvent({ type: "teardown", path, ...base });
-            }
-          }
-        })
-      );
-    }
-    let disposed = false;
-    const dispose = () => {
-      if (disposed) return;
-      disposed = true;
-      for (const u of unsubs) u();
-      for (const d of inspectorDetaches) d();
-      for (const resolve of asyncResolvers) resolve({ value: void 0, done: true });
-      asyncResolvers.length = 0;
-    };
-    const asyncQueue = [];
-    const asyncResolvers = [];
-    listeners.add((ev) => {
-      const resolve = asyncResolvers.shift();
-      if (resolve) resolve({ value: ev, done: false });
-      else asyncQueue.push(ev);
-    });
-    const result = {
-      get values() {
-        return values;
-      },
-      get dirtyCount() {
-        return dirtyCount;
-      },
-      get resolvedCount() {
-        return resolvedCount;
-      },
-      get invalidateCount() {
-        return invalidateCount;
-      },
-      get pauseCount() {
-        return pauseCount;
-      },
-      get resumeCount() {
-        return resumeCount;
-      },
-      get teardownCount() {
-        return teardownCount;
-      },
-      get events() {
-        return ring ? ring.toArray() : [...events];
-      },
-      get anyCompletedCleanly() {
-        return anyCompletedCleanly;
-      },
-      get anyErrored() {
-        return anyErrored;
-      },
-      get completedWithoutErrors() {
-        return anyCompletedCleanly && !anyErrored;
-      },
-      onEvent(listener) {
-        listeners.add(listener);
-        return () => listeners.delete(listener);
-      },
-      dispose,
-      expand(extra) {
-        dispose();
-        const merged = { ...options };
-        if (typeof extra === "string") {
-          merged.detail = extra;
-        } else {
-          Object.assign(merged, extra);
-        }
-        return expand(resolveObserveDetail(merged));
-      },
-      [Symbol.asyncIterator]() {
-        return {
-          next() {
-            if (asyncQueue.length > 0) {
-              return Promise.resolve({ value: asyncQueue.shift(), done: false });
-            }
-            if (disposed) return Promise.resolve({ value: void 0, done: true });
-            return new Promise((resolve) => asyncResolvers.push(resolve));
-          },
-          return() {
-            dispose();
-            return Promise.resolve({ value: void 0, done: true });
-          }
-        };
-      }
-    };
-    if (options.format != null) this._attachFormatLogger(result, options);
-    return result;
-  }
-  /**
-   * Attach format-rendering logger to an ObserveResult by subscribing to its
-   * event stream (no monkey-patching). Renders each event per `format` and
-   * `theme`, filtered by `includeTypes` / `excludeTypes`.
-   */
-  _attachFormatLogger(result, options) {
-    const format = options.format;
-    if (format == null) return;
-    const logger = options.logger ?? ((line) => console.log(line));
-    const include = options.includeTypes ? new Set(options.includeTypes) : null;
-    const exclude = options.excludeTypes ? new Set(options.excludeTypes) : null;
-    const shouldLog = include == null && exclude == null ? () => true : (type) => (include == null || include.has(type)) && (exclude == null || !exclude.has(type));
-    const theme = resolveObserveTheme(options.theme);
-    const renderEvent = (event) => {
-      if (format === "json") {
-        try {
-          return JSON.stringify(event);
-        } catch {
-          return JSON.stringify({
-            type: event.type,
-            path: event.path,
-            data: "[unserializable]"
-          });
-        }
-      }
-      const color = theme[event.type] ?? "";
-      const pathPart = event.path ? `${theme.path}${event.path}${theme.reset} ` : "";
-      const isDataBearing = event.type === "data" || event.type === "error";
-      const isLockBearing = event.type === "pause" || event.type === "resume";
-      const dataPart = isDataBearing ? ` ${describeData(event.data)}` : isLockBearing ? ` ${describeData(event.lockId)}` : "";
-      const causal = event.type === "data" || event.type === "resolved" || event.type === "derived" ? event : void 0;
-      const triggerPart = causal?.trigger_dep_name != null ? ` <- ${causal.trigger_dep_name}` : causal?.trigger_dep_index != null ? ` <- #${causal.trigger_dep_index}` : "";
-      const batchPart = event.in_batch ? " [batch]" : "";
-      return `${pathPart}${color}${event.type.toUpperCase()}${theme.reset}${dataPart}${triggerPart}${batchPart}`;
-    };
-    result.onEvent((event) => {
-      if (shouldLog(event.type)) logger(renderEvent(event), event);
-    });
-  }
-  // `dumpGraph` is folded into `describe({format: "pretty" | "json"})` (Unit 12).
-  // `toMermaid` / `toD2` are folded into `describe({format: "mermaid" | "d2"})` (Unit 20).
-  // ——————————————————————————————————————————————————————————————
-  //  Lifecycle & persistence (§3.7–§3.8)
-  // ——————————————————————————————————————————————————————————————
-  /**
-   * Register a cleanup function to be called on {@link Graph.destroy}.
-   *
-   * Factories use this to attach teardown logic for internal nodes, keepalive
-   * subscriptions, or other resources that are not registered on the graph and
-   * would otherwise leak on repeated create/destroy cycles.
-   *
-   * Returns a removal function — call it to unregister the disposer early.
-   */
-  addDisposer(fn) {
-    this._disposers.add(fn);
-    return () => {
-      this._disposers.delete(fn);
-    };
-  }
-  /**
-   * Drains disposers (registered via {@link addDisposer}), then sends `[[TEARDOWN]]` to all
-   * nodes and clears registries on this graph and every mounted subgraph (§3.7).
-   * The instance is left empty and may be reused with {@link Graph.add}.
-   */
-  destroy() {
-    drainDisposers(this._disposers, this.name);
-    this.signal([[TEARDOWN]], { internal: true });
-    drainDisposers(this._storageDisposers, this.name);
-    for (const child of [...this._mounts.values()]) {
-      child._parent = void 0;
-      child._destroyClearOnly();
-    }
-    this._mounts.clear();
-    this._nodes.clear();
-    this._parent = void 0;
-  }
-  /** Clear structure after parent already signaled TEARDOWN through this subtree. */
-  _destroyClearOnly() {
-    for (const child of [...this._mounts.values()]) {
-      child._parent = void 0;
-      child._destroyClearOnly();
-    }
-    this._mounts.clear();
-    this._nodes.clear();
-    this._parent = void 0;
-  }
-  snapshot(opts) {
-    const { expand: _, ...d } = this.describe({ detail: "full" });
-    const sortedNodes = {};
-    for (const key of Object.keys(d.nodes).sort()) {
-      const { lastMutation: _lm, guard: _g, ...node } = d.nodes[key];
-      sortedNodes[key] = node;
-    }
-    const sortedSubgraphs = [...d.subgraphs].sort();
-    const snap = {
-      ...d,
-      version: 1,
-      nodes: sortedNodes,
-      subgraphs: sortedSubgraphs
-    };
-    if (opts?.format == null) return snap;
-    if (opts.format === "json-string") return JSON.stringify(snap);
-    if (opts.format === "bytes") {
-      if (opts.codec == null) {
-        throw new Error("snapshot({format: 'bytes'}) requires a `codec` name");
-      }
-      const codec = this.config.lookupCodec(opts.codec);
-      if (codec == null) {
-        throw new Error(
-          `snapshot: codec "${opts.codec}" is not registered on this graph's config. Call config.registerCodec(...) before creating nodes.`
-        );
-      }
-      return encodeEnvelope(codec, codec.encode(snap));
-    }
-    throw new Error(`snapshot: unknown format "${String(opts.format)}"`);
-  }
-  /**
-   * Auto-dispatch a byte buffer produced by {@link Graph.snapshot} with
-   * `{format: "bytes", codec: name}`. Reads the v1 envelope, resolves the
-   * named codec on `config` (defaults to `defaultConfig`), and returns the
-   * decoded snapshot. Combine with {@link Graph.fromSnapshot} to rehydrate
-   * a full graph topology from bytes.
-   *
-   * @throws If the envelope is malformed or the named codec isn't
-   *   registered on the target config.
-   */
-  static decode(bytes, opts) {
-    const cfg = opts?.config ?? defaultConfig;
-    const { codec, codecVersion, payload } = decodeEnvelope(bytes, cfg);
-    return codec.decode(payload, codecVersion);
-  }
-  /**
-   * Apply persisted values onto an existing graph whose topology matches the snapshot
-   * (§3.8). Only {@link DescribeNodeOutput.type} `state` entries with a `value` field
-   * are written by default; `derived` / `operator` / `effect` are always skipped so
-   * deps drive recomputation. `producer` entries are skipped unless `includeProducers`
-   * is set (producers recompute on activation, so restoring is usually a no-op
-   * overwritten on the next wave — opt in for audit / forensic round-trip use cases).
-   * Unknown paths are ignored.
-   *
-   * @param data - Snapshot envelope with matching `name` and node slices.
-   * @throws If `data.name` does not equal {@link Graph.name}.
-   */
-  restore(data, options) {
-    parseSnapshotEnvelope(data);
-    if (data.name !== this.name) {
-      throw new Error(
-        `Graph "${this.name}": restore snapshot name "${data.name}" does not match this graph`
-      );
-    }
-    const onlyPatterns = options?.only == null ? null : (Array.isArray(options.only) ? options.only : [options.only]).map((p) => globToRegex(p));
-    const includeProducers = options?.includeProducers === true;
-    for (const path of Object.keys(data.nodes).sort()) {
-      if (onlyPatterns !== null && !onlyPatterns.some((re) => re.test(path))) continue;
-      const slice = data.nodes[path];
-      if (slice === void 0) continue;
-      if (!("value" in slice) || slice.value === void 0) {
-        if ("value" in slice && slice.value === void 0) {
-          options?.onError?.(
-            path,
-            new Error(
-              `restore: slice.value is undefined for "${path}" (undefined is the global SENTINEL; not valid DATA)`
-            )
-          );
-        }
-        continue;
-      }
-      if (slice.type === "derived" || slice.type === "effect") {
-        continue;
-      }
-      if (slice.type === "producer" && !includeProducers) {
-        continue;
-      }
-      if (slice.v != null) {
-        const live = this.tryResolve(path);
-        const lv = live?.v;
-        if (lv != null && lv.id === slice.v.id && lv.version === slice.v.version) {
-          continue;
-        }
-      }
-      try {
-        this.set(path, slice.value);
-      } catch (err) {
-        options?.onError?.(path, err);
-      }
-    }
-  }
-  /**
-   * Creates a graph named from the snapshot, optionally runs `build` to register nodes
-   * and mounts, then {@link Graph.restore} values (§3.8).
-   *
-   * @param data - Snapshot envelope (`version` checked).
-   * @param opts - Either a legacy `build(g)` callback, or an options object:
-   *   - `build?` — topology constructor; skips auto-hydration when present.
-   *   - `factories?` — map from glob pattern to {@link GraphNodeFactory},
-   *     used by auto-hydration to reconstruct non-state nodes. Per-call (no
-   *     process-global registry). First matching pattern wins.
-   * @returns Hydrated `Graph` instance.
-   */
-  static fromSnapshot(data, opts) {
-    parseSnapshotEnvelope(data);
-    const build = typeof opts === "function" ? opts : opts?.build;
-    const factoryMap = typeof opts === "function" ? void 0 : opts?.factories;
-    const g = new _Graph(data.name);
-    if (build) {
-      build(g);
-      g.restore(data);
-      return g;
-    }
-    for (const mount of [...data.subgraphs].sort((a, b) => {
-      const da = a.split(PATH_SEP).length;
-      const db = b.split(PATH_SEP).length;
-      if (da !== db) return da - db;
-      if (a < b) return -1;
-      if (a > b) return 1;
-      return 0;
-    })) {
-      const parts = mount.split(PATH_SEP);
-      let target = g;
-      for (const seg of parts) {
-        if (!target._mounts.has(seg)) {
-          target.mount(seg, new _Graph(seg));
-        }
-        target = target._mounts.get(seg);
-      }
-    }
-    const factories = factoryMap ? Object.entries(factoryMap).map(([pattern, factory]) => ({
-      re: globToRegex(pattern),
-      factory
-    })) : [];
-    const factoryForPath = (path) => {
-      for (const entry of factories) {
-        if (entry.re.test(path)) return entry.factory;
-      }
-      return void 0;
-    };
-    const ownerForPath = (path) => {
-      const segments = path.split(PATH_SEP);
-      const local = segments.pop();
-      if (local == null || local.length === 0) {
-        throw new Error(`invalid snapshot path "${path}"`);
-      }
-      let owner = g;
-      for (const seg of segments) {
-        const next = owner._mounts.get(seg);
-        if (!next) throw new Error(`unknown mount "${seg}" in path "${path}"`);
-        owner = next;
-      }
-      return [owner, local];
-    };
-    const primaryEntries = Object.entries(data.nodes).filter(([path]) => !path.includes(`${PATH_SEP}${GRAPH_META_SEGMENT}${PATH_SEP}`)).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
-    const pending = new Map(primaryEntries);
-    const created = /* @__PURE__ */ new Map();
-    let progressed = true;
-    while (pending.size > 0 && progressed) {
-      progressed = false;
-      for (const [path, slice] of [...pending.entries()]) {
-        const deps = slice?.deps ?? [];
-        if (!deps.every((dep) => created.has(dep))) continue;
-        const [owner, localName] = ownerForPath(path);
-        const meta = { ...slice?.meta ?? {} };
-        const factory = factoryForPath(path);
-        let node;
-        if (slice?.type === "state") {
-          node = state(slice.value, { meta });
-        } else {
-          if (factory == null) continue;
-          node = factory(localName, {
-            path,
-            type: slice.type,
-            value: slice.value,
-            meta,
-            deps,
-            resolvedDeps: deps.map((dep) => created.get(dep))
-          });
-        }
-        owner.add(localName, node);
-        created.set(path, node);
-        pending.delete(path);
-        progressed = true;
-      }
-    }
-    if (pending.size > 0) {
-      const unresolved = [...pending.keys()].sort().join(", ");
-      throw new Error(
-        `Graph.fromSnapshot could not reconstruct nodes without build callback: ${unresolved}. Pass matching factories via fromSnapshot(data, { factories: { pattern: factoryFn } }).`
-      );
-    }
-    g.restore(data);
-    return g;
-  }
-  /**
-   * ECMAScript `JSON.stringify` hook — returns the same object as
-   * {@link Graph.snapshot}. Makes `JSON.stringify(graph)` "just work"
-   * without double-encoding.
-   */
-  toJSON() {
-    return this.snapshot();
-  }
-  /**
-   * Unified persistence surface (§3.8). Cascades snapshot records through
-   * one or more {@link StorageTier}s, each with its own `debounceMs` /
-   * `compactEvery` cadence and independent diff baseline.
-   *
-   * Subscription gates on {@link messageTier} ≥ 3 (DATA/RESOLVED/terminal),
-   * never on tier-0/1/2 control waves (START/DIRTY/INVALIDATE/PAUSE/RESUME)
-   * or tier-5 TEARDOWN (graceful shutdown is the caller's responsibility).
-   *
-   * Per-tier cadence lets the hot tier stay sync while cold tiers absorb
-   * async writes without blocking the hot path. Each tier holds its own
-   * `{lastSnapshot, lastVersionFingerprint}` so cold-tier diff baselines
-   * aren't polluted by hot-tier flushes. Tiers with `debounceMs === 0`
-   * share a single snapshot computation per observe event; debounced tiers
-   * compute their own snapshot when their timer fires.
-   */
-  attachStorage(tiers, options = {}) {
-    const states = tiers.map((tier) => ({
-      tier,
-      debounceMs: Math.max(0, tier.debounceMs ?? 0),
-      compactEvery: Math.max(1, tier.compactEvery ?? 10),
-      timer: void 0,
-      seq: 0,
-      lastSnapshot: void 0,
-      lastFingerprint: "",
-      disposed: false,
-      savePending: void 0
-    }));
-    if (options.autoRestore === true) {
-      void this._cascadeRestore(tiers, options.onError);
-    }
-    const runFlush = (s, snapshot) => {
-      if (s.disposed) return;
-      const fingerprint = computeVersionFingerprint(snapshot.nodes);
-      if (s.lastSnapshot != null && fingerprint !== "" && fingerprint === s.lastFingerprint) {
-        return;
-      }
-      const nextSeq = s.seq + 1;
-      const timestamp_ns = wallClockNs();
-      const isFirst = s.lastSnapshot == null;
-      const shouldCompact = isFirst || nextSeq % s.compactEvery === 0;
-      const record = shouldCompact ? {
-        mode: "full",
-        snapshot,
-        seq: nextSeq,
-        timestamp_ns,
-        format_version: SNAPSHOT_VERSION
-      } : {
-        mode: "diff",
-        diff: diffForWAL(s.lastSnapshot, snapshot),
-        seq: nextSeq,
-        timestamp_ns,
-        format_version: SNAPSHOT_VERSION
-      };
-      if (s.tier.filter && !s.tier.filter(this.name, record)) {
-        return;
-      }
-      let result;
-      try {
-        result = s.tier.save(this.name, record);
-      } catch (error) {
-        options.onError?.(error, s.tier);
-        return;
-      }
-      if (result && typeof result.then === "function") {
-        const prev = s.savePending ?? Promise.resolve();
-        const chained = prev.then(
-          () => result,
-          // Previous rejection already surfaced; don't block this save.
-          () => result
-        );
-        const final = chained.then(
-          () => {
-            if (s.disposed) return;
-            s.seq = nextSeq;
-            s.lastSnapshot = snapshot;
-            s.lastFingerprint = fingerprint;
-          },
-          (err) => {
-            options.onError?.(err, s.tier);
-          }
-        );
-        s.savePending = final.finally(() => {
-          if (s.savePending === final) s.savePending = void 0;
-        });
-      } else {
-        s.seq = nextSeq;
-        s.lastSnapshot = snapshot;
-        s.lastFingerprint = fingerprint;
-      }
-    };
-    const flushTier = (s, snapshot) => {
-      try {
-        runFlush(s, snapshot);
-      } catch (error) {
-        options.onError?.(error, s.tier);
-      }
-    };
-    const onEvent = (path, messages) => {
-      const triggeredByTier = messages.some((m) => {
-        const tier = this.config.messageTier(m[0]);
-        return tier >= 3 && tier < 5;
-      });
-      if (!triggeredByTier) return;
-      if (options.filter) {
-        const nd = this.tryResolve(path);
-        if (nd == null) return;
-        const described = describeNode(nd, resolveDescribeFields("standard"));
-        if (!options.filter(path, described)) return;
-      }
-      let sharedSnapshot;
-      const getSnapshot = () => {
-        if (sharedSnapshot == null) sharedSnapshot = this.snapshot();
-        return sharedSnapshot;
-      };
-      for (const s of states) {
-        if (s.disposed) continue;
-        if (s.debounceMs === 0) {
-          flushTier(s, getSnapshot());
-        } else {
-          if (s.timer == null) s.timer = new ResettableTimer();
-          s.timer.start(s.debounceMs, () => {
-            if (s.disposed) return;
-            flushTier(s, this.snapshot());
-          });
-        }
-      }
-    };
-    let off;
-    if (options.paths != null) {
-      const paths = typeof options.paths === "string" ? this._pathsMatching(options.paths) : options.paths;
-      const unsubs = paths.map((p) => {
-        const nd = this.tryResolve(p);
-        if (nd == null) return () => {
-        };
-        return nd.subscribe((msgs) => onEvent(p, msgs));
-      });
-      off = () => {
-        for (const u of unsubs) u();
-      };
-    } else {
-      off = this.observe().subscribe((path, messages) => onEvent(path, messages));
-    }
-    const dispose = () => {
-      off();
-      for (const s of states) {
-        s.disposed = true;
-        s.timer?.cancel();
-      }
-      this._storageDisposers.delete(dispose);
-    };
-    this._storageDisposers.add(dispose);
-    return { dispose };
-  }
-  /**
-   * Try tiers in order (hottest first); apply the first record that hits
-   * via {@link Graph.restore}. Returns `true` if any tier produced a
-   * restorable snapshot, `false` if all missed.
-   *
-   * Resilience: a tier that returns data which cannot be restored (load
-   * throws, shape unrecognized, or `restore()` itself throws) does not abort
-   * the cascade — the error is routed through `onError` (if supplied) and
-   * the next colder tier is tried. This mirrors how a multi-tier cache
-   * falls through on a corrupt hot entry.
-   *
-   * Note: `restore()` mutates state incrementally. If a restore throws
-   * partway through, the graph may hold a mixed state (some slices from
-   * the bad tier, some pre-existing). A subsequent successful tier's
-   * `restore()` overwrites the overlapping slices.
-   *
-   * Internal helper shared by {@link Graph.attachStorage}'s `autoRestore`
-   * option and the static {@link Graph.fromStorage} factory.
-   */
-  async _cascadeRestore(tiers, onError) {
-    for (const tier of tiers) {
-      let raw;
-      try {
-        raw = await tier.load(this.name);
-      } catch (err) {
-        onError?.(err, tier);
-        continue;
-      }
-      if (raw == null) continue;
-      if (typeof raw !== "object" || Array.isArray(raw)) continue;
-      const record = raw;
-      try {
-        if (record.mode === "full" && record.snapshot != null) {
-          this.restore(record.snapshot);
-          return true;
-        }
-        if (record.version === SNAPSHOT_VERSION && record.nodes != null) {
-          this.restore(record);
-          return true;
-        }
-      } catch (err) {
-        onError?.(err, tier);
-      }
-    }
-    return false;
-  }
-  /**
-   * Construct a fresh {@link Graph} pre-hydrated from the first tier that
-   * hits. Delegates topology reconstruction to {@link Graph.fromSnapshot}
-   * on `"full"` records and direct {@link Graph.restore} on bare snapshots.
-   *
-   * Always asynchronous — awaits `tier.load()` for async tier support even
-   * when all tiers are sync. Callers that know they only pass sync tiers
-   * can safely `await` immediately.
-   *
-   * @throws If no tier holds a restorable record matching `name` *and* no
-   *   `factories` override is provided for dynamic nodes.
-   */
-  static async fromStorage(name, tiers, opts) {
-    for (const tier of tiers) {
-      let raw;
-      try {
-        raw = await tier.load(name);
-      } catch (err) {
-        opts?.onError?.(err, tier);
-        continue;
-      }
-      if (raw == null) continue;
-      if (typeof raw !== "object" || Array.isArray(raw)) continue;
-      const record = raw;
-      const snapshot = record.mode === "full" && record.snapshot != null ? record.snapshot : record.version === SNAPSHOT_VERSION && record.nodes != null ? record : void 0;
-      if (snapshot == null) continue;
-      try {
-        return _Graph.fromSnapshot(snapshot, opts);
-      } catch (err) {
-        opts?.onError?.(err, tier);
-      }
-    }
-    throw new Error(
-      `Graph.fromStorage: no tier held a restorable record for "${name}" across ${tiers.length} tier(s)`
-    );
-  }
-  // ——————————————————————————————————————————————————————————————
-  //  Inspector (roadmap 3.3) — reasoning trace, overhead gating
-  // ——————————————————————————————————————————————————————————————
-  // Inspector gating lives on `this.config.inspectorEnabled` (see
-  // `core/config.ts`). Default: `true` outside `NODE_ENV === "production"`.
-  _annotations = /* @__PURE__ */ new Map();
-  _traceRing;
-  trace(path, reason, opts) {
-    if (path != null && reason != null) {
-      if (!this.config.inspectorEnabled) return;
-      if (this.tryResolve(path) == null) return;
-      this._annotations.set(path, reason);
-      const entry = {
-        path,
-        reason,
-        timestamp_ns: monotonicNs(),
-        ...opts?.actor != null ? { actor: opts.actor } : {}
-      };
-      this._traceRing.push(entry);
-      return;
-    }
-    if (!this.config.inspectorEnabled) return [];
-    return this._traceRing.toArray();
-  }
-  /**
-   * Latest reason annotation attached to `path` via {@link Graph.trace},
-   * or `undefined` if none. `describe()` surfaces this via the `reason`
-   * field on each node entry (when present).
-   */
-  annotation(path) {
-    return this._annotations.get(path);
-  }
-  /**
-   * Clear all reasoning-trace state (both the per-path annotations map and
-   * the ring buffer). Useful for long-running processes that want periodic
-   * resets, or tests that need a clean slate.
-   */
-  clearTrace() {
-    this._annotations.clear();
-    this._traceRing.clear();
-  }
-  /**
-   * Remove trace entries matching `predicate`. Returns the number of
-   * entries removed. Does not touch the per-path annotations map — call
-   * {@link Graph.clearTrace} for a full reset.
-   */
-  pruneTrace(predicate) {
-    const kept = this._traceRing.toArray().filter((e) => !predicate(e));
-    const removed = this._traceRing.size - kept.length;
-    this._traceRing.clear();
-    for (const e of kept) this._traceRing.push(e);
-    return removed;
-  }
-  /**
-   * Computes structural + value diff between two {@link Graph.describe} snapshots.
-   *
-   * @param a - Earlier describe output.
-   * @param b - Later describe output.
-   * @returns Added/removed nodes, changed fields, and edge deltas.
-   */
-  static diff(a, b) {
-    const aKeys = new Set(Object.keys(a.nodes));
-    const bKeys = new Set(Object.keys(b.nodes));
-    const nodesAdded = [...bKeys].filter((k) => !aKeys.has(k)).sort();
-    const nodesRemoved = [...aKeys].filter((k) => !bKeys.has(k)).sort();
-    const nodesChanged = [];
-    const versionChanges = [];
-    for (const key of aKeys) {
-      if (!bKeys.has(key)) continue;
-      const na = a.nodes[key];
-      const nb = b.nodes[key];
-      const av = na.v;
-      const bv = nb.v;
-      if (av != null && bv != null && av.id === bv.id && av.version !== bv.version) {
-        versionChanges.push({
-          path: key,
-          id: av.id,
-          from: av.version,
-          to: bv.version
-        });
-      }
-      const versionMatches = av != null && bv != null && av.id === bv.id && av.version === bv.version;
-      for (const field of ["type", "status", "sentinel"]) {
-        const va = na[field];
-        const vb = nb[field];
-        if (va !== vb) {
-          nodesChanged.push({ path: key, field, from: va, to: vb });
-        }
-      }
-      if (versionMatches) continue;
-      for (const field of ["value", "meta"]) {
-        const va = na[field];
-        const vb = nb[field];
-        if (!deepEqual(va, vb)) {
-          nodesChanged.push({ path: key, field, from: va, to: vb });
-        }
-      }
-    }
-    const edgeKey = (e) => `${e.from}	${e.to}`;
-    const aEdges = new Set(a.edges.map(edgeKey));
-    const bEdges = new Set(b.edges.map(edgeKey));
-    const edgesAdded = b.edges.filter((e) => !aEdges.has(edgeKey(e)));
-    const edgesRemoved = a.edges.filter((e) => !bEdges.has(edgeKey(e)));
-    const aSubgraphs = new Set(a.subgraphs);
-    const bSubgraphs = new Set(b.subgraphs);
-    const subgraphsAdded = [...bSubgraphs].filter((s) => !aSubgraphs.has(s)).sort();
-    const subgraphsRemoved = [...aSubgraphs].filter((s) => !bSubgraphs.has(s)).sort();
-    return {
-      nodesAdded,
-      nodesRemoved,
-      nodesChanged,
-      versionChanges,
-      edgesAdded,
-      edgesRemoved,
-      subgraphsAdded,
-      subgraphsRemoved
-    };
-  }
-};
-function diffForWAL(a, b) {
-  const base = Graph.diff(a, b);
-  const nodesAddedFull = {};
-  for (const path of base.nodesAdded) {
-    const slice = b.nodes[path];
-    if (slice != null) nodesAddedFull[path] = slice;
-  }
-  return { ...base, nodesAddedFull };
-}
-function reachable(described, from, direction, options = {}) {
-  const empty = { paths: [], depths: /* @__PURE__ */ new Map(), truncated: false };
-  if (!from) return options.withDetail ? empty : [];
-  if (!options.both && direction !== "upstream" && direction !== "downstream") {
-    throw new Error(`reachable: direction must be "upstream" or "downstream"`);
-  }
-  const maxDepth = options.maxDepth;
-  if (maxDepth != null && (!Number.isInteger(maxDepth) || maxDepth < 0)) {
-    throw new Error(`reachable: maxDepth must be an integer >= 0`);
-  }
-  if (maxDepth === 0) return options.withDetail ? empty : [];
-  const depsByPath = /* @__PURE__ */ new Map();
-  const reverseDeps = /* @__PURE__ */ new Map();
-  const incomingEdges = /* @__PURE__ */ new Map();
-  const outgoingEdges = /* @__PURE__ */ new Map();
-  const universe = /* @__PURE__ */ new Set();
-  for (const [path, node] of Object.entries(described.nodes)) {
-    if (!path) continue;
-    universe.add(path);
-    const deps = node.deps ?? [];
-    depsByPath.set(path, deps);
-    for (const dep of deps) {
-      if (!dep) continue;
-      universe.add(dep);
-      if (!reverseDeps.has(dep)) reverseDeps.set(dep, /* @__PURE__ */ new Set());
-      reverseDeps.get(dep).add(path);
-    }
-  }
-  for (const edge of described.edges) {
-    if (edge == null || typeof edge !== "object") continue;
-    const from2 = typeof edge.from === "string" ? edge.from : "";
-    const to = typeof edge.to === "string" ? edge.to : "";
-    if (!from2 || !to) continue;
-    universe.add(from2);
-    universe.add(to);
-    if (!outgoingEdges.has(from2)) outgoingEdges.set(from2, /* @__PURE__ */ new Set());
-    outgoingEdges.get(from2).add(to);
-    if (!incomingEdges.has(to)) incomingEdges.set(to, /* @__PURE__ */ new Set());
-    incomingEdges.get(to).add(from2);
-  }
-  if (!universe.has(from)) return options.withDetail ? empty : [];
-  const doBoth = options.both === true;
-  const visit = (path) => {
-    if (doBoth) {
-      const up = depsByPath.get(path) ?? [];
-      const upEdges = incomingEdges.get(path);
-      const down2 = reverseDeps.get(path);
-      const downEdges2 = outgoingEdges.get(path);
-      const acc2 = [...up];
-      if (upEdges) acc2.push(...upEdges);
-      if (down2) acc2.push(...down2);
-      if (downEdges2) acc2.push(...downEdges2);
-      return acc2;
-    }
-    if (direction === "upstream") {
-      const up = depsByPath.get(path) ?? [];
-      const upEdges = incomingEdges.get(path);
-      if (!upEdges) return up;
-      return [...up, ...upEdges];
-    }
-    const down = reverseDeps.get(path);
-    const downEdges = outgoingEdges.get(path);
-    const acc = down ? [...down] : [];
-    if (downEdges) acc.push(...downEdges);
-    return acc;
-  };
-  const visited = /* @__PURE__ */ new Set([from]);
-  const depths = /* @__PURE__ */ new Map();
-  const queue = [{ path: from, depth: 0 }];
-  let head = 0;
-  let truncated = false;
-  while (head < queue.length) {
-    const next = queue[head++];
-    if (maxDepth != null && next.depth >= maxDepth) {
-      if (visit(next.path).length > 0) truncated = true;
-      continue;
-    }
-    for (const nb of visit(next.path)) {
-      if (!nb || visited.has(nb)) continue;
-      visited.add(nb);
-      depths.set(nb, next.depth + 1);
-      queue.push({ path: nb, depth: next.depth + 1 });
-    }
-  }
-  const paths = [...depths.keys()].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  if (options.withDetail) return { paths, depths, truncated };
-  return paths;
-}
-
-export {
-  explainPath,
-  OVERHEAD,
-  SIZEOF_SYMBOL,
-  sizeof,
-  graphProfile,
-  GRAPH_META_SEGMENT,
-  SNAPSHOT_VERSION,
-  Graph,
-  diffForWAL,
-  reachable
-};
-//# sourceMappingURL=chunk-PF7GRZMW.js.map