yaml-flow 4.0.0 → 5.1.0

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

@@ -1,13 +1,12 @@
 'use strict';
 
-var crypto = require('crypto');
 var child_process = require('child_process');
-var jsonata = require('jsonata');
+var jsonata2 = require('jsonata');
 require('ajv-formats');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var jsonata__default = /*#__PURE__*/_interopDefault(jsonata);
+var jsonata2__default = /*#__PURE__*/_interopDefault(jsonata2);
 
 // src/event-graph/constants.ts
 var TASK_STATUS = {
@@ -1029,9 +1028,11 @@ var MemoryJournal = class {
     return this.buffer.length;
   }
 };
+
+// src/continuous-event-graph/reactive.ts
 function computeDataHash(data) {
   const json = stableStringify(data);
-  return crypto.createHash("sha256").update(json).digest("hex").slice(0, 16);
+  return fnv1a64Hex(json);
 }
 function stableStringify(value) {
   if (value === null || value === void 0 || typeof value !== "object") {
@@ -1044,13 +1045,49 @@ function stableStringify(value) {
   const keys = Object.keys(obj).sort();
   return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
 }
+function fnv1a64Hex(input) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const mod = 0xffffffffffffffffn;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= BigInt(input.charCodeAt(i));
+    hash = hash * prime & mod;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function base64UrlEncode(input) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(input, "utf8").toString("base64url");
+  }
+  if (typeof btoa === "function") {
+    const bytes = new TextEncoder().encode(input);
+    let binary = "";
+    for (const b of bytes) binary += String.fromCharCode(b);
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+  }
+  throw new Error("No base64 encoder available in this runtime");
+}
+function base64UrlDecode(input) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(input, "base64url").toString("utf8");
+  }
+  if (typeof atob === "function") {
+    const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return new TextDecoder().decode(bytes);
+  }
+  throw new Error("No base64 decoder available in this runtime");
+}
 function encodeCallbackToken(taskName) {
   const payload = JSON.stringify({ t: taskName, n: Date.now().toString(36) + Math.random().toString(36).slice(2, 6) });
-  return Buffer.from(payload).toString("base64url");
+  return base64UrlEncode(payload);
 }
 function decodeCallbackToken(token) {
   try {
-    const payload = JSON.parse(Buffer.from(token, "base64url").toString());
+    const payload = JSON.parse(base64UrlDecode(token));
     if (typeof payload?.t === "string") return { taskName: payload.t };
     return null;
   } catch {
@@ -1678,18 +1715,18 @@ function deepSet(obj, path, value) {
 }
 async function run(node, options) {
   if (!node?.compute?.length) return node;
-  if (!node.state) node.state = {};
+  if (!node.card_data) node.card_data = {};
   node.computed_values = {};
   node._sourcesData = options?.sourcesData ?? {};
   const ctx = {
-    state: node.state,
+    card_data: node.card_data,
     requires: node.requires ?? {},
-    sources: node._sourcesData,
+    fetched_sources: node._sourcesData,
     computed_values: node.computed_values
   };
   for (const step of node.compute) {
     try {
-      const val = await jsonata__default.default(step.expr).evaluate(ctx);
+      const val = await jsonata2__default.default(step.expr).evaluate(ctx);
       deepSet(node.computed_values, step.bindTo, val);
       ctx.computed_values = node.computed_values;
     } catch (err) {
@@ -1700,16 +1737,16 @@ async function run(node, options) {
 }
 async function evalExpr(expr, node) {
   const ctx = {
-    state: node.state ?? {},
+    card_data: node.card_data ?? {},
     requires: node.requires ?? {},
-    sources: node._sourcesData ?? {},
+    fetched_sources: node._sourcesData ?? {},
     computed_values: node.computed_values ?? {}
   };
-  return jsonata__default.default(expr).evaluate(ctx);
+  return jsonata2__default.default(expr).evaluate(ctx);
 }
 function resolve(node, path) {
-  if (path.startsWith("sources.")) {
-    return deepGet(node._sourcesData ?? {}, path.slice("sources.".length));
+  if (path.startsWith("fetched_sources.")) {
+    return deepGet(node._sourcesData ?? {}, path.slice("fetched_sources.".length));
   }
   return deepGet(node, path);
 }
@@ -1729,8 +1766,7 @@ var VALID_ELEMENT_KINDS = /* @__PURE__ */ new Set([
   "markdown",
   "custom"
 ]);
-var VALID_STATUSES = /* @__PURE__ */ new Set(["fresh", "stale", "loading", "error"]);
-var ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "meta", "requires", "provides", "view", "state", "compute", "sources"]);
+var ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "meta", "requires", "provides", "view", "card_data", "compute", "sources"]);
 function validateNode(node) {
   const errors = [];
   if (!node || typeof node !== "object" || Array.isArray(node)) {
@@ -1741,13 +1777,8 @@ function validateNode(node) {
   for (const key of Object.keys(n)) {
     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");
-  } else {
-    const state = n.state;
-    if (state.status != null && !VALID_STATUSES.has(state.status)) {
-      errors.push(`state.status: must be one of: ${[...VALID_STATUSES].join(", ")}`);
-    }
+  if (n.card_data == null || typeof n.card_data !== "object" || Array.isArray(n.card_data)) {
+    errors.push("card_data: required, must be an object");
   }
   if (n.meta != null) {
     if (typeof n.meta !== "object" || Array.isArray(n.meta)) {
@@ -1836,11 +1867,21 @@ function validateNode(node) {
   }
   return { ok: errors.length === 0, errors };
 }
+function enrichSources(sources, context) {
+  if (!sources || sources.length === 0) return [];
+  return sources.map((src) => ({
+    ...src,
+    _requires: context.requires ?? {},
+    _sourcesData: context.sourcesData ?? {},
+    _computed_values: context.computed_values ?? {}
+  }));
+}
 var CardCompute = {
   run,
   eval: evalExpr,
   resolve,
-  validate: validateNode
+  validate: validateNode,
+  enrichSources
 };
 
 // src/continuous-event-graph/live-cards-bridge.ts
@@ -1876,7 +1917,7 @@ function liveCardsToReactiveGraph(input, options = {}) {
   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}` }]) {
+    for (const binding of card.provides ?? [{ bindTo: card.id, src: "card_data" }]) {
       allTokens.add(binding.bindTo);
       tokenToCardId.set(binding.bindTo, card.id);
     }
@@ -1890,7 +1931,7 @@ function liveCardsToReactiveGraph(input, options = {}) {
     }
     tasks[card.id] = {
       requires: requires.length > 0 ? requires : void 0,
-      provides: (card.provides ?? [{ bindTo: card.id, src: `state.${card.id}` }]).map((p) => p.bindTo),
+      provides: (card.provides ?? [{ bindTo: card.id, src: "card_data" }]).map((p) => p.bindTo),
       taskHandlers: [card.id],
       description: card.meta?.title ?? card.id
     };
@@ -1942,9 +1983,9 @@ function buildSourceHandler(card, sourceHandlers, defaultSourceHandler, sharedSt
     };
   }
   return async (input) => {
-    const state = { ...card.state };
-    sharedState.set(card.id, state);
-    getResolve()(input.callbackToken, state);
+    const data = { ...card.card_data };
+    sharedState.set(card.id, data);
+    getResolve()(input.callbackToken, data);
     return "task-initiated";
   };
 }
@@ -1967,7 +2008,7 @@ function buildCardHandler(card, cardHandlers, sharedState, _cardMap, tokenToCard
     }
     const computeNode = {
       id: card.id,
-      state: { ...card.state },
+      card_data: { ...card.card_data },
       requires: requiresData,
       compute: card.compute
     };
@@ -1979,9 +2020,9 @@ function buildCardHandler(card, cardHandlers, sharedState, _cardMap, tokenToCard
         resultData[bindTo] = CardCompute.resolve(computeNode, src);
       }
     } else {
-      resultData = { ...computeNode.state, ...computeNode.computed_values };
+      resultData = { ...computeNode.card_data, ...computeNode.computed_values };
     }
-    const resultState = { ...computeNode.state, ...computeNode.computed_values };
+    const resultState = { ...computeNode.card_data, ...computeNode.computed_values };
     sharedState.set(card.id, resultState);
     getResolve()(input.callbackToken, resultData);
     return "task-initiated";