@graphrefly/graphrefly 0.44.0 → 0.46.0

package/dist/utils/domain-templates/index.cjs

@@ -0,0 +1,732 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/domain-templates/index.ts
+var domain_templates_exports = {};
+__export(domain_templates_exports, {
+  contentModerationGraph: () => contentModerationGraph,
+  dataQualityGraph: () => dataQualityGraph,
+  issueTrackerGraph: () => issueTrackerGraph,
+  observabilityGraph: () => observabilityGraph
+});
+module.exports = __toCommonJS(domain_templates_exports);
+var import_core3 = require("@graphrefly/pure-ts/core");
+var import_extra4 = require("@graphrefly/pure-ts/extra");
+var import_graph3 = require("@graphrefly/pure-ts/graph");
+
+// src/utils/reduction/index.ts
+var import_core2 = require("@graphrefly/pure-ts/core");
+var import_extra2 = require("@graphrefly/pure-ts/extra");
+var import_graph2 = require("@graphrefly/pure-ts/graph");
+var import_extra3 = require("@graphrefly/pure-ts/extra");
+
+// src/base/meta/domain-meta.ts
+function domainMeta(domain, kind, extra) {
+  return {
+    [domain]: true,
+    [`${domain}_type`]: kind,
+    ...extra ?? {}
+  };
+}
+
+// src/base/mutation/index.ts
+var import_core = require("@graphrefly/pure-ts/core");
+var import_extra = require("@graphrefly/pure-ts/extra");
+var import_graph = require("@graphrefly/pure-ts/graph");
+function tryIncrementBounded(counter, cap, by = 1) {
+  const cur = counter.cache ?? 0;
+  if (by > cap - cur) return false;
+  counter.down([[import_core.DIRTY], [import_core.DATA, cur + by]]);
+  return true;
+}
+var DEFAULT_AUDIT_GUARD = (0, import_core.policy)((allow, deny) => {
+  allow("observe");
+  allow("signal");
+  deny("write");
+});
+
+// src/utils/reduction/index.ts
+function baseMeta(kind, meta) {
+  return domainMeta("reduction", kind, meta);
+}
+function feedback(graph, condition, reentry, opts) {
+  const maxIter = opts?.maxIterations ?? 10;
+  const counterName = `__feedback_${condition}`;
+  const counter = (0, import_core2.node)([], {
+    ...{
+      meta: baseMeta("feedback_counter", {
+        maxIterations: maxIter,
+        feedbackFrom: condition,
+        feedbackTo: reentry
+      })
+    },
+    initial: 0
+  });
+  graph.add(counter, { name: counterName });
+  const condNode = graph.resolve(condition);
+  const reentryNode = graph.resolve(reentry);
+  const feedbackEffectName = `__feedback_effect_${condition}`;
+  const feedbackEffect = (0, import_core2.node)(
+    [],
+    (_data, _feedbackActions) => {
+      const unsub = condNode.subscribe((msgs) => {
+        for (const msg of msgs) {
+          const t = msg[0];
+          if (t === import_core2.DATA) {
+            const condValue = msg[1];
+            if (condValue == null) return;
+            (0, import_core2.batch)(() => {
+              if (tryIncrementBounded(counter, maxIter)) {
+                reentryNode.emit(condValue);
+              }
+            });
+          } else if (t === import_core2.COMPLETE || t === import_core2.ERROR) {
+            const terminal = t === import_core2.ERROR && msg.length > 1 ? [import_core2.ERROR, msg[1]] : [t];
+            counter.down([terminal]);
+          }
+        }
+      });
+      return () => unsub();
+    },
+    {
+      name: feedbackEffectName,
+      describeKind: "effect",
+      meta: {
+        ...baseMeta("feedback_effect", {
+          feedbackFrom: condition,
+          feedbackTo: reentry
+        }),
+        _internal: true
+      }
+    }
+  );
+  graph.add(feedbackEffect, { name: feedbackEffectName });
+  graph.addDisposer((0, import_extra3.keepalive)(feedbackEffect));
+  return graph;
+}
+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 (0, import_core2.node)(
+    allDeps,
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      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;
+      }
+      actions.emit({
+        value: signals,
+        score: totalScore,
+        breakdown
+      });
+    },
+    {
+      ...opts ? {
+        equals: opts.equals,
+        resubscribable: opts.resubscribable,
+        resetOnTeardown: opts.resetOnTeardown
+      } : {},
+      describeKind: "derived",
+      meta: baseMeta("scorer", opts?.meta)
+    }
+  );
+}
+
+// src/utils/domain-templates/index.ts
+var import_extra5 = require("@graphrefly/pure-ts/extra");
+function baseMeta2(kind, extra) {
+  return domainMeta("domain_template", kind, extra);
+}
+function observabilityGraph(name, opts) {
+  const g = new import_graph3.Graph(name, opts);
+  g.add(opts.source, { name: "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 = (0, import_extra4.stratify)("stratify", opts.source, rules);
+  g.mount("stratify", strat);
+  const branchNodes = branches.map((b) => {
+    try {
+      const raw = g.resolve(`stratify::branch/${b.name}`);
+      return (0, import_core3.node)(
+        [raw],
+        (batchData, actions, ctx) => {
+          const data = batchData.map(
+            (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+          );
+          actions.emit(data[0]);
+        },
+        { initial: null, describeKind: "derived" }
+      );
+    } catch {
+      return (0, import_core3.node)([], { initial: null });
+    }
+  });
+  const correlateFn = opts.correlate ?? ((vals) => vals);
+  const correlateNode = (0, import_core3.node)(
+    branchNodes,
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(correlateFn(vals));
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("observability", { stage: "correlate" })
+    }
+  );
+  g.add(correlateNode, { name: "correlate" });
+  const sloCheckFn = opts.sloCheck ?? (() => ({ pass: true }));
+  const sloValue = (0, import_core3.node)(
+    [correlateNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(data[0]);
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("observability", { stage: "slo_value" })
+    }
+  );
+  const sloVerified = (0, import_core3.node)(
+    [sloValue],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(sloCheckFn(data[0]));
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("observability", { stage: "slo_verified" })
+    }
+  );
+  g.add(sloValue, { name: "slo_value" });
+  g.add(sloVerified, { name: "slo_verified" });
+  const weightValues = opts.weights ?? branches.map(() => 1);
+  const signalNodes = branchNodes.map(
+    (bn) => (0, import_core3.node)(
+      [bn],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+        );
+        actions.emit(data[0] != null ? 1 : 0);
+      },
+      { describeKind: "derived" }
+    )
+  );
+  const weightNodes = weightValues.map((w) => (0, import_core3.node)([], { initial: w }));
+  for (let i = 0; i < signalNodes.length; i++) {
+    g.add(signalNodes[i], { name: `__signal_${i}` });
+    g.add(weightNodes[i], { name: `__weight_${i}` });
+  }
+  const alerts = scorer(
+    signalNodes,
+    weightNodes
+  );
+  g.add(alerts, { name: "alerts" });
+  const output = (0, import_core3.node)(
+    [alerts, sloVerified],
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit({
+        scored: vals[0],
+        slo: vals[1]
+      });
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("observability", { stage: "output" })
+    }
+  );
+  g.add(output, { name: "output" });
+  const fbReentry = (0, import_core3.node)([], {
+    initial: null,
+    meta: baseMeta2("observability", { stage: "feedback_reentry" })
+  });
+  g.add(fbReentry, { name: "feedback_reentry" });
+  const fbCondition = (0, import_core3.node)(
+    [sloVerified],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const result = data[0];
+      actions.emit(result && result.pass === false ? result : null);
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("observability", { stage: "feedback_condition" })
+    }
+  );
+  g.add(fbCondition, { name: "feedback_condition" });
+  feedback(g, "feedback_condition", "feedback_reentry", {
+    maxIterations: opts.maxFeedbackIterations ?? 5
+  });
+  return g;
+}
+function issueTrackerGraph(name, opts) {
+  const g = new import_graph3.Graph(name, opts);
+  g.add(opts.source, { name: "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 = (0, import_core3.node)(
+    [opts.source],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(extractFn(data[0]));
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("issue_tracker", { stage: "extract" })
+    }
+  );
+  g.add(extractNode, { name: "extract" });
+  const verifyFn = opts.verify ?? (() => ({ valid: true }));
+  const verifyNode = (0, import_core3.node)(
+    [extractNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const issue = data[0];
+      actions.emit({ issue, verification: verifyFn(issue) });
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("issue_tracker", { stage: "verify" })
+    }
+  );
+  g.add(verifyNode, { name: "verify" });
+  const knownPatterns = (0, import_core3.node)([], {
+    initial: [],
+    meta: baseMeta2("issue_tracker", { stage: "known_patterns" })
+  });
+  g.add(knownPatterns, { name: "known_patterns" });
+  const detectFn = opts.detectRegression ?? (() => ({ regression: false }));
+  const regressionNode = (0, import_core3.node)(
+    [extractNode, knownPatterns],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const issue = data[0];
+      const known = data[1];
+      actions.emit({ issue, regression: detectFn(issue, known) });
+    },
+    { describeKind: "derived", meta: baseMeta2("issue_tracker", { stage: "regression" }) }
+  );
+  g.add(regressionNode, { name: "regression" });
+  const severitySignal = (0, import_core3.node)(
+    [extractNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const issue = data[0];
+      actions.emit(issue?.severity ?? 0);
+    },
+    { describeKind: "derived" }
+  );
+  const regressionSignal = (0, import_core3.node)(
+    [regressionNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const r = data[0];
+      actions.emit(r?.regression ? 2 : 0);
+    },
+    { describeKind: "derived" }
+  );
+  g.add(severitySignal, { name: "__severity_signal" });
+  g.add(regressionSignal, { name: "__regression_signal" });
+  const severityWeight = (0, import_core3.node)([], { initial: 1 });
+  const regressionWeight = (0, import_core3.node)([], { initial: 1.5 });
+  g.add(severityWeight, { name: "__severity_weight" });
+  g.add(regressionWeight, { name: "__regression_weight" });
+  const priority = scorer([severitySignal, regressionSignal], [severityWeight, regressionWeight]);
+  g.add(priority, { name: "priority" });
+  const output = (0, import_core3.node)(
+    [verifyNode, regressionNode, priority],
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit({
+        verified: vals[0],
+        regression: vals[1],
+        priority: vals[2]
+      });
+    },
+    { describeKind: "derived", meta: baseMeta2("issue_tracker", { stage: "output" }) }
+  );
+  g.add(output, { name: "output" });
+  const fbReentry = (0, import_core3.node)([], {
+    initial: null,
+    meta: baseMeta2("issue_tracker", { stage: "feedback_reentry" })
+  });
+  g.add(fbReentry, { name: "feedback_reentry" });
+  const fbCondition = (0, import_core3.node)(
+    [verifyNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const result = data[0];
+      if (result) {
+        const v = result.verification;
+        if (v && v.valid === false) {
+          actions.emit(result);
+          return;
+        }
+      }
+      actions.emit(null);
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("issue_tracker", { stage: "feedback_condition" })
+    }
+  );
+  g.add(fbCondition, { name: "feedback_condition" });
+  feedback(g, "feedback_condition", "feedback_reentry", {
+    maxIterations: opts.maxFeedbackIterations ?? 3
+  });
+  return g;
+}
+function contentModerationGraph(name, opts) {
+  const g = new import_graph3.Graph(name, opts);
+  g.add(opts.source, { name: "source" });
+  const defaultClassify = (content) => ({
+    label: "review",
+    confidence: 0.5,
+    original: content
+  });
+  const classifyFn = opts.classify ?? defaultClassify;
+  const classifyNode = (0, import_core3.node)(
+    [opts.source],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(classifyFn(data[0]));
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("content_moderation", { stage: "classify" })
+    }
+  );
+  g.add(classifyNode, { name: "classify" });
+  const strat = (0, import_extra4.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 = (0, import_extra4.reactiveLog)([], {
+    name: "review_queue",
+    maxSize: opts.maxQueueSize
+  });
+  g.add(reviewLog.entries, { name: "review_queue" });
+  let reviewBranch;
+  try {
+    reviewBranch = g.resolve("stratify::branch/review");
+  } catch {
+    reviewBranch = (0, import_core3.node)([], { initial: null });
+    g.add(reviewBranch, { name: "__review_fallback" });
+  }
+  const reviewAccumulator = (0, import_core3.node)(
+    [reviewBranch],
+    (batchData, _actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const item = data[0];
+      if (item) {
+        reviewLog.append(item);
+      }
+    },
+    { describeKind: "effect" }
+  );
+  g.add(reviewAccumulator, { name: "__review_accumulator" });
+  g.addDisposer((0, import_extra5.keepalive)(reviewAccumulator));
+  try {
+  } catch {
+  }
+  const policy2 = (0, import_core3.node)([], {
+    initial: {},
+    meta: baseMeta2("content_moderation", {
+      stage: "policy",
+      access: "both",
+      description: "Moderation policy rules \u2014 updated via feedback"
+    })
+  });
+  g.add(policy2, { name: "policy" });
+  const weights = opts.weights ?? [0.1, 1, 2];
+  const confidenceSignal = (0, import_core3.node)(
+    [classifyNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const r = data[0];
+      actions.emit(r?.confidence ?? 0);
+    },
+    { describeKind: "derived" }
+  );
+  const severitySignal = (0, import_core3.node)(
+    [classifyNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const r = data[0];
+      if (!r) {
+        actions.emit(0);
+        return;
+      }
+      actions.emit(
+        r.label === "block" ? weights[2] : r.label === "review" ? weights[1] : weights[0]
+      );
+    },
+    { describeKind: "derived" }
+  );
+  g.add(confidenceSignal, { name: "__confidence_signal" });
+  g.add(severitySignal, { name: "__severity_signal" });
+  const wConfidence = (0, import_core3.node)([], { initial: 1 });
+  const wSeverity = (0, import_core3.node)([], { initial: 1 });
+  g.add(wConfidence, { name: "__w_confidence" });
+  g.add(wSeverity, { name: "__w_severity" });
+  const priority = scorer([confidenceSignal, severitySignal], [wConfidence, wSeverity]);
+  g.add(priority, { name: "priority" });
+  const output = (0, import_core3.node)(
+    [classifyNode, priority],
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit({
+        classification: vals[0],
+        priority: vals[1]
+      });
+    },
+    { describeKind: "derived", meta: baseMeta2("content_moderation", { stage: "output" }) }
+  );
+  g.add(output, { name: "output" });
+  const fbCondition = (0, import_core3.node)(
+    [reviewLog.entries, policy2],
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const entries = vals[0];
+      if (entries && entries.length > 0) {
+        const latest = entries[entries.length - 1];
+        if (latest && latest.falsePositive) {
+          actions.emit(latest);
+          return;
+        }
+      }
+      actions.emit(null);
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("content_moderation", { stage: "feedback_condition" })
+    }
+  );
+  g.add(fbCondition, { name: "feedback_condition" });
+  feedback(g, "feedback_condition", "policy", {
+    maxIterations: opts.maxFeedbackIterations ?? 5
+  });
+  return g;
+}
+function dataQualityGraph(name, opts) {
+  const g = new import_graph3.Graph(name, opts);
+  g.add(opts.source, { name: "source" });
+  const validateFn = opts.validate ?? ((record) => ({
+    valid: true,
+    errors: [],
+    record
+  }));
+  const validateNode = (0, import_core3.node)(
+    [opts.source],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(data[0] != null ? validateFn(data[0]) : void 0);
+    },
+    { describeKind: "derived", meta: baseMeta2("data_quality", { stage: "validate" }) }
+  );
+  g.add(validateNode, { name: "validate" });
+  const detectAnomalyFn = opts.detectAnomaly ?? ((record) => ({
+    anomaly: false,
+    score: 0,
+    record
+  }));
+  const anomalyNode = (0, import_core3.node)(
+    [opts.source],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(data[0] != null ? detectAnomalyFn(data[0]) : void 0);
+    },
+    { describeKind: "derived", meta: baseMeta2("data_quality", { stage: "anomaly" }) }
+  );
+  g.add(anomalyNode, { name: "anomaly" });
+  const baseline = (0, import_core3.node)([], {
+    initial: null,
+    meta: baseMeta2("data_quality", {
+      stage: "baseline",
+      description: "Rolling baseline for drift detection"
+    })
+  });
+  g.add(baseline, { name: "baseline" });
+  const baselineUpdater = (0, import_core3.node)(
+    [validateNode],
+    (batchData, _actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const result = data[0];
+      if (result?.valid) {
+        (0, import_core3.batch)(() => {
+          baseline.emit(result.record);
+        });
+      }
+    },
+    { describeKind: "effect" }
+  );
+  g.add(baselineUpdater, { name: "__baseline_updater" });
+  (0, import_extra5.keepalive)(baselineUpdater);
+  const detectDriftFn = opts.detectDrift ?? (() => ({ drift: false }));
+  const driftNode = (0, import_core3.node)(
+    [opts.source, baseline],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(detectDriftFn(data[0], data[1]));
+    },
+    { describeKind: "derived", meta: baseMeta2("data_quality", { stage: "drift" }) }
+  );
+  g.add(driftNode, { name: "drift" });
+  const suggestFn = opts.suggest ?? (() => null);
+  const remediateNode = (0, import_core3.node)(
+    [validateNode, anomalyNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(
+        suggestFn({
+          validation: data[0],
+          anomaly: data[1]
+        })
+      );
+    },
+    { describeKind: "derived", meta: baseMeta2("data_quality", { stage: "remediate" }) }
+  );
+  g.add(remediateNode, { name: "remediate" });
+  const output = (0, import_core3.node)(
+    [validateNode, anomalyNode, driftNode, remediateNode],
+    (batchData, actions, ctx) => {
+      const vals = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      actions.emit({
+        validation: vals[0],
+        anomaly: vals[1],
+        drift: vals[2],
+        remediation: vals[3]
+      });
+    },
+    { describeKind: "derived", meta: baseMeta2("data_quality", { stage: "output" }) }
+  );
+  g.add(output, { name: "output" });
+  const validationRules = (0, import_core3.node)([], {
+    initial: [],
+    meta: baseMeta2("data_quality", { stage: "validation_rules" })
+  });
+  g.add(validationRules, { name: "validation_rules" });
+  const fbCondition = (0, import_core3.node)(
+    [anomalyNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch4, i) => batch4 != null && batch4.length > 0 ? batch4.at(-1) : ctx.prevData[i]
+      );
+      const a = data[0];
+      actions.emit(a?.anomaly ? a : null);
+    },
+    {
+      describeKind: "derived",
+      meta: baseMeta2("data_quality", { stage: "feedback_condition" })
+    }
+  );
+  g.add(fbCondition, { name: "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;
+}
+//# sourceMappingURL=index.cjs.map