@contractspec/lib.contracts-spec 2.0.0

package/dist/workflow/index.js

@@ -0,0 +1,1546 @@
+// @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/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/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/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/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/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/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/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
+};