@wooksjs/event-core 0.6.1 → 0.6.3

package/dist/index.cjs

@@ -37,18 +37,27 @@ var ContextInjector = class {
 		const fn = typeof attributes === "function" ? attributes : cb;
 		return fn();
 	}
-	hook(method, name, route) {}
+	hook(_method, _name, _route) {}
 };
 let ci = new ContextInjector();
+/** Returns the current global `ContextInjector` instance. */
 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`.
+*
+* @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'`).
+*/
 function attachHook(target, opts, name) {
 	Object.defineProperty(target, name || "value", {
 		get: opts.get,
@@ -59,14 +68,29 @@ function attachHook(target, opts, name) {
 
 //#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";
+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.`);
+} else {
+	_g[STORAGE_KEY] = new node_async_hooks.AsyncLocalStorage();
+	_g[VERSION_KEY] = CURRENT_VERSION;
+}
 /**
 * AsyncLocalStorage instance
 *
 * Use on your own risk only if you know what you're doing
 */
-const asyncStorage = new node_async_hooks.AsyncLocalStorage();
+const asyncStorage = _g[STORAGE_KEY];
+/** Symbol key for caching store accessors directly on the context object */
+const _storeCacheKey = Symbol("storeCache");
 /**
-* Create Wooks Context
+* Creates a new async event context and returns a runner function to execute callbacks within it.
+*
+* @param data - Initial context store data including the event object and options.
+* @returns A function that runs a callback within the created async context.
 */
 function createAsyncEventContext(data) {
 	const newContext = { ...data };
@@ -76,7 +100,10 @@ function createAsyncEventContext(data) {
 	return (cb) => asyncStorage.run(newContext, () => ci$1.with("Event:start", { eventType: newContext.event.type }, cb));
 }
 /**
-* Use Wooks Context
+* Retrieves the current async event context and returns helpers for reading/writing the store.
+*
+* @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.
 */
 function useAsyncEventContext(expectedTypes) {
 	let cc = asyncStorage.getStore();
@@ -89,12 +116,10 @@ function useAsyncEventContext(expectedTypes) {
 	}
 	return _getCtxHelpers(cc);
 }
-/**
-*
-* @param cc
-* @returns
-*/
 function _getCtxHelpers(cc) {
+	const ccAny = cc;
+	if (!ccAny[_storeCacheKey]) ccAny[_storeCacheKey] = /* @__PURE__ */ new Map();
+	const _storeCache = ccAny[_storeCacheKey];
 	/**
 	* Hook to an event store property
 	*
@@ -102,6 +127,12 @@ function _getCtxHelpers(cc) {
 	* @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,
@@ -115,46 +146,54 @@ function _getCtxHelpers(cc) {
 		};
 		attachHook(obj, {
 			set: (v) => {
-				set(key, v);
+				setSection(v);
 			},
-			get: () => get(key)
+			get: () => getSection()
 		});
 		function init(key2, getter) {
 			if (hasNested(key2)) return getNested(key2);
 			return setNested(key2, getter());
 		}
 		function hook(key2) {
-			const obj$1 = {
+			const hookObj = {
 				value: null,
 				isDefined: null
 			};
-			attachHook(obj$1, {
+			attachHook(hookObj, {
 				set: (v) => setNested(key2, v),
 				get: () => getNested(key2)
 			});
-			attachHook(obj$1, { get: () => hasNested(key2) }, "isDefined");
-			return obj$1;
+			attachHook(hookObj, { get: () => hasNested(key2) }, "isDefined");
+			return hookObj;
 		}
 		function setNested(key2, v) {
-			if (obj.value === void 0) obj.value = {};
-			obj.value[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) {
-			return (obj.value || {})[key2];
+			const section = getSection();
+			return section !== void 0 ? section[key2] : void 0;
 		}
 		function hasNested(key2) {
-			return (obj.value || {})[key2] !== void 0;
+			const section = getSection();
+			return section !== void 0 ? section[key2] !== void 0 : false;
 		}
 		function entries() {
-			return Object.entries(obj.value || {});
+			const section = getSection();
+			return section ? Object.entries(section) : [];
 		}
 		function clear() {
-			obj.value = {};
+			setSection({});
 		}
+		_storeCache.set(key, obj);
 		return obj;
 	}
 	/**
@@ -165,26 +204,14 @@ function _getCtxHelpers(cc) {
 	function getCtx() {
 		return cc;
 	}
-	/**
-	* Get value of event store property
-	*
-	* @param key property name
-	* @returns value of property by name
-	*/
 	function get(key) {
-		return getCtx()[key];
+		return cc[key];
 	}
-	/**
-	* Set value of event store property
-	*
-	* @param key property name
-	* @param v property value
-	*/
 	function set(key, v) {
-		getCtx()[key] = v;
+		cc[key] = v;
 	}
 	const hasParentCtx = () => !!cc.parentCtx;
-	return {
+	const helpers = {
 		getCtx,
 		store,
 		getStore: get,
@@ -198,10 +225,20 @@ function _getCtxHelpers(cc) {
 			return _getCtxHelpers(cc.parentCtx);
 		}
 	};
+	return helpers;
 }
 
 //#endregion
 //#region packages/event-core/src/composables/event-id.ts
+/**
+* Composable that provides a unique event ID for the current event context.
+*
+* @example
+* ```ts
+* const { getId } = useEventId()
+* console.log(getId()) // '550e8400-e29b-41d4-a716-446655440000'
+* ```
+*/
 function useEventId() {
 	const { store } = useAsyncEventContext();
 	const { init } = store("event");
@@ -211,6 +248,7 @@ function useEventId() {
 
 //#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 };
@@ -225,6 +263,16 @@ var EventLogger = class extends __prostojs_logger.ProstoLogger {
 
 //#endregion
 //#region packages/event-core/src/composables/event-logger.ts
+/**
+* Composable that provides a logger scoped to the current event context.
+*
+* @param topic - Optional topic name to create a sub-logger for.
+* @example
+* ```ts
+* const logger = useEventLogger('my-handler')
+* logger.log('processing request')
+* ```
+*/
 function useEventLogger(topic) {
 	const { getId } = useEventId();
 	const { store, getCtx } = useAsyncEventContext();
@@ -236,6 +284,16 @@ function useEventLogger(topic) {
 
 //#endregion
 //#region packages/event-core/src/composables/route-params.ts
+/**
+* Composable that provides access to route parameters from the current event context.
+*
+* @example
+* ```ts
+* const { get, params } = useRouteParams<{ id: string }>()
+* console.log(get('id')) // '123'
+* console.log(params)    // { id: '123' }
+* ```
+*/
 function useRouteParams() {
 	const { store } = useAsyncEventContext();
 	const params = store("routeParams").value || {};

package/dist/index.d.ts

@@ -1,37 +1,71 @@
 import { TConsoleBase, ProstoLogger, TProstoLoggerOptions } from '@prostojs/logger';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
+/**
+ * Composable that provides a unique event ID for the current event context.
+ *
+ * @example
+ * ```ts
+ * const { getId } = useEventId()
+ * console.log(getId()) // '550e8400-e29b-41d4-a716-446655440000'
+ * ```
+ */
 declare function useEventId(): {
     getId: () => string;
 };
 
+/**
+ * Composable that provides a logger scoped to the current event context.
+ *
+ * @param topic - Optional topic name to create a sub-logger for.
+ * @example
+ * ```ts
+ * const logger = useEventLogger('my-handler')
+ * logger.log('processing request')
+ * ```
+ */
 declare function useEventLogger(topic?: string): TConsoleBase;
 
+/**
+ * Composable that provides access to route parameters from the current event context.
+ *
+ * @example
+ * ```ts
+ * const { get, params } = useRouteParams<{ id: string }>()
+ * console.log(get('id')) // '123'
+ * console.log(params)    // { id: '123' }
+ * ```
+ */
 declare function useRouteParams<T extends object = Record<string, string | string[]>>(): {
     params: T;
     get: <K extends keyof T>(name: K) => T[K];
 };
 
+/** Data shape passed through logger transports, carrying the event ID. */
 interface TEventLoggerData {
     eventId: string;
 }
+/** Logger scoped to a single event, automatically tagging messages with the event ID. */
 declare class EventLogger extends ProstoLogger<TEventLoggerData> {
     constructor(eventId: string, opts?: TEventOptions['eventLogger']);
 }
 
+/** Base event shape shared by all event types. */
 interface TGenericEvent {
     type: string;
     logger?: EventLogger;
     id?: string;
 }
-interface TEmpty {
-}
+/** Empty record type used as a default generic parameter. */
+type TEmpty = Record<string, never>;
 
+/** Configuration options for event context creation. */
 interface TEventOptions {
     eventLogger?: {
         topic?: string;
     } & TProstoLoggerOptions<TEventLoggerData>;
 }
+/** Shape of the context store that holds event data, options, and route params. */
 interface TGenericContextStore<CustomEventType = TEmpty> {
     event: CustomEventType & TGenericEvent;
     options: TEventOptions;
@@ -46,13 +80,20 @@ interface TGenericContextStore<CustomEventType = TEmpty> {
  */
 declare const asyncStorage: AsyncLocalStorage<TGenericContextStore>;
 /**
- * Create Wooks Context
+ * Creates a new async event context and returns a runner function to execute callbacks within it.
+ *
+ * @param data - Initial context store data including the event object and options.
+ * @returns A function that runs a callback within the created async context.
  */
 declare function createAsyncEventContext<S = TEmpty, EventTypeToCreate = TEmpty>(data: S & TGenericContextStore<EventTypeToCreate>): <T>(cb: (...a: any[]) => T) => T;
 /**
- * Use Wooks Context
+ * Retrieves the current async event context and returns helpers for reading/writing the store.
+ *
+ * @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.
  */
 declare function useAsyncEventContext<S = TEmpty, EventType = TEmpty>(expectedTypes?: string | string[]): TCtxHelpers<S & TGenericContextStore<EventType>>;
+/** Helper methods returned by `useAsyncEventContext` for interacting with the context store. */
 interface TCtxHelpers<T> {
     getCtx: () => T;
     store: <K extends keyof Required<T>>(key: K) => {
@@ -85,19 +126,28 @@ interface TCtxHelpers<T> {
 declare class ContextInjector<N> {
     with<T>(name: N, attributes: Record<string, string | number | boolean>, cb: TContextInjectorCallback<T>): T;
     with<T>(name: N, cb: TContextInjectorCallback<T>): T;
-    hook(method: string, name: 'Handler:not_found' | 'Handler:routed', route?: string): void;
+    hook(_method: string, _name: 'Handler:not_found' | 'Handler:routed', _route?: string): void;
 }
 type TContextInjectorCallback<T> = () => T;
+/** Returns the current global `ContextInjector` instance. */
 declare function getContextInjector<N = TContextInjectorHooks>(): ContextInjector<N>;
+/** Replaces the global `ContextInjector` instance (e.g., to integrate with OpenTelemetry). */
 declare function replaceContextInjector(newCi: ContextInjector<string>): void;
 type TContextInjectorHooks = 'Event:start';
 
+/**
+ * Attaches a getter/setter hook to a target object property via `Object.defineProperty`.
+ *
+ * @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'`).
+ */
 declare function attachHook<V = unknown, T extends object | Function = object, P extends PropertyKey = 'value'>(target: T, opts: {
     get: () => V | undefined;
     set?: (value: V) => void;
 }, name?: P): T & THook<V, P>;
-type THook<T = string, K extends PropertyKey = 'value'> = {
-    [key in K]: T;
-};
+/** A record type representing a hooked property on an object. */
+type THook<T = string, K extends PropertyKey = 'value'> = Record<K, T>;
 
-export { ContextInjector, EventLogger, type TContextInjectorHooks, type TCtxHelpers, type TEmpty, type TEventLoggerData, type TEventOptions, type TGenericContextStore, type TGenericEvent, type THook, asyncStorage, attachHook, createAsyncEventContext, getContextInjector, replaceContextInjector, useAsyncEventContext, useEventId, useEventLogger, useRouteParams };
+export { ContextInjector, EventLogger, asyncStorage, attachHook, createAsyncEventContext, getContextInjector, replaceContextInjector, useAsyncEventContext, useEventId, useEventLogger, useRouteParams };
+export type { TContextInjectorHooks, TCtxHelpers, TEmpty, TEventLoggerData, TEventOptions, TGenericContextStore, TGenericEvent, THook };

package/dist/index.mjs

@@ -14,18 +14,27 @@ var ContextInjector = class {
 		const fn = typeof attributes === "function" ? attributes : cb;
 		return fn();
 	}
-	hook(method, name, route) {}
+	hook(_method, _name, _route) {}
 };
 let ci = new ContextInjector();
+/** Returns the current global `ContextInjector` instance. */
 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`.
+*
+* @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'`).
+*/
 function attachHook(target, opts, name) {
 	Object.defineProperty(target, name || "value", {
 		get: opts.get,
@@ -36,14 +45,29 @@ function attachHook(target, opts, name) {
 
 //#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";
+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.`);
+} else {
+	_g[STORAGE_KEY] = new AsyncLocalStorage();
+	_g[VERSION_KEY] = CURRENT_VERSION;
+}
 /**
 * AsyncLocalStorage instance
 *
 * Use on your own risk only if you know what you're doing
 */
-const asyncStorage = new AsyncLocalStorage();
+const asyncStorage = _g[STORAGE_KEY];
+/** Symbol key for caching store accessors directly on the context object */
+const _storeCacheKey = Symbol("storeCache");
 /**
-* Create Wooks Context
+* Creates a new async event context and returns a runner function to execute callbacks within it.
+*
+* @param data - Initial context store data including the event object and options.
+* @returns A function that runs a callback within the created async context.
 */
 function createAsyncEventContext(data) {
 	const newContext = { ...data };
@@ -53,7 +77,10 @@ function createAsyncEventContext(data) {
 	return (cb) => asyncStorage.run(newContext, () => ci$1.with("Event:start", { eventType: newContext.event.type }, cb));
 }
 /**
-* Use Wooks Context
+* Retrieves the current async event context and returns helpers for reading/writing the store.
+*
+* @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.
 */
 function useAsyncEventContext(expectedTypes) {
 	let cc = asyncStorage.getStore();
@@ -66,12 +93,10 @@ function useAsyncEventContext(expectedTypes) {
 	}
 	return _getCtxHelpers(cc);
 }
-/**
-*
-* @param cc
-* @returns
-*/
 function _getCtxHelpers(cc) {
+	const ccAny = cc;
+	if (!ccAny[_storeCacheKey]) ccAny[_storeCacheKey] = /* @__PURE__ */ new Map();
+	const _storeCache = ccAny[_storeCacheKey];
 	/**
 	* Hook to an event store property
 	*
@@ -79,6 +104,12 @@ function _getCtxHelpers(cc) {
 	* @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,
@@ -92,46 +123,54 @@ function _getCtxHelpers(cc) {
 		};
 		attachHook(obj, {
 			set: (v) => {
-				set(key, v);
+				setSection(v);
 			},
-			get: () => get(key)
+			get: () => getSection()
 		});
 		function init(key2, getter) {
 			if (hasNested(key2)) return getNested(key2);
 			return setNested(key2, getter());
 		}
 		function hook(key2) {
-			const obj$1 = {
+			const hookObj = {
 				value: null,
 				isDefined: null
 			};
-			attachHook(obj$1, {
+			attachHook(hookObj, {
 				set: (v) => setNested(key2, v),
 				get: () => getNested(key2)
 			});
-			attachHook(obj$1, { get: () => hasNested(key2) }, "isDefined");
-			return obj$1;
+			attachHook(hookObj, { get: () => hasNested(key2) }, "isDefined");
+			return hookObj;
 		}
 		function setNested(key2, v) {
-			if (obj.value === void 0) obj.value = {};
-			obj.value[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) {
-			return (obj.value || {})[key2];
+			const section = getSection();
+			return section !== void 0 ? section[key2] : void 0;
 		}
 		function hasNested(key2) {
-			return (obj.value || {})[key2] !== void 0;
+			const section = getSection();
+			return section !== void 0 ? section[key2] !== void 0 : false;
 		}
 		function entries() {
-			return Object.entries(obj.value || {});
+			const section = getSection();
+			return section ? Object.entries(section) : [];
 		}
 		function clear() {
-			obj.value = {};
+			setSection({});
 		}
+		_storeCache.set(key, obj);
 		return obj;
 	}
 	/**
@@ -142,26 +181,14 @@ function _getCtxHelpers(cc) {
 	function getCtx() {
 		return cc;
 	}
-	/**
-	* Get value of event store property
-	*
-	* @param key property name
-	* @returns value of property by name
-	*/
 	function get(key) {
-		return getCtx()[key];
+		return cc[key];
 	}
-	/**
-	* Set value of event store property
-	*
-	* @param key property name
-	* @param v property value
-	*/
 	function set(key, v) {
-		getCtx()[key] = v;
+		cc[key] = v;
 	}
 	const hasParentCtx = () => !!cc.parentCtx;
-	return {
+	const helpers = {
 		getCtx,
 		store,
 		getStore: get,
@@ -175,10 +202,20 @@ function _getCtxHelpers(cc) {
 			return _getCtxHelpers(cc.parentCtx);
 		}
 	};
+	return helpers;
 }
 
 //#endregion
 //#region packages/event-core/src/composables/event-id.ts
+/**
+* Composable that provides a unique event ID for the current event context.
+*
+* @example
+* ```ts
+* const { getId } = useEventId()
+* console.log(getId()) // '550e8400-e29b-41d4-a716-446655440000'
+* ```
+*/
 function useEventId() {
 	const { store } = useAsyncEventContext();
 	const { init } = store("event");
@@ -188,6 +225,7 @@ function useEventId() {
 
 //#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 ProstoLogger {
 	constructor(eventId, opts) {
 		const _opts = opts || { level: 4 };
@@ -202,6 +240,16 @@ var EventLogger = class extends ProstoLogger {
 
 //#endregion
 //#region packages/event-core/src/composables/event-logger.ts
+/**
+* Composable that provides a logger scoped to the current event context.
+*
+* @param topic - Optional topic name to create a sub-logger for.
+* @example
+* ```ts
+* const logger = useEventLogger('my-handler')
+* logger.log('processing request')
+* ```
+*/
 function useEventLogger(topic) {
 	const { getId } = useEventId();
 	const { store, getCtx } = useAsyncEventContext();
@@ -213,6 +261,16 @@ function useEventLogger(topic) {
 
 //#endregion
 //#region packages/event-core/src/composables/route-params.ts
+/**
+* Composable that provides access to route parameters from the current event context.
+*
+* @example
+* ```ts
+* const { get, params } = useRouteParams<{ id: string }>()
+* console.log(get('id')) // '123'
+* console.log(params)    // { id: '123' }
+* ```
+*/
 function useRouteParams() {
 	const { store } = useAsyncEventContext();
 	const params = store("routeParams").value || {};

package/package.json

@@ -1,13 +1,36 @@
 {
   "name": "@wooksjs/event-core",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "@wooksjs/event-core",
-  "main": "dist/index.cjs",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "keywords": [
+    "api",
+    "app",
+    "composables",
+    "framework",
+    "http",
+    "prostojs",
+    "rest",
+    "restful",
+    "web",
+    "wooks"
+  ],
+  "homepage": "https://github.com/wooksjs/wooksjs/tree/main/packages/event-core#readme",
+  "bugs": {
+    "url": "https://github.com/wooksjs/wooksjs/issues"
+  },
+  "license": "MIT",
+  "author": "Artem Maltsev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wooksjs/wooksjs.git",
+    "directory": "packages/event-core"
+  },
   "files": [
     "dist"
   ],
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
@@ -16,34 +39,11 @@
       "import": "./dist/index.mjs"
     }
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/wooksjs/wooksjs.git",
-    "directory": "packages/event-core"
-  },
-  "keywords": [
-    "http",
-    "wooks",
-    "composables",
-    "web",
-    "framework",
-    "app",
-    "api",
-    "rest",
-    "restful",
-    "prostojs"
-  ],
-  "author": "Artem Maltsev",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/wooksjs/wooksjs/issues"
-  },
   "dependencies": {
     "@prostojs/logger": "^0.4.3"
   },
-  "homepage": "https://github.com/wooksjs/wooksjs/tree/main/packages/event-core#readme",
   "devDependencies": {
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
   "scripts": {