@wooksjs/event-wf 0.7.2 → 0.7.3

package/dist/index.cjs

@@ -60,40 +60,16 @@ function useWfState() {
 
 //#endregion
 //#region packages/event-wf/src/event-wf.ts
-const wfSeeds = (data) => ({
-	schemaId: data.schemaId,
-	stepId: data.stepId,
-	inputContext: data.inputContext,
-	indexes: data.indexes,
-	input: data.input
-});
-/**
-* Creates a new event context for a fresh workflow execution.
-* When `parentCtx` is provided, the workflow creates a child context
-* linked to the parent, so step handlers can transparently access
-* composables from the parent scope (e.g. HTTP) via the parent chain.
-*/
-function createWfContext(data, options, parentCtx) {
-	const ctxOptions = parentCtx ? {
-		...options,
-		parent: parentCtx
-	} : options;
-	return (fn) => (0, __wooksjs_event_core.createEventContext)(ctxOptions, wfKind, wfSeeds(data), () => {
+/** Creates a WF event context for a fresh workflow execution and runs `fn` inside it. */
+function createWfContext(options, seeds, fn) {
+	return (0, __wooksjs_event_core.createEventContext)(options, wfKind, seeds, () => {
 		(0, __wooksjs_event_core.current)().set(resumeKey, false);
 		return fn();
 	});
 }
-/**
-* Creates an event context for resuming a paused workflow.
-* When `parentCtx` is provided, the workflow creates a child context
-* linked to the parent.
-*/
-function resumeWfContext(data, options, parentCtx) {
-	const ctxOptions = parentCtx ? {
-		...options,
-		parent: parentCtx
-	} : options;
-	return (fn) => (0, __wooksjs_event_core.createEventContext)(ctxOptions, wfKind, wfSeeds(data), () => {
+/** Creates a WF event context for resuming a paused workflow and runs `fn` inside it. */
+function resumeWfContext(options, seeds, fn) {
+	return (0, __wooksjs_event_core.createEventContext)(options, wfKind, seeds, () => {
 		(0, __wooksjs_event_core.current)().set(resumeKey, true);
 		return fn();
 	});
@@ -136,11 +112,13 @@ const wfShortcuts = {
 var WooksWf = class extends wooks.WooksAdapterBase {
 	logger;
 	wf;
+	eventContextOptions;
 	constructor(opts, wooks$1) {
 		super(wooks$1, opts?.logger, opts?.router);
 		this.opts = opts;
 		this.logger = opts?.logger || this.getLogger(`[wooks-wf]`);
 		this.wf = new WooksWorkflow(this.wooks);
+		this.eventContextOptions = this.getEventContextOptions();
 	}
 	/** Attaches a spy function to observe workflow step execution. */
 	attachSpy(fn) {
@@ -198,14 +176,19 @@ var WooksWf = class extends wooks.WooksAdapterBase {
 	async _start(schemaId, inputContext, indexes, opts, parentCtx) {
 		const { input, spy, cleanup } = opts ?? {};
 		const resume = !!indexes?.length;
-		const runInContext = (resume ? resumeWfContext : createWfContext)({
+		const factory = resume ? resumeWfContext : createWfContext;
+		const ctxOptions = parentCtx ? {
+			...this.eventContextOptions,
+			parent: parentCtx
+		} : this.eventContextOptions;
+		const seeds = {
 			inputContext,
 			schemaId,
 			stepId: null,
 			indexes,
 			input
-		}, this.getEventContextOptions(), parentCtx);
-		return runInContext(async () => {
+		};
+		return factory(ctxOptions, seeds, async () => {
 			const { handlers: foundHandlers } = this.wooks.lookup("WF_FLOW", `/${schemaId}`.replace(/^\/+/u, "/"));
 			const handlers = foundHandlers || this.opts?.onNotFound && [this.opts.onNotFound] || null;
 			if (handlers && handlers.length > 0) {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _wooksjs_event_core from '@wooksjs/event-core';
-import { EventContextOptions, EventContext } from '@wooksjs/event-core';
+import { EventContextOptions, EventKindSeeds, EventContext } from '@wooksjs/event-core';
 export { EventContext, EventContextOptions, useLogger, useRouteParams } from '@wooksjs/event-core';
 import * as wooks from 'wooks';
 import { Wooks, TWooksHandler, TWooksOptions, WooksAdapterBase } from 'wooks';
@@ -25,6 +25,20 @@ declare function useWfState(): {
     resume: boolean;
 };
 
+declare const wfKind: _wooksjs_event_core.EventKind<{
+    schemaId: _wooksjs_event_core.SlotMarker<string>;
+    stepId: _wooksjs_event_core.SlotMarker<string | null>;
+    inputContext: _wooksjs_event_core.SlotMarker<unknown>;
+    indexes: _wooksjs_event_core.SlotMarker<number[] | undefined>;
+    input: _wooksjs_event_core.SlotMarker<unknown>;
+}>;
+declare const resumeKey: _wooksjs_event_core.Key<boolean>;
+
+/** Creates a WF event context for a fresh workflow execution and runs `fn` inside it. */
+declare function createWfContext<R>(options: EventContextOptions, seeds: EventKindSeeds<typeof wfKind>, fn: () => R): R;
+/** Creates a WF event context for resuming a paused workflow and runs `fn` inside it. */
+declare function resumeWfContext<R>(options: EventContextOptions, seeds: EventKindSeeds<typeof wfKind>, fn: () => R): R;
+
 /** Input data for creating a workflow event context. */
 interface TWFEventInput {
     schemaId: string;
@@ -34,20 +48,6 @@ interface TWFEventInput {
     input?: unknown;
 }
 
-/**
- * Creates a new event context for a fresh workflow execution.
- * When `parentCtx` is provided, the workflow creates a child context
- * linked to the parent, so step handlers can transparently access
- * composables from the parent scope (e.g. HTTP) via the parent chain.
- */
-declare function createWfContext(data: TWFEventInput, options: EventContextOptions, parentCtx?: EventContext): <R>(fn: () => R) => R;
-/**
- * Creates an event context for resuming a paused workflow.
- * When `parentCtx` is provided, the workflow creates a child context
- * linked to the parent.
- */
-declare function resumeWfContext(data: TWFEventInput, options: EventContextOptions, parentCtx?: EventContext): <R>(fn: () => R) => R;
-
 /** Workflow engine that resolves steps via Wooks router lookup. */
 declare class WooksWorkflow<T, IR> extends Workflow<T, IR> {
     protected wooks: Wooks;
@@ -91,6 +91,7 @@ declare class WooksWf<T = any, IR = any> extends WooksAdapterBase {
     protected opts?: TWooksWfOptions | undefined;
     protected logger: TConsoleBase;
     protected wf: WooksWorkflow<T, IR>;
+    protected eventContextOptions: EventContextOptions;
     constructor(opts?: TWooksWfOptions | undefined, wooks?: Wooks | WooksAdapterBase);
     /** Attaches a spy function to observe workflow step execution. */
     attachSpy<I>(fn: TWorkflowSpy<T, I, IR>): () => void;
@@ -152,14 +153,5 @@ declare class WooksWf<T = any, IR = any> extends WooksAdapterBase {
  */
 declare function createWfApp<T>(opts?: TWooksWfOptions, wooks?: Wooks | WooksAdapterBase): WooksWf<T, any>;
 
-declare const wfKind: _wooksjs_event_core.EventKind<{
-    schemaId: _wooksjs_event_core.SlotMarker<string>;
-    stepId: _wooksjs_event_core.SlotMarker<string | null>;
-    inputContext: _wooksjs_event_core.SlotMarker<unknown>;
-    indexes: _wooksjs_event_core.SlotMarker<number[] | undefined>;
-    input: _wooksjs_event_core.SlotMarker<unknown>;
-}>;
-declare const resumeKey: _wooksjs_event_core.Key<boolean>;
-
 export { WooksWf, createWfApp, createWfContext, resumeKey, resumeWfContext, useWfState, wfKind, wfShortcuts };
 export type { TWFEventInput, TWfRunOptions, TWooksWfOptions };

package/dist/index.mjs

@@ -37,40 +37,16 @@ function useWfState() {
 
 //#endregion
 //#region packages/event-wf/src/event-wf.ts
-const wfSeeds = (data) => ({
-	schemaId: data.schemaId,
-	stepId: data.stepId,
-	inputContext: data.inputContext,
-	indexes: data.indexes,
-	input: data.input
-});
-/**
-* Creates a new event context for a fresh workflow execution.
-* When `parentCtx` is provided, the workflow creates a child context
-* linked to the parent, so step handlers can transparently access
-* composables from the parent scope (e.g. HTTP) via the parent chain.
-*/
-function createWfContext(data, options, parentCtx) {
-	const ctxOptions = parentCtx ? {
-		...options,
-		parent: parentCtx
-	} : options;
-	return (fn) => createEventContext(ctxOptions, wfKind, wfSeeds(data), () => {
+/** Creates a WF event context for a fresh workflow execution and runs `fn` inside it. */
+function createWfContext(options, seeds, fn) {
+	return createEventContext(options, wfKind, seeds, () => {
 		current().set(resumeKey, false);
 		return fn();
 	});
 }
-/**
-* Creates an event context for resuming a paused workflow.
-* When `parentCtx` is provided, the workflow creates a child context
-* linked to the parent.
-*/
-function resumeWfContext(data, options, parentCtx) {
-	const ctxOptions = parentCtx ? {
-		...options,
-		parent: parentCtx
-	} : options;
-	return (fn) => createEventContext(ctxOptions, wfKind, wfSeeds(data), () => {
+/** Creates a WF event context for resuming a paused workflow and runs `fn` inside it. */
+function resumeWfContext(options, seeds, fn) {
+	return createEventContext(options, wfKind, seeds, () => {
 		current().set(resumeKey, true);
 		return fn();
 	});
@@ -113,11 +89,13 @@ const wfShortcuts = {
 var WooksWf = class extends WooksAdapterBase {
 	logger;
 	wf;
+	eventContextOptions;
 	constructor(opts, wooks) {
 		super(wooks, opts?.logger, opts?.router);
 		this.opts = opts;
 		this.logger = opts?.logger || this.getLogger(`[wooks-wf]`);
 		this.wf = new WooksWorkflow(this.wooks);
+		this.eventContextOptions = this.getEventContextOptions();
 	}
 	/** Attaches a spy function to observe workflow step execution. */
 	attachSpy(fn) {
@@ -175,14 +153,19 @@ var WooksWf = class extends WooksAdapterBase {
 	async _start(schemaId, inputContext, indexes, opts, parentCtx) {
 		const { input, spy, cleanup } = opts ?? {};
 		const resume = !!indexes?.length;
-		const runInContext = (resume ? resumeWfContext : createWfContext)({
+		const factory = resume ? resumeWfContext : createWfContext;
+		const ctxOptions = parentCtx ? {
+			...this.eventContextOptions,
+			parent: parentCtx
+		} : this.eventContextOptions;
+		const seeds = {
 			inputContext,
 			schemaId,
 			stepId: null,
 			indexes,
 			input
-		}, this.getEventContextOptions(), parentCtx);
-		return runInContext(async () => {
+		};
+		return factory(ctxOptions, seeds, async () => {
 			const { handlers: foundHandlers } = this.wooks.lookup("WF_FLOW", `/${schemaId}`.replace(/^\/+/u, "/"));
 			const handlers = foundHandlers || this.opts?.onNotFound && [this.opts.onNotFound] || null;
 			if (handlers && handlers.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooksjs/event-wf",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "@wooksjs/event-wf",
   "keywords": [
     "app",
@@ -47,13 +47,13 @@
   "devDependencies": {
     "typescript": "^5.9.3",
     "vitest": "^3.2.4",
-    "@wooksjs/event-core": "^0.7.2",
-    "wooks": "^0.7.2"
+    "@wooksjs/event-core": "^0.7.3",
+    "wooks": "^0.7.3"
   },
   "peerDependencies": {
     "@prostojs/logger": "^0.4.3",
-    "@wooksjs/event-core": "^0.7.2",
-    "wooks": "^0.7.2"
+    "@wooksjs/event-core": "^0.7.3",
+    "wooks": "^0.7.3"
   },
   "scripts": {
     "build": "rolldown -c ../../rolldown.config.mjs",

package/skills/wooksjs-event-wf/core.md

@@ -184,33 +184,34 @@ const final = await app.resume(state, { input: { username: 'alice', password: 's
 
 ## How Workflow Context Works
 
-When `start()` or `resume()` is called, the adapter creates a workflow-specific event context:
+When `start()` or `resume()` is called, the adapter creates a workflow-specific event context using `createWfContext` (or `resumeWfContext`). These are context factories that hardcode the `wfKind` and delegate to `createEventContext`:
 
 ```
-app.start(schemaId, inputContext)
-  → createWfContext({ inputContext, schemaId, stepId, indexes, input }, options)
-    → AsyncLocalStorage.run(wfContextStore, handler)
-      → router matches flow ID → handler runs
-        → workflow engine executes steps sequentially
-          → each step can call useWfState(), useRouteParams(), etc.
-            → composables call current() from @wooksjs/event-core
-              → reads/writes the event context via key/cached accessors
+app.start(schemaId, inputContext, opts)
+  → createWfContext(ctxOptions, seeds, async () => { ... })
+    → createEventContext(ctxOptions, wfKind, seeds, fn)
+      → AsyncLocalStorage.run(ctx, handler)
+        → router matches flow ID → handler runs
+          → workflow engine executes steps sequentially
+            → each step can call useWfState(), useRouteParams(), etc.
+              → composables call current() from @wooksjs/event-core
+                → reads/writes the event context via key/cached accessors
 ```
 
-### The WF Context Store
+When `eventContext` is passed in opts, `ctxOptions` includes `parent: eventContext`, linking the WF context to the parent (e.g. HTTP) via the parent chain.
 
-```ts
-interface TWFContextStore {
-  resume: boolean // true if this is a resumed execution
-}
+### The WF Event Kind
 
-interface TWFEventData {
+The WF adapter defines its event kind with `defineEventKind`. Seeds are passed directly to the context factory:
+
+```ts
+// Seeds for createWfContext / resumeWfContext
+interface WfSeeds {
   schemaId: string // flow ID being executed
   stepId: string | null // current step ID (set during step execution)
   inputContext: unknown // the workflow context object (T)
   indexes?: number[] // position for resume
   input?: unknown // input for current step
-  type: 'WF'
 }
 ```
 

package/skills/wooksjs-event-wf/event-core.md

@@ -383,38 +383,48 @@ logger.error('something failed')
 
 ## Creating an Event Context (for adapter authors)
 
-Build an adapter that creates contexts and runs handlers:
+Each adapter exports a **context factory** that hardcodes the event kind and delegates to `createEventContext`. The factory signature mirrors `createEventContext` but omits the `kind` parameter:
 
 ```ts
-import { EventContext, defineEventKind, slot, run } from '@wooksjs/event-core'
+import { createEventContext, defineEventKind, slot } from '@wooksjs/event-core'
+import type { EventContextOptions, EventKindSeeds } from '@wooksjs/event-core'
 
 const myKind = defineEventKind('my-event', {
   data: slot<unknown>(),
   source: slot<string>(),
 })
 
+// Context factory — kind is hardcoded inside
+export function createMyEventContext<R>(
+  options: EventContextOptions,
+  seeds: EventKindSeeds<typeof myKind>,
+  fn: () => R,
+): R {
+  return createEventContext(options, myKind, seeds, fn)
+}
+
+// Usage in the adapter
 function handleEvent(data: unknown, source: string, handler: () => unknown) {
-  const ctx = new EventContext({ logger: console })
-  return run(ctx, () => ctx.seed(myKind, { data, source }, handler))
+  return createMyEventContext({ logger: console }, { data, source }, handler)
 }
 ```
 
+All built-in adapters follow this pattern: `createHttpContext`, `createCliContext`, `createWsConnectionContext`, `createWsMessageContext`, `createWfContext`, `resumeWfContext`.
+
 ### Parent context (nested events)
 
-Create child contexts with parent links. Each child sees its own data plus everything in the parent chain:
+Create child contexts by passing `parent` in the options. Each child sees its own data plus everything in the parent chain:
 
 ```ts
 createEventContext({ logger }, httpKind, httpSeeds, () => {
   const parentCtx = current()
 
-  const childCtx = new EventContext({ logger, parent: parentCtx })
-  run(childCtx, () =>
-    childCtx.seed(workflowKind, wfSeeds, () => {
-      // Both HTTP and workflow composables work
-      const { method } = useRequest() // found via parent chain
-      const { ctx } = useWfState() // found locally
-    }),
-  )
+  // Child context linked to the HTTP parent
+  createEventContext({ logger, parent: parentCtx }, workflowKind, wfSeeds, () => {
+    // Both HTTP and workflow composables work
+    const { method } = useRequest() // found via parent chain
+    const { ctx } = useWfState() // found locally
+  })
 })
 ```