@contractspec/lib.contracts 1.44.0

package/dist/workflow/adapters/db-adapter.d.ts

@@ -0,0 +1,46 @@
+import { StateStore, WorkflowState, WorkflowStateFilters } from "../state.js";
+
+//#region src/workflow/adapters/db-adapter.d.ts
+interface WorkflowStateRecord {
+  id: string;
+  name: string;
+  version: string;
+  status: string;
+  currentStep: string;
+  data: unknown;
+  history: unknown[];
+  retryCounts: Record<string, number>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface PrismaClientLike {
+  workflowState: {
+    create: (args: {
+      data: Record<string, unknown>;
+    }) => Promise<WorkflowStateRecord>;
+    findUnique: (args: {
+      where: {
+        id: string;
+      };
+    }) => Promise<WorkflowStateRecord | null>;
+    update: (args: {
+      where: {
+        id: string;
+      };
+      data: Record<string, unknown>;
+    }) => Promise<WorkflowStateRecord>;
+    findMany: (args: {
+      where?: Record<string, unknown>;
+    }) => Promise<WorkflowStateRecord[]>;
+  };
+}
+declare class PrismaStateStore implements StateStore {
+  private readonly prisma;
+  constructor(prisma: PrismaClientLike);
+  create(state: WorkflowState): Promise<void>;
+  get(workflowId: string): Promise<WorkflowState | undefined>;
+  update(workflowId: string, updater: (current: WorkflowState) => WorkflowState): Promise<WorkflowState>;
+  list(filters?: WorkflowStateFilters): Promise<WorkflowState[]>;
+}
+//#endregion
+export { PrismaStateStore };

package/dist/workflow/adapters/db-adapter.js

@@ -0,0 +1,83 @@
+//#region src/workflow/adapters/db-adapter.ts
+var PrismaStateStore = class {
+	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 void 0;
+		return {
+			workflowId: record.id,
+			workflowName: record.name,
+			workflowVersion: parseInt(record.version, 10),
+			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: parseInt(updated.version, 10),
+			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;
+		return (await this.prisma.workflowState.findMany({ where })).map((record) => ({
+			workflowId: record.id,
+			workflowName: record.name,
+			workflowVersion: parseInt(record.version, 10),
+			currentStep: record.currentStep,
+			data: record.data,
+			history: record.history,
+			retryCounts: record.retryCounts,
+			status: record.status,
+			createdAt: record.createdAt,
+			updatedAt: record.updatedAt
+		}));
+	}
+};
+
+//#endregion
+export { PrismaStateStore };

package/dist/workflow/adapters/file-adapter.d.ts

@@ -0,0 +1,14 @@
+import { StateStore } from "../state.js";
+
+//#region src/workflow/adapters/file-adapter.d.ts
+interface FileStateStoreOptions {
+  /** Absolute or relative path to the persistence file. */
+  filePath: string;
+}
+/**
+ * Placeholder for a file-backed state store adapter.
+ * Implementations should manage locking/concurrency and JSON serialization.
+ */
+declare function createFileStateStore(_options: FileStateStoreOptions): StateStore;
+//#endregion
+export { FileStateStoreOptions, createFileStateStore };

package/dist/workflow/adapters/file-adapter.js

@@ -0,0 +1,11 @@
+//#region src/workflow/adapters/file-adapter.ts
+/**
+* Placeholder for a file-backed state store adapter.
+* Implementations should manage locking/concurrency and JSON serialization.
+*/
+function createFileStateStore(_options) {
+	throw new Error("File-backed state store adapter not implemented. Provide a custom adapter that satisfies StateStore.");
+}
+
+//#endregion
+export { createFileStateStore };

package/dist/workflow/adapters/index.d.ts

@@ -0,0 +1,4 @@
+import { InMemoryStateStore } from "./memory-store.js";
+import { PrismaStateStore } from "./db-adapter.js";
+import { FileStateStoreOptions, createFileStateStore } from "./file-adapter.js";
+export { FileStateStoreOptions, InMemoryStateStore, PrismaStateStore, createFileStateStore };

package/dist/workflow/adapters/index.js

@@ -0,0 +1,5 @@
+import { InMemoryStateStore } from "./memory-store.js";
+import { PrismaStateStore } from "./db-adapter.js";
+import { createFileStateStore } from "./file-adapter.js";
+
+export { InMemoryStateStore, PrismaStateStore, createFileStateStore };

package/dist/workflow/adapters/memory-store.d.ts

@@ -0,0 +1,18 @@
+import { StateStore, WorkflowState, WorkflowStateFilters } from "../state.js";
+
+//#region src/workflow/adapters/memory-store.d.ts
+
+/**
+ * Naive in-memory state store. Suitable for tests and single-node development
+ * environments. Swap with a database-backed adapter in production.
+ */
+declare class InMemoryStateStore implements StateStore {
+  private readonly items;
+  create(state: WorkflowState): Promise<void>;
+  get(workflowId: string): Promise<WorkflowState | undefined>;
+  update(workflowId: string, updater: (current: WorkflowState) => WorkflowState): Promise<WorkflowState>;
+  list(filters?: WorkflowStateFilters): Promise<WorkflowState[]>;
+  clear(): void;
+}
+//#endregion
+export { InMemoryStateStore };

package/dist/workflow/adapters/memory-store.js

@@ -0,0 +1,58 @@
+//#region 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) : void 0
+		})),
+		createdAt: new Date(state.createdAt),
+		updatedAt: new Date(state.updatedAt)
+	};
+}
+/**
+* Naive in-memory state store. Suitable for tests and single-node development
+* environments. Swap with a database-backed adapter in production.
+*/
+var InMemoryStateStore = class {
+	items = /* @__PURE__ */ 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) : void 0;
+	}
+	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()];
+		return (filters?.status ? all.filter((state) => state.status === filters.status) : all).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;
+}
+
+//#endregion
+export { InMemoryStateStore };

package/dist/workflow/expression.d.ts

@@ -0,0 +1,9 @@
+//#region src/workflow/expression.d.ts
+interface ExpressionContext {
+  data: Record<string, unknown>;
+  input?: unknown;
+  output?: unknown;
+}
+declare function evaluateExpression(expression: string | undefined, ctx: ExpressionContext): boolean;
+//#endregion
+export { ExpressionContext, evaluateExpression };

package/dist/workflow/expression.js

@@ -0,0 +1,99 @@
+//#region 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;
+		return compare(resolveRoot(root, ctx, path), parseLiteral(rawRight), 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 void 0;
+	return trimmed;
+}
+function resolveRoot(root, ctx, path) {
+	return resolvePath(root === "data" ? ctx.data : root === "input" ? ctx.input : ctx.output, path);
+}
+function resolvePath(source, path) {
+	if (source == null) return void 0;
+	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 void 0;
+		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;
+}
+
+//#endregion
+export { evaluateExpression };

package/dist/workflow/index.d.ts

@@ -0,0 +1,10 @@
+import { CompensationStep, CompensationStrategy, FormRef, GuardCondition, GuardConditionKind, RetryPolicy, SLA, Step, StepAction, StepType, Transition, WorkflowDefinition, WorkflowMeta, WorkflowRegistry, WorkflowSpec, WorkflowStatus } from "./spec.js";
+import { ValidateWorkflowSpecOptions, WorkflowValidationError, WorkflowValidationIssue, WorkflowValidationLevel, assertWorkflowSpecValid, validateWorkflowSpec } from "./validation.js";
+import { StateStore, StepExecution, WorkflowState, WorkflowStateFilters } from "./state.js";
+import { GuardContext, GuardEvaluator, OperationExecutor, OperationExecutorContext, WorkflowPreFlightError, WorkflowPreFlightIssue, WorkflowPreFlightIssueSeverity, WorkflowPreFlightIssueType, WorkflowPreFlightResult, WorkflowRunner, WorkflowRunnerConfig } from "./runner.js";
+import { ExpressionContext, evaluateExpression } from "./expression.js";
+import { InMemoryStateStore } from "./adapters/memory-store.js";
+import { PrismaStateStore } from "./adapters/db-adapter.js";
+import { FileStateStoreOptions, createFileStateStore } from "./adapters/file-adapter.js";
+import "./adapters/index.js";
+export { CompensationStep, CompensationStrategy, ExpressionContext, FileStateStoreOptions, FormRef, GuardCondition, GuardConditionKind, GuardContext, GuardEvaluator, InMemoryStateStore, OperationExecutor, OperationExecutorContext, PrismaStateStore, RetryPolicy, SLA, StateStore, Step, StepAction, StepExecution, StepType, Transition, ValidateWorkflowSpecOptions, WorkflowDefinition, WorkflowMeta, WorkflowPreFlightError, WorkflowPreFlightIssue, WorkflowPreFlightIssueSeverity, WorkflowPreFlightIssueType, WorkflowPreFlightResult, WorkflowRegistry, WorkflowRunner, WorkflowRunnerConfig, WorkflowSpec, WorkflowState, WorkflowStateFilters, WorkflowStatus, WorkflowValidationError, WorkflowValidationIssue, WorkflowValidationLevel, assertWorkflowSpecValid, createFileStateStore, evaluateExpression, validateWorkflowSpec };

package/dist/workflow/index.js

@@ -0,0 +1,9 @@
+import { WorkflowRegistry } from "./spec.js";
+import { WorkflowValidationError, assertWorkflowSpecValid, validateWorkflowSpec } from "./validation.js";
+import { evaluateExpression } from "./expression.js";
+import { WorkflowPreFlightError, WorkflowRunner } from "./runner.js";
+import { InMemoryStateStore } from "./adapters/memory-store.js";
+import { PrismaStateStore } from "./adapters/db-adapter.js";
+import { createFileStateStore } from "./adapters/file-adapter.js";
+
+export { InMemoryStateStore, PrismaStateStore, WorkflowPreFlightError, WorkflowRegistry, WorkflowRunner, WorkflowValidationError, assertWorkflowSpecValid, createFileStateStore, evaluateExpression, validateWorkflowSpec };

package/dist/workflow/overview.docblock.d.ts

@@ -0,0 +1,6 @@
+import { DocBlock } from "@contractspec/lib.contracts/docs";
+
+//#region src/workflow/overview.docblock.d.ts
+declare const tech_workflows_overview_DocBlocks: DocBlock[];
+//#endregion
+export { tech_workflows_overview_DocBlocks };

package/dist/workflow/overview.docblock.js

@@ -0,0 +1,21 @@
+import { registerDocBlocks } from "../docs/registry.js";
+
+//#region src/workflow/overview.docblock.ts
+const tech_workflows_overview_DocBlocks = [{
+	id: "docs.tech.workflows.overview",
+	title: "WorkflowSpec Overview",
+	summary: "WorkflowSpec provides a declarative, versioned format for long-running flows that mix automation and human review. Specs stay inside `@contractspec/lib.contracts` (`src/workflow/spec.ts`) so the same definition powers runtime execution, documentation, and future generation.",
+	kind: "reference",
+	visibility: "public",
+	route: "/docs/tech/workflows/overview",
+	tags: [
+		"tech",
+		"workflows",
+		"overview"
+	],
+	body: "# WorkflowSpec Overview\n\n## Purpose\n\nWorkflowSpec provides a declarative, versioned format for long-running flows that mix automation and human review. Specs stay inside `@contractspec/lib.contracts` (`src/workflow/spec.ts`) so the same definition powers runtime execution, documentation, and future generation.\n\n## Core Types\n\n- `WorkflowMeta`: ownership metadata (`title`, `domain`, `owners`, `tags`, `stability`) plus `name` and `version`.\n- `WorkflowDefinition`:\n  - `entryStepId?`: optional explicit entry point (defaults to first step).\n  - `steps[]`: ordered list of `Step` descriptors.\n  - `transitions[]`: directed edges between steps with optional expressions.\n  - `sla?`: aggregated timing hints for the overall flow or per-step budgets.\n  - `compensation?`: fallback operations executed when a workflow is rolled back or fails.\n- `Step`:\n  - `type`: `human`, `automation`, or `decision`.\n  - `action`: references either a `ContractSpec` (`operation`) or `FormSpec` (`form`).\n  - Optional `guard`, `timeoutMs`, and retry policy (`maxAttempts`, `backoff`, `delayMs`, `maxDelayMs?`).\n  - `requiredIntegrations?`: integration slot ids that must be bound before the step may execute.\n  - `requiredCapabilities?`: `CapabilityRef[]` that must be enabled in the resolved app config.\n- `Transition`: `from` → `to` with optional `condition` string (simple data expressions).\n\n## Registry & Validation\n\n- `WorkflowRegistry` (`src/workflow/spec.ts`) stores specs by key `<name>.v<version>` and exposes `register`, `list`, and `get`.\n- `validateWorkflowSpec()` (`src/workflow/validation.ts`) checks:\n  - Duplicate step IDs.\n  - Unknown `from`/`to` transitions.\n  - Empty guards/conditions.\n  - Reachability from the entry step.\n  - Cycles in the graph.\n  - Operation/Form references against provided registries.\n- `assertWorkflowSpecValid()` wraps validation and throws `WorkflowValidationError` when errors remain.\n\n## Runtime\n\n- `WorkflowRunner` (`src/workflow/runner.ts`) executes workflows and coordinates steps.\n  - `start(name, version?, initialData?)` returns a `workflowId`.\n  - `executeStep(workflowId, input?)` runs the current step (automation or human).\n  - `getState(workflowId)` retrieves the latest state snapshot.\n  - `cancel(workflowId)` marks the workflow as cancelled.\n  - `preFlightCheck(name, version?, resolvedConfig?)` evaluates integration/capability requirements before the workflow starts.\n  - Throws `WorkflowPreFlightError` if required integration slots are unbound or required capabilities are disabled.\n- `StateStore` (`src/workflow/state.ts`) abstracts persistence. V1 ships with:\n  - `InMemoryStateStore` (`src/workflow/adapters/memory-store.ts`) for tests/dev.\n  - Placeholder factories for file/database adapters (`adapters/file-adapter.ts`, `adapters/db-adapter.ts`).\n- Guard evaluation: expression guards run through `evaluateExpression()` (`src/workflow/expression.ts`); custom policy guards can be provided via `guardEvaluator`.\n- Events: the runner emits `workflow.started`, `workflow.step_completed`, `workflow.step_failed`, and `workflow.cancelled` through the optional `eventEmitter`.\n- React bindings (`@contractspec/lib.presentation-runtime-react`):\n  - `useWorkflow` hook (polls state, exposes `executeStep`, `cancel`, `refresh`).\n  - `WorkflowStepper` progress indicator using design-system Stepper.\n  - `WorkflowStepRenderer` helper to render human/automation/decision steps with sensible fallbacks.\n\n## Authoring Checklist\n\n1. Reuse existing operations/forms; create new specs when missing.\n2. Prefer explicit `entryStepId` for clarity (especially with decision branches).\n3. Give automation steps an `operation` and human steps a `form` (warnings surface otherwise).\n4. Use short, meaningful step IDs (`submit`, `review`, `finalize`) to simplify analytics.\n5. Keep guard expressions deterministic; complex policy logic should move to PolicySpec (Phase 2).\n\n## Testing\n\n- Add unit tests for new workflows via `assertWorkflowSpecValid`.\n- Use the new Vitest suites (`validation.test.ts`, `expression.test.ts`, `runner.test.ts`) as examples.\n- CLI support will arrive in Phase 1 PR 3 (`contractspec create --type workflow`).\n\n## Tooling\n\n- `contractspec create --type workflow` scaffolds a WorkflowSpec with interactive prompts.\n- `contractspec build <spec.workflow.ts>` generates a runner scaffold (`.runner.ts`) wired to `WorkflowRunner` and the in-memory store.\n- `contractspec validate` understands `.workflow.ts` files and checks core structure (meta, steps, transitions).\n\n## Next Steps (Non-MVP)\n\n- Persistence adapters (database/file) for workflow state (Phase 2).\n- React bindings (`useWorkflow`, `WorkflowStepper`) and presentation-runtime integration (PR 3).\n- Policy engine integration (`guard.type === 'policy'` validated against PolicySpec).\n- Telemetry hooks for step execution metrics.\n\n"
+}];
+registerDocBlocks(tech_workflows_overview_DocBlocks);
+
+//#endregion
+export { tech_workflows_overview_DocBlocks };

package/dist/workflow/runner.d.ts

@@ -0,0 +1,75 @@
+import { GuardCondition, Step, WorkflowRegistry } from "./spec.js";
+import { ResolvedBranding } from "../app-config/branding.js";
+import { ResolvedAppConfig, ResolvedIntegration, ResolvedKnowledge, ResolvedTranslation } from "../app-config/runtime.js";
+import { SecretProvider } from "../integrations/secrets/provider.js";
+import { TranslationResolver } from "../types.js";
+import { OpRef } from "../features/types.js";
+import "../features/index.js";
+import { StateStore, WorkflowState } from "./state.js";
+
+//#region src/workflow/runner.d.ts
+interface OperationExecutorContext {
+  workflow: WorkflowState;
+  step: Step;
+  resolvedAppConfig?: ResolvedAppConfig;
+  integrations?: ResolvedIntegration[];
+  knowledge?: ResolvedKnowledge[];
+  branding?: ResolvedBranding;
+  translation?: ResolvedTranslation;
+  translationResolver?: TranslationResolver;
+  secretProvider?: SecretProvider;
+}
+type OperationExecutor = (op: OpRef, input: unknown, context: OperationExecutorContext) => Promise<unknown>;
+type WorkflowPreFlightIssueType = 'integration' | 'capability';
+type WorkflowPreFlightIssueSeverity = 'error' | 'warning';
+interface WorkflowPreFlightIssue {
+  stepId: string;
+  type: WorkflowPreFlightIssueType;
+  identifier: string;
+  severity: WorkflowPreFlightIssueSeverity;
+  reason: string;
+}
+interface WorkflowPreFlightResult {
+  canStart: boolean;
+  issues: WorkflowPreFlightIssue[];
+}
+interface GuardContext {
+  workflow: WorkflowState;
+  step: Step;
+  input?: unknown;
+}
+type GuardEvaluator = (guard: GuardCondition, context: GuardContext) => Promise<boolean> | boolean;
+interface WorkflowRunnerConfig {
+  registry: WorkflowRegistry;
+  stateStore: StateStore;
+  opExecutor: OperationExecutor;
+  guardEvaluator?: GuardEvaluator;
+  eventEmitter?: (event: string, payload: Record<string, unknown>) => void;
+  appConfigProvider?: (state: WorkflowState) => ResolvedAppConfig | undefined | Promise<ResolvedAppConfig | undefined>;
+  enforceCapabilities?: (operation: OpRef, context: OperationExecutorContext) => void | Promise<void>;
+  secretProvider?: SecretProvider;
+  translationResolver?: TranslationResolver;
+}
+declare class WorkflowRunner {
+  private readonly config;
+  constructor(config: WorkflowRunnerConfig);
+  preFlightCheck(workflowName: string, version?: number, resolvedConfig?: ResolvedAppConfig): Promise<WorkflowPreFlightResult>;
+  start(workflowName: string, version?: number, initialData?: Record<string, unknown>): Promise<string>;
+  executeStep(workflowId: string, input?: unknown): Promise<void>;
+  rollback(workflowId: string): Promise<void>;
+  getState(workflowId: string): Promise<WorkflowState>;
+  cancel(workflowId: string): Promise<void>;
+  private performPreFlight;
+  private evaluateGuard;
+  private runStepAction;
+  private pickNextStepId;
+  private getSpec;
+  private getStateOrThrow;
+  private emit;
+}
+declare class WorkflowPreFlightError extends Error {
+  readonly issues: WorkflowPreFlightIssue[];
+  constructor(issues: WorkflowPreFlightIssue[]);
+}
+//#endregion
+export { GuardContext, GuardEvaluator, OperationExecutor, OperationExecutorContext, WorkflowPreFlightError, WorkflowPreFlightIssue, WorkflowPreFlightIssueSeverity, WorkflowPreFlightIssueType, WorkflowPreFlightResult, WorkflowRunner, WorkflowRunnerConfig };