@graphrefly/graphrefly 0.10.0 → 0.12.0

package/dist/index.js

@@ -64,7 +64,6 @@ import {
   fromSyslog,
   fromWebSocket,
   fromWebhook,
-  gate,
   interval,
   last,
   linear,
@@ -126,6 +125,7 @@ import {
   toWebSocket,
   tokenBucket,
   tokenTracker,
+  valve,
   verifiable,
   window,
   windowCount,
@@ -137,14 +137,24 @@ import {
   workerBridge,
   workerSelf,
   zip
-} from "./chunk-TZLX4KIT.js";
+} from "./chunk-BRPCN2HJ.js";
 import {
   cqrs_exports,
   nestjs_exports
-} from "./chunk-UCW3VWMN.js";
+} from "./chunk-NULSP7U4.js";
 import {
+  DEFAULT_DOWN,
+  bridge,
   core_exports
-} from "./chunk-E7OH6ZAZ.js";
+} from "./chunk-XWMTVV2D.js";
+import {
+  JsonCodec,
+  createDagCborCodec,
+  createDagCborZstdCodec,
+  graph_exports,
+  negotiateCodec,
+  replayWAL
+} from "./chunk-IXTW3BIO.js";
 import {
   cached,
   createWatermarkController,
@@ -177,34 +187,27 @@ import {
   toArray,
   toMessages$,
   toObservable
-} from "./chunk-YWTP2XRJ.js";
+} from "./chunk-X732W3QA.js";
 import {
   ResettableTimer
 } from "./chunk-WZ2Z2CRV.js";
-import {
-  JsonCodec,
-  createDagCborCodec,
-  createDagCborZstdCodec,
-  graph_exports,
-  negotiateCodec,
-  replayWAL
-} from "./chunk-A2AJJOSJ.js";
 import {
   analyzeAndMeasure,
   computeLineBreaks,
   reactive_layout_exports
-} from "./chunk-XCZPGOVP.js";
+} from "./chunk-JYRHO63K.js";
 import {
   GRAPH_META_SEGMENT,
   Graph,
   reachable
-} from "./chunk-WYI7YW54.js";
+} from "./chunk-VQWLA6XQ.js";
 import {
   describeNode,
   metaSnapshot,
   resolveDescribeFields
-} from "./chunk-LR2CLSEF.js";
+} from "./chunk-6OLNYOGU.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-4F2ZFD5L.js";
 
 // src/compat/index.ts
 var compat_exports = {};
@@ -1045,6 +1049,7 @@ __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,
@@ -1070,6 +1075,7 @@ __export(ai_exports, {
   knobsAsTools: () => knobsAsTools,
   llmConsolidator: () => llmConsolidator,
   llmExtractor: () => llmExtractor,
+  promptNode: () => promptNode,
   suggestStrategy: () => suggestStrategy,
   systemPromptBuilder: () => systemPromptBuilder,
   toolRegistry: () => toolRegistry,
@@ -1585,6 +1591,75 @@ function fromLLMStream(adapter, messages, opts) {
     }
   };
 }
+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 cache2 = useCache ? /* @__PURE__ */ new Map() : null;
+  const messagesNode = derived(
+    deps,
+    (values) => {
+      const text = typeof prompt === "string" ? prompt : prompt(...values);
+      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")
+    }
+  );
+  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 (cache2?.has(cacheKey)) {
+      return state(cache2.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.get === "function") {
+            resolve(input.get());
+          } else {
+            resolve(input);
+          }
+        });
+        const content = extractContent(resp);
+        let parsed;
+        if (format === "json") {
+          parsed = JSON.parse(stripFences(content));
+        } else {
+          parsed = content;
+        }
+        cache2?.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;
   _keepaliveSubs = [];
@@ -2458,7 +2533,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);
@@ -3025,15 +3100,13 @@ function demoShell(opts) {
   };
 }
 
-// src/patterns/graphspec.ts
-var graphspec_exports = {};
-__export(graphspec_exports, {
-  compileSpec: () => compileSpec,
-  decompileGraph: () => decompileGraph,
-  llmCompose: () => llmCompose,
-  llmRefine: () => llmRefine,
-  specDiff: () => specDiff,
-  validateSpec: () => validateSpec
+// src/patterns/domain-templates.ts
+var domain_templates_exports = {};
+__export(domain_templates_exports, {
+  contentModerationGraph: () => contentModerationGraph,
+  dataQualityGraph: () => dataQualityGraph,
+  issueTrackerGraph: () => issueTrackerGraph,
+  observabilityGraph: () => observabilityGraph
 });
 
 // src/patterns/reduction.ts
@@ -3052,6 +3125,10 @@ function baseMeta(kind, meta) {
     ...meta ?? {}
   };
 }
+function keepalive2(n) {
+  return n.subscribe(() => {
+  });
+}
 function stratify(name, source, rules, opts) {
   const g = new Graph(name, opts);
   g.add("source", source);
@@ -3066,18 +3143,27 @@ function stratify(name, source, rules, opts) {
 }
 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;
-  const filterNode = node([source, rulesNode], () => void 0, {
-    describeKind: "operator",
-    meta: baseMeta("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];
+  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);
-        if (currentRule && currentRule.classify(value)) {
+        let matches = false;
+        try {
+          matches = currentRule?.classify(value) ?? false;
+        } catch {
+          matches = false;
+        }
+        if (matches) {
           pendingDirty = false;
           actions.emit(value);
         } else {
@@ -3086,28 +3172,57 @@ function _addBranch(graph, source, rulesNode, rule) {
             actions.down([[DIRTY], [RESOLVED]]);
           }
         }
-        return true;
-      }
-      if (t === DIRTY) {
-        pendingDirty = true;
-        return true;
-      }
-      if (t === RESOLVED) {
+      } else {
         if (pendingDirty) {
           pendingDirty = false;
           actions.down([[DIRTY], [RESOLVED]]);
         } else {
           actions.down([[RESOLVED]]);
         }
+      }
+    }
+  }
+  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 === COMPLETE || t === ERROR) {
+      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;
-        actions.down([msg]);
+        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);
@@ -3143,20 +3258,14 @@ function funnel(name, sources, stages, opts) {
     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]);
-        }
-      }
+    const bridgeName = `__bridge_${prevOutputPath}\u2192${stage.name}_input`;
+    const br = bridge(prevNode, stageInput, {
+      name: bridgeName,
+      down: DEFAULT_DOWN.filter((t) => t !== TEARDOWN)
     });
+    g.add(bridgeName, br);
+    g.connect(prevOutputPath, bridgeName);
+    keepalive2(br);
     prevOutputPath = `${stage.name}::output`;
   }
   return g;
@@ -3174,38 +3283,41 @@ function feedback(graph, condition, reentry, opts) {
   graph.add(counterName, counter);
   const condNode = graph.resolve(condition);
   const reentryNode = graph.resolve(reentry);
-  let tornDown = false;
-  let unsubCounter = null;
-  const safeUnsub = () => {
-    if (tornDown) return;
-    tornDown = true;
-    unsub();
-    unsubCounter?.();
-  };
-  const unsub = condNode.subscribe((msgs) => {
-    for (const msg of msgs) {
-      if (msg[0] === DATA) {
+  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) continue;
+        if (currentCount >= maxIter) return true;
         const condValue = msg[1];
-        if (condValue == null) continue;
-        counter.down([[DATA, currentCount + 1]]);
-        reentryNode.down([[DATA, condValue]]);
-      } else if (msg[0] === COMPLETE || msg[0] === ERROR) {
-        const terminal = msg[0] === ERROR && msg.length > 1 ? [ERROR, msg[1]] : [msg[0]];
-        counter.down([terminal]);
-        safeUnsub();
+        if (condValue == null) return true;
+        batch(() => {
+          counter.down([[DATA, currentCount + 1]]);
+          reentryNode.down([[DATA, condValue]]);
+        });
+        return true;
       }
-    }
-  });
-  unsubCounter = counter.subscribe((msgs) => {
-    for (const msg of msgs) {
-      if (msg[0] === COMPLETE || msg[0] === ERROR) {
-        safeUnsub();
-        return;
+      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) {
@@ -3221,7 +3333,8 @@ function budgetGate(source, constraints, opts) {
   }
   function flushBuffer(actions) {
     while (buffer2.length > 0 && checkBudget()) {
-      const item = buffer2.shift();
+      const item = buffer2[0];
+      buffer2 = buffer2.slice(1);
       actions.emit(item);
     }
     if (buffer2.length === 0 && pendingResolved) {
@@ -3339,7 +3452,600 @@ function scorer(sources, weights, opts) {
   );
 }
 
+// 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",
@@ -3516,6 +4222,21 @@ ${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)) {
@@ -3529,8 +4250,8 @@ ${validation.errors.join("\n")}`);
       g.add(name, nd);
       created.set(name, nd);
     } else if (n.type === "producer") {
-      const sourceFactory = n.source ? catalog.sources?.[n.source] : void 0;
-      const fnFactory = n.fn ? catalog.fns?.[n.fn] : void 0;
+      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);
@@ -3560,7 +4281,7 @@ ${validation.errors.join("\n")}`);
       const deps = n.deps ?? [];
       if (!deps.every((dep) => created.has(dep))) continue;
       const resolvedDeps = deps.map((dep) => created.get(dep));
-      const fnFactory = n.fn ? catalog.fns?.[n.fn] : void 0;
+      const fnFactory = n.fn ? resolveFn(n.fn) : void 0;
       let nd;
       if (fnFactory) {
         nd = fnFactory(resolvedDeps, n.config ?? {});
@@ -3603,8 +4324,8 @@ ${validation.errors.join("\n")}`);
         sub.add(nName, nd);
         subCreated.set(nName, nd);
       } else if (nSpec.type === "producer") {
-        const sourceFactory = nSpec.source ? catalog.sources?.[nSpec.source] : void 0;
-        const fnFactory = nSpec.fn ? catalog.fns?.[nSpec.fn] : void 0;
+        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);
@@ -3635,7 +4356,7 @@ ${validation.errors.join("\n")}`);
         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 ? catalog.fns?.[nSpec.fn] : void 0;
+        const fnFactory = nSpec.fn ? resolveFn(nSpec.fn) : void 0;
         let nd;
         if (fnFactory) {
           nd = fnFactory(resolvedDeps, nSpec.config ?? {});
@@ -3696,14 +4417,15 @@ var INTERNAL_META_KEYS = /* @__PURE__ */ new Set([
   "_templateName",
   "_templateBind",
   "feedbackFrom",
-  "feedbackTo"
+  "feedbackTo",
+  "_internal"
 ]);
 function decompileGraph(graph) {
   const desc = graph.describe({ detail: "standard" });
   const nodes = {};
   const feedbackEdges = [];
   const metaSegment = `::${GRAPH_META_SEGMENT}::`;
-  const feedbackCounterPattern = /^__feedback_(.+)$/;
+  const feedbackCounterPattern = /^__feedback_(?!effect_)(.+)$/;
   const feedbackConditions = /* @__PURE__ */ new Set();
   for (const path of Object.keys(desc.nodes)) {
     if (path.includes(metaSegment)) continue;
@@ -3723,6 +4445,9 @@ function decompileGraph(graph) {
   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
@@ -4055,11 +4780,12 @@ function stripFences2(text) {
 }
 async function llmCompose(problem, adapter, opts) {
   let systemPrompt = LLM_COMPOSE_SYSTEM_PROMPT;
-  if (opts?.catalogDescription) {
+  const catalogPrompt = opts?.catalogDescription ?? (opts?.catalog ? generateCatalogPrompt(opts.catalog) : void 0);
+  if (catalogPrompt) {
     systemPrompt += `
 
-Available catalog:
-${opts.catalogDescription}`;
+Available catalog (use ONLY these names):
+${catalogPrompt}`;
   }
   if (opts?.systemPromptExtra) {
     systemPrompt += `
@@ -4091,7 +4817,30 @@ ${opts.systemPromptExtra}`;
     throw new Error(`llmCompose: invalid GraphSpec:
 ${validation.errors.join("\n")}`);
   }
-  return parsed;
+  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;
@@ -4163,7 +4912,7 @@ function requireNonNegativeInt(value, label) {
   }
   return value;
 }
-function keepalive2(n) {
+function keepalive4(n) {
   return n.subscribe(() => {
   });
 }
@@ -4199,7 +4948,7 @@ var TopicGraph = class extends Graph {
     );
     this.add("latest", this.latest);
     this.connect("events", "latest");
-    this._keepaliveDisposers.push(keepalive2(this.latest));
+    this._keepaliveDisposers.push(keepalive4(this.latest));
   }
   destroy() {
     for (const dispose of this._keepaliveDisposers) dispose();
@@ -4255,8 +5004,8 @@ var SubscriptionGraph = class extends Graph {
     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));
+    this._keepaliveDisposers.push(keepalive4(this.source));
+    this._keepaliveDisposers.push(keepalive4(this.available));
   }
   destroy() {
     for (const dispose of this._keepaliveDisposers) dispose();
@@ -4308,7 +5057,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();
@@ -4408,7 +5157,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")
@@ -4448,7 +5197,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() {
@@ -4520,7 +5269,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();
@@ -4550,7 +5299,7 @@ __export(orchestration_exports, {
   approval: () => approval,
   branch: () => branch,
   forEach: () => forEach2,
-  gate: () => gate2,
+  gate: () => gate,
   join: () => join,
   loop: () => loop,
   onFailure: () => onFailure,
@@ -4558,6 +5307,7 @@ __export(orchestration_exports, {
   sensor: () => sensor,
   subPipeline: () => subPipeline,
   task: () => task,
+  valve: () => valve2,
   wait: () => wait
 });
 function resolveDep(graph, dep) {
@@ -4590,7 +5340,7 @@ function registerStep(graph, name, step, depPaths) {
     graph.connect(path, name);
   }
 }
-function baseMeta2(kind, meta) {
+function baseMeta3(kind, meta) {
   return {
     orchestration: true,
     orchestration_type: kind,
@@ -4628,7 +5378,7 @@ function task(graph, name, run, opts) {
       ...nodeOpts,
       name,
       describeKind: "derived",
-      meta: baseMeta2("task", opts?.meta)
+      meta: baseMeta3("task", opts?.meta)
     }
   );
   registerStep(
@@ -4651,13 +5401,13 @@ function branch(graph, name, source, predicate, opts) {
       ...opts,
       name,
       describeKind: "derived",
-      meta: baseMeta2("branch", opts?.meta)
+      meta: baseMeta3("branch", opts?.meta)
     }
   );
   registerStep(graph, name, step, src.path ? [src.path] : []);
   return step;
 }
-function gate2(graph, name, source, control, opts) {
+function valve2(graph, name, source, control, opts) {
   const src = resolveDep(graph, source);
   const ctrl = resolveDep(graph, control);
   const step = node(
@@ -4674,7 +5424,7 @@ function gate2(graph, name, source, control, opts) {
       ...opts,
       name,
       describeKind: "operator",
-      meta: baseMeta2("gate", opts?.meta)
+      meta: baseMeta3("valve", opts?.meta)
     }
   );
   registerStep(
@@ -4702,7 +5452,7 @@ function approval(graph, name, source, approver, opts) {
       ...opts,
       name,
       describeKind: "operator",
-      meta: baseMeta2("approval", opts?.meta)
+      meta: baseMeta3("approval", opts?.meta)
     }
   );
   registerStep(
@@ -4713,6 +5463,119 @@ function approval(graph, name, source, approver, opts) {
   );
   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 = node([pendingNode], ([arr]) => arr.length, {
+    name: "count",
+    describeKind: "derived"
+  });
+  let queue = [];
+  let torn = false;
+  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], () => void 0, {
+    name,
+    describeKind: "operator",
+    meta: baseMeta3("gate", opts?.meta),
+    onMessage(msg, _depIndex, actions) {
+      if (msg[0] === DATA) {
+        if (isOpenNode.get()) {
+          actions.emit(msg[1]);
+        } else {
+          enqueue(msg[1]);
+          actions.down([[RESOLVED]]);
+        }
+        return true;
+      }
+      if (msg[0] === TEARDOWN) {
+        torn = true;
+        queue = [];
+        syncPending();
+        actions.down([msg]);
+        return true;
+      }
+      if (msg[0] === COMPLETE || msg[0] === ERROR) {
+        torn = true;
+        queue = [];
+        syncPending();
+        actions.down([msg]);
+        return true;
+      }
+      actions.down([msg]);
+      return true;
+    }
+  });
+  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");
+      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]]);
+    }
+  };
+  countNode.subscribe(() => void 0);
+  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);
+  internal.connect("pending", "count");
+  graph.mount(`${name}_state`, internal);
+  return controller;
+}
 function forEach2(graph, name, source, run, opts) {
   const src = resolveDep(graph, source);
   let terminated = false;
@@ -4721,7 +5584,7 @@ function forEach2(graph, name, source, run, opts) {
     name,
     describeKind: "effect",
     completeWhenDepsComplete: false,
-    meta: baseMeta2("forEach", opts?.meta),
+    meta: baseMeta3("forEach", opts?.meta),
     onMessage(msg, depIndex, actions) {
       if (terminated) return true;
       if (depIndex !== 0) {
@@ -4756,7 +5619,7 @@ function join(graph, name, deps, opts) {
       ...opts,
       name,
       describeKind: "derived",
-      meta: baseMeta2("join", opts?.meta)
+      meta: baseMeta3("join", opts?.meta)
     }
   );
   registerStep(
@@ -4787,7 +5650,7 @@ function loop(graph, name, source, iterate, opts) {
       ...opts,
       name,
       describeKind: "derived",
-      meta: baseMeta2("loop", opts?.meta)
+      meta: baseMeta3("loop", opts?.meta)
     }
   );
   registerStep(
@@ -4812,7 +5675,7 @@ function sensor(graph, name, initial, opts) {
     name,
     initial,
     describeKind: "producer",
-    meta: baseMeta2("sensor", opts?.meta)
+    meta: baseMeta3("sensor", opts?.meta)
   });
   registerStep(graph, name, source, []);
   return {
@@ -4850,7 +5713,7 @@ function wait(graph, name, source, ms, opts) {
       initial: src.node.get(),
       describeKind: "operator",
       completeWhenDepsComplete: false,
-      meta: baseMeta2("wait", opts?.meta),
+      meta: baseMeta3("wait", opts?.meta),
       onMessage(msg, depIndex, actions) {
         if (terminated) return true;
         if (depIndex !== 0) {
@@ -4900,7 +5763,7 @@ function onFailure(graph, name, source, recover, opts) {
     name,
     describeKind: "operator",
     completeWhenDepsComplete: false,
-    meta: baseMeta2("onFailure", opts?.meta),
+    meta: baseMeta3("onFailure", opts?.meta),
     onMessage(msg, _depIndex, actions) {
       if (terminated) return true;
       if (msg[0] === ERROR) {
@@ -4924,10 +5787,12 @@ function onFailure(graph, name, source, recover, opts) {
 // src/index.ts
 var version = "0.0.0";
 export {
+  CLEANUP_RESULT,
   COMPLETE,
   CircuitOpenError,
   DATA,
   DEFAULT_ACTOR,
+  DEFAULT_DOWN,
   DIRTY,
   DictCheckpointAdapter,
   DynamicNodeImpl,
@@ -4953,6 +5818,7 @@ export {
   ai_exports as ai,
   audit,
   batch,
+  bridge,
   buffer,
   bufferCount,
   bufferTime,
@@ -4964,6 +5830,7 @@ export {
   checkpointToRedis,
   checkpointToS3,
   circuitBreaker,
+  cleanupResult,
   combine,
   combineLatest,
   compat_exports as compat,
@@ -4988,6 +5855,7 @@ export {
   deserializeError,
   distill,
   distinctUntilChanged,
+  domain_templates_exports as domainTemplates,
   dynamicNode,
   effect,
   elementAt,
@@ -5036,7 +5904,6 @@ export {
   fromTimer,
   fromWebSocket,
   fromWebhook,
-  gate,
   globToRegExp,
   graph_exports as graph,
   graphspec_exports as graphspec,
@@ -5152,6 +6019,7 @@ export {
   toWebSocket,
   tokenBucket,
   tokenTracker,
+  valve,
   verifiable,
   version,
   vue_exports as vue,