@moostjs/event-wf 0.6.4 → 0.6.6

package/dist/index.cjs

@@ -24,6 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 const __wooksjs_event_wf = __toESM(require("@wooksjs/event-wf"));
 const moost = __toESM(require("moost"));
 const __prostojs_wf = __toESM(require("@prostojs/wf"));
+const node_crypto = __toESM(require("node:crypto"));
 
 //#region packages/event-wf/src/meta-types.ts
 function getWfMate() {
@@ -76,6 +77,24 @@ function getWfMate() {
 	return getWfMate().decorate("wfSchema", schema);
 }
 /**
+* Sets TTL (in ms) for the workflow state when this step pauses.
+* The adapter wraps the step handler to set `expires` on the outlet signal,
+* which is then passed to `strategy.persist(state, { ttl })`.
+*
+* @param ttlMs - Time-to-live in milliseconds for the paused state token.
+*
+* @example
+* ```ts
+* @Step('send-invite')
+* @StepTTL(60 * 60 * 1000) // 1 hour
+* async sendInvite(@WorkflowParam('context') ctx: any) {
+*   return outletEmail(ctx.email, 'invite')
+* }
+* ```
+*/ function StepTTL(ttlMs) {
+	return getWfMate().decorate("wfStepTTL", ttlMs);
+}
+/**
 * Parameter decorator that resolves a workflow context value into a step handler argument.
 *
 * @param name - The workflow value to resolve:
@@ -160,6 +179,23 @@ const CONTEXT_TYPE = "WF";
 		this.wfApp.detachSpy(fn);
 	}
 	/**
+	* Handles an outlet trigger request within an HTTP handler.
+	*
+	* Reads `wfid` (workflow ID) and `wfs` (state token) from the HTTP request,
+	* starts or resumes the workflow, and dispatches pauses to registered outlets.
+	*
+	* Must be called from within an HTTP event context (e.g. a `@Post` handler)
+	* so that wooks HTTP composables are available.
+	*
+	* @param config - Outlet trigger configuration (allowed workflows, state strategy, outlets, etc.)
+	* @returns The outlet result (form payload + token), finished response, or error.
+	*/ handleOutlet(config) {
+		return (0, __wooksjs_event_wf.handleWfOutletRequest)(config, {
+			start: (schemaId, context, opts) => this.start(schemaId, context, opts?.input),
+			resume: (state, opts) => this.resume(state, opts?.input)
+		});
+	}
+	/**
 	* Starts a new workflow execution.
 	*
 	* @param schemaId - Identifier of the registered workflow schema.
@@ -203,17 +239,31 @@ const CONTEXT_TYPE = "WF";
 				resolveArgs: opts.resolveArgs,
 				manualUnscope: true,
 				targetPath,
+				controllerPrefix: opts.prefix,
 				handlerType: handler.type
 			});
 			if (handler.type === "WF_STEP") {
-				this.wfApp.step(targetPath, { handler: fn });
+				const stepTTL = getWfMate().read(opts.fakeInstance, opts.method)?.wfStepTTL;
+				let stepHandler = fn;
+				if (stepTTL !== void 0) {
+					const wrapped = stepHandler;
+					stepHandler = async () => {
+						const result = await wrapped();
+						if (result && typeof result === "object" && "inputRequired" in result) return {
+							...result,
+							expires: Date.now() + stepTTL
+						};
+						return result;
+					};
+				}
+				this.wfApp.step(targetPath, { handler: stepHandler });
 				opts.logHandler(`(${handler.type})${targetPath}`);
 			} else {
 				const mate = getWfMate();
 				let wfSchema = mate.read(opts.fakeInstance, opts.method)?.wfSchema;
 				if (!wfSchema) wfSchema = mate.read(opts.fakeInstance)?.wfSchema;
 				const _fn = async () => {
-					(0, moost.setControllerContext)(this.moost, "bindHandler", targetPath);
+					(0, moost.setControllerContext)(this.moost, "bindHandler", targetPath, { prefix: opts.prefix });
 					return fn();
 				};
 				this.toInit.push(() => {
@@ -241,6 +291,185 @@ const CONTEXT_TYPE = "WF";
 };
 
 //#endregion
+//#region node_modules/.pnpm/@prostojs+wf@0.1.1/node_modules/@prostojs/wf/dist/outlets/index.mjs
+/**
+* Generic outlet request. Use for custom outlets.
+*
+* @example
+* return outlet('pending-task', {
+*   payload: ApprovalForm,
+*   target: managerId,
+*   context: { orderId, amount },
+* })
+*/
+function outlet(name, data) {
+	return { inputRequired: {
+		outlet: name,
+		...data
+	} };
+}
+/**
+* Pause for HTTP form input. The outlet returns the payload (form definition)
+* and state token in the HTTP response.
+*
+* @example
+* return outletHttp(LoginForm)
+* return outletHttp(LoginForm, { error: 'Invalid credentials' })
+*/
+function outletHttp(payload, context) {
+	return outlet("http", {
+		payload,
+		context
+	});
+}
+/**
+* Pause and send email with a magic link containing the state token.
+*
+* @example
+* return outletEmail('user@test.com', 'invite', { name: 'Alice' })
+*/
+function outletEmail(target, template, context) {
+	return outlet("email", {
+		target,
+		template,
+		context
+	});
+}
+/**
+* Self-contained AES-256-GCM encrypted state strategy.
+*
+* Workflow state is encrypted into a base64url token that travels with the
+* transport (cookie, URL param, hidden field). No server-side storage needed.
+*
+* Token format: `base64url(iv[12] + authTag[16] + ciphertext)`
+*
+* @example
+* const strategy = new EncapsulatedStateStrategy({
+*     secret: crypto.randomBytes(32),
+*     defaultTtl: 3600_000, // 1 hour
+* });
+* const token = await strategy.persist(state);
+* const recovered = await strategy.retrieve(token);
+*/
+var EncapsulatedStateStrategy = class {
+	/** @throws if secret is not exactly 32 bytes */
+	constructor(config) {
+		this.config = config;
+		this.key = typeof config.secret === "string" ? Buffer.from(config.secret, "hex") : config.secret;
+		if (this.key.length !== 32) throw new Error("EncapsulatedStateStrategy: secret must be exactly 32 bytes");
+	}
+	/**
+	* Encrypt workflow state into a self-contained token.
+	* @param state — workflow state to persist
+	* @param options.ttl — time-to-live in ms (overrides defaultTtl)
+	* @returns base64url-encoded encrypted token
+	*/
+	async persist(state, options) {
+		const ttl = options?.ttl ?? this.config.defaultTtl ?? 0;
+		const exp = ttl > 0 ? Date.now() + ttl : 0;
+		const payload = JSON.stringify({
+			s: state,
+			e: exp
+		});
+		const iv = (0, node_crypto.randomBytes)(12);
+		const cipher = (0, node_crypto.createCipheriv)("aes-256-gcm", this.key, iv);
+		const encrypted = Buffer.concat([cipher.update(payload, "utf8"), cipher.final()]);
+		const tag = cipher.getAuthTag();
+		return Buffer.concat([
+			iv,
+			tag,
+			encrypted
+		]).toString("base64url");
+	}
+	/** Decrypt and return workflow state. Returns null if token is invalid, expired, or tampered. */
+	async retrieve(token) {
+		return this.decrypt(token);
+	}
+	/** Same as retrieve (stateless — cannot truly invalidate a token). */
+	async consume(token) {
+		return this.decrypt(token);
+	}
+	decrypt(token) {
+		try {
+			const buf = Buffer.from(token, "base64url");
+			if (buf.length < 28) return null;
+			const iv = buf.subarray(0, 12);
+			const tag = buf.subarray(12, 28);
+			const ciphertext = buf.subarray(28);
+			const decipher = (0, node_crypto.createDecipheriv)("aes-256-gcm", this.key, iv);
+			decipher.setAuthTag(tag);
+			const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+			const { s: state, e: exp } = JSON.parse(decrypted.toString("utf8"));
+			if (exp > 0 && Date.now() > exp) return null;
+			return state;
+		} catch {
+			return null;
+		}
+	}
+};
+var HandleStateStrategy = class {
+	constructor(config) {
+		this.config = config;
+	}
+	async persist(state, options) {
+		const handle = (this.config.generateHandle ?? node_crypto.randomUUID)();
+		const ttl = options?.ttl ?? this.config.defaultTtl ?? 0;
+		const expiresAt = ttl > 0 ? Date.now() + ttl : void 0;
+		await this.config.store.set(handle, state, expiresAt);
+		return handle;
+	}
+	async retrieve(token) {
+		return (await this.config.store.get(token))?.state ?? null;
+	}
+	async consume(token) {
+		return (await this.config.store.getAndDelete(token))?.state ?? null;
+	}
+};
+/**
+* In-memory state store for development and testing.
+* State is lost on process restart.
+*/
+var WfStateStoreMemory = class {
+	constructor() {
+		this.store = /* @__PURE__ */ new Map();
+	}
+	async set(handle, state, expiresAt) {
+		this.store.set(handle, {
+			state,
+			expiresAt
+		});
+	}
+	async get(handle) {
+		const entry = this.store.get(handle);
+		if (!entry) return null;
+		if (entry.expiresAt && Date.now() > entry.expiresAt) {
+			this.store.delete(handle);
+			return null;
+		}
+		return entry;
+	}
+	async delete(handle) {
+		this.store.delete(handle);
+	}
+	async getAndDelete(handle) {
+		const entry = await this.get(handle);
+		if (entry) this.store.delete(handle);
+		return entry;
+	}
+	async cleanup() {
+		const now = Date.now();
+		let count = 0;
+		for (const [handle, entry] of this.store) if (entry.expiresAt && now > entry.expiresAt) {
+			this.store.delete(handle);
+			count++;
+		}
+		return count;
+	}
+};
+
+//#endregion
+exports.EncapsulatedStateStrategy = EncapsulatedStateStrategy;
+exports.HandleStateStrategy = HandleStateStrategy;
 exports.MoostWf = MoostWf;
 exports.Step = Step;
 Object.defineProperty(exports, 'StepRetriableError', {
@@ -249,9 +478,50 @@ Object.defineProperty(exports, 'StepRetriableError', {
     return __prostojs_wf.StepRetriableError;
   }
 });
+exports.StepTTL = StepTTL;
+exports.WfStateStoreMemory = WfStateStoreMemory;
 exports.Workflow = Workflow;
 exports.WorkflowParam = WorkflowParam;
 exports.WorkflowSchema = WorkflowSchema;
+Object.defineProperty(exports, 'createEmailOutlet', {
+  enumerable: true,
+  get: function () {
+    return __wooksjs_event_wf.createEmailOutlet;
+  }
+});
+Object.defineProperty(exports, 'createHttpOutlet', {
+  enumerable: true,
+  get: function () {
+    return __wooksjs_event_wf.createHttpOutlet;
+  }
+});
+Object.defineProperty(exports, 'createOutletHandler', {
+  enumerable: true,
+  get: function () {
+    return __wooksjs_event_wf.createOutletHandler;
+  }
+});
+Object.defineProperty(exports, 'handleWfOutletRequest', {
+  enumerable: true,
+  get: function () {
+    return __wooksjs_event_wf.handleWfOutletRequest;
+  }
+});
+exports.outlet = outlet;
+exports.outletEmail = outletEmail;
+exports.outletHttp = outletHttp;
+Object.defineProperty(exports, 'useWfFinished', {
+  enumerable: true,
+  get: function () {
+    return __wooksjs_event_wf.useWfFinished;
+  }
+});
+Object.defineProperty(exports, 'useWfOutlet', {
+  enumerable: true,
+  get: function () {
+    return __wooksjs_event_wf.useWfOutlet;
+  }
+});
 Object.defineProperty(exports, 'useWfState', {
   enumerable: true,
   get: function () {

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 import { TWorkflowSchema, TWorkflowSpy, TFlowOutput } from '@prostojs/wf';
 export { StepRetriableError, TFlowOutput, TWorkflowSchema } from '@prostojs/wf';
-import { WooksWf, TWooksWfOptions } from '@wooksjs/event-wf';
-export { useWfState, wfKind } from '@wooksjs/event-wf';
+import { WooksWf, TWooksWfOptions, WfOutletTriggerConfig } from '@wooksjs/event-wf';
+export { WfFinishedResponse, WfOutletTokenConfig, WfOutletTriggerConfig, WfOutletTriggerDeps, createEmailOutlet, createHttpOutlet, createOutletHandler, handleWfOutletRequest, useWfFinished, useWfOutlet, useWfState, wfKind } from '@wooksjs/event-wf';
 import { TMoostAdapter, Moost, TMoostAdapterOptions } from 'moost';
+export { EncapsulatedStateStrategy, HandleStateStrategy, WfOutlet, WfOutletRequest, WfOutletResult, WfState, WfStateStore, WfStateStoreMemory, WfStateStrategy, outlet, outletEmail, outletHttp } from '@prostojs/wf/outlets';
 
 /**
  * Registers a method as a workflow step handler.
@@ -38,6 +39,23 @@ declare function Workflow(path?: string): MethodDecorator;
  * @param schema - Array of step definitions composing the workflow.
  */
 declare function WorkflowSchema<T>(schema: TWorkflowSchema<T>): MethodDecorator;
+/**
+ * Sets TTL (in ms) for the workflow state when this step pauses.
+ * The adapter wraps the step handler to set `expires` on the outlet signal,
+ * which is then passed to `strategy.persist(state, { ttl })`.
+ *
+ * @param ttlMs - Time-to-live in milliseconds for the paused state token.
+ *
+ * @example
+ * ```ts
+ * @Step('send-invite')
+ * @StepTTL(60 * 60 * 1000) // 1 hour
+ * async sendInvite(@WorkflowParam('context') ctx: any) {
+ *   return outletEmail(ctx.email, 'invite')
+ * }
+ * ```
+ */
+declare function StepTTL(ttlMs: number): MethodDecorator;
 /**
  * Parameter decorator that resolves a workflow context value into a step handler argument.
  *
@@ -92,6 +110,19 @@ declare class MoostWf<T = any, IR = any> implements TMoostAdapter<TWfHandlerMeta
     attachSpy<I>(fn: TWorkflowSpy<T, I, IR>): () => void;
     /** Detaches a previously attached workflow spy. */
     detachSpy<I>(fn: TWorkflowSpy<T, I, IR>): void;
+    /**
+     * Handles an outlet trigger request within an HTTP handler.
+     *
+     * Reads `wfid` (workflow ID) and `wfs` (state token) from the HTTP request,
+     * starts or resumes the workflow, and dispatches pauses to registered outlets.
+     *
+     * Must be called from within an HTTP event context (e.g. a `@Post` handler)
+     * so that wooks HTTP composables are available.
+     *
+     * @param config - Outlet trigger configuration (allowed workflows, state strategy, outlets, etc.)
+     * @returns The outlet result (form payload + token), finished response, or error.
+     */
+    handleOutlet(config: WfOutletTriggerConfig): Promise<unknown>;
     /**
      * Starts a new workflow execution.
      *
@@ -114,5 +145,5 @@ declare class MoostWf<T = any, IR = any> implements TMoostAdapter<TWfHandlerMeta
     bindHandler<T extends object = object>(opts: TMoostAdapterOptions<TWfHandlerMeta, T>): void;
 }
 
-export { MoostWf, Step, Workflow, WorkflowParam, WorkflowSchema };
+export { MoostWf, Step, StepTTL, Workflow, WorkflowParam, WorkflowSchema };
 export type { TWfHandlerMeta };

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { WooksWf, createWfApp, useWfState, useWfState as useWfState$1, wfKind } from "@wooksjs/event-wf";
+import { WooksWf, createEmailOutlet, createHttpOutlet, createOutletHandler, createWfApp, handleWfOutletRequest, handleWfOutletRequest as handleWfOutletRequest$1, useWfFinished, useWfOutlet, useWfState, useWfState as useWfState$1, wfKind } from "@wooksjs/event-wf";
 import { Resolve, defineMoostEventHandler, getMoostInfact, getMoostMate, setControllerContext, useScopeId } from "moost";
 import { StepRetriableError } from "@prostojs/wf";
+import { createCipheriv, createDecipheriv, randomBytes, randomUUID } from "node:crypto";
 
 //#region packages/event-wf/src/meta-types.ts
 function getWfMate() {
@@ -53,6 +54,24 @@ function getWfMate() {
 	return getWfMate().decorate("wfSchema", schema);
 }
 /**
+* Sets TTL (in ms) for the workflow state when this step pauses.
+* The adapter wraps the step handler to set `expires` on the outlet signal,
+* which is then passed to `strategy.persist(state, { ttl })`.
+*
+* @param ttlMs - Time-to-live in milliseconds for the paused state token.
+*
+* @example
+* ```ts
+* @Step('send-invite')
+* @StepTTL(60 * 60 * 1000) // 1 hour
+* async sendInvite(@WorkflowParam('context') ctx: any) {
+*   return outletEmail(ctx.email, 'invite')
+* }
+* ```
+*/ function StepTTL(ttlMs) {
+	return getWfMate().decorate("wfStepTTL", ttlMs);
+}
+/**
 * Parameter decorator that resolves a workflow context value into a step handler argument.
 *
 * @param name - The workflow value to resolve:
@@ -137,6 +156,23 @@ const CONTEXT_TYPE = "WF";
 		this.wfApp.detachSpy(fn);
 	}
 	/**
+	* Handles an outlet trigger request within an HTTP handler.
+	*
+	* Reads `wfid` (workflow ID) and `wfs` (state token) from the HTTP request,
+	* starts or resumes the workflow, and dispatches pauses to registered outlets.
+	*
+	* Must be called from within an HTTP event context (e.g. a `@Post` handler)
+	* so that wooks HTTP composables are available.
+	*
+	* @param config - Outlet trigger configuration (allowed workflows, state strategy, outlets, etc.)
+	* @returns The outlet result (form payload + token), finished response, or error.
+	*/ handleOutlet(config) {
+		return handleWfOutletRequest$1(config, {
+			start: (schemaId, context, opts) => this.start(schemaId, context, opts?.input),
+			resume: (state, opts) => this.resume(state, opts?.input)
+		});
+	}
+	/**
 	* Starts a new workflow execution.
 	*
 	* @param schemaId - Identifier of the registered workflow schema.
@@ -180,17 +216,31 @@ const CONTEXT_TYPE = "WF";
 				resolveArgs: opts.resolveArgs,
 				manualUnscope: true,
 				targetPath,
+				controllerPrefix: opts.prefix,
 				handlerType: handler.type
 			});
 			if (handler.type === "WF_STEP") {
-				this.wfApp.step(targetPath, { handler: fn });
+				const stepTTL = getWfMate().read(opts.fakeInstance, opts.method)?.wfStepTTL;
+				let stepHandler = fn;
+				if (stepTTL !== void 0) {
+					const wrapped = stepHandler;
+					stepHandler = async () => {
+						const result = await wrapped();
+						if (result && typeof result === "object" && "inputRequired" in result) return {
+							...result,
+							expires: Date.now() + stepTTL
+						};
+						return result;
+					};
+				}
+				this.wfApp.step(targetPath, { handler: stepHandler });
 				opts.logHandler(`(${handler.type})${targetPath}`);
 			} else {
 				const mate = getWfMate();
 				let wfSchema = mate.read(opts.fakeInstance, opts.method)?.wfSchema;
 				if (!wfSchema) wfSchema = mate.read(opts.fakeInstance)?.wfSchema;
 				const _fn = async () => {
-					setControllerContext(this.moost, "bindHandler", targetPath);
+					setControllerContext(this.moost, "bindHandler", targetPath, { prefix: opts.prefix });
 					return fn();
 				};
 				this.toInit.push(() => {
@@ -218,4 +268,181 @@ const CONTEXT_TYPE = "WF";
 };
 
 //#endregion
-export { MoostWf, Step, StepRetriableError, Workflow, WorkflowParam, WorkflowSchema, useWfState, wfKind };
+//#region node_modules/.pnpm/@prostojs+wf@0.1.1/node_modules/@prostojs/wf/dist/outlets/index.mjs
+/**
+* Generic outlet request. Use for custom outlets.
+*
+* @example
+* return outlet('pending-task', {
+*   payload: ApprovalForm,
+*   target: managerId,
+*   context: { orderId, amount },
+* })
+*/
+function outlet(name, data) {
+	return { inputRequired: {
+		outlet: name,
+		...data
+	} };
+}
+/**
+* Pause for HTTP form input. The outlet returns the payload (form definition)
+* and state token in the HTTP response.
+*
+* @example
+* return outletHttp(LoginForm)
+* return outletHttp(LoginForm, { error: 'Invalid credentials' })
+*/
+function outletHttp(payload, context) {
+	return outlet("http", {
+		payload,
+		context
+	});
+}
+/**
+* Pause and send email with a magic link containing the state token.
+*
+* @example
+* return outletEmail('user@test.com', 'invite', { name: 'Alice' })
+*/
+function outletEmail(target, template, context) {
+	return outlet("email", {
+		target,
+		template,
+		context
+	});
+}
+/**
+* Self-contained AES-256-GCM encrypted state strategy.
+*
+* Workflow state is encrypted into a base64url token that travels with the
+* transport (cookie, URL param, hidden field). No server-side storage needed.
+*
+* Token format: `base64url(iv[12] + authTag[16] + ciphertext)`
+*
+* @example
+* const strategy = new EncapsulatedStateStrategy({
+*     secret: crypto.randomBytes(32),
+*     defaultTtl: 3600_000, // 1 hour
+* });
+* const token = await strategy.persist(state);
+* const recovered = await strategy.retrieve(token);
+*/
+var EncapsulatedStateStrategy = class {
+	/** @throws if secret is not exactly 32 bytes */
+	constructor(config) {
+		this.config = config;
+		this.key = typeof config.secret === "string" ? Buffer.from(config.secret, "hex") : config.secret;
+		if (this.key.length !== 32) throw new Error("EncapsulatedStateStrategy: secret must be exactly 32 bytes");
+	}
+	/**
+	* Encrypt workflow state into a self-contained token.
+	* @param state — workflow state to persist
+	* @param options.ttl — time-to-live in ms (overrides defaultTtl)
+	* @returns base64url-encoded encrypted token
+	*/
+	async persist(state, options) {
+		const ttl = options?.ttl ?? this.config.defaultTtl ?? 0;
+		const exp = ttl > 0 ? Date.now() + ttl : 0;
+		const payload = JSON.stringify({
+			s: state,
+			e: exp
+		});
+		const iv = randomBytes(12);
+		const cipher = createCipheriv("aes-256-gcm", this.key, iv);
+		const encrypted = Buffer.concat([cipher.update(payload, "utf8"), cipher.final()]);
+		const tag = cipher.getAuthTag();
+		return Buffer.concat([
+			iv,
+			tag,
+			encrypted
+		]).toString("base64url");
+	}
+	/** Decrypt and return workflow state. Returns null if token is invalid, expired, or tampered. */
+	async retrieve(token) {
+		return this.decrypt(token);
+	}
+	/** Same as retrieve (stateless — cannot truly invalidate a token). */
+	async consume(token) {
+		return this.decrypt(token);
+	}
+	decrypt(token) {
+		try {
+			const buf = Buffer.from(token, "base64url");
+			if (buf.length < 28) return null;
+			const iv = buf.subarray(0, 12);
+			const tag = buf.subarray(12, 28);
+			const ciphertext = buf.subarray(28);
+			const decipher = createDecipheriv("aes-256-gcm", this.key, iv);
+			decipher.setAuthTag(tag);
+			const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+			const { s: state, e: exp } = JSON.parse(decrypted.toString("utf8"));
+			if (exp > 0 && Date.now() > exp) return null;
+			return state;
+		} catch {
+			return null;
+		}
+	}
+};
+var HandleStateStrategy = class {
+	constructor(config) {
+		this.config = config;
+	}
+	async persist(state, options) {
+		const handle = (this.config.generateHandle ?? randomUUID)();
+		const ttl = options?.ttl ?? this.config.defaultTtl ?? 0;
+		const expiresAt = ttl > 0 ? Date.now() + ttl : void 0;
+		await this.config.store.set(handle, state, expiresAt);
+		return handle;
+	}
+	async retrieve(token) {
+		return (await this.config.store.get(token))?.state ?? null;
+	}
+	async consume(token) {
+		return (await this.config.store.getAndDelete(token))?.state ?? null;
+	}
+};
+/**
+* In-memory state store for development and testing.
+* State is lost on process restart.
+*/
+var WfStateStoreMemory = class {
+	constructor() {
+		this.store = /* @__PURE__ */ new Map();
+	}
+	async set(handle, state, expiresAt) {
+		this.store.set(handle, {
+			state,
+			expiresAt
+		});
+	}
+	async get(handle) {
+		const entry = this.store.get(handle);
+		if (!entry) return null;
+		if (entry.expiresAt && Date.now() > entry.expiresAt) {
+			this.store.delete(handle);
+			return null;
+		}
+		return entry;
+	}
+	async delete(handle) {
+		this.store.delete(handle);
+	}
+	async getAndDelete(handle) {
+		const entry = await this.get(handle);
+		if (entry) this.store.delete(handle);
+		return entry;
+	}
+	async cleanup() {
+		const now = Date.now();
+		let count = 0;
+		for (const [handle, entry] of this.store) if (entry.expiresAt && now > entry.expiresAt) {
+			this.store.delete(handle);
+			count++;
+		}
+		return count;
+	}
+};
+
+//#endregion
+export { EncapsulatedStateStrategy, HandleStateStrategy, MoostWf, Step, StepRetriableError, StepTTL, WfStateStoreMemory, Workflow, WorkflowParam, WorkflowSchema, createEmailOutlet, createHttpOutlet, createOutletHandler, handleWfOutletRequest, outlet, outletEmail, outletHttp, useWfFinished, useWfOutlet, useWfState, wfKind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moostjs/event-wf",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "@moostjs/event-wf",
   "keywords": [
     "composables",
@@ -43,8 +43,8 @@
     }
   },
   "dependencies": {
-    "@prostojs/wf": "^0.0.18",
-    "@wooksjs/event-wf": "^0.7.7"
+    "@prostojs/wf": "^0.1.1",
+    "@wooksjs/event-wf": "^0.7.8"
   },
   "devDependencies": {
     "vitest": "3.2.4"
@@ -52,9 +52,9 @@
   "peerDependencies": {
     "@prostojs/infact": "^0.4.1",
     "@prostojs/mate": "^0.4.0",
-    "@wooksjs/event-core": "^0.7.7",
-    "wooks": "^0.7.7",
-    "moost": "^0.6.4"
+    "@wooksjs/event-core": "^0.7.8",
+    "wooks": "^0.7.8",
+    "moost": "^0.6.6"
   },
   "scripts": {
     "pub": "pnpm publish --access public",