yaml-flow 3.1.0 → 4.0.0

package/dist/continuous-event-graph/index.cjs

@@ -1,10 +1,14 @@
 'use strict';
 
-var fs = require('fs');
 var crypto = require('crypto');
 var child_process = require('child_process');
+var jsonata = require('jsonata');
 require('ajv-formats');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var jsonata__default = /*#__PURE__*/_interopDefault(jsonata);
+
 // src/event-graph/constants.ts
 var TASK_STATUS = {
   NOT_STARTED: "not-started",
@@ -247,43 +251,51 @@ function applyEvent(live, event) {
   if ("executionId" in event && event.executionId && event.executionId !== state.executionId) {
     return live;
   }
-  let newState;
   switch (event.type) {
+    // --- Execution state transitions ---
     case "task-started":
-      newState = applyTaskStart(state, event.taskName);
-      break;
+      return { config, state: applyTaskStart(state, event.taskName) };
     case "task-completed":
-      newState = applyTaskCompletion(state, config, event.taskName, event.result, event.dataHash, event.data);
-      break;
+      return { config, state: applyTaskCompletion(state, config, event.taskName, event.result, event.dataHash, event.data) };
     case "task-failed":
-      newState = applyTaskFailure(state, config, event.taskName, event.error);
-      break;
+      return { config, state: applyTaskFailure(state, config, event.taskName, event.error) };
     case "task-progress":
-      newState = applyTaskProgress(state, event.taskName, event.message, event.progress);
-      break;
+      return { config, state: applyTaskProgress(state, event.taskName, event.message, event.progress) };
     case "task-restart":
-      newState = applyTaskRestart(state, event.taskName);
-      break;
+      return { config, state: applyTaskRestart(state, event.taskName) };
     case "inject-tokens":
-      newState = {
-        ...state,
-        availableOutputs: [.../* @__PURE__ */ new Set([...state.availableOutputs, ...event.tokens])],
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      return {
+        config,
+        state: {
+          ...state,
+          availableOutputs: [.../* @__PURE__ */ new Set([...state.availableOutputs, ...event.tokens])],
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+        }
       };
-      break;
     case "agent-action":
-      newState = applyAgentAction(state, event.action);
-      break;
+      return { config, state: applyAgentAction(state, event.action) };
+    // --- Structural mutations ---
+    case "task-upsert":
+      return addNode(live, event.taskName, event.taskConfig);
+    case "task-removal":
+      return removeNode(live, event.taskName);
+    case "node-requires-add":
+      return addRequires(live, event.nodeName, event.tokens);
+    case "node-requires-remove":
+      return removeRequires(live, event.nodeName, event.tokens);
+    case "node-provides-add":
+      return addProvides(live, event.nodeName, event.tokens);
+    case "node-provides-remove":
+      return removeProvides(live, event.nodeName, event.tokens);
     default:
       return live;
   }
-  return { config, state: newState };
 }
 function applyEvents(live, events) {
   return events.reduce((current, event) => applyEvent(current, event), live);
 }
 function addNode(live, name, taskConfig) {
-  if (live.config.tasks[name]) return live;
+  const exists = !!live.config.tasks[name];
   return {
     config: {
       ...live.config,
@@ -291,7 +303,10 @@ function addNode(live, name, taskConfig) {
     },
     state: {
       ...live.state,
-      tasks: { ...live.state.tasks, [name]: createDefaultGraphEngineStore2() },
+      tasks: {
+        ...live.state.tasks,
+        [name]: exists ? live.state.tasks[name] : createDefaultGraphEngineStore2()
+      },
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
     }
   };
@@ -998,6 +1013,8 @@ function getDownstream(live, nodeName) {
   }));
   return { nodeName, nodes, tokens: [...tokenSet] };
 }
+
+// src/continuous-event-graph/journal.ts
 var MemoryJournal = class {
   buffer = [];
   append(event) {
@@ -1012,36 +1029,6 @@ var MemoryJournal = class {
     return this.buffer.length;
   }
 };
-var FileJournal = class {
-  constructor(path) {
-    this.path = path;
-    if (!fs.existsSync(path)) {
-      fs.writeFileSync(path, "", "utf-8");
-    }
-  }
-  path;
-  pending = 0;
-  append(event) {
-    fs.appendFileSync(this.path, JSON.stringify(event) + "\n", "utf-8");
-    this.pending++;
-  }
-  drain() {
-    const content = fs.readFileSync(this.path, "utf-8").trim();
-    fs.writeFileSync(this.path, "", "utf-8");
-    this.pending = 0;
-    if (!content) return [];
-    return content.split("\n").map((line) => JSON.parse(line));
-  }
-  get size() {
-    try {
-      const content = fs.readFileSync(this.path, "utf-8").trim();
-      if (!content) return 0;
-      return content.split("\n").length;
-    } catch {
-      return this.pending;
-    }
-  }
-};
 function computeDataHash(data) {
   const json = stableStringify(data);
   return crypto.createHash("sha256").update(json).digest("hex").slice(0, 16);
@@ -1070,15 +1057,16 @@ function decodeCallbackToken(token) {
     return null;
   }
 }
-function createReactiveGraph(config, options, executionId) {
+function createReactiveGraph(configOrLive, options, executionId) {
   const {
     handlers: initialHandlers,
-    journal = new MemoryJournal(),
     onDrain
   } = options;
-  let live = createLiveGraph(config, executionId);
+  const inputQueue = new MemoryJournal();
+  let live = "state" in configOrLive && "config" in configOrLive ? configOrLive : createLiveGraph(configOrLive, executionId);
   let disposed = false;
   const handlers = new Map(Object.entries(initialHandlers));
+  const internalJournal = new MemoryJournal();
   let draining = false;
   let drainQueued = false;
   function drain() {
@@ -1098,7 +1086,9 @@ function createReactiveGraph(config, options, executionId) {
     }
   }
   function drainOnce() {
-    const events = journal.drain();
+    const internalEvents = internalJournal.drain();
+    const inputEvents = inputQueue.drain();
+    const events = [...internalEvents, ...inputEvents];
     if (events.length > 0) {
       live = applyEvents(live, events);
     }
@@ -1109,6 +1099,26 @@ function createReactiveGraph(config, options, executionId) {
     for (const taskName of result.eligible) {
       dispatchTask(taskName);
     }
+    for (const event of events) {
+      if (event.type === "task-progress") {
+        const { taskName, update } = event;
+        const taskConfig = live.config.tasks[taskName];
+        if (!taskConfig) continue;
+        const taskState = live.state.tasks[taskName];
+        if (!taskState || taskState.status !== "running") continue;
+        const callbackToken = encodeCallbackToken(taskName);
+        runPipeline(taskName, callbackToken, update).catch((error) => {
+          if (disposed) return;
+          internalJournal.append({
+            type: "task-failed",
+            taskName,
+            error: error.message ?? String(error),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          drain();
+        });
+      }
+    }
   }
   function resolveUpstreamState(taskName) {
     const taskConfig = live.config.tasks[taskName];
@@ -1130,7 +1140,7 @@ function createReactiveGraph(config, options, executionId) {
     }
     return state;
   }
-  async function runPipeline(taskName, callbackToken) {
+  async function runPipeline(taskName, callbackToken, update) {
     const taskConfig = live.config.tasks[taskName];
     const handlerNames = taskConfig.taskHandlers ?? [];
     const upstreamState = resolveUpstreamState(taskName);
@@ -1144,7 +1154,8 @@ function createReactiveGraph(config, options, executionId) {
         state: upstreamState,
         taskState: live.state.tasks[taskName],
         config: taskConfig,
-        callbackToken
+        callbackToken,
+        update
       };
       const status = await handler(input);
       if (status === "task-initiate-failure") {
@@ -1158,15 +1169,16 @@ function createReactiveGraph(config, options, executionId) {
     if (!handlerNames || handlerNames.length === 0) {
       return;
     }
-    journal.append({
+    internalJournal.append({
       type: "task-started",
       taskName,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
+    drain();
     const callbackToken = encodeCallbackToken(taskName);
     runPipeline(taskName, callbackToken).catch((error) => {
       if (disposed) return;
-      journal.append({
+      internalJournal.append({
         type: "task-failed",
         taskName,
         error: error.message ?? String(error),
@@ -1181,16 +1193,16 @@ function createReactiveGraph(config, options, executionId) {
       if (event.type === "task-completed" && event.data && !event.dataHash) {
         event = { ...event, dataHash: computeDataHash(event.data) };
       }
-      journal.append(event);
+      inputQueue.append(event);
       drain();
     },
     pushAll(events) {
       if (disposed) return;
       for (const event of events) {
         if (event.type === "task-completed" && event.data && !event.dataHash) {
-          journal.append({ ...event, dataHash: computeDataHash(event.data) });
+          inputQueue.append({ ...event, dataHash: computeDataHash(event.data) });
         } else {
-          journal.append(event);
+          inputQueue.append(event);
         }
       }
       drain();
@@ -1202,7 +1214,7 @@ function createReactiveGraph(config, options, executionId) {
       const { taskName } = decoded;
       if (!live.config.tasks[taskName]) return;
       if (errors && errors.length > 0) {
-        journal.append({
+        inputQueue.append({
           type: "task-failed",
           taskName,
           error: errors.join("; "),
@@ -1210,7 +1222,7 @@ function createReactiveGraph(config, options, executionId) {
         });
       } else {
         const dataHash = data && Object.keys(data).length > 0 ? computeDataHash(data) : void 0;
-        journal.append({
+        inputQueue.append({
           type: "task-completed",
           taskName,
           data,
@@ -1222,31 +1234,33 @@ function createReactiveGraph(config, options, executionId) {
     },
     addNode(name, taskConfig) {
       if (disposed) return;
-      live = addNode(live, name, taskConfig);
+      inputQueue.append({ type: "task-upsert", taskName: name, taskConfig, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       drain();
     },
     removeNode(name) {
       if (disposed) return;
-      live = removeNode(live, name);
+      inputQueue.append({ type: "task-removal", taskName: name, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      drain();
     },
     addRequires(nodeName, tokens) {
       if (disposed) return;
-      live = addRequires(live, nodeName, tokens);
+      inputQueue.append({ type: "node-requires-add", nodeName, tokens, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       drain();
     },
     removeRequires(nodeName, tokens) {
       if (disposed) return;
-      live = removeRequires(live, nodeName, tokens);
+      inputQueue.append({ type: "node-requires-remove", nodeName, tokens, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       drain();
     },
     addProvides(nodeName, tokens) {
       if (disposed) return;
-      live = addProvides(live, nodeName, tokens);
+      inputQueue.append({ type: "node-provides-add", nodeName, tokens, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       drain();
     },
     removeProvides(nodeName, tokens) {
       if (disposed) return;
-      live = removeProvides(live, nodeName, tokens);
+      inputQueue.append({ type: "node-provides-remove", nodeName, tokens, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      drain();
     },
     registerHandler(name, fn) {
       handlers.set(name, fn);
@@ -1257,7 +1271,7 @@ function createReactiveGraph(config, options, executionId) {
     retrigger(taskName) {
       if (disposed) return;
       if (!live.config.tasks[taskName]) return;
-      journal.append({
+      inputQueue.append({
         type: "task-restart",
         taskName,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -1268,7 +1282,7 @@ function createReactiveGraph(config, options, executionId) {
       if (disposed) return;
       for (const name of taskNames) {
         if (!live.config.tasks[name]) continue;
-        journal.append({
+        inputQueue.append({
           type: "task-restart",
           taskName: name,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -1276,6 +1290,9 @@ function createReactiveGraph(config, options, executionId) {
       }
       drain();
     },
+    snapshot() {
+      return snapshot(live);
+    },
     getState() {
       return live;
     },
@@ -1659,288 +1676,43 @@ function deepSet(obj, path, value) {
   }
   cur[parts[parts.length - 1]] = value;
 }
-var _fns = {};
-_fns.sum = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input : [];
-  return opts.field ? a.reduce((s, r) => s + (Number(r[opts.field]) || 0), 0) : a.reduce((s, v) => s + (Number(v) || 0), 0);
-};
-_fns.avg = (input, _e, opts) => {
-  const s = _fns.sum(input, _e, opts);
-  const n = Array.isArray(input) ? input.length : 1;
-  return n ? s / n : 0;
-};
-_fns.min = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input : [];
-  const vals = opts.field ? a.map((r) => Number(r[opts.field])) : a.map(Number);
-  return vals.length ? Math.min(...vals) : 0;
-};
-_fns.max = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input : [];
-  const vals = opts.field ? a.map((r) => Number(r[opts.field])) : a.map(Number);
-  return vals.length ? Math.max(...vals) : 0;
-};
-_fns.count = (input) => Array.isArray(input) ? input.length : input != null ? 1 : 0;
-_fns.first = (input) => Array.isArray(input) ? input[0] : input;
-_fns.last = (input) => Array.isArray(input) ? input[input.length - 1] : input;
-_fns.add = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.reduce((s, v) => s + Number(v), 0);
-};
-_fns.sub = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 ? Number(a[0]) - Number(a[1]) : 0;
-};
-_fns.mul = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.reduce((s, v) => s * Number(v), 1);
-};
-_fns.div = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && Number(a[1]) !== 0 ? Number(a[0]) / Number(a[1]) : 0;
-};
-_fns.round = (input, _e, opts) => {
-  const decimals = opts.decimals != null ? opts.decimals : 0;
-  const factor = Math.pow(10, decimals);
-  return Math.round(Number(input) * factor) / factor;
-};
-_fns.abs = (input) => Math.abs(Number(input));
-_fns.mod = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 ? Number(a[0]) % Number(a[1]) : 0;
-};
-_fns.gt = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && Number(a[0]) > Number(a[1]);
-};
-_fns.gte = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && Number(a[0]) >= Number(a[1]);
-};
-_fns.lt = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && Number(a[0]) < Number(a[1]);
-};
-_fns.lte = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && Number(a[0]) <= Number(a[1]);
-};
-_fns.eq = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && a[0] === a[1];
-};
-_fns.neq = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && a[0] !== a[1];
-};
-_fns.and = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.every(Boolean);
-};
-_fns.or = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.some(Boolean);
-};
-_fns.not = (input) => !input;
-_fns.concat = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.map((v) => v != null ? String(v) : "").join("");
-};
-_fns.upper = (input) => String(input || "").toUpperCase();
-_fns.lower = (input) => String(input || "").toLowerCase();
-_fns.template = (input, _e, opts) => {
-  let t = String(opts.format || "");
-  if (input && typeof input === "object" && !Array.isArray(input)) {
-    for (const k of Object.keys(input)) {
-      const v = input[k];
-      t = t.split("{{" + k + "}}").join(v != null ? String(v) : "");
-    }
-  }
-  return t;
-};
-_fns.join = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input : [];
-  const sep = opts.separator != null ? String(opts.separator) : ", ";
-  return a.map((v) => v != null ? String(v) : "").join(sep);
-};
-_fns.split = (input, _e, opts) => {
-  const sep = opts.separator != null ? String(opts.separator) : ",";
-  return String(input || "").split(sep).map((s) => s.trim());
-};
-_fns.trim = (input) => String(input || "").trim();
-_fns.pluck = (input, _e, opts) => Array.isArray(input) ? input.map((r) => r[opts.field]) : [];
-_fns.filter = (input, _e, opts) => {
-  if (!Array.isArray(input)) return [];
-  if (opts.field) return input.filter((r) => !!r[opts.field]);
-  return input.filter(Boolean);
-};
-_fns.map = (input) => Array.isArray(input) ? input.slice() : [];
-_fns.sort = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input.slice() : [];
-  const f = opts.field;
-  const dir = opts.direction === "desc" ? -1 : 1;
-  if (f) return a.sort((x, y) => x[f] > y[f] ? dir : x[f] < y[f] ? -dir : 0);
-  return a.sort((x, y) => x > y ? dir : x < y ? -dir : 0);
-};
-_fns.slice = (input, _e, opts) => Array.isArray(input) ? input.slice(opts.start || 0, opts.end) : input;
-_fns.flat = (input, _e, opts) => {
-  const depth = opts.depth != null ? opts.depth : 1;
-  return Array.isArray(input) ? input.flat(depth) : [input];
-};
-_fns.unique = (input) => {
-  if (!Array.isArray(input)) return [input];
-  const seen = /* @__PURE__ */ new Set();
-  return input.filter((v) => {
-    const key = typeof v === "object" ? JSON.stringify(v) : v;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-};
-_fns.group = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input : [];
-  const g = {};
-  a.forEach((r) => {
-    const k = String(r[opts.field] || "");
-    if (!g[k]) g[k] = [];
-    g[k].push(r);
-  });
-  return g;
-};
-_fns.flatten_keys = (input) => {
-  if (!input || typeof input !== "object" || Array.isArray(input)) return [];
-  const result = [];
-  for (const k of Object.keys(input)) {
-    const vals = Array.isArray(input[k]) ? input[k] : [input[k]];
-    vals.forEach((v) => result.push({ key: k, value: v }));
-  }
-  return result;
-};
-_fns.entries = (input) => {
-  if (!input || typeof input !== "object" || Array.isArray(input)) return [];
-  return Object.keys(input).map((k) => ({ key: k, value: input[k] }));
-};
-_fns.from_entries = (input) => {
-  if (!Array.isArray(input)) return {};
-  const obj = {};
-  input.forEach((item) => {
-    if (item.key != null) obj[item.key] = item.value;
-  });
-  return obj;
-};
-_fns.length = (input) => {
-  if (Array.isArray(input)) return input.length;
-  if (typeof input === "string") return input.length;
-  if (input && typeof input === "object") return Object.keys(input).length;
-  return 0;
-};
-_fns.get = (input, _e, opts) => deepGet(input, opts.field || opts.path || "");
-_fns.default = (input, _e, opts) => input != null ? input : opts.value;
-_fns.coalesce = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] != null) return a[i];
-  }
-  return null;
-};
-_fns.now = () => (/* @__PURE__ */ new Date()).toISOString();
-_fns.diff_days = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 ? Math.floor((new Date(a[0]).getTime() - new Date(a[1]).getTime()) / 864e5) : 0;
-};
-_fns.format_date = (input, _e, opts) => {
-  try {
-    const d = new Date(input);
-    if (opts.format === "iso") return d.toISOString();
-    if (opts.format === "date") return d.toLocaleDateString();
-    if (opts.format === "time") return d.toLocaleTimeString();
-    return d.toLocaleDateString();
-  } catch {
-    return String(input);
-  }
-};
-_fns.parse_date = (input) => {
-  try {
-    return new Date(input).toISOString();
-  } catch {
-    return null;
-  }
-};
-_fns.to_number = (input) => Number(input) || 0;
-_fns.to_string = (input) => input != null ? String(input) : "";
-_fns.to_bool = (input) => !!input;
-_fns.type_of = (input) => Array.isArray(input) ? "array" : typeof input;
-_fns.is_null = (input) => input == null;
-_fns.is_empty = (input) => {
-  if (input == null) return true;
-  if (Array.isArray(input)) return input.length === 0;
-  if (typeof input === "string") return input.length === 0;
-  if (typeof input === "object") return Object.keys(input).length === 0;
-  return false;
-};
-var _customFns = {};
-function evalExpr(expr, node) {
-  if (expr == null) return expr;
-  if (typeof expr !== "object" || Array.isArray(expr)) return expr;
-  const e = expr;
-  if (!e.fn) return expr;
-  let input = e.input;
-  if (typeof input === "string" && input.startsWith("state.")) {
-    input = deepGet(node, input);
-  } else if (Array.isArray(input)) {
-    input = input.map((v) => {
-      if (typeof v === "string" && v.startsWith("state.")) return deepGet(node, v);
-      if (v && typeof v === "object" && v.fn) return evalExpr(v, node);
-      return v;
-    });
-  } else if (input && typeof input === "object" && input.fn) {
-    input = evalExpr(input, node);
-  }
-  if (e.fn === "if") {
-    const cond = evalExpr(e.cond, node);
-    if (cond) {
-      return e.then && typeof e.then === "object" && e.then.fn ? evalExpr(e.then, node) : e.then;
-    } else {
-      return e.else && typeof e.else === "object" && e.else.fn ? evalExpr(e.else, node) : e.else;
-    }
-  }
-  if (e.fn === "filter" && Array.isArray(input) && e.where) {
-    return input.filter((item) => {
-      const tmp = { state: { ...node.state, $: item } };
-      return evalExpr(e.where, tmp);
-    });
-  }
-  if (e.fn === "map" && Array.isArray(input) && e.apply) {
-    return input.map((item) => {
-      const tmp = { state: { ...node.state, $: item } };
-      return evalExpr(e.apply, tmp);
-    });
-  }
-  const fn = _customFns[e.fn] || _fns[e.fn];
-  if (!fn) {
-    console.warn('CardCompute: unknown function "' + e.fn + '"');
-    return void 0;
-  }
-  return fn(input, evalExpr, e);
-}
-function run(node) {
-  if (!node || !node.compute) return node;
+async function run(node, options) {
+  if (!node?.compute?.length) return node;
   if (!node.state) node.state = {};
-  for (const key of Object.keys(node.compute)) {
+  node.computed_values = {};
+  node._sourcesData = options?.sourcesData ?? {};
+  const ctx = {
+    state: node.state,
+    requires: node.requires ?? {},
+    sources: node._sourcesData,
+    computed_values: node.computed_values
+  };
+  for (const step of node.compute) {
     try {
-      const val = evalExpr(node.compute[key], node);
-      deepSet(node.state, key, val);
+      const val = await jsonata__default.default(step.expr).evaluate(ctx);
+      deepSet(node.computed_values, step.bindTo, val);
+      ctx.computed_values = node.computed_values;
     } catch (err) {
-      console.error(`CardCompute.run error on "${node.id || "?"}.${key}":`, err);
+      console.error(`CardCompute.run error on "${node.id ?? "?"}.${step.bindTo}":`, err);
     }
   }
   return node;
 }
+async function evalExpr(expr, node) {
+  const ctx = {
+    state: node.state ?? {},
+    requires: node.requires ?? {},
+    sources: node._sourcesData ?? {},
+    computed_values: node.computed_values ?? {}
+  };
+  return jsonata__default.default(expr).evaluate(ctx);
+}
 function resolve(node, path) {
+  if (path.startsWith("sources.")) {
+    return deepGet(node._sourcesData ?? {}, path.slice("sources.".length));
+  }
   return deepGet(node, path);
 }
-function registerFunction(name, fn) {
-  _customFns[name] = fn;
-}
 var VALID_ELEMENT_KINDS = /* @__PURE__ */ new Set([
   "metric",
   "table",
@@ -1957,26 +1729,17 @@ var VALID_ELEMENT_KINDS = /* @__PURE__ */ new Set([
   "markdown",
   "custom"
 ]);
-var VALID_SOURCE_KINDS = /* @__PURE__ */ new Set(["api", "websocket", "static", "llm"]);
 var VALID_STATUSES = /* @__PURE__ */ new Set(["fresh", "stale", "loading", "error"]);
-var CARD_ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "type", "meta", "data", "view", "state", "compute"]);
-var SOURCE_ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "type", "meta", "data", "source", "state", "compute"]);
+var ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "meta", "requires", "provides", "view", "state", "compute", "sources"]);
 function validateNode(node) {
   const errors = [];
   if (!node || typeof node !== "object" || Array.isArray(node)) {
     return { ok: false, errors: ["Node must be a non-null object"] };
   }
   const n = node;
-  if (typeof n.id !== "string" || !n.id) {
-    errors.push("id: required, must be a non-empty string");
-  }
-  if (n.type !== "card" && n.type !== "source") {
-    errors.push('type: must be "card" or "source"');
-    return { ok: false, errors };
-  }
-  const allowed = n.type === "card" ? CARD_ALLOWED_KEYS : SOURCE_ALLOWED_KEYS;
+  if (typeof n.id !== "string" || !n.id) errors.push("id: required, must be a non-empty string");
   for (const key of Object.keys(n)) {
-    if (!allowed.has(key)) errors.push(`Unknown top-level key: "${key}"`);
+    if (!ALLOWED_KEYS.has(key)) errors.push(`Unknown top-level key: "${key}"`);
   }
   if (n.state == null || typeof n.state !== "object" || Array.isArray(n.state)) {
     errors.push("state: required, must be an object");
@@ -1995,37 +1758,58 @@ function validateNode(node) {
       if (meta.tags != null && !Array.isArray(meta.tags)) errors.push("meta.tags: must be an array");
     }
   }
-  if (n.data != null) {
-    if (typeof n.data !== "object" || Array.isArray(n.data)) {
-      errors.push("data: must be an object");
+  if (n.requires != null && !Array.isArray(n.requires)) errors.push("requires: must be an array of strings");
+  if (n.provides != null) {
+    if (!Array.isArray(n.provides)) {
+      errors.push("provides: must be an array of { bindTo, src } bindings");
     } else {
-      const data = n.data;
-      if (data.requires != null && !Array.isArray(data.requires)) errors.push("data.requires: must be an array of strings");
-      if (data.provides != null && (typeof data.provides !== "object" || Array.isArray(data.provides))) errors.push("data.provides: must be an object");
+      n.provides.forEach((p, i) => {
+        if (!p || typeof p !== "object" || Array.isArray(p)) {
+          errors.push(`provides[${i}]: must be an object with bindTo and src`);
+        } else {
+          const b = p;
+          if (typeof b.bindTo !== "string" || !b.bindTo) errors.push(`provides[${i}]: missing required "bindTo" string`);
+          if (typeof b.src !== "string" || !b.src) errors.push(`provides[${i}]: missing required "src" string`);
+        }
+      });
     }
   }
   if (n.compute != null) {
-    if (typeof n.compute !== "object" || Array.isArray(n.compute)) {
-      errors.push("compute: must be an object");
+    if (!Array.isArray(n.compute)) {
+      errors.push("compute: must be an array of compute steps");
     } else {
-      for (const [key, expr] of Object.entries(n.compute)) {
-        if (!expr || typeof expr !== "object" || Array.isArray(expr)) {
-          errors.push(`compute.${key}: must be a compute expression object`);
-        } else if (!expr.fn) {
-          errors.push(`compute.${key}: missing required "fn" property`);
+      n.compute.forEach((step, i) => {
+        if (!step || typeof step !== "object" || Array.isArray(step)) {
+          errors.push(`compute[${i}]: must be a compute step object`);
         } else {
-          const fn = expr.fn;
-          if (!_fns[fn] && !_customFns[fn]) {
-            errors.push(`compute.${key}: unknown function "${fn}"`);
+          const s = step;
+          if (typeof s.bindTo !== "string" || !s.bindTo) errors.push(`compute[${i}]: missing required "bindTo" property`);
+          if (typeof s.expr !== "string" || !s.expr) errors.push(`compute[${i}]: missing required "expr" string (JSONata expression)`);
+        }
+      });
+    }
+  }
+  if (n.sources != null) {
+    if (!Array.isArray(n.sources)) {
+      errors.push("sources: must be an array");
+    } else {
+      n.sources.forEach((src, i) => {
+        if (!src || typeof src !== "object" || Array.isArray(src)) {
+          errors.push(`sources[${i}]: must be an object`);
+        } else {
+          const s = src;
+          if (typeof s.bindTo !== "string" || !s.bindTo) errors.push(`sources[${i}]: missing required "bindTo" property`);
+          if (s.outputFile != null && typeof s.outputFile !== "string") errors.push(`sources[${i}]: outputFile must be a string`);
+          if (s.optionalForCompletionGating != null && typeof s.optionalForCompletionGating !== "boolean") {
+            errors.push(`sources[${i}]: optionalForCompletionGating must be a boolean`);
           }
         }
-      }
+      });
     }
   }
-  if (n.type === "card") {
-    if (n.source != null) errors.push('Card nodes must not have "source" \u2014 use type "source" instead');
-    if (n.view == null || typeof n.view !== "object" || Array.isArray(n.view)) {
-      errors.push("view: required for card nodes, must be an object");
+  if (n.view != null) {
+    if (typeof n.view !== "object" || Array.isArray(n.view)) {
+      errors.push("view: must be an object");
     } else {
       const view = n.view;
       if (!Array.isArray(view.elements) || view.elements.length === 0) {
@@ -2046,28 +1830,8 @@ function validateNode(node) {
           }
         });
       }
-      if (view.layout != null && (typeof view.layout !== "object" || Array.isArray(view.layout))) {
-        errors.push("view.layout: must be an object");
-      }
-      if (view.features != null && (typeof view.features !== "object" || Array.isArray(view.features))) {
-        errors.push("view.features: must be an object");
-      }
-    }
-  }
-  if (n.type === "source") {
-    if (n.view != null) errors.push('Source nodes must not have "view" \u2014 use type "card" instead');
-    if (n.source == null || typeof n.source !== "object" || Array.isArray(n.source)) {
-      errors.push("source: required for source nodes, must be an object");
-    } else {
-      const src = n.source;
-      if (!src.kind || !VALID_SOURCE_KINDS.has(src.kind)) {
-        errors.push(`source.kind: required, must be one of: ${[...VALID_SOURCE_KINDS].join(", ")}`);
-      }
-      if (typeof src.bindTo !== "string" || !src.bindTo) {
-        errors.push("source.bindTo: required, must be a state path string");
-      } else if (!src.bindTo.startsWith("state.")) {
-        errors.push('source.bindTo: must start with "state."');
-      }
+      if (view.layout != null && (typeof view.layout !== "object" || Array.isArray(view.layout))) errors.push("view.layout: must be an object");
+      if (view.features != null && (typeof view.features !== "object" || Array.isArray(view.features))) errors.push("view.features: must be an object");
     }
   }
   return { ok: errors.length === 0, errors };
@@ -2076,14 +1840,7 @@ var CardCompute = {
   run,
   eval: evalExpr,
   resolve,
-  validate: validateNode,
-  registerFunction,
-  get functions() {
-    const all = {};
-    for (const k of Object.keys(_fns)) all[k] = _fns[k];
-    for (const k of Object.keys(_customFns)) all[k] = _customFns[k];
-    return all;
-  }
+  validate: validateNode
 };
 
 // src/continuous-event-graph/live-cards-bridge.ts
@@ -2116,19 +1873,26 @@ function liveCardsToReactiveGraph(input, options = {}) {
   }
   const sharedState = options.sharedState ?? /* @__PURE__ */ new Map();
   const tasks = {};
+  const allTokens = /* @__PURE__ */ new Set();
+  const tokenToCardId = /* @__PURE__ */ new Map();
+  for (const card of cards) {
+    for (const binding of card.provides ?? [{ bindTo: card.id, src: `state.${card.id}` }]) {
+      allTokens.add(binding.bindTo);
+      tokenToCardId.set(binding.bindTo, card.id);
+    }
+  }
   for (const card of cards) {
-    const requires = card.data?.requires ?? [];
+    const requires = card.requires ?? [];
     for (const req of requires) {
-      if (!cardMap.has(req)) {
-        throw new Error(`Card "${card.id}" requires "${req}" but no card with that ID exists`);
+      if (!allTokens.has(req)) {
+        throw new Error(`Card "${card.id}" requires "${req}" but no card provides that token`);
       }
     }
     tasks[card.id] = {
       requires: requires.length > 0 ? requires : void 0,
-      provides: [card.id],
+      provides: (card.provides ?? [{ bindTo: card.id, src: `state.${card.id}` }]).map((p) => p.bindTo),
       taskHandlers: [card.id],
-      // each card has a named handler matching its ID
-      description: card.meta?.title ?? `${card.type}: ${card.id}`
+      description: card.meta?.title ?? card.id
     };
   }
   const config = {
@@ -2147,10 +1911,10 @@ function liveCardsToReactiveGraph(input, options = {}) {
     graphRef.resolveCallback(token, data, errors);
   };
   for (const card of cards) {
-    if (card.type === "source") {
+    if (card.sources && card.sources.length > 0) {
       handlers[card.id] = buildSourceHandler(card, sourceHandlers, defaultSourceHandler, sharedState, getResolve);
     } else {
-      handlers[card.id] = buildCardHandler(card, cardHandlers, sharedState, cardMap, getResolve);
+      handlers[card.id] = buildCardHandler(card, cardHandlers, sharedState, cardMap, tokenToCardId, getResolve);
     }
   }
   const graph = createReactiveGraph(
@@ -2184,7 +1948,7 @@ function buildSourceHandler(card, sourceHandlers, defaultSourceHandler, sharedSt
     return "task-initiated";
   };
 }
-function buildCardHandler(card, cardHandlers, sharedState, cardMap, getResolve) {
+function buildCardHandler(card, cardHandlers, sharedState, _cardMap, tokenToCardId, getResolve) {
   if (cardHandlers[card.id]) {
     const userHandler = cardHandlers[card.id];
     return async (input) => {
@@ -2192,49 +1956,38 @@ function buildCardHandler(card, cardHandlers, sharedState, cardMap, getResolve)
     };
   }
   return async (input) => {
+    const requiresData = {};
+    const requires = card.requires ?? [];
+    for (const token of requires) {
+      const producerId = tokenToCardId.get(token) ?? token;
+      const upstreamState = sharedState.get(producerId);
+      if (upstreamState) {
+        requiresData[token] = upstreamState[token] ?? upstreamState;
+      }
+    }
     const computeNode = {
       id: card.id,
       state: { ...card.state },
+      requires: requiresData,
       compute: card.compute
     };
-    const requires = card.data?.requires ?? [];
-    for (const upstreamId of requires) {
-      const upstreamState = sharedState.get(upstreamId);
-      if (upstreamState) {
-        computeNode.state[upstreamId] = upstreamState;
-      }
-      const upstreamCard = cardMap.get(upstreamId);
-      if (upstreamCard?.data?.provides && upstreamState) {
-        for (const [key, bindRef] of Object.entries(upstreamCard.data.provides)) {
-          if (typeof bindRef === "string" && bindRef.startsWith("state.")) {
-            const path = bindRef.slice(6);
-            const value = deepGet2(upstreamState, path);
-            if (value !== void 0) {
-              computeNode.state[key] = value;
-            }
-          }
-        }
+    await CardCompute.run(computeNode);
+    let resultData;
+    if (card.provides && card.provides.length > 0) {
+      resultData = {};
+      for (const { bindTo, src } of card.provides) {
+        resultData[bindTo] = CardCompute.resolve(computeNode, src);
       }
+    } else {
+      resultData = { ...computeNode.state, ...computeNode.computed_values };
     }
-    CardCompute.run(computeNode);
-    const resultState = { ...computeNode.state };
+    const resultState = { ...computeNode.state, ...computeNode.computed_values };
     sharedState.set(card.id, resultState);
-    getResolve()(input.callbackToken, resultState);
+    getResolve()(input.callbackToken, resultData);
     return "task-initiated";
   };
 }
-function deepGet2(obj, path) {
-  if (!path || !obj) return void 0;
-  const parts = path.split(".");
-  let cur = obj;
-  for (const part of parts) {
-    if (cur == null) return void 0;
-    cur = cur[part];
-  }
-  return cur;
-}
 
-exports.FileJournal = FileJournal;
 exports.MemoryJournal = MemoryJournal;
 exports.addNode = addNode;
 exports.addProvides = addProvides;