@wooksjs/event-core 0.7.2 → 0.7.3

package/dist/index.cjs

@@ -293,7 +293,7 @@ function resetContextInjector() {
 //#region packages/event-core/src/storage.ts
 const STORAGE_KEY = Symbol.for("wooks.core.asyncStorage");
 const VERSION_KEY = Symbol.for("wooks.core.asyncStorage.version");
-const CURRENT_VERSION = "0.7.1";
+const CURRENT_VERSION = "0.7.2";
 const _g = globalThis;
 if (_g[STORAGE_KEY]) {
 	if (_g[VERSION_KEY] !== CURRENT_VERSION) throw new Error(`[wooks] Incompatible versions of @wooksjs/event-core detected: existing v${_g[VERSION_KEY]}, loading v${CURRENT_VERSION}. All packages must use the same @wooksjs/event-core version.`);

package/dist/index.mjs

@@ -270,7 +270,7 @@ function resetContextInjector() {
 //#region packages/event-core/src/storage.ts
 const STORAGE_KEY = Symbol.for("wooks.core.asyncStorage");
 const VERSION_KEY = Symbol.for("wooks.core.asyncStorage.version");
-const CURRENT_VERSION = "0.7.1";
+const CURRENT_VERSION = "0.7.2";
 const _g = globalThis;
 if (_g[STORAGE_KEY]) {
 	if (_g[VERSION_KEY] !== CURRENT_VERSION) throw new Error(`[wooks] Incompatible versions of @wooksjs/event-core detected: existing v${_g[VERSION_KEY]}, loading v${CURRENT_VERSION}. All packages must use the same @wooksjs/event-core version.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooksjs/event-core",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "@wooksjs/event-core",
   "keywords": [
     "composables",

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

@@ -175,39 +175,52 @@ This prevents subtle bugs from multiple context stores.
 
 ### Pattern: Custom adapter
 
-Build an adapter that creates contexts and runs handlers:
+Build an adapter that creates contexts and runs handlers. Each adapter exports a **context factory** that hardcodes the kind and delegates to `createEventContext`:
 
 ```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>(),
 })
 
-function handleEvent(data: unknown, handler: () => unknown, parent?: EventContext) {
-  const ctx = new EventContext({ logger: console, parent })
-  ctx.seed(myKind, { data })
-  return run(ctx, handler)
+// Context factory — same signature as createEventContext, minus the kind
+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, handler: () => unknown) {
+  return createMyEventContext({ logger: console }, { data }, handler)
 }
 ```
 
+All built-in adapters follow this pattern: `createHttpContext`, `createCliContext`, `createWsConnectionContext`, `createWsMessageContext`, `createWfContext`, `resumeWfContext`.
+
 ### Pattern: Child contexts with parent links
 
-Instead of attaching multiple kinds to a single context, create child contexts with parent links. Each child sees its own data plus everything in the parent chain:
+Instead of attaching multiple kinds to a single context, 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()
 
-  // Create a child context for workflow-specific data
-  const childCtx = new EventContext({ logger, parent: parentCtx })
-  childCtx.seed(workflowKind, { triggerId: 'deploy-42', payload })
-
-  run(childCtx, () => {
-    // Both HTTP and workflow composables work
-    const { method } = useRequest() // found via parent chain
-    const { triggerId } = useWorkflow() // found locally
-  })
+  // Create a child context linked to the HTTP parent
+  createEventContext(
+    { logger, parent: parentCtx },
+    workflowKind,
+    { triggerId: 'deploy-42', payload },
+    () => {
+      // Both HTTP and workflow composables work
+      const { method } = useRequest() // found via parent chain
+      const { triggerId } = useWorkflow() // found locally
+    },
+  )
 })
 ```
 
@@ -253,6 +266,8 @@ resetContextInjector()
 
 The injector's `with()` method wraps `createEventContext` callbacks. All adapters (HTTP, CLI, WS, WF) route through `createEventContext`, so installing an injector automatically instruments every event type.
 
+Adapter callbacks **return their result** (sync value or Promise), so `with()` can track async handler completion for span lifecycle. A `TracingInjector` can detect thenable returns and attach `.then()/.catch()` to end spans when the handler settles — no separate `onEnd()` hook needed.
+
 ## Best Practices
 
 - Let adapters handle context creation — in handler code, just use composables

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

@@ -62,7 +62,7 @@ Every event (HTTP request, CLI invocation, workflow step) gets its own `EventCon
 | `useEventId(ctx?)`                            | composable | Lazy UUID per event                                                                                              |
 | `routeParamsKey`                              | key        | Standard key for route params                                                                                    |
 | `eventTypeKey`                                | key        | Standard key for event type name                                                                                 |
-| `ContextInjector`                             | class      | Observability hook point (OpenTelemetry etc.)                                                                    |
+| `ContextInjector`                             | class      | Observability hook point (OpenTelemetry etc.). Defaults to `null` — zero overhead until installed.               |
 | `getContextInjector()`                        | function   | Get current injector (returns `null` when none installed)                                                        |
 | `replaceContextInjector(ci)`                  | function   | Install a custom injector (e.g. with OTel spans)                                                                 |
 | `resetContextInjector()`                      | function   | Reset injector back to `null` (disables instrumentation)                                                         |