@graphrefly/graphrefly 0.26.0 → 0.27.0

package/dist/index.js

@@ -1,17 +1,30 @@
 import {
   reactive_layout_exports
-} from "./chunk-ZQMEI34O.js";
+} from "./chunk-X3VMZYBT.js";
+import {
+  demo_shell_exports
+} from "./chunk-JWBCY4NC.js";
+import "./chunk-GTE6PWRZ.js";
 import {
   compat_exports,
   signals_exports
-} from "./chunk-SN4YWWYO.js";
+} from "./chunk-WBZOVTYK.js";
+import {
+  vue_exports
+} from "./chunk-MJ2NKQQL.js";
+import {
+  zustand_exports
+} from "./chunk-APFNLIRG.js";
+import {
+  jotai_exports
+} from "./chunk-XGPU467M.js";
 import {
   nanostores_exports
 } from "./chunk-N6UR7YVY.js";
 import {
   cqrs_exports,
   nestjs_exports
-} from "./chunk-IZYUSJC7.js";
+} from "./chunk-DST5DKZS.js";
 import {
   react_exports
 } from "./chunk-J22W6HV3.js";
@@ -21,59 +34,25 @@ import {
 import {
   svelte_exports
 } from "./chunk-OHISZPOJ.js";
-import {
-  vue_exports
-} from "./chunk-MJ2NKQQL.js";
-import {
-  zustand_exports
-} from "./chunk-JYXEWPH4.js";
 import {
   CircuitOpenError,
-  NS_PER_MS,
-  NS_PER_SEC,
   NativeIndexBackend,
-  NativeListBackend,
-  NativeMapBackend,
   NativePubSubBackend,
   RateLimiterOverflowError,
   TimeoutError,
-  audit,
-  buffer,
-  bufferCount,
-  bufferTime,
   cascadingCache,
-  catchError,
   checkpointToRedis,
   checkpointToS3,
   circuitBreaker,
-  combine,
-  combineLatest,
-  concat,
-  concatMap,
-  constant,
   createTransport,
   csvRows,
-  debounce,
-  debounceTime,
-  decorrelatedJitter,
-  delay,
   deserializeError,
   dictStorage,
-  distill,
-  distinctUntilChanged,
-  elementAt,
-  exhaustMap,
-  exponential,
   externalBundle,
   externalProducer,
   extra_exports,
   fallback,
-  fibonacci,
   fileStorage,
-  filter,
-  find,
-  first,
-  flatMap,
   fromCSV,
   fromClickHouseWatch,
   fromDrizzle,
@@ -104,47 +83,22 @@ import {
   fromWebSocketReconnect,
   fromWebhook,
   indexedDbStorage,
-  interval,
-  last,
-  linear,
   lru,
-  map,
   memoryStorage,
-  merge,
-  mergeMap,
   nameToSignal,
   ndjsonRows,
-  pairwise,
   parsePrometheusText,
   parseStatsD,
   parseSyslog,
-  pausable,
   pubsub,
-  race,
   rateLimiter,
   reactiveIndex,
-  reactiveList,
-  reactiveMap,
   reactiveSink,
-  reduce,
-  repeat,
-  rescue,
-  resolveBackoffPreset,
   retry,
   retrySource,
-  sample,
-  scan,
   serializeError,
   signalToName,
-  skip,
   sqliteStorage,
-  switchMap,
-  take,
-  takeUntil,
-  takeWhile,
-  tap,
-  throttle,
-  throttleTime,
   timeout,
   toCSV,
   toClickHouse,
@@ -166,3633 +120,255 @@ import {
   toTempo,
   toWebSocket,
   tokenBucket,
+  withBreaker,
+  withStatus,
+  workerBridge,
+  workerSelf
+} from "./chunk-BQ6RQQFF.js";
+import {
+  createWatermarkController,
+  toObservable
+} from "./chunk-OFVJBJXR.js";
+import {
+  ai_exports,
+  gate,
+  orchestration_exports,
+  promptNode
+} from "./chunk-K2AUJHVP.js";
+import {
+  decay,
+  memory_exports
+} from "./chunk-AT5LKYNL.js";
+import {
+  NS_PER_MS,
+  NS_PER_SEC,
+  audit,
+  buffer,
+  bufferCount,
+  bufferTime,
+  catchError,
+  combine,
+  combineLatest,
+  concat,
+  concatMap,
+  constant,
+  debounce,
+  debounceTime,
+  decorrelatedJitter,
+  delay,
+  distill,
+  distinctUntilChanged,
+  elementAt,
+  exhaustMap,
+  exponential,
+  fibonacci,
+  filter,
+  find,
+  first,
+  flatMap,
+  interval,
+  last,
+  linear,
+  map,
+  merge,
+  mergeMap,
+  pairwise,
+  pausable,
+  race,
+  reduce,
+  repeat,
+  rescue,
+  resolveBackoffPreset,
+  sample,
+  scan,
+  skip,
+  switchMap,
+  take,
+  takeUntil,
+  takeWhile,
+  tap,
+  throttle,
+  throttleTime,
   valve,
   verifiable,
   window,
   windowCount,
   windowTime,
-  withBreaker,
   withLatestFrom,
   withMaxAttempts,
-  withStatus,
-  workerBridge,
-  workerSelf,
   zip
-} from "./chunk-AMCG74RZ.js";
-import {
-  NativeLogBackend,
-  createWatermarkController,
-  reactiveLog,
-  toObservable
-} from "./chunk-RB6QPHJ7.js";
-import {
-  core_exports
-} from "./chunk-3ZWCKRHX.js";
+} from "./chunk-RNHBMHKA.js";
 import {
-  graph_exports,
-  watchTopologyTree
-} from "./chunk-6LDQFTYS.js";
+  audit_exports,
+  policyEnforcer,
+  reactiveExplainPath
+} from "./chunk-NC6S43JJ.js";
 import {
-  demo_shell_exports
-} from "./chunk-FQMKGR6L.js";
-import "./chunk-LCE3GF5P.js";
+  TopicGraph,
+  messaging_exports
+} from "./chunk-X5R3GL6H.js";
 import {
   domainMeta,
   trackingKey,
   tryIncrementBounded
 } from "./chunk-JSCT3CR4.js";
 import {
-  cached,
-  empty,
-  escapeRegexChar,
-  firstValueFrom,
-  firstWhere,
-  forEach,
-  fromAny,
-  fromAsyncIter,
-  fromCron,
-  fromEvent,
-  fromIter,
-  fromPromise,
-  fromRaf,
-  fromTimer,
-  globToRegExp,
-  keepalive,
-  matchesAnyPattern,
-  matchesCron,
-  never,
-  of,
-  parseCron,
-  reactiveCounter,
-  replay,
-  share,
-  shareReplay,
-  throwError,
-  toArray
-} from "./chunk-BVZYTZ5H.js";
-import {
-  GRAPH_META_SEGMENT,
-  Graph,
-  OVERHEAD,
-  SIZEOF_SYMBOL,
-  SNAPSHOT_VERSION,
-  diffForWAL,
-  explainPath,
-  graphProfile,
-  reachable,
-  sizeof
-} from "./chunk-THTWHNU4.js";
-import {
-  ResettableTimer
-} from "./chunk-7TAQJHQV.js";
-import {
-  resolveDescribeFields
-} from "./chunk-VYPWMZ6H.js";
+  core_exports
+} from "./chunk-3ZWCKRHX.js";
 import {
-  jotai_exports
-} from "./chunk-XGPU467M.js";
+  NativeListBackend,
+  NativeMapBackend,
+  reactiveList,
+  reactiveMap
+} from "./chunk-WKNUIZOY.js";
 import {
-  DEFAULT_ACTOR,
-  ENVELOPE_VERSION,
-  GraphReFlyConfig,
-  GuardDenied,
-  JsonCodec,
-  NodeImpl,
-  accessHintForGuard,
-  advanceVersion,
-  autoTrackNode,
-  batch,
-  configure,
-  createDagCborCodec,
-  createDagCborZstdCodec,
-  createVersioning,
-  decodeEnvelope,
-  defaultConfig,
-  defaultHash,
-  derived,
-  downWithBatch,
-  dynamicNode,
-  effect,
-  encodeEnvelope,
-  isBatching,
-  isV1,
-  monotonicNs,
-  node,
-  normalizeActor,
-  pipe,
-  policy,
-  policyFromRules,
-  producer,
-  registerBuiltinCodecs,
-  registerBuiltins,
-  replayWAL,
-  state,
-  wallClockNs
-} from "./chunk-PHOUUNK7.js";
+  NativeLogBackend,
+  reactiveLog
+} from "./chunk-J2VBW3DZ.js";
 import {
-  COMPLETE,
-  COMPLETE_MSG,
-  COMPLETE_ONLY_BATCH,
-  DATA,
-  DIRTY,
-  DIRTY_MSG,
-  DIRTY_ONLY_BATCH,
-  ERROR,
-  INVALIDATE,
-  INVALIDATE_MSG,
-  INVALIDATE_ONLY_BATCH,
-  PAUSE,
-  RESOLVED,
-  RESOLVED_MSG,
-  RESOLVED_ONLY_BATCH,
-  RESUME,
-  START,
-  START_MSG,
-  TEARDOWN,
-  TEARDOWN_MSG,
-  TEARDOWN_ONLY_BATCH,
-  __export
-} from "./chunk-SX52TAR4.js";
-
-// src/patterns/index.ts
-var patterns_exports = {};
-__export(patterns_exports, {
-  SNAPSHOT_WIRE_VERSION: () => SNAPSHOT_WIRE_VERSION,
-  SurfaceError: () => SurfaceError,
-  accountability: () => audit_exports,
-  ai: () => ai_exports,
-  asSurfaceError: () => asSurfaceError,
-  cqrs: () => cqrs_exports,
-  createGraph: () => createGraph,
-  deleteSnapshot: () => deleteSnapshot,
-  demoShell: () => demo_shell_exports,
-  diffSnapshots: () => diffSnapshots,
-  domainTemplates: () => domain_templates_exports,
-  graphspec: () => graphspec_exports,
-  guarded: () => guarded_execution_exports,
-  harness: () => harness_exports,
-  layout: () => reactive_layout_exports,
-  lens: () => lens_exports,
-  listSnapshots: () => listSnapshots,
-  memory: () => memory_exports,
-  messaging: () => messaging_exports,
-  orchestration: () => orchestration_exports,
-  reduction: () => reduction_exports,
-  resilientPipeline: () => resilient_pipeline_exports,
-  restoreSnapshot: () => restoreSnapshot,
-  runReduction: () => runReduction,
-  saveSnapshot: () => saveSnapshot,
-  surface: () => surface_exports
-});
-
-// src/patterns/ai.ts
-var ai_exports = {};
-__export(ai_exports, {
-  AgentLoopGraph: () => AgentLoopGraph,
-  ChatStreamGraph: () => ChatStreamGraph,
-  ToolRegistryGraph: () => ToolRegistryGraph,
-  admissionFilter3D: () => admissionFilter3D,
-  agentLoop: () => agentLoop,
-  agentMemory: () => agentMemory,
-  chatStream: () => chatStream,
-  contentGate: () => contentGate,
-  costMeterExtractor: () => costMeterExtractor,
-  fromLLM: () => fromLLM,
-  gatedStream: () => gatedStream,
-  gaugesAsContext: () => gaugesAsContext,
-  graphFromSpec: () => graphFromSpec,
-  keywordFlagExtractor: () => keywordFlagExtractor,
-  knobsAsTools: () => knobsAsTools,
-  llmConsolidator: () => llmConsolidator,
-  llmExtractor: () => llmExtractor,
-  promptNode: () => promptNode,
-  redactor: () => redactor,
-  streamExtractor: () => streamExtractor,
-  streamingPromptNode: () => streamingPromptNode,
-  suggestStrategy: () => suggestStrategy,
-  systemPromptBuilder: () => systemPromptBuilder,
-  toolCallExtractor: () => toolCallExtractor,
-  toolRegistry: () => toolRegistry,
-  validateGraphDef: () => validateGraphDef
-});
-
-// src/patterns/memory.ts
-var memory_exports = {};
-__export(memory_exports, {
-  collection: () => collection,
-  decay: () => decay,
-  knowledgeGraph: () => knowledgeGraph,
-  lightCollection: () => lightCollection,
-  vectorIndex: () => vectorIndex
-});
-function decay(baseScore, ageSeconds, ratePerSecond, minScore = 0) {
-  if (!Number.isFinite(baseScore)) return minScore;
-  if (!Number.isFinite(ageSeconds) || ageSeconds <= 0) return Math.max(minScore, baseScore);
-  if (!Number.isFinite(ratePerSecond) || ratePerSecond <= 0) return Math.max(minScore, baseScore);
-  const decayed = baseScore * Math.exp(-ratePerSecond * ageSeconds);
-  return Math.max(minScore, decayed);
-}
-function assertMaxSize(maxSize) {
-  if (maxSize !== void 0 && maxSize < 1) {
-    throw new RangeError("maxSize must be >= 1");
-  }
-}
-function copyMap(m) {
-  return new Map(m);
-}
-function readMap(node2) {
-  return node2.cache ?? /* @__PURE__ */ new Map();
-}
-function readArray(node2) {
-  return node2.cache ?? [];
-}
-function cosineSimilarity(a, b) {
-  const n = Math.max(a.length, b.length);
-  let dot = 0;
-  let na = 0;
-  let nb = 0;
-  for (let i = 0; i < n; i += 1) {
-    const av = a[i] ?? 0;
-    const bv = b[i] ?? 0;
-    dot += av * bv;
-    na += av * av;
-    nb += bv * bv;
-  }
-  if (na === 0 || nb === 0) return 0;
-  return dot / Math.sqrt(na * nb);
-}
-function lightCollection(opts = {}) {
-  const maxSize = opts.maxSize;
-  const policy2 = opts.policy ?? "fifo";
-  assertMaxSize(maxSize);
-  const entries = state(/* @__PURE__ */ new Map(), {
-    name: opts.name,
-    describeKind: "state"
-  });
-  function evictIfNeeded(next) {
-    if (maxSize === void 0) return;
-    while (next.size > maxSize) {
-      let victim;
-      for (const entry of next.values()) {
-        if (!victim) {
-          victim = entry;
-          continue;
-        }
-        const lhs = policy2 === "lru" ? entry.lastAccessNs : entry.createdAtNs;
-        const rhs = policy2 === "lru" ? victim.lastAccessNs : victim.createdAtNs;
-        if (lhs < rhs) victim = entry;
-      }
-      if (!victim) break;
-      next.delete(victim.id);
-    }
-  }
-  function commit(next) {
-    entries.down([[DATA, next]]);
-  }
-  return {
-    entries,
-    upsert(id, value) {
-      const now = monotonicNs();
-      const current = readMap(entries);
-      const prev = current.get(id);
-      const next = copyMap(current);
-      next.set(id, {
-        id,
-        value,
-        createdAtNs: prev?.createdAtNs ?? now,
-        lastAccessNs: now
-      });
-      evictIfNeeded(next);
-      commit(next);
-    },
-    remove(id) {
-      const next = copyMap(readMap(entries));
-      if (!next.delete(id)) return;
-      commit(next);
-    },
-    clear() {
-      if (readMap(entries).size === 0) return;
-      commit(/* @__PURE__ */ new Map());
-    },
-    get(id) {
-      const current = readMap(entries);
-      const found = current.get(id);
-      if (!found) return void 0;
-      if (policy2 === "lru") {
-        const now = monotonicNs();
-        const next = copyMap(current);
-        next.set(id, { ...found, lastAccessNs: now });
-        commit(next);
-      }
-      return found.value;
-    },
-    has(id) {
-      return readMap(entries).has(id);
-    }
-  };
-}
-function collection(name, opts = {}) {
-  const maxSize = opts.maxSize;
-  const policy2 = opts.policy ?? "lru";
-  const decayRate = opts.decayRate ?? 0;
-  const minScore = opts.minScore ?? 0;
-  const scoreFn = opts.score ?? (() => 1);
-  assertMaxSize(maxSize);
-  const graph = new Graph(name);
-  const items = state(/* @__PURE__ */ new Map(), {
-    name: "items",
-    describeKind: "state"
-  });
-  const ranked = derived(
-    [items],
-    ([snapshot]) => {
-      const typed = snapshot ?? /* @__PURE__ */ new Map();
-      const now = monotonicNs();
-      const out2 = [...typed.values()].map((entry) => {
-        const ageSeconds = (now - entry.lastAccessNs) / 1e9;
-        return {
-          ...entry,
-          score: decay(entry.baseScore, ageSeconds, decayRate, minScore)
-        };
-      });
-      out2.sort((a, b) => b.score - a.score || b.lastAccessNs - a.lastAccessNs);
-      return out2;
-    },
-    { name: "ranked", describeKind: "derived" }
-  );
-  const size = derived(
-    [items],
-    ([snapshot]) => (snapshot ?? /* @__PURE__ */ new Map()).size,
-    {
-      name: "size",
-      describeKind: "derived",
-      initial: 0
-    }
-  );
-  void ranked.subscribe(() => void 0);
-  void size.subscribe(() => void 0);
-  graph.add("items", items);
-  graph.add("ranked", ranked);
-  graph.add("size", size);
-  function effective(entry, now) {
-    const ageSeconds = (now - entry.lastAccessNs) / 1e9;
-    return decay(entry.baseScore, ageSeconds, decayRate, minScore);
-  }
-  function evictIfNeeded(next) {
-    if (maxSize === void 0) return;
-    while (next.size > maxSize) {
-      const now = monotonicNs();
-      let victim;
-      let victimScore = Number.POSITIVE_INFINITY;
-      for (const entry of next.values()) {
-        const score = effective(entry, now);
-        if (score < victimScore) {
-          victim = entry;
-          victimScore = score;
-          continue;
-        }
-        if (score === victimScore && victim) {
-          const lhs = policy2 === "lru" ? entry.lastAccessNs : entry.createdAtNs;
-          const rhs = policy2 === "lru" ? victim.lastAccessNs : victim.createdAtNs;
-          if (lhs < rhs) victim = entry;
-        }
-      }
-      if (!victim) break;
-      next.delete(victim.id);
-    }
-  }
-  function commit(next) {
-    items.down([[DATA, next]]);
-  }
-  const out = Object.assign(graph, {
-    upsert(id, value, upsertOpts) {
-      const now = monotonicNs();
-      const current = readMap(items);
-      const prev = current.get(id);
-      const baseScore = upsertOpts?.score ?? scoreFn(value);
-      const next = copyMap(current);
-      next.set(id, {
-        id,
-        value,
-        baseScore,
-        createdAtNs: prev?.createdAtNs ?? now,
-        lastAccessNs: now
-      });
-      evictIfNeeded(next);
-      commit(next);
-    },
-    remove(id) {
-      const next = copyMap(readMap(items));
-      if (!next.delete(id)) return;
-      commit(next);
-    },
-    clear() {
-      if (readMap(items).size === 0) return;
-      commit(/* @__PURE__ */ new Map());
-    },
-    getItem(id) {
-      const current = readMap(items);
-      const found = current.get(id);
-      if (!found) return void 0;
-      if (policy2 === "lru") {
-        const next = copyMap(current);
-        next.set(id, { ...found, lastAccessNs: monotonicNs() });
-        commit(next);
-      }
-      return found;
-    }
-  });
-  return out;
-}
-function vectorIndex(opts = {}) {
-  const backend = opts.backend ?? "flat";
-  const dimension = opts.dimension;
-  let hnsw;
-  if (backend === "hnsw") {
-    hnsw = opts.hnswFactory?.();
-    if (!hnsw) {
-      throw new Error(
-        'vectorIndex backend "hnsw" requires an optional dependency adapter; install your HNSW package and provide `hnswFactory`.'
-      );
-    }
-  }
-  const entries = state(/* @__PURE__ */ new Map(), {
-    describeKind: "state",
-    name: "vector-index"
-  });
-  function assertDimension(vector) {
-    if (dimension !== void 0 && vector.length !== dimension) {
-      throw new RangeError(
-        `vector dimension mismatch: expected ${dimension}, got ${vector.length}`
-      );
-    }
-  }
-  function commit(next) {
-    entries.down([[DATA, next]]);
-  }
-  return {
-    backend,
-    entries,
-    upsert(id, vector, meta) {
-      assertDimension(vector);
-      const next = copyMap(readMap(entries));
-      next.set(id, { id, vector: [...vector], meta });
-      if (backend === "hnsw") hnsw.upsert(id, vector, meta);
-      commit(next);
-    },
-    remove(id) {
-      const next = copyMap(readMap(entries));
-      if (!next.delete(id)) return;
-      if (backend === "hnsw") hnsw.remove(id);
-      commit(next);
-    },
-    clear() {
-      if (readMap(entries).size === 0) return;
-      if (backend === "hnsw") hnsw.clear();
-      commit(/* @__PURE__ */ new Map());
-    },
-    search(query, k = 5) {
-      assertDimension(query);
-      if (k <= 0) return [];
-      if (backend === "hnsw") return hnsw.search(query, k);
-      const ranked = [...readMap(entries).values()].map((row) => ({
-        id: row.id,
-        score: cosineSimilarity(query, row.vector),
-        meta: row.meta
-      })).sort((a, b) => b.score - a.score).slice(0, k);
-      return ranked;
-    }
-  };
-}
-function knowledgeGraph(name) {
-  const graph = new Graph(name);
-  const entities = state(/* @__PURE__ */ new Map(), {
-    name: "entities",
-    describeKind: "state"
-  });
-  const edges = state([], {
-    name: "edges",
-    describeKind: "state"
-  });
-  const adjacency = derived(
-    [edges],
-    ([rows]) => {
-      const typed = rows ?? [];
-      const out2 = /* @__PURE__ */ new Map();
-      for (const edge of typed) {
-        const prev = out2.get(edge.from) ?? [];
-        out2.set(edge.from, Object.freeze([...prev, edge]));
-      }
-      return out2;
-    },
-    { name: "adjacency", describeKind: "derived", initial: /* @__PURE__ */ new Map() }
-  );
-  void adjacency.subscribe(() => void 0);
-  graph.add("entities", entities);
-  graph.add("edges", edges);
-  graph.add("adjacency", adjacency);
-  function commitEntities(next) {
-    entities.down([[DATA, next]]);
-  }
-  function commitEdges(next) {
-    edges.down([[DATA, next]]);
-  }
-  const out = Object.assign(graph, {
-    upsertEntity(id, value) {
-      const next = copyMap(readMap(entities));
-      next.set(id, value);
-      commitEntities(next);
-    },
-    removeEntity(id) {
-      const nextEntities = copyMap(readMap(entities));
-      const existed = nextEntities.delete(id);
-      const currentEdges = readArray(edges);
-      const nextEdges = currentEdges.filter((edge) => edge.from !== id && edge.to !== id);
-      if (!existed && nextEdges.length === currentEdges.length) return;
-      commitEntities(nextEntities);
-      commitEdges(nextEdges);
-    },
-    link(from, to, relation, weight = 1) {
-      const key = `${from}\0${to}\0${relation}`;
-      const currentEdges = readArray(edges);
-      const existing = new Set(
-        currentEdges.map((edge) => `${edge.from}\0${edge.to}\0${edge.relation}`)
-      );
-      const next = [...currentEdges];
-      if (existing.has(key)) {
-        for (let i = 0; i < next.length; i += 1) {
-          const edge = next[i];
-          if (edge.from === from && edge.to === to && edge.relation === relation) {
-            next[i] = { ...edge, weight };
-            break;
-          }
-        }
-      } else {
-        next.push({ from, to, relation, weight });
-      }
-      commitEdges(next);
-    },
-    unlink(from, to, relation) {
-      const currentEdges = readArray(edges);
-      const next = currentEdges.filter(
-        (edge) => relation === void 0 ? !(edge.from === from && edge.to === to) : !(edge.from === from && edge.to === to && edge.relation === relation)
-      );
-      if (next.length === currentEdges.length) return;
-      commitEdges(next);
-    },
-    related(id, relation) {
-      return readArray(edges).filter(
-        (edge) => (edge.from === id || edge.to === id) && (relation === void 0 || edge.relation === relation)
-      );
-    }
-  });
-  return out;
-}
-
-// src/patterns/messaging.ts
-var messaging_exports = {};
-__export(messaging_exports, {
-  JobFlowGraph: () => JobFlowGraph,
-  JobQueueGraph: () => JobQueueGraph,
-  MessagingHubGraph: () => MessagingHubGraph,
-  SubscriptionGraph: () => SubscriptionGraph,
-  TopicBridgeGraph: () => TopicBridgeGraph,
-  TopicGraph: () => TopicGraph,
-  jobFlow: () => jobFlow,
-  jobQueue: () => jobQueue,
-  messagingHub: () => messagingHub,
-  subscription: () => subscription,
-  topic: () => topic,
-  topicBridge: () => topicBridge
-});
-var DEFAULT_MAX_PER_PUMP = 2147483647;
-function requireNonNegativeInt(value, label) {
-  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
-    throw new Error(`${label} must be a non-negative integer`);
-  }
-  return value;
-}
-function messagingMeta(kind, extra) {
-  return domainMeta("messaging", kind, extra);
-}
-var TopicGraph = class extends Graph {
-  _log;
-  events;
-  /**
-   * Most recently published value, or `null` when the topic has no entries
-   * yet. Spec §5.12 reserves `undefined` as the protocol-internal "never
-   * sent DATA" sentinel — `null` is the idiomatic "empty / no value" signal
-   * for domain nodes. F7.
-   *
-   * **Caveat when `T` itself includes `null`** (e.g., `topic<number | null>`):
-   * `latest === null` is ambiguous — it could mean "no publish yet" OR "a
-   * `null` value was published". Use {@link hasLatest} to disambiguate, or
-   * observe {@link events} directly and track length yourself.
-   */
-  latest;
-  /**
-   * Reactive `true` once the topic has at least one published entry.
-   * Disambiguates "`null` never published" from "`null` was published" when
-   * `T` includes `null`.
-   */
-  hasLatest;
-  constructor(name, opts = {}) {
-    super(name, opts.graph);
-    this._log = reactiveLog([], { name: "events", maxSize: opts.retainedLimit });
-    this.events = this._log.entries;
-    this.add("events", this.events);
-    this.latest = derived(
-      [this.events],
-      ([snapshot]) => {
-        const entries = snapshot;
-        return entries.length === 0 ? null : entries[entries.length - 1];
-      },
-      {
-        name: "latest",
-        describeKind: "derived",
-        meta: messagingMeta("topic_latest")
-      }
-    );
-    this.add("latest", this.latest);
-    this.addDisposer(keepalive(this.latest));
-    this.hasLatest = derived(
-      [this.events],
-      ([snapshot]) => snapshot.length > 0,
-      {
-        name: "hasLatest",
-        describeKind: "derived",
-        meta: messagingMeta("topic_has_latest")
-      }
-    );
-    this.add("hasLatest", this.hasLatest);
-    this.addDisposer(keepalive(this.hasLatest));
-    this.addDisposer(() => {
-      this.events.down([[COMPLETE]]);
-    });
-    this.addDisposer(() => this._log.disposeAllViews());
-  }
-  publish(value) {
-    this._log.append(value);
-  }
-  retained() {
-    return this.events.cache;
-  }
-};
-var SubscriptionGraph = class extends Graph {
-  source;
-  cursor;
-  available;
-  /**
-   * Reference to the upstream topic graph. Intentionally NOT mounted
-   * under this subscription: a subscription is a VIEW over an
-   * externally-owned topic. Double-mounting (e.g. hub-owned topic +
-   * sub-mount here) would make either-side teardown leave the other
-   * holding a dead reference. Node-level `derived([topicEvents], …)`
-   * still wires the data dependency across graph boundaries. D1(e).
-   */
-  topic;
-  constructor(name, topicGraph, opts = {}) {
-    super(name, opts.graph);
-    const initialCursor = requireNonNegativeInt(opts.cursor ?? 0, "subscription cursor");
-    this.topic = topicGraph;
-    const topicEvents = topicGraph.events;
-    this.source = derived([topicEvents], ([snapshot]) => snapshot, {
-      name: "source",
-      describeKind: "derived",
-      meta: messagingMeta("subscription_source"),
-      initial: topicEvents.cache
-    });
-    this.add("source", this.source);
-    this.cursor = state(initialCursor, {
-      name: "cursor",
-      describeKind: "state",
-      meta: messagingMeta("subscription_cursor")
-    });
-    this.add("cursor", this.cursor);
-    this.available = derived(
-      [this.source, this.cursor],
-      ([sourceSnapshot, cursor]) => {
-        const entries = sourceSnapshot;
-        const start = Math.max(0, Math.trunc(cursor ?? 0));
-        return entries.slice(start);
-      },
-      {
-        name: "available",
-        describeKind: "derived",
-        meta: messagingMeta("subscription_available"),
-        initial: []
-      }
-    );
-    this.add("available", this.available);
-    this.addDisposer(keepalive(this.source));
-    this.addDisposer(keepalive(this.available));
-  }
-  ack(count) {
-    const available = this.available.cache;
-    const requested = count === void 0 ? available.length : requireNonNegativeInt(count, "subscription ack count");
-    const step = Math.min(requested, available.length);
-    if (step <= 0) return this.cursor.cache;
-    const next = this.cursor.cache + step;
-    this.cursor.emit(next);
-    return next;
-  }
-  pull(limit, opts = {}) {
-    const available = this.available.cache;
-    const max = limit === void 0 ? available.length : requireNonNegativeInt(limit, "subscription pull limit");
-    const out = available.slice(0, max);
-    if (opts.ack && out.length > 0) this.ack(out.length);
-    return out;
-  }
-};
-var JobQueueGraph = class extends Graph {
-  _pending;
-  _jobs;
-  _seq = 0;
-  pending;
-  jobs;
-  depth;
-  constructor(name, opts = {}) {
-    super(name, opts.graph);
-    this._pending = reactiveList([], { name: "pending" });
-    this._jobs = reactiveMap({ name: "jobs" });
-    this.pending = this._pending.items;
-    this.jobs = this._jobs.entries;
-    this.add("pending", this.pending);
-    this.add("jobs", this.jobs);
-    this.depth = derived([this.pending], ([snapshot]) => snapshot.length, {
-      name: "depth",
-      describeKind: "derived",
-      meta: messagingMeta("queue_depth"),
-      initial: 0
-    });
-    this.add("depth", this.depth);
-    this.addDisposer(keepalive(this.depth));
-  }
-  enqueue(payload, opts = {}) {
-    const id = opts.id ?? `${this.name}-${++this._seq}`;
-    if (this._jobs.get(id) !== void 0) {
-      throw new Error(`jobQueue("${this.name}"): duplicate job id "${id}"`);
-    }
-    const job = {
-      id,
-      payload,
-      attempts: 0,
-      metadata: Object.freeze({ ...opts.metadata ?? {} }),
-      state: "queued"
-    };
-    this._jobs.set(id, job);
-    this._pending.append(id);
-    return id;
-  }
-  claim(limit = 1) {
-    const max = requireNonNegativeInt(limit, "job queue claim limit");
-    if (max === 0) return [];
-    const out = [];
-    while (out.length < max) {
-      const ids = this.pending.cache;
-      if (ids.length === 0) break;
-      const id = this._pending.pop(0);
-      const job = this._jobs.get(id);
-      if (!job || job.state !== "queued") continue;
-      const inflight = {
-        ...job,
-        state: "inflight",
-        attempts: job.attempts + 1
-      };
-      this._jobs.set(id, inflight);
-      out.push(inflight);
-    }
-    return out;
-  }
-  ack(id) {
-    const job = this._jobs.get(id);
-    if (!job || job.state !== "inflight") return false;
-    this._jobs.delete(id);
-    return true;
-  }
-  nack(id, opts = {}) {
-    const job = this._jobs.get(id);
-    if (!job || job.state !== "inflight") return false;
-    if (opts.requeue ?? true) {
-      this._jobs.set(id, { ...job, state: "queued" });
-      this._pending.append(id);
-      return true;
-    }
-    this._jobs.delete(id);
-    return true;
-  }
-};
-var JobFlowGraph = class extends Graph {
-  _stageNames;
-  _queues = /* @__PURE__ */ new Map();
-  _completed;
-  completed;
-  completedCount;
-  constructor(name, opts = {}) {
-    super(name, opts.graph);
-    const stages = (opts.stages ?? ["incoming", "processing", "done"]).map((v) => v.trim());
-    if (stages.length < 2) {
-      throw new Error(`jobFlow("${name}"): requires at least 2 stages`);
-    }
-    const unique = new Set(stages);
-    if (unique.size !== stages.length) {
-      throw new Error(`jobFlow("${name}"): stage names must be unique`);
-    }
-    this._stageNames = Object.freeze([...stages]);
-    for (const stage of this._stageNames) {
-      const q = jobQueue(`${name}-${stage}`);
-      this._queues.set(stage, q);
-      this.mount(stage, q);
-    }
-    this._completed = reactiveLog([], { name: "completed" });
-    this.completed = this._completed.entries;
-    this.add("completed", this.completed);
-    this.completedCount = derived(
-      [this.completed],
-      ([snapshot]) => snapshot.length,
-      {
-        name: "completedCount",
-        describeKind: "derived",
-        meta: messagingMeta("job_flow_completed_count"),
-        initial: 0
-      }
-    );
-    this.add("completedCount", this.completedCount);
-    this.addDisposer(keepalive(this.completedCount));
-    const maxPerPump = Math.max(
-      1,
-      requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "job flow maxPerPump")
-    );
-    for (let i = 0; i < this._stageNames.length; i += 1) {
-      const stage = this._stageNames[i];
-      const current = this.queue(stage);
-      const next = i + 1 < this._stageNames.length ? this.queue(this._stageNames[i + 1]) : null;
-      const pump = node(
-        [current.pending],
-        () => {
-          let moved = 0;
-          while (moved < maxPerPump) {
-            const claim = current.claim(1);
-            if (claim.length === 0) break;
-            const job = claim[0];
-            if (!job) break;
-            if (next) {
-              next.enqueue(job.payload, {
-                metadata: {
-                  ...job.metadata,
-                  job_flow_from: stage
-                }
-              });
-            } else {
-              this._completed.append(job);
-            }
-            current.ack(job.id);
-            moved += 1;
-          }
-        },
-        {
-          name: `pump_${stage}`,
-          describeKind: "effect",
-          meta: messagingMeta("job_flow_pump")
-        }
-      );
-      this.add(`pump_${stage}`, pump);
-      this.addDisposer(keepalive(pump));
-    }
-  }
-  stages() {
-    return this._stageNames;
-  }
-  queue(stage) {
-    const q = this._queues.get(stage);
-    if (!q) throw new Error(`jobFlow("${this.name}"): unknown stage "${stage}"`);
-    return q;
-  }
-  enqueue(payload, opts = {}) {
-    return this.queue(this._stageNames[0]).enqueue(payload, opts);
-  }
-  retainedCompleted() {
-    return this.completed.cache;
-  }
-};
-var TopicBridgeGraph = class extends Graph {
-  _sourceSub;
-  _target;
-  bridgedCount;
-  constructor(name, sourceTopic, targetTopic, opts = {}) {
-    super(name, opts.graph);
-    this._sourceSub = subscription(`${name}-subscription`, sourceTopic, {
-      cursor: opts.cursor
-    });
-    this._target = targetTopic;
-    this.mount("subscription", this._sourceSub);
-    this.bridgedCount = state(0, {
-      name: "bridgedCount",
-      describeKind: "state",
-      meta: messagingMeta("topic_bridge_count")
-    });
-    this.add("bridgedCount", this.bridgedCount);
-    const maxPerPump = Math.max(
-      1,
-      requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "topic bridge maxPerPump")
-    );
-    const mapValue = opts.map ?? ((value) => value);
-    const pump = node(
-      [this._sourceSub.available],
-      () => {
-        const available = this._sourceSub.pull(maxPerPump, { ack: true });
-        if (available.length === 0) return;
-        let bridged = 0;
-        for (const value of available) {
-          const mapped = mapValue(value);
-          if (mapped === void 0) continue;
-          this._target.publish(mapped);
-          bridged += 1;
-        }
-        if (bridged > 0) {
-          const current = this.bridgedCount.cache;
-          this.bridgedCount.down([[DATA, current + bridged]]);
-        }
-      },
-      {
-        name: "pump",
-        describeKind: "effect",
-        meta: messagingMeta("topic_bridge_pump")
-      }
-    );
-    this.add("pump", pump);
-    this.addDisposer(keepalive(pump));
-  }
-};
-var MessagingHubGraph = class extends Graph {
-  _topics = /* @__PURE__ */ new Map();
-  _version = 0;
-  _defaultTopicOptions;
-  constructor(name, opts = {}) {
-    super(name, opts.graph);
-    this._defaultTopicOptions = { ...opts.defaultTopicOptions ?? {} };
-  }
-  /** Monotonic counter advancing on topic create/remove. */
-  get version() {
-    return this._version;
-  }
-  /** Number of topics currently in the hub. */
-  get size() {
-    return this._topics.size;
-  }
-  /** Checks topic existence without creating. */
-  has(name) {
-    return this._topics.has(name);
-  }
-  /** Iterator over topic names. */
-  topicNames() {
-    return this._topics.keys();
-  }
-  /**
-   * Returns the {@link TopicGraph} for `name`, creating lazily on first call.
-   * Subsequent calls with the same name return the same instance (options on
-   * repeat calls are ignored — the topic is already configured).
-   */
-  topic(name, opts) {
-    let t = this._topics.get(name);
-    if (t === void 0) {
-      const effective = { ...this._defaultTopicOptions, ...opts ?? {} };
-      t = new TopicGraph(name, effective);
-      this._topics.set(name, t);
-      this.mount(name, t);
-      this._version += 1;
-    }
-    return t;
-  }
-  /**
-   * Publishes a value to the topic, lazily creating it on first publish.
-   *
-   * **Late-subscriber caveat:** the topic is created lazily, so subscribers
-   * that attach AFTER a publish only see the retained window (governed by
-   * `retainedLimit` on `TopicOptions` / `defaultTopicOptions`). If
-   * `retainedLimit === 0` is set explicitly, early publishes are
-   * effectively dropped — prefer an unset `retainedLimit` (unbounded
-   * retention) or subscribe before publishing when late-subscribers matter.
-   */
-  publish(name, value) {
-    this.topic(name).publish(value);
-  }
-  /**
-   * Bulk publish — issues all publishes inside one outer batch. New topics
-   * are created on demand. No-op if `entries` yields nothing.
-   *
-   * **Iterable consumption (F6):** `entries` is consumed once (single-pass)
-   * INSIDE the batch frame. If the iterator throws mid-way, the batch is
-   * discarded and NO publishes are visible to subscribers (all-or-nothing).
-   * Pass an array or `Set` for multi-shot callers.
-   */
-  publishMany(entries) {
-    batch(() => {
-      for (const [name, value] of entries) {
-        this.topic(name).publish(value);
-      }
-    });
-  }
-  /**
-   * Creates a {@link SubscriptionGraph} over a named topic. The topic is
-   * lazily created if missing. Subscription lifecycle is owned by the caller —
-   * the hub does NOT mount the subscription.
-   *
-   * @param subName - Local name for the subscription graph.
-   * @param topicName - Hub topic to subscribe to.
-   * @param opts - `SubscriptionOptions` (initial cursor, etc.).
-   */
-  subscribe(subName, topicName, opts) {
-    const t = this.topic(topicName);
-    return new SubscriptionGraph(subName, t, opts);
-  }
-  /**
-   * Unmounts and tears down the topic's graph. Returns `true` if the topic
-   * existed. Subscribers receive `TEARDOWN` via {@link Graph.remove}.
-   */
-  removeTopic(name) {
-    if (!this._topics.has(name)) return false;
-    try {
-      this.remove(name);
-    } finally {
-      this._topics.delete(name);
-      this._version += 1;
-    }
-    return true;
-  }
-};
-function topic(name, opts) {
-  return new TopicGraph(name, opts);
-}
-function messagingHub(name, opts) {
-  return new MessagingHubGraph(name, opts);
-}
-function subscription(name, topicGraph, opts) {
-  return new SubscriptionGraph(name, topicGraph, opts);
-}
-function jobQueue(name, opts) {
-  return new JobQueueGraph(name, opts);
-}
-function jobFlow(name, opts) {
-  return new JobFlowGraph(name, opts);
-}
-function topicBridge(name, sourceTopic, targetTopic, opts) {
-  return new TopicBridgeGraph(name, sourceTopic, targetTopic, opts);
-}
-
-// src/patterns/orchestration.ts
-var orchestration_exports = {};
-__export(orchestration_exports, {
-  approval: () => approval,
-  branch: () => branch,
-  forEach: () => forEach2,
-  gate: () => gate,
-  join: () => join,
-  loop: () => loop,
-  onFailure: () => onFailure,
-  pipeline: () => pipeline,
-  sensor: () => sensor,
-  subPipeline: () => subPipeline,
-  task: () => task,
-  valve: () => valve2,
-  wait: () => wait
-});
-function resolveDep(graph, dep) {
-  if (typeof dep === "string") {
-    return { node: graph.resolve(dep), path: dep };
-  }
-  const path = findRegisteredNodePath(graph, dep);
-  if (!path) {
-    throw new Error(
-      "orchestration dep node must already be registered in the graph so explicit edges can be recorded; pass a string path or register the node first"
-    );
-  }
-  return { node: dep, path };
-}
-function findRegisteredNodePath(graph, target) {
-  const described = graph.describe();
-  const metaSegment = `::${GRAPH_META_SEGMENT}::`;
-  for (const path of Object.keys(described.nodes).sort()) {
-    if (path.includes(metaSegment)) continue;
-    try {
-      if (graph.resolve(path) === target) return path;
-    } catch {
-    }
-  }
-  return void 0;
-}
-function registerStep(graph, name, step, depPaths) {
-  graph.add(name, step);
-  void depPaths;
-}
-function baseMeta(kind, meta) {
-  return domainMeta("orchestration", kind, meta);
-}
-function coerceLoopIterations(raw) {
-  const parseString = (value) => {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) return 0;
-    return Number(trimmed);
-  };
-  let parsed;
-  if (typeof raw === "string") {
-    parsed = parseString(raw);
-  } else if (raw === null) {
-    parsed = 0;
-  } else {
-    parsed = Number(raw);
-  }
-  if (!Number.isFinite(parsed)) return 1;
-  return Math.max(0, Math.trunc(parsed));
-}
-function pipeline(name, opts) {
-  return new Graph(name, opts);
-}
-function task(graph, name, run, opts) {
-  const depRefs = opts?.deps ?? [];
-  const deps = depRefs.map((dep) => resolveDep(graph, dep));
-  const { deps: _deps, ...nodeOpts } = opts ?? {};
-  const wrapped = (batchData, actions, ctx) => {
-    const data = batchData.map(
-      (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
-    );
-    actions.emit(run(data, ctx));
-    return void 0;
-  };
-  const step = node(
-    deps.map((d) => d.node),
-    wrapped,
-    {
-      ...nodeOpts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("task", opts?.meta)
-    }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    deps.flatMap((d) => d.path ? [d.path] : [])
-  );
-  return step;
-}
-function branch(graph, name, source, predicate, opts) {
-  const src = resolveDep(graph, source);
-  const step = derived(
-    [src.node],
-    ([value]) => ({
-      branch: predicate(value) ? "then" : "else",
-      value
-    }),
-    {
-      ...opts,
-      name,
-      meta: baseMeta("branch", opts?.meta)
-    }
-  );
-  registerStep(graph, name, step, src.path ? [src.path] : []);
-  return step;
-}
-function valve2(graph, name, source, control, opts) {
-  const src = resolveDep(graph, source);
-  const ctrl = resolveDep(graph, control);
-  const step = node(
-    [src.node, ctrl.node],
-    (batchData, actions, ctx) => {
-      const batch0 = batchData[0];
-      const batch1 = batchData[1];
-      const ctrlVal = batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1];
-      if (batch0 == null || batch0.length === 0) {
-        if (batch1 != null && batch1.length > 0 && ctrlVal && ctx.prevData[0] !== void 0) {
-          actions.emit(ctx.prevData[0]);
-        } else {
-          actions.down([[RESOLVED]]);
-        }
-        return;
-      }
-      if (!ctrlVal) {
-        actions.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) actions.emit(v);
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("valve", opts?.meta)
-    }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    [src.path, ctrl.path].filter((v) => typeof v === "string")
-  );
-  return step;
-}
-function approval(graph, name, source, approver, opts) {
-  const src = resolveDep(graph, source);
-  const ctrl = resolveDep(graph, approver);
-  const isApproved = opts?.isApproved ?? ((value) => Boolean(value));
-  const step = node(
-    [src.node, ctrl.node],
-    (batchData, actions, ctx) => {
-      const batch0 = batchData[0];
-      const batch1 = batchData[1];
-      const ctrlVal = batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1];
-      if (ctrlVal === void 0 || !isApproved(ctrlVal)) {
-        actions.down([[RESOLVED]]);
-        return;
-      }
-      if (batch0 == null || batch0.length === 0) {
-        if (batch1 != null && batch1.length > 0 && ctx.prevData[0] !== void 0) {
-          actions.emit(ctx.prevData[0]);
-        } else {
-          actions.down([[RESOLVED]]);
-        }
-        return;
-      }
-      for (const v of batch0) actions.emit(v);
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("approval", opts?.meta)
-    }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    [src.path, ctrl.path].filter((v) => typeof v === "string")
-  );
-  return step;
-}
-function gate(graph, name, source, opts) {
-  const maxPending = opts?.maxPending ?? Infinity;
-  if (maxPending < 1 && maxPending !== Infinity) {
-    throw new RangeError("gate: maxPending must be >= 1");
-  }
-  const startOpen = opts?.startOpen ?? false;
-  const src = resolveDep(graph, source);
-  const pendingNode = state([], { name: "pending", equals: () => false });
-  const isOpenNode = state(startOpen, { name: "isOpen" });
-  const countNode = derived([pendingNode], ([arr]) => arr.length, {
-    name: "count"
-  });
-  let queue = [];
-  let torn = false;
-  let latestIsOpen = startOpen;
-  const isOpenUnsub = isOpenNode.subscribe((msgs) => {
-    for (const m of msgs) {
-      if (m[0] === DATA) latestIsOpen = m[1];
-    }
-  });
-  function syncPending() {
-    pendingNode.down([[DATA, [...queue]]]);
-  }
-  function enqueue(value) {
-    queue.push(value);
-    if (queue.length > maxPending) queue.shift();
-    syncPending();
-  }
-  function dequeue(n) {
-    const items = queue.splice(0, n);
-    syncPending();
-    return items;
-  }
-  function guardTorn(method) {
-    if (torn) throw new Error(`gate: ${method}() called after gate was torn down`);
-  }
-  const output = node(
-    [src.node],
-    (batchData, actions, ctx) => {
-      const terminal = ctx.terminalDeps[0];
-      if (terminal !== void 0) {
-        torn = true;
-        queue = [];
-        syncPending();
-        actions.down(terminal === true ? [[COMPLETE]] : [[ERROR, terminal]]);
-        return;
-      }
-      const batch0 = batchData[0];
-      if (batch0 == null || batch0.length === 0) {
-        actions.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        if (latestIsOpen) {
-          actions.emit(v);
-        } else {
-          enqueue(v);
-          actions.down([[RESOLVED]]);
-        }
-      }
-    },
-    {
-      name,
-      describeKind: "derived",
-      meta: baseMeta("gate", opts?.meta)
-    }
-  );
-  const controller = {
-    node: output,
-    pending: pendingNode,
-    count: countNode,
-    isOpen: isOpenNode,
-    approve(count = 1) {
-      guardTorn("approve");
-      const items = dequeue(count);
-      for (const item of items) {
-        if (torn) break;
-        output.down([[DATA, item]]);
-      }
-    },
-    reject(count = 1) {
-      guardTorn("reject");
-      dequeue(count);
-    },
-    modify(fn, count = 1) {
-      guardTorn("modify");
-      const snapshot = [...queue];
-      const items = dequeue(count);
-      for (let i = 0; i < items.length; i++) {
-        if (torn) break;
-        output.down([[DATA, fn(items[i], i, snapshot)]]);
-      }
-    },
-    open() {
-      guardTorn("open");
-      batch(() => {
-        isOpenNode.down([[DATA, true]]);
-        const items = dequeue(queue.length);
-        for (const item of items) {
-          if (torn) break;
-          output.down([[DATA, item]]);
-        }
-      });
-    },
-    close() {
-      guardTorn("close");
-      isOpenNode.down([[DATA, false]]);
-    }
-  };
-  graph.addDisposer(countNode.subscribe(() => void 0));
-  graph.addDisposer(isOpenUnsub);
-  registerStep(graph, name, output, src.path ? [src.path] : []);
-  const internal = new Graph(`${name}_state`);
-  internal.add("pending", pendingNode);
-  internal.add("isOpen", isOpenNode);
-  internal.add("count", countNode);
-  graph.mount(`${name}_state`, internal);
-  return controller;
-}
-function forEach2(graph, name, source, run, opts) {
-  const src = resolveDep(graph, source);
-  let terminated = false;
-  const step = node(
-    [src.node],
-    (batchData, actions, ctx) => {
-      if (terminated) {
-        actions.down([[RESOLVED]]);
-        return;
-      }
-      const terminal = ctx.terminalDeps[0];
-      if (terminal !== void 0) {
-        terminated = true;
-        actions.down(terminal === true ? [[COMPLETE]] : [[ERROR, terminal]]);
-        return;
-      }
-      const batch0 = batchData[0];
-      if (batch0 == null || batch0.length === 0) {
-        actions.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        try {
-          run(v, actions);
-        } catch (err) {
-          terminated = true;
-          actions.down([[ERROR, err]]);
-          return;
-        }
-      }
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "effect",
-      completeWhenDepsComplete: false,
-      meta: baseMeta("forEach", opts?.meta)
-    }
-  );
-  registerStep(graph, name, step, src.path ? [src.path] : []);
-  return step;
-}
-function join(graph, name, deps, opts) {
-  const resolved = deps.map((dep) => resolveDep(graph, dep));
-  const step = derived(
-    resolved.map((d) => d.node),
-    (values) => values,
-    {
-      ...opts,
-      name,
-      meta: baseMeta("join", opts?.meta)
-    }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    resolved.flatMap((d) => d.path ? [d.path] : [])
-  );
-  return step;
-}
-function loop(graph, name, source, iterate, opts) {
-  const src = resolveDep(graph, source);
-  const iterRef = opts?.iterations;
-  const iterDep = typeof iterRef === "number" || iterRef === void 0 ? void 0 : resolveDep(graph, iterRef);
-  const staticIterations = typeof iterRef === "number" ? iterRef : void 0;
-  const step = node(
-    iterDep ? [src.node, iterDep.node] : [src.node],
-    (depValues, actions, ctx) => {
-      const batch0 = depValues[0];
-      let current = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
-      const batch1 = iterDep ? depValues[1] : void 0;
-      const rawCount = staticIterations ?? (iterDep ? batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1] : 1);
-      const count = coerceLoopIterations(rawCount);
-      for (let i = 0; i < count; i += 1) {
-        current = iterate(current, i, actions);
-      }
-      actions.emit(current);
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "derived",
-      meta: baseMeta("loop", opts?.meta)
-    }
-  );
-  registerStep(
-    graph,
-    name,
-    step,
-    [src.path, iterDep?.path].filter((v) => typeof v === "string")
-  );
-  return step;
-}
-function subPipeline(graph, name, childOrBuild, opts) {
-  const child = childOrBuild instanceof Graph ? childOrBuild : pipeline(name, opts);
-  if (typeof childOrBuild === "function") {
-    childOrBuild(child);
-  }
-  graph.mount(name, child);
-  return child;
-}
-function sensor(graph, name, initial, opts) {
-  const source = node([], () => void 0, {
-    ...opts,
-    name,
-    initial,
-    describeKind: "producer",
-    meta: baseMeta("sensor", opts?.meta)
-  });
-  registerStep(graph, name, source, []);
-  return {
-    node: source,
-    push(value) {
-      source.down([[DATA, value]]);
-    },
-    error(err) {
-      source.down([[ERROR, err]]);
-    },
-    complete() {
-      source.down([[COMPLETE]]);
-    }
-  };
-}
-function wait(graph, name, source, ms, opts) {
-  const src = resolveDep(graph, source);
-  const timers = /* @__PURE__ */ new Set();
-  let terminated = false;
-  let completed = false;
-  function clearAllTimers() {
-    for (const id of timers) clearTimeout(id);
-    timers.clear();
-  }
-  const srcVal = src.node.cache;
-  const initialOpt = srcVal !== void 0 ? { initial: srcVal } : {};
-  const step = node(
-    [],
-    (_deps, actions) => {
-      clearAllTimers();
-      terminated = false;
-      completed = false;
-      const unsub = src.node.subscribe((msgs) => {
-        for (const msg of msgs) {
-          if (terminated) return;
-          if (msg[0] === DATA) {
-            const id = setTimeout(() => {
-              timers.delete(id);
-              actions.down([msg]);
-              if (completed && timers.size === 0) {
-                actions.down([[COMPLETE]]);
-              }
-            }, ms);
-            timers.add(id);
-          } else if (msg[0] === COMPLETE) {
-            terminated = true;
-            completed = true;
-            if (timers.size === 0) {
-              actions.down([[COMPLETE]]);
-            }
-          } else if (msg[0] === ERROR) {
-            terminated = true;
-            clearAllTimers();
-            actions.down([msg]);
-          } else {
-            actions.down([msg]);
-          }
-        }
-      });
-      return () => {
-        unsub();
-        clearAllTimers();
-        terminated = true;
-      };
-    },
-    {
-      ...opts,
-      name,
-      ...initialOpt,
-      describeKind: "derived",
-      completeWhenDepsComplete: false,
-      meta: baseMeta("wait", opts?.meta)
-    }
-  );
-  graph.add(name, step);
-  return step;
-}
-function onFailure(graph, name, source, recover, opts) {
-  const src = resolveDep(graph, source);
-  let terminated = false;
-  const step = node(
-    [],
-    (_data, actions) => {
-      const unsub = src.node.subscribe((msgs) => {
-        for (const msg of msgs) {
-          if (terminated) return;
-          if (msg[0] === ERROR) {
-            try {
-              actions.emit(recover(msg[1], actions));
-            } catch (err) {
-              terminated = true;
-              actions.down([[ERROR, err]]);
-            }
-          } else {
-            actions.down([msg]);
-            if (msg[0] === COMPLETE) terminated = true;
-          }
-        }
-      });
-      return () => unsub();
-    },
-    {
-      ...opts,
-      name,
-      describeKind: "derived",
-      completeWhenDepsComplete: false,
-      // onFailure handles errors via manual subscription (recover callback).
-      // Disable auto-propagation so dep-channel ERROR doesn't terminate this
-      // node before the recover callback has a chance to emit a replacement value.
-      errorWhenDepsError: false,
-      meta: baseMeta("onFailure", opts?.meta)
-    }
-  );
-  registerStep(graph, name, step, src.path ? [src.path] : []);
-  return step;
-}
-
-// src/patterns/ai.ts
-function aiMeta(kind, extra) {
-  return domainMeta("ai", kind, extra);
-}
-function isPromiseLike(x) {
-  return x != null && typeof x.then === "function";
-}
-function isNodeLike(x) {
-  return typeof x === "object" && x !== null && "subscribe" in x && typeof x.subscribe === "function" && "cache" in x;
-}
-function isAsyncIterableLike(x) {
-  return x != null && typeof x === "object" && Symbol.asyncIterator in x && typeof x[Symbol.asyncIterator] === "function";
-}
-var DEFAULT_TIMEOUT_MS = 3e4;
-function firstDataFromNode(resolved, opts) {
-  if (resolved.status === "settled") {
-    const immediate = resolved.cache;
-    if (immediate !== void 0) {
-      return Promise.resolve(immediate);
-    }
-  }
-  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  return new Promise((resolve, reject) => {
-    const timer = new ResettableTimer();
-    const unsub = resolved.subscribe((messages) => {
-      for (const msg of messages) {
-        if (msg[0] === DATA) {
-          timer.cancel();
-          unsub();
-          resolve(msg[1]);
-          return;
-        }
-        if (msg[0] === ERROR) {
-          timer.cancel();
-          unsub();
-          reject(msg[1]);
-          return;
-        }
-        if (msg[0] === COMPLETE) {
-          timer.cancel();
-          unsub();
-          reject(new Error("firstDataFromNode: completed without producing a value"));
-          return;
-        }
-      }
-    });
-    timer.start(timeoutMs, () => {
-      unsub();
-      reject(new Error(`firstDataFromNode: timed out after ${timeoutMs}ms`));
-    });
-  });
-}
-async function resolveToolHandlerResult(value) {
-  if (isPromiseLike(value)) {
-    return resolveToolHandlerResult(await value);
-  }
-  if (isNodeLike(value)) {
-    return firstDataFromNode(value);
-  }
-  if (isAsyncIterableLike(value)) {
-    return firstDataFromNode(fromAny(value));
-  }
-  return value;
-}
-function fromLLM(adapter, messages, opts) {
-  const msgsNode = fromAny(messages);
-  const result = switchMap(msgsNode, (msgs) => {
-    if (!msgs || msgs.length === 0) {
-      return state(null);
-    }
-    const tools = opts?.tools;
-    return adapter.invoke(msgs, {
-      model: opts?.model,
-      temperature: opts?.temperature,
-      maxTokens: opts?.maxTokens,
-      tools,
-      systemPrompt: opts?.systemPrompt
-    });
-  });
-  return result;
-}
-function streamingPromptNode(adapter, deps, prompt, opts) {
-  const sourceName = opts?.name ?? "llm";
-  const format = opts?.format ?? "text";
-  const streamTopic = topic(`${sourceName}/stream`);
-  const messagesNode = derived(deps, (values) => {
-    if (values.some((v) => v == null)) return [];
-    const text = typeof prompt === "string" ? prompt : prompt(...values);
-    if (!text) return [];
-    const msgs = [];
-    if (opts?.systemPrompt) msgs.push({ role: "system", content: opts.systemPrompt });
-    msgs.push({ role: "user", content: text });
-    return msgs;
-  });
-  const output = switchMap(messagesNode, (msgs) => {
-    const chatMsgs = msgs;
-    if (!chatMsgs || chatMsgs.length === 0) {
-      return state(null);
-    }
-    const ac = new AbortController();
-    async function* pumpAndCollect() {
-      let accumulated = "";
-      let index = 0;
-      try {
-        for await (const token of adapter.stream(chatMsgs, {
-          model: opts?.model,
-          temperature: opts?.temperature,
-          maxTokens: opts?.maxTokens,
-          systemPrompt: opts?.systemPrompt,
-          signal: ac.signal
-        })) {
-          accumulated += token;
-          streamTopic.publish({
-            source: sourceName,
-            token,
-            accumulated,
-            index: index++
-          });
-        }
-        let result;
-        if (format === "json") {
-          try {
-            result = JSON.parse(stripFences(accumulated));
-          } catch {
-            result = null;
-          }
-        } else {
-          result = accumulated;
-        }
-        yield result;
-      } finally {
-        ac.abort();
-      }
-    }
-    return fromAny(pumpAndCollect());
-  });
-  const unsub = keepalive(output);
-  return {
-    output,
-    stream: streamTopic,
-    dispose: () => {
-      unsub();
-      streamTopic.destroy();
-    }
-  };
-}
-function streamExtractor(streamTopic, extractFn, opts) {
-  return derived(
-    [streamTopic.latest],
-    ([chunk]) => {
-      if (chunk == null) return null;
-      return extractFn(chunk.accumulated);
-    },
-    {
-      name: opts?.name ?? "extractor",
-      describeKind: "derived",
-      initial: null,
-      meta: aiMeta("stream_extractor"),
-      ...opts?.equals ? { equals: opts.equals } : {}
-    }
-  );
-}
-var keywordFlagsEqual = (a, b) => {
-  if (a === b) return true;
-  if (a == null || b == null) return a === b;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    const x = a[i];
-    const y = b[i];
-    if (x.label !== y.label || x.pattern !== y.pattern || x.match !== y.match || x.position !== y.position) {
-      return false;
-    }
-  }
-  return true;
-};
-function keywordFlagExtractor(streamTopic, opts) {
-  const maxPatternLength = opts.maxPatternLength ?? 128;
-  return derived(
-    [streamTopic.latest],
-    ([chunk], ctx) => {
-      if (chunk == null) return [];
-      const accumulated = chunk.accumulated;
-      if (!("flags" in ctx.store)) {
-        ctx.store.flags = [];
-        ctx.store.scannedTo = 0;
-      }
-      const flags = ctx.store.flags;
-      const scannedTo = ctx.store.scannedTo;
-      const startOffset = Math.max(0, scannedTo - maxPatternLength);
-      const region = accumulated.slice(startOffset);
-      let added = false;
-      for (const { pattern, label } of opts.patterns) {
-        const re = new RegExp(pattern.source, `${pattern.flags.replace("g", "")}g`);
-        for (const m of region.matchAll(re)) {
-          const pos = startOffset + m.index;
-          if (pos + m[0].length <= scannedTo) continue;
-          flags.push({ label, pattern, match: m[0], position: pos });
-          added = true;
-        }
-      }
-      ctx.store.scannedTo = accumulated.length;
-      return added ? [...flags] : flags.slice();
-    },
-    {
-      name: opts.name ?? "keyword-flag-extractor",
-      describeKind: "derived",
-      initial: [],
-      meta: aiMeta("keyword_flag_extractor"),
-      equals: keywordFlagsEqual
-    }
-  );
-}
-var toolCallsEqual = (a, b) => {
-  if (a === b) return true;
-  if (a == null || b == null) return a === b;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    const x = a[i];
-    const y = b[i];
-    if (x.startIndex !== y.startIndex || x.name !== y.name || x.raw !== y.raw) {
-      return false;
-    }
-  }
-  return true;
-};
-function toolCallExtractor(streamTopic, opts) {
-  return derived(
-    [streamTopic.latest],
-    ([chunk], ctx) => {
-      if (chunk == null) return [];
-      const accumulated = chunk.accumulated;
-      if (!("calls" in ctx.store)) {
-        ctx.store.calls = [];
-        ctx.store.scanFrom = 0;
-      }
-      const calls = ctx.store.calls;
-      let i = ctx.store.scanFrom;
-      let added = false;
-      while (i < accumulated.length) {
-        const start = accumulated.indexOf("{", i);
-        if (start === -1) {
-          ctx.store.scanFrom = accumulated.length;
-          break;
-        }
-        let depth = 0;
-        let end = -1;
-        let inString = false;
-        for (let j = start; j < accumulated.length; j++) {
-          const ch = accumulated[j];
-          if (inString) {
-            if (ch === "\\" && j + 1 < accumulated.length) {
-              j++;
-            } else if (ch === '"') {
-              inString = false;
-            }
-          } else if (ch === '"') {
-            inString = true;
-          } else if (ch === "{") {
-            depth++;
-          } else if (ch === "}") {
-            depth--;
-            if (depth === 0) {
-              end = j;
-              break;
-            }
-          }
-        }
-        if (end === -1) {
-          ctx.store.scanFrom = start;
-          break;
-        }
-        const raw = accumulated.slice(start, end + 1);
-        try {
-          const parsed = JSON.parse(raw);
-          if (typeof parsed.name === "string" && parsed.arguments != null && typeof parsed.arguments === "object") {
-            calls.push({
-              name: parsed.name,
-              arguments: parsed.arguments,
-              raw,
-              startIndex: start
-            });
-            added = true;
-          }
-        } catch {
-        }
-        i = end + 1;
-        ctx.store.scanFrom = i;
-      }
-      return added ? [...calls] : calls.slice();
-    },
-    {
-      name: opts?.name ?? "tool-call-extractor",
-      describeKind: "derived",
-      initial: [],
-      meta: aiMeta("tool_call_extractor"),
-      equals: toolCallsEqual
-    }
-  );
-}
-var costMeterEqual = (a, b) => {
-  if (a === b) return true;
-  return a.chunkCount === b.chunkCount && a.charCount === b.charCount && a.estimatedTokens === b.estimatedTokens;
-};
-function costMeterExtractor(streamTopic, opts) {
-  const charsPerToken = opts?.charsPerToken ?? 4;
-  return derived(
-    [streamTopic.latest],
-    ([chunk]) => {
-      if (chunk == null) return { chunkCount: 0, charCount: 0, estimatedTokens: 0 };
-      const c = chunk;
-      const charCount = c.accumulated.length;
-      return {
-        chunkCount: c.index + 1,
-        charCount,
-        estimatedTokens: Math.ceil(charCount / charsPerToken)
-      };
-    },
-    {
-      name: opts?.name ?? "cost-meter",
-      describeKind: "derived",
-      initial: { chunkCount: 0, charCount: 0, estimatedTokens: 0 },
-      meta: aiMeta("cost_meter_extractor"),
-      equals: costMeterEqual
-    }
-  );
-}
-function redactor(streamTopic, patterns, replaceFn, opts) {
-  const replace = replaceFn ?? (() => "[REDACTED]");
-  function sanitize(text) {
-    let result = text;
-    for (const pat of patterns) {
-      const global = pat.global ? pat : new RegExp(pat.source, `${pat.flags}g`);
-      result = result.replace(global, (m) => replace(m, pat));
-    }
-    return result;
-  }
-  return derived(
-    [streamTopic.latest],
-    ([chunk]) => {
-      if (chunk == null) {
-        return { source: "", token: "", accumulated: "", index: -1 };
-      }
-      const c = chunk;
-      const sanitizedAccumulated = sanitize(c.accumulated);
-      const sanitizedToken = sanitize(c.token);
-      return {
-        source: c.source,
-        token: sanitizedToken,
-        accumulated: sanitizedAccumulated,
-        index: c.index
-      };
-    },
-    { name: opts?.name ?? "redactor" }
-  );
-}
-function contentGate(streamTopic, classifier, threshold, opts) {
-  const hardThreshold = threshold * (opts?.hardMultiplier ?? 1.5);
-  const isNodeClassifier = typeof classifier !== "function";
-  const deps = [streamTopic.latest];
-  if (isNodeClassifier) deps.push(classifier);
-  return derived(
-    deps,
-    (values) => {
-      const chunk = values[0];
-      if (chunk == null) return "allow";
-      const score = isNodeClassifier ? values[1] ?? 0 : classifier(chunk.accumulated);
-      if (score >= hardThreshold) return "block";
-      if (score >= threshold) return "review";
-      return "allow";
-    },
-    { name: opts?.name ?? "content-gate", initial: "allow" }
-  );
-}
-function gatedStream(graph, name, adapter, deps, prompt, opts) {
-  const cancelSignal = state(0, { name: `${name}/cancel` });
-  let cancelCounter = 0;
-  const allDeps = [...deps, cancelSignal];
-  const sourceName = opts?.name ?? name;
-  const format = opts?.format ?? "text";
-  const streamTopic = topic(`${sourceName}/stream`);
-  const messagesNode = derived(allDeps, (values) => {
-    const depValues = values.slice(0, -1);
-    if (depValues.some((v) => v == null)) return [];
-    const text = typeof prompt === "string" ? prompt : prompt(...depValues);
-    if (!text) return [];
-    const msgs = [];
-    if (opts?.systemPrompt) msgs.push({ role: "system", content: opts.systemPrompt });
-    msgs.push({ role: "user", content: text });
-    return msgs;
-  });
-  const output = switchMap(messagesNode, (msgs) => {
-    const chatMsgs = msgs;
-    if (!chatMsgs || chatMsgs.length === 0) {
-      return state(null);
-    }
-    const ac = new AbortController();
-    async function* pumpAndCollect() {
-      let accumulated = "";
-      let index = 0;
-      try {
-        for await (const token of adapter.stream(chatMsgs, {
-          model: opts?.model,
-          temperature: opts?.temperature,
-          maxTokens: opts?.maxTokens,
-          systemPrompt: opts?.systemPrompt,
-          signal: ac.signal
-        })) {
-          accumulated += token;
-          streamTopic.publish({
-            source: sourceName,
-            token,
-            accumulated,
-            index: index++
-          });
-        }
-        let result;
-        if (format === "json") {
-          try {
-            result = JSON.parse(stripFences(accumulated));
-          } catch {
-            result = null;
-          }
-        } else {
-          result = accumulated;
-        }
-        yield result;
-      } finally {
-        ac.abort();
-      }
-    }
-    return fromAny(pumpAndCollect());
-  });
-  const unsub = keepalive(output);
-  const nonNullOutput = derived(
-    [output],
-    ([v]) => {
-      if (v == null) return void 0;
-      return v;
-    },
-    {
-      name: `${name}/filter`
-    }
-  );
-  graph.add(`${name}/raw`, nonNullOutput);
-  const gateCtrl = gate(graph, `${name}/gate`, `${name}/raw`, opts?.gate);
-  const originalReject = gateCtrl.reject.bind(gateCtrl);
-  const gateWithAbort = {
-    ...gateCtrl,
-    reject(count = 1) {
-      originalReject(count);
-      cancelSignal.down([[DATA, ++cancelCounter]]);
-    }
-  };
-  return {
-    output: gateCtrl.node,
-    stream: streamTopic,
-    gate: gateWithAbort,
-    dispose: () => {
-      unsub();
-      streamTopic.destroy();
-    }
-  };
-}
-function extractContent(resp) {
-  if (resp != null && typeof resp === "object" && "content" in resp) {
-    return String(resp.content);
-  }
-  if (typeof resp === "string") return resp;
-  return String(resp);
-}
-function promptNode(adapter, deps, prompt, opts) {
-  const format = opts?.format ?? "text";
-  const retries = opts?.retries ?? 0;
-  const useCache = opts?.cache ?? false;
-  const cache = useCache ? /* @__PURE__ */ new Map() : null;
-  const messagesNode = derived(
-    deps,
-    (values) => {
-      if (values.some((v) => v == null)) return [];
-      const text = typeof prompt === "string" ? prompt : prompt(...values);
-      if (!text) return [];
-      const msgs = [];
-      if (opts?.systemPrompt) msgs.push({ role: "system", content: opts.systemPrompt });
-      msgs.push({ role: "user", content: text });
-      return msgs;
-    },
-    {
-      name: opts?.name ? `${opts.name}::messages` : "prompt_node::messages",
-      meta: aiMeta("prompt_node"),
-      initial: []
-    }
-  );
-  const result = switchMap(messagesNode, (msgs) => {
-    if (!msgs || msgs.length === 0) {
-      return state(null);
-    }
-    const cacheKey = useCache ? JSON.stringify(msgs.map((m) => [m.role, m.content])) : "";
-    if (cache?.has(cacheKey)) {
-      return state(cache.get(cacheKey));
-    }
-    async function attempt(remaining) {
-      try {
-        const resp = await new Promise((resolve, reject) => {
-          const input = adapter.invoke(msgs, {
-            model: opts?.model,
-            temperature: opts?.temperature,
-            maxTokens: opts?.maxTokens,
-            systemPrompt: opts?.systemPrompt
-          });
-          if (input && typeof input.then === "function") {
-            input.then(resolve, reject);
-          } else if (input && typeof input.subscribe === "function") {
-            resolve(input.cache);
-          } else {
-            resolve(input);
-          }
-        });
-        const content = extractContent(resp);
-        let parsed;
-        if (format === "json") {
-          parsed = JSON.parse(stripFences(content));
-        } else {
-          parsed = content;
-        }
-        cache?.set(cacheKey, parsed);
-        return parsed;
-      } catch (err) {
-        if (remaining > 0) return attempt(remaining - 1);
-        throw err;
-      }
-    }
-    return attempt(retries);
-  });
-  return result;
-}
-var ChatStreamGraph = class extends Graph {
-  _log;
-  messages;
-  latest;
-  messageCount;
-  constructor(name, opts = {}) {
-    super(name, opts.graph);
-    this._log = reactiveLog([], {
-      name: "messages",
-      maxSize: opts.maxMessages
-    });
-    this.messages = this._log.entries;
-    this.add("messages", this.messages);
-    this.latest = derived(
-      [this.messages],
-      ([snapshot]) => {
-        const entries = snapshot;
-        return entries.length === 0 ? null : entries[entries.length - 1];
-      },
-      {
-        name: "latest",
-        describeKind: "derived",
-        meta: aiMeta("chat_latest")
-      }
-    );
-    this.add("latest", this.latest);
-    this.addDisposer(keepalive(this.latest));
-    this.messageCount = derived(
-      [this.messages],
-      ([snapshot]) => snapshot.length,
-      {
-        name: "messageCount",
-        describeKind: "derived",
-        meta: aiMeta("chat_message_count"),
-        initial: 0
-      }
-    );
-    this.add("messageCount", this.messageCount);
-    this.addDisposer(keepalive(this.messageCount));
-  }
-  append(role, content, extra) {
-    this._log.append({ role, content, ...extra });
-  }
-  appendToolResult(callId, content) {
-    this._log.append({ role: "tool", content, toolCallId: callId });
-  }
-  clear() {
-    this._log.clear();
-  }
-  allMessages() {
-    return this.messages.cache;
-  }
-};
-function chatStream(name, opts) {
-  return new ChatStreamGraph(name, opts);
-}
-var ToolRegistryGraph = class extends Graph {
-  definitions;
-  schemas;
-  constructor(name, opts = {}) {
-    super(name, opts.graph);
-    this.definitions = state(/* @__PURE__ */ new Map(), {
-      name: "definitions",
-      describeKind: "state",
-      meta: aiMeta("tool_definitions")
-    });
-    this.add("definitions", this.definitions);
-    this.schemas = derived(
-      [this.definitions],
-      ([defs]) => [...(defs ?? /* @__PURE__ */ new Map()).values()],
-      {
-        name: "schemas",
-        describeKind: "derived",
-        meta: aiMeta("tool_schemas"),
-        initial: []
-      }
-    );
-    this.add("schemas", this.schemas);
-    this.addDisposer(keepalive(this.schemas));
-  }
-  register(tool) {
-    const current = this.definitions.cache;
-    const next = new Map(current);
-    next.set(tool.name, tool);
-    this.definitions.down([[DATA, next]]);
-  }
-  unregister(name) {
-    const current = this.definitions.cache;
-    if (!current.has(name)) return;
-    const next = new Map(current);
-    next.delete(name);
-    this.definitions.down([[DATA, next]]);
-  }
-  async execute(name, args) {
-    const defs = this.definitions.cache;
-    const tool = defs.get(name);
-    if (!tool) throw new Error(`toolRegistry: unknown tool "${name}"`);
-    const raw = tool.handler(args);
-    return resolveToolHandlerResult(raw);
-  }
-  getDefinition(name) {
-    return this.definitions.cache?.get(name);
-  }
-};
-function toolRegistry(name, opts) {
-  return new ToolRegistryGraph(name, opts);
-}
-function systemPromptBuilder(sections, opts) {
-  const separator = opts?.separator ?? "\n\n";
-  const sectionNodes = sections.map((s) => typeof s === "string" ? state(s) : fromAny(s));
-  const prompt = derived(
-    sectionNodes,
-    (values) => values.filter((v) => v != null && v !== "").join(separator),
-    {
-      name: opts?.name ?? "systemPrompt",
-      describeKind: "derived",
-      meta: aiMeta("system_prompt"),
-      initial: ""
-    }
-  );
-  const unsub = keepalive(prompt);
-  return Object.assign(prompt, { dispose: unsub });
-}
-function llmExtractor(systemPrompt, opts) {
-  return (raw, existing) => {
-    const existingKeys = [...existing.keys()].slice(0, 100);
-    const messages = [
-      { role: "system", content: systemPrompt },
-      {
-        role: "user",
-        content: JSON.stringify({
-          input: raw,
-          existingKeys
-        })
-      }
-    ];
-    return producer((actions) => {
-      let active = true;
-      const result = opts.adapter.invoke(messages, {
-        model: opts.model,
-        temperature: opts.temperature ?? 0,
-        maxTokens: opts.maxTokens
-      });
-      const resolved = fromAny(result);
-      const unsub = resolved.subscribe((msgs) => {
-        if (!active) return;
-        let done = false;
-        for (const msg of msgs) {
-          if (done) break;
-          if (msg[0] === DATA) {
-            const response = msg[1];
-            try {
-              const parsed = JSON.parse(response.content);
-              actions.emit(parsed);
-              actions.down([[COMPLETE]]);
-            } catch {
-              actions.down([
-                [ERROR, new Error("llmExtractor: failed to parse LLM response as JSON")]
-              ]);
-            }
-            done = true;
-          } else if (msg[0] === ERROR) {
-            actions.down([[ERROR, msg[1]]]);
-            done = true;
-          } else if (msg[0] === COMPLETE) {
-            actions.down([[COMPLETE]]);
-            done = true;
-          } else {
-            actions.down([[msg[0], msg[1]]]);
-          }
-        }
-      });
-      return () => {
-        unsub();
-        active = false;
-      };
-    });
-  };
-}
-function llmConsolidator(systemPrompt, opts) {
-  return (entries) => {
-    const entriesArray = [...entries.entries()].map(([key, value]) => ({ key, value }));
-    const messages = [
-      { role: "system", content: systemPrompt },
-      { role: "user", content: JSON.stringify({ memories: entriesArray }) }
-    ];
-    return producer((actions) => {
-      let active = true;
-      const result = opts.adapter.invoke(messages, {
-        model: opts.model,
-        temperature: opts.temperature ?? 0,
-        maxTokens: opts.maxTokens
-      });
-      const resolved = fromAny(result);
-      const unsub = resolved.subscribe((msgs) => {
-        if (!active) return;
-        let done = false;
-        for (const msg of msgs) {
-          if (done) break;
-          if (msg[0] === DATA) {
-            const response = msg[1];
-            try {
-              const parsed = JSON.parse(response.content);
-              actions.emit(parsed);
-              actions.down([[COMPLETE]]);
-            } catch {
-              actions.down([
-                [ERROR, new Error("llmConsolidator: failed to parse LLM response as JSON")]
-              ]);
-            }
-            done = true;
-          } else if (msg[0] === ERROR) {
-            actions.down([[ERROR, msg[1]]]);
-            done = true;
-          } else if (msg[0] === COMPLETE) {
-            actions.down([[COMPLETE]]);
-            done = true;
-          } else {
-            actions.down([[msg[0], msg[1]]]);
-          }
-        }
-      });
-      return () => {
-        unsub();
-        active = false;
-      };
-    });
-  };
-}
-function defaultAdmissionScorer(_raw) {
-  return { persistence: 0.5, structure: 0.5, personalValue: 0.5 };
-}
-function admissionFilter3D(opts = {}) {
-  const scoreFn = opts.scoreFn ?? defaultAdmissionScorer;
-  const pThresh = opts.persistenceThreshold ?? 0.3;
-  const pvThresh = opts.personalValueThreshold ?? 0.3;
-  const reqStructured = opts.requireStructured ?? false;
-  return (raw) => {
-    const scores = scoreFn(raw);
-    if (scores.persistence < pThresh) return false;
-    if (scores.personalValue < pvThresh) return false;
-    if (reqStructured && scores.structure <= 0) return false;
-    return true;
-  };
-}
-var DEFAULT_DECAY_RATE = Math.LN2 / (7 * 86400);
-function extractStoreMap(snapshot) {
-  if (snapshot instanceof Map) return snapshot;
-  return /* @__PURE__ */ new Map();
-}
-function agentMemory(name, source, opts) {
-  const graph = new Graph(name, opts.graph);
-  const keepaliveSubs = [];
-  let rawExtractFn;
-  if (opts.extractFn) {
-    rawExtractFn = opts.extractFn;
-  } else if (opts.adapter && opts.extractPrompt) {
-    rawExtractFn = llmExtractor(opts.extractPrompt, { adapter: opts.adapter });
-  } else {
-    throw new Error("agentMemory: provide either extractFn or adapter + extractPrompt");
-  }
-  const extractFn = (raw, existing) => {
-    if (raw == null) return { upsert: [] };
-    return rawExtractFn(raw, existing);
-  };
-  let filteredSource = source;
-  if (opts.admissionFilter) {
-    const srcNode = fromAny(source);
-    const filter2 = opts.admissionFilter;
-    filteredSource = derived(
-      [srcNode],
-      ([raw]) => {
-        if (filter2(raw)) return raw;
-        return void 0;
-      },
-      { name: "admissionFilter", describeKind: "derived" }
-    );
-  }
-  let consolidateFn;
-  if (opts.consolidateFn) {
-    consolidateFn = opts.consolidateFn;
-  } else if (opts.adapter && opts.consolidatePrompt) {
-    consolidateFn = llmConsolidator(opts.consolidatePrompt, { adapter: opts.adapter });
-  }
-  let consolidateTrigger = opts.consolidateTrigger;
-  if (!consolidateTrigger && consolidateFn && opts.reflection?.enabled !== false) {
-    const interval2 = opts.reflection?.interval ?? 3e5;
-    consolidateTrigger = fromTimer(interval2, { period: interval2 });
-  }
-  const distillOpts = {
-    score: opts.score,
-    cost: opts.cost,
-    budget: opts.budget ?? 2e3,
-    context: opts.context,
-    consolidate: consolidateFn,
-    consolidateTrigger
-  };
-  const distillBundle = distill(filteredSource, extractFn, distillOpts);
-  graph.add("store", distillBundle.store.entries);
-  graph.add("compact", distillBundle.compact);
-  graph.add("size", distillBundle.size);
-  let vectors = null;
-  if (opts.vectorDimensions && opts.vectorDimensions > 0 && opts.embedFn) {
-    vectors = vectorIndex({ dimension: opts.vectorDimensions });
-    graph.add("vectorIndex", vectors.entries);
-  }
-  let kg = null;
-  if (opts.enableKnowledgeGraph) {
-    kg = knowledgeGraph(`${name}-kg`);
-    graph.mount("kg", kg);
-  }
-  let memoryTiersBundle = null;
-  if (opts.tiers) {
-    const tiersOpts = opts.tiers;
-    const decayRate = tiersOpts.decayRate ?? DEFAULT_DECAY_RATE;
-    const maxActive = tiersOpts.maxActive ?? 1e3;
-    const archiveThreshold = tiersOpts.archiveThreshold ?? 0.1;
-    const permanentFilter = tiersOpts.permanentFilter ?? (() => false);
-    const permanent = lightCollection({ name: "permanent" });
-    graph.add("permanent", permanent.entries);
-    const permanentKeys = /* @__PURE__ */ new Set();
-    const tierOf = (key) => {
-      if (permanentKeys.has(key)) return "permanent";
-      const storeMap = extractStoreMap(distillBundle.store.entries.cache);
-      if (storeMap.has(key)) return "active";
-      return "archived";
-    };
-    const markPermanent = (key, value) => {
-      permanentKeys.add(key);
-      permanent.upsert(key, value);
-    };
-    const entryCreatedAtNs = /* @__PURE__ */ new Map();
-    const storeNode = distillBundle.store.entries;
-    const contextNode = opts.context ? fromAny(opts.context) : state(null);
-    const tierClassifier = effect([storeNode, contextNode], ([snapshot, ctx]) => {
-      const storeMap = extractStoreMap(snapshot);
-      const nowNs = monotonicNs();
-      const toArchive = [];
-      const toPermanent = [];
-      for (const [key, mem] of storeMap) {
-        if (!entryCreatedAtNs.has(key)) {
-          entryCreatedAtNs.set(key, nowNs);
-        }
-        if (permanentFilter(key, mem)) {
-          toPermanent.push({ key, value: mem });
-          continue;
-        }
-        const baseScore = opts.score(mem, ctx);
-        const createdNs = entryCreatedAtNs.get(key) ?? nowNs;
-        const ageSeconds = Number(nowNs - createdNs) / 1e9;
-        const decayed = decay(baseScore, ageSeconds, decayRate);
-        if (decayed < archiveThreshold) {
-          toArchive.push(key);
-        }
-      }
-      for (const key of entryCreatedAtNs.keys()) {
-        if (!storeMap.has(key)) entryCreatedAtNs.delete(key);
-      }
-      for (const { key, value } of toPermanent) {
-        if (!permanentKeys.has(key)) {
-          markPermanent(key, value);
-        }
-      }
-      const activeCount = storeMap.size - permanentKeys.size;
-      if (activeCount > maxActive) {
-        const scored = [...storeMap.entries()].filter(([k]) => !permanentKeys.has(k)).map(([k, m]) => ({ key: k, score: opts.score(m, ctx) })).sort((a, b) => a.score - b.score);
-        const excess = activeCount - maxActive;
-        for (let i = 0; i < excess && i < scored.length; i++) {
-          const sk = scored[i].key;
-          if (!toArchive.includes(sk)) toArchive.push(sk);
-        }
-      }
-      if (toArchive.length > 0) {
-        batch(() => {
-          for (const key of toArchive) {
-            distillBundle.store.delete(key);
-          }
-        });
-      }
-    });
-    keepaliveSubs.push(tierClassifier.subscribe(() => void 0));
-    let archiveHandle = null;
-    if (tiersOpts.archiveTier) {
-      archiveHandle = graph.attachStorage(
-        [tiersOpts.archiveTier],
-        tiersOpts.archiveStorageOptions ?? {}
-      );
-    }
-    memoryTiersBundle = {
-      permanent,
-      activeEntries: storeNode,
-      archiveHandle,
-      tierOf,
-      markPermanent
-    };
-  }
-  if (vectors || kg) {
-    const embedFn = opts.embedFn;
-    const entityFn = opts.entityFn;
-    const storeNode = distillBundle.store.entries;
-    const indexer = effect([storeNode], ([snapshot]) => {
-      const storeMap = extractStoreMap(snapshot);
-      for (const [key, mem] of storeMap) {
-        if (vectors && embedFn) {
-          const vec = embedFn(mem);
-          if (vec) vectors.upsert(key, vec, mem);
-        }
-        if (kg && entityFn) {
-          const extracted = entityFn(key, mem);
-          if (extracted) {
-            for (const ent of extracted.entities ?? []) {
-              kg.upsertEntity(ent.id, ent.value);
-            }
-            for (const rel of extracted.relations ?? []) {
-              kg.link(rel.from, rel.to, rel.relation, rel.weight);
-            }
-          }
-        }
-      }
-    });
-    keepaliveSubs.push(indexer.subscribe(() => void 0));
-  }
-  let retrievalNode = null;
-  let retrievalTraceNode = null;
-  let retrieveFn = null;
-  if (vectors || kg) {
-    const topK = opts.retrieval?.topK ?? 20;
-    const graphDepth = opts.retrieval?.graphDepth ?? 1;
-    const budget = opts.budget ?? 2e3;
-    const costFn = opts.cost;
-    const scoreFn = opts.score;
-    const contextNode = opts.context ? fromAny(opts.context) : state(null);
-    const retrievalOutput = state([], {
-      name: "retrieval",
-      describeKind: "state",
-      meta: aiMeta("retrieval_pipeline")
-    });
-    graph.add("retrieval", retrievalOutput);
-    retrievalNode = retrievalOutput;
-    const traceState = state(null, {
-      name: "retrievalTrace",
-      describeKind: "state",
-      meta: aiMeta("retrieval_trace")
-    });
-    graph.add("retrievalTrace", traceState);
-    retrievalTraceNode = traceState;
-    retrieveFn = (query) => {
-      const storeMap = extractStoreMap(distillBundle.store.entries.cache);
-      const ctx = contextNode.cache;
-      const candidateMap = /* @__PURE__ */ new Map();
-      let vectorCandidates = [];
-      if (vectors && query.vector) {
-        vectorCandidates = vectors.search(query.vector, topK);
-        for (const vc of vectorCandidates) {
-          const mem = storeMap.get(vc.id);
-          if (mem) {
-            candidateMap.set(vc.id, { value: mem, sources: /* @__PURE__ */ new Set(["vector"]) });
-          }
-        }
-      }
-      const graphExpanded = [];
-      if (kg) {
-        const seedIds = [...query.entityIds ?? [], ...[...candidateMap.keys()]];
-        const visited = /* @__PURE__ */ new Set();
-        let frontier = seedIds;
-        for (let depth = 0; depth < graphDepth; depth++) {
-          const nextFrontier = [];
-          for (const id of frontier) {
-            if (visited.has(id)) continue;
-            visited.add(id);
-            const related = kg.related(id);
-            for (const edge of related) {
-              const targetId = edge.to;
-              if (!visited.has(targetId)) {
-                nextFrontier.push(targetId);
-                const mem = storeMap.get(targetId);
-                if (mem) {
-                  const existing = candidateMap.get(targetId);
-                  if (existing) {
-                    existing.sources.add("graph");
-                  } else {
-                    candidateMap.set(targetId, { value: mem, sources: /* @__PURE__ */ new Set(["graph"]) });
-                  }
-                  graphExpanded.push(targetId);
-                }
-              }
-            }
-          }
-          frontier = nextFrontier;
-        }
-      }
-      for (const [key, mem] of storeMap) {
-        if (!candidateMap.has(key)) {
-          candidateMap.set(key, { value: mem, sources: /* @__PURE__ */ new Set(["store"]) });
-        }
-      }
-      const ranked = [];
-      for (const [key, { value, sources }] of candidateMap) {
-        const score = scoreFn(value, ctx);
-        ranked.push({ key, value, score, sources: [...sources] });
-      }
-      ranked.sort((a, b) => b.score - a.score);
-      const packed = [];
-      let usedBudget = 0;
-      for (const entry of ranked) {
-        const c = costFn(entry.value);
-        if (usedBudget + c > budget && packed.length > 0) break;
-        packed.push(entry);
-        usedBudget += c;
-      }
-      const trace = {
-        vectorCandidates,
-        graphExpanded,
-        ranked,
-        packed
-      };
-      batch(() => {
-        retrievalOutput.down([[DATA, packed]]);
-        traceState.down([[DATA, trace]]);
-      });
-      return packed;
-    };
-  }
-  graph.addDisposer(() => {
-    for (const unsub of keepaliveSubs) unsub();
-    keepaliveSubs.length = 0;
-  });
-  return Object.assign(graph, {
-    distillBundle,
-    compact: distillBundle.compact,
-    size: distillBundle.size,
-    vectors,
-    kg,
-    memoryTiers: memoryTiersBundle,
-    retrieval: retrievalNode,
-    retrievalTrace: retrievalTraceNode,
-    retrieve: retrieveFn
-  });
-}
-var AgentLoopGraph = class extends Graph {
-  chat;
-  tools;
-  status;
-  turnCount;
-  lastResponse;
-  _statusState;
-  _turnCountState;
-  _adapter;
-  _maxTurns;
-  _stopWhen;
-  _onToolCall;
-  _systemPrompt;
-  _model;
-  _temperature;
-  _maxTokens;
-  _running = false;
-  _abortController = null;
-  constructor(name, opts) {
-    super(name, opts.graph);
-    this._adapter = opts.adapter;
-    this._maxTurns = opts.maxTurns ?? 10;
-    this._stopWhen = opts.stopWhen;
-    this._onToolCall = opts.onToolCall;
-    this._systemPrompt = opts.systemPrompt;
-    this._model = opts.model;
-    this._temperature = opts.temperature;
-    this._maxTokens = opts.maxTokens;
-    this.chat = chatStream(`${name}-chat`, { maxMessages: opts.maxMessages });
-    this.mount("chat", this.chat);
-    this.tools = toolRegistry(`${name}-tools`);
-    this.mount("tools", this.tools);
-    if (opts.tools) {
-      for (const tool of opts.tools) {
-        this.tools.register(tool);
-      }
-    }
-    this._statusState = state("idle", {
-      name: "status",
-      describeKind: "state",
-      meta: aiMeta("agent_status")
-    });
-    this.status = this._statusState;
-    this.add("status", this.status);
-    this._turnCountState = state(0, {
-      name: "turnCount",
-      describeKind: "state",
-      meta: aiMeta("agent_turn_count")
-    });
-    this.turnCount = this._turnCountState;
-    this.add("turnCount", this.turnCount);
-    this.lastResponse = state(null, {
-      name: "lastResponse",
-      describeKind: "state",
-      meta: aiMeta("agent_last_response")
-    });
-    this.add("lastResponse", this.lastResponse);
-  }
-  /**
-   * Start the agent loop with a user message. The loop runs reactively:
-   * think (LLM call) → act (tool execution) → repeat until done.
-   *
-   * Messages accumulate across calls. Call `chat.clear()` before `run()`
-   * to reset conversation history.
-   */
-  async run(userMessage) {
-    if (this._running) throw new Error("agentLoop: already running");
-    this._running = true;
-    this._abortController = new AbortController();
-    const { signal } = this._abortController;
-    batch(() => {
-      this._statusState.down([[DATA, "idle"]]);
-      this._turnCountState.down([[DATA, 0]]);
-    });
-    this.chat.append("user", userMessage);
-    try {
-      let turns = 0;
-      while (turns < this._maxTurns) {
-        if (signal.aborted) throw new Error("agentLoop: aborted");
-        turns++;
-        batch(() => {
-          this._turnCountState.down([[DATA, turns]]);
-          this._statusState.down([[DATA, "thinking"]]);
-        });
-        const msgs = this.chat.allMessages();
-        const toolSchemas = this.tools.schemas.cache ?? [];
-        const response = await this._invokeLLM(msgs, toolSchemas, signal);
-        if (signal.aborted) throw new Error("agentLoop: aborted");
-        this.lastResponse.down([[DATA, response]]);
-        this.chat.append("assistant", response.content, {
-          toolCalls: response.toolCalls
-        });
-        if (this._shouldStop(response)) {
-          this._statusState.down([[DATA, "done"]]);
-          this._running = false;
-          this._abortController = null;
-          return response;
-        }
-        if (response.toolCalls && response.toolCalls.length > 0) {
-          this._statusState.down([[DATA, "acting"]]);
-          for (const call of response.toolCalls) {
-            if (signal.aborted) throw new Error("agentLoop: aborted");
-            this._onToolCall?.(call);
-            try {
-              const result = await this.tools.execute(call.name, call.arguments);
-              this.chat.appendToolResult(call.id, JSON.stringify(result));
-            } catch (err) {
-              this.chat.appendToolResult(call.id, JSON.stringify({ error: String(err) }));
-            }
-          }
-        } else {
-          this._statusState.down([[DATA, "done"]]);
-          this._running = false;
-          this._abortController = null;
-          return response;
-        }
-      }
-      this._statusState.down([[DATA, "done"]]);
-      this._running = false;
-      this._abortController = null;
-      return this.lastResponse.cache;
-    } catch (err) {
-      this._statusState.down([[DATA, "error"]]);
-      this._running = false;
-      this._abortController = null;
-      throw err;
-    }
-  }
-  async _invokeLLM(msgs, tools, signal) {
-    const result = this._adapter.invoke(msgs, {
-      tools: tools.length > 0 ? tools : void 0,
-      systemPrompt: this._systemPrompt,
-      model: this._model,
-      temperature: this._temperature,
-      maxTokens: this._maxTokens,
-      signal
-    });
-    if (result == null) {
-      throw new Error("_invokeLLM: adapter.invoke() returned null or undefined");
-    }
-    if (typeof result === "string") {
-      throw new Error("_invokeLLM: adapter.invoke() returned a string, expected LLMResponse");
-    }
-    if (typeof result === "object" && "content" in result && !("subscribe" in result) && !("then" in result)) {
-      return result;
-    }
-    if (isPromiseLike(result)) {
-      const awaited = await result;
-      if (typeof awaited === "object" && awaited !== null && "content" in awaited && !("subscribe" in awaited)) {
-        return awaited;
-      }
-      return firstDataFromNode(fromAny(awaited));
-    }
-    return firstDataFromNode(fromAny(result));
-  }
-  _shouldStop(response) {
-    if (response.finishReason === "end_turn" && (!response.toolCalls || response.toolCalls.length === 0))
-      return true;
-    if (this._stopWhen?.(response)) return true;
-    return false;
-  }
-  destroy() {
-    if (this._abortController) {
-      this._abortController.abort();
-      this._abortController = null;
-    }
-    this._running = false;
-    super.destroy();
-  }
-};
-function agentLoop(name, opts) {
-  return new AgentLoopGraph(name, opts);
-}
-function metaToJsonSchema(meta) {
-  const schema = {};
-  const metaType = meta.type;
-  if (metaType === "enum" && Array.isArray(meta.values)) {
-    schema.type = "string";
-    schema.enum = meta.values;
-  } else if (metaType === "integer") {
-    schema.type = "integer";
-  } else if (metaType === "number") {
-    schema.type = "number";
-  } else if (metaType === "boolean") {
-    schema.type = "boolean";
-  } else if (metaType === "string") {
-    schema.type = "string";
-  } else {
-    schema.type = ["string", "number", "boolean"];
-  }
-  if (Array.isArray(meta.range) && meta.range.length === 2) {
-    schema.minimum = meta.range[0];
-    schema.maximum = meta.range[1];
-  }
-  if (typeof meta.format === "string") {
-    schema.description = `Format: ${meta.format}`;
-  }
-  if (typeof meta.unit === "string") {
-    if (schema.description) {
-      schema.description += ` (${meta.unit})`;
-    } else {
-      schema.description = `Unit: ${meta.unit}`;
-    }
-  }
-  return schema;
-}
-function knobsAsTools(graph, actor) {
-  const described = graph.describe({ actor, detail: "full" });
-  const openai = [];
-  const mcp = [];
-  const definitions = [];
-  for (const [path, node2] of Object.entries(described.nodes)) {
-    if (node2.type !== "state") continue;
-    if (path.includes("::__meta__::")) continue;
-    if (node2.status === "completed" || node2.status === "errored") continue;
-    const meta = node2.meta ?? {};
-    const access = meta.access;
-    if (access === "human" || access === "system") continue;
-    const description = meta.description ?? `Set the value of ${path}`;
-    const valueSchema = metaToJsonSchema(meta);
-    const parameterSchema = {
-      type: "object",
-      required: ["value"],
-      properties: {
-        value: valueSchema
-      },
-      additionalProperties: false
-    };
-    const sanitizedName = path.replace(/::/g, "__");
-    openai.push({
-      type: "function",
-      function: {
-        name: sanitizedName,
-        description,
-        parameters: parameterSchema
-      }
-    });
-    mcp.push({
-      name: path,
-      description,
-      inputSchema: parameterSchema
-    });
-    const graphRef = graph;
-    const actorRef = actor;
-    const nv = node2.v;
-    definitions.push({
-      name: path,
-      description,
-      parameters: parameterSchema,
-      handler(args) {
-        graphRef.set(path, args.value, actorRef ? { actor: actorRef } : void 0);
-        return args.value;
-      },
-      ...nv != null ? { version: { id: nv.id, version: nv.version } } : {}
-    });
-  }
-  return { openai, mcp, definitions };
-}
-function gaugesAsContext(graph, actor, options) {
-  const described = graph.describe({ actor, detail: "full" });
-  const groupByTags = options?.groupByTags ?? true;
-  const separator = options?.separator ?? "\n";
-  const entries = [];
-  const sinceVersion = options?.sinceVersion;
-  for (const [path, node2] of Object.entries(described.nodes)) {
-    const meta = node2.meta ?? {};
-    const desc = meta.description;
-    const format = meta.format;
-    if (!desc && !format) continue;
-    if (sinceVersion != null && node2.v != null) {
-      const lastSeen = sinceVersion.get(path);
-      if (lastSeen != null && lastSeen.id === node2.v.id && node2.v.version <= lastSeen.version)
-        continue;
-    }
-    const label = desc ?? path;
-    const value = node2.value;
-    const unit = meta.unit;
-    let formatted;
-    if (format === "currency" && typeof value === "number") {
-      formatted = `$${value.toFixed(2)}`;
-    } else if (format === "percentage" && typeof value === "number") {
-      formatted = `${(value * 100).toFixed(1)}%`;
-    } else if (value === void 0 || value === null) {
-      formatted = "(no value)";
-    } else {
-      formatted = String(value);
-    }
-    if (unit && format !== "currency" && format !== "percentage") {
-      formatted = `${formatted} ${unit}`;
-    }
-    entries.push({ path, description: label, formatted });
-  }
-  if (entries.length === 0) return "";
-  if (groupByTags) {
-    const tagGroups = /* @__PURE__ */ new Map();
-    const ungrouped = [];
-    for (const entry of entries) {
-      const node2 = described.nodes[entry.path];
-      const tags = node2.meta?.tags;
-      if (tags && tags.length > 0) {
-        const tag = tags[0];
-        let group = tagGroups.get(tag);
-        if (!group) {
-          group = [];
-          tagGroups.set(tag, group);
-        }
-        group.push(entry);
-      } else {
-        ungrouped.push(entry);
-      }
-    }
-    if (tagGroups.size === 0) {
-      return entries.map((e) => `- ${e.description}: ${e.formatted}`).join(separator);
-    }
-    const sections = [];
-    for (const [tag, group] of [...tagGroups.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
-      sections.push(
-        `[${tag}]${separator}${group.map((e) => `- ${e.description}: ${e.formatted}`).join(separator)}`
-      );
-    }
-    if (ungrouped.length > 0) {
-      sections.push(ungrouped.map((e) => `- ${e.description}: ${e.formatted}`).join(separator));
-    }
-    return sections.join(separator + separator);
-  }
-  return entries.map((e) => `- ${e.description}: ${e.formatted}`).join(separator);
-}
-var VALID_NODE_TYPES = /* @__PURE__ */ new Set(["state", "derived", "producer", "operator", "effect"]);
-function validateGraphDef(def) {
-  const errors = [];
-  if (def == null || typeof def !== "object") {
-    return { valid: false, errors: ["Definition must be a non-null object"] };
-  }
-  const d = def;
-  if (typeof d.name !== "string" || d.name.length === 0) {
-    errors.push("Missing or empty 'name' field");
-  }
-  if (d.nodes == null || typeof d.nodes !== "object" || Array.isArray(d.nodes)) {
-    errors.push("Missing or invalid 'nodes' field (must be an object)");
-    return { valid: false, errors };
-  }
-  const nodeNames = new Set(Object.keys(d.nodes));
-  for (const [name, raw] of Object.entries(d.nodes)) {
-    if (raw == null || typeof raw !== "object") {
-      errors.push(`Node "${name}": must be an object`);
-      continue;
-    }
-    const node2 = raw;
-    if (typeof node2.type !== "string" || !VALID_NODE_TYPES.has(node2.type)) {
-      errors.push(
-        `Node "${name}": invalid type "${String(node2.type)}" (expected: ${[...VALID_NODE_TYPES].join(", ")})`
-      );
-    }
-    if (Array.isArray(node2.deps)) {
-      for (const dep of node2.deps) {
-        if (typeof dep === "string" && !nodeNames.has(dep)) {
-          errors.push(`Node "${name}": dep "${dep}" does not reference an existing node`);
-        }
-      }
-    }
-  }
-  if (!Array.isArray(d.edges)) {
-    if (d.edges !== void 0) {
-      errors.push("'edges' must be an array");
-    }
-  } else {
-    const seen = /* @__PURE__ */ new Set();
-    for (let i = 0; i < d.edges.length; i++) {
-      const edge = d.edges[i];
-      if (edge == null || typeof edge !== "object") {
-        errors.push(`Edge [${i}]: must be an object`);
-        continue;
-      }
-      const e = edge;
-      if (typeof e.from !== "string" || !nodeNames.has(e.from)) {
-        errors.push(`Edge [${i}]: 'from' "${String(e.from)}" does not reference an existing node`);
-      }
-      if (typeof e.to !== "string" || !nodeNames.has(e.to)) {
-        errors.push(`Edge [${i}]: 'to' "${String(e.to)}" does not reference an existing node`);
-      }
-      const key = `${e.from}->${e.to}`;
-      if (seen.has(key)) {
-        errors.push(`Edge [${i}]: duplicate edge ${key}`);
-      }
-      seen.add(key);
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-function stripFences(text) {
-  const match = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```[\s\S]*$/);
-  return match ? match[1] : text;
-}
-var GRAPH_FROM_SPEC_SYSTEM_PROMPT = `You are a graph architect for GraphReFly, a reactive graph protocol.
-
-Given a natural-language description, produce a JSON graph definition with this structure:
-
-{
-  "name": "<graph_name>",
-  "nodes": {
-    "<node_name>": {
-      "type": "state" | "derived" | "producer" | "operator" | "effect",
-      "value": <initial_value_or_null>,
-      "deps": ["<dep_node_name>", ...],
-      "meta": {
-        "description": "<human-readable purpose>",
-        "type": "string" | "number" | "boolean" | "integer" | "enum",
-        "range": [min, max],
-        "values": ["a", "b"],
-        "format": "currency" | "percentage" | "status",
-        "access": "human" | "llm" | "both" | "system",
-        "unit": "<unit>",
-        "tags": ["<tag>"]
-      }
-    }
-  },
-  "edges": [
-    { "from": "<source_node>", "to": "<target_node>" }
-  ]
-}
-
-Rules:
-- "state" nodes have no deps and hold user/LLM-writable values (knobs).
-- "derived" nodes have deps and compute from them.
-- "effect" nodes have deps but produce side effects (no return value).
-- "producer" nodes have no deps but generate values asynchronously.
-- Edges wire output of one node as input to another. They must match deps.
-- meta.description is required for every node.
-- Return ONLY valid JSON, no markdown fences or commentary.`;
-async function graphFromSpec(naturalLanguage, adapter, opts) {
-  const systemPrompt = opts?.systemPromptExtra ? `${GRAPH_FROM_SPEC_SYSTEM_PROMPT}
-
-${opts.systemPromptExtra}` : GRAPH_FROM_SPEC_SYSTEM_PROMPT;
-  const messages = [
-    { role: "system", content: systemPrompt },
-    { role: "user", content: naturalLanguage }
-  ];
-  const rawResult = adapter.invoke(messages, {
-    model: opts?.model,
-    temperature: opts?.temperature ?? 0,
-    maxTokens: opts?.maxTokens
-  });
-  const response = await resolveToolHandlerResult(rawResult);
-  let content = response.content.trim();
-  if (content.startsWith("```")) {
-    content = stripFences(content);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    throw new Error(`graphFromSpec: LLM response is not valid JSON: ${content.slice(0, 200)}`);
-  }
-  const validation = validateGraphDef(parsed);
-  if (!validation.valid) {
-    throw new Error(`graphFromSpec: invalid graph definition:
-${validation.errors.join("\n")}`);
-  }
-  const def = parsed;
-  if (def.version === void 0) def.version = 1;
-  if (!Array.isArray(def.subgraphs)) def.subgraphs = [];
-  return Graph.fromSnapshot(def, opts?.build);
-}
-var SUGGEST_STRATEGY_SYSTEM_PROMPT = `You are a reactive graph optimizer for GraphReFly.
-
-Given a graph's current structure (from describe()) and a problem statement, suggest topology and parameter changes to solve the problem.
-
-Return ONLY valid JSON with this structure:
-{
-  "summary": "<one-line summary of the strategy>",
-  "reasoning": "<explanation of why these changes help>",
-  "operations": [
-    { "type": "add_node", "name": "<name>", "nodeType": "state|derived|effect|producer|operator", "meta": {...}, "initial": <value> },
-    { "type": "remove_node", "name": "<name>" },
-    { "type": "connect", "from": "<source>", "to": "<target>" },
-    { "type": "disconnect", "from": "<source>", "to": "<target>" },
-    { "type": "set_value", "name": "<name>", "value": <new_value> },
-    { "type": "update_meta", "name": "<name>", "key": "<meta_key>", "value": <new_value> }
-  ]
-}
-
-Rules:
-- Only suggest operations that reference existing nodes (for remove/disconnect/set_value/update_meta) or new nodes you define (for add_node).
-- Keep changes minimal \u2014 prefer the smallest set of operations that solves the problem.
-- Return ONLY valid JSON, no markdown fences or commentary.`;
-async function suggestStrategy(graph, problem, adapter, opts) {
-  const { expand: _, ...described } = graph.describe({ actor: opts?.actor, detail: "standard" });
-  const messages = [
-    { role: "system", content: SUGGEST_STRATEGY_SYSTEM_PROMPT },
-    {
-      role: "user",
-      content: JSON.stringify({
-        graph: described,
-        problem
-      })
-    }
-  ];
-  const rawResult = adapter.invoke(messages, {
-    model: opts?.model,
-    temperature: opts?.temperature ?? 0,
-    maxTokens: opts?.maxTokens
-  });
-  const response = await resolveToolHandlerResult(rawResult);
-  let content = response.content.trim();
-  if (content.startsWith("```")) {
-    content = content.replace(/^```(?:json)?\s*/, "").replace(/\s*```$/, "");
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    throw new Error(`suggestStrategy: LLM response is not valid JSON: ${content.slice(0, 200)}`);
-  }
-  const plan = parsed;
-  if (typeof plan.summary !== "string") {
-    throw new Error("suggestStrategy: missing 'summary' in response");
-  }
-  if (typeof plan.reasoning !== "string") {
-    throw new Error("suggestStrategy: missing 'reasoning' in response");
-  }
-  if (!Array.isArray(plan.operations)) {
-    throw new Error("suggestStrategy: missing 'operations' array in response");
-  }
-  return {
-    summary: plan.summary,
-    reasoning: plan.reasoning,
-    operations: plan.operations
-  };
-}
+  cached,
+  empty,
+  escapeRegexChar,
+  firstValueFrom,
+  firstWhere,
+  forEach,
+  fromAny,
+  fromAsyncIter,
+  fromCron,
+  fromEvent,
+  fromIter,
+  fromPromise,
+  fromRaf,
+  fromTimer,
+  globToRegExp,
+  keepalive,
+  matchesAnyPattern,
+  matchesCron,
+  never,
+  of,
+  parseCron,
+  reactiveCounter,
+  replay,
+  share,
+  shareReplay,
+  throwError,
+  toArray
+} from "./chunk-BVZYTZ5H.js";
+import {
+  graph_exports,
+  watchTopologyTree
+} from "./chunk-OU5CQKNW.js";
+import {
+  GRAPH_META_SEGMENT,
+  Graph,
+  OVERHEAD,
+  SIZEOF_SYMBOL,
+  SNAPSHOT_VERSION,
+  diffForWAL,
+  explainPath,
+  graphProfile,
+  reachable,
+  sizeof
+} from "./chunk-PF7GRZMW.js";
+import {
+  resolveDescribeFields
+} from "./chunk-VYPWMZ6H.js";
+import {
+  ResettableTimer
+} from "./chunk-7TAQJHQV.js";
+import {
+  DEFAULT_ACTOR,
+  ENVELOPE_VERSION,
+  GraphReFlyConfig,
+  GuardDenied,
+  JsonCodec,
+  NodeImpl,
+  accessHintForGuard,
+  advanceVersion,
+  autoTrackNode,
+  batch,
+  configure,
+  createDagCborCodec,
+  createDagCborZstdCodec,
+  createVersioning,
+  decodeEnvelope,
+  defaultConfig,
+  defaultHash,
+  derived,
+  downWithBatch,
+  dynamicNode,
+  effect,
+  encodeEnvelope,
+  isBatching,
+  isV1,
+  monotonicNs,
+  node,
+  normalizeActor,
+  pipe,
+  policy,
+  policyFromRules,
+  producer,
+  registerBuiltinCodecs,
+  registerBuiltins,
+  replayWAL,
+  state,
+  wallClockNs
+} from "./chunk-PHOUUNK7.js";
+import {
+  COMPLETE,
+  COMPLETE_MSG,
+  COMPLETE_ONLY_BATCH,
+  DATA,
+  DIRTY,
+  DIRTY_MSG,
+  DIRTY_ONLY_BATCH,
+  ERROR,
+  INVALIDATE,
+  INVALIDATE_MSG,
+  INVALIDATE_ONLY_BATCH,
+  PAUSE,
+  RESOLVED,
+  RESOLVED_MSG,
+  RESOLVED_ONLY_BATCH,
+  RESUME,
+  START,
+  START_MSG,
+  TEARDOWN,
+  TEARDOWN_MSG,
+  TEARDOWN_ONLY_BATCH,
+  __export
+} from "./chunk-SX52TAR4.js";
 
-// src/patterns/audit.ts
-var audit_exports = {};
-__export(audit_exports, {
-  AuditTrailGraph: () => AuditTrailGraph,
-  PolicyEnforcerGraph: () => PolicyEnforcerGraph,
-  auditTrail: () => auditTrail,
-  complianceSnapshot: () => complianceSnapshot,
-  policyEnforcer: () => policyEnforcer,
-  reactiveExplainPath: () => reactiveExplainPath
+// src/patterns/index.ts
+var patterns_exports = {};
+__export(patterns_exports, {
+  SNAPSHOT_WIRE_VERSION: () => SNAPSHOT_WIRE_VERSION,
+  SurfaceError: () => SurfaceError,
+  accountability: () => audit_exports,
+  ai: () => ai_exports,
+  asSurfaceError: () => asSurfaceError,
+  cqrs: () => cqrs_exports,
+  createGraph: () => createGraph,
+  deleteSnapshot: () => deleteSnapshot,
+  demoShell: () => demo_shell_exports,
+  diffSnapshots: () => diffSnapshots,
+  domainTemplates: () => domain_templates_exports,
+  graphspec: () => graphspec_exports,
+  guarded: () => guarded_execution_exports,
+  harness: () => harness_exports,
+  layout: () => reactive_layout_exports,
+  lens: () => lens_exports,
+  listSnapshots: () => listSnapshots,
+  memory: () => memory_exports,
+  messaging: () => messaging_exports,
+  orchestration: () => orchestration_exports,
+  reduction: () => reduction_exports,
+  resilientPipeline: () => resilient_pipeline_exports,
+  restoreSnapshot: () => restoreSnapshot,
+  runReduction: () => runReduction,
+  saveSnapshot: () => saveSnapshot,
+  surface: () => surface_exports
 });
-function auditMeta(kind, extra) {
-  return domainMeta("audit", kind, extra);
-}
-var DEFAULT_INCLUDE_TYPES = /* @__PURE__ */ new Set([
-  "data",
-  "error",
-  "complete",
-  "teardown"
-]);
-var AuditTrailGraph = class extends Graph {
-  entries;
-  count;
-  _log;
-  _target;
-  constructor(target, opts) {
-    super(opts.name ?? `${target.name}_audit`, opts.graph);
-    this._target = target;
-    this._log = reactiveLog([], {
-      name: "entries",
-      ...opts.maxSize != null ? { maxSize: opts.maxSize } : {}
-    });
-    this.entries = this._log.entries;
-    this.add("entries", this.entries);
-    this.count = derived(
-      [this.entries],
-      ([snapshot]) => snapshot.length,
-      { name: "count", describeKind: "derived", meta: auditMeta("count") }
-    );
-    this.add("count", this.count);
-    this.addDisposer(keepalive(this.count));
-    const includeTypes = opts.includeTypes != null ? new Set(opts.includeTypes) : DEFAULT_INCLUDE_TYPES;
-    const filter2 = opts.filter;
-    let seq = 0;
-    const handle = target.observe({ timeline: true, structured: true });
-    const offEvent = handle.onEvent((event) => {
-      if (event.type === "derived") return;
-      const type = event.type;
-      if (!includeTypes.has(type)) return;
-      const path = event.path ?? "";
-      const entry = {
-        seq: seq++,
-        timestamp_ns: event.timestamp_ns ?? monotonicNs(),
-        wall_clock_ns: wallClockNs(),
-        path,
-        type
-      };
-      const node2 = path ? safeNode(target, path) : void 0;
-      const lastMutation = node2?.lastMutation;
-      if (lastMutation != null) entry.actor = lastMutation.actor;
-      if (type === "data") entry.value = event.data;
-      if (type === "error") entry.error = event.data;
-      const reason = path ? safeAnnotation(target, path) : void 0;
-      if (reason != null) entry.reason = reason;
-      if (filter2 != null && !filter2(entry)) return;
-      this._log.append(entry);
-    });
-    this.addDisposer(() => {
-      offEvent();
-      handle.dispose();
-    });
-    this.addDisposer(() => this._log.disposeAllViews());
-  }
-  /** All entries currently in the ring (snapshot). */
-  all() {
-    return this.entries.cache ?? [];
-  }
-  /** Entries matching `path`. Order preserved. */
-  byNode(path) {
-    return this.all().filter((e) => e.path === path);
-  }
-  /** Entries whose `actor.id` matches. Use `byActorType` for type filtering. */
-  byActor(actorId) {
-    return this.all().filter((e) => e.actor?.id === actorId);
-  }
-  /** Entries whose `actor.type` matches (e.g. `"llm"`, `"human"`). */
-  byActorType(type) {
-    return this.all().filter((e) => e.actor?.type === type);
-  }
-  /**
-   * Entries with `timestamp_ns` in `[start_ns, end_ns)` (end exclusive).
-   * Omit `end_ns` to query open-ended.
-   */
-  byTimeRange(start_ns, end_ns) {
-    return this.all().filter((e) => {
-      if (e.timestamp_ns < start_ns) return false;
-      if (end_ns != null && e.timestamp_ns >= end_ns) return false;
-      return true;
-    });
-  }
-  /** Reference to the audited graph (escape hatch for tooling). */
-  get target() {
-    return this._target;
-  }
-};
-function auditTrail(target, opts = {}) {
-  return new AuditTrailGraph(target, opts);
-}
-var PolicyEnforcerGraph = class extends Graph {
-  policies;
-  violations;
-  violationCount;
-  _target;
-  _mode;
-  _currentGuard;
-  constructor(target, policies, opts) {
-    super(opts.name ?? `${target.name}_policy`, opts.graph);
-    this._target = target;
-    this._mode = opts.mode ?? "audit";
-    const policiesNode = isNode(policies) ? policies : state(policies, { name: "policies" });
-    this.policies = policiesNode;
-    this.add("policies", this.policies);
-    this.violations = new TopicGraph("violations", {
-      retainedLimit: opts.violationsLimit ?? 1e3
-    });
-    this.mount("violations", this.violations);
-    this.violationCount = derived(
-      [this.violations.events],
-      ([snapshot]) => snapshot.length,
-      {
-        name: "violationCount",
-        describeKind: "derived",
-        meta: auditMeta("policy_violation_count")
-      }
-    );
-    this.add("violationCount", this.violationCount);
-    this.addDisposer(keepalive(this.violationCount));
-    const initialRules = policiesNode.cache ?? [];
-    let latestRules = initialRules;
-    this._currentGuard = policyFromRules(latestRules);
-    const offPolicies = policiesNode.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          latestRules = m[1] ?? [];
-          this._currentGuard = policyFromRules(latestRules);
-        }
-      }
-    });
-    this.addDisposer(offPolicies);
-    const paths = opts.paths != null ? [...opts.paths] : collectPaths(target);
-    if (this._mode === "enforce") {
-      const restorers = /* @__PURE__ */ new Map();
-      const wrapAndPush = (path) => {
-        if (restorers.has(path)) return;
-        const node2 = safeNode(target, path);
-        if (!(node2 instanceof NodeImpl)) return;
-        const pathGuard = (actor, action) => {
-          const ok = this._currentGuard(actor, action);
-          if (!ok) {
-            this._publishViolation(actor, action, path, "blocked");
-          }
-          return ok;
-        };
-        restorers.set(path, node2._pushGuard(pathGuard));
-      };
-      for (const path of paths) wrapAndPush(path);
-      if (opts.paths == null) {
-        const offTopology = watchTopologyTree(target, (event, emitter, prefix) => {
-          if (event.kind === "added") {
-            if (event.nodeKind === "node") {
-              wrapAndPush(`${prefix}${event.name}`);
-            } else {
-              const child = emitter._mounts.get(event.name);
-              if (!(child instanceof Graph)) return;
-              const mountPrefix = `${prefix}${event.name}::`;
-              const localPaths = collectPaths(child);
-              for (const localPath of localPaths) {
-                wrapAndPush(
-                  localPath === "" ? `${prefix}${event.name}` : `${mountPrefix}${localPath}`
-                );
-              }
-            }
-          } else if (event.kind === "removed") {
-            if (event.nodeKind === "node") {
-              const qp = `${prefix}${event.name}`;
-              const r = restorers.get(qp);
-              if (r != null) {
-                r();
-                restorers.delete(qp);
-              }
-            } else {
-              const mountQp = `${prefix}${event.name}`;
-              const mountPrefix = `${mountQp}::`;
-              for (const [p, r] of restorers) {
-                if (p === mountQp || p.startsWith(mountPrefix)) {
-                  r();
-                  restorers.delete(p);
-                }
-              }
-            }
-          }
-        });
-        this.addDisposer(offTopology);
-      } else {
-        const offCleanup = target.topology.subscribe((msgs) => {
-          for (const m of msgs) {
-            if (m[0] !== DATA) continue;
-            const event = m[1];
-            if (event.kind !== "removed" || event.nodeKind !== "node") continue;
-            const r = restorers.get(event.name);
-            if (r != null) {
-              r();
-              restorers.delete(event.name);
-            }
-          }
-        });
-        this.addDisposer(offCleanup);
-      }
-      this.addDisposer(() => {
-        for (const r of restorers.values()) r();
-        restorers.clear();
-      });
-    } else {
-      const handle = target.observe({ timeline: true, structured: true });
-      const off = handle.onEvent((event) => {
-        if (event.type !== "data" && event.type !== "error") return;
-        const path = event.path ?? "";
-        if (!path) return;
-        if (opts.paths != null && !opts.paths.includes(path)) return;
-        const node2 = safeNode(target, path);
-        const lastMutation = node2?.lastMutation;
-        if (lastMutation == null) return;
-        const action = "write";
-        if (this._currentGuard(lastMutation.actor, action)) return;
-        this._publishViolation(lastMutation.actor, action, path, "observed");
-      });
-      this.addDisposer(() => {
-        off();
-        handle.dispose();
-      });
-    }
-  }
-  _publishViolation(actor, action, path, result) {
-    this.violations.publish({
-      timestamp_ns: monotonicNs(),
-      wall_clock_ns: wallClockNs(),
-      path,
-      actor,
-      action,
-      mode: this._mode,
-      result
-    });
-  }
-  /** Snapshot of recorded violations. */
-  all() {
-    return this.violations.retained();
-  }
-  get mode() {
-    return this._mode;
-  }
-  get target() {
-    return this._target;
-  }
-};
-function policyEnforcer(target, policies, opts = {}) {
-  return new PolicyEnforcerGraph(target, policies, opts);
-}
-function reactiveExplainPath(target, from, to, opts) {
-  let v = 0;
-  const version2 = state(v, { name: "explain_version" });
-  const handle = target.observe({ timeline: true, structured: true });
-  const off = handle.onEvent((event) => {
-    const t = event.type;
-    if (t !== "data" && t !== "error" && t !== "complete" && t !== "teardown") return;
-    v += 1;
-    version2.emit(v);
-  });
-  const explainOpts = {
-    ...opts?.maxDepth != null ? { maxDepth: opts.maxDepth } : {},
-    ...opts?.findCycle === true ? { findCycle: true } : {}
-  };
-  const node2 = derived([version2], () => target.explain(from, to, explainOpts), {
-    name: opts?.name ?? "explain",
-    describeKind: "derived",
-    equals: (a, b) => a.found === b.found && a.reason === b.reason && a.steps.length === b.steps.length && causalStepsEqual(a.steps, b.steps),
-    meta: auditMeta("explain_path", { from, to })
-  });
-  const stopKeepalive = keepalive(node2);
-  return {
-    node: node2,
-    dispose() {
-      off();
-      handle.dispose();
-      stopKeepalive();
-    }
-  };
-}
-function causalStepsEqual(a, b) {
-  for (let i = 0; i < a.length; i++) {
-    const x = a[i];
-    const y = b[i];
-    if (x.path !== y.path) return false;
-    if (x.type !== y.type) return false;
-    if (x.status !== y.status) return false;
-    if (x.hop !== y.hop) return false;
-    if (x.dep_index !== y.dep_index) return false;
-    if (x.reason !== y.reason) return false;
-    if (x.value !== y.value) return false;
-    if (x.lastMutation !== y.lastMutation) return false;
-    const xv = x.v;
-    const yv = y.v;
-    if (xv !== yv) {
-      if (xv == null || yv == null) return false;
-      if (xv.id !== yv.id || xv.version !== yv.version) return false;
-    }
-  }
-  return true;
-}
-function complianceSnapshot(target, opts = {}) {
-  const result = {
-    format_version: 1,
-    timestamp_ns: monotonicNs(),
-    wall_clock_ns: wallClockNs(),
-    graph: target.snapshot()
-  };
-  if (opts.actor != null) result.actor = opts.actor;
-  if (opts.audit != null) {
-    const entries = [...opts.audit.all()];
-    result.audit = { count: entries.length, entries };
-  }
-  if (opts.policies != null) {
-    const rules = opts.policies.policies.cache ?? [];
-    result.policies = {
-      mode: opts.policies.mode,
-      rules,
-      violations: [...opts.policies.all()]
-    };
-  }
-  const fingerprint = computeFingerprint(result);
-  return { ...result, fingerprint };
-}
-function isNode(x) {
-  return typeof x === "object" && x !== null && "subscribe" in x;
-}
-function safeNode(target, path) {
-  try {
-    return target.node(path);
-  } catch {
-    return void 0;
-  }
-}
-function safeAnnotation(target, path) {
-  try {
-    return target.annotation(path);
-  } catch {
-    return void 0;
-  }
-}
-function collectPaths(target) {
-  const described = target.describe({ detail: "minimal" });
-  return Object.keys(described.nodes);
-}
-function computeFingerprint(value) {
-  return defaultHash(JSON.stringify(canonicalize(value)));
-}
-function canonicalize(value) {
-  const stack = /* @__PURE__ */ new Set();
-  const walk = (v) => {
-    if (v === void 0) return { __undefined: true };
-    if (v === null) return null;
-    const t = typeof v;
-    if (t === "bigint") return { __bigint: v.toString() };
-    if (t !== "object") return v;
-    const obj = v;
-    if (stack.has(obj)) return { __circular: true };
-    stack.add(obj);
-    try {
-      if (Array.isArray(obj)) {
-        return obj.map(walk);
-      }
-      if (obj instanceof Date) {
-        return { __date: obj.toISOString() };
-      }
-      if (obj instanceof RegExp) {
-        return { __regexp: { source: obj.source, flags: obj.flags } };
-      }
-      if (obj instanceof Map) {
-        const entries = [...obj.entries()].map(([k, mv]) => [
-          walk(k),
-          walk(mv)
-        ]);
-        return { __map: entries };
-      }
-      if (obj instanceof Set) {
-        const items = [...obj].map(walk);
-        return { __set: items };
-      }
-      if (ArrayBuffer.isView(obj)) {
-        const ta = obj;
-        const arr = new Array(ta.length);
-        for (let i = 0; i < ta.length; i++) arr[i] = ta[i] ?? 0;
-        return { __typed_array: { ctor: obj.constructor.name, data: arr } };
-      }
-      const out = {};
-      for (const k of Object.keys(obj).sort()) {
-        out[k] = walk(obj[k]);
-      }
-      return out;
-    } finally {
-      stack.delete(obj);
-    }
-  };
-  return walk(value);
-}
 
 // src/patterns/domain-templates.ts
 var domain_templates_exports = {};
@@ -3813,14 +389,14 @@ __export(reduction_exports, {
   scorer: () => scorer,
   stratify: () => stratify
 });
-function baseMeta2(kind, meta) {
+function baseMeta(kind, meta) {
   return domainMeta("reduction", kind, meta);
 }
 function stratify(name, source, rules, opts) {
   const g = new Graph(name, opts);
   g.add("source", source);
   const rulesNode = state(rules, {
-    meta: baseMeta2("stratify_rules")
+    meta: baseMeta("stratify_rules")
   });
   g.add("rules", rulesNode);
   for (const rule of rules) {
@@ -3889,7 +465,7 @@ function _addBranch(graph, source, rulesNode, rule) {
     },
     {
       describeKind: "derived",
-      meta: baseMeta2("stratify_branch", { branch: rule.name }),
+      meta: baseMeta("stratify_branch", { branch: rule.name }),
       completeWhenDepsComplete: false
     }
   );
@@ -3983,7 +559,7 @@ function feedback(graph, condition, reentry, opts) {
   const maxIter = opts?.maxIterations ?? 10;
   const counterName = `__feedback_${condition}`;
   const counter = state(0, {
-    meta: baseMeta2("feedback_counter", {
+    meta: baseMeta("feedback_counter", {
       maxIterations: maxIter,
       feedbackFrom: condition,
       feedbackTo: reentry
@@ -4019,7 +595,7 @@ function feedback(graph, condition, reentry, opts) {
       name: feedbackEffectName,
       describeKind: "effect",
       meta: {
-        ...baseMeta2("feedback_effect", {
+        ...baseMeta("feedback_effect", {
           feedbackFrom: condition,
           feedbackTo: reentry
         }),
@@ -4078,7 +654,7 @@ function budgetGate(source, constraints, opts) {
     {
       ...opts,
       describeKind: "derived",
-      meta: baseMeta2("budget_gate", opts?.meta)
+      meta: baseMeta("budget_gate", opts?.meta)
     }
   );
   function _handleBudgetMessage(msg, depIndex, actions) {
@@ -4188,7 +764,7 @@ function scorer(sources, weights, opts) {
         resetOnTeardown: opts.resetOnTeardown
       } : {},
       describeKind: "derived",
-      meta: baseMeta2("scorer", opts?.meta)
+      meta: baseMeta("scorer", opts?.meta)
     }
   );
 }
@@ -4239,7 +815,7 @@ function effectivenessTracker(opts) {
 }
 
 // src/patterns/domain-templates.ts
-function baseMeta3(kind, extra) {
+function baseMeta2(kind, extra) {
   return domainMeta("domain_template", kind, extra);
 }
 function observabilityGraph(name, opts) {
@@ -4270,16 +846,16 @@ function observabilityGraph(name, opts) {
     branchNodes,
     (vals) => correlateFn(vals),
     {
-      meta: baseMeta3("observability", { stage: "correlate" })
+      meta: baseMeta2("observability", { stage: "correlate" })
     }
   );
   g.add("correlate", correlateNode);
   const sloCheckFn = opts.sloCheck ?? (() => ({ pass: true }));
   const sloValue = derived([correlateNode], (vals) => vals[0], {
-    meta: baseMeta3("observability", { stage: "slo_value" })
+    meta: baseMeta2("observability", { stage: "slo_value" })
   });
   const sloVerified = derived([sloValue], (vals) => sloCheckFn(vals[0]), {
-    meta: baseMeta3("observability", { stage: "slo_verified" })
+    meta: baseMeta2("observability", { stage: "slo_verified" })
   });
   g.add("slo_value", sloValue);
   g.add("slo_verified", sloVerified);
@@ -4304,12 +880,12 @@ function observabilityGraph(name, opts) {
       slo: vals[1]
     }),
     {
-      meta: baseMeta3("observability", { stage: "output" })
+      meta: baseMeta2("observability", { stage: "output" })
     }
   );
   g.add("output", output);
   const fbReentry = state(null, {
-    meta: baseMeta3("observability", { stage: "feedback_reentry" })
+    meta: baseMeta2("observability", { stage: "feedback_reentry" })
   });
   g.add("feedback_reentry", fbReentry);
   const fbCondition = derived(
@@ -4320,7 +896,7 @@ function observabilityGraph(name, opts) {
       return null;
     },
     {
-      meta: baseMeta3("observability", { stage: "feedback_condition" })
+      meta: baseMeta2("observability", { stage: "feedback_condition" })
     }
   );
   g.add("feedback_condition", fbCondition);
@@ -4342,7 +918,7 @@ function issueTrackerGraph(name, opts) {
   });
   const extractFn = opts.extract ?? defaultExtract;
   const extractNode = derived([opts.source], (vals) => extractFn(vals[0]), {
-    meta: baseMeta3("issue_tracker", { stage: "extract" })
+    meta: baseMeta2("issue_tracker", { stage: "extract" })
   });
   g.add("extract", extractNode);
   const verifyFn = opts.verify ?? (() => ({ valid: true }));
@@ -4353,12 +929,12 @@ function issueTrackerGraph(name, opts) {
       return { issue, verification: verifyFn(issue) };
     },
     {
-      meta: baseMeta3("issue_tracker", { stage: "verify" })
+      meta: baseMeta2("issue_tracker", { stage: "verify" })
     }
   );
   g.add("verify", verifyNode);
   const knownPatterns = state([], {
-    meta: baseMeta3("issue_tracker", { stage: "known_patterns" })
+    meta: baseMeta2("issue_tracker", { stage: "known_patterns" })
   });
   g.add("known_patterns", knownPatterns);
   const detectFn = opts.detectRegression ?? (() => ({ regression: false }));
@@ -4369,7 +945,7 @@ function issueTrackerGraph(name, opts) {
       const known = vals[1];
       return { issue, regression: detectFn(issue, known) };
     },
-    { meta: baseMeta3("issue_tracker", { stage: "regression" }) }
+    { meta: baseMeta2("issue_tracker", { stage: "regression" }) }
   );
   g.add("regression", regressionNode);
   const severitySignal = derived([extractNode], (vals) => {
@@ -4395,11 +971,11 @@ function issueTrackerGraph(name, opts) {
       regression: vals[1],
       priority: vals[2]
     }),
-    { meta: baseMeta3("issue_tracker", { stage: "output" }) }
+    { meta: baseMeta2("issue_tracker", { stage: "output" }) }
   );
   g.add("output", output);
   const fbReentry = state(null, {
-    meta: baseMeta3("issue_tracker", { stage: "feedback_reentry" })
+    meta: baseMeta2("issue_tracker", { stage: "feedback_reentry" })
   });
   g.add("feedback_reentry", fbReentry);
   const fbCondition = derived(
@@ -4413,7 +989,7 @@ function issueTrackerGraph(name, opts) {
       return null;
     },
     {
-      meta: baseMeta3("issue_tracker", { stage: "feedback_condition" })
+      meta: baseMeta2("issue_tracker", { stage: "feedback_condition" })
     }
   );
   g.add("feedback_condition", fbCondition);
@@ -4432,7 +1008,7 @@ function contentModerationGraph(name, opts) {
   });
   const classifyFn = opts.classify ?? defaultClassify;
   const classifyNode = derived([opts.source], (vals) => classifyFn(vals[0]), {
-    meta: baseMeta3("content_moderation", { stage: "classify" })
+    meta: baseMeta2("content_moderation", { stage: "classify" })
   });
   g.add("classify", classifyNode);
   const strat = stratify("stratify", classifyNode, [
@@ -4467,7 +1043,7 @@ function contentModerationGraph(name, opts) {
   const policy2 = state(
     {},
     {
-      meta: baseMeta3("content_moderation", {
+      meta: baseMeta2("content_moderation", {
         stage: "policy",
         access: "both",
         description: "Moderation policy rules \u2014 updated via feedback"
@@ -4499,7 +1075,7 @@ function contentModerationGraph(name, opts) {
       classification: vals[0],
       priority: vals[1]
     }),
-    { meta: baseMeta3("content_moderation", { stage: "output" }) }
+    { meta: baseMeta2("content_moderation", { stage: "output" }) }
   );
   g.add("output", output);
   const fbCondition = derived(
@@ -4515,7 +1091,7 @@ function contentModerationGraph(name, opts) {
       return null;
     },
     {
-      meta: baseMeta3("content_moderation", { stage: "feedback_condition" })
+      meta: baseMeta2("content_moderation", { stage: "feedback_condition" })
     }
   );
   g.add("feedback_condition", fbCondition);
@@ -4535,7 +1111,7 @@ function dataQualityGraph(name, opts) {
   const validateNode = derived(
     [opts.source],
     (vals) => vals[0] != null ? validateFn(vals[0]) : void 0,
-    { meta: baseMeta3("data_quality", { stage: "validate" }) }
+    { meta: baseMeta2("data_quality", { stage: "validate" }) }
   );
   g.add("validate", validateNode);
   const detectAnomalyFn = opts.detectAnomaly ?? ((record) => ({
@@ -4546,11 +1122,11 @@ function dataQualityGraph(name, opts) {
   const anomalyNode = derived(
     [opts.source],
     (vals) => vals[0] != null ? detectAnomalyFn(vals[0]) : void 0,
-    { meta: baseMeta3("data_quality", { stage: "anomaly" }) }
+    { meta: baseMeta2("data_quality", { stage: "anomaly" }) }
   );
   g.add("anomaly", anomalyNode);
   const baseline = state(null, {
-    meta: baseMeta3("data_quality", {
+    meta: baseMeta2("data_quality", {
       stage: "baseline",
       description: "Rolling baseline for drift detection"
     })
@@ -4570,7 +1146,7 @@ function dataQualityGraph(name, opts) {
   const driftNode = derived(
     [opts.source, baseline],
     (vals) => detectDriftFn(vals[0], vals[1]),
-    { meta: baseMeta3("data_quality", { stage: "drift" }) }
+    { meta: baseMeta2("data_quality", { stage: "drift" }) }
   );
   g.add("drift", driftNode);
   const suggestFn = opts.suggest ?? (() => null);
@@ -4580,7 +1156,7 @@ function dataQualityGraph(name, opts) {
       validation: vals[0],
       anomaly: vals[1]
     }),
-    { meta: baseMeta3("data_quality", { stage: "remediate" }) }
+    { meta: baseMeta2("data_quality", { stage: "remediate" }) }
   );
   g.add("remediate", remediateNode);
   const output = derived(
@@ -4591,11 +1167,11 @@ function dataQualityGraph(name, opts) {
       drift: vals[2],
       remediation: vals[3]
     }),
-    { meta: baseMeta3("data_quality", { stage: "output" }) }
+    { meta: baseMeta2("data_quality", { stage: "output" }) }
   );
   g.add("output", output);
   const validationRules = state([], {
-    meta: baseMeta3("data_quality", { stage: "validation_rules" })
+    meta: baseMeta2("data_quality", { stage: "validation_rules" })
   });
   g.add("validation_rules", validationRules);
   const fbCondition = derived(
@@ -4606,7 +1182,7 @@ function dataQualityGraph(name, opts) {
       return null;
     },
     {
-      meta: baseMeta3("data_quality", { stage: "feedback_condition" })
+      meta: baseMeta2("data_quality", { stage: "feedback_condition" })
     }
   );
   g.add("feedback_condition", fbCondition);
@@ -4793,7 +1369,7 @@ function levenshtein(a, b) {
   }
   return dp[m][n];
 }
-var VALID_NODE_TYPES2 = /* @__PURE__ */ new Set([
+var VALID_NODE_TYPES = /* @__PURE__ */ new Set([
   "state",
   "producer",
   "derived",
@@ -4880,9 +1456,9 @@ function validateSpec(spec) {
       continue;
     }
     const n = raw;
-    if (typeof n.type !== "string" || !VALID_NODE_TYPES2.has(n.type)) {
+    if (typeof n.type !== "string" || !VALID_NODE_TYPES.has(n.type)) {
       errors.push(
-        `Node "${name}": invalid type "${String(n.type)}" (expected: ${[...VALID_NODE_TYPES2].join(", ")})`
+        `Node "${name}": invalid type "${String(n.type)}" (expected: ${[...VALID_NODE_TYPES].join(", ")})`
       );
       continue;
     }
@@ -5507,7 +2083,7 @@ Rules:
 - Use "feedback" for bounded cycles where a derived value writes back to a state node.
 - meta.description is required for every node.
 - Return ONLY valid JSON, no markdown fences or commentary.`;
-function stripFences2(text) {
+function stripFences(text) {
   const match = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```[\s\S]*$/);
   return match ? match[1] : text;
 }
@@ -5537,7 +2113,7 @@ ${opts.systemPromptExtra}`;
   const response = await rawResult;
   let content = response.content.trim();
   if (content.startsWith("```")) {
-    content = stripFences2(content);
+    content = stripFences(content);
   }
   let parsed;
   try {
@@ -5608,7 +2184,7 @@ Return the complete modified GraphSpec as JSON.`
   const response = await rawResult;
   let content = response.content.trim();
   if (content.startsWith("```")) {
-    content = stripFences2(content);
+    content = stripFences(content);
   }
   let parsed;
   try {
@@ -5686,7 +2262,7 @@ function guardedExecution(target, opts) {
 // src/patterns/harness/index.ts
 var harness_exports = {};
 __export(harness_exports, {
-  DEFAULT_DECAY_RATE: () => DEFAULT_DECAY_RATE2,
+  DEFAULT_DECAY_RATE: () => DEFAULT_DECAY_RATE,
   DEFAULT_QUEUE_CONFIGS: () => DEFAULT_QUEUE_CONFIGS,
   DEFAULT_SEVERITY_WEIGHTS: () => DEFAULT_SEVERITY_WEIGHTS,
   HarnessGraph: () => HarnessGraph,
@@ -5729,28 +2305,28 @@ function evalIntakeBridge(evalSource2, intakeTopic, opts) {
       if (results == null) return;
       const runs = Array.isArray(results) ? results : [results];
       for (const run of runs) {
-        for (const task2 of run.tasks) {
-          if (task2.valid && task2.judge_scores?.every((s) => s.pass)) continue;
-          if (!task2.valid && (!task2.judge_scores || task2.judge_scores.length === 0)) {
+        for (const task of run.tasks) {
+          if (task.valid && task.judge_scores?.every((s) => s.pass)) continue;
+          if (!task.valid && (!task.judge_scores || task.judge_scores.length === 0)) {
             intakeTopic.publish({
               source: "eval",
-              summary: `Task ${task2.task_id} invalid (model: ${run.model})`,
+              summary: `Task ${task.task_id} invalid (model: ${run.model})`,
               evidence: `Run ${run.run_id}: task produced invalid output`,
               affectsAreas: ["graphspec"],
-              affectsEvalTasks: [task2.task_id],
+              affectsEvalTasks: [task.task_id],
               severity: defaultSeverity
             });
             continue;
           }
-          if (task2.judge_scores) {
-            for (const score of task2.judge_scores) {
+          if (task.judge_scores) {
+            for (const score of task.judge_scores) {
               if (score.pass) continue;
               intakeTopic.publish({
                 source: "eval",
-                summary: `${task2.task_id}: ${score.claim} (model: ${run.model})`,
+                summary: `${task.task_id}: ${score.claim} (model: ${run.model})`,
                 evidence: score.reasoning,
                 affectsAreas: ["graphspec"],
-                affectsEvalTasks: [task2.task_id],
+                affectsEvalTasks: [task.task_id],
                 severity: defaultSeverity
               });
             }
@@ -5855,9 +2431,9 @@ function codeChangeBridge(source, intakeTopic, parser, opts) {
     { name: opts?.name ?? "code-change-bridge" }
   );
 }
-function notifyEffect(topic2, transport, opts) {
+function notifyEffect(topic, transport, opts) {
   return effect(
-    [topic2.latest],
+    [topic.latest],
     ([item]) => {
       if (item == null) return;
       void transport(item);
@@ -5889,7 +2465,7 @@ var DEFAULT_SEVERITY_WEIGHTS = {
   medium: 40,
   low: 10
 };
-var DEFAULT_DECAY_RATE2 = Math.LN2 / (7 * 24 * 3600);
+var DEFAULT_DECAY_RATE = Math.LN2 / (7 * 24 * 3600);
 var DEFAULT_QUEUE_CONFIGS = {
   "auto-fix": { gated: false },
   "needs-decision": { gated: true },
@@ -5945,7 +2521,7 @@ function strategyModel() {
 }
 function priorityScore(item, strategy, lastInteractionNs, urgency, signals) {
   const severityWeights = { ...DEFAULT_SEVERITY_WEIGHTS, ...signals?.severityWeights };
-  const decayRate = signals?.decayRate ?? DEFAULT_DECAY_RATE2;
+  const decayRate = signals?.decayRate ?? DEFAULT_DECAY_RATE;
   const effectivenessThreshold = signals?.effectivenessThreshold ?? 0.7;
   const effectivenessBoost = signals?.effectivenessBoost ?? 15;
   const deps = [item, strategy, lastInteractionNs];
@@ -6089,8 +2665,8 @@ function harnessLoop(name, opts) {
     if (!classification || !classification.route) return;
     const intakeItem = triagePair?.[0];
     const merged = { ...intakeItem, ...classification };
-    const topic2 = queueTopics.get(merged.route);
-    if (topic2) topic2.publish(merged);
+    const topic = queueTopics.get(merged.route);
+    if (topic) topic.publish(merged);
   });
   const routerUnsub = router.subscribe(() => {
   });
@@ -6098,9 +2674,9 @@ function harnessLoop(name, opts) {
   const gateControllers = /* @__PURE__ */ new Map();
   for (const route of QUEUE_NAMES) {
     const config = queueConfigs.get(route);
-    const topic2 = queueTopics.get(route);
+    const topic = queueTopics.get(route);
     if (config.gated) {
-      gateGraph.add(`${route}/source`, topic2.latest);
+      gateGraph.add(`${route}/source`, topic.latest);
       const ctrl = gate(gateGraph, `${route}/gate`, `${route}/source`, {
         maxPending: config.maxPending,
         startOpen: config.startOpen
@@ -6239,8 +2815,8 @@ function harnessLoop(name, opts) {
   harness.add("verify", verifyNode);
   harness.add("strategy", strategy.node);
   harness.mount("intake", intake);
-  for (const [route, topic2] of queueTopics) {
-    harness.mount(`queue/${route}`, topic2);
+  for (const [route, topic] of queueTopics) {
+    harness.mount(`queue/${route}`, topic);
   }
   harness.mount("gates", gateGraph);
   harness.mount("retry-input", retryTopic);
@@ -6252,8 +2828,8 @@ function harnessLoop(name, opts) {
 function harnessProfile(harness, opts) {
   const base = graphProfile(harness, opts);
   const queueDepths = {};
-  for (const [route, topic2] of harness.queues) {
-    queueDepths[route] = topic2.retained().length;
+  for (const [route, topic] of harness.queues) {
+    queueDepths[route] = topic.retained().length;
   }
   return {
     ...base,
@@ -6746,11 +3322,11 @@ ${catalogValidation.errors.join("\n")}`,
 }
 
 // src/patterns/surface/reduce.ts
-var DEFAULT_TIMEOUT_MS2 = 3e4;
+var DEFAULT_TIMEOUT_MS = 3e4;
 async function runReduction(spec, input, opts) {
   const inputPath = opts?.inputPath ?? "input";
   const outputPath = opts?.outputPath ?? "output";
-  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const graph = createGraph(spec, { catalog: opts?.catalog });
   let outputNode;
   try {