@graphrefly/graphrefly 0.8.0 → 0.9.0

package/dist/index.js

@@ -142,9 +142,6 @@ import {
   cqrs_exports,
   nestjs_exports
 } from "./chunk-UCW3VWMN.js";
-import {
-  core_exports
-} from "./chunk-E7OH6ZAZ.js";
 import {
   JsonCodec,
   createDagCborCodec,
@@ -186,6 +183,9 @@ import {
   toMessages$,
   toObservable
 } from "./chunk-YWTP2XRJ.js";
+import {
+  core_exports
+} from "./chunk-E7OH6ZAZ.js";
 import {
   ResettableTimer
 } from "./chunk-WZ2Z2CRV.js";
@@ -1048,7 +1048,8 @@ __export(patterns_exports, {
   layout: () => reactive_layout_exports,
   memory: () => memory_exports,
   messaging: () => messaging_exports,
-  orchestration: () => orchestration_exports
+  orchestration: () => orchestration_exports,
+  reduction: () => reduction_exports
 });
 
 // src/patterns/ai.ts
@@ -3802,6 +3803,277 @@ 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 {
@@ -3977,6 +4249,7 @@ export {
   reactiveLog,
   reactiveMap,
   reduce,
+  reduction_exports as reduction,
   repeat,
   replay,
   replayWAL,