@graphrefly/graphrefly 0.9.0 → 0.11.0

package/dist/index.js

@@ -137,11 +137,16 @@ import {
   workerBridge,
   workerSelf,
   zip
-} from "./chunk-TZLX4KIT.js";
+} from "./chunk-2VHNCFGG.js";
 import {
   cqrs_exports,
   nestjs_exports
-} from "./chunk-UCW3VWMN.js";
+} from "./chunk-PZCDQD2U.js";
+import {
+  DEFAULT_DOWN,
+  bridge,
+  core_exports
+} from "./chunk-FMVFRP7L.js";
 import {
   JsonCodec,
   createDagCborCodec,
@@ -149,7 +154,7 @@ import {
   graph_exports,
   negotiateCodec,
   replayWAL
-} from "./chunk-A2AJJOSJ.js";
+} from "./chunk-U5HFZGAQ.js";
 import {
   cached,
   createWatermarkController,
@@ -182,10 +187,7 @@ import {
   toArray,
   toMessages$,
   toObservable
-} from "./chunk-YWTP2XRJ.js";
-import {
-  core_exports
-} from "./chunk-E7OH6ZAZ.js";
+} from "./chunk-5WXTWOD7.js";
 import {
   ResettableTimer
 } from "./chunk-WZ2Z2CRV.js";
@@ -193,18 +195,19 @@ import {
   analyzeAndMeasure,
   computeLineBreaks,
   reactive_layout_exports
-} from "./chunk-XCZPGOVP.js";
+} from "./chunk-3WACHRHV.js";
 import {
   GRAPH_META_SEGMENT,
   Graph,
   reachable
-} from "./chunk-WYI7YW54.js";
+} from "./chunk-2OTXEZQO.js";
 import {
   describeNode,
   metaSnapshot,
   resolveDescribeFields
-} from "./chunk-LR2CLSEF.js";
+} from "./chunk-OHUECHWY.js";
 import {
+  CLEANUP_RESULT,
   COMPLETE,
   DATA,
   DEFAULT_ACTOR,
@@ -221,6 +224,7 @@ import {
   accessHintForGuard,
   advanceVersion,
   batch,
+  cleanupResult,
   createVersioning,
   defaultHash,
   derived,
@@ -245,7 +249,7 @@ import {
   propagatesToMeta,
   state,
   wallClockNs
-} from "./chunk-QTZSBQGJ.js";
+} from "./chunk-UG2QZMRN.js";
 
 // src/compat/index.ts
 var compat_exports = {};
@@ -1045,6 +1049,8 @@ __export(patterns_exports, {
   ai: () => ai_exports,
   cqrs: () => cqrs_exports,
   demoShell: () => demo_shell_exports,
+  domainTemplates: () => domain_templates_exports,
+  graphspec: () => graphspec_exports,
   layout: () => reactive_layout_exports,
   memory: () => memory_exports,
   messaging: () => messaging_exports,
@@ -2457,7 +2463,7 @@ function gaugesAsContext(graph, actor, options) {
     const ungrouped = [];
     for (const entry of entries) {
       const node2 = described.nodes[entry.path];
-      const tags = (node2.meta ?? {}).tags;
+      const tags = node2.meta?.tags;
       if (tags && tags.length > 0) {
         const tag = tags[0];
         let group = tagGroups.get(tag);
@@ -3024,128 +3030,1919 @@ function demoShell(opts) {
   };
 }
 
-// src/patterns/messaging.ts
-var messaging_exports = {};
-__export(messaging_exports, {
-  JobFlowGraph: () => JobFlowGraph,
-  JobQueueGraph: () => JobQueueGraph,
-  SubscriptionGraph: () => SubscriptionGraph,
-  TopicBridgeGraph: () => TopicBridgeGraph,
-  TopicGraph: () => TopicGraph,
-  jobFlow: () => jobFlow,
-  jobQueue: () => jobQueue,
-  subscription: () => subscription,
-  topic: () => topic,
-  topicBridge: () => topicBridge
+// src/patterns/domain-templates.ts
+var domain_templates_exports = {};
+__export(domain_templates_exports, {
+  contentModerationGraph: () => contentModerationGraph,
+  dataQualityGraph: () => dataQualityGraph,
+  issueTrackerGraph: () => issueTrackerGraph,
+  observabilityGraph: () => observabilityGraph
 });
-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;
+
+// src/patterns/reduction.ts
+var reduction_exports = {};
+__export(reduction_exports, {
+  budgetGate: () => budgetGate,
+  feedback: () => feedback,
+  funnel: () => funnel,
+  scorer: () => scorer,
+  stratify: () => stratify
+});
+function baseMeta(kind, meta) {
+  return {
+    reduction: true,
+    reduction_type: kind,
+    ...meta ?? {}
+  };
 }
 function keepalive2(n) {
   return n.subscribe(() => {
   });
 }
-function messagingMeta(kind, extra) {
-  return {
-    messaging: true,
-    messaging_type: kind,
-    ...extra ?? {}
-  };
+function stratify(name, source, rules, opts) {
+  const g = new Graph(name, opts);
+  g.add("source", source);
+  const rulesNode = state(rules, {
+    meta: baseMeta("stratify_rules")
+  });
+  g.add("rules", rulesNode);
+  for (const rule of rules) {
+    _addBranch(g, source, rulesNode, rule);
+  }
+  return g;
 }
-var TopicGraph = class extends Graph {
-  _log;
-  _keepaliveDisposers = [];
-  events;
-  latest;
-  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.value.entries;
-        return entries.length === 0 ? void 0 : entries[entries.length - 1];
-      },
-      {
-        name: "latest",
-        describeKind: "derived",
-        meta: messagingMeta("topic_latest"),
-        initial: void 0
+function _addBranch(graph, source, rulesNode, rule) {
+  const branchName = `branch/${rule.name}`;
+  const _noValue = /* @__PURE__ */ Symbol("noValue");
+  let sourceDirty = false;
+  let rulesDirty = false;
+  let sourcePhase2 = false;
+  let sourceValue = _noValue;
+  let pendingDirty = false;
+  function resolve(actions) {
+    if (sourcePhase2) {
+      sourcePhase2 = false;
+      const value = sourceValue;
+      sourceValue = _noValue;
+      if (value !== _noValue) {
+        const currentRules = rulesNode.get();
+        const currentRule = currentRules.find((r) => r.name === rule.name);
+        let matches = false;
+        try {
+          matches = currentRule?.classify(value) ?? false;
+        } catch {
+          matches = false;
+        }
+        if (matches) {
+          pendingDirty = false;
+          actions.emit(value);
+        } else {
+          if (pendingDirty) {
+            pendingDirty = false;
+            actions.down([[DIRTY], [RESOLVED]]);
+          }
+        }
+      } else {
+        if (pendingDirty) {
+          pendingDirty = false;
+          actions.down([[DIRTY], [RESOLVED]]);
+        } else {
+          actions.down([[RESOLVED]]);
+        }
       }
-    );
-    this.add("latest", this.latest);
-    this.connect("events", "latest");
-    this._keepaliveDisposers.push(keepalive2(this.latest));
-  }
-  destroy() {
-    for (const dispose of this._keepaliveDisposers) dispose();
-    this._keepaliveDisposers.length = 0;
-    super.destroy();
-  }
-  publish(value) {
-    this._log.append(value);
+    }
   }
-  retained() {
-    const snapshot = this.events.get();
-    return snapshot.value.entries;
+  const filterNode = node([source, rulesNode], () => void 0, {
+    describeKind: "operator",
+    meta: baseMeta("stratify_branch", { branch: rule.name }),
+    onMessage(msg, depIndex, actions) {
+      const t = msg[0];
+      if (t === DIRTY) {
+        if (depIndex === 0) {
+          sourceDirty = true;
+          pendingDirty = true;
+        } else {
+          rulesDirty = true;
+        }
+        return true;
+      }
+      if (t === DATA || t === RESOLVED) {
+        if (depIndex === 0) {
+          sourceDirty = false;
+          sourcePhase2 = true;
+          sourceValue = t === DATA ? msg[1] : _noValue;
+        } else {
+          rulesDirty = false;
+        }
+        if (sourceDirty || rulesDirty) return true;
+        resolve(actions);
+        return true;
+      }
+      if (t === COMPLETE || t === ERROR || t === TEARDOWN) {
+        sourceDirty = false;
+        rulesDirty = false;
+        sourcePhase2 = false;
+        sourceValue = _noValue;
+        pendingDirty = false;
+        if (depIndex === 0) {
+          actions.down([msg]);
+        }
+        return true;
+      }
+      if (depIndex === 1) return true;
+      return false;
+    },
+    completeWhenDepsComplete: false
+  });
+  graph.add(branchName, filterNode);
+  graph.connect("source", branchName);
+  if (rule.ops) {
+    const transformed = rule.ops(filterNode);
+    const transformedName = `branch/${rule.name}/out`;
+    graph.add(transformedName, transformed);
+    graph.connect(branchName, transformedName);
   }
-};
-var SubscriptionGraph = class extends Graph {
-  _keepaliveDisposers = [];
-  source;
-  cursor;
-  available;
-  constructor(name, topicGraph, opts = {}) {
-    super(name, opts.graph);
-    const initialCursor = requireNonNegativeInt(opts.cursor ?? 0, "subscription cursor");
-    this.mount("topic", topicGraph);
-    const topicEvents = topicGraph.events;
-    this.source = derived([topicEvents], ([snapshot]) => snapshot, {
-      name: "source",
-      describeKind: "derived",
-      meta: messagingMeta("subscription_source"),
-      initial: topicEvents.get()
-    });
-    this.add("source", this.source);
-    this.cursor = state(initialCursor, {
-      name: "cursor",
-      describeKind: "state",
-      meta: messagingMeta("subscription_cursor")
+}
+function funnel(name, sources, stages, opts) {
+  if (sources.length === 0) throw new RangeError("funnel requires at least one source");
+  if (stages.length === 0) throw new RangeError("funnel requires at least one stage");
+  const g = new Graph(name, opts);
+  const merged = sources.length === 1 ? sources[0] : merge(...sources);
+  g.add("merged", merged);
+  let prevOutputPath = "merged";
+  for (let i = 0; i < stages.length; i++) {
+    const stage = stages[i];
+    const sub = new Graph(stage.name);
+    stage.build(sub);
+    try {
+      sub.resolve("input");
+    } catch {
+      throw new Error(`funnel stage "${stage.name}" must define an "input" node`);
+    }
+    try {
+      sub.resolve("output");
+    } catch {
+      throw new Error(`funnel stage "${stage.name}" must define an "output" node`);
+    }
+    g.mount(stage.name, sub);
+    const prevNode = g.resolve(prevOutputPath);
+    const stageInputPath = `${stage.name}::input`;
+    const stageInput = g.resolve(stageInputPath);
+    const bridgeName = `__bridge_${prevOutputPath}\u2192${stage.name}_input`;
+    const br = bridge(prevNode, stageInput, {
+      name: bridgeName,
+      down: DEFAULT_DOWN.filter((t) => t !== TEARDOWN)
     });
-    this.add("cursor", this.cursor);
-    this.available = derived(
-      [this.source, this.cursor],
-      ([sourceSnapshot, cursor]) => {
-        const entries = sourceSnapshot.value.entries;
-        const start = Math.max(0, Math.trunc(cursor ?? 0));
-        return entries.slice(start);
-      },
-      {
-        name: "available",
-        describeKind: "derived",
-        meta: messagingMeta("subscription_available"),
-        initial: []
+    g.add(bridgeName, br);
+    g.connect(prevOutputPath, bridgeName);
+    keepalive2(br);
+    prevOutputPath = `${stage.name}::output`;
+  }
+  return g;
+}
+function feedback(graph, condition, reentry, opts) {
+  const maxIter = opts?.maxIterations ?? 10;
+  const counterName = `__feedback_${condition}`;
+  const counter = state(0, {
+    meta: baseMeta("feedback_counter", {
+      maxIterations: maxIter,
+      feedbackFrom: condition,
+      feedbackTo: reentry
+    })
+  });
+  graph.add(counterName, counter);
+  const condNode = graph.resolve(condition);
+  const reentryNode = graph.resolve(reentry);
+  const feedbackEffectName = `__feedback_effect_${condition}`;
+  const feedbackEffect = node([condNode], void 0, {
+    name: feedbackEffectName,
+    describeKind: "effect",
+    meta: {
+      ...baseMeta("feedback_effect", {
+        feedbackFrom: condition,
+        feedbackTo: reentry
+      }),
+      _internal: true
+    },
+    onMessage(msg, _depIndex, _actions) {
+      const t = msg[0];
+      if (t === DATA) {
+        const currentCount = counter.get();
+        if (currentCount >= maxIter) return true;
+        const condValue = msg[1];
+        if (condValue == null) return true;
+        batch(() => {
+          counter.down([[DATA, currentCount + 1]]);
+          reentryNode.down([[DATA, condValue]]);
+        });
+        return true;
       }
-    );
-    this.add("available", this.available);
-    this.connect("topic::events", "source");
-    this.connect("source", "available");
-    this.connect("cursor", "available");
-    this._keepaliveDisposers.push(keepalive2(this.source));
-    this._keepaliveDisposers.push(keepalive2(this.available));
+      if (t === COMPLETE || t === ERROR) {
+        const terminal = t === ERROR && msg.length > 1 ? [ERROR, msg[1]] : [t];
+        counter.down([terminal]);
+        return true;
+      }
+      return false;
+    }
+  });
+  graph.add(feedbackEffectName, feedbackEffect);
+  graph.connect(condition, feedbackEffectName);
+  keepalive2(feedbackEffect);
+  return graph;
+}
+function budgetGate(source, constraints, opts) {
+  if (constraints.length === 0) throw new RangeError("budgetGate requires at least one constraint");
+  const constraintNodes = constraints.map((c) => c.node);
+  const allDeps = [source, ...constraintNodes];
+  let buffer2 = [];
+  let paused = false;
+  let pendingResolved = false;
+  const lockId = /* @__PURE__ */ Symbol("budget-gate");
+  function checkBudget() {
+    return constraints.every((c) => c.check(c.node.get()));
   }
-  destroy() {
-    for (const dispose of this._keepaliveDisposers) dispose();
-    this._keepaliveDisposers.length = 0;
-    super.destroy();
+  function flushBuffer(actions) {
+    while (buffer2.length > 0 && checkBudget()) {
+      const item = buffer2[0];
+      buffer2 = buffer2.slice(1);
+      actions.emit(item);
+    }
+    if (buffer2.length === 0 && pendingResolved) {
+      pendingResolved = false;
+      actions.down([[RESOLVED]]);
+    }
   }
-  ack(count) {
+  return node(allDeps, () => void 0, {
+    ...opts,
+    describeKind: "operator",
+    meta: baseMeta("budget_gate", opts?.meta),
+    onMessage(msg, depIndex, actions) {
+      const t = msg[0];
+      if (depIndex === 0) {
+        if (t === DATA) {
+          if (checkBudget() && buffer2.length === 0) {
+            actions.emit(msg[1]);
+          } else {
+            buffer2.push(msg[1]);
+            if (!paused) {
+              paused = true;
+              actions.up([[PAUSE, lockId]]);
+            }
+          }
+          return true;
+        }
+        if (t === DIRTY) {
+          actions.down([[DIRTY]]);
+          return true;
+        }
+        if (t === RESOLVED) {
+          if (buffer2.length === 0) {
+            actions.down([[RESOLVED]]);
+          } else {
+            pendingResolved = true;
+          }
+          return true;
+        }
+        if (t === COMPLETE || t === ERROR) {
+          for (const item of buffer2) {
+            actions.emit(item);
+          }
+          buffer2 = [];
+          pendingResolved = false;
+          if (paused) {
+            paused = false;
+            actions.up([[RESUME, lockId]]);
+          }
+          actions.down([msg]);
+          return true;
+        }
+        return false;
+      }
+      if (t === DATA || t === RESOLVED) {
+        if (checkBudget() && buffer2.length > 0) {
+          flushBuffer(actions);
+          if (buffer2.length === 0 && paused) {
+            paused = false;
+            actions.up([[RESUME, lockId]]);
+          }
+        } else if (!checkBudget() && !paused && buffer2.length > 0) {
+          paused = true;
+          actions.up([[PAUSE, lockId]]);
+        }
+        return true;
+      }
+      if (t === DIRTY) {
+        return true;
+      }
+      if (t === ERROR) {
+        actions.down([msg]);
+        return true;
+      }
+      if (t === COMPLETE) {
+        return true;
+      }
+      return false;
+    }
+  });
+}
+function scorer(sources, weights, opts) {
+  if (sources.length === 0) throw new RangeError("scorer requires at least one source");
+  if (sources.length !== weights.length) {
+    throw new RangeError("scorer requires the same number of sources and weights");
+  }
+  const allDeps = [...sources, ...weights];
+  const n = sources.length;
+  const scoreFns = opts?.scoreFns;
+  return derived(
+    allDeps,
+    (vals) => {
+      const signals = vals.slice(0, n);
+      const weightValues = vals.slice(n);
+      const breakdown = [];
+      let totalScore = 0;
+      for (let i = 0; i < n; i++) {
+        const sig = signals[i] ?? 0;
+        const wt = weightValues[i] ?? 0;
+        const rawScore = scoreFns?.[i] ? scoreFns[i](sig) : sig;
+        const weighted = rawScore * wt;
+        breakdown.push(weighted);
+        totalScore += weighted;
+      }
+      return {
+        value: signals,
+        score: totalScore,
+        breakdown
+      };
+    },
+    {
+      ...opts,
+      describeKind: "derived",
+      meta: baseMeta("scorer", opts?.meta)
+    }
+  );
+}
+
+// src/patterns/domain-templates.ts
+function keepalive3(n) {
+  return n.subscribe(() => {
+  });
+}
+function baseMeta2(kind, extra) {
+  return { domain_template: true, template_type: kind, ...extra ?? {} };
+}
+function observabilityGraph(name, opts) {
+  const g = new Graph(name, opts);
+  g.add("source", opts.source);
+  const defaultBranches = [
+    { name: "errors", classify: (v) => isTagged(v, "error") },
+    { name: "traces", classify: (v) => isTagged(v, "trace") },
+    { name: "metrics", classify: (v) => isTagged(v, "metric") }
+  ];
+  const branches = opts.branches ?? defaultBranches;
+  const rules = branches.map((b) => ({
+    name: b.name,
+    classify: b.classify
+  }));
+  const strat = stratify("stratify", opts.source, rules);
+  g.mount("stratify", strat);
+  const branchNodes = branches.map((b) => {
+    try {
+      return g.resolve(`stratify::branch/${b.name}`);
+    } catch {
+      return state(null);
+    }
+  });
+  const correlateFn = opts.correlate ?? ((vals) => vals);
+  const correlateNode = derived(
+    branchNodes,
+    (vals) => correlateFn(vals),
+    {
+      meta: baseMeta2("observability", { stage: "correlate" })
+    }
+  );
+  g.add("correlate", correlateNode);
+  for (const b of branches) {
+    try {
+      g.connect(`stratify::branch/${b.name}`, "correlate");
+    } catch {
+    }
+  }
+  const sloCheckFn = opts.sloCheck ?? (() => ({ pass: true }));
+  const sloValue = derived([correlateNode], (vals) => vals[0], {
+    meta: baseMeta2("observability", { stage: "slo_value" })
+  });
+  const sloVerified = derived([sloValue], (vals) => sloCheckFn(vals[0]), {
+    meta: baseMeta2("observability", { stage: "slo_verified" })
+  });
+  g.add("slo_value", sloValue);
+  g.add("slo_verified", sloVerified);
+  g.connect("correlate", "slo_value");
+  g.connect("slo_value", "slo_verified");
+  const weightValues = opts.weights ?? branches.map(() => 1);
+  const signalNodes = branchNodes.map(
+    (bn) => derived([bn], (vals) => vals[0] != null ? 1 : 0)
+  );
+  const weightNodes = weightValues.map((w) => state(w));
+  for (let i = 0; i < signalNodes.length; i++) {
+    g.add(`__signal_${i}`, signalNodes[i]);
+    g.add(`__weight_${i}`, weightNodes[i]);
+  }
+  const alerts = scorer(
+    signalNodes,
+    weightNodes
+  );
+  g.add("alerts", alerts);
+  const output = derived(
+    [alerts, sloVerified],
+    (vals) => ({
+      scored: vals[0],
+      slo: vals[1]
+    }),
+    {
+      meta: baseMeta2("observability", { stage: "output" })
+    }
+  );
+  g.add("output", output);
+  g.connect("alerts", "output");
+  g.connect("slo_verified", "output");
+  const fbReentry = state(null, {
+    meta: baseMeta2("observability", { stage: "feedback_reentry" })
+  });
+  g.add("feedback_reentry", fbReentry);
+  const fbCondition = derived(
+    [sloVerified],
+    (vals) => {
+      const result = vals[0];
+      if (result && result.pass === false) return result;
+      return null;
+    },
+    {
+      meta: baseMeta2("observability", { stage: "feedback_condition" })
+    }
+  );
+  g.add("feedback_condition", fbCondition);
+  g.connect("slo_verified", "feedback_condition");
+  feedback(g, "feedback_condition", "feedback_reentry", {
+    maxIterations: opts.maxFeedbackIterations ?? 5
+  });
+  return g;
+}
+function issueTrackerGraph(name, opts) {
+  const g = new Graph(name, opts);
+  g.add("source", opts.source);
+  let _issueCounter = 0;
+  const defaultExtract = (raw) => ({
+    id: `issue-${++_issueCounter}`,
+    title: String(raw),
+    severity: 1,
+    source: "unknown",
+    raw
+  });
+  const extractFn = opts.extract ?? defaultExtract;
+  const extractNode = derived([opts.source], (vals) => extractFn(vals[0]), {
+    meta: baseMeta2("issue_tracker", { stage: "extract" })
+  });
+  g.add("extract", extractNode);
+  g.connect("source", "extract");
+  const verifyFn = opts.verify ?? (() => ({ valid: true }));
+  const verifyNode = derived(
+    [extractNode],
+    (vals) => {
+      const issue = vals[0];
+      return { issue, verification: verifyFn(issue) };
+    },
+    {
+      meta: baseMeta2("issue_tracker", { stage: "verify" })
+    }
+  );
+  g.add("verify", verifyNode);
+  g.connect("extract", "verify");
+  const knownPatterns = state([], {
+    meta: baseMeta2("issue_tracker", { stage: "known_patterns" })
+  });
+  g.add("known_patterns", knownPatterns);
+  const detectFn = opts.detectRegression ?? (() => ({ regression: false }));
+  const regressionNode = derived(
+    [extractNode, knownPatterns],
+    (vals) => {
+      const issue = vals[0];
+      const known = vals[1];
+      return { issue, regression: detectFn(issue, known) };
+    },
+    { meta: baseMeta2("issue_tracker", { stage: "regression" }) }
+  );
+  g.add("regression", regressionNode);
+  g.connect("extract", "regression");
+  g.connect("known_patterns", "regression");
+  const severitySignal = derived([extractNode], (vals) => {
+    const issue = vals[0];
+    return issue?.severity ?? 0;
+  });
+  const regressionSignal = derived([regressionNode], (vals) => {
+    const r = vals[0];
+    return r?.regression ? 2 : 0;
+  });
+  g.add("__severity_signal", severitySignal);
+  g.add("__regression_signal", regressionSignal);
+  const severityWeight = state(1);
+  const regressionWeight = state(1.5);
+  g.add("__severity_weight", severityWeight);
+  g.add("__regression_weight", regressionWeight);
+  const priority = scorer([severitySignal, regressionSignal], [severityWeight, regressionWeight]);
+  g.add("priority", priority);
+  const output = derived(
+    [verifyNode, regressionNode, priority],
+    (vals) => ({
+      verified: vals[0],
+      regression: vals[1],
+      priority: vals[2]
+    }),
+    { meta: baseMeta2("issue_tracker", { stage: "output" }) }
+  );
+  g.add("output", output);
+  g.connect("verify", "output");
+  g.connect("regression", "output");
+  g.connect("priority", "output");
+  const fbReentry = state(null, {
+    meta: baseMeta2("issue_tracker", { stage: "feedback_reentry" })
+  });
+  g.add("feedback_reentry", fbReentry);
+  const fbCondition = derived(
+    [verifyNode],
+    (vals) => {
+      const result = vals[0];
+      if (result) {
+        const v = result.verification;
+        if (v && v.valid === false) return result;
+      }
+      return null;
+    },
+    {
+      meta: baseMeta2("issue_tracker", { stage: "feedback_condition" })
+    }
+  );
+  g.add("feedback_condition", fbCondition);
+  g.connect("verify", "feedback_condition");
+  feedback(g, "feedback_condition", "feedback_reentry", {
+    maxIterations: opts.maxFeedbackIterations ?? 3
+  });
+  return g;
+}
+function contentModerationGraph(name, opts) {
+  const g = new Graph(name, opts);
+  g.add("source", opts.source);
+  const defaultClassify = (content) => ({
+    label: "review",
+    confidence: 0.5,
+    original: content
+  });
+  const classifyFn = opts.classify ?? defaultClassify;
+  const classifyNode = derived([opts.source], (vals) => classifyFn(vals[0]), {
+    meta: baseMeta2("content_moderation", { stage: "classify" })
+  });
+  g.add("classify", classifyNode);
+  g.connect("source", "classify");
+  const strat = stratify("stratify", classifyNode, [
+    { name: "safe", classify: (v) => v.label === "safe" },
+    { name: "review", classify: (v) => v.label === "review" },
+    { name: "block", classify: (v) => v.label === "block" }
+  ]);
+  g.mount("stratify", strat);
+  const reviewLog = reactiveLog([], {
+    name: "review_queue",
+    maxSize: opts.maxQueueSize
+  });
+  g.add("review_queue", reviewLog.entries);
+  let reviewBranch;
+  try {
+    reviewBranch = g.resolve("stratify::branch/review");
+  } catch {
+    reviewBranch = state(null);
+    g.add("__review_fallback", reviewBranch);
+  }
+  const reviewAccumulator = effect([reviewBranch], (vals) => {
+    const item = vals[0];
+    if (item) {
+      reviewLog.append(item);
+    }
+  });
+  g.add("__review_accumulator", reviewAccumulator);
+  keepalive3(reviewAccumulator);
+  try {
+    g.connect("stratify::branch/review", "__review_accumulator");
+  } catch {
+  }
+  const policy2 = state(
+    {},
+    {
+      meta: baseMeta2("content_moderation", {
+        stage: "policy",
+        access: "both",
+        description: "Moderation policy rules \u2014 updated via feedback"
+      })
+    }
+  );
+  g.add("policy", policy2);
+  const weights = opts.weights ?? [0.1, 1, 2];
+  const confidenceSignal = derived([classifyNode], (vals) => {
+    const r = vals[0];
+    return r?.confidence ?? 0;
+  });
+  const severitySignal = derived([classifyNode], (vals) => {
+    const r = vals[0];
+    if (!r) return 0;
+    return r.label === "block" ? weights[2] : r.label === "review" ? weights[1] : weights[0];
+  });
+  g.add("__confidence_signal", confidenceSignal);
+  g.add("__severity_signal", severitySignal);
+  const wConfidence = state(1);
+  const wSeverity = state(1);
+  g.add("__w_confidence", wConfidence);
+  g.add("__w_severity", wSeverity);
+  const priority = scorer([confidenceSignal, severitySignal], [wConfidence, wSeverity]);
+  g.add("priority", priority);
+  const output = derived(
+    [classifyNode, priority],
+    (vals) => ({
+      classification: vals[0],
+      priority: vals[1]
+    }),
+    { meta: baseMeta2("content_moderation", { stage: "output" }) }
+  );
+  g.add("output", output);
+  g.connect("classify", "output");
+  g.connect("priority", "output");
+  const fbCondition = derived(
+    [reviewLog.entries, policy2],
+    (vals) => {
+      const snap = vals[0];
+      const entries = snap?.value?.entries;
+      if (entries && entries.length > 0) {
+        const latest = entries[entries.length - 1];
+        if (latest && latest.falsePositive) {
+          return latest;
+        }
+      }
+      return null;
+    },
+    {
+      meta: baseMeta2("content_moderation", { stage: "feedback_condition" })
+    }
+  );
+  g.add("feedback_condition", fbCondition);
+  feedback(g, "feedback_condition", "policy", {
+    maxIterations: opts.maxFeedbackIterations ?? 5
+  });
+  return g;
+}
+function dataQualityGraph(name, opts) {
+  const g = new Graph(name, opts);
+  g.add("source", opts.source);
+  const validateFn = opts.validate ?? ((record) => ({
+    valid: true,
+    errors: [],
+    record
+  }));
+  const validateNode = derived(
+    [opts.source],
+    (vals) => vals[0] != null ? validateFn(vals[0]) : void 0,
+    { meta: baseMeta2("data_quality", { stage: "validate" }) }
+  );
+  g.add("validate", validateNode);
+  g.connect("source", "validate");
+  const detectAnomalyFn = opts.detectAnomaly ?? ((record) => ({
+    anomaly: false,
+    score: 0,
+    record
+  }));
+  const anomalyNode = derived(
+    [opts.source],
+    (vals) => vals[0] != null ? detectAnomalyFn(vals[0]) : void 0,
+    { meta: baseMeta2("data_quality", { stage: "anomaly" }) }
+  );
+  g.add("anomaly", anomalyNode);
+  g.connect("source", "anomaly");
+  const baseline = state(null, {
+    meta: baseMeta2("data_quality", {
+      stage: "baseline",
+      description: "Rolling baseline for drift detection"
+    })
+  });
+  g.add("baseline", baseline);
+  const baselineUpdater = effect([validateNode], (vals) => {
+    const result = vals[0];
+    if (result?.valid) {
+      batch(() => {
+        baseline.down([[DATA, result.record]]);
+      });
+    }
+  });
+  g.add("__baseline_updater", baselineUpdater);
+  g.connect("validate", "__baseline_updater");
+  keepalive3(baselineUpdater);
+  const detectDriftFn = opts.detectDrift ?? (() => ({ drift: false }));
+  const driftNode = derived(
+    [opts.source, baseline],
+    (vals) => detectDriftFn(vals[0], vals[1]),
+    { meta: baseMeta2("data_quality", { stage: "drift" }) }
+  );
+  g.add("drift", driftNode);
+  g.connect("source", "drift");
+  g.connect("baseline", "drift");
+  const suggestFn = opts.suggest ?? (() => null);
+  const remediateNode = derived(
+    [validateNode, anomalyNode],
+    (vals) => suggestFn({
+      validation: vals[0],
+      anomaly: vals[1]
+    }),
+    { meta: baseMeta2("data_quality", { stage: "remediate" }) }
+  );
+  g.add("remediate", remediateNode);
+  g.connect("validate", "remediate");
+  g.connect("anomaly", "remediate");
+  const output = derived(
+    [validateNode, anomalyNode, driftNode, remediateNode],
+    (vals) => ({
+      validation: vals[0],
+      anomaly: vals[1],
+      drift: vals[2],
+      remediation: vals[3]
+    }),
+    { meta: baseMeta2("data_quality", { stage: "output" }) }
+  );
+  g.add("output", output);
+  g.connect("validate", "output");
+  g.connect("anomaly", "output");
+  g.connect("drift", "output");
+  g.connect("remediate", "output");
+  const validationRules = state([], {
+    meta: baseMeta2("data_quality", { stage: "validation_rules" })
+  });
+  g.add("validation_rules", validationRules);
+  const fbCondition = derived(
+    [anomalyNode],
+    (vals) => {
+      const a = vals[0];
+      if (a?.anomaly) return a;
+      return null;
+    },
+    {
+      meta: baseMeta2("data_quality", { stage: "feedback_condition" })
+    }
+  );
+  g.add("feedback_condition", fbCondition);
+  g.connect("anomaly", "feedback_condition");
+  feedback(g, "feedback_condition", "validation_rules", {
+    maxIterations: opts.maxFeedbackIterations ?? 3
+  });
+  return g;
+}
+function isTagged(value, tag) {
+  if (value == null || typeof value !== "object") return false;
+  const v = value;
+  return v.type === tag || v.kind === tag;
+}
+
+// src/patterns/graphspec.ts
+var graphspec_exports = {};
+__export(graphspec_exports, {
+  compileSpec: () => compileSpec,
+  decompileGraph: () => decompileGraph,
+  extractFnFactory: () => extractFnFactory,
+  extractSourceFactory: () => extractSourceFactory,
+  generateCatalogPrompt: () => generateCatalogPrompt,
+  isRichFnEntry: () => isRichFnEntry,
+  isRichSourceEntry: () => isRichSourceEntry,
+  llmCompose: () => llmCompose,
+  llmRefine: () => llmRefine,
+  specDiff: () => specDiff,
+  validateSpec: () => validateSpec,
+  validateSpecAgainstCatalog: () => validateSpecAgainstCatalog
+});
+function isRichFnEntry(entry) {
+  return typeof entry === "object" && entry !== null && "factory" in entry;
+}
+function isRichSourceEntry(entry) {
+  return typeof entry === "object" && entry !== null && "factory" in entry;
+}
+function extractFnFactory(entry) {
+  return isRichFnEntry(entry) ? entry.factory : entry;
+}
+function extractSourceFactory(entry) {
+  return isRichSourceEntry(entry) ? entry.factory : entry;
+}
+function generateCatalogPrompt(catalog) {
+  const sections = [];
+  if (catalog.fns) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const [name, entry] of Object.entries(catalog.fns)) {
+      const tag = isRichFnEntry(entry) ? entry.tags?.[0] ?? "Other" : "Other";
+      if (!groups.has(tag)) groups.set(tag, []);
+      groups.get(tag).push(formatFnEntry(name, entry));
+    }
+    for (const [tag, lines] of groups) {
+      sections.push(`${tag}:
+${lines.join("\n")}`);
+    }
+  }
+  if (catalog.sources) {
+    const lines = [];
+    for (const [name, entry] of Object.entries(catalog.sources)) {
+      lines.push(formatSourceEntry(name, entry));
+    }
+    if (lines.length > 0) {
+      sections.push(`Sources:
+${lines.join("\n")}`);
+    }
+  }
+  return sections.join("\n\n");
+}
+function formatFnEntry(name, entry) {
+  if (!isRichFnEntry(entry)) return `- ${name}`;
+  let line = `- ${name}: ${entry.description}`;
+  if (entry.configSchema) {
+    const fields = Object.entries(entry.configSchema).map(([k, v]) => {
+      let desc = `${k}: ${v.type}`;
+      if (v.enum) desc += ` (${v.enum.join("|")})`;
+      if (v.required === false) desc += "?";
+      return desc;
+    });
+    line += `. Config: { ${fields.join(", ")} }`;
+  }
+  return line;
+}
+function formatSourceEntry(name, entry) {
+  if (!isRichSourceEntry(entry)) return `- ${name}`;
+  let line = `- ${name}: ${entry.description}`;
+  if (entry.configSchema) {
+    const fields = Object.entries(entry.configSchema).map(([k, v]) => {
+      let desc = `${k}: ${v.type}`;
+      if (v.required === false) desc += "?";
+      return desc;
+    });
+    line += `. Config: { ${fields.join(", ")} }`;
+  }
+  return line;
+}
+function validateSpecAgainstCatalog(spec, catalog) {
+  const errors = [];
+  const fnNames = new Set(Object.keys(catalog.fns ?? {}));
+  const sourceNames = new Set(Object.keys(catalog.sources ?? {}));
+  for (const [nodeName, nodeRaw] of Object.entries(spec.nodes)) {
+    if (nodeRaw.type === "template") continue;
+    const node2 = nodeRaw;
+    if (node2.fn && fnNames.size > 0 && !fnNames.has(node2.fn)) {
+      if (sourceNames.has(node2.fn)) {
+        errors.push(
+          `Node "${nodeName}": fn "${node2.fn}" is a source, not a function. Use it as a producer source instead, or use a function from: ${[...fnNames].join(", ")}`
+        );
+      } else {
+        const suggestion = findClosest(node2.fn, fnNames);
+        errors.push(
+          `Node "${nodeName}": fn "${node2.fn}" not found in catalog` + (suggestion ? `. Did you mean "${suggestion}"?` : "")
+        );
+      }
+    }
+    if (node2.source && sourceNames.size > 0 && !sourceNames.has(node2.source)) {
+      if (fnNames.has(node2.source)) {
+        errors.push(
+          `Node "${nodeName}": source "${node2.source}" is a function, not a source. Use it as fn instead, or use a source from: ${[...sourceNames].join(", ")}`
+        );
+      } else {
+        const suggestion = findClosest(node2.source, sourceNames);
+        errors.push(
+          `Node "${nodeName}": source "${node2.source}" not found in catalog` + (suggestion ? `. Did you mean "${suggestion}"?` : "")
+        );
+      }
+    }
+    if (node2.fn && node2.config && catalog.fns?.[node2.fn]) {
+      const entry = catalog.fns[node2.fn];
+      if (isRichFnEntry(entry) && entry.configSchema) {
+        for (const [field, schema] of Object.entries(entry.configSchema)) {
+          if (schema.required !== false && !(field in node2.config)) {
+            errors.push(`Node "${nodeName}": config missing required field "${field}"`);
+          }
+          if (field in node2.config && schema.enum) {
+            const val = node2.config[field];
+            if (!schema.enum.includes(val)) {
+              errors.push(
+                `Node "${nodeName}": config.${field} = ${JSON.stringify(val)}, expected one of: ${schema.enum.join(", ")}`
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  if (spec.templates) {
+    for (const [tName, template] of Object.entries(spec.templates)) {
+      for (const [nodeName, node2] of Object.entries(template.nodes)) {
+        if (node2.fn && fnNames.size > 0 && !fnNames.has(node2.fn)) {
+          const suggestion = findClosest(node2.fn, fnNames);
+          errors.push(
+            `Template "${tName}" node "${nodeName}": fn "${node2.fn}" not found in catalog` + (suggestion ? `. Did you mean "${suggestion}"?` : "")
+          );
+        }
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function findClosest(input, candidates) {
+  let best = null;
+  let bestDist = Infinity;
+  const lower = input.toLowerCase();
+  for (const c of candidates) {
+    const dist = levenshtein(lower, c.toLowerCase());
+    if (dist < bestDist && dist <= Math.max(3, Math.floor(input.length / 2))) {
+      bestDist = dist;
+      best = c;
+    }
+  }
+  return best;
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    (_, i) => Array.from({ length: n + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
+  );
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+var VALID_NODE_TYPES2 = /* @__PURE__ */ new Set([
+  "state",
+  "producer",
+  "derived",
+  "effect",
+  "operator",
+  "template"
+]);
+var INNER_NODE_TYPES = /* @__PURE__ */ new Set(["state", "producer", "derived", "effect", "operator"]);
+function validateSpec(spec) {
+  const errors = [];
+  if (spec == null || typeof spec !== "object") {
+    return { valid: false, errors: ["GraphSpec must be a non-null object"] };
+  }
+  const s = spec;
+  if (typeof s.name !== "string" || s.name.length === 0) {
+    errors.push("Missing or empty 'name' field");
+  }
+  if (s.nodes == null || typeof s.nodes !== "object" || Array.isArray(s.nodes)) {
+    errors.push("Missing or invalid 'nodes' field (must be an object)");
+    return { valid: false, errors };
+  }
+  const nodeNames = new Set(Object.keys(s.nodes));
+  const nodeTypes = /* @__PURE__ */ new Map();
+  const templateDefs = /* @__PURE__ */ new Map();
+  if (s.templates != null && typeof s.templates === "object" && !Array.isArray(s.templates)) {
+    for (const [tName, tRaw] of Object.entries(s.templates)) {
+      if (tRaw != null && typeof tRaw === "object") {
+        const t = tRaw;
+        templateDefs.set(tName, {
+          params: Array.isArray(t.params) ? t.params : []
+        });
+      }
+    }
+  }
+  if (s.templates != null) {
+    if (typeof s.templates !== "object" || Array.isArray(s.templates)) {
+      errors.push("'templates' must be an object");
+    } else {
+      for (const [tName, tRaw] of Object.entries(s.templates)) {
+        if (tRaw == null || typeof tRaw !== "object") {
+          errors.push(`Template "${tName}": must be an object`);
+          continue;
+        }
+        const t = tRaw;
+        if (!Array.isArray(t.params)) {
+          errors.push(`Template "${tName}": missing 'params' array`);
+        }
+        if (t.nodes == null || typeof t.nodes !== "object" || Array.isArray(t.nodes)) {
+          errors.push(`Template "${tName}": missing or invalid 'nodes' object`);
+        } else {
+          const paramSet = new Set(Array.isArray(t.params) ? t.params : []);
+          const innerNames = new Set(Object.keys(t.nodes));
+          for (const [nName, nRaw] of Object.entries(t.nodes)) {
+            if (nRaw == null || typeof nRaw !== "object") {
+              errors.push(`Template "${tName}" node "${nName}": must be an object`);
+              continue;
+            }
+            const n = nRaw;
+            if (typeof n.type !== "string" || !INNER_NODE_TYPES.has(n.type)) {
+              errors.push(`Template "${tName}" node "${nName}": invalid type`);
+            }
+            if (Array.isArray(n.deps)) {
+              for (const dep of n.deps) {
+                if (!innerNames.has(dep) && !paramSet.has(dep)) {
+                  errors.push(
+                    `Template "${tName}" node "${nName}": dep "${dep}" is not an inner node or param`
+                  );
+                }
+              }
+            }
+          }
+          if (typeof t.output !== "string") {
+            errors.push(`Template "${tName}": missing 'output' string`);
+          } else if (!t.nodes[t.output]) {
+            errors.push(`Template "${tName}": output "${t.output}" is not a declared node`);
+          }
+        }
+      }
+    }
+  }
+  for (const [name, raw] of Object.entries(s.nodes)) {
+    if (raw == null || typeof raw !== "object") {
+      errors.push(`Node "${name}": must be an object`);
+      continue;
+    }
+    const n = raw;
+    if (typeof n.type !== "string" || !VALID_NODE_TYPES2.has(n.type)) {
+      errors.push(
+        `Node "${name}": invalid type "${String(n.type)}" (expected: ${[...VALID_NODE_TYPES2].join(", ")})`
+      );
+      continue;
+    }
+    nodeTypes.set(name, n.type);
+    if (n.type === "template") {
+      if (typeof n.template !== "string" || !templateDefs.has(n.template)) {
+        errors.push(`Node "${name}": template "${String(n.template)}" not found in templates`);
+      } else {
+        if (n.bind == null || typeof n.bind !== "object" || Array.isArray(n.bind)) {
+          errors.push(`Node "${name}": template ref requires 'bind' object`);
+        } else {
+          const tmpl = templateDefs.get(n.template);
+          const bind = n.bind;
+          for (const param of tmpl.params) {
+            if (!(param in bind)) {
+              errors.push(
+                `Node "${name}": template param "${param}" is not bound (template "${n.template}")`
+              );
+            }
+          }
+          for (const [, target] of Object.entries(bind)) {
+            if (typeof target === "string" && !nodeNames.has(target)) {
+              errors.push(
+                `Node "${name}": bind target "${target}" does not reference an existing node`
+              );
+            }
+          }
+        }
+      }
+    } else {
+      if (Array.isArray(n.deps)) {
+        for (const dep of n.deps) {
+          if (dep === name) {
+            errors.push(`Node "${name}": self-referencing dep`);
+          } else if (!nodeNames.has(dep)) {
+            errors.push(`Node "${name}": dep "${dep}" does not reference an existing node`);
+          }
+        }
+      }
+      if ((n.type === "derived" || n.type === "effect" || n.type === "operator") && !Array.isArray(n.deps)) {
+        errors.push(`Node "${name}": ${n.type} node should have a 'deps' array`);
+      }
+    }
+  }
+  if (s.feedback != null) {
+    if (!Array.isArray(s.feedback)) {
+      errors.push("'feedback' must be an array");
+    } else {
+      for (let i = 0; i < s.feedback.length; i++) {
+        const edge = s.feedback[i];
+        if (edge == null || typeof edge !== "object") {
+          errors.push(`Feedback [${i}]: must be an object`);
+          continue;
+        }
+        const e = edge;
+        if (typeof e.from !== "string" || !nodeNames.has(e.from)) {
+          errors.push(
+            `Feedback [${i}]: 'from' "${String(e.from)}" does not reference an existing node`
+          );
+        }
+        if (typeof e.from === "string" && e.from === e.to) {
+          errors.push(`Feedback [${i}]: 'from' and 'to' must be different nodes`);
+        }
+        if (typeof e.to !== "string" || !nodeNames.has(e.to)) {
+          errors.push(
+            `Feedback [${i}]: 'to' "${String(e.to)}" does not reference an existing node`
+          );
+        } else if (typeof e.to === "string" && nodeTypes.get(e.to) !== "state") {
+          errors.push(
+            `Feedback [${i}]: 'to' node "${e.to}" must be a state node (got "${nodeTypes.get(e.to) ?? "unknown"}")`
+          );
+        }
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function compileSpec(spec, opts) {
+  const validation = validateSpec(spec);
+  if (!validation.valid) {
+    throw new Error(`compileSpec: invalid GraphSpec:
+${validation.errors.join("\n")}`);
+  }
+  const catalog = opts?.catalog ?? {};
+  const g = new Graph(spec.name);
+  const templates = spec.templates ?? {};
+  const catalogValidation = validateSpecAgainstCatalog(spec, catalog);
+  if (!catalogValidation.valid) {
+    throw new Error(
+      `compileSpec: catalog validation errors:
+${catalogValidation.errors.join("\n")}`
+    );
+  }
+  const resolveFn = (fnName) => {
+    const entry = catalog.fns?.[fnName];
+    return entry ? extractFnFactory(entry) : void 0;
+  };
+  const resolveSource = (sourceName) => {
+    const entry = catalog.sources?.[sourceName];
+    return entry ? extractSourceFactory(entry) : void 0;
+  };
+  const created = /* @__PURE__ */ new Map();
+  const deferred = [];
+  for (const [name, raw] of Object.entries(spec.nodes)) {
+    if (raw.type === "template") continue;
+    const n = raw;
+    if (n.type === "state") {
+      const nd = state(n.initial, {
+        name,
+        meta: n.meta ? { ...n.meta } : void 0
+      });
+      g.add(name, nd);
+      created.set(name, nd);
+    } else if (n.type === "producer") {
+      const sourceFactory = n.source ? resolveSource(n.source) : void 0;
+      const fnFactory = n.fn ? resolveFn(n.fn) : void 0;
+      if (sourceFactory) {
+        const nd = sourceFactory(n.config ?? {});
+        g.add(name, nd);
+        created.set(name, nd);
+      } else if (fnFactory) {
+        const nd = fnFactory([], n.config ?? {});
+        g.add(name, nd);
+        created.set(name, nd);
+      } else {
+        const nd = producer(() => {
+        }, {
+          name,
+          meta: { ...n.meta, _specFn: n.fn, _specSource: n.source }
+        });
+        g.add(name, nd);
+        created.set(name, nd);
+      }
+    } else {
+      deferred.push([name, n]);
+    }
+  }
+  let progressed = true;
+  const pending = new Map(deferred);
+  while (pending.size > 0 && progressed) {
+    progressed = false;
+    for (const [name, n] of [...pending.entries()]) {
+      const deps = n.deps ?? [];
+      if (!deps.every((dep) => created.has(dep))) continue;
+      const resolvedDeps = deps.map((dep) => created.get(dep));
+      const fnFactory = n.fn ? resolveFn(n.fn) : void 0;
+      let nd;
+      if (fnFactory) {
+        nd = fnFactory(resolvedDeps, n.config ?? {});
+      } else if (n.type === "effect") {
+        nd = effect(resolvedDeps, () => {
+        });
+      } else {
+        nd = derived(resolvedDeps, (vals) => vals[0]);
+      }
+      g.add(name, nd);
+      created.set(name, nd);
+      pending.delete(name);
+      progressed = true;
+    }
+  }
+  if (pending.size > 0) {
+    const unresolved = [...pending.keys()].sort().join(", ");
+    throw new Error(`compileSpec: unresolvable deps for nodes: ${unresolved}`);
+  }
+  for (const [name, raw] of Object.entries(spec.nodes)) {
+    if (raw.type !== "template") continue;
+    const ref = raw;
+    const tmpl = templates[ref.template];
+    const sub = new Graph(name);
+    const subCreated = /* @__PURE__ */ new Map();
+    const subDeferred = [];
+    for (const [nName, nSpec] of Object.entries(tmpl.nodes)) {
+      const resolvedDeps = (nSpec.deps ?? []).map((dep) => {
+        if (dep.startsWith("$") && ref.bind[dep]) {
+          return ref.bind[dep];
+        }
+        return dep;
+      });
+      const specWithResolvedDeps = { ...nSpec, deps: resolvedDeps };
+      if (nSpec.type === "state") {
+        const nd = state(nSpec.initial, {
+          name: nName,
+          meta: nSpec.meta ? { ...nSpec.meta } : void 0
+        });
+        sub.add(nName, nd);
+        subCreated.set(nName, nd);
+      } else if (nSpec.type === "producer") {
+        const sourceFactory = nSpec.source ? resolveSource(nSpec.source) : void 0;
+        const fnFactory = nSpec.fn ? resolveFn(nSpec.fn) : void 0;
+        if (sourceFactory) {
+          const nd = sourceFactory(nSpec.config ?? {});
+          sub.add(nName, nd);
+          subCreated.set(nName, nd);
+        } else if (fnFactory) {
+          const nd = fnFactory([], nSpec.config ?? {});
+          sub.add(nName, nd);
+          subCreated.set(nName, nd);
+        } else {
+          const nd = producer(() => {
+          }, {
+            name: nName,
+            meta: { ...nSpec.meta, _specFn: nSpec.fn, _specSource: nSpec.source }
+          });
+          sub.add(nName, nd);
+          subCreated.set(nName, nd);
+        }
+      } else {
+        subDeferred.push([nName, specWithResolvedDeps]);
+      }
+    }
+    let subProgressed = true;
+    const subPending = new Map(subDeferred);
+    while (subPending.size > 0 && subProgressed) {
+      subProgressed = false;
+      for (const [nName, nSpec] of [...subPending.entries()]) {
+        const deps = nSpec.deps ?? [];
+        const allReady = deps.every((dep) => subCreated.has(dep) || created.has(dep));
+        if (!allReady) continue;
+        const resolvedDeps = deps.map((dep) => subCreated.get(dep) ?? created.get(dep));
+        const fnFactory = nSpec.fn ? resolveFn(nSpec.fn) : void 0;
+        let nd;
+        if (fnFactory) {
+          nd = fnFactory(resolvedDeps, nSpec.config ?? {});
+        } else if (nSpec.type === "effect") {
+          nd = effect(resolvedDeps, () => {
+          });
+        } else {
+          nd = derived(resolvedDeps, (vals) => vals[0]);
+        }
+        sub.add(nName, nd);
+        subCreated.set(nName, nd);
+        subPending.delete(nName);
+        subProgressed = true;
+      }
+    }
+    if (subPending.size > 0) {
+      const unresolved = [...subPending.keys()].sort().join(", ");
+      throw new Error(
+        `compileSpec: template "${ref.template}" has unresolvable deps: ${unresolved}`
+      );
+    }
+    g.mount(name, sub);
+    const outputPath = `${name}::${tmpl.output}`;
+    created.set(name, g.resolve(outputPath));
+    try {
+      const outputNode = g.resolve(outputPath);
+      outputNode.meta._templateName?.down([[DATA, ref.template]]);
+      outputNode.meta._templateBind?.down([[DATA, ref.bind]]);
+    } catch {
+    }
+  }
+  for (const [name, raw] of Object.entries(spec.nodes)) {
+    if (raw.type === "template") continue;
+    const n = raw;
+    for (const dep of n.deps ?? []) {
+      try {
+        g.connect(dep, name);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "";
+        if (!msg.includes("constructor deps") && !msg.includes("already")) {
+          throw err;
+        }
+      }
+    }
+  }
+  for (const fb of spec.feedback ?? []) {
+    feedback(g, fb.from, fb.to, {
+      maxIterations: fb.maxIterations
+    });
+  }
+  return g;
+}
+var INTERNAL_META_KEYS = /* @__PURE__ */ new Set([
+  "reduction",
+  "reduction_type",
+  "_specFn",
+  "_specSource",
+  "_templateName",
+  "_templateBind",
+  "feedbackFrom",
+  "feedbackTo",
+  "_internal"
+]);
+function decompileGraph(graph) {
+  const desc = graph.describe({ detail: "standard" });
+  const nodes = {};
+  const feedbackEdges = [];
+  const metaSegment = `::${GRAPH_META_SEGMENT}::`;
+  const feedbackCounterPattern = /^__feedback_(?!effect_)(.+)$/;
+  const feedbackConditions = /* @__PURE__ */ new Set();
+  for (const path of Object.keys(desc.nodes)) {
+    if (path.includes(metaSegment)) continue;
+    const match = feedbackCounterPattern.exec(path);
+    if (match) {
+      feedbackConditions.add(match[1]);
+      const meta = desc.nodes[path]?.meta;
+      if (meta?.feedbackFrom && meta?.feedbackTo) {
+        feedbackEdges.push({
+          from: meta.feedbackFrom,
+          to: meta.feedbackTo,
+          ...meta.maxIterations ? { maxIterations: meta.maxIterations } : {}
+        });
+      }
+    }
+  }
+  for (const [path, nodeDesc] of Object.entries(desc.nodes)) {
+    if (path.includes(metaSegment)) continue;
+    if (feedbackCounterPattern.test(path)) continue;
+    if (nodeDesc.meta?._internal) continue;
+    if (path.startsWith("__feedback_effect_")) continue;
+    if (path.startsWith("__bridge_")) continue;
+    if (path.includes("::")) continue;
+    const specNode = {
+      type: nodeDesc.type
+    };
+    if (nodeDesc.deps.length > 0) {
+      specNode.deps = nodeDesc.deps.filter((d) => !d.includes("::"));
+    }
+    if (nodeDesc.type === "state" && nodeDesc.value !== void 0) {
+      specNode.initial = nodeDesc.value;
+    }
+    if (nodeDesc.meta && Object.keys(nodeDesc.meta).length > 0) {
+      const meta = {};
+      for (const [k, v] of Object.entries(nodeDesc.meta)) {
+        if (!INTERNAL_META_KEYS.has(k)) meta[k] = v;
+      }
+      if (Object.keys(meta).length > 0) {
+        specNode.meta = meta;
+      }
+    }
+    nodes[path] = specNode;
+  }
+  const templates = {};
+  const templateRefs = {};
+  const metaDetectedSubgraphs = /* @__PURE__ */ new Set();
+  for (const subName of desc.subgraphs) {
+    const prefix = `${subName}::`;
+    for (const [path, nodeDesc] of Object.entries(desc.nodes)) {
+      if (!path.startsWith(prefix)) continue;
+      if (path.includes(metaSegment)) continue;
+      const meta = nodeDesc.meta;
+      if (meta?._templateName && meta?._templateBind) {
+        const templateName = meta._templateName;
+        const bind = meta._templateBind;
+        if (!templates[templateName]) {
+          const tmplNodes = {};
+          const tmplInnerNames = /* @__PURE__ */ new Set();
+          const tmplPrefix = `${subName}::`;
+          for (const [p, nd] of Object.entries(desc.nodes)) {
+            if (!p.startsWith(tmplPrefix) || p.includes(metaSegment)) continue;
+            const localName = p.slice(tmplPrefix.length);
+            if (localName.includes("::")) continue;
+            tmplInnerNames.add(localName);
+            tmplNodes[localName] = {
+              type: nd.type,
+              ...nd.deps.length > 0 ? {
+                deps: nd.deps.map(
+                  (d) => d.startsWith(tmplPrefix) ? d.slice(tmplPrefix.length) : d
+                )
+              } : {}
+            };
+          }
+          const tmplParams = [];
+          const tmplParamMap = /* @__PURE__ */ new Map();
+          for (const n of Object.values(tmplNodes)) {
+            for (const dep of n.deps ?? []) {
+              if (!tmplInnerNames.has(dep) && !tmplParamMap.has(dep)) {
+                const param = `$${dep}`;
+                tmplParams.push(param);
+                tmplParamMap.set(dep, param);
+              }
+            }
+          }
+          for (const n of Object.values(tmplNodes)) {
+            if (n.deps) n.deps = n.deps.map((d) => tmplParamMap.get(d) ?? d);
+          }
+          const depended = /* @__PURE__ */ new Set();
+          for (const n of Object.values(tmplNodes)) {
+            for (const dep of n.deps ?? []) {
+              if (tmplInnerNames.has(dep)) depended.add(dep);
+            }
+          }
+          const outputCandidates = [...tmplInnerNames].filter((n) => !depended.has(n));
+          const tmplOutput = outputCandidates[0] ?? [...tmplInnerNames].pop();
+          templates[templateName] = { params: tmplParams, nodes: tmplNodes, output: tmplOutput };
+        }
+        delete nodes[subName];
+        templateRefs[subName] = { type: "template", template: templateName, bind };
+        metaDetectedSubgraphs.add(subName);
+        break;
+      }
+    }
+  }
+  const structureMap = /* @__PURE__ */ new Map();
+  for (const subName of desc.subgraphs) {
+    if (metaDetectedSubgraphs.has(subName)) continue;
+    const subNodes = {};
+    const prefix = `${subName}::`;
+    for (const [path, nodeDesc] of Object.entries(desc.nodes)) {
+      if (path.includes(metaSegment)) continue;
+      if (!path.startsWith(prefix)) continue;
+      const localName = path.slice(prefix.length);
+      if (localName.includes("::")) continue;
+      subNodes[localName] = {
+        type: nodeDesc.type,
+        ...nodeDesc.deps.length > 0 ? {
+          deps: nodeDesc.deps.map((d) => d.startsWith(prefix) ? d.slice(prefix.length) : d)
+        } : {}
+      };
+    }
+    const fingerprint = JSON.stringify(
+      Object.fromEntries(
+        Object.entries(subNodes).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => [k, { type: v.type, deps: v.deps ?? [] }])
+      )
+    );
+    if (!structureMap.has(fingerprint)) {
+      structureMap.set(fingerprint, []);
+    }
+    structureMap.get(fingerprint).push({ name: subName, nodes: subNodes });
+  }
+  for (const [, group] of structureMap) {
+    if (group.length < 2) continue;
+    const templateName = `${group[0].name}_template`;
+    const refNodes = group[0].nodes;
+    const innerNames = new Set(Object.keys(refNodes));
+    const params = [];
+    const baseParamMap = /* @__PURE__ */ new Map();
+    for (const n of Object.values(refNodes)) {
+      for (const dep of n.deps ?? []) {
+        if (!innerNames.has(dep) && !baseParamMap.has(dep)) {
+          const param = `$${dep}`;
+          params.push(param);
+          baseParamMap.set(dep, param);
+        }
+      }
+    }
+    const depended = /* @__PURE__ */ new Set();
+    for (const n of Object.values(refNodes)) {
+      for (const dep of n.deps ?? []) {
+        if (innerNames.has(dep)) depended.add(dep);
+      }
+    }
+    const outputCandidates = [...innerNames].filter((n) => !depended.has(n));
+    const output = outputCandidates[0] ?? [...innerNames].pop();
+    const tmplNodes = {};
+    for (const [nName, nSpec] of Object.entries(refNodes)) {
+      tmplNodes[nName] = {
+        ...nSpec,
+        deps: nSpec.deps?.map((d) => baseParamMap.get(d) ?? d)
+      };
+    }
+    templates[templateName] = { params, nodes: tmplNodes, output };
+    for (const member of group) {
+      delete nodes[member.name];
+      const memberBind = {};
+      const memberInnerNames = new Set(Object.keys(member.nodes));
+      for (const n of Object.values(member.nodes)) {
+        for (const dep of n.deps ?? []) {
+          if (!memberInnerNames.has(dep)) {
+            const param = baseParamMap.get(dep) ?? `$${dep}`;
+            memberBind[param] = dep;
+          }
+        }
+      }
+      templateRefs[member.name] = {
+        type: "template",
+        template: templateName,
+        bind: memberBind
+      };
+    }
+  }
+  const allNodes = {
+    ...nodes,
+    ...templateRefs
+  };
+  const result = { name: desc.name, nodes: allNodes };
+  if (Object.keys(templates).length > 0) result.templates = templates;
+  if (feedbackEdges.length > 0) result.feedback = feedbackEdges;
+  return result;
+}
+function specDiff(specA, specB) {
+  const entries = [];
+  if (specA.name !== specB.name) {
+    entries.push({
+      type: "changed",
+      path: "name",
+      detail: `"${specA.name}" \u2192 "${specB.name}"`
+    });
+  }
+  const nodesA = new Set(Object.keys(specA.nodes));
+  const nodesB = new Set(Object.keys(specB.nodes));
+  for (const name of nodesB) {
+    if (!nodesA.has(name)) {
+      const n = specB.nodes[name];
+      entries.push({
+        type: "added",
+        path: `nodes.${name}`,
+        detail: `type: ${n.type}`
+      });
+    }
+  }
+  for (const name of nodesA) {
+    if (!nodesB.has(name)) {
+      entries.push({ type: "removed", path: `nodes.${name}` });
+    }
+  }
+  for (const name of nodesA) {
+    if (!nodesB.has(name)) continue;
+    const a = specA.nodes[name];
+    const b = specB.nodes[name];
+    if (JSON.stringify(a) !== JSON.stringify(b)) {
+      const details = [];
+      if (a.type !== b.type) details.push(`type: ${a.type} \u2192 ${b.type}`);
+      if (JSON.stringify(a.deps) !== JSON.stringify(b.deps)) {
+        details.push("deps changed");
+      }
+      if (a.fn !== b.fn) {
+        details.push(`fn: ${a.fn} \u2192 ${b.fn}`);
+      }
+      if (JSON.stringify(a.config) !== JSON.stringify(b.config)) {
+        details.push("config changed");
+      }
+      entries.push({
+        type: "changed",
+        path: `nodes.${name}`,
+        detail: details.join("; ") || "modified"
+      });
+    }
+  }
+  const tmplA = specA.templates ?? {};
+  const tmplB = specB.templates ?? {};
+  const tmplNamesA = new Set(Object.keys(tmplA));
+  const tmplNamesB = new Set(Object.keys(tmplB));
+  for (const name of tmplNamesB) {
+    if (!tmplNamesA.has(name)) {
+      entries.push({ type: "added", path: `templates.${name}` });
+    }
+  }
+  for (const name of tmplNamesA) {
+    if (!tmplNamesB.has(name)) {
+      entries.push({ type: "removed", path: `templates.${name}` });
+    }
+  }
+  for (const name of tmplNamesA) {
+    if (!tmplNamesB.has(name)) continue;
+    if (JSON.stringify(tmplA[name]) !== JSON.stringify(tmplB[name])) {
+      entries.push({
+        type: "changed",
+        path: `templates.${name}`,
+        detail: "template definition changed"
+      });
+    }
+  }
+  const fbA = specA.feedback ?? [];
+  const fbB = specB.feedback ?? [];
+  const fbKeyA = new Set(fbA.map((e) => `${e.from}->${e.to}`));
+  const fbKeyB = new Set(fbB.map((e) => `${e.from}->${e.to}`));
+  for (const fb of fbB) {
+    const key = `${fb.from}->${fb.to}`;
+    if (!fbKeyA.has(key)) {
+      entries.push({
+        type: "added",
+        path: `feedback.${key}`,
+        detail: `maxIterations: ${fb.maxIterations ?? 10}`
+      });
+    }
+  }
+  for (const fb of fbA) {
+    const key = `${fb.from}->${fb.to}`;
+    if (!fbKeyB.has(key)) {
+      entries.push({ type: "removed", path: `feedback.${key}` });
+    }
+  }
+  for (const fb of fbA) {
+    const key = `${fb.from}->${fb.to}`;
+    const counterpart = fbB.find((b) => b.from === fb.from && b.to === fb.to);
+    if (counterpart && JSON.stringify(fb) !== JSON.stringify(counterpart)) {
+      entries.push({
+        type: "changed",
+        path: `feedback.${key}`,
+        detail: `maxIterations: ${fb.maxIterations ?? 10} \u2192 ${counterpart.maxIterations ?? 10}`
+      });
+    }
+  }
+  const added = entries.filter((e) => e.type === "added").length;
+  const removed = entries.filter((e) => e.type === "removed").length;
+  const changed = entries.filter((e) => e.type === "changed").length;
+  const parts = [];
+  if (added) parts.push(`${added} added`);
+  if (removed) parts.push(`${removed} removed`);
+  if (changed) parts.push(`${changed} changed`);
+  const summary = parts.length > 0 ? parts.join(", ") : "no changes";
+  return { entries, summary };
+}
+var LLM_COMPOSE_SYSTEM_PROMPT = `You are a graph architect for GraphReFly, a reactive graph protocol.
+
+Given a natural-language description, produce a JSON GraphSpec with this structure:
+
+{
+  "name": "<graph_name>",
+  "nodes": {
+    "<node_name>": {
+      "type": "state" | "derived" | "producer" | "effect" | "operator",
+      "deps": ["<dep_node_name>", ...],
+      "fn": "<catalog_function_name>",
+      "source": "<catalog_source_name>",
+      "config": { ... },
+      "initial": <value>,
+      "meta": { "description": "<purpose>" }
+    },
+    "<template_instance>": {
+      "type": "template",
+      "template": "<template_name>",
+      "bind": { "$param": "node_name" }
+    }
+  },
+  "templates": {
+    "<template_name>": {
+      "params": ["$param1", "$param2"],
+      "nodes": { ... },
+      "output": "<output_node>"
+    }
+  },
+  "feedback": [
+    { "from": "<condition_node>", "to": "<state_node>", "maxIterations": 10 }
+  ]
+}
+
+Rules:
+- "state" nodes hold user/LLM-writable values (knobs). Use "initial" for default values.
+- "derived" nodes compute from deps using a named "fn".
+- "effect" nodes produce side effects from deps.
+- "producer" nodes generate values from a named "source".
+- Use "templates" when the same subgraph pattern repeats (e.g., per-source resilience).
+- 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) {
+  const match = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```[\s\S]*$/);
+  return match ? match[1] : text;
+}
+async function llmCompose(problem, adapter, opts) {
+  let systemPrompt = LLM_COMPOSE_SYSTEM_PROMPT;
+  const catalogPrompt = opts?.catalogDescription ?? (opts?.catalog ? generateCatalogPrompt(opts.catalog) : void 0);
+  if (catalogPrompt) {
+    systemPrompt += `
+
+Available catalog (use ONLY these names):
+${catalogPrompt}`;
+  }
+  if (opts?.systemPromptExtra) {
+    systemPrompt += `
+
+${opts.systemPromptExtra}`;
+  }
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: problem }
+  ];
+  const rawResult = adapter.invoke(messages, {
+    model: opts?.model,
+    temperature: opts?.temperature ?? 0,
+    maxTokens: opts?.maxTokens
+  });
+  const response = await rawResult;
+  let content = response.content.trim();
+  if (content.startsWith("```")) {
+    content = stripFences2(content);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error(`llmCompose: LLM response is not valid JSON: ${content.slice(0, 200)}`);
+  }
+  const validation = validateSpec(parsed);
+  if (!validation.valid) {
+    throw new Error(`llmCompose: invalid GraphSpec:
+${validation.errors.join("\n")}`);
+  }
+  let spec = parsed;
+  if (opts?.catalog) {
+    const maxRefine = opts.maxAutoRefine ?? 0;
+    for (let attempt = 0; attempt <= maxRefine; attempt++) {
+      const catalogValidation = validateSpecAgainstCatalog(spec, opts.catalog);
+      if (catalogValidation.valid) break;
+      if (attempt === maxRefine) {
+        throw new Error(
+          `llmCompose: catalog validation failed after ${maxRefine} refine attempts:
+${catalogValidation.errors.join("\n")}`
+        );
+      }
+      spec = await llmRefine(
+        spec,
+        `Fix these catalog errors:
+${catalogValidation.errors.join("\n")}
+
+Use ONLY functions and sources from the catalog.`,
+        adapter,
+        { ...opts, catalogDescription: catalogPrompt }
+      );
+    }
+  }
+  return spec;
+}
+async function llmRefine(currentSpec, feedback2, adapter, opts) {
+  let systemPrompt = LLM_COMPOSE_SYSTEM_PROMPT;
+  if (opts?.catalogDescription) {
+    systemPrompt += `
+
+Available catalog:
+${opts.catalogDescription}`;
+  }
+  if (opts?.systemPromptExtra) {
+    systemPrompt += `
+
+${opts.systemPromptExtra}`;
+  }
+  const messages = [
+    { role: "system", content: systemPrompt },
+    {
+      role: "user",
+      content: `Current GraphSpec:
+${JSON.stringify(currentSpec, null, 2)}
+
+Modification request: ${feedback2}
+
+Return the complete modified GraphSpec as JSON.`
+    }
+  ];
+  const rawResult = adapter.invoke(messages, {
+    model: opts?.model,
+    temperature: opts?.temperature ?? 0,
+    maxTokens: opts?.maxTokens
+  });
+  const response = await rawResult;
+  let content = response.content.trim();
+  if (content.startsWith("```")) {
+    content = stripFences2(content);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error(`llmRefine: LLM response is not valid JSON: ${content.slice(0, 200)}`);
+  }
+  const validation = validateSpec(parsed);
+  if (!validation.valid) {
+    throw new Error(`llmRefine: invalid GraphSpec:
+${validation.errors.join("\n")}`);
+  }
+  return parsed;
+}
+
+// src/patterns/messaging.ts
+var messaging_exports = {};
+__export(messaging_exports, {
+  JobFlowGraph: () => JobFlowGraph,
+  JobQueueGraph: () => JobQueueGraph,
+  SubscriptionGraph: () => SubscriptionGraph,
+  TopicBridgeGraph: () => TopicBridgeGraph,
+  TopicGraph: () => TopicGraph,
+  jobFlow: () => jobFlow,
+  jobQueue: () => jobQueue,
+  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 keepalive4(n) {
+  return n.subscribe(() => {
+  });
+}
+function messagingMeta(kind, extra) {
+  return {
+    messaging: true,
+    messaging_type: kind,
+    ...extra ?? {}
+  };
+}
+var TopicGraph = class extends Graph {
+  _log;
+  _keepaliveDisposers = [];
+  events;
+  latest;
+  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.value.entries;
+        return entries.length === 0 ? void 0 : entries[entries.length - 1];
+      },
+      {
+        name: "latest",
+        describeKind: "derived",
+        meta: messagingMeta("topic_latest"),
+        initial: void 0
+      }
+    );
+    this.add("latest", this.latest);
+    this.connect("events", "latest");
+    this._keepaliveDisposers.push(keepalive4(this.latest));
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
+  }
+  publish(value) {
+    this._log.append(value);
+  }
+  retained() {
+    const snapshot = this.events.get();
+    return snapshot.value.entries;
+  }
+};
+var SubscriptionGraph = class extends Graph {
+  _keepaliveDisposers = [];
+  source;
+  cursor;
+  available;
+  constructor(name, topicGraph, opts = {}) {
+    super(name, opts.graph);
+    const initialCursor = requireNonNegativeInt(opts.cursor ?? 0, "subscription cursor");
+    this.mount("topic", topicGraph);
+    const topicEvents = topicGraph.events;
+    this.source = derived([topicEvents], ([snapshot]) => snapshot, {
+      name: "source",
+      describeKind: "derived",
+      meta: messagingMeta("subscription_source"),
+      initial: topicEvents.get()
+    });
+    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.value.entries;
+        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.connect("topic::events", "source");
+    this.connect("source", "available");
+    this.connect("cursor", "available");
+    this._keepaliveDisposers.push(keepalive4(this.source));
+    this._keepaliveDisposers.push(keepalive4(this.available));
+  }
+  destroy() {
+    for (const dispose of this._keepaliveDisposers) dispose();
+    this._keepaliveDisposers.length = 0;
+    super.destroy();
+  }
+  ack(count) {
     const available = this.available.get();
     const requested = count === void 0 ? available.length : requireNonNegativeInt(count, "subscription ack count");
     const step = Math.min(requested, available.length);
@@ -3190,7 +4987,7 @@ var JobQueueGraph = class extends Graph {
     );
     this.add("depth", this.depth);
     this.connect("pending", "depth");
-    this._keepaliveDisposers.push(keepalive2(this.depth));
+    this._keepaliveDisposers.push(keepalive4(this.depth));
   }
   destroy() {
     for (const dispose of this._keepaliveDisposers) dispose();
@@ -3290,7 +5087,7 @@ var JobFlowGraph = class extends Graph {
     );
     this.add("completedCount", this.completedCount);
     this.connect("completed", "completedCount");
-    this._keepaliveDisposers.push(keepalive2(this.completedCount));
+    this._keepaliveDisposers.push(keepalive4(this.completedCount));
     const maxPerPump = Math.max(
       1,
       requireNonNegativeInt(opts.maxPerPump ?? DEFAULT_MAX_PER_PUMP, "job flow maxPerPump")
@@ -3330,7 +5127,7 @@ var JobFlowGraph = class extends Graph {
       );
       this.add(`pump_${stage}`, pump);
       this.connect(`${stage}::pending`, `pump_${stage}`);
-      this._keepaliveDisposers.push(keepalive2(pump));
+      this._keepaliveDisposers.push(keepalive4(pump));
     }
   }
   destroy() {
@@ -3402,7 +5199,7 @@ var TopicBridgeGraph = class extends Graph {
     );
     this.add("pump", pump);
     this.connect("subscription::available", "pump");
-    this._keepaliveDisposers.push(keepalive2(pump));
+    this._keepaliveDisposers.push(keepalive4(pump));
   }
   destroy() {
     for (const dispose of this._keepaliveDisposers) dispose();
@@ -3472,7 +5269,7 @@ function registerStep(graph, name, step, depPaths) {
     graph.connect(path, name);
   }
 }
-function baseMeta(kind, meta) {
+function baseMeta3(kind, meta) {
   return {
     orchestration: true,
     orchestration_type: kind,
@@ -3510,7 +5307,7 @@ function task(graph, name, run, opts) {
       ...nodeOpts,
       name,
       describeKind: "derived",
-      meta: baseMeta("task", opts?.meta)
+      meta: baseMeta3("task", opts?.meta)
     }
   );
   registerStep(
@@ -3533,7 +5330,7 @@ function branch(graph, name, source, predicate, opts) {
       ...opts,
       name,
       describeKind: "derived",
-      meta: baseMeta("branch", opts?.meta)
+      meta: baseMeta3("branch", opts?.meta)
     }
   );
   registerStep(graph, name, step, src.path ? [src.path] : []);
@@ -3556,7 +5353,7 @@ function gate2(graph, name, source, control, opts) {
       ...opts,
       name,
       describeKind: "operator",
-      meta: baseMeta("gate", opts?.meta)
+      meta: baseMeta3("gate", opts?.meta)
     }
   );
   registerStep(
@@ -3584,7 +5381,7 @@ function approval(graph, name, source, approver, opts) {
       ...opts,
       name,
       describeKind: "operator",
-      meta: baseMeta("approval", opts?.meta)
+      meta: baseMeta3("approval", opts?.meta)
     }
   );
   registerStep(
@@ -3603,7 +5400,7 @@ function forEach2(graph, name, source, run, opts) {
     name,
     describeKind: "effect",
     completeWhenDepsComplete: false,
-    meta: baseMeta("forEach", opts?.meta),
+    meta: baseMeta3("forEach", opts?.meta),
     onMessage(msg, depIndex, actions) {
       if (terminated) return true;
       if (depIndex !== 0) {
@@ -3638,7 +5435,7 @@ function join(graph, name, deps, opts) {
       ...opts,
       name,
       describeKind: "derived",
-      meta: baseMeta("join", opts?.meta)
+      meta: baseMeta3("join", opts?.meta)
     }
   );
   registerStep(
@@ -3669,7 +5466,7 @@ function loop(graph, name, source, iterate, opts) {
       ...opts,
       name,
       describeKind: "derived",
-      meta: baseMeta("loop", opts?.meta)
+      meta: baseMeta3("loop", opts?.meta)
     }
   );
   registerStep(
@@ -3694,7 +5491,7 @@ function sensor(graph, name, initial, opts) {
     name,
     initial,
     describeKind: "producer",
-    meta: baseMeta("sensor", opts?.meta)
+    meta: baseMeta3("sensor", opts?.meta)
   });
   registerStep(graph, name, source, []);
   return {
@@ -3732,7 +5529,7 @@ function wait(graph, name, source, ms, opts) {
       initial: src.node.get(),
       describeKind: "operator",
       completeWhenDepsComplete: false,
-      meta: baseMeta("wait", opts?.meta),
+      meta: baseMeta3("wait", opts?.meta),
       onMessage(msg, depIndex, actions) {
         if (terminated) return true;
         if (depIndex !== 0) {
@@ -3782,7 +5579,7 @@ function onFailure(graph, name, source, recover, opts) {
     name,
     describeKind: "operator",
     completeWhenDepsComplete: false,
-    meta: baseMeta("onFailure", opts?.meta),
+    meta: baseMeta3("onFailure", opts?.meta),
     onMessage(msg, _depIndex, actions) {
       if (terminated) return true;
       if (msg[0] === ERROR) {
@@ -3803,284 +5600,15 @@ function onFailure(graph, name, source, recover, opts) {
   return step;
 }
 
-// src/patterns/reduction.ts
-var reduction_exports = {};
-__export(reduction_exports, {
-  budgetGate: () => budgetGate,
-  feedback: () => feedback,
-  funnel: () => funnel,
-  scorer: () => scorer,
-  stratify: () => stratify
-});
-function baseMeta2(kind, meta) {
-  return {
-    reduction: true,
-    reduction_type: 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")
-  });
-  g.add("rules", rulesNode);
-  for (const rule of rules) {
-    _addBranch(g, source, rulesNode, rule);
-  }
-  return g;
-}
-function _addBranch(graph, source, rulesNode, rule) {
-  const branchName = `branch/${rule.name}`;
-  let pendingDirty = false;
-  const filterNode = node([source, rulesNode], () => void 0, {
-    describeKind: "operator",
-    meta: baseMeta2("stratify_branch", { branch: rule.name }),
-    onMessage(msg, depIndex, actions) {
-      if (depIndex !== 0) return false;
-      const t = msg[0];
-      if (t === DATA) {
-        const value = msg[1];
-        const currentRules = rulesNode.get();
-        const currentRule = currentRules.find((r) => r.name === rule.name);
-        if (currentRule && currentRule.classify(value)) {
-          pendingDirty = false;
-          actions.emit(value);
-        } else {
-          if (pendingDirty) {
-            pendingDirty = false;
-            actions.down([[DIRTY], [RESOLVED]]);
-          }
-        }
-        return true;
-      }
-      if (t === DIRTY) {
-        pendingDirty = true;
-        return true;
-      }
-      if (t === RESOLVED) {
-        if (pendingDirty) {
-          pendingDirty = false;
-          actions.down([[DIRTY], [RESOLVED]]);
-        } else {
-          actions.down([[RESOLVED]]);
-        }
-        return true;
-      }
-      if (t === COMPLETE || t === ERROR) {
-        pendingDirty = false;
-        actions.down([msg]);
-        return true;
-      }
-      return false;
-    }
-  });
-  graph.add(branchName, filterNode);
-  graph.connect("source", branchName);
-  if (rule.ops) {
-    const transformed = rule.ops(filterNode);
-    const transformedName = `branch/${rule.name}/out`;
-    graph.add(transformedName, transformed);
-    graph.connect(branchName, transformedName);
-  }
-}
-function funnel(name, sources, stages, opts) {
-  if (sources.length === 0) throw new RangeError("funnel requires at least one source");
-  if (stages.length === 0) throw new RangeError("funnel requires at least one stage");
-  const g = new Graph(name, opts);
-  const merged = sources.length === 1 ? sources[0] : merge(...sources);
-  g.add("merged", merged);
-  let prevOutputPath = "merged";
-  for (let i = 0; i < stages.length; i++) {
-    const stage = stages[i];
-    const sub = new Graph(stage.name);
-    stage.build(sub);
-    try {
-      sub.resolve("input");
-    } catch {
-      throw new Error(`funnel stage "${stage.name}" must define an "input" node`);
-    }
-    try {
-      sub.resolve("output");
-    } catch {
-      throw new Error(`funnel stage "${stage.name}" must define an "output" node`);
-    }
-    g.mount(stage.name, sub);
-    const prevNode = g.resolve(prevOutputPath);
-    const stageInputPath = `${stage.name}::input`;
-    const stageInput = g.resolve(stageInputPath);
-    prevNode.subscribe((msgs) => {
-      for (const msg of msgs) {
-        const t = msg[0];
-        if (t === DATA) {
-          stageInput.down([[DATA, msg[1]]]);
-        } else if (t === DIRTY) {
-          stageInput.down([[DIRTY]]);
-        } else if (t === RESOLVED) {
-          stageInput.down([[RESOLVED]]);
-        } else if (t === COMPLETE || t === ERROR) {
-          stageInput.down([msg]);
-        }
-      }
-    });
-    prevOutputPath = `${stage.name}::output`;
-  }
-  return g;
-}
-function feedback(graph, condition, reentry, opts) {
-  const maxIter = opts?.maxIterations ?? 10;
-  const counterName = `__feedback_${condition}`;
-  const counter = state(0, {
-    meta: baseMeta2("feedback_counter", { maxIterations: maxIter })
-  });
-  graph.add(counterName, counter);
-  const condNode = graph.resolve(condition);
-  const reentryNode = graph.resolve(reentry);
-  condNode.subscribe((msgs) => {
-    for (const msg of msgs) {
-      if (msg[0] === DATA) {
-        const currentCount = counter.get();
-        if (currentCount >= maxIter) continue;
-        const condValue = msg[1];
-        if (condValue == null) continue;
-        counter.down([[DATA, currentCount + 1]]);
-        reentryNode.down([[DATA, condValue]]);
-      }
-    }
-  });
-  return graph;
-}
-function budgetGate(source, constraints, opts) {
-  if (constraints.length === 0) throw new RangeError("budgetGate requires at least one constraint");
-  const constraintNodes = constraints.map((c) => c.node);
-  const allDeps = [source, ...constraintNodes];
-  let buffer2 = [];
-  let paused = false;
-  const lockId = /* @__PURE__ */ Symbol("budget-gate");
-  function checkBudget() {
-    return constraints.every((c) => c.check(c.node.get()));
-  }
-  function flushBuffer(actions) {
-    while (buffer2.length > 0 && checkBudget()) {
-      const item = buffer2.shift();
-      actions.emit(item);
-    }
-  }
-  return node(allDeps, () => void 0, {
-    ...opts,
-    describeKind: "operator",
-    meta: baseMeta2("budget_gate", opts?.meta),
-    onMessage(msg, depIndex, actions) {
-      const t = msg[0];
-      if (depIndex === 0) {
-        if (t === DATA) {
-          if (checkBudget() && buffer2.length === 0) {
-            actions.emit(msg[1]);
-          } else {
-            buffer2.push(msg[1]);
-            if (!paused) {
-              paused = true;
-              actions.up([[PAUSE, lockId]]);
-            }
-          }
-          return true;
-        }
-        if (t === DIRTY) {
-          actions.down([[DIRTY]]);
-          return true;
-        }
-        if (t === RESOLVED) {
-          if (buffer2.length === 0) {
-            actions.down([[RESOLVED]]);
-          }
-          return true;
-        }
-        if (t === COMPLETE || t === ERROR) {
-          for (const item of buffer2) {
-            actions.emit(item);
-          }
-          buffer2 = [];
-          if (paused) {
-            paused = false;
-            actions.up([[RESUME, lockId]]);
-          }
-          actions.down([msg]);
-          return true;
-        }
-        return false;
-      }
-      if (t === DATA || t === RESOLVED) {
-        if (checkBudget() && buffer2.length > 0) {
-          flushBuffer(actions);
-          if (buffer2.length === 0 && paused) {
-            paused = false;
-            actions.up([[RESUME, lockId]]);
-          }
-        } else if (!checkBudget() && !paused && buffer2.length > 0) {
-          paused = true;
-          actions.up([[PAUSE, lockId]]);
-        }
-        return true;
-      }
-      if (t === DIRTY) {
-        return true;
-      }
-      if (t === ERROR) {
-        actions.down([msg]);
-        return true;
-      }
-      if (t === COMPLETE) {
-        return true;
-      }
-      return false;
-    }
-  });
-}
-function scorer(sources, weights, opts) {
-  if (sources.length === 0) throw new RangeError("scorer requires at least one source");
-  if (sources.length !== weights.length) {
-    throw new RangeError("scorer requires the same number of sources and weights");
-  }
-  const allDeps = [...sources, ...weights];
-  const n = sources.length;
-  const scoreFns = opts?.scoreFns;
-  return derived(
-    allDeps,
-    (vals) => {
-      const signals = vals.slice(0, n);
-      const weightValues = vals.slice(n);
-      const breakdown = [];
-      let totalScore = 0;
-      for (let i = 0; i < n; i++) {
-        const sig = signals[i] ?? 0;
-        const wt = weightValues[i] ?? 0;
-        const rawScore = scoreFns?.[i] ? scoreFns[i](sig) : sig;
-        const weighted = rawScore * wt;
-        breakdown.push(weighted);
-        totalScore += weighted;
-      }
-      return {
-        value: signals,
-        score: totalScore,
-        breakdown
-      };
-    },
-    {
-      ...opts,
-      describeKind: "derived",
-      meta: baseMeta2("scorer", opts?.meta)
-    }
-  );
-}
-
 // src/index.ts
 var version = "0.0.0";
 export {
+  CLEANUP_RESULT,
   COMPLETE,
   CircuitOpenError,
   DATA,
   DEFAULT_ACTOR,
+  DEFAULT_DOWN,
   DIRTY,
   DictCheckpointAdapter,
   DynamicNodeImpl,
@@ -4106,6 +5634,7 @@ export {
   ai_exports as ai,
   audit,
   batch,
+  bridge,
   buffer,
   bufferCount,
   bufferTime,
@@ -4117,6 +5646,7 @@ export {
   checkpointToRedis,
   checkpointToS3,
   circuitBreaker,
+  cleanupResult,
   combine,
   combineLatest,
   compat_exports as compat,
@@ -4141,6 +5671,7 @@ export {
   deserializeError,
   distill,
   distinctUntilChanged,
+  domain_templates_exports as domainTemplates,
   dynamicNode,
   effect,
   elementAt,
@@ -4192,6 +5723,7 @@ export {
   gate,
   globToRegExp,
   graph_exports as graph,
+  graphspec_exports as graphspec,
   interval,
   isBatching,
   isKnownMessageType,