@classytic/streamline 1.0.0 → 2.0.0

package/dist/{container-BzpIMrrj.mjs → container-BSxj_Or4.mjs}

@@ -1,144 +1,10 @@
-import { a as StepNotFoundError, c as WorkflowNotFoundError, r as InvalidStateError } from "./errors-BqunvWPz.mjs";
-import { n as globalEventBus, t as WorkflowEventBus } from "./events-B5aTz7kD.mjs";
+import { a as logger, n as StepContextImpl, r as WaitSignal, t as GotoSignal } from "./context-DMkusPr_.mjs";
+import { a as StepNotFoundError, c as WorkflowNotFoundError, r as InvalidStateError } from "./errors-Ba7ZziTN.mjs";
+import { n as globalEventBus, t as WorkflowEventBus } from "./events-CpesEn3I.mjs";
 import { randomUUID } from "node:crypto";
 import { Repository, methodRegistryPlugin, mongoOperationsPlugin } from "@classytic/mongokit";
 import mongoose, { Schema } from "mongoose";
 
-//#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 WaitSignal = class extends Error {
-	constructor(type, reason, data) {
-		super(reason);
-		this.type = type;
-		this.reason = reason;
-		this.data = data;
-		this.name = "WaitSignal";
-	}
-};
-var StepContextImpl = class {
-	signal;
-	constructor(runId, stepId, context, input, attempt, run, repository, eventBus, signal) {
-		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.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) {
-		this.eventBus.emit(eventName, {
-			runId: this.runId,
-			stepId: this.stepId,
-			data
-		});
-	}
-	log(message, data) {
-		logger.info(message, {
-			runId: this.runId,
-			stepId: this.stepId,
-			attempt: this.attempt,
-			...data !== void 0 && { data }
-		});
-	}
-};
-
-//#endregion
 //#region src/core/status.ts
 const STEP_STATUS_VALUES = [
 	"pending",
@@ -400,11 +266,12 @@ const CANCELLED_GUARD = { status: { $ne: "cancelled" } };
 var StepExecutor = class {
 	/** Track active AbortControllers by runId for cancellation support */
 	activeControllers = /* @__PURE__ */ new Map();
-	constructor(registry, repository, eventBus, cache) {
+	constructor(registry, repository, eventBus, cache, signalStore) {
 		this.registry = registry;
 		this.repository = repository;
 		this.eventBus = eventBus;
 		this.cache = cache;
+		this.signalStore = signalStore;
 	}
 	/**
 	* Abort any in-flight step execution for a workflow.
@@ -566,7 +433,7 @@ var StepExecutor = class {
 		this.activeControllers.set(run._id, abortController);
 		try {
 			const stepState = run.steps.find((s) => s.stepId === stepId);
-			const ctx = new StepContextImpl(run._id, stepId, run.context, run.input, stepState.attempts, run, this.repository, this.eventBus, abortController.signal);
+			const ctx = new StepContextImpl(run._id, stepId, run.context, run.input, stepState.attempts, run, this.repository, this.eventBus, abortController.signal, this.signalStore);
 			const output = await this.executeWithTimeout(handler, ctx, step.timeout || this.registry.definition.defaults?.timeout, run._id, abortController);
 			run = await this.updateStepState(run, stepId, {
 				status: "done",
@@ -584,6 +451,11 @@ var StepExecutor = class {
 			return await this.moveToNextStep(run);
 		} catch (error) {
 			if (error instanceof WaitSignal) return await this.handleWait(run, stepId, error);
+			else if (error instanceof GotoSignal) try {
+				return await this.handleGoto(run, stepId, error.targetStepId);
+			} catch (gotoError) {
+				return await this.handleFailure(run, stepId, gotoError);
+			}
 			else if (error instanceof InvalidStateError) throw error;
 			else return await this.handleFailure(run, stepId, error);
 		} finally {
@@ -593,11 +465,22 @@ var StepExecutor = class {
 	async executeWithTimeout(handler, ctx, timeout, runId, abortController) {
 		let heartbeatTimer;
 		let timeoutHandle;
-		if (runId) heartbeatTimer = setInterval(async () => {
-			try {
-				await this.repository.updateOne({ _id: runId }, { lastHeartbeat: /* @__PURE__ */ new Date() }, { bypassTenant: true });
-			} catch {}
-		}, TIMING.HEARTBEAT_INTERVAL_MS);
+		if (runId) {
+			let consecutiveHeartbeatFailures = 0;
+			heartbeatTimer = setInterval(async () => {
+				try {
+					await this.repository.updateOne({ _id: runId }, { lastHeartbeat: /* @__PURE__ */ new Date() }, { bypassTenant: true });
+					consecutiveHeartbeatFailures = 0;
+				} catch (error) {
+					consecutiveHeartbeatFailures++;
+					this.eventBus.emit("engine:error", {
+						runId,
+						error: error instanceof Error ? error : new Error(String(error)),
+						context: consecutiveHeartbeatFailures >= 3 ? "heartbeat-critical" : "heartbeat-warning"
+					});
+				}
+			}, TIMING.HEARTBEAT_INTERVAL_MS);
+		}
 		const cleanup = () => {
 			if (heartbeatTimer) clearInterval(heartbeatTimer);
 			if (timeoutHandle) clearTimeout(timeoutHandle);
@@ -793,6 +676,55 @@ var StepExecutor = class {
 		return run;
 	}
 	/**
+	* Handle a goto signal — jump execution to a target step.
+	* Marks the current step as done and sets currentStepId to the target.
+	*/
+	async handleGoto(run, fromStepId, targetStepId) {
+		if (!this.registry.getStep(targetStepId)) {
+			const availableSteps = this.registry.definition.steps.map((s) => s.id);
+			throw new StepNotFoundError(targetStepId, run.workflowId, availableSteps);
+		}
+		run = await this.updateStepState(run, fromStepId, {
+			status: "skipped",
+			endedAt: /* @__PURE__ */ new Date()
+		});
+		this.eventBus.emit("step:completed", {
+			runId: run._id,
+			stepId: fromStepId,
+			data: { goto: targetStepId }
+		});
+		const now = /* @__PURE__ */ new Date();
+		const targetIndex = this.registry.definition.steps.findIndex((s) => s.id === targetStepId);
+		const updates = {
+			currentStepId: targetStepId,
+			status: "running",
+			updatedAt: now
+		};
+		if (targetIndex !== -1) {
+			updates[`steps.${targetIndex}.status`] = "pending";
+			updates[`steps.${targetIndex}.attempts`] = 0;
+			const step = run.steps[targetIndex];
+			if (step) {
+				step.status = "pending";
+				step.attempts = 0;
+				step.output = void 0;
+				step.error = void 0;
+				step.startedAt = void 0;
+				step.endedAt = void 0;
+				step.waitingFor = void 0;
+				step.retryAfter = void 0;
+			}
+		}
+		await this.repository.updateOne({
+			_id: run._id,
+			status: { $ne: "cancelled" }
+		}, { $set: updates }, { bypassTenant: true });
+		run.currentStepId = targetStepId;
+		run.status = "running";
+		run.updatedAt = now;
+		return run;
+	}
+	/**
 	* Resume a waiting step with payload.
 	* Marks the step as done and continues to next step.
 	* 
@@ -805,7 +737,7 @@ var StepExecutor = class {
 		const stepId = run.currentStepId;
 		const { step: stepState } = this.findStepOrThrow(run, stepId);
 		if (stepState.status !== "waiting") {
-			const { InvalidStateError } = await import("./errors-BqunvWPz.mjs").then((n) => n.l);
+			const { InvalidStateError } = await import("./errors-Ba7ZziTN.mjs").then((n) => n.l);
 			throw new InvalidStateError("resume step", stepState.status, ["waiting"], {
 				runId: run._id,
 				stepId
@@ -906,7 +838,8 @@ const DEFAULT_SCHEDULER_CONFIG = {
 	adaptivePolling: true,
 	maxConsecutiveFailures: SCHEDULER.MAX_CONSECUTIVE_FAILURES,
 	staleCheckInterval: SCHEDULER.STALE_CHECK_INTERVAL_MS,
-	staleThreshold: TIMING.STALE_WORKFLOW_THRESHOLD_MS
+	staleThreshold: TIMING.STALE_WORKFLOW_THRESHOLD_MS,
+	maxConcurrentExecutions: Infinity
 };
 var SmartScheduler = class {
 	timers = /* @__PURE__ */ new Map();
@@ -1108,7 +1041,17 @@ var SmartScheduler = class {
 		const startTime = Date.now();
 		try {
 			const now = /* @__PURE__ */ new Date();
-			const limit = this.config.maxWorkflowsPerPoll;
+			let limit = this.config.maxWorkflowsPerPoll;
+			if (this.config.maxConcurrentExecutions !== Infinity) {
+				const activeCount = (await this.repository.getRunningRuns()).length;
+				if (activeCount >= this.config.maxConcurrentExecutions) {
+					const duration = Date.now() - startTime;
+					this.metrics.recordPoll(duration, true, 0);
+					return;
+				}
+				const availableSlots = this.config.maxConcurrentExecutions - activeCount;
+				limit = Math.min(limit, availableSlots);
+			}
 			const waiting = await this.repository.getReadyToResume(now, limit);
 			const retrying = await this.repository.getReadyForRetry(now, limit);
 			let resumedCount = 0;
@@ -1126,17 +1069,6 @@ var SmartScheduler = class {
 			else logger.warn(`Retry workflow detected but no retry callback set`, { runId: run._id });
 			const scheduled = (await this.repository.getScheduledWorkflowsReadyToExecute(now, { limit })).docs || [];
 			for (const run of scheduled) if (this.retryCallback) try {
-				if ((await this.repository.updateOne({
-					_id: run._id,
-					status: "draft",
-					"scheduling.executionTime": { $lte: now },
-					paused: { $ne: true }
-				}, {
-					status: "running",
-					startedAt: now,
-					updatedAt: now,
-					lastHeartbeat: now
-				}, { bypassTenant: true })).modifiedCount === 0) continue;
 				await this.retryCallback(run._id);
 				resumedCount++;
 			} catch (err) {
@@ -1389,15 +1321,39 @@ var HookRegistry = class {
 /** Global hook registry instance */
 const hookRegistry = new 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.
+*/
+var WorkflowRegistryGlobal = class {
+	engines = /* @__PURE__ */ new Map();
+	register(workflowId, engine) {
+		this.engines.set(workflowId, new WeakRef(engine));
+	}
+	getEngine(workflowId) {
+		const ref = this.engines.get(workflowId);
+		if (!ref) return void 0;
+		const engine = ref.deref();
+		if (!engine) {
+			this.engines.delete(workflowId);
+			return;
+		}
+		return engine;
+	}
+};
+const workflowRegistry = new WorkflowRegistryGlobal();
+/**
 * Clean up all event listeners for a specific workflow
 */
 function cleanupEventListeners(runId, listeners, eventBus) {
 	const prefix = `${runId}:`;
-	const keysToRemove = Array.from(listeners.keys()).filter((key) => key.startsWith(prefix));
+	const signalPrefix = `signal:${runId}:`;
+	const keysToRemove = Array.from(listeners.keys()).filter((key) => key.startsWith(prefix) || key.startsWith(signalPrefix));
 	for (const key of keysToRemove) {
 		const entry = listeners.get(key);
 		if (entry) {
-			eventBus.off(entry.eventName, entry.listener);
+			if (key.startsWith("signal:")) entry.listener();
+			else eventBus.off(entry.eventName, entry.listener);
 			listeners.delete(key);
 		}
 	}
@@ -1456,7 +1412,7 @@ var WorkflowEngine = class {
 		this.handlers = handlers;
 		this.container = container;
 		this.registry = new WorkflowRegistry(definition, handlers);
-		this.executor = new StepExecutor(this.registry, container.repository, container.eventBus, container.cache);
+		this.executor = new StepExecutor(this.registry, container.repository, container.eventBus, container.cache, container.signalStore);
 		this.eventListeners = /* @__PURE__ */ new Map();
 		const schedulerConfig = {
 			...DEFAULT_SCHEDULER_CONFIG,
@@ -1465,6 +1421,7 @@ var WorkflowEngine = class {
 		this.scheduler = new SmartScheduler(container.repository, async (runId) => {
 			await this.resume(runId);
 		}, schedulerConfig, container.eventBus);
+		workflowRegistry.register(definition.id, this);
 		this.scheduler.setStaleRecoveryCallback(async (runId, thresholdMs) => {
 			return this.recoverStale(runId, thresholdMs);
 		});
@@ -1555,11 +1512,67 @@ var WorkflowEngine = class {
 			if (error instanceof InvalidStateError) {
 				const cancelled = await this.get(runId);
 				if (cancelled) run = cancelled;
+			} else if (error instanceof StepNotFoundError) {
+				const stepId = run.currentStepId;
+				this.container.eventBus.emit("engine:error", {
+					runId,
+					error: /* @__PURE__ */ new Error(`Version mismatch: workflow "${run.workflowId}" run has currentStepId="${stepId}" but this engine (v${this.definition.version}) doesn't define it. Register the old version with workflowRegistry or migrate in-flight runs.`),
+					context: "version-mismatch"
+				});
+				const now = /* @__PURE__ */ new Date();
+				await this.container.repository.updateOne({ _id: runId }, { $set: {
+					status: "failed",
+					updatedAt: now,
+					endedAt: now,
+					error: {
+						message: `Step "${stepId}" not found — code version changed while workflow was in-flight`,
+						code: "VERSION_MISMATCH"
+					}
+				} }, { bypassTenant: true });
+				run.status = "failed";
+				run.endedAt = now;
+				run.error = {
+					message: `Step "${stepId}" not found — code version changed while workflow was in-flight`,
+					code: "VERSION_MISMATCH"
+				};
 			} else throw error;
 		}
 		if (isTerminalState(run.status)) {
 			cleanupEventListeners(runId, this.eventListeners, this.container.eventBus);
 			hookRegistry.unregister(runId);
+			if (run.status === "failed" && this.options.compensationHandlers) run = await this.runCompensation(run);
+		}
+		return run;
+	}
+	/**
+	* Run saga compensation handlers for completed steps in reverse order.
+	* Called automatically when a workflow fails and compensation handlers are registered.
+	*/
+	async runCompensation(run) {
+		const compensationHandlers = this.options.compensationHandlers;
+		if (!compensationHandlers) return run;
+		const completedSteps = run.steps.filter((s) => s.status === "done" && compensationHandlers[s.stepId]).reverse();
+		if (completedSteps.length === 0) return run;
+		this.container.eventBus.emit("workflow:compensating", {
+			runId: run._id,
+			data: { steps: completedSteps.map((s) => s.stepId) }
+		});
+		for (const stepState of completedSteps) {
+			const handler = compensationHandlers[stepState.stepId];
+			if (!handler) continue;
+			try {
+				await handler(new (await (import("./context-DMkusPr_.mjs").then((n) => n.i))).StepContextImpl(run._id, stepState.stepId, run.context, run.input, stepState.attempts, run, this.container.repository, this.container.eventBus));
+				this.container.eventBus.emit("step:compensated", {
+					runId: run._id,
+					stepId: stepState.stepId
+				});
+			} catch (err) {
+				this.container.eventBus.emit("engine:error", {
+					runId: run._id,
+					error: err instanceof Error ? err : new Error(String(err)),
+					context: `compensation-${stepState.stepId}`
+				});
+			}
 		}
 		return run;
 	}
@@ -1584,6 +1597,9 @@ var WorkflowEngine = class {
 	checkNoProgress(run, prevStepId, prevStepStatus) {
 		const currentStep = run.steps.find((s) => s.stepId === run.currentStepId);
 		const isRetryPending = currentStep?.status === "pending" && currentStep?.retryAfter;
+		if (prevStepId) {
+			if (run.steps.find((s) => s.stepId === prevStepId)?.status === "skipped") return false;
+		}
 		return run.currentStepId === prevStepId && currentStep?.status === prevStepStatus && !isRetryPending;
 	}
 	/**
@@ -1612,6 +1628,46 @@ var WorkflowEngine = class {
 			}
 			return false;
 		}
+		if (stepState.waitingFor?.type === "childWorkflow") {
+			const data = stepState.waitingFor.data;
+			if (data?.childWorkflowId && !data.childRunId) {
+				const childEngine = workflowRegistry.getEngine(data.childWorkflowId);
+				if (childEngine) {
+					const childRun = await childEngine.start(data.childInput);
+					const stepIndex = run.steps.findIndex((s) => s.stepId === run.currentStepId);
+					if (stepIndex !== -1) await this.container.repository.updateOne({ _id: runId }, { $set: { [`steps.${stepIndex}.waitingFor.data.childRunId`]: childRun._id } }, { bypassTenant: true });
+					const childCompletionHandler = async (payload) => {
+						if (!payload.runId || payload.runId !== childRun._id) return;
+						try {
+							const completedChild = await childEngine.get(childRun._id);
+							const output = completedChild?.output ?? completedChild?.context;
+							await this.resume(runId, output);
+						} catch {}
+						this.container.eventBus.off("workflow:completed", childCompletionHandler);
+						this.container.eventBus.off("workflow:failed", childFailHandler);
+					};
+					const childFailHandler = async (payload) => {
+						if (!payload.runId || payload.runId !== childRun._id) return;
+						try {
+							const failedChild = await childEngine.get(childRun._id);
+							await this.resume(runId, {
+								__childFailed: true,
+								error: failedChild?.error
+							});
+						} catch {}
+						this.container.eventBus.off("workflow:completed", childCompletionHandler);
+						this.container.eventBus.off("workflow:failed", childFailHandler);
+					};
+					this.container.eventBus.on("workflow:completed", childCompletionHandler);
+					this.container.eventBus.on("workflow:failed", childFailHandler);
+				} else this.container.eventBus.emit("engine:error", {
+					runId,
+					error: /* @__PURE__ */ new Error(`Child workflow '${data.childWorkflowId}' not registered. Ensure the child workflow is created with createWorkflow() before the parent starts. Or resume the parent manually when the child completes.`),
+					context: "child-workflow-not-found"
+				});
+			}
+			return false;
+		}
 		return false;
 	}
 	findCurrentStep(run) {
@@ -1684,6 +1740,28 @@ var WorkflowEngine = class {
 			listener,
 			eventName
 		});
+		const signalUnsub = this.container.signalStore.subscribe(`streamline:event:${eventName}`, (data) => {
+			const signalPayload = data;
+			if (!signalPayload || signalPayload.runId === runId || signalPayload.broadcast) listener(signalPayload);
+		});
+		const signalKey = `signal:${listenerKey}`;
+		const currentEntry = this.eventListeners.get(listenerKey);
+		if (currentEntry) {
+			const origListener = currentEntry.listener;
+			this.eventListeners.set(listenerKey, {
+				...currentEntry,
+				listener: ((...args) => {
+					origListener(...args);
+				})
+			});
+			this.eventListeners.set(signalKey, {
+				listener: (() => {
+					if (typeof signalUnsub === "function") signalUnsub();
+					else if (signalUnsub instanceof Promise) signalUnsub.then((fn) => fn());
+				}),
+				eventName: signalKey
+			});
+		}
 	}
 	/**
 	* Handle retry backoff wait with inline execution for short delays
@@ -1716,9 +1794,15 @@ var WorkflowEngine = class {
 	async resume(runId, payload) {
 		const run = await this.getOrThrow(runId);
 		if (run.paused) {
+			if ((await this.container.repository.updateOne({
+				_id: runId,
+				paused: true
+			}, { $set: {
+				paused: false,
+				updatedAt: /* @__PURE__ */ new Date()
+			} }, { bypassTenant: true })).modifiedCount === 0) return await this.getOrThrow(runId);
 			run.paused = false;
 			run.updatedAt = /* @__PURE__ */ new Date();
-			await this.container.repository.update(runId, run, { bypassTenant: true });
 			this.container.cache.set(run);
 		}
 		if (run.status === "waiting") return this.resumeWaitingWorkflow(run, payload);
@@ -1757,6 +1841,15 @@ var WorkflowEngine = class {
 			updatedAt: /* @__PURE__ */ new Date()
 		}, { bypassTenant: true })).modifiedCount === 0) return null;
 		this.container.cache.delete(runId);
+		const run = await this.get(runId);
+		if (run?.currentStepId) {
+			const stepIndex = run.steps.findIndex((s) => s.stepId === run.currentStepId);
+			if (stepIndex !== -1 && run.steps[stepIndex]?.status === "running") await this.container.repository.updateOne({ _id: runId }, { $set: {
+				[`steps.${stepIndex}.status`]: "pending",
+				[`steps.${stepIndex}.startedAt`]: void 0
+			} }, { bypassTenant: true });
+		}
+		this.container.cache.delete(runId);
 		this.container.eventBus.emit("workflow:recovered", { runId });
 		return this.execute(runId);
 	}
@@ -2135,7 +2228,11 @@ const WorkflowRunSchema = new Schema({
 	meta: Schema.Types.Mixed
 }, {
 	collection: "workflow_runs",
-	timestamps: false
+	timestamps: false,
+	writeConcern: {
+		w: "majority",
+		j: true
+	}
 });
 WorkflowRunSchema.index({
 	workflowId: 1,
@@ -2169,6 +2266,18 @@ WorkflowRunSchema.index({
 	"scheduling.executionTime": 1,
 	paused: 1
 });
+WorkflowRunSchema.index({
+	status: 1,
+	paused: 1,
+	updatedAt: -1,
+	_id: -1
+});
+WorkflowRunSchema.index({
+	status: 1,
+	paused: 1,
+	updatedAt: 1,
+	_id: 1
+});
 /**
 * MULTI-TENANCY & SCHEDULED WORKFLOWS - COMPOSITE INDEXES
 *
@@ -2637,6 +2746,24 @@ const workflowRunRepository = createWorkflowRepository();
 * All shared dependencies are passed through this container.
 */
 /**
+* Default in-memory signal store (process-local).
+* Sufficient for single-worker deployments and testing.
+*/
+var InMemorySignalStore = class {
+	listeners = /* @__PURE__ */ new Map();
+	publish(channel, data) {
+		const handlers = this.listeners.get(channel);
+		if (handlers) for (const handler of handlers) handler(data);
+	}
+	subscribe(channel, handler) {
+		if (!this.listeners.has(channel)) this.listeners.set(channel, /* @__PURE__ */ new Set());
+		this.listeners.get(channel).add(handler);
+		return () => {
+			this.listeners.get(channel)?.delete(handler);
+		};
+	}
+};
+/**
 * Create a new container with configurable dependencies.
 *
 * @param options - Optional configuration for container dependencies
@@ -2678,10 +2805,12 @@ function createContainer(options = {}) {
 	else if (options.eventBus instanceof WorkflowEventBus) eventBus = options.eventBus;
 	else eventBus = new WorkflowEventBus();
 	const cache = options.cache ?? new WorkflowCache();
+	const signalStore = options.signalStore ?? new InMemorySignalStore();
 	return {
 		repository,
 		eventBus,
-		cache
+		cache,
+		signalStore
 	};
 }
 /**
@@ -2694,4 +2823,4 @@ function isStreamlineContainer(obj) {
 }
 
 //#endregion
-export { isValidStepTransition as A, RUN_STATUS_VALUES as C, isStepStatus as D, isRunStatus as E, logger as M, isTerminalState as O, shouldSkipStep as S, deriveRunStatus as T, COMPUTED as _, singleTenantPlugin as a, createCondition as b, RUN_STATUS as c, WorkflowRunModel as d, WorkflowCache as f, validateRetryConfig as g, validateId as h, workflowRunRepository as i, WaitSignal as j, isValidRunTransition as k, STEP_STATUS as l, hookRegistry as m, isStreamlineContainer as n, tenantFilterPlugin as o, WorkflowEngine as p, createWorkflowRepository as r, CommonQueries as s, createContainer as t, WorkflowQueryBuilder as u, SCHEDULING as v, STEP_STATUS_VALUES as w, isConditionalStep as x, conditions as y };
+export { isValidRunTransition as A, shouldSkipStep as C, isRunStatus as D, deriveRunStatus as E, isStepStatus as O, isConditionalStep as S, STEP_STATUS_VALUES as T, validateRetryConfig as _, singleTenantPlugin as a, conditions as b, RUN_STATUS as c, WorkflowRunModel as d, WorkflowCache as f, validateId as g, workflowRegistry as h, workflowRunRepository as i, isValidStepTransition as j, isTerminalState as k, STEP_STATUS as l, hookRegistry as m, isStreamlineContainer as n, tenantFilterPlugin as o, WorkflowEngine as p, createWorkflowRepository as r, CommonQueries as s, createContainer as t, WorkflowQueryBuilder as u, COMPUTED as v, RUN_STATUS_VALUES as w, createCondition as x, SCHEDULING as y };