@geenius/ai-workflow 0.1.0 → 0.5.0

package/packages/react-css/dist/index.js

@@ -0,0 +1,2620 @@
+import { GeeniusError, ErrorCode } from '@geenius/tools/errors';
+import { z } from 'zod/v4';
+import { useState, useCallback, useRef, useEffect, useMemo } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// ../shared/dist/index.js
+function isRecord(value) {
+  return Boolean(value && typeof value === "object");
+}
+function resolvePath(obj, path) {
+  return path.split(".").reduce((acc, key) => {
+    if (isRecord(acc)) {
+      return acc[key];
+    }
+    return void 0;
+  }, obj);
+}
+function interpolate(template, vars) {
+  return template.replace(/\{\{([^}]+)\}\}/g, (match, expr) => {
+    const [path, defaultValue] = expr.trim().split("|").map((s) => s.trim());
+    const val = resolvePath(vars, path);
+    if (val !== void 0 && val !== null) {
+      return typeof val === "object" ? JSON.stringify(val) : String(val);
+    }
+    return defaultValue ?? "";
+  });
+}
+var WorkflowError = class _WorkflowError extends GeeniusError {
+  /**
+   * Create a structured workflow error.
+   *
+   * @param options Error metadata, message, and optional structured context.
+   * @returns A typed workflow error instance.
+   */
+  constructor(options) {
+    super({
+      code: options.code ?? ErrorCode.INTERNAL,
+      message: options.message,
+      cause: options.cause,
+      context: options.context
+    });
+    this.name = "WorkflowError";
+    Object.setPrototypeOf(this, _WorkflowError.prototype);
+  }
+};
+var WorkflowConfigurationError = class _WorkflowConfigurationError extends WorkflowError {
+  /**
+   * Create a configuration error for invalid workflow setup.
+   *
+   * @param message Human-readable explanation of the invalid configuration.
+   * @param context Optional structured metadata describing the failing config area.
+   * @returns A typed workflow configuration error.
+   */
+  constructor(message, context) {
+    super({
+      code: ErrorCode.INVALID_CONFIG,
+      message,
+      context
+    });
+    this.name = "WorkflowConfigurationError";
+    Object.setPrototypeOf(this, _WorkflowConfigurationError.prototype);
+  }
+};
+var WorkflowExecutionError = class _WorkflowExecutionError extends WorkflowError {
+  /**
+   * Create an execution error for a workflow runtime failure.
+   *
+   * @param message Human-readable explanation of the runtime failure.
+   * @param context Optional structured metadata describing the failing execution path.
+   * @param cause Optional underlying exception that triggered the runtime failure.
+   * @returns A typed workflow execution error.
+   */
+  constructor(message, context, cause) {
+    super({
+      code: ErrorCode.INTERNAL,
+      message,
+      cause,
+      context
+    });
+    this.name = "WorkflowExecutionError";
+    Object.setPrototypeOf(this, _WorkflowExecutionError.prototype);
+  }
+};
+var WorkflowGraphError = class _WorkflowGraphError extends WorkflowError {
+  /**
+   * Create a graph-validation error for an invalid workflow topology.
+   *
+   * @param message Human-readable explanation of the graph validation failure.
+   * @param context Optional structured metadata describing the invalid topology.
+   * @returns A typed workflow graph error.
+   */
+  constructor(message, context) {
+    super({
+      code: ErrorCode.VALIDATION,
+      message,
+      context
+    });
+    this.name = "WorkflowGraphError";
+    Object.setPrototypeOf(this, _WorkflowGraphError.prototype);
+  }
+};
+var WorkflowExpressionError = class _WorkflowExpressionError extends WorkflowError {
+  /**
+   * Create an expression error for a failed transform or condition expression.
+   *
+   * @param message Human-readable explanation of the expression failure.
+   * @param context Optional structured metadata including the source expression.
+   * @param cause Optional underlying parse or runtime error.
+   * @returns A typed workflow expression error.
+   */
+  constructor(message, context, cause) {
+    super({
+      code: ErrorCode.VALIDATION,
+      message,
+      cause,
+      context
+    });
+    this.name = "WorkflowExpressionError";
+    Object.setPrototypeOf(this, _WorkflowExpressionError.prototype);
+  }
+};
+function normalizeWorkflowError(error, fallbackMessage, context) {
+  if (error instanceof WorkflowError) {
+    return error;
+  }
+  if (error instanceof GeeniusError) {
+    return new WorkflowError({
+      code: error.code,
+      message: error.message,
+      cause: error,
+      context
+    });
+  }
+  if (error instanceof Error) {
+    return new WorkflowExecutionError(error.message, context, error);
+  }
+  return new WorkflowExecutionError(fallbackMessage, context, error);
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object");
+}
+function isExpressionOperand(value) {
+  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean";
+}
+function isRelationalOperand(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean";
+}
+function toPropertyKey(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "symbol") {
+    return value;
+  }
+  throw createExpressionError(
+    "Computed property access expects a string, number, or symbol key."
+  );
+}
+function createExpressionError(message, expression, cause) {
+  return new WorkflowExpressionError(
+    message,
+    expression ? { expression } : void 0,
+    cause
+  );
+}
+var FORBIDDEN_PROPERTIES = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor",
+  "caller",
+  "callee",
+  "arguments"
+]);
+var SAFE_GLOBALS = Object.freeze({
+  Math,
+  JSON: Object.freeze({
+    parse: JSON.parse.bind(JSON),
+    stringify: JSON.stringify.bind(JSON)
+  }),
+  Date: Object.freeze({
+    now: Date.now.bind(Date),
+    parse: Date.parse.bind(Date),
+    UTC: Date.UTC.bind(Date)
+  }),
+  Number: (value) => Number(value),
+  String: (value) => String(value),
+  Boolean: (value) => Boolean(value)
+});
+function isIdentifierStart(char) {
+  return /[A-Za-z_$]/.test(char);
+}
+function isIdentifierPart(char) {
+  return /[A-Za-z0-9_$]/.test(char);
+}
+function isDigit(char) {
+  return /[0-9]/.test(char);
+}
+function tokenize(expression) {
+  const tokens = [];
+  let index = 0;
+  const push = (type, value) => {
+    tokens.push({ type, value });
+  };
+  while (index < expression.length) {
+    const char = expression[index];
+    if (/\s/.test(char)) {
+      index++;
+      continue;
+    }
+    const three = expression.slice(index, index + 3);
+    if (three === "...") {
+      push("operator", "...");
+      index += 3;
+      continue;
+    }
+    const multi = [
+      "===",
+      "!==",
+      ">=",
+      "<=",
+      "&&",
+      "||",
+      "??",
+      "==",
+      "!=",
+      "**"
+    ];
+    const matched = multi.find((op) => expression.startsWith(op, index));
+    if (matched) {
+      push("operator", matched);
+      index += matched.length;
+      continue;
+    }
+    if (isDigit(char) || char === "." && isDigit(expression[index + 1] ?? "")) {
+      let end = index + 1;
+      while (end < expression.length && /[0-9.]/.test(expression[end])) end++;
+      push("number", expression.slice(index, end));
+      index = end;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const quote = char;
+      let end = index + 1;
+      let value = "";
+      while (end < expression.length) {
+        const current = expression[end];
+        if (current === "\\") {
+          const next = expression[end + 1];
+          if (next === void 0)
+            throw createExpressionError(
+              "Unterminated string literal.",
+              expression
+            );
+          const escapes = {
+            n: "\n",
+            r: "\r",
+            t: "	",
+            b: "\b",
+            f: "\f",
+            "\\": "\\",
+            '"': '"',
+            "'": "'"
+          };
+          value += escapes[next] ?? next;
+          end += 2;
+          continue;
+        }
+        if (current === quote) break;
+        value += current;
+        end++;
+      }
+      if (expression[end] !== quote)
+        throw createExpressionError("Unterminated string literal.", expression);
+      push("string", value);
+      index = end + 1;
+      continue;
+    }
+    if (isIdentifierStart(char)) {
+      let end = index + 1;
+      while (end < expression.length && isIdentifierPart(expression[end]))
+        end++;
+      push("identifier", expression.slice(index, end));
+      index = end;
+      continue;
+    }
+    const punctuators = ["(", ")", "{", "}", "[", "]", ".", ",", ":", "?"];
+    if (punctuators.includes(char)) {
+      push("punctuator", char);
+      index++;
+      continue;
+    }
+    const operators = ["+", "-", "*", "/", "%", "!", "<", ">", "="];
+    if (operators.includes(char)) {
+      push("operator", char);
+      index++;
+      continue;
+    }
+    throw createExpressionError(
+      `Unsupported token in expression: ${char}`,
+      expression
+    );
+  }
+  tokens.push({ type: "eof", value: "" });
+  return tokens;
+}
+var ExpressionParser = class {
+  tokens;
+  index = 0;
+  context;
+  constructor(expression, context) {
+    this.tokens = tokenize(expression);
+    this.context = context;
+  }
+  evaluate() {
+    const result = this.parseConditional();
+    this.expect("eof");
+    return this.unwrap(result);
+  }
+  current() {
+    return this.tokens[this.index] ?? { type: "eof", value: "" };
+  }
+  advance() {
+    const token = this.current();
+    this.index++;
+    return token;
+  }
+  match(type, value) {
+    const token = this.current();
+    if (token.type !== type) return false;
+    if (value !== void 0 && token.value !== value) return false;
+    this.index++;
+    return true;
+  }
+  expect(type, value) {
+    const token = this.current();
+    if (token.type !== type || value !== void 0 && token.value !== value) {
+      throw createExpressionError(
+        `Unexpected token "${token.value}" in expression.`
+      );
+    }
+    this.index++;
+    return token;
+  }
+  unwrap(value) {
+    if (this.isReference(value)) return value.value;
+    return value;
+  }
+  unwrapOperand(value) {
+    const operand = this.unwrap(value);
+    if (!isExpressionOperand(operand)) {
+      throw createExpressionError(
+        "Expression operand must resolve to a primitive value."
+      );
+    }
+    return operand;
+  }
+  relationalOperand(value) {
+    const operand = this.unwrap(value);
+    if (!isRelationalOperand(operand)) {
+      throw createExpressionError(
+        "Relational comparisons require primitive operands."
+      );
+    }
+    return operand;
+  }
+  isReference(value) {
+    return isRecord2(value) && value.__ref === true;
+  }
+  toReference(base, key) {
+    if (typeof key === "string" && FORBIDDEN_PROPERTIES.has(key)) {
+      throw createExpressionError(
+        `Access to property "${key}" is not allowed.`
+      );
+    }
+    if (base === null || base === void 0) {
+      throw createExpressionError(
+        `Cannot read property "${String(key)}" of ${base}.`
+      );
+    }
+    return {
+      __ref: true,
+      base,
+      key,
+      value: Reflect.get(Object(base), key)
+    };
+  }
+  resolveIdentifier(name) {
+    if (name === "true") return true;
+    if (name === "false") return false;
+    if (name === "null") return null;
+    if (name === "undefined") return void 0;
+    if (Object.prototype.hasOwnProperty.call(this.context, name)) {
+      return this.context[name];
+    }
+    if (Object.prototype.hasOwnProperty.call(SAFE_GLOBALS, name)) {
+      return SAFE_GLOBALS[name];
+    }
+    throw createExpressionError(`Unknown identifier in expression: ${name}.`);
+  }
+  parseConditional() {
+    let test = this.parseNullish();
+    if (this.match("punctuator", "?")) {
+      const consequent = this.parseConditional();
+      this.expect("punctuator", ":");
+      const alternate = this.parseConditional();
+      test = this.unwrap(test) ? consequent : alternate;
+    }
+    return test;
+  }
+  parseNullish() {
+    let left = this.parseLogicalOr();
+    while (this.match("operator", "??")) {
+      const right = this.parseLogicalOr();
+      left = this.unwrap(left) ?? right;
+    }
+    return left;
+  }
+  parseLogicalOr() {
+    let left = this.parseLogicalAnd();
+    while (this.match("operator", "||")) {
+      const right = this.parseLogicalAnd();
+      left = this.unwrap(left) || right;
+    }
+    return left;
+  }
+  parseLogicalAnd() {
+    let left = this.parseEquality();
+    while (this.match("operator", "&&")) {
+      const right = this.parseEquality();
+      left = this.unwrap(left) && right;
+    }
+    return left;
+  }
+  parseEquality() {
+    let left = this.parseComparison();
+    while (true) {
+      if (this.match("operator", "===")) {
+        const right = this.parseComparison();
+        left = this.unwrap(left) === this.unwrap(right);
+        continue;
+      }
+      if (this.match("operator", "!==")) {
+        const right = this.parseComparison();
+        left = this.unwrap(left) !== this.unwrap(right);
+        continue;
+      }
+      if (this.match("operator", "==")) {
+        const right = this.parseComparison();
+        left = this.unwrap(left) == this.unwrap(right);
+        continue;
+      }
+      if (this.match("operator", "!=")) {
+        const right = this.parseComparison();
+        left = this.unwrap(left) != this.unwrap(right);
+        continue;
+      }
+      return left;
+    }
+  }
+  compare(left, right, operator) {
+    const leftValue = this.relationalOperand(left);
+    const rightValue = this.relationalOperand(right);
+    switch (operator) {
+      case "<":
+        return leftValue < rightValue;
+      case "<=":
+        return leftValue <= rightValue;
+      case ">":
+        return leftValue > rightValue;
+      case ">=":
+        return leftValue >= rightValue;
+    }
+  }
+  add(left, right) {
+    const leftValue = this.unwrapOperand(left);
+    const rightValue = this.unwrapOperand(right);
+    return typeof leftValue === "string" || typeof rightValue === "string" ? String(leftValue) + String(rightValue) : Number(leftValue) + Number(rightValue);
+  }
+  subtract(left, right) {
+    return Number(this.unwrapOperand(left)) - Number(this.unwrapOperand(right));
+  }
+  multiply(left, right) {
+    return Number(this.unwrapOperand(left)) * Number(this.unwrapOperand(right));
+  }
+  divide(left, right) {
+    return Number(this.unwrapOperand(left)) / Number(this.unwrapOperand(right));
+  }
+  remainder(left, right) {
+    return Number(this.unwrapOperand(left)) % Number(this.unwrapOperand(right));
+  }
+  exponent(left, right) {
+    return Number(this.unwrapOperand(left)) ** Number(this.unwrapOperand(right));
+  }
+  parseComparison() {
+    let left = this.parseAdditive();
+    while (true) {
+      if (this.match("operator", "<")) {
+        const right = this.parseAdditive();
+        left = this.compare(left, right, "<");
+        continue;
+      }
+      if (this.match("operator", "<=")) {
+        const right = this.parseAdditive();
+        left = this.compare(left, right, "<=");
+        continue;
+      }
+      if (this.match("operator", ">")) {
+        const right = this.parseAdditive();
+        left = this.compare(left, right, ">");
+        continue;
+      }
+      if (this.match("operator", ">=")) {
+        const right = this.parseAdditive();
+        left = this.compare(left, right, ">=");
+        continue;
+      }
+      return left;
+    }
+  }
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    while (true) {
+      if (this.match("operator", "+")) {
+        const right = this.parseMultiplicative();
+        left = this.add(left, right);
+        continue;
+      }
+      if (this.match("operator", "-")) {
+        const right = this.parseMultiplicative();
+        left = this.subtract(left, right);
+        continue;
+      }
+      return left;
+    }
+  }
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    while (true) {
+      if (this.match("operator", "*")) {
+        const right = this.parseUnary();
+        left = this.multiply(left, right);
+        continue;
+      }
+      if (this.match("operator", "/")) {
+        const right = this.parseUnary();
+        left = this.divide(left, right);
+        continue;
+      }
+      if (this.match("operator", "%")) {
+        const right = this.parseUnary();
+        left = this.remainder(left, right);
+        continue;
+      }
+      if (this.match("operator", "**")) {
+        const right = this.parseUnary();
+        left = this.exponent(left, right);
+        continue;
+      }
+      return left;
+    }
+  }
+  parseUnary() {
+    if (this.match("operator", "!")) {
+      return !this.unwrap(this.parseUnary());
+    }
+    if (this.match("operator", "+")) {
+      return Number(this.unwrap(this.parseUnary()));
+    }
+    if (this.match("operator", "-")) {
+      return -Number(this.unwrap(this.parseUnary()));
+    }
+    if (this.current().type === "identifier" && this.current().value === "typeof") {
+      this.advance();
+      return typeof this.unwrap(this.parseUnary());
+    }
+    return this.parseCallMember();
+  }
+  parseCallMember() {
+    let value = this.parsePrimary();
+    while (true) {
+      if (this.match("punctuator", ".")) {
+        const property = this.expect("identifier").value;
+        const target = this.isReference(value) ? value.value : value;
+        value = this.toReference(target, property);
+        continue;
+      }
+      if (this.match("punctuator", "[")) {
+        const property = this.parseConditional();
+        this.expect("punctuator", "]");
+        const target = this.isReference(value) ? value.value : value;
+        value = this.toReference(target, toPropertyKey(this.unwrap(property)));
+        continue;
+      }
+      if (this.match("punctuator", "(")) {
+        const args = [];
+        if (!this.match("punctuator", ")")) {
+          do {
+            args.push(this.unwrap(this.parseConditional()));
+          } while (this.match("punctuator", ","));
+          this.expect("punctuator", ")");
+        }
+        const callee = this.isReference(value) ? value.value : value;
+        if (typeof callee !== "function") {
+          throw createExpressionError(
+            "Expression attempted to call a non-function value."
+          );
+        }
+        const thisArg = this.isReference(value) ? value.base : void 0;
+        value = callee.apply(thisArg, args);
+        continue;
+      }
+      return value;
+    }
+  }
+  parsePrimary() {
+    const token = this.current();
+    if (token.type === "number") {
+      this.advance();
+      return Number(token.value);
+    }
+    if (token.type === "string") {
+      this.advance();
+      return token.value;
+    }
+    if (token.type === "identifier") {
+      this.advance();
+      return this.resolveIdentifier(token.value);
+    }
+    if (this.match("punctuator", "(")) {
+      const value = this.parseConditional();
+      this.expect("punctuator", ")");
+      return value;
+    }
+    if (this.match("punctuator", "[")) {
+      const items = [];
+      if (!this.match("punctuator", "]")) {
+        do {
+          if (this.match("operator", "...")) {
+            const spread = this.unwrap(this.parseConditional());
+            if (Array.isArray(spread)) {
+              items.push(...spread);
+            } else {
+              throw createExpressionError(
+                "Array spread expects an array value."
+              );
+            }
+          } else {
+            items.push(this.unwrap(this.parseConditional()));
+          }
+        } while (this.match("punctuator", ","));
+        this.expect("punctuator", "]");
+      }
+      return items;
+    }
+    if (this.match("punctuator", "{")) {
+      const out = {};
+      if (!this.match("punctuator", "}")) {
+        do {
+          if (this.match("operator", "...")) {
+            const spread = this.unwrap(this.parseConditional());
+            if (spread && typeof spread === "object") {
+              Object.assign(out, spread);
+            } else {
+              throw createExpressionError(
+                "Object spread expects an object value."
+              );
+            }
+          } else {
+            let key;
+            if (this.current().type === "string" || this.current().type === "number") {
+              key = String(this.advance().value);
+            } else {
+              key = this.expect("identifier").value;
+            }
+            if (this.match("punctuator", ":")) {
+              out[key] = this.unwrap(this.parseConditional());
+            } else {
+              out[key] = this.resolveIdentifier(key);
+            }
+          }
+        } while (this.match("punctuator", ","));
+        this.expect("punctuator", "}");
+      }
+      return out;
+    }
+    throw createExpressionError(
+      `Unexpected token "${token.value}" in expression.`
+    );
+  }
+};
+function evaluateExpression(expression, context) {
+  const trimmed = expression.trim();
+  if (!trimmed)
+    throw createExpressionError("Expression cannot be empty.", expression);
+  try {
+    return new ExpressionParser(trimmed, context).evaluate();
+  } catch (error) {
+    throw error instanceof WorkflowExpressionError ? error : createExpressionError(
+      "Failed to evaluate workflow expression.",
+      expression,
+      error
+    );
+  }
+}
+function formatCost(usd) {
+  if (usd < 0.01) return `$${(usd * 100).toFixed(2)}\xA2`;
+  return `$${usd.toFixed(4)}`;
+}
+var WorkflowEngine = class {
+  options;
+  cancelled = false;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Cancel the in-flight execution loop before the next step begins.
+   */
+  cancel() {
+    this.cancelled = true;
+  }
+  /**
+   * Execute a workflow definition from start to finish and capture the full
+   * run state for UI or persistence layers.
+   */
+  async execute(definition, input = {}) {
+    this.cancelled = false;
+    const run = {
+      id: crypto.randomUUID?.() ?? String(Date.now()),
+      workflowId: definition.id,
+      workflowVersion: definition.version,
+      status: "running",
+      input,
+      variables: { ...definition.variables, ...input },
+      stepResults: [],
+      currentStepIndex: 0,
+      triggeredBy: "",
+      startedAt: Date.now()
+    };
+    const sortedSteps = this.topoSort(definition);
+    for (let i = 0; i < sortedSteps.length; i++) {
+      if (this.cancelled) {
+        run.status = "cancelled";
+        break;
+      }
+      run.currentStepIndex = i;
+      const stepDef = sortedSteps[i];
+      const result = await this.executeStep(stepDef, run.variables, definition);
+      run.stepResults.push(result);
+      this.options.onStepComplete?.(result);
+      if (result.status === "failed" && !stepDef.optional) {
+        run.status = "failed";
+        run.error = result.error;
+        break;
+      }
+      if (result.output !== void 0 && result.output !== null && "outputVar" in stepDef.config) {
+        if (stepDef.config.outputVar) {
+          run.variables[stepDef.config.outputVar] = result.output;
+        }
+      }
+      if (stepDef.config.type === "condition") {
+        const nextStepId = Boolean(result.output) ? stepDef.config.trueStepId : stepDef.config.falseStepId;
+        const targetIndex = sortedSteps.findIndex((s) => s.id === nextStepId);
+        if (targetIndex > i) {
+          for (let j = i + 1; j < targetIndex; j++) {
+            run.stepResults.push({
+              stepId: sortedSteps[j].id,
+              stepName: sortedSteps[j].name,
+              type: sortedSteps[j].type,
+              status: "skipped",
+              durationMs: 0,
+              startedAt: Date.now()
+            });
+          }
+          i = targetIndex - 1;
+        }
+      }
+    }
+    if (run.status === "running") {
+      run.status = "completed";
+    }
+    run.completedAt = Date.now();
+    return run;
+  }
+  /**
+   * Execute one step with retry handling and normalized result capture.
+   */
+  async executeStep(stepDef, variables, _definition) {
+    const start = Date.now();
+    const baseResult = {
+      stepId: stepDef.id,
+      stepName: stepDef.name,
+      type: stepDef.type,
+      status: "running",
+      durationMs: 0,
+      startedAt: start
+    };
+    let attempts = 0;
+    const maxAttempts = stepDef.retries?.maxAttempts ?? 1;
+    while (attempts < maxAttempts) {
+      attempts++;
+      try {
+        const output = await this.runStepLogic(stepDef, variables);
+        return {
+          ...baseResult,
+          status: "completed",
+          output,
+          durationMs: Date.now() - start,
+          completedAt: Date.now()
+        };
+      } catch (err) {
+        if (attempts >= maxAttempts) {
+          const workflowError = normalizeWorkflowError(
+            err,
+            `Workflow step "${stepDef.name}" failed.`,
+            { stepId: stepDef.id, workflowId: _definition.id }
+          );
+          return {
+            ...baseResult,
+            status: "failed",
+            error: workflowError.message,
+            durationMs: Date.now() - start,
+            completedAt: Date.now()
+          };
+        }
+        const backoff = stepDef.retries?.backoffMs ?? 1e3;
+        await new Promise((r) => setTimeout(r, backoff * 2 ** (attempts - 1)));
+      }
+    }
+    return {
+      ...baseResult,
+      status: "failed",
+      error: "Max retries exceeded",
+      durationMs: Date.now() - start
+    };
+  }
+  /**
+   * Run the concrete logic for an individual step type.
+   */
+  async runStepLogic(stepDef, variables) {
+    const config = stepDef.config;
+    switch (config.type) {
+      case "llm-call": {
+        if (!this.options.callLLM) {
+          throw new WorkflowConfigurationError(
+            "No LLM function provided for llm-call steps.",
+            {
+              stepId: stepDef.id
+            }
+          );
+        }
+        const userPrompt = this.interpolate(
+          config.userPromptTemplate,
+          variables
+        );
+        const result = await this.options.callLLM(
+          config.systemPrompt,
+          userPrompt,
+          config.model
+        );
+        if (config.parseJson) {
+          try {
+            return JSON.parse(result.content);
+          } catch {
+            return result.content;
+          }
+        }
+        return result.content;
+      }
+      case "transform": {
+        const scope = this.buildExpressionScope(config.inputVars, variables);
+        return evaluateExpression(config.expression, scope);
+      }
+      case "condition": {
+        return Boolean(evaluateExpression(config.expression, variables));
+      }
+      case "human-approval": {
+        if (!this.options.onApprovalRequired) {
+          return true;
+        }
+        return this.options.onApprovalRequired(config.message, stepDef.id);
+      }
+      case "webhook": {
+        if (!this.options.callWebhook) {
+          throw new WorkflowConfigurationError(
+            "No webhook function provided for webhook steps.",
+            {
+              stepId: stepDef.id
+            }
+          );
+        }
+        const body = config.bodyTemplate ? interpolate(config.bodyTemplate, variables) : void 0;
+        return this.options.callWebhook(
+          config.url,
+          config.method,
+          body,
+          config.headers
+        );
+      }
+      case "delay": {
+        await new Promise((r) => setTimeout(r, config.durationMs));
+        return null;
+      }
+      case "custom": {
+        const handler = this.options.customHandlers?.[config.handler];
+        if (!handler) {
+          throw new WorkflowConfigurationError(
+            `No handler registered for custom step "${config.handler}".`,
+            { stepId: stepDef.id }
+          );
+        }
+        return handler(config.params, variables);
+      }
+      default:
+        throw new WorkflowExecutionError(
+          `Unsupported step type "${config.type}".`,
+          {
+            stepId: stepDef.id
+          }
+        );
+    }
+  }
+  /** Interpolate `{{variable}}` references in a string. */
+  interpolate(template, vars) {
+    return interpolate(template, vars);
+  }
+  buildExpressionScope(inputVars, variables) {
+    const scope = {};
+    for (const name of inputVars) {
+      scope[name] = variables[name];
+    }
+    return scope;
+  }
+  /** Topological sort of steps based on declared workflow connections. */
+  topoSort(def) {
+    const stepMap = new Map(def.steps.map((s) => [s.id, s]));
+    const inDegree = /* @__PURE__ */ new Map();
+    const adjacency = /* @__PURE__ */ new Map();
+    for (const step of def.steps) {
+      inDegree.set(step.id, 0);
+      adjacency.set(step.id, []);
+    }
+    for (const conn of def.connections) {
+      adjacency.get(conn.fromStepId)?.push(conn.toStepId);
+      inDegree.set(conn.toStepId, (inDegree.get(conn.toStepId) ?? 0) + 1);
+    }
+    const queue = [];
+    for (const [id, degree] of inDegree) {
+      if (degree === 0) queue.push(id);
+    }
+    const sorted = [];
+    while (queue.length > 0) {
+      const id = queue.shift();
+      const step = stepMap.get(id);
+      if (step) sorted.push(step);
+      for (const neighbor of adjacency.get(id) ?? []) {
+        const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+        inDegree.set(neighbor, newDegree);
+        if (newDegree === 0) queue.push(neighbor);
+      }
+    }
+    if (sorted.length !== def.steps.length) {
+      throw new WorkflowGraphError(
+        "Workflow definition contains a cycle and cannot be executed.",
+        {
+          workflowId: def.id
+        }
+      );
+    }
+    return sorted;
+  }
+};
+var llmCallConfigSchema = z.object({
+  type: z.literal("llm-call"),
+  model: z.string().optional(),
+  systemPrompt: z.string().min(1, "System prompt is required"),
+  userPromptTemplate: z.string().min(1, "User prompt template is required"),
+  temperature: z.number().min(0).max(2).optional(),
+  maxTokens: z.number().int().positive().optional(),
+  parseJson: z.boolean().optional(),
+  outputVar: z.string().min(1, "Output variable name is required")
+});
+var transformConfigSchema = z.object({
+  type: z.literal("transform"),
+  expression: z.string().min(1, "Expression is required"),
+  inputVars: z.array(z.string()).min(1, "At least one input variable is required"),
+  outputVar: z.string().min(1)
+});
+var conditionConfigSchema = z.object({
+  type: z.literal("condition"),
+  expression: z.string().min(1),
+  trueStepId: z.string().min(1),
+  falseStepId: z.string().min(1)
+});
+var humanApprovalConfigSchema = z.object({
+  type: z.literal("human-approval"),
+  message: z.string().min(1, "Approval message is required"),
+  approvers: z.array(z.string()).optional(),
+  autoApproveAfterMs: z.number().positive().optional()
+});
+var webhookConfigSchema = z.object({
+  type: z.literal("webhook"),
+  url: z.string().url("Valid URL required"),
+  method: z.enum(["GET", "POST", "PUT", "DELETE"]),
+  headers: z.record(z.string(), z.string()).optional(),
+  bodyTemplate: z.string().optional(),
+  outputVar: z.string().min(1)
+});
+var delayConfigSchema = z.object({
+  type: z.literal("delay"),
+  durationMs: z.number().int().positive("Duration must be positive")
+});
+var parallelConfigSchema = z.object({
+  type: z.literal("parallel"),
+  stepIds: z.array(z.string()).min(2, "Parallel needs at least 2 steps"),
+  failurePolicy: z.enum(["fail-fast", "continue"])
+});
+var loopConfigSchema = z.object({
+  type: z.literal("loop"),
+  stepIds: z.array(z.string()).min(1),
+  iterateVar: z.string().min(1),
+  itemVar: z.string().min(1),
+  maxIterations: z.number().int().positive().optional()
+});
+var subWorkflowConfigSchema = z.object({
+  type: z.literal("sub-workflow"),
+  workflowId: z.string().min(1),
+  inputMapping: z.record(z.string(), z.string()),
+  outputVar: z.string().min(1)
+});
+var customStepConfigSchema = z.object({
+  type: z.literal("custom"),
+  handler: z.string().min(1, "Handler name is required"),
+  params: z.record(z.string(), z.unknown()),
+  outputVar: z.string().optional()
+});
+var stepConfigSchema = z.discriminatedUnion("type", [
+  llmCallConfigSchema,
+  transformConfigSchema,
+  conditionConfigSchema,
+  humanApprovalConfigSchema,
+  webhookConfigSchema,
+  delayConfigSchema,
+  parallelConfigSchema,
+  loopConfigSchema,
+  subWorkflowConfigSchema,
+  customStepConfigSchema
+]);
+var workflowStepDefSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1, "Step name is required"),
+  type: z.enum(["llm-call", "transform", "condition", "human-approval", "webhook", "delay", "parallel", "loop", "sub-workflow", "custom"]),
+  config: stepConfigSchema,
+  position: z.object({ x: z.number(), y: z.number() }).optional(),
+  optional: z.boolean().optional(),
+  retries: z.object({ maxAttempts: z.number().int().positive(), backoffMs: z.number().positive() }).optional()
+});
+var stepConnectionSchema = z.object({
+  fromStepId: z.string().min(1),
+  toStepId: z.string().min(1),
+  label: z.string().optional(),
+  condition: z.string().optional()
+});
+var workflowVariableSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum(["string", "number", "boolean", "object", "array"]),
+  description: z.string().optional(),
+  required: z.boolean().optional(),
+  default: z.unknown().optional()
+});
+var workflowDefinitionSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1, "Workflow name is required").max(120, "Name too long"),
+  description: z.string().max(2e3).optional(),
+  version: z.number().int().positive(),
+  status: z.enum(["draft", "active", "paused", "archived"]),
+  steps: z.array(workflowStepDefSchema).min(1, "At least one step is required"),
+  connections: z.array(stepConnectionSchema),
+  inputSchema: z.array(workflowVariableSchema).optional(),
+  variables: z.record(z.string(), z.unknown()).optional(),
+  tags: z.array(z.string()).optional(),
+  createdBy: z.string(),
+  createdAt: z.number(),
+  updatedAt: z.number()
+});
+var stepResultSchema = z.object({
+  stepId: z.string(),
+  stepName: z.string(),
+  type: z.enum(["llm-call", "transform", "condition", "human-approval", "webhook", "delay", "parallel", "loop", "sub-workflow", "custom"]),
+  status: z.enum(["pending", "running", "completed", "failed", "skipped", "waiting-approval"]),
+  input: z.record(z.string(), z.unknown()).optional(),
+  output: z.unknown().optional(),
+  error: z.string().optional(),
+  durationMs: z.number(),
+  tokens: z.number().optional(),
+  costUsd: z.number().optional(),
+  startedAt: z.number(),
+  completedAt: z.number().optional()
+});
+var workflowRunSchema = z.object({
+  id: z.string(),
+  workflowId: z.string(),
+  workflowVersion: z.number(),
+  status: z.enum(["pending", "running", "paused", "completed", "failed", "cancelled"]),
+  input: z.record(z.string(), z.unknown()),
+  variables: z.record(z.string(), z.unknown()),
+  stepResults: z.array(stepResultSchema),
+  currentStepIndex: z.number(),
+  error: z.string().optional(),
+  triggeredBy: z.string(),
+  startedAt: z.number(),
+  completedAt: z.number().optional()
+});
+function validateWorkflow(data) {
+  return workflowDefinitionSchema.safeParse(data);
+}
+function validateRun(data) {
+  return workflowRunSchema.safeParse(data);
+}
+function uid() {
+  return `step_tpl_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function wfId() {
+  return `wf_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+var contentPipeline = {
+  id: "tpl-content-pipeline",
+  name: "Content Pipeline",
+  description: "Generate, review, and publish content with AI refinement and human approval.",
+  category: "content",
+  tags: ["content", "blog", "marketing"],
+  create: (createdBy) => {
+    const draft = uid(), refine = uid(), approve = uid(), publish = uid();
+    const steps = [
+      { id: draft, name: "Generate Draft", type: "llm-call", config: { type: "llm-call", systemPrompt: "You are a content writer.", userPromptTemplate: "Write a blog post about {{topic}}. Tone: {{tone}}.", outputVar: "draft" }, position: { x: 100, y: 200 } },
+      { id: refine, name: "Refine Content", type: "llm-call", config: { type: "llm-call", systemPrompt: "You are an editor. Improve clarity, grammar, and engagement.", userPromptTemplate: "Polish this draft:\n\n{{draft}}", outputVar: "polished" }, position: { x: 350, y: 200 } },
+      { id: approve, name: "Human Review", type: "human-approval", config: { type: "human-approval", message: "Please review the polished content before publishing." }, position: { x: 600, y: 200 } },
+      { id: publish, name: "Format for Publishing", type: "transform", config: { type: "transform", expression: '({ title: polished.split("\\n")[0], body: polished, publishedAt: Date.now() })', inputVars: ["polished"], outputVar: "publishData" }, position: { x: 850, y: 200 } }
+    ];
+    const connections = [
+      { fromStepId: draft, toStepId: refine },
+      { fromStepId: refine, toStepId: approve },
+      { fromStepId: approve, toStepId: publish }
+    ];
+    return { id: wfId(), name: "Content Pipeline", description: "AI-powered content generation with editorial review.", version: 1, status: "draft", steps, connections, inputSchema: [{ name: "topic", type: "string", required: true }, { name: "tone", type: "string", required: false, default: "professional" }], tags: ["content"], createdBy, createdAt: Date.now(), updatedAt: Date.now() };
+  }
+};
+var dataEnrichment = {
+  id: "tpl-data-enrichment",
+  name: "Data Enrichment",
+  description: "Fetch external data, enrich with AI analysis, and transform for downstream use.",
+  category: "data",
+  tags: ["data", "analytics", "enrichment"],
+  create: (createdBy) => {
+    const fetch_ = uid(), analyze = uid(), transform = uid();
+    const steps = [
+      { id: fetch_, name: "Fetch Data", type: "webhook", config: { type: "webhook", url: "https://api.example.com/data-source", method: "GET", outputVar: "rawData" }, position: { x: 100, y: 200 } },
+      { id: analyze, name: "AI Analysis", type: "llm-call", config: { type: "llm-call", systemPrompt: "You are a data analyst. Analyze the data and extract key insights.", userPromptTemplate: "Analyze this dataset and return a JSON summary with key metrics:\n\n{{rawData}}", parseJson: true, outputVar: "analysis" }, position: { x: 400, y: 200 } },
+      { id: transform, name: "Transform Output", type: "transform", config: { type: "transform", expression: "({ ...analysis, enrichedAt: Date.now(), source: dataSourceUrl })", inputVars: ["analysis", "dataSourceUrl"], outputVar: "enrichedData" }, position: { x: 700, y: 200 } }
+    ];
+    const connections = [
+      { fromStepId: fetch_, toStepId: analyze },
+      { fromStepId: analyze, toStepId: transform }
+    ];
+    return { id: wfId(), name: "Data Enrichment", version: 1, status: "draft", steps, connections, inputSchema: [{ name: "dataSourceUrl", type: "string", required: true }], tags: ["data"], createdBy, createdAt: Date.now(), updatedAt: Date.now() };
+  }
+};
+var approvalChain = {
+  id: "tpl-approval-chain",
+  name: "Approval Chain",
+  description: "Multi-level approval workflow with conditional escalation.",
+  category: "approval",
+  tags: ["approval", "governance", "compliance"],
+  create: (createdBy) => {
+    const checkRisk = uid(), lowApproval = uid(), highApproval = uid(), finalize = uid();
+    const steps = [
+      { id: checkRisk, name: "Assess Risk Level", type: "llm-call", config: { type: "llm-call", systemPrompt: 'Assess the risk level of this request. Respond with JSON: {"riskLevel": "low"|"medium"|"high", "reason": "..."}', userPromptTemplate: "{{request}}", parseJson: true, outputVar: "riskAssessment" }, position: { x: 100, y: 200 } },
+      { id: lowApproval, name: "Manager Approval", type: "human-approval", config: { type: "human-approval", message: "Low/medium risk: Manager approval needed for: {{request}}" }, position: { x: 400, y: 100 } },
+      { id: highApproval, name: "Executive Approval", type: "human-approval", config: { type: "human-approval", message: "High risk: Executive approval required for: {{request}}" }, position: { x: 400, y: 300 } },
+      { id: finalize, name: "Record Decision", type: "transform", config: { type: "transform", expression: "({ approved: true, approvedAt: Date.now(), riskLevel: riskAssessment.riskLevel })", inputVars: ["riskAssessment"], outputVar: "decision" }, position: { x: 700, y: 200 } }
+    ];
+    const connections = [
+      { fromStepId: checkRisk, toStepId: lowApproval, condition: 'riskAssessment.riskLevel !== "high"' },
+      { fromStepId: checkRisk, toStepId: highApproval, condition: 'riskAssessment.riskLevel === "high"' },
+      { fromStepId: lowApproval, toStepId: finalize },
+      { fromStepId: highApproval, toStepId: finalize }
+    ];
+    return { id: wfId(), name: "Approval Chain", version: 1, status: "draft", steps, connections, inputSchema: [{ name: "request", type: "string", required: true }], tags: ["approval"], createdBy, createdAt: Date.now(), updatedAt: Date.now() };
+  }
+};
+var researchPipeline = {
+  id: "tpl-research",
+  name: "Research Pipeline",
+  description: "Multi-source research with AI synthesis and summary generation.",
+  category: "research",
+  tags: ["research", "analysis", "summary"],
+  create: (createdBy) => {
+    const research = uid(), synthesize = uid(), summarize = uid();
+    const steps = [
+      { id: research, name: "Deep Research", type: "llm-call", config: { type: "llm-call", systemPrompt: "You are a research assistant. Provide comprehensive, well-sourced research on the given topic.", userPromptTemplate: "Research the following topic in depth: {{topic}}\n\nFocus areas: {{focusAreas}}", outputVar: "researchOutput" }, position: { x: 100, y: 200 } },
+      { id: synthesize, name: "Synthesize Findings", type: "llm-call", config: { type: "llm-call", systemPrompt: "You are a synthesis expert. Combine research findings into structured insights with citations.", userPromptTemplate: "Synthesize these research findings into key themes and actionable insights:\n\n{{researchOutput}}", parseJson: true, outputVar: "synthesis" }, position: { x: 400, y: 200 } },
+      { id: summarize, name: "Executive Summary", type: "llm-call", config: { type: "llm-call", systemPrompt: "Write a concise executive summary (3-5 paragraphs) suitable for senior leadership.", userPromptTemplate: "Create an executive summary from:\n\n{{synthesis}}", outputVar: "executiveSummary" }, position: { x: 700, y: 200 } }
+    ];
+    const connections = [
+      { fromStepId: research, toStepId: synthesize },
+      { fromStepId: synthesize, toStepId: summarize }
+    ];
+    return { id: wfId(), name: "Research Pipeline", version: 1, status: "draft", steps, connections, inputSchema: [{ name: "topic", type: "string", required: true }, { name: "focusAreas", type: "string", required: false, default: "general overview" }], tags: ["research"], createdBy, createdAt: Date.now(), updatedAt: Date.now() };
+  }
+};
+var codeReviewPipeline = {
+  id: "tpl-code-review",
+  name: "Code Review Pipeline",
+  description: "Automated code review with AI analysis, security check, and human approval.",
+  category: "devops",
+  tags: ["code", "review", "security", "devops"],
+  create: (createdBy) => {
+    const analyze = uid(), security = uid(), approve = uid(), report = uid();
+    const steps = [
+      { id: analyze, name: "AI Code Review", type: "llm-call", config: { type: "llm-call", systemPrompt: 'You are a senior code reviewer. Analyze the code for bugs, performance issues, and best practices. Return JSON: {"issues": [], "suggestions": [], "quality": 1-10}', userPromptTemplate: "Review this code:\n\n```{{language}}\n{{code}}\n```", parseJson: true, outputVar: "codeReview" }, position: { x: 100, y: 200 } },
+      { id: security, name: "Security Scan", type: "llm-call", config: { type: "llm-call", systemPrompt: 'You are a security auditor. Check for vulnerabilities (XSS, SQL injection, secrets exposure, etc). Return JSON: {"vulnerabilities": [], "riskLevel": "low"|"medium"|"high"}', userPromptTemplate: "Security audit for:\n\n```{{language}}\n{{code}}\n```", parseJson: true, outputVar: "securityReport" }, position: { x: 100, y: 400 } },
+      { id: approve, name: "Developer Approval", type: "human-approval", config: { type: "human-approval", message: "Review the AI code analysis and security scan before merging." }, position: { x: 450, y: 300 } },
+      { id: report, name: "Generate Report", type: "transform", config: { type: "transform", expression: "({ codeQuality: codeReview.quality, issues: codeReview.issues.length, vulnerabilities: securityReport.vulnerabilities.length, riskLevel: securityReport.riskLevel, reviewedAt: Date.now() })", inputVars: ["codeReview", "securityReport"], outputVar: "finalReport" }, position: { x: 700, y: 300 } }
+    ];
+    const connections = [
+      { fromStepId: analyze, toStepId: approve },
+      { fromStepId: security, toStepId: approve },
+      { fromStepId: approve, toStepId: report }
+    ];
+    return { id: wfId(), name: "Code Review Pipeline", version: 1, status: "draft", steps, connections, inputSchema: [{ name: "code", type: "string", required: true }, { name: "language", type: "string", required: false, default: "typescript" }], tags: ["devops", "review"], createdBy, createdAt: Date.now(), updatedAt: Date.now() };
+  }
+};
+var leadQualification = {
+  id: "tpl-lead-qualification",
+  name: "Lead Qualification",
+  description: "Score incoming leads, prepare a summary, and route them for follow-up.",
+  category: "data",
+  tags: ["sales", "crm", "lead-scoring"],
+  create: (createdBy) => {
+    const score = uid(), summarize = uid(), route = uid();
+    const steps = [
+      { id: score, name: "Score Lead", type: "llm-call", config: { type: "llm-call", systemPrompt: "You are a sales operations analyst. Score the lead from 1-10 and return JSON with score, rationale, and nextAction.", userPromptTemplate: "Lead details:\n\n{{lead}}", parseJson: true, outputVar: "leadScore" }, position: { x: 100, y: 200 } },
+      { id: summarize, name: "Summarize Lead", type: "transform", config: { type: "transform", expression: '({ score: leadScore.score, summary: leadScore.rationale, priority: leadScore.score >= 8 ? "high" : "standard", updatedAt: Date.now() })', inputVars: ["leadScore"], outputVar: "leadSummary" }, position: { x: 400, y: 200 } },
+      { id: route, name: "Notify Sales", type: "webhook", config: { type: "webhook", url: "https://api.example.com/crm/webhook", method: "POST", bodyTemplate: "Lead summary: {{leadSummary}}", outputVar: "salesNotification" }, position: { x: 700, y: 200 } }
+    ];
+    const connections = [
+      { fromStepId: score, toStepId: summarize },
+      { fromStepId: summarize, toStepId: route }
+    ];
+    return {
+      id: wfId(),
+      name: "Lead Qualification",
+      description: "AI-assisted lead scoring and sales handoff.",
+      version: 1,
+      status: "draft",
+      steps,
+      connections,
+      inputSchema: [
+        { name: "lead", type: "string", required: true },
+        { name: "crmWebhookUrl", type: "string", required: false, default: "https://api.example.com/crm/webhook" }
+      ],
+      tags: ["sales", "lead"],
+      createdBy,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+  }
+};
+var incidentTriage = {
+  id: "tpl-incident-triage",
+  name: "Incident Triage",
+  description: "Collect incident context, classify severity, and draft the response.",
+  category: "devops",
+  tags: ["incident", "ops", "triage"],
+  create: (createdBy) => {
+    const fetchIncident = uid(), classify = uid(), draftResponse = uid();
+    const steps = [
+      { id: fetchIncident, name: "Fetch Incident", type: "webhook", config: { type: "webhook", url: "https://api.example.com/incidents", method: "GET", outputVar: "incidentData" }, position: { x: 100, y: 200 } },
+      { id: classify, name: "Classify Severity", type: "llm-call", config: { type: "llm-call", systemPrompt: "You are an incident commander. Classify the incident severity and summarize the likely impact in JSON.", userPromptTemplate: "Incident context:\n\n{{incidentData}}", parseJson: true, outputVar: "classification" }, position: { x: 400, y: 200 } },
+      { id: draftResponse, name: "Draft Response", type: "transform", config: { type: "transform", expression: "({ severity: classification.severity, summary: classification.summary, draftedAt: Date.now() })", inputVars: ["classification"], outputVar: "responseDraft" }, position: { x: 700, y: 200 } }
+    ];
+    const connections = [
+      { fromStepId: fetchIncident, toStepId: classify },
+      { fromStepId: classify, toStepId: draftResponse }
+    ];
+    return {
+      id: wfId(),
+      name: "Incident Triage",
+      description: "Automated incident classification and response drafting.",
+      version: 1,
+      status: "draft",
+      steps,
+      connections,
+      inputSchema: [
+        { name: "incidentApiUrl", type: "string", required: false, default: "https://api.example.com/incidents" }
+      ],
+      tags: ["incident", "ops"],
+      createdBy,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+  }
+};
+var launchReadiness = {
+  id: "tpl-launch-readiness",
+  name: "Launch Readiness",
+  description: "Prepare launch notes, request approval, and publish the rollout payload.",
+  category: "approval",
+  tags: ["launch", "release", "approval"],
+  create: (createdBy) => {
+    const prepare = uid(), approve = uid(), publish = uid();
+    const steps = [
+      { id: prepare, name: "Prepare Launch Notes", type: "llm-call", config: { type: "llm-call", systemPrompt: "You are a product marketing lead. Create concise launch notes with risks and highlights.", userPromptTemplate: "Launch context:\n\n{{launchBrief}}", outputVar: "launchNotes" }, position: { x: 100, y: 200 } },
+      { id: approve, name: "Approval Gate", type: "human-approval", config: { type: "human-approval", message: "Review the launch notes before the rollout payload is published." }, position: { x: 400, y: 200 } },
+      { id: publish, name: "Build Payload", type: "transform", config: { type: "transform", expression: '({ notes: launchNotes, approvedAt: Date.now(), releaseChannel: releaseChannel || "stable" })', inputVars: ["launchNotes", "releaseChannel"], outputVar: "launchPayload" }, position: { x: 700, y: 200 } }
+    ];
+    const connections = [
+      { fromStepId: prepare, toStepId: approve },
+      { fromStepId: approve, toStepId: publish }
+    ];
+    return {
+      id: wfId(),
+      name: "Launch Readiness",
+      description: "Human-approved release preparation workflow.",
+      version: 1,
+      status: "draft",
+      steps,
+      connections,
+      inputSchema: [
+        { name: "launchBrief", type: "string", required: true },
+        { name: "releaseChannel", type: "string", required: false, default: "stable" }
+      ],
+      tags: ["launch", "release"],
+      createdBy,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+  }
+};
+var WORKFLOW_TEMPLATES = [
+  contentPipeline,
+  dataEnrichment,
+  approvalChain,
+  researchPipeline,
+  codeReviewPipeline,
+  leadQualification,
+  incidentTriage,
+  launchReadiness
+];
+function getTemplate(id) {
+  return WORKFLOW_TEMPLATES.find((t) => t.id === id);
+}
+function getTemplatesByCategory(category) {
+  return WORKFLOW_TEMPLATES.filter((t) => t.category === category);
+}
+function useApprovalGate() {
+  const [pendingApprovals, setPendingApprovals] = useState(
+    []
+  );
+  const [history, setHistory] = useState([]);
+  const requestApproval = useCallback(
+    (stepId, message, approvers) => {
+      const request = {
+        id: `approval_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+        stepId,
+        message,
+        requestedAt: Date.now(),
+        approvers
+      };
+      setPendingApprovals((current) => [...current, request]);
+      return request.id;
+    },
+    []
+  );
+  const approve = useCallback((approvalId) => {
+    setPendingApprovals((current) => {
+      const request = current.find((item) => item.id === approvalId);
+      if (request) {
+        setHistory((entries) => [
+          ...entries,
+          { ...request, decision: "approved", decidedAt: Date.now() }
+        ]);
+      }
+      return current.filter((item) => item.id !== approvalId);
+    });
+  }, []);
+  const reject = useCallback((approvalId) => {
+    setPendingApprovals((current) => {
+      const request = current.find((item) => item.id === approvalId);
+      if (request) {
+        setHistory((entries) => [
+          ...entries,
+          { ...request, decision: "rejected", decidedAt: Date.now() }
+        ]);
+      }
+      return current.filter((item) => item.id !== approvalId);
+    });
+  }, []);
+  const clearHistory = useCallback(() => {
+    setHistory([]);
+  }, []);
+  return {
+    pendingApprovals,
+    history,
+    hasPending: pendingApprovals.length > 0,
+    requestApproval,
+    approve,
+    reject,
+    clearHistory
+  };
+}
+function useWorkflow(options) {
+  const [run, setRun] = useState(null);
+  const [isRunning, setIsRunning] = useState(false);
+  const [error, setError] = useState(null);
+  const [stepResults, setStepResults] = useState([]);
+  const engine = new WorkflowEngine({
+    ...options,
+    onStepComplete: (result) => {
+      setStepResults((current) => [...current, result]);
+      options.onStepComplete?.(result);
+    }
+  });
+  const execute = useCallback(
+    async (definition, input) => {
+      setIsRunning(true);
+      setError(null);
+      setStepResults([]);
+      try {
+        const result = await engine.execute(definition, input);
+        setRun(result);
+        return result;
+      } catch (caughtError) {
+        const normalizedError = normalizeWorkflowError(
+          caughtError,
+          "Workflow execution failed.",
+          { workflowId: definition.id }
+        );
+        setError(normalizedError);
+        throw normalizedError;
+      } finally {
+        setIsRunning(false);
+      }
+    },
+    []
+  );
+  const cancel = useCallback(() => {
+    engine.cancel();
+  }, []);
+  const reset = useCallback(() => {
+    setRun(null);
+    setError(null);
+    setStepResults([]);
+  }, []);
+  return {
+    execute,
+    cancel,
+    run,
+    isRunning,
+    error,
+    stepResults,
+    reset
+  };
+}
+function createEmptyDefinition() {
+  return {
+    id: crypto.randomUUID?.() ?? String(Date.now()),
+    name: "New Workflow",
+    version: 1,
+    status: "draft",
+    steps: [],
+    connections: [],
+    createdBy: "",
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  };
+}
+function useWorkflowBuilder(initial) {
+  const [state, setState] = useState({
+    definition: { ...createEmptyDefinition(), ...initial },
+    selectedStepId: null,
+    isDirty: false,
+    undoStack: [],
+    redoStack: []
+  });
+  const pushUndo = useCallback(() => {
+    setState((current) => ({
+      ...current,
+      undoStack: [...current.undoStack.slice(-20), current.definition],
+      redoStack: []
+    }));
+  }, []);
+  const addStep = useCallback(
+    (step) => {
+      pushUndo();
+      setState((current) => ({
+        ...current,
+        isDirty: true,
+        definition: {
+          ...current.definition,
+          steps: [...current.definition.steps, step],
+          updatedAt: Date.now()
+        }
+      }));
+    },
+    [pushUndo]
+  );
+  const removeStep = useCallback(
+    (stepId) => {
+      pushUndo();
+      setState((current) => ({
+        ...current,
+        isDirty: true,
+        definition: {
+          ...current.definition,
+          steps: current.definition.steps.filter((step) => step.id !== stepId),
+          connections: current.definition.connections.filter(
+            (connection) => connection.fromStepId !== stepId && connection.toStepId !== stepId
+          ),
+          updatedAt: Date.now()
+        },
+        selectedStepId: current.selectedStepId === stepId ? null : current.selectedStepId
+      }));
+    },
+    [pushUndo]
+  );
+  const updateStep = useCallback(
+    (stepId, updates) => {
+      pushUndo();
+      setState((current) => ({
+        ...current,
+        isDirty: true,
+        definition: {
+          ...current.definition,
+          steps: current.definition.steps.map(
+            (step) => step.id === stepId ? { ...step, ...updates } : step
+          ),
+          updatedAt: Date.now()
+        }
+      }));
+    },
+    [pushUndo]
+  );
+  const addConnection = useCallback(
+    (connection) => {
+      pushUndo();
+      setState((current) => ({
+        ...current,
+        isDirty: true,
+        definition: {
+          ...current.definition,
+          connections: [...current.definition.connections, connection],
+          updatedAt: Date.now()
+        }
+      }));
+    },
+    [pushUndo]
+  );
+  const removeConnection = useCallback(
+    (fromStepId, toStepId) => {
+      pushUndo();
+      setState((current) => ({
+        ...current,
+        isDirty: true,
+        definition: {
+          ...current.definition,
+          connections: current.definition.connections.filter(
+            (connection) => !(connection.fromStepId === fromStepId && connection.toStepId === toStepId)
+          ),
+          updatedAt: Date.now()
+        }
+      }));
+    },
+    [pushUndo]
+  );
+  const selectStep = useCallback((stepId) => {
+    setState((current) => ({ ...current, selectedStepId: stepId }));
+  }, []);
+  const undo = useCallback(() => {
+    setState((current) => {
+      if (current.undoStack.length === 0) {
+        return current;
+      }
+      const previousDefinition = current.undoStack[current.undoStack.length - 1];
+      return {
+        ...current,
+        definition: previousDefinition,
+        undoStack: current.undoStack.slice(0, -1),
+        redoStack: [current.definition, ...current.redoStack]
+      };
+    });
+  }, []);
+  const redo = useCallback(() => {
+    setState((current) => {
+      if (current.redoStack.length === 0) {
+        return current;
+      }
+      const nextDefinition = current.redoStack[0];
+      return {
+        ...current,
+        definition: nextDefinition,
+        undoStack: [...current.undoStack, current.definition],
+        redoStack: current.redoStack.slice(1)
+      };
+    });
+  }, []);
+  const setDefinition = useCallback((definition) => {
+    setState((current) => ({
+      ...current,
+      definition,
+      isDirty: false,
+      undoStack: [],
+      redoStack: []
+    }));
+  }, []);
+  return {
+    definition: state.definition,
+    selectedStepId: state.selectedStepId,
+    isDirty: state.isDirty,
+    canUndo: state.undoStack.length > 0,
+    canRedo: state.redoStack.length > 0,
+    addStep,
+    removeStep,
+    updateStep,
+    addConnection,
+    removeConnection,
+    selectStep,
+    undo,
+    redo,
+    setDefinition
+  };
+}
+function useWorkflowRun(options = {}) {
+  const [run, setRun] = useState(null);
+  const [currentStepIndex, setCurrentStepIndex] = useState(0);
+  const [completedSteps, setCompletedSteps] = useState([]);
+  const [status, setStatus] = useState("pending");
+  const [progress, setProgress] = useState(0);
+  const [error, setError] = useState(null);
+  const timerRef = useRef(null);
+  const trackRun = useCallback(
+    (workflowRun) => {
+      setRun(workflowRun);
+      setStatus(workflowRun.status);
+      setCurrentStepIndex(workflowRun.currentStepIndex);
+      setCompletedSteps(workflowRun.stepResults);
+      setError(workflowRun.error ?? null);
+      const totalSteps = workflowRun.stepResults.length;
+      const completedCount = workflowRun.stepResults.filter(
+        (step) => step.status === "completed" || step.status === "skipped"
+      ).length;
+      setProgress(
+        totalSteps > 0 ? Math.round(completedCount / totalSteps * 100) : 0
+      );
+      if (workflowRun.status === "completed" || workflowRun.status === "failed") {
+        options.onRunComplete?.(workflowRun);
+      }
+    },
+    [options.onRunComplete]
+  );
+  const updateStep = useCallback(
+    (result) => {
+      setCompletedSteps((current) => {
+        const existingIndex = current.findIndex(
+          (step) => step.stepId === result.stepId
+        );
+        if (existingIndex >= 0) {
+          const updatedSteps = [...current];
+          updatedSteps[existingIndex] = result;
+          return updatedSteps;
+        }
+        return [...current, result];
+      });
+      setCurrentStepIndex((current) => current + 1);
+      options.onStepComplete?.(result);
+    },
+    [options.onStepComplete]
+  );
+  const reset = useCallback(() => {
+    setRun(null);
+    setCurrentStepIndex(0);
+    setCompletedSteps([]);
+    setStatus("pending");
+    setProgress(0);
+    setError(null);
+    if (timerRef.current) {
+      clearInterval(timerRef.current);
+    }
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) {
+        clearInterval(timerRef.current);
+      }
+    };
+  }, []);
+  return {
+    run,
+    status,
+    currentStepIndex,
+    completedSteps,
+    progress,
+    error,
+    trackRun,
+    updateStep,
+    reset,
+    isRunning: status === "running",
+    isComplete: status === "completed",
+    isFailed: status === "failed"
+  };
+}
+function useWorkflowStep(stepDef) {
+  const [status, setStatus] = useState("pending");
+  const [output, setOutput] = useState(null);
+  const [error, setError] = useState(null);
+  const [durationMs, setDurationMs] = useState(0);
+  const updateFromResult = useCallback((result) => {
+    setStatus(result.status);
+    setOutput(result.output ?? null);
+    setError(result.error ?? null);
+    setDurationMs(result.durationMs);
+  }, []);
+  const reset = useCallback(() => {
+    setStatus("pending");
+    setOutput(null);
+    setError(null);
+    setDurationMs(0);
+  }, []);
+  const icon = useMemo(() => {
+    const iconMap = {
+      "llm-call": "\u{1F916}",
+      transform: "\u2699\uFE0F",
+      condition: "\u{1F500}",
+      "human-approval": "\u{1F464}",
+      webhook: "\u{1F310}",
+      delay: "\u23F1\uFE0F",
+      parallel: "\u26A1",
+      loop: "\u{1F504}",
+      "sub-workflow": "\u{1F4CB}",
+      custom: "\u{1F527}"
+    };
+    return iconMap[stepDef.type] ?? "\u{1F4E6}";
+  }, [stepDef.type]);
+  const statusColor = useMemo(() => {
+    const colorMap = {
+      pending: "gray",
+      running: "blue",
+      completed: "green",
+      failed: "red",
+      skipped: "orange",
+      "waiting-approval": "purple"
+    };
+    return colorMap[status];
+  }, [status]);
+  return {
+    stepDef,
+    status,
+    output,
+    error,
+    durationMs,
+    icon,
+    statusColor,
+    updateFromResult,
+    reset,
+    isComplete: status === "completed",
+    isRunning: status === "running",
+    isFailed: status === "failed",
+    isWaiting: status === "waiting-approval",
+    config: stepDef.config
+  };
+}
+function useWorkflowTemplates(userId) {
+  const [selectedTemplateId, setSelectedTemplateId] = useState(
+    null
+  );
+  const [filterCategory, setFilterCategory] = useState("all");
+  const [searchQuery, setSearchQuery] = useState("");
+  const filteredTemplates = useMemo(() => {
+    let templates = filterCategory === "all" ? WORKFLOW_TEMPLATES : getTemplatesByCategory(filterCategory);
+    if (searchQuery.trim()) {
+      const normalizedQuery = searchQuery.toLowerCase();
+      templates = templates.filter(
+        (template) => template.name.toLowerCase().includes(normalizedQuery) || template.description.toLowerCase().includes(normalizedQuery) || template.tags.some((tag) => tag.includes(normalizedQuery))
+      );
+    }
+    return templates;
+  }, [filterCategory, searchQuery]);
+  const selectedTemplate = useMemo(() => {
+    return selectedTemplateId ? getTemplate(selectedTemplateId) ?? null : null;
+  }, [selectedTemplateId]);
+  const createFromTemplate = useCallback(
+    (templateId) => {
+      const template = getTemplate(templateId);
+      return template ? template.create(userId) : null;
+    },
+    [userId]
+  );
+  const categories = useMemo(() => {
+    return [...new Set(WORKFLOW_TEMPLATES.map((template) => template.category))];
+  }, []);
+  return {
+    templates: filteredTemplates,
+    allTemplates: WORKFLOW_TEMPLATES,
+    selectedTemplate,
+    selectedTemplateId,
+    categories,
+    filterCategory,
+    searchQuery,
+    setSelectedTemplateId,
+    setFilterCategory,
+    setSearchQuery,
+    createFromTemplate
+  };
+}
+var NODE_WIDTH = 200;
+var NODE_HEIGHT = 80;
+function StepConnector(props) {
+  const startX = props.from.x + NODE_WIDTH;
+  const startY = props.from.y + NODE_HEIGHT / 2;
+  const endX = props.to.x;
+  const endY = props.to.y + NODE_HEIGHT / 2;
+  const midX = (startX + endX) / 2;
+  return /* @__PURE__ */ jsxs("g", { className: "ai-workflow__connector", children: [
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: `M ${startX} ${startY} C ${midX} ${startY}, ${midX} ${endY}, ${endX} ${endY}`,
+        fill: "none",
+        stroke: props.isActive ? "var(--primary)" : "var(--border)",
+        strokeWidth: props.isActive ? 3 : 2
+      }
+    ),
+    props.label && /* @__PURE__ */ jsx(
+      "text",
+      {
+        x: midX,
+        y: (startY + endY) / 2 - 8,
+        textAnchor: "middle",
+        fill: "var(--muted-foreground)",
+        fontSize: "12",
+        children: props.label
+      }
+    )
+  ] });
+}
+
+// src/utils/cx.ts
+function cx(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+var ICONS = {
+  "llm-call": "\u{1F916}",
+  transform: "\u2699\uFE0F",
+  condition: "\u{1F500}",
+  "human-approval": "\u{1F464}",
+  webhook: "\u{1F310}",
+  delay: "\u23F1\uFE0F",
+  parallel: "\u26A1",
+  loop: "\u{1F504}",
+  "sub-workflow": "\u{1F4CB}",
+  custom: "\u{1F527}"
+};
+function StepNode(props) {
+  const cls = cx(
+    "ai-workflow__step-node",
+    props.isSelected && "ai-workflow__step-node--selected",
+    props.status && `ai-workflow__step-node--${props.status}`
+  );
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cx(cls, "ai-workflow__focus-visible", props.className),
+      role: "button",
+      tabIndex: 0,
+      "aria-label": `Workflow step ${props.step.name}`,
+      "aria-pressed": props.isSelected,
+      onClick: props.onClick,
+      onKeyDown: (event) => {
+        if (event.key === "Enter" || event.key === " ") {
+          event.preventDefault();
+          props.onClick?.();
+        }
+      },
+      style: props.step.position ? {
+        position: "absolute",
+        left: props.step.position.x,
+        top: props.step.position.y
+      } : void 0,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "ai-workflow__step-header", children: [
+          /* @__PURE__ */ jsx("span", { className: "ai-workflow__step-icon", children: ICONS[props.step.type] }),
+          /* @__PURE__ */ jsx("span", { className: "ai-workflow__step-name", children: props.step.name })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "ai-workflow__step-type-badge", children: props.step.type }),
+        props.step.optional && /* @__PURE__ */ jsx("span", { className: "ai-workflow__step-optional-badge", children: "Optional" }),
+        props.step.retries && /* @__PURE__ */ jsxs("span", { className: "ai-workflow__step-retry-badge", children: [
+          "\u21BB ",
+          props.step.retries.maxAttempts
+        ] })
+      ]
+    }
+  );
+}
+function WorkflowCanvas(props) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "ai-workflow__canvas",
+      role: "application",
+      "aria-label": "Workflow canvas",
+      children: [
+        /* @__PURE__ */ jsx("svg", { style: { position: "absolute", inset: 0, pointerEvents: "none" }, children: props.definition.connections.map((connection, index) => {
+          const fromStep = props.definition.steps.find(
+            (step) => step.id === connection.fromStepId
+          );
+          const toStep = props.definition.steps.find(
+            (step) => step.id === connection.toStepId
+          );
+          return fromStep?.position && toStep?.position ? /* @__PURE__ */ jsx(
+            StepConnector,
+            {
+              from: fromStep.position,
+              to: toStep.position,
+              label: connection.label
+            },
+            `${connection.fromStepId}-${connection.toStepId}-${index}`
+          ) : null;
+        }) }),
+        /* @__PURE__ */ jsx("div", { children: props.definition.steps.map((step) => /* @__PURE__ */ jsx(
+          StepNode,
+          {
+            step,
+            isSelected: props.selectedStepId === step.id,
+            onClick: () => props.onSelectStep(
+              step.id === props.selectedStepId ? null : step.id
+            )
+          },
+          step.id
+        )) }),
+        props.definition.steps.length === 0 && /* @__PURE__ */ jsxs("div", { className: "ai-workflow__canvas-empty", children: [
+          /* @__PURE__ */ jsx("p", { children: "No steps yet" }),
+          /* @__PURE__ */ jsx("p", { children: "Drag steps from the palette or use a template" })
+        ] })
+      ]
+    }
+  );
+}
+function StepConfigPanel(props) {
+  const [name, setName] = useState(props.step.name);
+  const inputId = `workflow-step-name-${props.step.id}`;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "ai-workflow__config-panel",
+      role: "complementary",
+      "aria-label": "Step configuration",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "ai-workflow__config-header", children: [
+          /* @__PURE__ */ jsx("h3", { className: "ai-workflow__config-title", children: "Configure Step" }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: cx(
+                "ai-workflow__config-close",
+                "ai-workflow__focus-visible"
+              ),
+              onClick: props.onClose,
+              "aria-label": "Close step configuration",
+              children: "\u2715"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "ai-workflow__config-body", children: [
+          /* @__PURE__ */ jsx("label", { className: "ai-workflow__config-label", htmlFor: inputId, children: "Step Name" }),
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              id: inputId,
+              className: "ai-workflow__config-input",
+              value: name,
+              onChange: (event) => setName(event.target.value),
+              onBlur: () => {
+                if (name.trim() && name !== props.step.name)
+                  props.onUpdate(props.step.id, { name: name.trim() });
+              }
+            }
+          ),
+          /* @__PURE__ */ jsxs("div", { className: "ai-workflow__config-field", children: [
+            /* @__PURE__ */ jsx("span", { className: "ai-workflow__config-field-label", children: "Type" }),
+            /* @__PURE__ */ jsx("span", { className: "ai-workflow__config-field-value", children: props.step.type })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "ai-workflow__config-field", children: [
+            /* @__PURE__ */ jsx("span", { className: "ai-workflow__config-field-label", children: "ID" }),
+            /* @__PURE__ */ jsx("code", { className: "ai-workflow__config-field-value", children: props.step.id })
+          ] }),
+          props.step.optional !== void 0 && /* @__PURE__ */ jsxs("label", { className: "ai-workflow__config-checkbox", children: [
+            /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "checkbox",
+                checked: props.step.optional,
+                onChange: (event) => props.onUpdate(props.step.id, {
+                  optional: event.target.checked
+                })
+              }
+            ),
+            "Optional (skip on failure)"
+          ] }),
+          /* @__PURE__ */ jsx("pre", { className: "ai-workflow__config-json-view", children: JSON.stringify(props.step.config, null, 2) })
+        ] }),
+        /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: cx(
+              "ai-workflow__config-delete",
+              "ai-workflow__focus-visible"
+            ),
+            onClick: () => {
+              props.onDelete(props.step.id);
+              props.onClose();
+            },
+            children: "\u{1F5D1} Delete Step"
+          }
+        ) })
+      ]
+    }
+  );
+}
+var SI = {
+  pending: "\u23F3",
+  running: "\u{1F504}",
+  completed: "\u2705",
+  failed: "\u274C",
+  skipped: "\u23ED\uFE0F",
+  "waiting-approval": "\u{1F464}"
+};
+function WorkflowRunPanel(props) {
+  if (!props.run)
+    return /* @__PURE__ */ jsx("div", { className: "ai-workflow__run-panel", children: /* @__PURE__ */ jsx("div", { className: "ai-workflow__run-empty", children: /* @__PURE__ */ jsx("p", { children: "No active run." }) }) });
+  const run = props.run;
+  const done = run.stepResults.filter(
+    (step) => step.status === "completed"
+  ).length;
+  const total = run.stepResults.length;
+  const progress = total > 0 ? Math.round(done / total * 100) : 0;
+  const totalCost = run.stepResults.reduce(
+    (sum, step) => sum + (step.costUsd ?? 0),
+    0
+  );
+  const totalTokens = run.stepResults.reduce(
+    (sum, step) => sum + (step.tokens ?? 0),
+    0
+  );
+  const duration = (run.completedAt ?? Date.now()) - run.startedAt;
+  return /* @__PURE__ */ jsxs("div", { className: "ai-workflow__run-panel", children: [
+    /* @__PURE__ */ jsxs("div", { className: "ai-workflow__run-header", children: [
+      /* @__PURE__ */ jsxs("h3", { className: "ai-workflow__run-title", children: [
+        SI[run.status],
+        " Run ",
+        run.status
+      ] }),
+      props.isRunning && props.onCancel && /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: cx(
+            "ai-workflow__run-cancel",
+            "ai-workflow__focus-visible"
+          ),
+          onClick: props.onCancel,
+          children: "\u23F9 Cancel"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "ai-workflow__run-progress", children: [
+      /* @__PURE__ */ jsx("div", { className: "ai-workflow__run-progress-bar", children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "ai-workflow__run-progress-fill",
+          style: { width: `${progress}%` }
+        }
+      ) }),
+      /* @__PURE__ */ jsxs("span", { className: "ai-workflow__run-progress-text", children: [
+        done,
+        "/",
+        total,
+        " (",
+        progress,
+        "%)"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "ai-workflow__run-stats", children: [
+      /* @__PURE__ */ jsxs("span", { className: "ai-workflow__run-stat", children: [
+        "\u23F1 ",
+        (duration / 1e3).toFixed(1),
+        "s"
+      ] }),
+      totalTokens > 0 && /* @__PURE__ */ jsxs("span", { className: "ai-workflow__run-stat", children: [
+        "\u{1FA99} ",
+        totalTokens.toLocaleString(),
+        " tokens"
+      ] }),
+      totalCost > 0 && /* @__PURE__ */ jsxs("span", { className: "ai-workflow__run-stat", children: [
+        "\u{1F4B0} ",
+        formatCost(totalCost)
+      ] })
+    ] }),
+    run.error && /* @__PURE__ */ jsx("div", { className: "ai-workflow__run-error", role: "alert", children: run.error }),
+    /* @__PURE__ */ jsx("ul", { className: "ai-workflow__run-steps", children: run.stepResults.map((stepResult) => /* @__PURE__ */ jsxs(
+      "li",
+      {
+        className: "ai-workflow__run-step-item",
+        "data-status": stepResult.status,
+        children: [
+          /* @__PURE__ */ jsx("span", { children: SI[stepResult.status] }),
+          /* @__PURE__ */ jsx("span", { children: stepResult.stepName }),
+          /* @__PURE__ */ jsxs("span", { children: [
+            stepResult.durationMs,
+            "ms"
+          ] })
+        ]
+      },
+      stepResult.stepId
+    )) })
+  ] });
+}
+function getFocusableElements(container) {
+  if (!container) {
+    return [];
+  }
+  return Array.from(
+    container.querySelectorAll(
+      'button:not([disabled]), [href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])'
+    )
+  );
+}
+function ApprovalModal(props) {
+  if (!props.request) return null;
+  const request = props.request;
+  const titleId = `workflow-approval-title-${request.id}`;
+  const messageId = `workflow-approval-message-${request.id}`;
+  const dialogRef = useRef(null);
+  const previousActiveElementRef = useRef(null);
+  useEffect(() => {
+    previousActiveElementRef.current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+    const dialog = dialogRef.current;
+    const dismiss = () => {
+      if (props.onDismiss) {
+        props.onDismiss(request.id);
+        return;
+      }
+      props.onReject(request.id);
+    };
+    const focusableElements = getFocusableElements(dialog);
+    (focusableElements[0] ?? dialog)?.focus();
+    const handleKeyDown = (event) => {
+      if (!dialog) {
+        return;
+      }
+      if (event.key === "Escape") {
+        event.preventDefault();
+        dismiss();
+        return;
+      }
+      if (event.key !== "Tab") {
+        return;
+      }
+      const currentFocusableElements = getFocusableElements(dialog);
+      if (currentFocusableElements.length === 0) {
+        event.preventDefault();
+        dialog.focus();
+        return;
+      }
+      const firstElement = currentFocusableElements[0];
+      const lastElement = currentFocusableElements[currentFocusableElements.length - 1];
+      if (event.shiftKey && document.activeElement === firstElement) {
+        event.preventDefault();
+        lastElement.focus();
+      } else if (!event.shiftKey && document.activeElement === lastElement) {
+        event.preventDefault();
+        firstElement.focus();
+      }
+    };
+    dialog?.addEventListener("keydown", handleKeyDown);
+    return () => {
+      dialog?.removeEventListener("keydown", handleKeyDown);
+      previousActiveElementRef.current?.focus();
+      previousActiveElementRef.current = null;
+    };
+  }, [props.onDismiss, props.onReject, request.id]);
+  return /* @__PURE__ */ jsxs("div", { "data-workflow": "approval-modal", children: [
+    /* @__PURE__ */ jsx("div", { className: "ai-workflow__approval-overlay", "aria-hidden": "true" }),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: dialogRef,
+        className: "ai-workflow__approval-dialog",
+        role: "dialog",
+        "aria-modal": "true",
+        "aria-labelledby": titleId,
+        "aria-describedby": messageId,
+        tabIndex: -1,
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "ai-workflow__approval-header", children: [
+            /* @__PURE__ */ jsx("span", { className: "ai-workflow__approval-icon", children: "\u{1F464}" }),
+            /* @__PURE__ */ jsx("h3", { id: titleId, className: "ai-workflow__approval-title", children: "Approval Required" })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("p", { id: messageId, className: "ai-workflow__approval-message", children: request.message }),
+            /* @__PURE__ */ jsxs("div", { className: "ai-workflow__approval-meta", children: [
+              /* @__PURE__ */ jsxs("span", { children: [
+                "Step: ",
+                request.stepId
+              ] }),
+              /* @__PURE__ */ jsxs("span", { children: [
+                "Requested:",
+                " ",
+                new Date(request.requestedAt).toLocaleTimeString()
+              ] })
+            ] }),
+            request.approvers && request.approvers.length > 0 && /* @__PURE__ */ jsxs("div", { children: [
+              /* @__PURE__ */ jsx("span", { children: "Authorized approvers: " }),
+              request.approvers.map((approver, index) => /* @__PURE__ */ jsx(
+                "span",
+                {
+                  className: "ai-workflow__approval-approver-badge",
+                  children: approver
+                },
+                index
+              ))
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "ai-workflow__approval-actions", children: [
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                className: cx(
+                  "ai-workflow__approval-reject",
+                  "ai-workflow__focus-visible"
+                ),
+                onClick: () => props.onReject(request.id),
+                children: "\u2715 Reject"
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                className: cx(
+                  "ai-workflow__approval-approve",
+                  "ai-workflow__focus-visible"
+                ),
+                onClick: () => props.onApprove(request.id),
+                children: "\u2713 Approve"
+              }
+            )
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+function WorkflowToolbar(props) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cx("ai-workflow__toolbar", props.className),
+      role: "toolbar",
+      "aria-label": "Workflow actions",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "ai-workflow__toolbar-left", children: [
+          /* @__PURE__ */ jsx("h2", { className: "ai-workflow__toolbar-title", children: props.workflowName }),
+          props.isDirty && /* @__PURE__ */ jsx("span", { className: "ai-workflow__toolbar-dirty", children: "\u25CF" })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "ai-workflow__toolbar-center", children: [
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: cx(
+                "ai-workflow__toolbar-btn",
+                "ai-workflow__focus-visible"
+              ),
+              onClick: props.onUndo,
+              disabled: !props.canUndo,
+              "aria-label": "Undo",
+              children: "\u21B6"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: cx(
+                "ai-workflow__toolbar-btn",
+                "ai-workflow__focus-visible"
+              ),
+              onClick: props.onRedo,
+              disabled: !props.canRedo,
+              "aria-label": "Redo",
+              children: "\u21B7"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "ai-workflow__toolbar-right", children: [
+          props.onExport && /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: cx(
+                "ai-workflow__toolbar-btn-secondary",
+                "ai-workflow__focus-visible"
+              ),
+              onClick: props.onExport,
+              "aria-label": "Export workflow",
+              children: "\u{1F4E4} Export"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: cx(
+                "ai-workflow__toolbar-btn-secondary",
+                "ai-workflow__focus-visible"
+              ),
+              onClick: props.onSave,
+              disabled: !props.isDirty,
+              "aria-label": "Save workflow",
+              children: "\u{1F4BE} Save"
+            }
+          ),
+          props.isRunning ? /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: cx(
+                "ai-workflow__toolbar-btn-danger",
+                "ai-workflow__focus-visible"
+              ),
+              onClick: props.onCancel,
+              "aria-label": "Stop workflow run",
+              children: "\u23F9 Stop"
+            }
+          ) : /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: cx(
+                "ai-workflow__toolbar-btn-primary",
+                "ai-workflow__focus-visible"
+              ),
+              onClick: props.onRun,
+              "aria-label": "Run workflow",
+              children: "\u25B6 Run"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+var ITEMS = [
+  { type: "llm-call", label: "LLM Call", icon: "\u{1F916}", desc: "Call an AI model" },
+  { type: "transform", label: "Transform", icon: "\u2699\uFE0F", desc: "Transform data" },
+  {
+    type: "condition",
+    label: "Condition",
+    icon: "\u{1F500}",
+    desc: "If/else branching"
+  },
+  {
+    type: "human-approval",
+    label: "Approval",
+    icon: "\u{1F464}",
+    desc: "Human approval gate"
+  },
+  { type: "webhook", label: "Webhook", icon: "\u{1F310}", desc: "HTTP request" },
+  { type: "delay", label: "Delay", icon: "\u23F1\uFE0F", desc: "Wait for duration" },
+  { type: "parallel", label: "Parallel", icon: "\u26A1", desc: "Run in parallel" },
+  { type: "loop", label: "Loop", icon: "\u{1F504}", desc: "Iterate items" },
+  {
+    type: "sub-workflow",
+    label: "Sub-workflow",
+    icon: "\u{1F4CB}",
+    desc: "Run another workflow"
+  },
+  { type: "custom", label: "Custom", icon: "\u{1F527}", desc: "Custom handler" }
+];
+function StepPalette(props) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "ai-workflow__step-palette",
+      role: "list",
+      "aria-label": "Available workflow step types",
+      children: [
+        /* @__PURE__ */ jsx("h3", { className: "ai-workflow__palette-title", children: "Steps" }),
+        ITEMS.map((item) => /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            className: cx(
+              "ai-workflow__palette-item",
+              "ai-workflow__focus-visible"
+            ),
+            role: "listitem",
+            "aria-label": `Add ${item.label} step`,
+            onClick: () => props.onAddStep(item.type),
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "ai-workflow__palette-icon", children: item.icon }),
+              /* @__PURE__ */ jsxs("div", { className: "ai-workflow__palette-info", children: [
+                /* @__PURE__ */ jsx("span", { className: "ai-workflow__palette-label", children: item.label }),
+                /* @__PURE__ */ jsx("span", { className: "ai-workflow__palette-desc", children: item.desc })
+              ] })
+            ]
+          },
+          item.type
+        ))
+      ]
+    }
+  );
+}
+function createStepConfig(type) {
+  switch (type) {
+    case "llm-call":
+      return {
+        type,
+        systemPrompt: "",
+        userPromptTemplate: "",
+        outputVar: "result"
+      };
+    case "transform":
+      return { type, expression: "", inputVars: [], outputVar: "result" };
+    case "condition":
+      return { type, expression: "", trueStepId: "", falseStepId: "" };
+    case "human-approval":
+      return { type, message: "" };
+    case "webhook":
+      return { type, url: "", method: "POST", outputVar: "result" };
+    case "delay":
+      return { type, durationMs: 0 };
+    case "parallel":
+      return { type, stepIds: [], failurePolicy: "continue" };
+    case "loop":
+      return {
+        type,
+        stepIds: [],
+        iterateVar: "",
+        itemVar: "",
+        maxIterations: 1
+      };
+    case "sub-workflow":
+      return { type, workflowId: "", inputMapping: {}, outputVar: "result" };
+    case "custom":
+      return { type, handler: "custom", params: {}, outputVar: "result" };
+  }
+}
+function WorkflowBuilderPage(props) {
+  const builder = useWorkflowBuilder();
+  const runTracker = useWorkflowRun();
+  const workflowCount = props.workflows?.length ?? 0;
+  const runCount = props.workflowRuns?.length ?? 0;
+  const handleAddStep = useCallback(
+    (type) => {
+      const step = {
+        id: `step_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+        name: `New ${type} step`,
+        type,
+        config: createStepConfig(type),
+        position: {
+          x: 100 + builder.definition.steps.length * 250,
+          y: 200
+        }
+      };
+      builder.addStep(step);
+    },
+    [builder]
+  );
+  const handleRun = useCallback(async () => {
+    const engine = new WorkflowEngine({
+      ...props.engineOptions,
+      onStepComplete: (result2) => {
+        runTracker.updateStep(result2);
+      }
+    });
+    const result = await engine.execute(builder.definition);
+    runTracker.trackRun(result);
+  }, [builder.definition, props.engineOptions, runTracker]);
+  const selectedStep = builder.selectedStepId ? builder.definition.steps.find((step) => step.id === builder.selectedStepId) ?? null : null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cx("ai-workflow__builder-page", props.className),
+      "data-workflow": "builder-page",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "ai-workflow__builder-summary", "data-workflow": "builder-summary", children: [
+          /* @__PURE__ */ jsxs("span", { "data-workflow": "builder-workflow-count", children: [
+            workflowCount,
+            " workflows"
+          ] }),
+          /* @__PURE__ */ jsxs("span", { "data-workflow": "builder-run-count", children: [
+            runCount,
+            " runs"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(
+          WorkflowToolbar,
+          {
+            workflowName: builder.definition.name,
+            isDirty: builder.isDirty,
+            isRunning: runTracker.isRunning,
+            canUndo: builder.canUndo,
+            canRedo: builder.canRedo,
+            onSave: () => props.onSave?.(builder.definition),
+            onRun: handleRun,
+            onUndo: builder.undo,
+            onRedo: builder.redo
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "ai-workflow__builder-layout", children: [
+          /* @__PURE__ */ jsx(StepPalette, { onAddStep: handleAddStep }),
+          /* @__PURE__ */ jsx(
+            WorkflowCanvas,
+            {
+              definition: builder.definition,
+              selectedStepId: builder.selectedStepId,
+              onSelectStep: builder.selectStep
+            }
+          ),
+          selectedStep ? /* @__PURE__ */ jsx(
+            StepConfigPanel,
+            {
+              step: selectedStep,
+              onUpdate: builder.updateStep,
+              onDelete: builder.removeStep,
+              onClose: () => builder.selectStep(null)
+            }
+          ) : null,
+          runTracker.run ? /* @__PURE__ */ jsx(
+            WorkflowRunPanel,
+            {
+              run: runTracker.run,
+              isRunning: runTracker.isRunning
+            }
+          ) : null
+        ] })
+      ]
+    }
+  );
+}
+var SI2 = {
+  pending: "\u23F3",
+  running: "\u{1F504}",
+  completed: "\u2705",
+  failed: "\u274C",
+  cancelled: "\u26D4",
+  paused: "\u23F8\uFE0F"
+};
+function WorkflowRunsPage(props) {
+  return /* @__PURE__ */ jsxs("div", { className: cx("ai-workflow__runs-page", props.className), children: [
+    /* @__PURE__ */ jsxs("div", { className: "ai-workflow__runs-header", children: [
+      /* @__PURE__ */ jsx("h1", { className: "ai-workflow__runs-title", children: "Workflow Runs" }),
+      /* @__PURE__ */ jsxs("span", { className: "ai-workflow__runs-count", children: [
+        props.runs.length,
+        " runs"
+      ] })
+    ] }),
+    props.runs.length === 0 ? /* @__PURE__ */ jsx("div", { className: "ai-workflow__runs-empty", children: /* @__PURE__ */ jsx("p", { children: "No runs yet." }) }) : /* @__PURE__ */ jsx("div", { role: "list", children: props.runs.map((run) => {
+      const completedSteps = run.stepResults.filter(
+        (step) => step.status === "completed"
+      ).length;
+      return /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: cx(
+            "ai-workflow__run-card",
+            "ai-workflow__focus-visible"
+          ),
+          role: "listitem",
+          tabIndex: 0,
+          onClick: () => props.onSelectRun?.(run.id),
+          onKeyDown: (event) => {
+            if (event.key === "Enter" || event.key === " ") {
+              event.preventDefault();
+              props.onSelectRun?.(run.id);
+            }
+          },
+          children: [
+            /* @__PURE__ */ jsxs("div", { className: "ai-workflow__run-card-header", children: [
+              /* @__PURE__ */ jsxs("span", { className: "ai-workflow__run-card-status", children: [
+                SI2[run.status],
+                " ",
+                run.status
+              ] }),
+              /* @__PURE__ */ jsxs("span", { className: "ai-workflow__run-card-id", children: [
+                run.id.slice(0, 8),
+                "\u2026"
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "ai-workflow__run-card-meta", children: [
+              /* @__PURE__ */ jsxs("span", { children: [
+                completedSteps,
+                "/",
+                run.stepResults.length,
+                " steps"
+              ] }),
+              /* @__PURE__ */ jsx("span", { children: new Date(run.startedAt).toLocaleString() })
+            ] }),
+            run.error && /* @__PURE__ */ jsx("p", { className: "ai-workflow__run-card-error", children: run.error })
+          ]
+        },
+        run.id
+      );
+    }) })
+  ] });
+}
+
+export { ApprovalModal, StepConfigPanel, StepConnector, StepNode, StepPalette, WORKFLOW_TEMPLATES, WorkflowBuilderPage, WorkflowCanvas, WorkflowEngine, WorkflowRunPanel, WorkflowRunsPage, WorkflowToolbar, getTemplate, getTemplatesByCategory, useApprovalGate, useWorkflow, useWorkflowBuilder, useWorkflowRun, useWorkflowStep, useWorkflowTemplates, validateRun, validateWorkflow };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map