@contractspec/lib.contracts 1.62.0 → 1.64.0

package/dist/workflow/index.js

@@ -1,1546 +0,0 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// src/registry-utils.ts
-var exports_registry_utils = {};
-__export(exports_registry_utils, {
-  groupByToArray: () => groupByToArray,
-  groupByMultiple: () => groupByMultiple,
-  groupBy: () => groupBy,
-  getUniqueTags: () => getUniqueTags,
-  getUniqueOwners: () => getUniqueOwners,
-  getUniqueDomains: () => getUniqueDomains,
-  filterBy: () => filterBy,
-  GroupingStrategies: () => GroupingStrategies
-});
-function filterBy(items, filter) {
-  return items.filter((item) => {
-    if (filter.tags?.length) {
-      const hasMatchingTag = filter.tags.some((tag) => item.meta.tags?.includes(tag));
-      if (!hasMatchingTag)
-        return false;
-    }
-    if (filter.owners?.length) {
-      const hasMatchingOwner = filter.owners.some((owner) => item.meta.owners?.includes(owner));
-      if (!hasMatchingOwner)
-        return false;
-    }
-    if (filter.stability?.length) {
-      if (!filter.stability.includes(item.meta.stability ?? "stable")) {
-        return false;
-      }
-    }
-    if (filter.domain) {
-      const itemDomain = GroupingStrategies.byDomain(item);
-      if (itemDomain !== filter.domain)
-        return false;
-    }
-    if (filter.keyPattern) {
-      const name = item.meta.key ?? item.meta.key ?? "";
-      const pattern = filter.keyPattern.replace(/\*/g, ".*").replace(/\?/g, ".");
-      const regex = new RegExp(`^${pattern}$`, "i");
-      if (!regex.test(name))
-        return false;
-    }
-    return true;
-  });
-}
-function groupBy(items, keyFn) {
-  const groups = new Map;
-  for (const item of items) {
-    const key = keyFn(item);
-    const existing = groups.get(key);
-    if (existing) {
-      existing.push(item);
-    } else {
-      groups.set(key, [item]);
-    }
-  }
-  return groups;
-}
-function groupByToArray(items, keyFn) {
-  const map = groupBy(items, keyFn);
-  return Array.from(map.entries()).map(([key, items2]) => ({ key, items: items2 }));
-}
-function groupByMultiple(items, keysFn) {
-  const groups = new Map;
-  for (const item of items) {
-    const keys = keysFn(item);
-    for (const key of keys) {
-      const existing = groups.get(key);
-      if (existing) {
-        existing.push(item);
-      } else {
-        groups.set(key, [item]);
-      }
-    }
-  }
-  return groups;
-}
-function getUniqueTags(items) {
-  const tags = new Set;
-  for (const item of items) {
-    for (const tag of item.meta.tags ?? []) {
-      tags.add(tag);
-    }
-  }
-  return Array.from(tags).sort();
-}
-function getUniqueOwners(items) {
-  const owners = new Set;
-  for (const item of items) {
-    for (const owner of item.meta.owners ?? []) {
-      owners.add(owner);
-    }
-  }
-  return Array.from(owners).sort();
-}
-function getUniqueDomains(items) {
-  const domains = new Set;
-  for (const item of items) {
-    domains.add(GroupingStrategies.byDomain(item));
-  }
-  return Array.from(domains).sort();
-}
-var GroupingStrategies;
-var init_registry_utils = __esm(() => {
-  GroupingStrategies = {
-    byTag: (item) => item.meta.tags?.[0] ?? "untagged",
-    byAllTags: (item) => item.meta.tags?.length ? item.meta.tags : ["untagged"],
-    byOwner: (item) => item.meta.owners?.[0] ?? "unowned",
-    byDomain: (item) => {
-      const name = item.meta.key ?? item.meta.key ?? "";
-      return name.split(".")[0] ?? "default";
-    },
-    byStability: (item) => item.meta.stability ?? "stable",
-    byUrlPath: (level) => (item) => {
-      if (!item.path)
-        return "root";
-      const segments = item.path.split("/").filter(Boolean);
-      return segments.slice(0, level).join("/") || "root";
-    }
-  };
-});
-
-// src/registry.ts
-init_registry_utils();
-import { compareVersions } from "compare-versions";
-var keyOfSpecContract = (spec) => `${spec.meta.key}.v${spec.meta.version}`;
-
-class SpecContractRegistry {
-  contractType;
-  items = new Map;
-  constructor(contractType, items) {
-    this.contractType = contractType;
-    if (items) {
-      items.forEach((p) => this.register(p));
-    }
-  }
-  register(p) {
-    const key = keyOfSpecContract(p);
-    if (this.items.has(key))
-      throw new Error(`Duplicate contract \`${this.contractType}\` ${key}`);
-    this.items.set(key, p);
-    return this;
-  }
-  count() {
-    return this.items.size;
-  }
-  list() {
-    return [...this.items.values()];
-  }
-  get(key, version) {
-    if (version != null)
-      return this.items.get(`${key}.v${version}`);
-    let candidate;
-    for (const [k, p] of this.items.entries()) {
-      if (!k.startsWith(`${key}.v`))
-        continue;
-      if (!candidate || compareVersions(p.meta.version, candidate.meta.version) > 0) {
-        candidate = p;
-      }
-    }
-    return candidate;
-  }
-  has(key, version) {
-    return !!this.get(key, version);
-  }
-  filter(criteria) {
-    return filterBy(this.list(), criteria);
-  }
-  listByTag(tag) {
-    return this.list().filter((p) => p.meta.tags?.includes(tag));
-  }
-  listByOwner(owner) {
-    return this.list().filter((p) => p.meta.owners?.includes(owner));
-  }
-  groupBy(keyFn) {
-    return groupBy(this.list(), keyFn);
-  }
-  getUniqueTags() {
-    return getUniqueTags(this.list());
-  }
-}
-
-// src/workflow/spec.ts
-class WorkflowRegistry extends SpecContractRegistry {
-  constructor(items) {
-    super("workflow", items);
-  }
-}
-
-// src/workflow/validation.ts
-class WorkflowValidationError extends Error {
-  issues;
-  constructor(message, issues) {
-    super(message);
-    this.issues = issues;
-    this.name = "WorkflowValidationError";
-  }
-}
-function validateWorkflowSpec(spec, options = {}) {
-  const issues = [];
-  const { definition } = spec;
-  if (!definition.steps.length) {
-    issues.push({
-      level: "error",
-      message: "Workflow must declare at least one step."
-    });
-    return issues;
-  }
-  const stepsById = indexSteps(definition, issues);
-  const entryStepId = definition.entryStepId ?? definition.steps[0]?.id ?? null;
-  if (!entryStepId) {
-    issues.push({
-      level: "error",
-      message: "Workflow requires an entry step (definition.entryStepId)."
-    });
-  } else if (!stepsById.has(entryStepId)) {
-    issues.push({
-      level: "error",
-      message: `Entry step "${entryStepId}" is not defined in steps.`
-    });
-  }
-  const adjacency = buildAdjacency(definition, stepsById, issues);
-  validateStepActions(definition.steps, options, issues);
-  validateReachability(entryStepId, stepsById, adjacency, issues);
-  detectCycles(adjacency, issues);
-  return issues;
-}
-function assertWorkflowSpecValid(spec, options = {}) {
-  const issues = validateWorkflowSpec(spec, options);
-  const errors = issues.filter((issue) => issue.level === "error");
-  if (errors.length) {
-    throw new WorkflowValidationError(`Workflow ${spec.meta.key}.v${spec.meta.version} is invalid`, issues);
-  }
-}
-function indexSteps(definition, issues) {
-  const stepsById = new Map;
-  for (const step of definition.steps) {
-    if (stepsById.has(step.id)) {
-      issues.push({
-        level: "error",
-        message: `Duplicate step id "${step.id}" detected.`
-      });
-      continue;
-    }
-    stepsById.set(step.id, step);
-    if (step.type === "automation" && !step.action?.operation) {
-      issues.push({
-        level: "warning",
-        message: `Automation step "${step.id}" does not declare an operation.`
-      });
-    }
-    if (step.type === "human" && !step.action?.form) {
-      issues.push({
-        level: "warning",
-        message: `Human step "${step.id}" does not declare a form.`
-      });
-    }
-    if (step.guard && !step.guard.value.trim()) {
-      issues.push({
-        level: "error",
-        message: `Guard for step "${step.id}" must have a non-empty value.`
-      });
-    }
-  }
-  return stepsById;
-}
-function buildAdjacency(definition, stepsById, issues) {
-  const adjacency = new Map;
-  const incoming = new Map;
-  for (const stepId of stepsById.keys()) {
-    adjacency.set(stepId, new Set);
-    incoming.set(stepId, 0);
-  }
-  for (const transition of definition.transitions) {
-    const from = stepsById.get(transition.from);
-    const to = stepsById.get(transition.to);
-    if (!from) {
-      issues.push({
-        level: "error",
-        message: `Transition refers to unknown "from" step "${transition.from}".`
-      });
-      continue;
-    }
-    if (!to) {
-      issues.push({
-        level: "error",
-        message: `Transition refers to unknown "to" step "${transition.to}".`
-      });
-      continue;
-    }
-    adjacency.get(transition.from)?.add(transition.to);
-    incoming.set(transition.to, (incoming.get(transition.to) ?? 0) + 1);
-    validateTransition(transition, issues);
-  }
-  const roots = [...incoming.entries()].filter(([, count]) => count === 0).map(([id]) => id);
-  if (roots.length > 1) {
-    issues.push({
-      level: "warning",
-      message: `Workflow has multiple potential entry steps: ${roots.join(", ")}`
-    });
-  }
-  return adjacency;
-}
-function validateTransition(transition, issues) {
-  if (transition.condition && !transition.condition.trim()) {
-    issues.push({
-      level: "error",
-      message: `Transition ${transition.from} -> ${transition.to} declares an empty condition.`
-    });
-  }
-}
-function validateStepActions(steps, options, issues) {
-  for (const step of steps) {
-    const action = step.action;
-    if (!action)
-      continue;
-    if (action.operation && options.operations) {
-      const op = options.operations.get(action.operation.key, action.operation.version);
-      if (!op) {
-        issues.push({
-          level: "error",
-          message: `Step "${step.id}" references unknown operation ${action.operation.key}.v${action.operation.version}.`
-        });
-      }
-    }
-    if (action.form && options.forms) {
-      const form = options.forms.get(action.form.key, action.form.version);
-      if (!form) {
-        issues.push({
-          level: "error",
-          message: `Step "${step.id}" references unknown form ${action.form.key}.v${action.form.version}.`
-        });
-      }
-    }
-  }
-}
-function validateReachability(entryStepId, stepsById, adjacency, issues) {
-  if (!entryStepId || !stepsById.has(entryStepId))
-    return;
-  const visited = new Set;
-  const queue = [entryStepId];
-  visited.add(entryStepId);
-  while (queue.length) {
-    const current = queue.shift();
-    if (!current)
-      continue;
-    const neighbours = adjacency.get(current);
-    if (!neighbours)
-      continue;
-    for (const next of neighbours) {
-      if (visited.has(next))
-        continue;
-      visited.add(next);
-      queue.push(next);
-    }
-  }
-  for (const stepId of stepsById.keys()) {
-    if (!visited.has(stepId)) {
-      issues.push({
-        level: "error",
-        message: `Step "${stepId}" is unreachable from entry step "${entryStepId}".`
-      });
-    }
-  }
-}
-function detectCycles(adjacency, issues) {
-  const visited = new Set;
-  const stack = new Set;
-  let cycleReported = false;
-  const dfs = (node) => {
-    if (stack.has(node)) {
-      if (!cycleReported) {
-        issues.push({
-          level: "error",
-          message: `Workflow contains a cycle involving step "${node}".`
-        });
-        cycleReported = true;
-      }
-      return;
-    }
-    if (visited.has(node))
-      return;
-    stack.add(node);
-    const neighbours = adjacency.get(node);
-    if (neighbours) {
-      for (const next of neighbours)
-        dfs(next);
-    }
-    stack.delete(node);
-    visited.add(node);
-  };
-  for (const node of adjacency.keys())
-    dfs(node);
-}
-function validateWorkflowConsistency(deps) {
-  const issues = [];
-  for (const workflow of deps.workflows.list()) {
-    const specOptions = {
-      operations: deps.operations,
-      forms: deps.forms
-    };
-    const specIssues = validateWorkflowSpec(workflow, specOptions);
-    issues.push(...specIssues.map((i) => ({
-      ...i,
-      message: `[${workflow.meta.key}.v${workflow.meta.version}] ${i.message}`
-    })));
-    if (deps.capabilities) {
-      for (const step of workflow.definition.steps) {
-        for (const capRef of step.requiredCapabilities ?? []) {
-          const cap = deps.capabilities.get(capRef.key, capRef.version);
-          if (!cap) {
-            issues.push({
-              level: "error",
-              message: `[${workflow.meta.key}.v${workflow.meta.version}] Step "${step.id}" references unknown capability "${capRef.key}.v${capRef.version}"`,
-              context: { stepId: step.id, capability: capRef }
-            });
-          }
-        }
-      }
-    }
-    if (workflow.definition.compensation && deps.operations) {
-      for (const compStep of workflow.definition.compensation.steps) {
-        const op = deps.operations.get(compStep.operation.key, compStep.operation.version);
-        if (!op) {
-          issues.push({
-            level: "error",
-            message: `[${workflow.meta.key}.v${workflow.meta.version}] Compensation for step "${compStep.stepId}" references unknown operation "${compStep.operation.key}.v${compStep.operation.version}"`,
-            context: { stepId: compStep.stepId, operation: compStep.operation }
-          });
-        }
-      }
-    }
-    if (workflow.definition.sla?.stepDurationMs) {
-      const stepIds = new Set(workflow.definition.steps.map((s) => s.id));
-      for (const stepId of Object.keys(workflow.definition.sla.stepDurationMs)) {
-        if (!stepIds.has(stepId)) {
-          issues.push({
-            level: "warning",
-            message: `[${workflow.meta.key}.v${workflow.meta.version}] SLA references unknown step "${stepId}"`,
-            context: { stepId }
-          });
-        }
-      }
-    }
-  }
-  return {
-    valid: issues.filter((i) => i.level === "error").length === 0,
-    issues
-  };
-}
-function assertWorkflowConsistency(deps) {
-  const result = validateWorkflowConsistency(deps);
-  if (!result.valid) {
-    throw new WorkflowValidationError("Workflow consistency check failed", result.issues);
-  }
-}
-function validateSlaConfig(spec) {
-  const issues = [];
-  const sla = spec.definition.sla;
-  if (!sla)
-    return issues;
-  if (sla.totalDurationMs !== undefined && sla.totalDurationMs <= 0) {
-    issues.push({
-      level: "error",
-      message: "SLA totalDurationMs must be positive",
-      context: { totalDurationMs: sla.totalDurationMs }
-    });
-  }
-  if (sla.stepDurationMs) {
-    for (const [stepId, duration] of Object.entries(sla.stepDurationMs)) {
-      if (duration <= 0) {
-        issues.push({
-          level: "error",
-          message: `SLA stepDurationMs for "${stepId}" must be positive`,
-          context: { stepId, duration }
-        });
-      }
-    }
-    const stepDurationsSum = Object.values(sla.stepDurationMs).reduce((sum, d) => sum + d, 0);
-    if (sla.totalDurationMs && stepDurationsSum > sla.totalDurationMs) {
-      issues.push({
-        level: "warning",
-        message: `Sum of step durations (${stepDurationsSum}ms) exceeds total duration (${sla.totalDurationMs}ms)`,
-        context: { stepDurationsSum, totalDurationMs: sla.totalDurationMs }
-      });
-    }
-  }
-  return issues;
-}
-function validateCompensation(spec) {
-  const issues = [];
-  const compensation = spec.definition.compensation;
-  if (!compensation)
-    return issues;
-  const stepIds = new Set(spec.definition.steps.map((s) => s.id));
-  const coveredSteps = new Set;
-  for (const compStep of compensation.steps) {
-    if (!stepIds.has(compStep.stepId)) {
-      issues.push({
-        level: "error",
-        message: `Compensation references unknown step "${compStep.stepId}"`,
-        context: { stepId: compStep.stepId }
-      });
-    }
-    if (coveredSteps.has(compStep.stepId)) {
-      issues.push({
-        level: "warning",
-        message: `Multiple compensation handlers for step "${compStep.stepId}"`,
-        context: { stepId: compStep.stepId }
-      });
-    }
-    coveredSteps.add(compStep.stepId);
-    if (!compStep.operation?.key || !compStep.operation?.version) {
-      issues.push({
-        level: "error",
-        message: `Compensation for step "${compStep.stepId}" must specify operation with key and version`,
-        context: { stepId: compStep.stepId }
-      });
-    }
-  }
-  const automationSteps = spec.definition.steps.filter((s) => s.type === "automation");
-  for (const step of automationSteps) {
-    if (!coveredSteps.has(step.id)) {
-      issues.push({
-        level: "warning",
-        message: `Automation step "${step.id}" has no compensation handler`,
-        context: { stepId: step.id }
-      });
-    }
-  }
-  return issues;
-}
-function validateRetryConfig(spec) {
-  const issues = [];
-  for (const step of spec.definition.steps) {
-    if (!step.retry)
-      continue;
-    if (step.retry.maxAttempts <= 0) {
-      issues.push({
-        level: "error",
-        message: `Step "${step.id}" retry maxAttempts must be positive`,
-        context: { stepId: step.id, maxAttempts: step.retry.maxAttempts }
-      });
-    }
-    if (step.retry.delayMs <= 0) {
-      issues.push({
-        level: "error",
-        message: `Step "${step.id}" retry delayMs must be positive`,
-        context: { stepId: step.id, delayMs: step.retry.delayMs }
-      });
-    }
-    if (step.retry.maxDelayMs !== undefined && step.retry.maxDelayMs < step.retry.delayMs) {
-      issues.push({
-        level: "warning",
-        message: `Step "${step.id}" retry maxDelayMs (${step.retry.maxDelayMs}) is less than delayMs (${step.retry.delayMs})`,
-        context: { stepId: step.id }
-      });
-    }
-  }
-  return issues;
-}
-function validateWorkflowComprehensive(spec, options = {}) {
-  const issues = [];
-  issues.push(...validateWorkflowSpec(spec, options));
-  issues.push(...validateSlaConfig(spec));
-  issues.push(...validateCompensation(spec));
-  issues.push(...validateRetryConfig(spec));
-  return {
-    valid: issues.filter((i) => i.level === "error").length === 0,
-    issues
-  };
-}
-// src/workflow/expression.ts
-function evaluateExpression(expression, ctx) {
-  if (!expression)
-    return true;
-  const trimmed = expression.trim();
-  if (!trimmed)
-    return true;
-  const orParts = splitByOperator(trimmed, "||");
-  if (orParts.length > 1)
-    return orParts.some((part) => evaluateExpression(part, ctx));
-  const andParts = splitByOperator(trimmed, "&&");
-  if (andParts.length > 1)
-    return andParts.every((part) => evaluateExpression(part, ctx));
-  return evaluateSingle(trimmed, ctx);
-}
-function evaluateSingle(expr, ctx) {
-  const trimmed = expr.trim();
-  if (!trimmed)
-    return true;
-  if (trimmed.startsWith("!"))
-    return !evaluateSingle(trimmed.slice(1), ctx);
-  const comparisonMatch = trimmed.match(/^(data|input|output)\.([A-Za-z0-9_.[\]]+)\s*(===|==|!==|!=|>=|<=|>|<)\s*(.+)$/);
-  if (comparisonMatch) {
-    const [, root, path, operator, rawRight] = comparisonMatch;
-    const left = resolveRoot(root, ctx, path);
-    const right = parseLiteral(rawRight);
-    return compare(left, right, operator);
-  }
-  const truthyMatch = trimmed.match(/^(data|input|output)\.([A-Za-z0-9_.[\]]+)$/);
-  if (truthyMatch) {
-    const [, root, path] = truthyMatch;
-    const value = resolveRoot(root, ctx, path);
-    return Boolean(value);
-  }
-  const literal = parseLiteral(trimmed);
-  return Boolean(literal);
-}
-function compare(left, right, operator) {
-  switch (operator) {
-    case "===":
-    case "==":
-      return left === right;
-    case "!==":
-    case "!=":
-      return left !== right;
-    case ">":
-      return Number(left) > Number(right);
-    case ">=":
-      return Number(left) >= Number(right);
-    case "<":
-      return Number(left) < Number(right);
-    case "<=":
-      return Number(left) <= Number(right);
-    default:
-      return false;
-  }
-}
-function parseLiteral(value) {
-  const trimmed = (value ?? "").trim();
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'"))
-    return trimmed.slice(1, -1);
-  if (/^-?\d+(\.\d+)?$/.test(trimmed))
-    return Number(trimmed);
-  if (/^true$/i.test(trimmed))
-    return true;
-  if (/^false$/i.test(trimmed))
-    return false;
-  if (/^null$/i.test(trimmed))
-    return null;
-  if (/^undefined$/i.test(trimmed))
-    return;
-  return trimmed;
-}
-function resolveRoot(root, ctx, path) {
-  const source = root === "data" ? ctx.data : root === "input" ? ctx.input : ctx.output;
-  return resolvePath(source, path);
-}
-function resolvePath(source, path) {
-  if (source == null)
-    return;
-  if (!path)
-    return source;
-  const segments = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
-  let current = source;
-  for (const segment of segments) {
-    if (current == null)
-      return;
-    current = current[segment];
-  }
-  return current;
-}
-function splitByOperator(expr, operator) {
-  const parts = [];
-  let buffer = "";
-  let inSingleQuote = false;
-  let inDoubleQuote = false;
-  for (let i = 0;i < expr.length; i++) {
-    const char = expr[i];
-    if (!char)
-      continue;
-    const next = expr.slice(i, i + operator.length);
-    if (char === "'" && !inDoubleQuote) {
-      inSingleQuote = !inSingleQuote;
-      buffer += char;
-      continue;
-    }
-    if (char === '"' && !inSingleQuote) {
-      inDoubleQuote = !inDoubleQuote;
-      buffer += char;
-      continue;
-    }
-    if (!inSingleQuote && !inDoubleQuote && next === operator) {
-      parts.push(buffer.trim());
-      buffer = "";
-      i += operator.length - 1;
-      continue;
-    }
-    buffer += char;
-  }
-  if (buffer.trim().length)
-    parts.push(buffer.trim());
-  return parts;
-}
-
-// src/workflow/runner.ts
-import { randomUUID } from "crypto";
-class WorkflowRunner {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  async preFlightCheck(workflowName, version, resolvedConfig) {
-    const spec = this.getSpec(workflowName, version);
-    return this.performPreFlight(spec, resolvedConfig);
-  }
-  async start(workflowName, version, initialData) {
-    const spec = this.getSpec(workflowName, version);
-    const entryStepId = resolveEntryStepId(spec);
-    const now = new Date;
-    const workflowId = randomUUID();
-    const state = {
-      workflowId,
-      workflowName: spec.meta.key,
-      workflowVersion: spec.meta.version,
-      currentStep: entryStepId,
-      data: { ...initialData ?? {} },
-      retryCounts: {},
-      history: [],
-      status: "running",
-      createdAt: now,
-      updatedAt: now
-    };
-    const resolvedAppConfig = this.config.appConfigProvider ? await this.config.appConfigProvider(state) : undefined;
-    const preFlightResult = await this.performPreFlight(spec, resolvedAppConfig);
-    if (!preFlightResult.canStart) {
-      throw new WorkflowPreFlightError(preFlightResult.issues);
-    }
-    await this.config.stateStore.create(state);
-    this.emit("workflow.started", {
-      workflowId,
-      workflowName: spec.meta.key,
-      workflowVersion: spec.meta.version,
-      currentStep: entryStepId
-    });
-    return workflowId;
-  }
-  async executeStep(workflowId, input) {
-    const state = await this.getStateOrThrow(workflowId);
-    if (isTerminalStatus(state.status)) {
-      throw new Error(`Workflow ${workflowId} is in terminal status "${state.status}".`);
-    }
-    const spec = this.getSpec(state.workflowName, state.workflowVersion);
-    const step = getCurrentStep(spec, state.currentStep);
-    const guardOk = await this.evaluateGuard(step, state, input);
-    if (!guardOk)
-      throw new Error(`GuardRejected: ${state.workflowName} -> ${step.id}`);
-    const execution = {
-      stepId: step.id,
-      startedAt: new Date,
-      status: "running",
-      input
-    };
-    const workingState = {
-      ...state,
-      data: { ...state.data },
-      history: [...state.history]
-    };
-    try {
-      const output = await this.runStepAction(step, workingState, input);
-      execution.output = output;
-      execution.status = "completed";
-      execution.completedAt = new Date;
-      workingState.history.push(execution);
-      workingState.updatedAt = new Date;
-      if (isRecord(input)) {
-        workingState.data = { ...workingState.data, ...input };
-      }
-      if (isRecord(output)) {
-        workingState.data = { ...workingState.data, ...output };
-      }
-      const nextStepId = this.pickNextStepId(spec, workingState, step, input, output);
-      if (nextStepId) {
-        workingState.currentStep = nextStepId;
-        workingState.status = "running";
-      } else if (!hasOutgoing(spec, step.id)) {
-        workingState.status = "completed";
-      } else {
-        throw new Error(`No transition matched after executing step "${step.id}".`);
-      }
-      await this.config.stateStore.update(workflowId, () => workingState);
-      this.emit("workflow.step_completed", {
-        workflowId,
-        workflowName: state.workflowName,
-        stepId: step.id,
-        status: workingState.status
-      });
-    } catch (error) {
-      execution.status = "failed";
-      execution.completedAt = new Date;
-      execution.error = error instanceof Error ? error.message : String(error);
-      workingState.history.push(execution);
-      workingState.updatedAt = new Date;
-      if (step.retry) {
-        const retries = state.retryCounts?.[step.id] ?? 0;
-        if (retries < step.retry.maxAttempts) {
-          const backoff = step.retry.backoff ?? "exponential";
-          const baseDelay = step.retry.delayMs ?? 1000;
-          const delay = backoff === "exponential" ? baseDelay * Math.pow(2, retries) : baseDelay;
-          const cappedDelay = Math.min(delay, step.retry.maxDelayMs ?? Infinity);
-          workingState.retryCounts = {
-            ...state.retryCounts ?? {},
-            [step.id]: retries + 1
-          };
-          workingState.status = "running";
-          await this.config.stateStore.update(workflowId, () => workingState);
-          this.emit("workflow.step_retrying", {
-            workflowId,
-            workflowName: state.workflowName,
-            stepId: step.id,
-            attempt: retries + 1,
-            delay: cappedDelay,
-            error: execution.error
-          });
-          await new Promise((resolve) => setTimeout(resolve, cappedDelay));
-          return this.executeStep(workflowId, input);
-        }
-      }
-      workingState.status = "failed";
-      await this.config.stateStore.update(workflowId, () => workingState);
-      this.emit("workflow.step_failed", {
-        workflowId,
-        workflowName: state.workflowName,
-        stepId: step.id,
-        error: execution.error ?? "unknown"
-      });
-      if (spec.definition.compensation?.trigger === "on_failure") {
-        await this.rollback(workflowId);
-      }
-      throw error;
-    }
-  }
-  async rollback(workflowId) {
-    const state = await this.getStateOrThrow(workflowId);
-    const spec = this.getSpec(state.workflowName, state.workflowVersion);
-    if (!spec.definition.compensation) {
-      return;
-    }
-    this.emit("workflow.rollback_started", { workflowId });
-    const completedSteps = state.history.filter((h) => h.status === "completed").reverse();
-    for (const execution of completedSteps) {
-      const compStep = spec.definition.compensation.steps.find((s) => s.stepId === execution.stepId);
-      if (compStep) {
-        const input = {
-          stepId: execution.stepId,
-          originalInput: execution.input,
-          originalOutput: execution.output,
-          workflowData: state.data
-        };
-        try {
-          const step = getCurrentStep(spec, execution.stepId);
-          const resolvedAppConfig = this.config.appConfigProvider ? await this.config.appConfigProvider(state) : undefined;
-          const executorContext = {
-            workflow: state,
-            step,
-            resolvedAppConfig,
-            integrations: resolvedAppConfig?.integrations ?? [],
-            knowledge: resolvedAppConfig?.knowledge ?? [],
-            branding: resolvedAppConfig?.branding,
-            translation: resolvedAppConfig?.translation,
-            translationResolver: this.config.translationResolver,
-            secretProvider: this.config.secretProvider
-          };
-          await this.config.opExecutor(compStep.operation, input, executorContext);
-          this.emit("workflow.compensation_step_completed", {
-            workflowId,
-            stepId: execution.stepId,
-            compensationOp: compStep.operation.key
-          });
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          this.emit("workflow.compensation_step_failed", {
-            workflowId,
-            stepId: execution.stepId,
-            compensationOp: compStep.operation.key,
-            error: errorMessage
-          });
-        }
-      }
-    }
-    this.emit("workflow.rollback_completed", { workflowId });
-  }
-  async getState(workflowId) {
-    return this.getStateOrThrow(workflowId);
-  }
-  async cancel(workflowId) {
-    const state = await this.getStateOrThrow(workflowId);
-    if (state.status === "cancelled")
-      return;
-    const nextState = {
-      ...state,
-      status: "cancelled",
-      updatedAt: new Date
-    };
-    await this.config.stateStore.update(workflowId, () => nextState);
-    this.emit("workflow.cancelled", {
-      workflowId,
-      workflowName: state.workflowName
-    });
-  }
-  async performPreFlight(spec, resolvedConfig) {
-    if (!resolvedConfig) {
-      return { canStart: true, issues: [] };
-    }
-    const issues = [];
-    const integrationBySlot = new Map;
-    for (const integration of resolvedConfig.integrations) {
-      integrationBySlot.set(integration.slot.slotId, integration);
-    }
-    for (const step of spec.definition.steps) {
-      for (const slotId of step.requiredIntegrations ?? []) {
-        const integration = integrationBySlot.get(slotId);
-        if (!integration) {
-          issues.push({
-            stepId: step.id,
-            type: "integration",
-            identifier: slotId,
-            severity: "error",
-            reason: `Integration slot "${slotId}" is not bound in the resolved app config.`
-          });
-          continue;
-        }
-        const status = integration.connection.status;
-        if (status === "disconnected" || status === "error") {
-          issues.push({
-            stepId: step.id,
-            type: "integration",
-            identifier: slotId,
-            severity: "error",
-            reason: `Integration slot "${slotId}" is in status "${status}".`
-          });
-        } else if (status === "unknown") {
-          issues.push({
-            stepId: step.id,
-            type: "integration",
-            identifier: slotId,
-            severity: "warning",
-            reason: `Integration slot "${slotId}" reports unknown health status.`
-          });
-        }
-      }
-    }
-    const enabledCapabilities = new Set(resolvedConfig.capabilities.enabled.map(capabilityKey));
-    for (const step of spec.definition.steps) {
-      for (const required of step.requiredCapabilities ?? []) {
-        if (!enabledCapabilities.has(capabilityKey(required))) {
-          issues.push({
-            stepId: step.id,
-            type: "capability",
-            identifier: capabilityKey(required),
-            severity: "error",
-            reason: `Capability "${required.key}@${required.version}" is not enabled.`
-          });
-        }
-      }
-    }
-    const canStart = issues.every((issue) => issue.severity !== "error");
-    return { canStart, issues };
-  }
-  async evaluateGuard(step, state, input) {
-    if (!step.guard)
-      return true;
-    if (this.config.guardEvaluator)
-      return this.config.guardEvaluator(step.guard, {
-        workflow: state,
-        step,
-        input
-      });
-    if (step.guard.type === "expression") {
-      return evaluateExpression(step.guard.value, {
-        data: state.data,
-        input
-      });
-    }
-    return true;
-  }
-  async runStepAction(step, state, input) {
-    if (step.type === "automation") {
-      const op = step.action?.operation;
-      if (!op)
-        throw new Error(`Automation step "${step.id}" requires an operation.`);
-      const resolvedAppConfig = this.config.appConfigProvider ? await this.config.appConfigProvider(state) : undefined;
-      const executorContext = {
-        workflow: state,
-        step,
-        resolvedAppConfig,
-        integrations: resolvedAppConfig?.integrations ?? [],
-        knowledge: resolvedAppConfig?.knowledge ?? [],
-        branding: resolvedAppConfig?.branding,
-        translation: resolvedAppConfig?.translation,
-        translationResolver: this.config.translationResolver,
-        secretProvider: this.config.secretProvider
-      };
-      if (this.config.enforceCapabilities) {
-        await this.config.enforceCapabilities(op, executorContext);
-      }
-      return this.config.opExecutor(op, input, executorContext);
-    }
-    if (step.type === "human") {
-      return input;
-    }
-    return input;
-  }
-  pickNextStepId(spec, state, step, input, output) {
-    const transitions = spec.definition.transitions.filter((t) => t.from === step.id);
-    for (const transition of transitions) {
-      if (evaluateExpression(transition.condition, {
-        data: state.data,
-        input,
-        output
-      })) {
-        const target = spec.definition.steps.find((s) => s.id === transition.to);
-        if (!target)
-          throw new Error(`Transition ${transition.from} -> ${transition.to} points to missing step.`);
-        return target.id;
-      }
-    }
-    return null;
-  }
-  getSpec(name, version) {
-    const spec = this.config.registry.get(name, version);
-    if (!spec)
-      throw new Error(`Workflow spec not found for ${name}${version ? `.v${version}` : ""}`);
-    return spec;
-  }
-  async getStateOrThrow(workflowId) {
-    const state = await this.config.stateStore.get(workflowId);
-    if (!state)
-      throw new Error(`Workflow state not found for ${workflowId}`);
-    return state;
-  }
-  emit(event, payload) {
-    this.config.eventEmitter?.(event, payload);
-  }
-}
-function resolveEntryStepId(spec) {
-  const entry = spec.definition.entryStepId ?? spec.definition.steps[0]?.id ?? null;
-  if (!entry)
-    throw new Error(`Workflow ${spec.meta.key}.v${spec.meta.version} has no entry step.`);
-  return entry;
-}
-function getCurrentStep(spec, stepId) {
-  const step = spec.definition.steps.find((s) => s.id === stepId);
-  if (!step)
-    throw new Error(`Step "${stepId}" not found in workflow ${spec.meta.key}.v${spec.meta.version}.`);
-  return step;
-}
-function hasOutgoing(spec, stepId) {
-  return spec.definition.transitions.some((t) => t.from === stepId);
-}
-function isRecord(value) {
-  return value != null && typeof value === "object" && !Array.isArray(value);
-}
-function isTerminalStatus(status) {
-  return status === "completed" || status === "failed" || status === "cancelled";
-}
-
-class WorkflowPreFlightError extends Error {
-  issues;
-  constructor(issues) {
-    super(`Workflow pre-flight failed: ${issues.filter((issue) => issue.severity === "error").map((issue) => `${issue.type}:${issue.identifier}`).join(", ")}`);
-    this.issues = issues;
-    this.name = "WorkflowPreFlightError";
-  }
-}
-function capabilityKey(ref) {
-  return `${ref.key}@${ref.version}`;
-}
-
-// src/workflow/adapters/memory-store.ts
-function cloneState(state) {
-  return {
-    ...state,
-    data: deepCopy(state.data),
-    history: state.history.map((execution) => ({
-      ...execution,
-      input: deepCopy(execution.input),
-      output: deepCopy(execution.output),
-      startedAt: new Date(execution.startedAt),
-      completedAt: execution.completedAt ? new Date(execution.completedAt) : undefined
-    })),
-    createdAt: new Date(state.createdAt),
-    updatedAt: new Date(state.updatedAt)
-  };
-}
-
-class InMemoryStateStore {
-  items = new Map;
-  async create(state) {
-    if (this.items.has(state.workflowId))
-      throw new Error(`Workflow state already exists: ${state.workflowId}`);
-    this.items.set(state.workflowId, cloneState(state));
-  }
-  async get(workflowId) {
-    const state = this.items.get(workflowId);
-    return state ? cloneState(state) : undefined;
-  }
-  async update(workflowId, updater) {
-    const current = this.items.get(workflowId);
-    if (!current)
-      throw new Error(`Workflow state not found for ${workflowId}`);
-    const next = cloneState(updater(cloneState(current)));
-    this.items.set(workflowId, next);
-    return cloneState(next);
-  }
-  async list(filters) {
-    const all = [...this.items.values()];
-    const filtered = filters?.status ? all.filter((state) => state.status === filters.status) : all;
-    return filtered.map(cloneState);
-  }
-  clear() {
-    this.items.clear();
-  }
-}
-function deepCopy(value) {
-  if (value instanceof Date)
-    return new Date(value.getTime());
-  if (Array.isArray(value))
-    return value.map((item) => deepCopy(item));
-  if (value && typeof value === "object") {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = deepCopy(val);
-    }
-    return result;
-  }
-  return value;
-}
-
-// src/workflow/adapters/db-adapter.ts
-class PrismaStateStore {
-  prisma;
-  constructor(prisma) {
-    this.prisma = prisma;
-  }
-  async create(state) {
-    await this.prisma.workflowState.create({
-      data: {
-        id: state.workflowId,
-        name: state.workflowName,
-        version: state.workflowVersion,
-        status: state.status,
-        currentStep: state.currentStep,
-        data: state.data,
-        history: state.history,
-        retryCounts: state.retryCounts ?? {},
-        createdAt: state.createdAt,
-        updatedAt: state.updatedAt
-      }
-    });
-  }
-  async get(workflowId) {
-    const record = await this.prisma.workflowState.findUnique({
-      where: { id: workflowId }
-    });
-    if (!record)
-      return;
-    return {
-      workflowId: record.id,
-      workflowName: record.name,
-      workflowVersion: record.version,
-      currentStep: record.currentStep,
-      data: record.data,
-      history: record.history,
-      retryCounts: record.retryCounts,
-      status: record.status,
-      createdAt: record.createdAt,
-      updatedAt: record.updatedAt
-    };
-  }
-  async update(workflowId, updater) {
-    const current = await this.get(workflowId);
-    if (!current) {
-      throw new Error(`Workflow ${workflowId} not found`);
-    }
-    const next = updater(current);
-    const updated = await this.prisma.workflowState.update({
-      where: { id: workflowId },
-      data: {
-        status: next.status,
-        currentStep: next.currentStep,
-        data: next.data,
-        history: next.history,
-        retryCounts: next.retryCounts,
-        updatedAt: next.updatedAt
-      }
-    });
-    return {
-      workflowId: updated.id,
-      workflowName: updated.name,
-      workflowVersion: updated.version,
-      currentStep: updated.currentStep,
-      data: updated.data,
-      history: updated.history,
-      retryCounts: updated.retryCounts,
-      status: updated.status,
-      createdAt: updated.createdAt,
-      updatedAt: updated.updatedAt
-    };
-  }
-  async list(filters) {
-    const where = {};
-    if (filters?.status) {
-      where.status = filters.status;
-    }
-    const records = await this.prisma.workflowState.findMany({
-      where
-    });
-    return records.map((record) => ({
-      workflowId: record.id,
-      workflowName: record.name,
-      workflowVersion: record.version,
-      currentStep: record.currentStep,
-      data: record.data,
-      history: record.history,
-      retryCounts: record.retryCounts,
-      status: record.status,
-      createdAt: record.createdAt,
-      updatedAt: record.updatedAt
-    }));
-  }
-}
-
-// src/workflow/adapters/file-adapter.ts
-function createFileStateStore(_options) {
-  throw new Error("File-backed state store adapter not implemented. Provide a custom adapter that satisfies StateStore.");
-}
-// src/workflow/context.ts
-class WorkflowContextError extends Error {
-  errorType;
-  workflowId;
-  details;
-  constructor(type, workflowId, message, details) {
-    super(message);
-    this.name = "WorkflowContextError";
-    this.errorType = type;
-    this.workflowId = workflowId;
-    this.details = details;
-  }
-}
-
-class WorkflowContextImpl {
-  state;
-  spec;
-  constructor(state, spec) {
-    this.state = state;
-    this.spec = spec;
-  }
-  get workflowId() {
-    return this.state.workflowId;
-  }
-  get workflowKey() {
-    return this.state.workflowName;
-  }
-  get workflowVersion() {
-    return this.state.workflowVersion;
-  }
-  get currentStep() {
-    return this.state.currentStep;
-  }
-  get status() {
-    return this.state.status;
-  }
-  get data() {
-    return this.state.data;
-  }
-  get history() {
-    return this.state.history;
-  }
-  getState() {
-    return this.state;
-  }
-  getData(key) {
-    return this.state.data[key];
-  }
-  isTerminal() {
-    return this.state.status === "completed" || this.state.status === "failed" || this.state.status === "cancelled";
-  }
-  isRunning() {
-    return this.state.status === "running";
-  }
-  getCurrentStepDef() {
-    return this.spec.definition.steps.find((s) => s.id === this.state.currentStep);
-  }
-  getRetryCount(stepId) {
-    const id = stepId ?? this.state.currentStep;
-    return this.state.retryCounts?.[id] ?? 0;
-  }
-  canTransition(toStepId) {
-    const transitions = this.spec.definition.transitions.filter((t) => t.from === this.state.currentStep && t.to === toStepId);
-    return transitions.length > 0;
-  }
-  getAvailableTransitions() {
-    return this.spec.definition.transitions.filter((t) => t.from === this.state.currentStep).map((t) => ({
-      from: t.from,
-      to: t.to,
-      label: t.label,
-      condition: t.condition
-    }));
-  }
-  hasNextStep() {
-    return this.spec.definition.transitions.some((t) => t.from === this.state.currentStep);
-  }
-  getRemainingTime(slaKey) {
-    const sla = this.spec.definition.sla;
-    if (!sla)
-      return null;
-    const now = Date.now();
-    if (slaKey === "totalDuration") {
-      if (!sla.totalDurationMs)
-        return null;
-      const elapsed2 = now - this.state.createdAt.getTime();
-      return Math.max(0, sla.totalDurationMs - elapsed2);
-    }
-    const stepLimit = sla.stepDurationMs?.[slaKey];
-    if (!stepLimit)
-      return null;
-    const stepExecution = this.state.history.find((h) => h.stepId === slaKey && h.status === "running");
-    if (!stepExecution)
-      return stepLimit;
-    const elapsed = now - stepExecution.startedAt.getTime();
-    return Math.max(0, stepLimit - elapsed);
-  }
-  isSlaViolated(slaKey) {
-    const remaining = this.getRemainingTime(slaKey);
-    return remaining !== null && remaining <= 0;
-  }
-  getAllSlaStatuses() {
-    const sla = this.spec.definition.sla;
-    if (!sla)
-      return [];
-    const statuses = [];
-    const now = Date.now();
-    if (sla.totalDurationMs) {
-      const elapsed = now - this.state.createdAt.getTime();
-      const remaining = Math.max(0, sla.totalDurationMs - elapsed);
-      statuses.push({
-        key: "totalDuration",
-        type: "workflow",
-        limitMs: sla.totalDurationMs,
-        elapsedMs: elapsed,
-        remainingMs: remaining,
-        violated: remaining <= 0,
-        percentUsed: elapsed / sla.totalDurationMs * 100
-      });
-    }
-    if (sla.stepDurationMs) {
-      for (const [stepId, limitMs] of Object.entries(sla.stepDurationMs)) {
-        const stepExecution = this.state.history.find((h) => h.stepId === stepId && h.status === "running");
-        const elapsed = stepExecution ? now - stepExecution.startedAt.getTime() : 0;
-        const remaining = Math.max(0, limitMs - elapsed);
-        statuses.push({
-          key: stepId,
-          type: "step",
-          stepId,
-          limitMs,
-          elapsedMs: elapsed,
-          remainingMs: remaining,
-          violated: stepExecution !== undefined && remaining <= 0,
-          percentUsed: elapsed / limitMs * 100
-        });
-      }
-    }
-    return statuses;
-  }
-  hasCompensation() {
-    return this.spec.definition.compensation !== undefined;
-  }
-  getCompensableSteps() {
-    const compensation = this.spec.definition.compensation;
-    if (!compensation)
-      return [];
-    return compensation.steps.map((s) => s.stepId);
-  }
-  getEvents() {
-    const events = [];
-    for (const execution of this.state.history) {
-      events.push({
-        timestamp: execution.startedAt,
-        type: "step_started",
-        stepId: execution.stepId,
-        input: execution.input
-      });
-      if (execution.completedAt) {
-        if (execution.status === "completed") {
-          events.push({
-            timestamp: execution.completedAt,
-            type: "step_completed",
-            stepId: execution.stepId,
-            output: execution.output
-          });
-        } else if (execution.status === "failed") {
-          events.push({
-            timestamp: execution.completedAt,
-            type: "step_failed",
-            stepId: execution.stepId,
-            error: execution.error
-          });
-        }
-      }
-    }
-    events.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-    return events;
-  }
-}
-function createWorkflowContext(state, spec) {
-  return new WorkflowContextImpl(state, spec);
-}
-function calculateWorkflowProgress(ctx) {
-  const state = ctx.getState();
-  const completedSteps = new Set(state.history.filter((h) => h.status === "completed").map((h) => h.stepId));
-  const _totalSteps = completedSteps.size + (ctx.isTerminal() ? 0 : 1);
-  if (ctx.status === "completed")
-    return 100;
-  if (ctx.status === "failed" || ctx.status === "cancelled") {
-    return completedSteps.size > 0 ? Math.min(99, completedSteps.size * 20) : 0;
-  }
-  return Math.min(99, completedSteps.size * 20);
-}
-function getWorkflowDuration(ctx) {
-  const state = ctx.getState();
-  const endTime = ctx.isTerminal() ? state.updatedAt.getTime() : Date.now();
-  return endTime - state.createdAt.getTime();
-}
-function getAverageStepDuration(ctx) {
-  const completedSteps = ctx.history.filter((h) => h.status === "completed" && h.completedAt);
-  if (completedSteps.length === 0)
-    return 0;
-  const totalDuration = completedSteps.reduce((sum, step) => {
-    if (!step.completedAt)
-      return sum;
-    const duration = step.completedAt.getTime() - step.startedAt.getTime();
-    return sum + duration;
-  }, 0);
-  return totalDuration / completedSteps.length;
-}
-
-// src/workflow/sla-monitor.ts
-class SLAMonitor {
-  eventEmitter;
-  constructor(eventEmitter) {
-    this.eventEmitter = eventEmitter;
-  }
-  check(state, spec) {
-    const sla = spec.definition.sla;
-    if (!sla)
-      return;
-    const now = new Date().getTime();
-    if (sla.totalDurationMs) {
-      const duration = now - state.createdAt.getTime();
-      if (duration > sla.totalDurationMs) {
-        if (state.status === "running" || state.status === "paused") {
-          this.eventEmitter("workflow.sla_breach", {
-            workflowId: state.workflowId,
-            workflowName: state.workflowName,
-            type: "workflow_duration",
-            expectedMs: sla.totalDurationMs,
-            actualMs: duration,
-            breachedAt: new Date
-          });
-        }
-      }
-    }
-    if (sla.stepDurationMs) {
-      if (state.status === "running" && state.currentStep) {
-        const currentExecution = state.history.find((h) => h.stepId === state.currentStep && h.status === "running");
-        if (currentExecution) {
-          const stepLimit = sla.stepDurationMs[state.currentStep];
-          if (stepLimit) {
-            const stepDuration = now - currentExecution.startedAt.getTime();
-            if (stepDuration > stepLimit) {
-              this.eventEmitter("workflow.sla_breach", {
-                workflowId: state.workflowId,
-                workflowName: state.workflowName,
-                type: "step_duration",
-                stepId: state.currentStep,
-                expectedMs: stepLimit,
-                actualMs: stepDuration,
-                breachedAt: new Date
-              });
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-// src/workflow/index.ts
-var defineWorkflow = (spec2) => spec2;
-export {
-  validateWorkflowSpec,
-  validateWorkflowConsistency,
-  validateWorkflowComprehensive,
-  validateSlaConfig,
-  validateRetryConfig,
-  validateCompensation,
-  getWorkflowDuration,
-  getAverageStepDuration,
-  evaluateExpression,
-  defineWorkflow,
-  createWorkflowContext,
-  createFileStateStore,
-  calculateWorkflowProgress,
-  assertWorkflowSpecValid,
-  assertWorkflowConsistency,
-  WorkflowValidationError,
-  WorkflowRunner,
-  WorkflowRegistry,
-  WorkflowPreFlightError,
-  WorkflowContextError,
-  SLAMonitor,
-  PrismaStateStore,
-  InMemoryStateStore
-};