@wooksjs/event-core 0.6.5 → 0.7.0

package/dist/index.cjs

@@ -6,11 +6,11 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key$1; i < n; i++) {
+		key$1 = keys[i];
+		if (!__hasOwnProp.call(to, key$1) && key$1 !== except) __defProp(to, key$1, {
+			get: ((k) => from[k]).bind(null, key$1),
+			enumerable: !(desc = __getOwnPropDesc(from, key$1)) || desc.enumerable
 		});
 	}
 	return to;
@@ -21,300 +21,519 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const crypto = __toESM(require("crypto"));
 const node_async_hooks = __toESM(require("node:async_hooks"));
-const __prostojs_logger = __toESM(require("@prostojs/logger"));
+const node_crypto = __toESM(require("node:crypto"));
 
+//#region packages/event-core/src/key.ts
+let nextId = 0;
+/**
+* Creates a typed, writable context slot. Use `ctx.set(k, value)` to store
+* and `ctx.get(k)` to retrieve. Throws if read before being set.
+*
+* @param name - Debug label (shown in error messages, not used for lookup)
+*
+* @example
+* ```ts
+* const userIdKey = key<string>('userId')
+* ctx.set(userIdKey, '123')
+* ctx.get(userIdKey) // '123'
+* ```
+*/
+function key(name) {
+	return {
+		_id: nextId++,
+		_name: name
+	};
+}
+/**
+* Creates a lazily-computed, read-only context slot. The factory runs once
+* per `EventContext` on first `ctx.get(slot)` call; the result is cached
+* for the context lifetime. Errors are also cached and re-thrown.
+*
+* @param fn - Factory receiving the current `EventContext`, returning the value to cache
+*
+* @example
+* ```ts
+* const parsedUrl = cached((ctx) => new URL(ctx.get(rawUrlKey)))
+* // first call computes, subsequent calls return cached result
+* ctx.get(parsedUrl)
+* ```
+*/
+function cached(fn) {
+	return {
+		_id: nextId++,
+		_name: `cached:${nextId}`,
+		_fn: fn
+	};
+}
+/** @internal Returns true if the accessor is a `Cached` slot (has a factory function). */
+function isCached(accessor) {
+	return "_fn" in accessor;
+}
+
+//#endregion
+//#region packages/event-core/src/keys.ts
+/** Context key for route parameters. Set by adapters after route matching. */
+const routeParamsKey = key("routeParams");
+/** Context key for the event type name (e.g. `'http'`, `'cli'`). Set by `ctx.seed()`. */
+const eventTypeKey = key("eventType");
+
+//#endregion
+//#region packages/event-core/src/context.ts
+const COMPUTING = Symbol("computing");
+const UNDEFINED = Symbol("undefined");
+var CachedError = class {
+	constructor(error) {
+		this.error = error;
+	}
+};
+/**
+* Per-event container for typed slots, propagated via `AsyncLocalStorage`.
+* Composables read and write data through `get`/`set` using typed `Key` or `Cached` accessors.
+*
+* Supports a parent chain: when a slot is not found locally, `get()` traverses
+* parent contexts. `set()` writes to the nearest context that already holds the slot,
+* or locally if the slot is new.
+*
+* Typically created by adapters (HTTP, CLI, etc.) — application code
+* interacts with it indirectly through composables.
+*
+* @example
+* ```ts
+* const ctx = new EventContext({ logger })
+* ctx.set(userIdKey, '123')
+* ctx.get(userIdKey) // '123'
+* ```
+*/
+var EventContext = class {
+	/** Logger instance for this event. */
+	logger;
+	/** Parent context for read-through and scoped writes. */
+	parent;
+	slots = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.logger = options.logger;
+		this.parent = options.parent;
+	}
+	/**
+	* Reads a value from a typed slot.
+	* - For `Key<T>`: returns the previously `set` value, checking parent chain if not found locally.
+	* - For `Cached<T>`: returns a cached result from this context or any parent. If not found
+	*   anywhere, runs the factory on first access, caches locally, and returns the result.
+	*   Throws on circular dependencies. Errors are cached and re-thrown on subsequent access.
+	*/
+	get(accessor) {
+		const id = accessor._id;
+		let val = this.slots.get(id);
+		if (val === void 0 && this.parent) val = this.parent._findSlot(id);
+		if (val !== void 0) {
+			if (val === COMPUTING) throw new Error(`Circular dependency detected for "${accessor._name}"`);
+			if (val instanceof CachedError) throw val.error;
+			if (val === UNDEFINED) return void 0;
+			return val;
+		}
+		if (isCached(accessor)) {
+			this.slots.set(id, COMPUTING);
+			try {
+				const result = accessor._fn(this);
+				this.slots.set(id, result === void 0 ? UNDEFINED : result);
+				return result;
+			} catch (error) {
+				this.slots.set(id, new CachedError(error));
+				throw error;
+			}
+		}
+		throw new Error(`Key "${accessor._name}" is not set`);
+	}
+	/**
+	* Writes a value to a typed slot. If the slot already exists somewhere in the
+	* parent chain, the value is written there. Otherwise, it is written locally.
+	*/
+	set(key$1, value) {
+		const encoded = value === void 0 ? UNDEFINED : value;
+		if (this.slots.has(key$1._id)) {
+			this.slots.set(key$1._id, encoded);
+			return;
+		}
+		if (this.parent && this.parent._setIfExists(key$1._id, encoded)) return;
+		this.slots.set(key$1._id, encoded);
+	}
+	/**
+	* Returns `true` if the slot has been set or computed in this context or any parent.
+	*/
+	has(accessor) {
+		const val = this.slots.get(accessor._id);
+		if (val !== void 0 && val !== COMPUTING) return true;
+		return this.parent?.has(accessor) ?? false;
+	}
+	/**
+	* Reads a value from a typed slot in this context only, ignoring parents.
+	* Same semantics as `get()` but without parent chain traversal.
+	*/
+	getOwn(accessor) {
+		const id = accessor._id;
+		const val = this.slots.get(id);
+		if (val !== void 0) {
+			if (val === COMPUTING) throw new Error(`Circular dependency detected for "${accessor._name}"`);
+			if (val instanceof CachedError) throw val.error;
+			if (val === UNDEFINED) return void 0;
+			return val;
+		}
+		if (isCached(accessor)) {
+			this.slots.set(id, COMPUTING);
+			try {
+				const result = accessor._fn(this);
+				this.slots.set(id, result === void 0 ? UNDEFINED : result);
+				return result;
+			} catch (error) {
+				this.slots.set(id, new CachedError(error));
+				throw error;
+			}
+		}
+		throw new Error(`Key "${accessor._name}" is not set`);
+	}
+	/**
+	* Writes a value to a typed slot in this context only, ignoring parents.
+	*/
+	setOwn(key$1, value) {
+		this.slots.set(key$1._id, value === void 0 ? UNDEFINED : value);
+	}
+	/**
+	* Returns `true` if the slot has been set or computed in this context only.
+	*/
+	hasOwn(accessor) {
+		const val = this.slots.get(accessor._id);
+		return val !== void 0 && val !== COMPUTING;
+	}
+	seed(kind, seeds, fn) {
+		const entries = kind._entries;
+		for (const [prop, k] of entries) {
+			const v = seeds[prop];
+			this.slots.set(k._id, v === void 0 ? UNDEFINED : v);
+		}
+		this.setOwn(eventTypeKey, kind.name);
+		if (fn) return fn();
+	}
+	/** Walk the parent chain looking for a set slot. Returns `undefined` if not found. */
+	_findSlot(id) {
+		const val = this.slots.get(id);
+		if (val !== void 0) return val;
+		return this.parent?._findSlot(id);
+	}
+	/** Set value in the first context in the chain that has this slot. Returns true if found. */
+	_setIfExists(id, encoded) {
+		if (this.slots.has(id)) {
+			this.slots.set(id, encoded);
+			return true;
+		}
+		return this.parent?._setIfExists(id, encoded) ?? false;
+	}
+};
+
+//#endregion
 //#region packages/event-core/src/context-injector.ts
 /**
-* ContextInjector
+* No-op base class for observability integration. Subclass and override
+* `with()` / `hook()` to add tracing, metrics, or logging around event
+* lifecycle points.
 *
-* Provides a way to inject context
-* Usefull when working with opentelemetry spans
+* The default implementation simply calls the callback with no overhead.
+* Replace via `replaceContextInjector()` to enable instrumentation.
 */
 var ContextInjector = class {
 	with(name, attributes, cb) {
 		const fn = typeof attributes === "function" ? attributes : cb;
 		return fn();
 	}
+	/**
+	* Hook called by adapters at specific lifecycle points (e.g., after route lookup).
+	* Default implementation is a no-op — override for observability.
+	*/
 	hook(_method, _name, _route) {}
 };
 let ci = new ContextInjector();
-/** Returns the current global `ContextInjector` instance. */
+/**
+* Returns the current `ContextInjector` instance (default: no-op).
+* Used internally by adapters to wrap lifecycle events.
+*/
 function getContextInjector() {
 	return ci;
 }
-/** Replaces the global `ContextInjector` instance (e.g., to integrate with OpenTelemetry). */
-function replaceContextInjector(newCi) {
-	ci = newCi;
-}
-
-//#endregion
-//#region packages/event-core/src/hook.ts
 /**
-* Attaches a getter/setter hook to a target object property via `Object.defineProperty`.
+* Replaces the global `ContextInjector` with a custom implementation.
+* Use this to integrate OpenTelemetry or other observability tools.
+*
+* @param newCi - Custom `ContextInjector` subclass instance
 *
-* @param target - The object to attach the hook to.
-* @param opts - Getter and optional setter for the hooked property.
-* @param name - Property name to hook (defaults to `'value'`).
+* @example
+* ```ts
+* class OtelInjector extends ContextInjector<string> {
+*   with<T>(name: string, attrs: Record<string, any>, cb: () => T): T {
+*     return tracer.startActiveSpan(name, (span) => {
+*       span.setAttributes(attrs)
+*       try { return cb() } finally { span.end() }
+*     })
+*   }
+* }
+* replaceContextInjector(new OtelInjector())
+* ```
 */
-function attachHook(target, opts, name) {
-	Object.defineProperty(target, name || "value", {
-		get: opts.get,
-		set: opts.set
-	});
-	return target;
+function replaceContextInjector(newCi) {
+	ci = newCi;
 }
 
 //#endregion
-//#region packages/event-core/src/context.ts
-const STORAGE_KEY = Symbol.for("wooks.asyncStorage");
-const VERSION_KEY = Symbol.for("wooks.asyncStorage.version");
-const CURRENT_VERSION = "0.6.2";
+//#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.6.6";
 const _g = globalThis;
 if (_g[STORAGE_KEY]) {
-	if (_g[VERSION_KEY] !== CURRENT_VERSION) console.warn(`[wooks] Multiple versions of @wooksjs/event-core detected: existing v${_g[VERSION_KEY]}, current v${CURRENT_VERSION}. Reusing existing asyncStorage to avoid runtime errors.`);
+	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.`);
 } else {
 	_g[STORAGE_KEY] = new node_async_hooks.AsyncLocalStorage();
 	_g[VERSION_KEY] = CURRENT_VERSION;
 }
+const storage = _g[STORAGE_KEY];
 /**
-* AsyncLocalStorage instance
+* Runs a callback with the given `EventContext` as the active context.
+* All composables and `current()` calls inside `fn` will resolve to `ctx`.
+*
+* @param ctx - The event context to make active
+* @param fn - Callback to execute within the context scope
+* @returns The return value of `fn`
 *
-* Use on your own risk only if you know what you're doing
+* @example
+* ```ts
+* const ctx = new EventContext({ logger })
+* run(ctx, () => {
+*   // current() returns ctx here
+*   const logger = useLogger()
+* })
+* ```
 */
-const asyncStorage = _g[STORAGE_KEY];
-/** Symbol key for caching store accessors directly on the context object */
-const _storeCacheKey = Symbol("storeCache");
+function run(ctx, fn) {
+	return storage.run(ctx, fn);
+}
 /**
-* Creates a new async event context and returns a runner function to execute callbacks within it.
+* Returns the active `EventContext` for the current async scope.
+* Throws if called outside an event context (e.g., at module level).
+*
+* All composables use this internally. Prefer composables over direct `current()` access.
 *
-* @param data - Initial context store data including the event object and options.
-* @returns A function that runs a callback within the created async context.
+* @throws Error if no active event context exists
+*/
+function current() {
+	const ctx = storage.getStore();
+	if (!ctx) throw new Error("[Wooks] No active event context");
+	return ctx;
+}
+/**
+* Returns the active `EventContext`, or `undefined` if none is active.
+* Use this when context availability is uncertain (e.g., in code that may
+* run both inside and outside an event handler).
 */
-function createAsyncEventContext(data) {
-	const newContext = { ...data };
-	const cc = asyncStorage.getStore();
-	if (cc && typeof cc === "object" && cc.event?.type) newContext.parentCtx = cc;
-	const ci$1 = getContextInjector();
-	return (cb) => asyncStorage.run(newContext, () => ci$1.with("Event:start", { eventType: newContext.event.type }, cb));
+function tryGetCurrent() {
+	return storage.getStore();
 }
 /**
-* Retrieves the current async event context and returns helpers for reading/writing the store.
+* Returns the logger for the current event context.
+*
+* @param ctx - Optional explicit context (defaults to `current()`)
 *
-* @param expectedTypes - Optional event type(s) to validate the context against.
-* @throws If no event context exists or if the event type does not match.
+* @example
+* ```ts
+* const logger = useLogger()
+* logger.info('Processing request')
+* ```
 */
-function useAsyncEventContext(expectedTypes) {
-	let cc = asyncStorage.getStore();
-	if (!cc) throw new Error("Event context does not exist at this point.");
-	if (expectedTypes || typeof expectedTypes === "string") {
-		const type = cc.event.type;
-		const types = typeof expectedTypes === "string" ? [expectedTypes] : expectedTypes;
-		if (!types.includes(type)) if (cc.parentCtx?.event.type && types.includes(cc.parentCtx.event.type)) cc = cc.parentCtx;
-		else throw new Error(`Event context type mismatch: expected ${types.map((t) => `"${t}"`).join(", ")}, received "${type}"`);
-	}
-	return _getCtxHelpers(cc);
+function useLogger(ctx) {
+	return (ctx ?? current()).logger;
 }
-function _getCtxHelpers(cc) {
-	const ccAny = cc;
-	if (!ccAny[_storeCacheKey]) ccAny[_storeCacheKey] = /* @__PURE__ */ new Map();
-	const _storeCache = ccAny[_storeCacheKey];
-	/**
-	* Hook to an event store property
-	*
-	* @param key store property key
-	* @returns a hook { value: <prop value>, hook: (key2: keyof <prop value>) => { value: <nested prop value> }, ... }
-	*/
-	function store(key) {
-		const cachedStore = _storeCache.get(key);
-		if (cachedStore) return cachedStore;
-		const getSection = () => cc[key];
-		const setSection = (v) => {
-			cc[key] = v;
-		};
-		const obj = {
-			value: null,
-			hook,
-			init,
-			set: setNested,
-			get: getNested,
-			has: hasNested,
-			del: delNested,
-			entries,
-			clear
-		};
-		attachHook(obj, {
-			set: (v) => {
-				setSection(v);
-			},
-			get: () => getSection()
-		});
-		function init(key2, getter) {
-			if (hasNested(key2)) return getNested(key2);
-			return setNested(key2, getter());
-		}
-		function hook(key2) {
-			const hookObj = {
-				value: null,
-				isDefined: null
-			};
-			attachHook(hookObj, {
-				set: (v) => setNested(key2, v),
-				get: () => getNested(key2)
-			});
-			attachHook(hookObj, { get: () => hasNested(key2) }, "isDefined");
-			return hookObj;
-		}
-		function setNested(key2, v) {
-			let section = getSection();
-			if (section === void 0) {
-				section = {};
-				setSection(section);
-			}
-			section[key2] = v;
-			return v;
-		}
-		function delNested(key2) {
-			setNested(key2, void 0);
-		}
-		function getNested(key2) {
-			const section = getSection();
-			return section !== void 0 ? section[key2] : void 0;
-		}
-		function hasNested(key2) {
-			const section = getSection();
-			return section !== void 0 ? section[key2] !== void 0 : false;
-		}
-		function entries() {
-			const section = getSection();
-			return section ? Object.entries(section) : [];
-		}
-		function clear() {
-			setSection({});
-		}
-		_storeCache.set(key, obj);
-		return obj;
-	}
-	/**
-	* Get event context object
-	*
-	* @returns whole context object
-	*/
-	function getCtx() {
-		return cc;
-	}
-	function get(key) {
-		return cc[key];
-	}
-	function set(key, v) {
-		cc[key] = v;
-	}
-	const hasParentCtx = () => !!cc.parentCtx;
-	const helpers = {
-		getCtx,
-		store,
-		getStore: get,
-		setStore: set,
-		setParentCtx: (parentCtx) => {
-			cc.parentCtx = parentCtx;
-		},
-		hasParentCtx,
-		getParentCtx: () => {
-			if (!hasParentCtx()) throw new Error("Parent context is not available");
-			return _getCtxHelpers(cc.parentCtx);
-		}
-	};
-	return helpers;
+function createEventContext(options, kindOrFn, seedsOrUndefined, maybeFn) {
+	const ctx = new EventContext(options);
+	if (typeof kindOrFn === "function") return run(ctx, kindOrFn);
+	return run(ctx, () => {
+		ctx.seed(kindOrFn, seedsOrUndefined);
+		return getContextInjector().with("Event:start", { eventType: kindOrFn.name }, maybeFn);
+	});
 }
 
 //#endregion
-//#region packages/event-core/src/composables/event-id.ts
+//#region packages/event-core/src/cached-by.ts
 /**
-* Composable that provides a unique event ID for the current event context.
+* Creates a parameterized cached computation. Maintains a `Map<K, V>` per
+* event context — one cached result per unique key argument.
+*
+* @param fn - Factory receiving the lookup key and `EventContext`, returning the value to cache
+* @returns A function `(key: K, ctx?: EventContext) => V` that computes on first call per key
 *
 * @example
 * ```ts
-* const { getId } = useEventId()
-* console.log(getId()) // '550e8400-e29b-41d4-a716-446655440000'
+* const parseCookie = cachedBy((name: string, ctx) => {
+*   const raw = ctx.get(cookieHeaderKey)
+*   return parseSingleCookie(raw, name)
+* })
+*
+* parseCookie('session') // computed and cached for 'session'
+* parseCookie('theme')   // computed and cached for 'theme'
+* parseCookie('session') // returns cached result
 * ```
 */
-function useEventId() {
-	const { store } = useAsyncEventContext();
-	const { init } = store("event");
-	const getId = () => init("id", () => (0, crypto.randomUUID)());
-	return { getId };
+function cachedBy(fn) {
+	const mapSlot = cached(() => /* @__PURE__ */ new Map());
+	return (k, ctx) => {
+		const c = ctx ?? current();
+		const map = c.get(mapSlot);
+		if (!map.has(k)) map.set(k, fn(k, c));
+		return map.get(k);
+	};
 }
 
 //#endregion
-//#region packages/event-core/src/event-logger.ts
-/** Logger scoped to a single event, automatically tagging messages with the event ID. */
-var EventLogger = class extends __prostojs_logger.ProstoLogger {
-	constructor(eventId, opts) {
-		const _opts = opts || { level: 4 };
-		if (!_opts.mapper) _opts.mapper = (msg) => ({
-			...msg,
-			eventId
-		});
-		if (!_opts.transports) _opts.transports = [(0, __prostojs_logger.createConsoleTransort)({ format: __prostojs_logger.coloredConsole })];
-		super(_opts, opts?.topic || "event");
+//#region packages/event-core/src/kind.ts
+/**
+* Type-level marker used inside `defineEventKind` schemas. Each `slot<T>()`
+* becomes a typed `Key<T>` on the resulting `EventKind`. Has no runtime behavior.
+*
+* @example
+* ```ts
+* const httpKind = defineEventKind('http', {
+*   req: slot<IncomingMessage>(),
+*   response: slot<HttpResponse>(),
+* })
+* ```
+*/
+function slot() {
+	return {};
+}
+/**
+* Declares a named event kind with typed seed slots. The returned object
+* contains `keys` — typed accessors for reading seed values from context —
+* and is passed to `ctx.seed(kind, seeds)` or `createEventContext()`.
+*
+* @param name - Unique event kind name (e.g. `'http'`, `'cli'`, `'workflow'`)
+* @param schema - Object mapping slot names to `slot<T>()` markers
+* @returns An `EventKind` with typed `keys` for context access
+*
+* @example
+* ```ts
+* const httpKind = defineEventKind('http', {
+*   req: slot<IncomingMessage>(),
+*   response: slot<HttpResponse>(),
+* })
+*
+* // Access typed seed values:
+* const req = ctx.get(httpKind.keys.req) // IncomingMessage
+* ```
+*/
+function defineEventKind(name, schema) {
+	const keys = {};
+	const _entries = [];
+	for (const prop of Object.keys(schema)) {
+		const k = key(`${name}.${prop}`);
+		keys[prop] = k;
+		_entries.push([prop, k]);
 	}
-};
+	return {
+		name,
+		keys,
+		_entries
+	};
+}
 
 //#endregion
-//#region packages/event-core/src/composables/event-logger.ts
+//#region packages/event-core/src/wook.ts
 /**
-* Composable that provides a logger scoped to the current event context.
+* Creates a composable with per-event caching. The factory runs once per
+* `EventContext`; subsequent calls within the same event return the cached result.
+*
+* This is the recommended way to build composables in Wooks. All built-in
+* composables (`useRequest`, `useResponse`, `useCookies`, etc.) are created with `defineWook`.
+*
+* @param factory - Receives the `EventContext` and returns the composable's public API
+* @returns A composable function `(ctx?: EventContext) => T`
 *
-* @param topic - Optional topic name to create a sub-logger for.
 * @example
 * ```ts
-* const logger = useEventLogger('my-handler')
-* logger.log('processing request')
+* export const useCurrentUser = defineWook((ctx) => {
+*   const { basicCredentials } = useAuthorization(ctx)
+*   const username = basicCredentials()?.username
+*   return {
+*     username,
+*     profile: async () => username ? await db.findUser(username) : null,
+*   }
+* })
+*
+* // In a handler — factory runs once, cached for the request:
+* const { username, profile } = useCurrentUser()
 * ```
 */
-function useEventLogger(topic) {
-	const { getId } = useEventId();
-	const { store, getCtx } = useAsyncEventContext();
-	const { init } = store("event");
-	const ctx = getCtx();
-	const get = () => init("logger", () => new EventLogger(getId(), ctx.options.eventLogger));
-	return topic ? get().createTopic(topic) : get();
+function defineWook(factory) {
+	const slot$1 = cached(factory);
+	return (ctx) => (ctx ?? current()).get(slot$1);
 }
 
 //#endregion
-//#region packages/event-core/src/composables/route-params.ts
+//#region packages/event-core/src/composables.ts
+const eventIdSlot = cached(() => (0, node_crypto.randomUUID)());
 /**
-* Composable that provides access to route parameters from the current event context.
+* Returns the route parameters for the current event. Works with HTTP
+* routes, CLI commands, workflow steps — any adapter that sets `routeParamsKey`.
+*
+* @param ctx - Optional explicit context (defaults to `current()`)
+* @returns Object with `params` (the full params record) and `get(name)` for typed access
 *
 * @example
 * ```ts
-* const { get, params } = useRouteParams<{ id: string }>()
-* console.log(get('id')) // '123'
-* console.log(params)    // { id: '123' }
+* app.get('/users/:id', () => {
+*   const { params, get } = useRouteParams<{ id: string }>()
+*   console.log(get('id')) // typed as string
+* })
 * ```
 */
-function useRouteParams() {
-	const { store } = useAsyncEventContext();
-	const params = store("routeParams").value || {};
-	function get(name) {
-		return params[name];
-	}
+function useRouteParams(ctx) {
+	const c = ctx ?? current();
+	const params = c.get(routeParamsKey);
 	return {
 		params,
-		get
+		get: (name) => params[name]
 	};
 }
+/**
+* Provides a unique, per-event identifier. The ID is a random UUID, generated
+* lazily on first `getId()` call and cached for the event lifetime.
+*
+* @param ctx - Optional explicit context (defaults to `current()`)
+*
+* @example
+* ```ts
+* const { getId } = useEventId()
+* logger.info(`Request ${getId()}`)
+* ```
+*/
+function useEventId(ctx) {
+	const c = ctx ?? current();
+	return { getId: () => c.get(eventIdSlot) };
+}
 
 //#endregion
 exports.ContextInjector = ContextInjector;
-exports.EventLogger = EventLogger;
-exports.asyncStorage = asyncStorage;
-exports.attachHook = attachHook;
-exports.createAsyncEventContext = createAsyncEventContext;
+exports.EventContext = EventContext;
+exports.cached = cached;
+exports.cachedBy = cachedBy;
+exports.createEventContext = createEventContext;
+exports.current = current;
+exports.defineEventKind = defineEventKind;
+exports.defineWook = defineWook;
+exports.eventTypeKey = eventTypeKey;
 exports.getContextInjector = getContextInjector;
+exports.key = key;
 exports.replaceContextInjector = replaceContextInjector;
-exports.useAsyncEventContext = useAsyncEventContext;
+exports.routeParamsKey = routeParamsKey;
+exports.run = run;
+exports.slot = slot;
+exports.tryGetCurrent = tryGetCurrent;
 exports.useEventId = useEventId;
-exports.useEventLogger = useEventLogger;
+exports.useLogger = useLogger;
 exports.useRouteParams = useRouteParams;