@classytic/streamline 1.0.0 → 2.0.0

package/dist/context-DMkusPr_.mjs

@@ -0,0 +1,224 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+
+//#region src/utils/logger.ts
+var Logger = class {
+	minLevel = "info";
+	setLevel(level) {
+		this.minLevel = level;
+	}
+	debug(message, context) {
+		this.log("debug", message, context);
+	}
+	info(message, context) {
+		this.log("info", message, context);
+	}
+	warn(message, context) {
+		this.log("warn", message, context);
+	}
+	error(message, error, context) {
+		const errorContext = error instanceof Error ? {
+			error: {
+				message: error.message,
+				stack: error.stack
+			},
+			...context
+		} : {
+			error,
+			...context
+		};
+		this.log("error", message, errorContext);
+	}
+	log(level, message, context) {
+		if (!this.shouldLog(level)) return;
+		const logEntry = {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			level: level.toUpperCase(),
+			message,
+			...context
+		};
+		this.getLogFunction(level)(JSON.stringify(logEntry));
+	}
+	shouldLog(level) {
+		const levels = [
+			"debug",
+			"info",
+			"warn",
+			"error"
+		];
+		return levels.indexOf(level) >= levels.indexOf(this.minLevel);
+	}
+	getLogFunction(level) {
+		switch (level) {
+			case "error": return console.error;
+			case "warn": return console.warn;
+			case "info": return console.info;
+			default: return console.debug;
+		}
+	}
+};
+const logger = new Logger();
+if (process.env.NODE_ENV === "development") logger.setLevel("debug");
+
+//#endregion
+//#region src/execution/context.ts
+var context_exports = /* @__PURE__ */ __exportAll({
+	GotoSignal: () => GotoSignal,
+	StepContextImpl: () => StepContextImpl,
+	WaitSignal: () => WaitSignal
+});
+var WaitSignal = class extends Error {
+	constructor(type, reason, data) {
+		super(reason);
+		this.type = type;
+		this.reason = reason;
+		this.data = data;
+		this.name = "WaitSignal";
+	}
+};
+/**
+* Signal thrown by ctx.goto() to jump execution to a different step.
+* Caught by the engine to update currentStepId.
+*/
+var GotoSignal = class extends Error {
+	constructor(targetStepId) {
+		super(`goto:${targetStepId}`);
+		this.targetStepId = targetStepId;
+		this.name = "GotoSignal";
+	}
+};
+var StepContextImpl = class {
+	signal;
+	constructor(runId, stepId, context, input, attempt, run, repository, eventBus, signal, signalStore) {
+		this.runId = runId;
+		this.stepId = stepId;
+		this.context = context;
+		this.input = input;
+		this.attempt = attempt;
+		this.run = run;
+		this.repository = repository;
+		this.eventBus = eventBus;
+		this.signalStore = signalStore;
+		this.signal = signal ?? new AbortController().signal;
+	}
+	async set(key, value) {
+		if (this.signal.aborted) throw new Error(`Cannot update context: workflow ${this.runId} has been cancelled`);
+		this.context[key] = value;
+		this.run.context[key] = value;
+		if ((await this.repository.updateOne({
+			_id: this.runId,
+			status: { $ne: "cancelled" }
+		}, { $set: {
+			[`context.${String(key)}`]: value,
+			updatedAt: /* @__PURE__ */ new Date()
+		} }, { bypassTenant: true })).modifiedCount === 0) throw new Error(`Cannot update context: workflow ${this.runId} may have been cancelled`);
+	}
+	getOutput(stepId) {
+		return this.run.steps.find((s) => s.stepId === stepId)?.output;
+	}
+	async wait(reason, data) {
+		throw new WaitSignal("human", reason, data);
+	}
+	async waitFor(eventName, reason) {
+		throw new WaitSignal("event", reason || `Waiting for ${eventName}`, { eventName });
+	}
+	async sleep(ms) {
+		const resumeAt = new Date(Date.now() + ms);
+		throw new WaitSignal("timer", `Sleep ${ms}ms`, { resumeAt });
+	}
+	async heartbeat() {
+		if (this.signal.aborted) return;
+		try {
+			await this.repository.updateOne({
+				_id: this.runId,
+				status: { $ne: "cancelled" }
+			}, { lastHeartbeat: /* @__PURE__ */ new Date() }, { bypassTenant: true });
+		} catch {}
+	}
+	emit(eventName, data) {
+		const payload = {
+			runId: this.runId,
+			stepId: this.stepId,
+			data
+		};
+		this.eventBus.emit(eventName, payload);
+		this.signalStore?.publish(`streamline:event:${eventName}`, payload);
+	}
+	log(message, data) {
+		logger.info(message, {
+			runId: this.runId,
+			stepId: this.stepId,
+			attempt: this.attempt,
+			...data !== void 0 && { data }
+		});
+	}
+	async startChildWorkflow(workflowId, input) {
+		throw new WaitSignal("childWorkflow", `Waiting for child workflow: ${workflowId}`, {
+			childWorkflowId: workflowId,
+			childInput: input,
+			parentRunId: this.runId,
+			parentStepId: this.stepId
+		});
+	}
+	async goto(targetStepId) {
+		throw new GotoSignal(targetStepId);
+	}
+	async scatter(tasks, options) {
+		const taskIds = Object.keys(tasks);
+		const concurrency = options?.concurrency ?? Infinity;
+		const checkpoint = this.getCheckpoint() ?? {};
+		const results = {};
+		for (const id of taskIds) {
+			const saved = checkpoint[id];
+			if (saved?.done) results[id] = saved.value;
+		}
+		const pending = taskIds.filter((id) => !checkpoint[id]?.done);
+		if (pending.length === 0) return results;
+		const executing = /* @__PURE__ */ new Set();
+		for (const id of pending) {
+			if (this.signal.aborted) break;
+			const taskFn = tasks[id];
+			let promise;
+			promise = (async () => {
+				try {
+					const value = await taskFn();
+					results[id] = value;
+					checkpoint[id] = {
+						done: true,
+						value
+					};
+				} catch (err) {
+					throw err;
+				} finally {
+					executing.delete(promise);
+					await this.checkpoint(checkpoint);
+				}
+			})();
+			executing.add(promise);
+			if (executing.size >= concurrency) await Promise.race(executing).catch(() => {});
+		}
+		const failures = (await Promise.allSettled(executing)).filter((r) => r.status === "rejected");
+		if (failures.length > 0) throw failures[0].reason;
+		return results;
+	}
+	async checkpoint(value) {
+		if (this.signal.aborted) return;
+		const stepIndex = this.run.steps.findIndex((s) => s.stepId === this.stepId);
+		if (stepIndex === -1) return;
+		await this.repository.updateOne({
+			_id: this.runId,
+			status: { $ne: "cancelled" }
+		}, { $set: {
+			[`steps.${stepIndex}.output`]: { __checkpoint: value },
+			updatedAt: /* @__PURE__ */ new Date(),
+			lastHeartbeat: /* @__PURE__ */ new Date()
+		} }, { bypassTenant: true });
+		const step = this.run.steps[stepIndex];
+		if (step) step.output = { __checkpoint: value };
+	}
+	getCheckpoint() {
+		return (this.run.steps.find((s) => s.stepId === this.stepId)?.output)?.__checkpoint;
+	}
+};
+
+//#endregion
+export { logger as a, context_exports as i, StepContextImpl as n, WaitSignal as r, GotoSignal as t };

package/dist/{errors-BqunvWPz.mjs → errors-Ba7ZziTN.mjs}

@@ -1,20 +1,5 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
 
-//#endregion
 //#region src/utils/errors.ts
 var errors_exports = /* @__PURE__ */ __exportAll({
 	DataCorruptionError: () => DataCorruptionError,

package/dist/{events-C0sZINZq.d.mts → events-DC0ddZZ9.d.mts}

@@ -89,4 +89,4 @@ declare class WorkflowEventBus extends EventEmitter {
  */
 declare const globalEventBus: WorkflowEventBus;
 //#endregion
-export { WorkflowEventName as n, globalEventBus as r, WorkflowEventBus as t };
+export { StepEventPayload as a, WorkflowCompletedPayload as c, WorkflowFailedPayload as d, WorkflowResumedPayload as f, StepCompletedPayload as i, WorkflowEventBus as l, EngineErrorPayload as n, StepFailedPayload as o, globalEventBus as p, EventPayloadMap as r, StepRetryPayload as s, BaseEventPayload as t, WorkflowEventName as u };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { _ as WorkflowHandlers, a as SchedulingInfo, c as StepError, d as StepState, f as StepStatus, g as WorkflowEventPayload, h as WorkflowDefinition, i as RunStatus, l as StepHandler, m as WaitingFor, n as InferHandlersContext, o as Step, p as TypedHandlers, r as RecurrencePattern, s as StepContext, t as InferContext, u as StepIds, v as WorkflowRun } from "./types-DG85_LzF.mjs";
-import { n as WorkflowEventName, r as globalEventBus, t as WorkflowEventBus } from "./events-C0sZINZq.mjs";
+import { _ as WorkflowHandlers, a as SchedulingInfo, c as StepError, d as StepState, f as StepStatus, g as WorkflowEventPayload, h as WorkflowDefinition, i as RunStatus, l as StepHandler, m as WaitingFor, n as InferHandlersContext, o as Step, p as TypedHandlers, r as RecurrencePattern, s as StepContext, t as InferContext, u as StepIds, v as WorkflowRun } from "./types-DjgzSrNY.mjs";
+import { a as StepEventPayload, c as WorkflowCompletedPayload, d as WorkflowFailedPayload, f as WorkflowResumedPayload, i as StepCompletedPayload, l as WorkflowEventBus, n as EngineErrorPayload, o as StepFailedPayload, p as globalEventBus, r as EventPayloadMap, s as StepRetryPayload, t as BaseEventPayload, u as WorkflowEventName } from "./events-DC0ddZZ9.mjs";
 import { FilterQuery, Plugin, Repository } from "@classytic/mongokit";
 import mongoose from "mongoose";
 
@@ -206,6 +206,12 @@ interface SmartSchedulerConfig {
   staleCheckInterval: number;
   /** Threshold for stale workflow detection */
   staleThreshold: number;
+  /**
+   * Max workflows executing simultaneously.
+   * When the limit is reached, the scheduler skips processing new workflows until slots free up.
+   * @default Infinity (no limit — current behavior)
+   */
+  maxConcurrentExecutions: number;
 }
 declare class SmartScheduler {
   private repository;
@@ -347,6 +353,38 @@ declare class WorkflowCache {
 }
 //#endregion
 //#region src/core/container.d.ts
+/**
+ * Pluggable signal store for durable cross-process event delivery.
+ *
+ * Default: in-memory (process-local). For durable signals across workers,
+ * plug in Redis, Kafka, BullMQ, or any pub/sub backend.
+ *
+ * Streamline never depends on these — users bring their own adapter.
+ *
+ * @example Redis adapter (user-provided)
+ * ```typescript
+ * import Redis from 'ioredis';
+ *
+ * const redis = new Redis();
+ * const signalStore: SignalStore = {
+ *   publish: (channel, data) => redis.publish(channel, JSON.stringify(data)),
+ *   subscribe: (channel, handler) => {
+ *     const sub = redis.duplicate();
+ *     sub.subscribe(channel);
+ *     sub.on('message', (ch, msg) => handler(JSON.parse(msg)));
+ *     return () => { sub.unsubscribe(channel); sub.disconnect(); };
+ *   },
+ * };
+ *
+ * const container = createContainer({ signalStore });
+ * ```
+ */
+interface SignalStore {
+  /** Publish a signal to a named channel */
+  publish(channel: string, data: unknown): Promise<void> | void;
+  /** Subscribe to a channel. Returns an unsubscribe function. */
+  subscribe(channel: string, handler: (data: unknown) => void): (() => void) | Promise<() => void>;
+}
 /**
  * Container holding all shared dependencies for a workflow engine instance.
  *
@@ -369,6 +407,8 @@ interface StreamlineContainer {
   eventBus: WorkflowEventBus;
   /** In-memory cache for active workflows */
   cache: WorkflowCache;
+  /** Pluggable signal store for durable cross-process event delivery */
+  signalStore: SignalStore;
 }
 /**
  * Options for creating a container
@@ -393,6 +433,12 @@ interface ContainerOptions {
    * If undefined: creates a new isolated cache
    */
   cache?: WorkflowCache;
+  /**
+   * Custom signal store for durable cross-process event delivery.
+   * - If SignalStore: uses the provided instance (e.g., Redis, Kafka, BullMQ adapter)
+   * - If undefined: uses default in-memory store (process-local)
+   */
+  signalStore?: SignalStore;
 }
 /**
  * Create a new container with configurable dependencies.
@@ -448,11 +494,27 @@ declare class HookRegistry {
 }
 /** Global hook registry instance */
 declare const hookRegistry: HookRegistry;
+/**
+ * Global registry mapping workflowId → engine.
+ * Populated by createWorkflow(). Enables ctx.startChildWorkflow() to find
+ * and start child workflows by ID without the caller needing a reference.
+ */
+declare class WorkflowRegistryGlobal {
+  private engines;
+  register(workflowId: string, engine: WorkflowEngine<unknown>): void;
+  getEngine(workflowId: string): WorkflowEngine<unknown> | undefined;
+}
+declare const workflowRegistry: WorkflowRegistryGlobal;
 interface WorkflowEngineOptions {
   /** Auto-execute workflow after start (default: true) */
   autoExecute?: boolean;
   /** Custom scheduler configuration */
   scheduler?: Partial<SmartSchedulerConfig>;
+  /**
+   * Compensation handlers for saga pattern rollback.
+   * Keyed by stepId. Called in reverse order when a later step fails.
+   */
+  compensationHandlers?: WorkflowHandlers<unknown>;
 }
 /**
  * Core workflow execution engine.
@@ -509,6 +571,11 @@ declare class WorkflowEngine<TContext = Record<string, unknown>> {
    * @returns The updated workflow run
    */
   execute(runId: string): Promise<WorkflowRun<TContext>>;
+  /**
+   * Run saga compensation handlers for completed steps in reverse order.
+   * Called automatically when a workflow fails and compensation handlers are registered.
+   */
+  private runCompensation;
   private getOrThrow;
   private shouldContinueExecution;
   private executeNextStep;
@@ -607,8 +674,74 @@ declare class WorkflowEngine<TContext = Record<string, unknown>> {
 }
 //#endregion
 //#region src/workflow/define.d.ts
+/**
+ * Per-step configuration for overriding timeout, retries, and conditions.
+ *
+ * `TContext` flows from `WorkflowConfig` — no manual annotation needed.
+ *
+ * @example
+ * ```typescript
+ * const workflow = createWorkflow('pipeline', {
+ *   steps: {
+ *     clone: {
+ *       handler: async (ctx) => { ... },
+ *       timeout: 120_000,
+ *       retries: 5,
+ *     },
+ *     review: {
+ *       handler: async (ctx) => { ... },
+ *       timeout: 300_000,
+ *       skipIf: (ctx) => ctx.autoApproved, // ctx is your TContext
+ *     },
+ *   },
+ * });
+ * ```
+ */
+interface StepConfig<TOutput = unknown, TContext = Record<string, unknown>> {
+  handler: StepHandler<TOutput, TContext>;
+  timeout?: number;
+  retries?: number;
+  condition?: (context: TContext, run: WorkflowRun) => boolean | Promise<boolean>;
+  skipIf?: (context: TContext) => boolean | Promise<boolean>;
+  runIf?: (context: TContext) => boolean | Promise<boolean>;
+  /**
+   * Compensation handler (saga pattern rollback).
+   *
+   * Called in reverse order when a later step fails permanently.
+   * Only runs for steps that completed successfully (status: 'done').
+   *
+   * @example
+   * ```typescript
+   * charge: {
+   *   handler: async (ctx) => stripe.charges.create({ amount: 100 }),
+   *   onCompensate: async (ctx) => {
+   *     const chargeId = ctx.getOutput<{ id: string }>('charge')?.id;
+   *     await stripe.refunds.create({ charge: chargeId });
+   *   },
+   * },
+   * ```
+   */
+  onCompensate?: StepHandler<unknown, TContext>;
+}
+/**
+ * Configuration for `createWorkflow()`.
+ *
+ * Steps can be plain async handlers or `StepConfig` objects with per-step
+ * timeout, retries, and conditions. Mix freely — `TContext` infers everywhere.
+ *
+ * @example
+ * ```typescript
+ * const config: WorkflowConfig<MyContext> = {
+ *   steps: {
+ *     fast: async (ctx) => ctx.context.value * 2,
+ *     slow: { handler: async (ctx) => heavyWork(), timeout: 120_000 },
+ *   },
+ *   context: (input) => ({ value: input.n }),
+ * };
+ * ```
+ */
 interface WorkflowConfig<TContext, TInput = unknown> {
-  steps: Record<string, StepHandler<unknown, TContext>>;
+  steps: Record<string, StepHandler<unknown, TContext> | StepConfig<unknown, TContext>>;
   context?: (input: TInput) => TContext;
   version?: string;
   defaults?: {
@@ -619,13 +752,25 @@ interface WorkflowConfig<TContext, TInput = unknown> {
   /** Optional custom container for dependency injection */
   container?: StreamlineContainer;
 }
-/** Options for waitFor method */
+/** Options for `Workflow.waitFor()` */
 interface WaitForOptions {
-  /** Poll interval in ms (default: 1000) */
+  /** Poll interval in ms @default 1000 */
   pollInterval?: number;
-  /** Maximum time to wait in ms (default: no timeout) */
+  /** Maximum time to wait in ms @default undefined (no timeout) */
   timeout?: number;
 }
+/**
+ * A running workflow instance returned by `createWorkflow()`.
+ *
+ * Exported so consumers can type variables without the `ReturnType<>` workaround.
+ *
+ * @example
+ * ```typescript
+ * import { createWorkflow, type Workflow } from '@classytic/streamline';
+ *
+ * export const myWorkflow: Workflow<MyCtx, MyInput> = createWorkflow('my', { ... });
+ * ```
+ */
 interface Workflow<TContext, TInput = unknown> {
   start: (input: TInput, meta?: Record<string, unknown>) => Promise<WorkflowRun<TContext>>;
   get: (runId: string) => Promise<WorkflowRun<TContext> | null>;
@@ -634,22 +779,6 @@ interface Workflow<TContext, TInput = unknown> {
   cancel: (runId: string) => Promise<WorkflowRun<TContext>>;
   pause: (runId: string) => Promise<WorkflowRun<TContext>>;
   rewindTo: (runId: string, stepId: string) => Promise<WorkflowRun<TContext>>;
-  /**
-   * Wait for a workflow to complete (reach a terminal state).
-   * Polls the workflow status until it's done, failed, or cancelled.
-   *
-   * @param runId - Workflow run ID to wait for
-   * @param options - Poll interval and timeout settings
-   * @returns The completed workflow run
-   * @throws {Error} If timeout is exceeded or workflow not found
-   *
-   * @example
-   * ```typescript
-   * const run = await workflow.start({ data: 'test' });
-   * const completed = await workflow.waitFor(run._id);
-   * console.log(completed.status); // 'done' | 'failed' | 'cancelled'
-   * ```
-   */
   waitFor: (runId: string, options?: WaitForOptions) => Promise<WorkflowRun<TContext>>;
   shutdown: () => void;
   definition: WorkflowDefinition<TContext>;
@@ -675,12 +804,17 @@ interface Workflow<TContext, TInput = unknown> {
  * await orderProcess.start({ id: '123', email: 'user@example.com' });
  * ```
  *
- * @example Custom container for testing
+ * @example Per-step configuration
  * ```typescript
- * const container = createContainer();
- * const workflow = createWorkflow('test-workflow', {
- *   steps: { ... },
- *   container
+ * const pipeline = createWorkflow('ci-pipeline', {
+ *   steps: {
+ *     clone: { handler: async (ctx) => { ... }, timeout: 120_000 },
+ *     build: { handler: async (ctx) => { ... }, retries: 5 },
+ *     deploy: {
+ *       handler: async (ctx) => { ... },
+ *       skipIf: (ctx) => !ctx.shouldDeploy,
+ *     },
+ *   },
  * });
  * ```
  */
@@ -714,37 +848,24 @@ interface HookResult {
  * Create a hook that pauses workflow until external input.
  * The token includes a crypto-random suffix for security.
  *
- * IMPORTANT: Pass the returned token to ctx.wait() to enable token validation:
- * ```typescript
- * const hook = createHook(ctx, 'approval');
- * return ctx.wait(hook.token, { hookToken: hook.token }); // Token stored for validation
- * ```
- *
  * @example
  * ```typescript
- * // In step handler
- * async function waitForApproval(ctx) {
- *   const hook = createHook(ctx, 'waiting-for-approval');
- *   console.log('Resume with token:', hook.token);
- *   return ctx.wait(hook.token, { hookToken: hook.token }); // Token validated on resume
- * }
- *
- * // From API route
- * await resumeHook('token-123', { approved: true });
+ * const hook = createHook(ctx, 'waiting-for-approval');
+ * return ctx.wait(hook.token, { hookToken: hook.token });
  * ```
  */
 declare function createHook(ctx: StepContext, reason: string, options?: HookOptions): HookResult;
 /**
  * Resume a paused workflow by hook token.
  *
- * Security: If the workflow was paused with a hookToken in waitingFor.data,
- * this function validates the token before resuming.
+ * **Durable**: Works across process restarts and multi-worker deployments.
+ * - Fast path: Uses in-memory hookRegistry if the engine is in this process.
+ * - Fallback: Looks up the workflow in MongoDB and resumes via atomic DB operations.
  *
- * Multi-worker support: Falls back to DB lookup if engine not in local registry.
+ * Security: Validates the token against the stored hookToken if present.
  *
  * @example
  * ```typescript
- * // API route handler
  * app.post('/hooks/:token', async (req, res) => {
  *   const result = await resumeHook(req.params.token, req.body);
  *   res.json({ success: true, runId: result.runId, status: result.run.status });
@@ -760,7 +881,6 @@ declare function resumeHook(token: string, payload: unknown): Promise<{
  *
  * @example
  * ```typescript
- * // Slack bot - same channel always gets same token
  * const token = hookToken('slack', channelId);
  * const hook = createHook(ctx, 'slack-message', { token });
  * ```
@@ -769,10 +889,18 @@ declare function hookToken(...parts: string[]): string;
 //#endregion
 //#region src/execution/context.d.ts
 declare class WaitSignal extends Error {
-  type: 'human' | 'webhook' | 'timer' | 'event';
+  type: 'human' | 'webhook' | 'timer' | 'event' | 'childWorkflow';
   reason: string;
   data?: unknown | undefined;
-  constructor(type: 'human' | 'webhook' | 'timer' | 'event', reason: string, data?: unknown | undefined);
+  constructor(type: 'human' | 'webhook' | 'timer' | 'event' | 'childWorkflow', reason: string, data?: unknown | undefined);
+}
+/**
+ * Signal thrown by ctx.goto() to jump execution to a different step.
+ * Caught by the engine to update currentStepId.
+ */
+declare class GotoSignal extends Error {
+  targetStepId: string;
+  constructor(targetStepId: string);
 }
 //#endregion
 //#region src/storage/run.model.d.ts
@@ -1016,7 +1144,7 @@ declare function getWorkflowProgress(run: WorkflowRun): WorkflowProgress;
 declare function getStepUIStates(run: WorkflowRun): StepUIState[];
 declare function getWaitingInfo(run: WorkflowRun): {
   stepId: string;
-  type: "human" | "webhook" | "timer" | "event";
+  type: "human" | "webhook" | "timer" | "event" | "childWorkflow";
   reason: string;
   resumeAt: Date | undefined;
   eventName: string | undefined;
@@ -1586,4 +1714,4 @@ declare class MaxRetriesExceededError extends WorkflowError {
   constructor(stepId: string, attempts: number, runId?: string);
 }
 //#endregion
-export { COMPUTED, type CacheHealthStatus, CommonQueries, type ConditionalStep, type ContainerOptions, DataCorruptionError, ErrorCode, type ErrorCode as ErrorCodeType, type ExecuteParallelOptions, type GetScheduledWorkflowsOptions, InferContext, InferHandlersContext, InvalidStateError, MaxRetriesExceededError, RUN_STATUS, RUN_STATUS_VALUES, RecurrencePattern, RunStatus, STEP_STATUS, STEP_STATUS_VALUES, type ScheduleWorkflowOptions, type SchedulerStats, SchedulingInfo, SchedulingService, type SchedulingServiceConfig, type SmartSchedulerConfig, Step, type StepContext, StepError, StepHandler, StepIds, StepNotFoundError, StepState, StepStatus, type StepTimeline, StepTimeoutError, type StepUIState, type StreamlineContainer, type TenantFilterOptions, type TimezoneCalculationResult, TimezoneHandler, TypedHandlers, WaitSignal, WaitingFor, WorkflowCache, WorkflowDefinition, type WorkflowDefinitionDoc, WorkflowDefinitionModel, WorkflowEngine, type WorkflowEngineOptions, WorkflowError, WorkflowEventBus, type WorkflowEventName, WorkflowEventPayload, WorkflowHandlers, WorkflowNotFoundError, type WorkflowProgress, WorkflowQueryBuilder, type WorkflowRepositoryConfig, type WorkflowRun, WorkflowRunModel, type WorkflowRunRepository, canRewindTo, conditions, createCondition, createContainer, createHook, createWorkflow, createWorkflowRepository, deriveRunStatus, executeParallel, getExecutionPath, getStepTimeline, getStepUIStates, getWaitingInfo, getWorkflowProgress, globalEventBus, hookRegistry, hookToken, isConditionalStep, isRunStatus, isStepStatus, isStreamlineContainer, isTerminalState, isValidRunTransition, isValidStepTransition, resumeHook, shouldSkipStep, singleTenantPlugin, tenantFilterPlugin, timezoneHandler, workflowDefinitionRepository, workflowRunRepository };
+export { type BaseEventPayload, COMPUTED, type CacheHealthStatus, CommonQueries, type ConditionalStep, type ContainerOptions, DataCorruptionError, type EngineErrorPayload, ErrorCode, type ErrorCode as ErrorCodeType, type EventPayloadMap, type ExecuteParallelOptions, type GetScheduledWorkflowsOptions, GotoSignal, type HookOptions, type HookResult, InferContext, InferHandlersContext, InvalidStateError, MaxRetriesExceededError, RUN_STATUS, RUN_STATUS_VALUES, RecurrencePattern, RunStatus, STEP_STATUS, STEP_STATUS_VALUES, type ScheduleWorkflowOptions, type SchedulerStats, SchedulingInfo, SchedulingService, type SchedulingServiceConfig, type SignalStore, type SmartSchedulerConfig, Step, type StepCompletedPayload, type StepConfig, type StepContext, StepError, type StepEventPayload, type StepFailedPayload, StepHandler, StepIds, StepNotFoundError, type StepRetryPayload, StepState, StepStatus, type StepTimeline, StepTimeoutError, type StepUIState, type StreamlineContainer, type TenantFilterOptions, type TimezoneCalculationResult, TimezoneHandler, TypedHandlers, type WaitForOptions, WaitSignal, WaitingFor, type Workflow, WorkflowCache, type WorkflowCompletedPayload, type WorkflowConfig, WorkflowDefinition, type WorkflowDefinitionDoc, WorkflowDefinitionModel, WorkflowEngine, type WorkflowEngineOptions, WorkflowError, WorkflowEventBus, type WorkflowEventName, WorkflowEventPayload, type WorkflowFailedPayload, WorkflowHandlers, WorkflowNotFoundError, type WorkflowProgress, WorkflowQueryBuilder, type WorkflowRepositoryConfig, type WorkflowResumedPayload, type WorkflowRun, WorkflowRunModel, type WorkflowRunRepository, canRewindTo, conditions, createCondition, createContainer, createHook, createWorkflow, createWorkflowRepository, deriveRunStatus, executeParallel, getExecutionPath, getStepTimeline, getStepUIStates, getWaitingInfo, getWorkflowProgress, globalEventBus, hookRegistry, hookToken, isConditionalStep, isRunStatus, isStepStatus, isStreamlineContainer, isTerminalState, isValidRunTransition, isValidStepTransition, resumeHook, shouldSkipStep, singleTenantPlugin, tenantFilterPlugin, timezoneHandler, workflowDefinitionRepository, workflowRegistry, workflowRunRepository };