@goplasmatic/dataflow-ui 2.0.4 → 2.0.6

package/dist/index.js

@@ -1,3 +1,6 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import require$$0, { createContext, useState, useEffect, useContext, forwardRef, createElement, useReducer, useRef, useCallback, memo, useMemo, useLayoutEffect, Component } from "react";
 import { createPortal } from "react-dom";
@@ -241,6 +244,21 @@ const FileJson = createLucideIcon("FileJson", [
     { d: "M14 18a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1 1 1 0 0 1-1-1v-1a1 1 0 0 0-1-1", key: "mpwhp6" }
   ]
 ]);
+/**
+ * @license lucide-react v0.462.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Folder = createLucideIcon("Folder", [
+  [
+    "path",
+    {
+      d: "M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z",
+      key: "1kt360"
+    }
+  ]
+]);
 /**
  * @license lucide-react v0.462.0 - ISC
  *
@@ -626,7 +644,8 @@ const DebuggerContext = createContext(null);
 function DebuggerProvider({
   children: children2,
   initialPayload,
-  autoActivate = false
+  autoActivate = false,
+  engineFactory
 }) {
   const [state, dispatch2] = useReducer(debuggerReducer, {
     ...initialState,
@@ -634,6 +653,9 @@ function DebuggerProvider({
     isActive: autoActivate
   });
   const playbackTimerRef = useRef(null);
+  const engineRef = useRef(null);
+  const lastWorkflowsJsonRef = useRef(null);
+  const isEngineReady = Boolean(engineFactory);
   const activate = useCallback(() => dispatch2({ type: "ACTIVATE" }), []);
   const deactivate = useCallback(() => dispatch2({ type: "DEACTIVATE" }), []);
   const setInputPayload = useCallback(
@@ -657,6 +679,38 @@ function DebuggerProvider({
   const stepBackward = useCallback(() => dispatch2({ type: "STEP_BACKWARD" }), []);
   const goToStep = useCallback((index2) => dispatch2({ type: "GO_TO_STEP", index: index2 }), []);
   const setSpeed = useCallback((speed) => dispatch2({ type: "SET_SPEED", speed }), []);
+  const runExecution = useCallback(
+    async (workflows, payload) => {
+      var _a;
+      if (workflows.length === 0 || !engineFactory) {
+        return null;
+      }
+      try {
+        const workflowsJson = JSON.stringify(workflows);
+        if (lastWorkflowsJsonRef.current !== workflowsJson || !engineRef.current) {
+          if ((_a = engineRef.current) == null ? void 0 : _a.dispose) {
+            engineRef.current.dispose();
+          }
+          engineRef.current = engineFactory(workflows);
+          lastWorkflowsJsonRef.current = workflowsJson;
+        }
+        return await engineRef.current.processWithTrace(payload);
+      } catch (error) {
+        console.error("Execution error:", error);
+        throw error;
+      }
+    },
+    [engineFactory]
+  );
+  useEffect(() => {
+    return () => {
+      var _a;
+      if ((_a = engineRef.current) == null ? void 0 : _a.dispose) {
+        engineRef.current.dispose();
+        engineRef.current = null;
+      }
+    };
+  }, []);
   useEffect(() => {
     if (state.playbackState === "playing") {
       playbackTimerRef.current = window.setInterval(() => {
@@ -699,6 +753,7 @@ function DebuggerProvider({
     stepBackward,
     goToStep,
     setSpeed,
+    runExecution,
     currentStep,
     currentMessage,
     currentChanges,
@@ -706,7 +761,8 @@ function DebuggerProvider({
     isAtEnd,
     hasTrace,
     progress,
-    totalSteps
+    totalSteps,
+    isEngineReady
   };
   return /* @__PURE__ */ jsx(DebuggerContext.Provider, { value, children: children2 });
 }
@@ -9607,9 +9663,9 @@ function ResizeControl({ nodeId, position, variant = ResizeControlVariant.Handle
   }, children: children2 });
 }
 memo(ResizeControl);
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
 let CATEGORY_COLORS, DataLogicEditor, OPERATORS, applyTreeLayout, jsonLogicToNodes;
 (async () => {
   const BRANCH_COLORS = {
@@ -13343,23 +13399,23 @@ let CATEGORY_COLORS, DataLogicEditor, OPERATORS, applyTreeLayout, jsonLogicToNod
     var EDGE_KEY_DELIM = "
";
     class Graph {
       constructor(opts) {
-        __publicField(this, "_isDirected", true);
-        __publicField(this, "_isMultigraph", false);
-        __publicField(this, "_isCompound", false);
-        __publicField(this, "_label");
-        __publicField(this, "_defaultNodeLabelFn", () => void 0);
-        __publicField(this, "_defaultEdgeLabelFn", () => void 0);
-        __publicField(this, "_nodes", {});
-        __publicField(this, "_in", {});
-        __publicField(this, "_preds", {});
-        __publicField(this, "_out", {});
-        __publicField(this, "_sucs", {});
-        __publicField(this, "_edgeObjs", {});
-        __publicField(this, "_edgeLabels", {});
-        __publicField(this, "_nodeCount", 0);
-        __publicField(this, "_edgeCount", 0);
-        __publicField(this, "_parent");
-        __publicField(this, "_children");
+        __publicField2(this, "_isDirected", true);
+        __publicField2(this, "_isMultigraph", false);
+        __publicField2(this, "_isCompound", false);
+        __publicField2(this, "_label");
+        __publicField2(this, "_defaultNodeLabelFn", () => void 0);
+        __publicField2(this, "_defaultEdgeLabelFn", () => void 0);
+        __publicField2(this, "_nodes", {});
+        __publicField2(this, "_in", {});
+        __publicField2(this, "_preds", {});
+        __publicField2(this, "_out", {});
+        __publicField2(this, "_sucs", {});
+        __publicField2(this, "_edgeObjs", {});
+        __publicField2(this, "_edgeLabels", {});
+        __publicField2(this, "_nodeCount", 0);
+        __publicField2(this, "_edgeCount", 0);
+        __publicField2(this, "_parent");
+        __publicField2(this, "_children");
         if (opts) {
           this._isDirected = Object.hasOwn(opts, "directed") ? opts.directed : true;
           this._isMultigraph = Object.hasOwn(opts, "multigraph") ? opts.multigraph : false;
@@ -13891,8 +13947,8 @@ let CATEGORY_COLORS, DataLogicEditor, OPERATORS, applyTreeLayout, jsonLogicToNod
     hasRequiredPriorityQueue = 1;
     class PriorityQueue {
       constructor() {
-        __publicField(this, "_arr", []);
-        __publicField(this, "_keyIndices", {});
+        __publicField2(this, "_arr", []);
+        __publicField2(this, "_keyIndices", {});
       }
       size() {
         return this._arr.length;
@@ -17572,13 +17628,13 @@ let CATEGORY_COLORS, DataLogicEditor, OPERATORS, applyTreeLayout, jsonLogicToNod
         try {
           setLoading(true);
           setError(null);
-          const wasm = await import("./datalogic_wasm-4utZNR2J-DW6r1ZIK.js");
-          await wasm.default();
+          const wasm2 = await import("./datalogic_wasm-4utZNR2J-DW6r1ZIK.js");
+          await wasm2.default();
           if (!cancelled) {
             moduleRef.current = {
-              evaluate: wasm.evaluate,
-              evaluate_with_trace: wasm.evaluate_with_trace,
-              CompiledRule: wasm.CompiledRule
+              evaluate: wasm2.evaluate,
+              evaluate_with_trace: wasm2.evaluate_with_trace,
+              CompiledRule: wasm2.CompiledRule
             };
             setReady(true);
             setLoading(false);
@@ -19852,31 +19908,38 @@ function TreeNode({
   };
   const debugStateClass = debugState ? `df-tree-node-${debugState}` : "";
   const currentClass = isCurrent ? "df-tree-node-current-step" : "";
-  return /* @__PURE__ */ jsxs("div", { className: `df-tree-node ${debugStateClass} ${currentClass}`, children: [
-    /* @__PURE__ */ jsxs(
-      "div",
-      {
-        className: `df-tree-node-content ${isSelected ? "df-tree-node-selected" : ""}`,
-        style: { paddingLeft: `${level * 16 + 8}px` },
-        onClick: handleClick,
-        children: [
-          /* @__PURE__ */ jsx(
-            "span",
-            {
-              className: "df-tree-toggle",
-              onClick: hasChildren ? handleToggle : void 0,
-              style: { visibility: hasChildren ? "visible" : "hidden" },
-              children: isExpanded ? /* @__PURE__ */ jsx(ChevronDown, { size: 14 }) : /* @__PURE__ */ jsx(ChevronRight, { size: 14 })
-            }
-          ),
-          icon && /* @__PURE__ */ jsx("span", { className: "df-tree-icon", style: iconColor ? { color: iconColor } : void 0, children: icon }),
-          /* @__PURE__ */ jsx("span", { className: "df-tree-label", children: label }),
-          debugState && /* @__PURE__ */ jsx("span", { className: "df-tree-debug-indicator", children: /* @__PURE__ */ jsx(DebugStateIcon, { state: debugState, conditionResult }) })
-        ]
-      }
-    ),
-    isExpanded && hasChildren && /* @__PURE__ */ jsx("div", { className: "df-tree-children", children: children2 })
-  ] });
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `df-tree-node ${debugStateClass} ${currentClass}`,
+      "data-current-step": isCurrent ? "true" : void 0,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: `df-tree-node-content ${isSelected ? "df-tree-node-selected" : ""}`,
+            style: { paddingLeft: `${level * 16 + 8}px` },
+            onClick: handleClick,
+            children: [
+              /* @__PURE__ */ jsx(
+                "span",
+                {
+                  className: "df-tree-toggle",
+                  onClick: hasChildren ? handleToggle : void 0,
+                  style: { visibility: hasChildren ? "visible" : "hidden" },
+                  children: isExpanded ? /* @__PURE__ */ jsx(ChevronDown, { size: 14 }) : /* @__PURE__ */ jsx(ChevronRight, { size: 14 })
+                }
+              ),
+              icon && /* @__PURE__ */ jsx("span", { className: "df-tree-icon", style: iconColor ? { color: iconColor } : void 0, children: icon }),
+              /* @__PURE__ */ jsx("span", { className: "df-tree-label", children: label }),
+              debugState && /* @__PURE__ */ jsx("span", { className: "df-tree-debug-indicator", children: /* @__PURE__ */ jsx(DebugStateIcon, { state: debugState, conditionResult }) })
+            ]
+          }
+        ),
+        isExpanded && hasChildren && /* @__PURE__ */ jsx("div", { className: "df-tree-children", children: children2 })
+      ]
+    }
+  );
 }
 const TREE_COLORS = {
   workflow: "#0078d4",
@@ -19889,8 +19952,10 @@ const TREE_COLORS = {
   // VSCode teal/green
   validation: "#ce9178",
   // VSCode orange
-  tasks: "#9d9d9d"
+  tasks: "#9d9d9d",
   // VSCode gray
+  folder: "#dcb67a"
+  // VSCode folder yellow/gold
 };
 function TaskNode({
   task,
@@ -20089,20 +20154,177 @@ function WorkflowNode({
     }
   );
 }
+function FolderNode({
+  folder,
+  level,
+  selection: selection2,
+  onSelect,
+  expandedNodes,
+  toggleNode,
+  debugMode = false
+}) {
+  const folderId = `folder-${folder.fullPath}`;
+  const isExpanded = expandedNodes.has(folderId);
+  const hasChildren = folder.folders.size > 0 || folder.workflows.length > 0;
+  const sortedFolders = Array.from(folder.folders.values()).sort(
+    (a, b) => a.name.localeCompare(b.name)
+  );
+  return /* @__PURE__ */ jsxs(
+    TreeNode,
+    {
+      label: `${folder.name} (${folder.totalWorkflowCount})`,
+      icon: /* @__PURE__ */ jsx(Folder, { size: 14 }),
+      iconColor: TREE_COLORS.folder,
+      isExpanded,
+      hasChildren,
+      level,
+      onToggle: () => toggleNode(folderId),
+      onClick: () => toggleNode(folderId),
+      children: [
+        sortedFolders.map((childFolder) => /* @__PURE__ */ jsx(
+          FolderNode,
+          {
+            folder: childFolder,
+            level: level + 1,
+            selection: selection2,
+            onSelect,
+            expandedNodes,
+            toggleNode,
+            debugMode
+          },
+          childFolder.fullPath
+        )),
+        folder.workflows.map((workflow) => /* @__PURE__ */ jsx(
+          WorkflowNode,
+          {
+            workflow,
+            level: level + 1,
+            selection: selection2,
+            onSelect,
+            expandedNodes,
+            toggleNode,
+            debugMode
+          },
+          workflow.id
+        ))
+      ]
+    }
+  );
+}
+function parsePath(path) {
+  if (!path) return [];
+  const trimmed = path.replace(/^\/+|\/+$/g, "");
+  if (!trimmed) return [];
+  return trimmed.split("/").filter((segment) => segment.length > 0);
+}
+function createFolderNode(name, fullPath) {
+  return {
+    name,
+    fullPath,
+    folders: /* @__PURE__ */ new Map(),
+    workflows: [],
+    totalWorkflowCount: 0
+  };
+}
+function calculateTotalCount(node) {
+  let count = node.workflows.length;
+  for (const child of node.folders.values()) {
+    count += calculateTotalCount(child);
+  }
+  node.totalWorkflowCount = count;
+  return count;
+}
+function buildFolderTree(workflows) {
+  const tree = {
+    folders: /* @__PURE__ */ new Map(),
+    workflows: []
+  };
+  const sortedWorkflows = [...workflows].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+  for (const workflow of sortedWorkflows) {
+    const segments = parsePath(workflow.path);
+    if (segments.length === 0) {
+      tree.workflows.push(workflow);
+    } else {
+      let currentLevel = tree.folders;
+      let currentPath = "";
+      for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        currentPath = currentPath ? `${currentPath}/${segment}` : segment;
+        if (!currentLevel.has(segment)) {
+          currentLevel.set(segment, createFolderNode(segment, currentPath));
+        }
+        const folder = currentLevel.get(segment);
+        if (i === segments.length - 1) {
+          folder.workflows.push(workflow);
+        } else {
+          currentLevel = folder.folders;
+        }
+      }
+    }
+  }
+  for (const folder of tree.folders.values()) {
+    calculateTotalCount(folder);
+  }
+  return tree;
+}
+function getFirstLevelFolderIds(tree) {
+  return Array.from(tree.folders.keys()).map((name) => `folder-${name}`);
+}
+function getParentFolderIds(path) {
+  const segments = parsePath(path);
+  if (segments.length === 0) return [];
+  const ids = [];
+  let currentPath = "";
+  for (const segment of segments) {
+    currentPath = currentPath ? `${currentPath}/${segment}` : segment;
+    ids.push(`folder-${currentPath}`);
+  }
+  return ids;
+}
 function TreeView({ workflows, selection: selection2, onSelect, debugMode = false }) {
   const debuggerContext = useDebugger();
   const effectiveDebugContext = debugMode ? debuggerContext : null;
+  const folderTree = useMemo(() => buildFolderTree(workflows), [workflows]);
+  const sortedRootFolders = useMemo(() => {
+    return Array.from(folderTree.folders.values()).sort(
+      (a, b) => a.name.localeCompare(b.name)
+    );
+  }, [folderTree]);
+  const rootWorkflows = folderTree.workflows;
   const [expandedNodes, setExpandedNodes] = useState(() => {
     const initial = /* @__PURE__ */ new Set(["workflows-root"]);
-    if (workflows.length > 0) {
-      initial.add(`workflow-${workflows[0].id}`);
-    }
+    getFirstLevelFolderIds(folderTree).forEach((id2) => initial.add(id2));
     return initial;
   });
-  const sortedWorkflows = useMemo(() => {
-    return [...workflows].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
-  }, [workflows]);
+  useEffect(() => {
+    setExpandedNodes((prev) => {
+      const next = new Set(prev);
+      next.add("workflows-root");
+      getFirstLevelFolderIds(folderTree).forEach((id2) => next.add(id2));
+      return next;
+    });
+  }, [folderTree]);
+  useEffect(() => {
+    const allWorkflows = [...folderTree.workflows];
+    function collectWorkflows(folders) {
+      for (const folder of folders.values()) {
+        allWorkflows.push(...folder.workflows);
+        collectWorkflows(folder.folders);
+      }
+    }
+    collectWorkflows(folderTree.folders);
+    if (allWorkflows.length > 0) {
+      allWorkflows.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+      setExpandedNodes((prev) => {
+        const next = new Set(prev);
+        next.add(`workflow-${allWorkflows[0].id}`);
+        getParentFolderIds(allWorkflows[0].path).forEach((id2) => next.add(id2));
+        return next;
+      });
+    }
+  }, [folderTree]);
   const lastSelectedRef = useRef(null);
+  const treeContainerRef = useRef(null);
   useEffect(() => {
     var _a, _b;
     if (!debugMode || !(effectiveDebugContext == null ? void 0 : effectiveDebugContext.currentStep) || effectiveDebugContext.state.currentStepIndex < 0) {
@@ -20112,9 +20334,13 @@ function TreeView({ workflows, selection: selection2, onSelect, debugMode = fals
     if (((_a = lastSelectedRef.current) == null ? void 0 : _a.workflowId) === workflow_id && ((_b = lastSelectedRef.current) == null ? void 0 : _b.taskId) === task_id) {
       return;
     }
+    const workflow = workflows.find((w) => w.id === workflow_id);
     setExpandedNodes((prev) => {
       const next = new Set(prev);
       next.add("workflows-root");
+      if (workflow == null ? void 0 : workflow.path) {
+        getParentFolderIds(workflow.path).forEach((id2) => next.add(id2));
+      }
       next.add(`workflow-${workflow_id}`);
       next.add(`tasks-${workflow_id}`);
       if (task_id) {
@@ -20123,7 +20349,6 @@ function TreeView({ workflows, selection: selection2, onSelect, debugMode = fals
       return next;
     });
     if (task_id) {
-      const workflow = workflows.find((w) => w.id === workflow_id);
       const task = workflow == null ? void 0 : workflow.tasks.find((t) => t.id === task_id);
       if (workflow && task) {
         lastSelectedRef.current = { workflowId: workflow_id, taskId: task_id };
@@ -20132,6 +20357,16 @@ function TreeView({ workflows, selection: selection2, onSelect, debugMode = fals
     } else {
       lastSelectedRef.current = { workflowId: workflow_id };
     }
+    setTimeout(() => {
+      var _a2;
+      const currentStepElement = (_a2 = treeContainerRef.current) == null ? void 0 : _a2.querySelector('[data-current-step="true"]');
+      if (currentStepElement) {
+        currentStepElement.scrollIntoView({
+          behavior: "smooth",
+          block: "nearest"
+        });
+      }
+    }, 50);
   }, [debugMode, effectiveDebugContext == null ? void 0 : effectiveDebugContext.currentStep, effectiveDebugContext == null ? void 0 : effectiveDebugContext.state.currentStepIndex, workflows, onSelect]);
   const toggleNode = (id2) => {
     setExpandedNodes((prev) => {
@@ -20145,30 +20380,46 @@ function TreeView({ workflows, selection: selection2, onSelect, debugMode = fals
     });
   };
   const isRootExpanded = expandedNodes.has("workflows-root");
-  return /* @__PURE__ */ jsx("div", { className: `df-tree-view ${debugMode ? "df-tree-view-debug" : ""}`, children: /* @__PURE__ */ jsx(
+  const totalWorkflowCount = workflows.length;
+  return /* @__PURE__ */ jsx("div", { ref: treeContainerRef, className: `df-tree-view ${debugMode ? "df-tree-view-debug" : ""}`, children: /* @__PURE__ */ jsxs(
     TreeNode,
     {
       label: "Workflows",
       icon: /* @__PURE__ */ jsx(Layers, { size: 14 }),
       iconColor: TREE_COLORS.workflow,
       isExpanded: isRootExpanded,
-      hasChildren: sortedWorkflows.length > 0,
+      hasChildren: totalWorkflowCount > 0,
       level: 0,
       onToggle: () => toggleNode("workflows-root"),
       onClick: () => toggleNode("workflows-root"),
-      children: sortedWorkflows.map((workflow) => /* @__PURE__ */ jsx(
-        WorkflowNode,
-        {
-          workflow,
-          level: 1,
-          selection: selection2,
-          onSelect,
-          expandedNodes,
-          toggleNode,
-          debugMode
-        },
-        workflow.id
-      ))
+      children: [
+        sortedRootFolders.map((folder) => /* @__PURE__ */ jsx(
+          FolderNode,
+          {
+            folder,
+            level: 1,
+            selection: selection2,
+            onSelect,
+            expandedNodes,
+            toggleNode,
+            debugMode
+          },
+          folder.fullPath
+        )),
+        rootWorkflows.map((workflow) => /* @__PURE__ */ jsx(
+          WorkflowNode,
+          {
+            workflow,
+            level: 1,
+            selection: selection2,
+            onSelect,
+            expandedNodes,
+            toggleNode,
+            debugMode
+          },
+          workflow.id
+        ))
+      ]
     }
   ) });
 }
@@ -22021,6 +22272,223 @@ function DebugStateBadge({
     conditionResult !== void 0 && /* @__PURE__ */ jsx("span", { className: `df-debug-badge-condition ${conditionResult ? "df-debug-badge-condition-pass" : "df-debug-badge-condition-fail"}`, children: conditionResult ? /* @__PURE__ */ jsx(Check, { size: iconSize }) : /* @__PURE__ */ jsx(X, { size: iconSize }) })
   ] });
 }
+class WasmEngine {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    WasmEngineFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_wasmengine_free(ptr, 0);
+  }
+  /**
+   * Create a new WasmEngine from a JSON array of workflow definitions.
+   *
+   * # Arguments
+   * * `workflows_json` - JSON string containing an array of workflow definitions
+   *
+   * # Example
+   * ```javascript
+   * const workflows = JSON.stringify([{
+   *     id: "workflow1",
+   *     name: "My Workflow",
+   *     priority: 1,
+   *     tasks: [...]
+   * }]);
+   * const engine = new WasmEngine(workflows);
+   * ```
+   * @param {string} workflows_json
+   */
+  constructor(workflows_json) {
+    const ptr0 = passStringToWasm0(workflows_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.wasmengine_new(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0] >>> 0;
+    WasmEngineFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Process a payload through the engine's workflows.
+   *
+   * This is an async operation that returns a Promise.
+   *
+   * # Arguments
+   * * `payload_json` - JSON string of the payload to process
+   *
+   * # Returns
+   * A Promise that resolves to the processed message as a JSON string
+   *
+   * # Example
+   * ```javascript
+   * const payload = JSON.stringify({ name: "John", email: "john@example.com" });
+   * const result = await engine.process(payload);
+   * const processed = JSON.parse(result);
+   * console.log(processed.context.data);
+   * ```
+   * @param {string} payload_json
+   * @returns {Promise<any>}
+   */
+  process(payload_json) {
+    const ptr0 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.wasmengine_process(this.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
+  /**
+   * Process a payload with step-by-step execution tracing.
+   *
+   * This is an async operation that returns a Promise with the execution trace.
+   * The trace contains message snapshots after each step, including which
+   * workflows/tasks were executed or skipped.
+   *
+   * # Arguments
+   * * `payload_json` - JSON string of the payload to process
+   *
+   * # Returns
+   * A Promise that resolves to the execution trace as a JSON string
+   *
+   * # Example
+   * ```javascript
+   * const payload = JSON.stringify({ name: "John", email: "john@example.com" });
+   * const trace = await engine.process_with_trace(payload);
+   * const traceData = JSON.parse(trace);
+   * console.log(traceData.steps); // Array of execution steps
+   * ```
+   * @param {string} payload_json
+   * @returns {Promise<any>}
+   */
+  process_with_trace(payload_json) {
+    const ptr0 = passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.wasmengine_process_with_trace(this.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
+  /**
+   * Get the number of workflows registered in the engine.
+   * @returns {number}
+   */
+  workflow_count() {
+    const ret = wasm.wasmengine_workflow_count(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  /**
+   * Get the list of workflow IDs.
+   *
+   * # Returns
+   * JSON array of workflow IDs as a string
+   * @returns {string}
+   */
+  workflow_ids() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.wasmengine_workflow_ids(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+}
+if (Symbol.dispose) WasmEngine.prototype[Symbol.dispose] = WasmEngine.prototype.free;
+const WasmEngineFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_wasmengine_free(ptr >>> 0, 1));
+typeof FinalizationRegistry === "undefined" ? {} : new FinalizationRegistry((state) => state.dtor(state.a, state.b));
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+let cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+const cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+}
+let WASM_VECTOR_LEN = 0;
+let wasm;
+class WasmEngineAdapter {
+  constructor(workflows) {
+    __publicField(this, "engine");
+    const workflowsJson = JSON.stringify(workflows);
+    this.engine = new WasmEngine(workflowsJson);
+  }
+  async processWithTrace(payload) {
+    const payloadJson = JSON.stringify(payload);
+    const traceJson = await this.engine.process_with_trace(payloadJson);
+    return JSON.parse(traceJson);
+  }
+  dispose() {
+    this.engine.free();
+  }
+}
+const defaultEngineFactory = (workflows) => new WasmEngineAdapter(workflows);
 export {
   ConditionBadge,
   DebugInfoBubble,
@@ -22037,11 +22505,13 @@ export {
   TaskRow,
   ThemeProvider,
   TreeView,
+  WasmEngineAdapter,
   WorkflowCard,
   WorkflowFlowView,
   WorkflowVisualizer,
   cloneMessage,
   createEmptyMessage,
+  defaultEngineFactory,
   getChangesAtStep,
   getFunctionDisplayInfo,
   getMessageAtStep,