@wooksjs/event-wf 0.6.6 → 0.7.0

package/dist/index.mjs

@@ -1,38 +1,16 @@
-import { createAsyncEventContext, useAsyncEventContext } from "@wooksjs/event-core";
+import { EventContext, current, defineEventKind, key, run, slot, useLogger, useRouteParams } from "@wooksjs/event-core";
 import { StepRetriableError, Workflow, createStep } from "@prostojs/wf";
 import { WooksAdapterBase } from "wooks";
 
-//#region packages/event-wf/src/event-wf.ts
-/** Creates a new async event context for a fresh workflow execution. */
-function createWfContext(data, options) {
-	return createAsyncEventContext({
-		event: {
-			...data,
-			type: "WF"
-		},
-		resume: false,
-		options
-	});
-}
-/** Creates an async event context for resuming a paused workflow. */
-function resumeWfContext(data, options) {
-	return createAsyncEventContext({
-		event: {
-			...data,
-			type: "WF"
-		},
-		resume: true,
-		options
-	});
-}
-/**
-* Wrapper on top of useEventContext that provides
-* proper context types for WF event
-* @returns set of hooks { getCtx, restoreCtx, clearCtx, hookStore, getStore, setStore }
-*/
-function useWFContext() {
-	return useAsyncEventContext("WF");
-}
+//#region packages/event-wf/src/wf-kind.ts
+const wfKind = defineEventKind("WF", {
+	schemaId: slot(),
+	stepId: slot(),
+	inputContext: slot(),
+	indexes: slot(),
+	input: slot()
+});
+const resumeKey = key("wf.resume");
 
 //#endregion
 //#region packages/event-wf/src/composables/wf-state.ts
@@ -46,18 +24,58 @@ function useWFContext() {
 * ```
 */
 function useWfState() {
-	const { store, getCtx } = useWFContext();
-	const event = store("event");
+	const c = current();
 	return {
-		ctx: () => event.get("inputContext"),
-		input: () => event.get("input"),
-		schemaId: event.get("schemaId"),
-		stepId: () => event.get("stepId"),
-		indexes: () => event.get("indexes"),
-		resume: getCtx().resume
+		ctx: () => c.get(wfKind.keys.inputContext),
+		input: () => c.get(wfKind.keys.input),
+		schemaId: c.get(wfKind.keys.schemaId),
+		stepId: () => c.get(wfKind.keys.stepId),
+		indexes: () => c.get(wfKind.keys.indexes),
+		resume: c.get(resumeKey)
 	};
 }
 
+//#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 ctx = new EventContext(parentCtx ? {
+		...options,
+		parent: parentCtx
+	} : options);
+	return (fn) => run(ctx, () => {
+		ctx.set(resumeKey, false);
+		return ctx.seed(wfKind, wfSeeds(data), 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 ctx = new EventContext(parentCtx ? {
+		...options,
+		parent: parentCtx
+	} : options);
+	return (fn) => run(ctx, () => {
+		ctx.set(resumeKey, true);
+		return ctx.seed(wfKind, wfSeeds(data), fn);
+	});
+}
+
 //#endregion
 //#region packages/event-wf/src/workflow.ts
 /** Workflow engine that resolves steps via Wooks router lookup. */
@@ -69,10 +87,10 @@ var WooksWorkflow = class extends Workflow {
 	resolveStep(stepId) {
 		const stepIdNorm = `/${stepId}`.replace(/\/{2,}/gu, "/");
 		try {
-			const store = useWFContext().store("event");
+			const ctx = current();
 			const found = this.wooks.lookup("WF_STEP", stepIdNorm);
 			if (found.handlers?.length) {
-				store.set("stepId", stepIdNorm);
+				ctx.set(wfKind.keys.stepId, stepIdNorm);
 				return found.handlers[0]();
 			}
 		} catch {
@@ -122,15 +140,40 @@ var WooksWf = class extends WooksAdapterBase {
 			id
 		}));
 	}
-	/** Starts a new workflow execution from the beginning. */
-	start(schemaId, inputContext, input, spy, cleanup) {
-		return this._start(schemaId, inputContext, void 0, input, spy, cleanup);
+	/**
+	* Starts a new workflow execution from the beginning.
+	*
+	* @example
+	* ```ts
+	* // Simple
+	* await app.start('my-flow', { result: 0 })
+	*
+	* // With options
+	* await app.start('my-flow', { result: 0 }, { input: 5, eventContext: current() })
+	* ```
+	*/
+	start(schemaId, inputContext, opts) {
+		const parentCtx = opts?.eventContext;
+		return this._start(schemaId, inputContext, void 0, opts, parentCtx);
 	}
-	/** Resumes a previously paused workflow from saved state. */
-	resume(state, input, spy, cleanup) {
-		return this._start(state.schemaId, state.context, state.indexes, input, spy, cleanup);
+	/**
+	* Resumes a previously paused workflow from saved state.
+	*
+	* @example
+	* ```ts
+	* // With user input
+	* await app.resume(output.state, { input: userInput })
+	*
+	* // Simple retry (no input)
+	* await app.resume(output.state)
+	* ```
+	*/
+	resume(state, opts) {
+		const parentCtx = opts?.eventContext;
+		return this._start(state.schemaId, state.context, state.indexes, opts, parentCtx);
 	}
-	async _start(schemaId, inputContext, indexes, input, spy, cleanup) {
+	async _start(schemaId, inputContext, indexes, opts, parentCtx) {
+		const { input, spy, cleanup } = opts ?? {};
 		const resume = !!indexes?.length;
 		const runInContext = (resume ? resumeWfContext : createWfContext)({
 			inputContext,
@@ -138,7 +181,7 @@ var WooksWf = class extends WooksAdapterBase {
 			stepId: null,
 			indexes,
 			input
-		}, this.mergeEventOptions(this.opts?.eventOptions));
+		}, this.getEventContextOptions(), parentCtx);
 		return runInContext(async () => {
 			const { handlers: foundHandlers } = this.wooks.lookup("WF_FLOW", `/${schemaId}`.replace(/^\/+/u, "/"));
 			const handlers = foundHandlers || this.opts?.onNotFound && [this.opts.onNotFound] || null;
@@ -149,8 +192,8 @@ var WooksWf = class extends WooksAdapterBase {
 					if (spy) spy(...args);
 					if (firstStep && args[0] === "step") {
 						firstStep = false;
-						const { store } = useWFContext();
-						store("event").set("input", void 0);
+						const ctx = current();
+						ctx.set(wfKind.keys.input, void 0);
 					}
 				};
 				try {
@@ -174,7 +217,11 @@ var WooksWf = class extends WooksAdapterBase {
 					throw error;
 				}
 				clean();
-				if (result.resume) result.resume = (_input) => this.resume(result.state, _input, spy, cleanup);
+				if (result.resume) result.resume = (_input) => this.resume(result.state, {
+					input: _input,
+					spy,
+					cleanup
+				});
 				return result;
 			}
 			clean();
@@ -205,7 +252,7 @@ var WooksWf = class extends WooksAdapterBase {
 * ```ts
 * const app = createWfApp()
 * app.step('process', { handler: (ctx) => ctx })
-* app.flow('my-flow', [{ step: 'process' }])
+* app.flow('my-flow', ['process'])
 * await app.start('my-flow', { data: 'hello' })
 * ```
 */
@@ -214,4 +261,4 @@ function createWfApp(opts, wooks) {
 }
 
 //#endregion
-export { StepRetriableError, WooksWf, createWfApp, createWfContext, resumeWfContext, useWFContext, useWfState, wfShortcuts };
+export { StepRetriableError, WooksWf, createWfApp, createWfContext, resumeKey, resumeWfContext, useLogger, useRouteParams, useWfState, wfKind, wfShortcuts };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooksjs/event-wf",
-  "version": "0.6.6",
+  "version": "0.7.0",
   "description": "@wooksjs/event-wf",
   "keywords": [
     "app",
@@ -23,7 +23,7 @@
     "directory": "packages/event-wf"
   },
   "bin": {
-    "setup-skills": "scripts/setup-skills.js"
+    "wooksjs-event-wf-skill": "scripts/setup-skills.js"
   },
   "files": [
     "dist",
@@ -47,13 +47,13 @@
   "devDependencies": {
     "typescript": "^5.9.3",
     "vitest": "^3.2.4",
-    "@wooksjs/event-core": "^0.6.6",
-    "wooks": "^0.6.6"
+    "@wooksjs/event-core": "^0.7.0",
+    "wooks": "^0.7.0"
   },
   "peerDependencies": {
     "@prostojs/logger": "^0.4.3",
-    "@wooksjs/event-core": "^0.6.6",
-    "wooks": "^0.6.6"
+    "wooks": "^0.7.0",
+    "@wooksjs/event-core": "^0.7.0"
   },
   "scripts": {
     "build": "rolldown -c ../../rolldown.config.mjs",

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

@@ -1,6 +1,6 @@
 ---
 name: wooksjs-event-wf
-description: Wooks Workflow framework — composable, step-based workflow engine for Node.js. Load when building workflow/process automation with wooks; defining workflow steps and flows; using workflow composables (useWfState, useRouteParams); working with @wooksjs/event-core context store (init, get, set, hook); creating conditional and looping flows; resuming paused workflows; handling user input requirements; using string-based step handlers; attaching workflow spies; working with StepRetriableError; creating custom event context composables for workflows.
+description: Wooks Workflow framework — composable, step-based workflow engine for Node.js. Load when building workflow/process automation with wooks; defining workflow steps and flows; using workflow composables (useWfState, useRouteParams, useLogger); working with @wooksjs/event-core context (key, cached, defineWook, defineEventKind); creating conditional and looping flows; resuming paused workflows; handling user input requirements; using string-based step handlers; attaching workflow spies; working with StepRetriableError; creating custom event context composables for workflows; sharing parent event context (eventContext) for HTTP integration; accessing HTTP composables from workflow steps.
 ---
 
 # @wooksjs/event-wf
@@ -11,11 +11,11 @@ A composable workflow framework for Node.js built on async context (AsyncLocalSt
 
 Read the domain file that matches the task. Do not load all files — only what you need.
 
-| Domain | File | Load when... |
-|--------|------|------------|
-| Event context (core machinery) | [event-core.md](event-core.md) | Understanding the context store API (`init`/`get`/`set`/`hook`), creating custom composables, lazy evaluation and caching, building your own `use*()` functions |
-| Workflow app setup | [core.md](core.md) | Creating a workflow app, `createWfApp`, starting/resuming workflows, error handling, spies, testing, logging |
-| Steps & flows | [workflows.md](workflows.md) | Defining steps (`app.step`), defining flows (`app.flow`), workflow schemas, conditions, loops, user input, parametric steps, `useWfState`, `StepRetriableError`, string-based handlers |
+| Domain                         | File                           | Load when...                                                                                                                                                                           |
+| ------------------------------ | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Event context (core machinery) | [event-core.md](event-core.md) | Understanding `EventContext`, `key()`/`cached()`/`defineWook()`/`defineEventKind()`/`slot()`, creating custom composables, lazy evaluation and caching, building your own `use*()` functions |
+| Workflow app setup             | [core.md](core.md)             | Creating a workflow app, `createWfApp`, starting/resuming workflows, error handling, spies, testing, logging, sharing parent event context (`eventContext`), HTTP integration          |
+| Steps & flows                  | [workflows.md](workflows.md)   | Defining steps (`app.step`), defining flows (`app.flow`), workflow schemas, conditions, loops, user input, parametric steps, `useWfState`, `StepRetriableError`, string-based handlers |
 
 ## Quick reference
 
@@ -39,4 +39,4 @@ const output = await app.start('calculate', { result: 0 })
 console.log(output.state.context) // { result: 10 }
 ```
 
-Key exports: `createWfApp()`, `useWfState()`, `useWFContext()`, `useRouteParams()`, `StepRetriableError`.
+Key exports: `createWfApp()`, `useWfState()`, `useRouteParams()`, `useLogger()`, `StepRetriableError`.

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

@@ -9,6 +9,7 @@ For the underlying event context store API (`init`, `get`, `set`, `hook`, etc.)
 `@wooksjs/event-wf` is the workflow adapter for Wooks. It wraps the `@prostojs/wf` workflow engine, adding composable context management via `AsyncLocalStorage`. Each workflow execution gets its own isolated context store, and step handlers can call composable functions (`useWfState()`, `useRouteParams()`, etc.) from anywhere.
 
 Key principles:
+
 1. **Steps are route handlers** — Steps are registered with IDs that are resolved via the Wooks router, supporting parametric step IDs (`:param`), wildcards, and regex constraints.
 2. **Flows are schemas** — Flows define the execution order of steps, with conditions, loops, and branching.
 3. **Pause and resume** — Workflows can pause for user input and resume from saved state.
@@ -28,7 +29,9 @@ import { createWfApp } from '@wooksjs/event-wf'
 const app = createWfApp<{ result: number }>()
 
 app.step('increment', {
-  handler: (ctx) => { ctx.result++ },
+  handler: (ctx) => {
+    ctx.result++
+  },
 })
 
 app.flow('my-flow', [{ id: 'increment' }])
@@ -43,11 +46,11 @@ Options:
 
 ```ts
 interface TWooksWfOptions {
-  onError?: (e: Error) => void          // custom error handler
-  onNotFound?: TWooksHandler             // handler when flow not found
+  onError?: (e: Error) => void // custom error handler
+  onNotFound?: TWooksHandler // handler when flow not found
   onUnknownFlow?: (schemaId: string, raiseError: () => void) => unknown
-  logger?: TConsoleBase                  // custom logger
-  eventOptions?: TEventOptions           // event-level logger config
+  logger?: TConsoleBase // custom logger
+  eventOptions?: EventContextOptions // event context options (logger, parent)
   router?: {
     ignoreTrailingSlash?: boolean
     ignoreCase?: boolean
@@ -58,37 +61,51 @@ interface TWooksWfOptions {
 
 ## Starting a Workflow
 
-### `app.start(schemaId, inputContext, input?, spy?, cleanup?)`
+### `app.start(schemaId, inputContext, opts?)`
 
 Starts a new workflow execution from the beginning:
 
 ```ts
 const output = await app.start('my-flow', { result: 0 })
+
+// With options
+const output = await app.start(
+  'my-flow',
+  { result: 0 },
+  {
+    input: 5,
+    eventContext: current(),
+  },
+)
 ```
 
 **Parameters:**
+
 - `schemaId` — The flow ID registered with `app.flow()`
 - `inputContext` — The initial context object (`T`)
-- `input` — Optional input for the first step
-- `spy` — Optional spy function to observe step execution
-- `cleanup` — Optional cleanup function called when execution ends
+- `opts` — Optional `TWfRunOptions` object:
+  - `input` — Input for the first step (consumed after execution)
+  - `spy` — Spy function to observe step execution
+  - `cleanup` — Cleanup function called when execution ends
+  - `eventContext` — Parent `EventContext` to link to. Pass `current()` from within an active event scope (e.g. HTTP handler). The workflow creates a child context with `parent: current()`, so step handlers can access parent composables transparently via parent chain traversal.
 
 **Return value (`TFlowOutput<T, I, IR>`):**
 
 ```ts
 interface TFlowOutput<T, I, IR> {
-  finished: boolean              // true if workflow completed
+  finished: boolean // true if workflow completed
   state: {
-    schemaId: string             // flow ID
-    indexes: number[]            // position in schema (for resume)
-    context: T                   // final context state
+    schemaId: string // flow ID
+    indexes: number[] // position in schema (for resume)
+    context: T // final context state
   }
-  inputRequired?: {              // present if paused for input
-    type: string                 // expected input type
-    schemaId: string             // step requiring input
+  inputRequired?: {
+    // present if paused for input
+    type: string // expected input type
+    schemaId: string // step requiring input
   }
-  stepResult?: IR                // last step's return value
-  resume?: (input?: I) => Promise<TFlowOutput<T, I, IR>>  // resume function
+  stepResult?: IR // last step's return value
+  resume?: (input?: I) => Promise<TFlowOutput<T, I, IR>> // resume function
 }
 ```
 
@@ -107,15 +124,20 @@ if (output.finished) {
 
 ## Resuming a Workflow
 
-### `app.resume(state, input?, spy?, cleanup?)`
+### `app.resume(state, opts?)`
 
 Resumes a previously paused workflow from saved state:
 
 ```ts
 // Resume with user-provided input
-const resumed = await app.resume(output.state, userInput)
+const resumed = await app.resume(output.state, { input: userInput })
+
+// Simple retry (no input)
+const retried = await app.resume(output.state)
 ```
 
+The `opts` parameter accepts the same `TWfRunOptions` as `start()` — including `eventContext` to link to the active event context via a parent chain.
+
 ### Using the `resume()` function on output
 
 The output object includes a convenience `resume()` method:
@@ -144,10 +166,7 @@ app.step('welcome', {
   handler: (ctx) => console.log(`Welcome, ${ctx.username}!`),
 })
 
-app.flow('login', [
-  { id: 'get-credentials' },
-  { id: 'welcome' },
-])
+app.flow('login', [{ id: 'get-credentials' }, { id: 'welcome' }])
 
 // Start — pauses at get-credentials because input is required
 const output = await app.start('login', {})
@@ -159,7 +178,7 @@ const savedState = JSON.stringify(output.state)
 
 // Later, resume with user input
 const state = JSON.parse(savedState)
-const final = await app.resume(state, { username: 'alice', password: 'secret' })
+const final = await app.resume(state, { input: { username: 'alice', password: 'secret' } })
 // final.finished === true
 ```
 
@@ -174,52 +193,50 @@ app.start(schemaId, inputContext)
       → router matches flow ID → handler runs
         → workflow engine executes steps sequentially
           → each step can call useWfState(), useRouteParams(), etc.
-            → composables call useWFContext()
-              → reads/writes the WF context store
+            → composables call current() from @wooksjs/event-core
+              → reads/writes the event context via key/cached accessors
 ```
 
 ### The WF Context Store
 
 ```ts
 interface TWFContextStore {
-  resume: boolean   // true if this is a resumed execution
+  resume: boolean // true if this is a resumed execution
 }
 
 interface TWFEventData {
-  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
+  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'
 }
 ```
 
-### Extending the WF Store for Custom Composables
+### Custom Composables for Workflows
 
-```ts
-import { useWFContext } from '@wooksjs/event-wf'
+Use `defineWook` and `key()` from `@wooksjs/event-core` to create custom composables that store data in the event context:
 
-interface TMyStore {
-  metrics?: {
-    startTime?: number
-    stepCount?: number
-  }
-}
+```ts
+import { defineWook, key } from '@wooksjs/event-core'
 
-export function useWorkflowMetrics() {
-  const { store } = useWFContext<TMyStore>()
-  const { init, get, set } = store('metrics')
+const startTimeKey = key<number>('wf.metrics.startTime')
+const stepCountKey = key<number>('wf.metrics.stepCount')
 
-  const startTimer = () => init('startTime', () => Date.now())
-  const incrementSteps = () => set('stepCount', (get('stepCount') || 0) + 1)
-  const getElapsed = () => Date.now() - (get('startTime') || Date.now())
+export const useWorkflowMetrics = defineWook((ctx) => {
+  ctx.set(startTimeKey, Date.now())
+  ctx.set(stepCountKey, 0)
 
-  return { startTimer, incrementSteps, getElapsed }
-}
+  return {
+    incrementSteps: () => ctx.set(stepCountKey, ctx.get(stepCountKey) + 1),
+    getElapsed: () => Date.now() - ctx.get(startTimeKey),
+    getStepCount: () => ctx.get(stepCountKey),
+  }
+})
 ```
 
-For the full context store API and composable patterns, see [event-core.md](event-core.md).
+For the full context store API and composable patterns, see the `@wooksjs/event-core` skill.
 
 ## Workflow Spies
 
@@ -241,14 +258,21 @@ app.detachSpy(spy)
 ### Per-execution spy
 
 ```ts
-const output = await app.start('my-flow', { result: 0 }, undefined, (event, ...args) => {
-  if (event === 'step') {
-    console.log('Step executed:', args)
-  }
-})
+const output = await app.start(
+  'my-flow',
+  { result: 0 },
+  {
+    spy: (event, ...args) => {
+      if (event === 'step') {
+        console.log('Step executed:', args)
+      }
+    },
+  },
+)
 ```
 
 The spy function receives:
+
 - `event` — Event type (e.g., `'step'`)
 - Additional arguments vary by event type
 
@@ -299,6 +323,49 @@ app.step('validate', {
 })
 ```
 
+## Sharing the Parent Event Context
+
+By default, `start()` and `resume()` create an isolated event context — step handlers cannot access composables from the calling scope (e.g., HTTP composables). When `eventContext` is passed, the workflow creates a **child context** with a parent link (`parent: current()`) instead of sharing the parent context directly. The child context seeds its own WF slots locally, and slot lookups that are not found in the child automatically traverse the parent chain. This means both WF composables and parent composables (e.g., HTTP) work transparently inside step handlers.
+
+### Use case: accessing HTTP auth data in workflow steps
+
+```ts
+import { current } from '@wooksjs/event-core'
+import { createHttpApp, useRequest } from '@wooksjs/event-http'
+import { createWfApp, useWfState } from '@wooksjs/event-wf'
+
+const wf = createWfApp<{ userId: string; role: string }>()
+
+wf.step('check-permissions', {
+  handler: () => {
+    const { ctx } = useWfState()
+    // useRequest() works because the child context traverses the parent chain
+    const { headers } = useRequest()
+    const user = decodeToken(headers.authorization)
+    ctx<{ userId: string; role: string }>().userId = user.id
+    ctx<{ userId: string; role: string }>().role = user.role
+  },
+})
+
+wf.flow('secure-action', ['check-permissions', 'do-work'])
+
+const http = createHttpApp()
+
+http.post('/actions/run', async () => {
+  const output = await wf.start(
+    'secure-action',
+    { userId: '', role: '' },
+    { eventContext: current() },
+  )
+  return output.state.context
+})
+```
+
+### When to inherit vs isolate
+
+- **Inherit** (`eventContext: current()`) when the workflow runs entirely within a single HTTP request and steps need parent composables (auth, headers, cached user data). The child context links to the parent via a parent chain, keeping WF-specific slots isolated while providing transparent access to parent slots.
+- **Isolate** (default) when the workflow may pause and resume across different requests, or when it should be testable without a parent context.
+
 ## Sharing Router Between Adapters
 
 Multiple adapters can share the same Wooks router:
@@ -309,7 +376,7 @@ import { createWfApp } from '@wooksjs/event-wf'
 
 const wooks = new Wooks()
 const app1 = createWfApp({}, wooks)
-const app2 = createWfApp({}, wooks)  // shares the same routes
+const app2 = createWfApp({}, wooks) // shares the same routes
 ```
 
 Or share with another adapter (e.g., HTTP):
@@ -319,7 +386,7 @@ import { createHttpApp } from '@wooksjs/event-http'
 import { createWfApp } from '@wooksjs/event-wf'
 
 const httpApp = createHttpApp()
-const wfApp = createWfApp({}, httpApp)  // shares httpApp's router
+const wfApp = createWfApp({}, httpApp) // shares httpApp's router
 ```
 
 ## Testing
@@ -332,13 +399,12 @@ import { createWfApp } from '@wooksjs/event-wf'
 const app = createWfApp<{ count: number }>()
 
 app.step('increment', {
-  handler: (ctx) => { ctx.count++ },
+  handler: (ctx) => {
+    ctx.count++
+  },
 })
 
-app.flow('test-flow', [
-  { id: 'increment' },
-  { id: 'increment' },
-])
+app.flow('test-flow', [{ id: 'increment' }, { id: 'increment' }])
 
 // Test:
 const output = await app.start('test-flow', { count: 0 })
@@ -359,7 +425,7 @@ app.flow('resume-flow', [{ id: 'needs-input' }])
 const output = await app.start('resume-flow', { count: 0 })
 expect(output.finished).toBe(false)
 
-const final = await app.resume(output.state, 42)
+const final = await app.resume(output.state, { input: 42 })
 expect(final.state.context.count).toBe(42)
 expect(final.finished).toBe(true)
 ```
@@ -369,12 +435,12 @@ expect(final.finished).toBe(true)
 Inside a step handler, use the event-scoped logger:
 
 ```ts
-import { useEventLogger } from '@wooksjs/event-core'
+import { useLogger } from '@wooksjs/event-core'
 
 app.step('process', {
   handler: (ctx) => {
-    const logger = useEventLogger('process-step')
-    logger.log('Processing...')
+    const logger = useLogger()
+    logger.info('Processing...')
     ctx.processed = true
   },
 })