@contractspec/lib.contracts 0.0.0-canary-20260119225944 → 0.0.0-canary-20260202053150

package/dist/workflow/context.d.ts

@@ -0,0 +1,191 @@
+import { Step, WorkflowSpec } from "./spec.js";
+import { StepExecution, WorkflowState } from "./state.js";
+
+//#region src/workflow/context.d.ts
+
+/**
+ * Error thrown when a workflow operation fails.
+ */
+declare class WorkflowContextError extends Error {
+  readonly errorType: WorkflowContextErrorType;
+  readonly workflowId: string;
+  readonly details?: Record<string, unknown>;
+  constructor(type: WorkflowContextErrorType, workflowId: string, message: string, details?: Record<string, unknown>);
+}
+type WorkflowContextErrorType = 'invalid_transition' | 'workflow_completed' | 'workflow_failed' | 'step_not_found' | 'guard_rejected' | 'sla_violated';
+interface WorkflowTransitionResult {
+  success: boolean;
+  previousStep: string;
+  currentStep: string;
+  status: WorkflowState['status'];
+  error?: string;
+}
+interface AvailableTransition {
+  from: string;
+  to: string;
+  label?: string;
+  condition?: string;
+}
+interface SlaStatus {
+  key: string;
+  type: 'workflow' | 'step';
+  stepId?: string;
+  limitMs: number;
+  elapsedMs: number;
+  remainingMs: number;
+  violated: boolean;
+  percentUsed: number;
+}
+interface WorkflowEvent {
+  timestamp: Date;
+  type: 'step_started' | 'step_completed' | 'step_failed' | 'step_retried' | 'transition';
+  stepId?: string;
+  fromStep?: string;
+  toStep?: string;
+  input?: unknown;
+  output?: unknown;
+  error?: string;
+}
+/**
+ * Runtime context for interacting with a workflow instance.
+ *
+ * Provides a simplified interface over WorkflowRunner for common
+ * workflow operations like state access, transitions, and SLA tracking.
+ */
+interface WorkflowContext<TData = Record<string, unknown>> {
+  /** Unique workflow instance identifier. */
+  readonly workflowId: string;
+  /** Workflow spec key. */
+  readonly workflowKey: string;
+  /** Workflow spec version. */
+  readonly workflowVersion: string;
+  /** Current step identifier. */
+  readonly currentStep: string;
+  /** Current workflow status. */
+  readonly status: WorkflowState['status'];
+  /** Workflow data/state. */
+  readonly data: TData;
+  /** Execution history. */
+  readonly history: readonly StepExecution[];
+  /**
+   * Get the current workflow state.
+   * @returns Full workflow state object
+   */
+  getState(): WorkflowState;
+  /**
+   * Get a value from workflow data.
+   * @param key - Data key to retrieve
+   * @returns Value or undefined
+   */
+  getData<T = unknown>(key: string): T | undefined;
+  /**
+   * Check if workflow is in a terminal state.
+   * @returns True if completed, failed, or cancelled
+   */
+  isTerminal(): boolean;
+  /**
+   * Check if workflow is running.
+   * @returns True if status is 'running'
+   */
+  isRunning(): boolean;
+  /**
+   * Get the current step definition.
+   * @returns Step definition or undefined
+   */
+  getCurrentStepDef(): Step | undefined;
+  /**
+   * Get the retry count for a step.
+   * @param stepId - Step to check (defaults to current step)
+   * @returns Number of retry attempts
+   */
+  getRetryCount(stepId?: string): number;
+  /**
+   * Check if a transition to a target step is valid.
+   * @param toStepId - Target step identifier
+   * @returns True if transition is valid from current step
+   */
+  canTransition(toStepId: string): boolean;
+  /**
+   * Get all available transitions from current step.
+   * @returns Array of available transitions
+   */
+  getAvailableTransitions(): AvailableTransition[];
+  /**
+   * Check if the current step has any outgoing transitions.
+   * @returns True if there are outgoing transitions
+   */
+  hasNextStep(): boolean;
+  /**
+   * Get remaining time for an SLA constraint.
+   * @param slaKey - 'totalDuration' or step ID
+   * @returns Remaining milliseconds, or null if no SLA configured
+   */
+  getRemainingTime(slaKey: string): number | null;
+  /**
+   * Check if an SLA constraint has been violated.
+   * @param slaKey - 'totalDuration' or step ID
+   * @returns True if SLA has been violated
+   */
+  isSlaViolated(slaKey: string): boolean;
+  /**
+   * Get status of all SLA constraints.
+   * @returns Array of SLA statuses
+   */
+  getAllSlaStatuses(): SlaStatus[];
+  /**
+   * Check if compensation/rollback is available.
+   * @returns True if workflow has compensation strategy
+   */
+  hasCompensation(): boolean;
+  /**
+   * Get steps that have compensation handlers.
+   * @returns Array of step IDs with compensation
+   */
+  getCompensableSteps(): string[];
+  /**
+   * Convert execution history to workflow events.
+   * @returns Array of workflow events
+   */
+  getEvents(): WorkflowEvent[];
+}
+/**
+ * Creates a workflow context from state and spec.
+ *
+ * @param state - Current workflow state
+ * @param spec - Workflow specification
+ * @returns WorkflowContext for interacting with the workflow
+ *
+ * @example
+ * ```typescript
+ * const state = await runner.getState(workflowId);
+ * const spec = registry.get(state.workflowName, state.workflowVersion);
+ * const ctx = createWorkflowContext(state, spec);
+ *
+ * console.log('Current step:', ctx.currentStep);
+ * console.log('Available transitions:', ctx.getAvailableTransitions());
+ * ```
+ */
+declare function createWorkflowContext<TData = Record<string, unknown>>(state: WorkflowState, spec: WorkflowSpec): WorkflowContext<TData>;
+/**
+ * Calculate workflow progress as a percentage.
+ *
+ * @param ctx - Workflow context
+ * @returns Progress percentage (0-100)
+ */
+declare function calculateWorkflowProgress(ctx: WorkflowContext): number;
+/**
+ * Get the duration of a workflow in milliseconds.
+ *
+ * @param ctx - Workflow context
+ * @returns Duration in milliseconds
+ */
+declare function getWorkflowDuration(ctx: WorkflowContext): number;
+/**
+ * Get the average step duration in milliseconds.
+ *
+ * @param ctx - Workflow context
+ * @returns Average duration or 0 if no completed steps
+ */
+declare function getAverageStepDuration(ctx: WorkflowContext): number;
+//#endregion
+export { AvailableTransition, SlaStatus, WorkflowContext, WorkflowContextError, WorkflowContextErrorType, WorkflowEvent, WorkflowTransitionResult, calculateWorkflowProgress, createWorkflowContext, getAverageStepDuration, getWorkflowDuration };

package/dist/workflow/context.js

@@ -0,0 +1,227 @@
+//#region src/workflow/context.ts
+/**
+* Error thrown when a workflow operation fails.
+*/
+var WorkflowContextError = class extends Error {
+	errorType;
+	workflowId;
+	details;
+	constructor(type, workflowId, message, details) {
+		super(message);
+		this.name = "WorkflowContextError";
+		this.errorType = type;
+		this.workflowId = workflowId;
+		this.details = details;
+	}
+};
+var WorkflowContextImpl = class {
+	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) {
+		return this.spec.definition.transitions.filter((t) => t.from === this.state.currentStep && t.to === toStepId).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 elapsed$1 = now - this.state.createdAt.getTime();
+			return Math.max(0, sla.totalDurationMs - elapsed$1);
+		}
+		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 !== void 0 && remaining <= 0,
+				percentUsed: elapsed / limitMs * 100
+			});
+		}
+		return statuses;
+	}
+	hasCompensation() {
+		return this.spec.definition.compensation !== void 0;
+	}
+	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;
+	}
+};
+/**
+* Creates a workflow context from state and spec.
+*
+* @param state - Current workflow state
+* @param spec - Workflow specification
+* @returns WorkflowContext for interacting with the workflow
+*
+* @example
+* ```typescript
+* const state = await runner.getState(workflowId);
+* const spec = registry.get(state.workflowName, state.workflowVersion);
+* const ctx = createWorkflowContext(state, spec);
+*
+* console.log('Current step:', ctx.currentStep);
+* console.log('Available transitions:', ctx.getAvailableTransitions());
+* ```
+*/
+function createWorkflowContext(state, spec) {
+	return new WorkflowContextImpl(state, spec);
+}
+/**
+* Calculate workflow progress as a percentage.
+*
+* @param ctx - Workflow context
+* @returns Progress percentage (0-100)
+*/
+function calculateWorkflowProgress(ctx) {
+	const state = ctx.getState();
+	const completedSteps = new Set(state.history.filter((h) => h.status === "completed").map((h) => h.stepId));
+	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);
+}
+/**
+* Get the duration of a workflow in milliseconds.
+*
+* @param ctx - Workflow context
+* @returns Duration in milliseconds
+*/
+function getWorkflowDuration(ctx) {
+	const state = ctx.getState();
+	return (ctx.isTerminal() ? state.updatedAt.getTime() : Date.now()) - state.createdAt.getTime();
+}
+/**
+* Get the average step duration in milliseconds.
+*
+* @param ctx - Workflow context
+* @returns Average duration or 0 if no completed steps
+*/
+function getAverageStepDuration(ctx) {
+	const completedSteps = ctx.history.filter((h) => h.status === "completed" && h.completedAt);
+	if (completedSteps.length === 0) return 0;
+	return completedSteps.reduce((sum, step) => {
+		if (!step.completedAt) return sum;
+		return sum + (step.completedAt.getTime() - step.startedAt.getTime());
+	}, 0) / completedSteps.length;
+}
+
+//#endregion
+export { WorkflowContextError, calculateWorkflowProgress, createWorkflowContext, getAverageStepDuration, getWorkflowDuration };

package/dist/workflow/index.d.ts

@@ -1,5 +1,6 @@
-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 { FormRef } from "../features/types.js";
+import { CompensationStep, CompensationStrategy, GuardCondition, GuardConditionKind, RetryPolicy, SLA, Step, StepAction, StepType, Transition, WorkflowDefinition, WorkflowMeta, WorkflowRegistry, WorkflowSpec, WorkflowStatus } from "./spec.js";
+import { ValidateWorkflowSpecOptions, WorkflowConsistencyDeps, WorkflowValidationError, WorkflowValidationIssue, WorkflowValidationLevel, WorkflowValidationResult, assertWorkflowConsistency, assertWorkflowSpecValid, validateCompensation, validateRetryConfig, validateSlaConfig, validateWorkflowComprehensive, validateWorkflowConsistency, 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";
@@ -7,6 +8,8 @@ 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";
+import { AvailableTransition, SlaStatus, WorkflowContext, WorkflowContextError, WorkflowContextErrorType, WorkflowEvent, WorkflowTransitionResult, calculateWorkflowProgress, createWorkflowContext, getAverageStepDuration, getWorkflowDuration } from "./context.js";
+import { SLABreachEvent, SLAMonitor } from "./sla-monitor.js";
 
 //#region src/workflow/index.d.ts
 /**
@@ -14,4 +17,4 @@ import "./adapters/index.js";
  */
 declare const defineWorkflow: (spec: WorkflowSpec) => WorkflowSpec;
 //#endregion
-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, defineWorkflow, evaluateExpression, validateWorkflowSpec };
+export { AvailableTransition, CompensationStep, CompensationStrategy, ExpressionContext, FileStateStoreOptions, FormRef, GuardCondition, GuardConditionKind, GuardContext, GuardEvaluator, InMemoryStateStore, OperationExecutor, OperationExecutorContext, PrismaStateStore, RetryPolicy, SLA, SLABreachEvent, SLAMonitor, SlaStatus, StateStore, Step, StepAction, StepExecution, StepType, Transition, ValidateWorkflowSpecOptions, WorkflowConsistencyDeps, WorkflowContext, WorkflowContextError, WorkflowContextErrorType, WorkflowDefinition, WorkflowEvent, WorkflowMeta, WorkflowPreFlightError, WorkflowPreFlightIssue, WorkflowPreFlightIssueSeverity, WorkflowPreFlightIssueType, WorkflowPreFlightResult, WorkflowRegistry, WorkflowRunner, WorkflowRunnerConfig, WorkflowSpec, WorkflowState, WorkflowStateFilters, WorkflowStatus, WorkflowTransitionResult, WorkflowValidationError, WorkflowValidationIssue, WorkflowValidationLevel, WorkflowValidationResult, assertWorkflowConsistency, assertWorkflowSpecValid, calculateWorkflowProgress, createFileStateStore, createWorkflowContext, defineWorkflow, evaluateExpression, getAverageStepDuration, getWorkflowDuration, validateCompensation, validateRetryConfig, validateSlaConfig, validateWorkflowComprehensive, validateWorkflowConsistency, validateWorkflowSpec };

package/dist/workflow/index.js

@@ -1,10 +1,12 @@
 import { WorkflowRegistry } from "./spec.js";
-import { WorkflowValidationError, assertWorkflowSpecValid, validateWorkflowSpec } from "./validation.js";
+import { WorkflowValidationError, assertWorkflowConsistency, assertWorkflowSpecValid, validateCompensation, validateRetryConfig, validateSlaConfig, validateWorkflowComprehensive, validateWorkflowConsistency, 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";
+import { WorkflowContextError, calculateWorkflowProgress, createWorkflowContext, getAverageStepDuration, getWorkflowDuration } from "./context.js";
+import { SLAMonitor } from "./sla-monitor.js";
 
 //#region src/workflow/index.ts
 /**
@@ -13,4 +15,4 @@ import { createFileStateStore } from "./adapters/file-adapter.js";
 const defineWorkflow = (spec) => spec;
 
 //#endregion
-export { InMemoryStateStore, PrismaStateStore, WorkflowPreFlightError, WorkflowRegistry, WorkflowRunner, WorkflowValidationError, assertWorkflowSpecValid, createFileStateStore, defineWorkflow, evaluateExpression, validateWorkflowSpec };
+export { InMemoryStateStore, PrismaStateStore, SLAMonitor, WorkflowContextError, WorkflowPreFlightError, WorkflowRegistry, WorkflowRunner, WorkflowValidationError, assertWorkflowConsistency, assertWorkflowSpecValid, calculateWorkflowProgress, createFileStateStore, createWorkflowContext, defineWorkflow, evaluateExpression, getAverageStepDuration, getWorkflowDuration, validateCompensation, validateRetryConfig, validateSlaConfig, validateWorkflowComprehensive, validateWorkflowConsistency, validateWorkflowSpec };

package/dist/workflow/spec.d.ts

@@ -1,19 +1,12 @@
-import { OwnerShipMeta } from "../ownership.js";
 import { CapabilityRef } from "../capabilities/capabilities.js";
+import { SpecContractRegistry } from "../registry.js";
 import "../capabilities/index.js";
 import { ExperimentRef } from "../experiments/spec.js";
-import { OpRef } from "../features/types.js";
+import { FormRef, OpRef } from "../features/types.js";
 import "../features/index.js";
-import { SpecContractRegistry } from "../registry.js";
+import { OwnerShipMeta } from "../ownership.js";
 
 //#region src/workflow/spec.d.ts
-/**
- * Reference to a form spec declared in {@link FormRegistry}.
- */
-interface FormRef {
-  key: string;
-  version: string;
-}
 type StepType = 'human' | 'automation' | 'decision';
 type WorkflowStatus = 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
 type GuardConditionKind = 'policy' | 'expression';
@@ -90,4 +83,4 @@ declare class WorkflowRegistry extends SpecContractRegistry<'workflow', Workflow
   constructor(items?: WorkflowSpec[]);
 }
 //#endregion
-export { CompensationStep, CompensationStrategy, FormRef, GuardCondition, GuardConditionKind, RetryPolicy, SLA, Step, StepAction, StepType, Transition, WorkflowDefinition, WorkflowMeta, WorkflowRegistry, WorkflowSpec, WorkflowStatus };
+export { CompensationStep, CompensationStrategy, type FormRef, GuardCondition, GuardConditionKind, RetryPolicy, SLA, Step, StepAction, StepType, Transition, WorkflowDefinition, WorkflowMeta, WorkflowRegistry, WorkflowSpec, WorkflowStatus };

package/dist/workflow/validation.d.ts

@@ -1,7 +1,9 @@
+import { CapabilityRegistry } from "../capabilities/capabilities.js";
+import { WorkflowRegistry, WorkflowSpec } from "./spec.js";
 import { OperationSpecRegistry } from "../operations/registry.js";
-import { WorkflowSpec } from "./spec.js";
 import { FormRegistry } from "../forms/forms.js";
 import "../forms/index.js";
+import { EventRegistry } from "../events.js";
 
 //#region src/workflow/validation.d.ts
 type WorkflowValidationLevel = 'error' | 'warning';
@@ -25,5 +27,65 @@ declare class WorkflowValidationError extends Error {
  */
 declare function validateWorkflowSpec(spec: WorkflowSpec, options?: ValidateWorkflowSpecOptions): WorkflowValidationIssue[];
 declare function assertWorkflowSpecValid(spec: WorkflowSpec, options?: ValidateWorkflowSpecOptions): void;
+interface WorkflowConsistencyDeps {
+  workflows: WorkflowRegistry;
+  operations?: OperationSpecRegistry;
+  forms?: FormRegistry;
+  events?: EventRegistry;
+  capabilities?: CapabilityRegistry;
+}
+interface WorkflowValidationResult {
+  valid: boolean;
+  issues: WorkflowValidationIssue[];
+}
+/**
+ * Validate workflow consistency across registries.
+ *
+ * Checks that:
+ * - All workflow specs are internally valid
+ * - Operations referenced by steps exist
+ * - Forms referenced by steps exist
+ * - Capabilities required by steps exist
+ *
+ * @param deps - Registry dependencies
+ * @returns Validation result
+ */
+declare function validateWorkflowConsistency(deps: WorkflowConsistencyDeps): WorkflowValidationResult;
+/**
+ * Assert workflow consistency across registries.
+ *
+ * @param deps - Registry dependencies
+ * @throws {WorkflowValidationError} If validation fails
+ */
+declare function assertWorkflowConsistency(deps: WorkflowConsistencyDeps): void;
+/**
+ * Validate SLA configuration is reasonable.
+ *
+ * @param spec - Workflow spec to validate
+ * @returns Array of validation issues
+ */
+declare function validateSlaConfig(spec: WorkflowSpec): WorkflowValidationIssue[];
+/**
+ * Validate compensation configuration.
+ *
+ * @param spec - Workflow spec to validate
+ * @returns Array of validation issues
+ */
+declare function validateCompensation(spec: WorkflowSpec): WorkflowValidationIssue[];
+/**
+ * Validate retry configuration.
+ *
+ * @param spec - Workflow spec to validate
+ * @returns Array of validation issues
+ */
+declare function validateRetryConfig(spec: WorkflowSpec): WorkflowValidationIssue[];
+/**
+ * Perform comprehensive workflow validation.
+ *
+ * @param spec - Workflow spec to validate
+ * @param options - Validation options
+ * @returns Validation result
+ */
+declare function validateWorkflowComprehensive(spec: WorkflowSpec, options?: ValidateWorkflowSpecOptions): WorkflowValidationResult;
 //#endregion
-export { ValidateWorkflowSpecOptions, WorkflowValidationError, WorkflowValidationIssue, WorkflowValidationLevel, assertWorkflowSpecValid, validateWorkflowSpec };
+export { ValidateWorkflowSpecOptions, WorkflowConsistencyDeps, WorkflowValidationError, WorkflowValidationIssue, WorkflowValidationLevel, WorkflowValidationResult, assertWorkflowConsistency, assertWorkflowSpecValid, validateCompensation, validateRetryConfig, validateSlaConfig, validateWorkflowComprehensive, validateWorkflowConsistency, validateWorkflowSpec };