@geekmidas/services 1.0.3 → 1.0.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @geekmidas/services
 
+## 1.0.4
+
+### Patch Changes
+
+- 🐛 [#3](https://github.com/geekmidas/toolbox/pull/3) [`42fda53`](https://github.com/geekmidas/toolbox/commit/42fda532bdf4489a3352f6a684f5f30beafccedd) Thanks [@geekmidas](https://github.com/geekmidas)! - Fix stale logger from service initialization
+
 ## 1.0.3
 
 ### Patch Changes

package/README.md

@@ -286,6 +286,30 @@ const db3 = await serviceDiscovery.discover(databaseService);
 console.log(db1 === db2 && db2 === db3); // true
 ```
 
+### Request-Scoped Logging
+
+Because services are singletons, `register()` runs **once** while the per-request
+logger changes on every request. `serviceContext.getLogger()` returns a
+**request-scoped proxy** that re-resolves the current request's logger on each call,
+so a service can safely capture the logger once during `register()` and still log
+against the correct request:
+
+```typescript
+register({ context }) {
+  const logger = context.getLogger().child({ svc: 'db' }); // ✅ safe to capture
+
+  return {
+    async query(sql: string) {
+      logger.debug({ sql }, 'Executing query'); // logs to the CURRENT request
+    },
+  };
+}
+```
+
+See [docs/request-scoped-logging.md](./docs/request-scoped-logging.md) for the full
+problem description (and the bug it prevents: a captured logger freezing the first
+request's `requestId` for every later request).
+
 ## Error Handling
 
 Handle service initialization errors gracefully:

package/dist/{ServiceDiscovery-ykolgkIj.d.mts → ServiceDiscovery-CadEgTKz.d.mts}

@@ -1,4 +1,4 @@
-import { Service } from "./types-CcHmCx_U.mjs";
+import { Service } from "./types-B99KrvXR.mjs";
 import { EnvironmentParser } from "@geekmidas/envkit";
 
 //#region src/ServiceDiscovery.d.ts
@@ -184,4 +184,4 @@ type ServiceRecord<T extends Service[]> = { [K in T[number] as K['serviceName']]
 //# sourceMappingURL=ServiceDiscovery.d.ts.map
 //#endregion
 export { ExtractServiceNames, ServiceDiscovery, ServiceRecord };
-//# sourceMappingURL=ServiceDiscovery-ykolgkIj.d.mts.map
+//# sourceMappingURL=ServiceDiscovery-CadEgTKz.d.mts.map

package/dist/{ServiceDiscovery-ykolgkIj.d.mts.map → ServiceDiscovery-CadEgTKz.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"ServiceDiscovery-ykolgkIj.d.mts","names":[],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;AAgL8B;AAoB9B;AAA+B,cApMlB,gBAoMkB,CAAA,kBApMiB,MAoMjB,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAA,SAAW,SAAA,EAlJT,iBAkJS,CAAA,CAAA,CAAA,CAAA;EAAO;EAAO,eAAA,SAAA;EAiB5C;EAAa,QAAA,QAAA;EAAA;EAAkB,QACpC,SAAA;EAAC;;;;;;AACG;;;;;;;+BAlMmB,uCACjB,wBACT,iBAAiB;;;;;;;;;;;;;;;;;;yBA2BY;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BP,qBAAqB,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;sBAwCpD,0BAA0B,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;2BA6BrC,kCACnB,KACT,gBAAgB,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;wBA6BnB;;;;;;;;;;;;;KAoBX,8BAA8B,aAAa;;;;;;;;;;;;;;;;KAiB3C,wBAAwB,qBAC7B,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}
+{"version":3,"file":"ServiceDiscovery-CadEgTKz.d.mts","names":[],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;AAgL8B;AAoB9B;AAA+B,cApMlB,gBAoMkB,CAAA,kBApMiB,MAoMjB,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAA,SAAW,SAAA,EAlJT,iBAkJS,CAAA,CAAA,CAAA,CAAA;EAAO;EAAO,eAAA,SAAA;EAiB5C;EAAa,QAAA,QAAA;EAAA;EAAkB,QACpC,SAAA;EAAC;;;;;;AACG;;;;;;;+BAlMmB,uCACjB,wBACT,iBAAiB;;;;;;;;;;;;;;;;;;yBA2BY;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BP,qBAAqB,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;sBAwCpD,0BAA0B,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;2BA6BrC,kCACnB,KACT,gBAAgB,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;wBA6BnB;;;;;;;;;;;;;KAoBX,8BAA8B,aAAa;;;;;;;;;;;;;;;;KAiB3C,wBAAwB,qBAC7B,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}

package/dist/{ServiceDiscovery-C5x1wcN1.cjs → ServiceDiscovery-Cxus7ber.cjs}

@@ -1,4 +1,4 @@
-const require_context = require('./context-CoyHq8lH.cjs');
+const require_context = require('./context-CkCPt2Fe.cjs');
 
 //#region src/ServiceDiscovery.ts
 /**
@@ -195,4 +195,4 @@ Object.defineProperty(exports, 'ServiceDiscovery', {
     return ServiceDiscovery;
   }
 });
-//# sourceMappingURL=ServiceDiscovery-C5x1wcN1.cjs.map
+//# sourceMappingURL=ServiceDiscovery-Cxus7ber.cjs.map

package/dist/{ServiceDiscovery-C5x1wcN1.cjs.map → ServiceDiscovery-Cxus7ber.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"ServiceDiscovery-C5x1wcN1.cjs","names":["envParser: EnvironmentParser<{}>","services: T","serviceContext","name: K","names: [...K]","service: string | Service"],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport { serviceContext } from './context';\nimport type { Service } from './types';\n\n/**\n * Service discovery container that manages service registration and retrieval.\n * Implements a singleton pattern with lazy initialization of services.\n *\n * @template TServices - Record type mapping service names to their instance types\n *\n * @example\n * ```typescript\n * // Define service types\n * interface MyServices {\n *   database: Database;\n *   cache: CacheService;\n *   auth: AuthService;\n * }\n *\n * // Get service discovery instance\n * const discovery = ServiceDiscovery.getInstance<MyServices>(envParser);\n *\n * // Register services\n * await discovery.register([\n *   databaseService,\n *   cacheService,\n *   authService\n * ]);\n *\n * // Retrieve services\n * const db = await discovery.get('database');\n * const { cache, auth } = await discovery.getMany(['cache', 'auth']);\n * ```\n */\nexport class ServiceDiscovery<TServices extends Record<string, unknown> = {}> {\n\t/** Singleton instance of ServiceDiscovery */\n\tprivate static _instance: ServiceDiscovery<any>;\n\t/** Map of registered service definitions */\n\tprivate services = new Map<string, Service>();\n\t/** Map of instantiated service instances */\n\tprivate instances = new Map<keyof TServices, TServices[keyof TServices]>();\n\n\t/**\n\t * Gets the singleton instance of ServiceDiscovery.\n\t * Creates a new instance if one doesn't exist.\n\t *\n\t * @template T - Record type mapping service names to their instance types\n\t * @param envParser - Environment parser for service configuration\n\t * @returns The ServiceDiscovery singleton instance\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = ServiceDiscovery.getInstance<MyServices>(envParser);\n\t * ```\n\t */\n\tstatic getInstance<T extends Record<any, unknown> = any>(\n\t\tenvParser: EnvironmentParser<{}>,\n\t): ServiceDiscovery<T> {\n\t\tif (!ServiceDiscovery._instance) {\n\t\t\tServiceDiscovery._instance = new ServiceDiscovery<T>(envParser);\n\t\t}\n\t\treturn ServiceDiscovery._instance as ServiceDiscovery<T>;\n\t}\n\n\t/**\n\t * Resets the singleton instance. Use only for testing purposes.\n\t * This clears all cached services and allows a fresh instance to be created.\n\t *\n\t * @example\n\t * ```typescript\n\t * // In test teardown\n\t * afterEach(() => {\n\t *   ServiceDiscovery.reset();\n\t * });\n\t * ```\n\t */\n\tstatic reset(): void {\n\t\tServiceDiscovery._instance = undefined as any;\n\t}\n\n\t/**\n\t *\n\t * @param envParser - Environment parser for service configuration\n\t */\n\tconstructor(readonly envParser: EnvironmentParser<{}>) {}\n\n\t/**\n\t * Register multiple services with the service discovery.\n\t * Services are instantiated lazily on first access.\n\t * Already instantiated services are returned from cache.\n\t *\n\t * @template T - Array type of services to register\n\t * @param services - Array of services to register\n\t * @returns Promise resolving to a record of service names to instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = await discovery.register([\n\t *   databaseService,\n\t *   cacheService,\n\t *   authService\n\t * ]);\n\t *\n\t * // services = {\n\t * //   database: Database instance,\n\t * //   cache: CacheService instance,\n\t * //   auth: AuthService instance\n\t * // }\n\t * ```\n\t */\n\tasync register<T extends Service[]>(services: T): Promise<ServiceRecord<T>> {\n\t\tconst registeredServices = {} as ServiceRecord<T>;\n\t\tfor (const service of services) {\n\t\t\tconst name = service.serviceName as T[number]['serviceName'];\n\t\t\tif (this.instances.has(name)) {\n\t\t\t\t(registeredServices as any)[name] = this.instances.get(\n\t\t\t\t\tname,\n\t\t\t\t) as TServices[keyof TServices];\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Pass both envParser and context to service\n\t\t\tconst instance = await service.register({\n\t\t\t\tenvParser: this.envParser,\n\t\t\t\tcontext: serviceContext,\n\t\t\t});\n\n\t\t\tthis.instances.set(name, instance as TServices[keyof TServices]);\n\t\t\t(registeredServices as any)[name] =\n\t\t\t\tinstance as TServices[keyof TServices];\n\t\t}\n\n\t\treturn registeredServices;\n\t}\n\n\t/**\n\t * Get a service from the service discovery.\n\t * Services are instantiated on first access if not already cached.\n\t *\n\t * @template K - The service name key\n\t * @param name - The name of the service to get\n\t * @returns Promise resolving to the service instance\n\t * @throws {Error} If the service is not registered\n\t *\n\t * @example\n\t * ```typescript\n\t * const database = await discovery.get('database');\n\t * const users = await database.query('SELECT * FROM users');\n\t * ```\n\t */\n\tget<K extends keyof TServices & string>(name: K): Promise<TServices[K]> {\n\t\tconst service = this.services.get(name);\n\n\t\tif (!service) {\n\t\t\tthrow new Error(`Service '${name}' not found in service discovery`);\n\t\t}\n\n\t\treturn service.register({\n\t\t\tenvParser: this.envParser,\n\t\t\tcontext: serviceContext,\n\t\t}) as Promise<TServices[K]>;\n\t}\n\t/**\n\t * Get multiple services from the service discovery.\n\t * Useful for retrieving multiple dependencies at once.\n\t *\n\t * @template K - Array of service name keys\n\t * @param names - Array of service names to retrieve\n\t * @returns Promise resolving to an object containing the service instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const { database, cache, auth } = await discovery.getMany([\n\t *   'database',\n\t *   'cache',\n\t *   'auth'\n\t * ]);\n\t * ```\n\t */\n\tasync getMany<K extends (keyof TServices & string)[]>(\n\t\tnames: [...K],\n\t): Promise<{ [P in K[number]]: TServices[P] }> {\n\t\tconst result = {} as { [P in K[number]]: TServices[P] };\n\n\t\tfor (const name of names) {\n\t\t\tresult[name] = await this.get(name);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/**\n\t * Check if a service exists in the service discovery.\n\t * Can check by service name or service instance.\n\t *\n\t * @param service - The service name or service instance to check\n\t * @returns True if the service exists, false otherwise\n\t *\n\t * @example\n\t * ```typescript\n\t * if (discovery.has('database')) {\n\t *   const db = await discovery.get('database');\n\t * }\n\t *\n\t * // Or check with service instance\n\t * if (!discovery.has(databaseService)) {\n\t *   await discovery.register([databaseService]);\n\t * }\n\t * ```\n\t */\n\thas(service: string | Service): boolean {\n\t\tif (typeof service === 'string') {\n\t\t\treturn this.services.has(service);\n\t\t}\n\n\t\treturn this.services.has(service.serviceName);\n\t}\n}\n\n/**\n * Utility type to extract service names from an array of services.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type Names = ExtractServiceNames<[typeof databaseService, typeof cacheService]>;\n * // type Names = 'database' | 'cache'\n * ```\n */\nexport type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];\n\n/**\n * Utility type to create a record type from an array of services.\n * Maps service names to their registered instance types.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type MyServiceRecord = ServiceRecord<[typeof databaseService, typeof cacheService]>;\n * // type MyServiceRecord = {\n * //   database: DatabaseInstance;\n * //   cache: CacheInstance;\n * // }\n * ```\n */\nexport type ServiceRecord<T extends Service[]> = {\n\t[K in T[number] as K['serviceName']]: K extends Service\n\t\t? Awaited<ReturnType<K['register']>>\n\t\t: never;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,mBAAb,MAAa,iBAAiE;;CAE7E,OAAe;;CAEf,AAAQ,2BAAW,IAAI;;CAEvB,AAAQ,4BAAY,IAAI;;;;;;;;;;;;;;CAexB,OAAO,YACNA,WACsB;AACtB,OAAK,iBAAiB,UACrB,kBAAiB,YAAY,IAAI,iBAAoB;AAEtD,SAAO,iBAAiB;CACxB;;;;;;;;;;;;;CAcD,OAAO,QAAc;AACpB,mBAAiB;CACjB;;;;;CAMD,YAAqBA,WAAkC;EAAlC;CAAoC;;;;;;;;;;;;;;;;;;;;;;;;;CA0BzD,MAAM,SAA8BC,UAAwC;EAC3E,MAAM,qBAAqB,CAAE;AAC7B,OAAK,MAAM,WAAW,UAAU;GAC/B,MAAM,OAAO,QAAQ;AACrB,OAAI,KAAK,UAAU,IAAI,KAAK,EAAE;AAC7B,IAAC,mBAA2B,QAAQ,KAAK,UAAU,IAClD,KACA;AACD;GACA;GAGD,MAAM,WAAW,MAAM,QAAQ,SAAS;IACvC,WAAW,KAAK;IAChB,SAASC;GACT,EAAC;AAEF,QAAK,UAAU,IAAI,MAAM,SAAuC;AAChE,GAAC,mBAA2B,QAC3B;EACD;AAED,SAAO;CACP;;;;;;;;;;;;;;;;CAiBD,IAAwCC,MAAgC;EACvE,MAAM,UAAU,KAAK,SAAS,IAAI,KAAK;AAEvC,OAAK,QACJ,OAAM,IAAI,OAAO,WAAW,KAAK;AAGlC,SAAO,QAAQ,SAAS;GACvB,WAAW,KAAK;GAChB,SAASD;EACT,EAAC;CACF;;;;;;;;;;;;;;;;;;CAkBD,MAAM,QACLE,OAC8C;EAC9C,MAAM,SAAS,CAAE;AAEjB,OAAK,MAAM,QAAQ,MAClB,QAAO,QAAQ,MAAM,KAAK,IAAI,KAAK;AAGpC,SAAO;CACP;;;;;;;;;;;;;;;;;;;;CAqBD,IAAIC,SAAoC;AACvC,aAAW,YAAY,SACtB,QAAO,KAAK,SAAS,IAAI,QAAQ;AAGlC,SAAO,KAAK,SAAS,IAAI,QAAQ,YAAY;CAC7C;AACD"}
+{"version":3,"file":"ServiceDiscovery-Cxus7ber.cjs","names":["envParser: EnvironmentParser<{}>","services: T","serviceContext","name: K","names: [...K]","service: string | Service"],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport { serviceContext } from './context';\nimport type { Service } from './types';\n\n/**\n * Service discovery container that manages service registration and retrieval.\n * Implements a singleton pattern with lazy initialization of services.\n *\n * @template TServices - Record type mapping service names to their instance types\n *\n * @example\n * ```typescript\n * // Define service types\n * interface MyServices {\n *   database: Database;\n *   cache: CacheService;\n *   auth: AuthService;\n * }\n *\n * // Get service discovery instance\n * const discovery = ServiceDiscovery.getInstance<MyServices>(envParser);\n *\n * // Register services\n * await discovery.register([\n *   databaseService,\n *   cacheService,\n *   authService\n * ]);\n *\n * // Retrieve services\n * const db = await discovery.get('database');\n * const { cache, auth } = await discovery.getMany(['cache', 'auth']);\n * ```\n */\nexport class ServiceDiscovery<TServices extends Record<string, unknown> = {}> {\n\t/** Singleton instance of ServiceDiscovery */\n\tprivate static _instance: ServiceDiscovery<any>;\n\t/** Map of registered service definitions */\n\tprivate services = new Map<string, Service>();\n\t/** Map of instantiated service instances */\n\tprivate instances = new Map<keyof TServices, TServices[keyof TServices]>();\n\n\t/**\n\t * Gets the singleton instance of ServiceDiscovery.\n\t * Creates a new instance if one doesn't exist.\n\t *\n\t * @template T - Record type mapping service names to their instance types\n\t * @param envParser - Environment parser for service configuration\n\t * @returns The ServiceDiscovery singleton instance\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = ServiceDiscovery.getInstance<MyServices>(envParser);\n\t * ```\n\t */\n\tstatic getInstance<T extends Record<any, unknown> = any>(\n\t\tenvParser: EnvironmentParser<{}>,\n\t): ServiceDiscovery<T> {\n\t\tif (!ServiceDiscovery._instance) {\n\t\t\tServiceDiscovery._instance = new ServiceDiscovery<T>(envParser);\n\t\t}\n\t\treturn ServiceDiscovery._instance as ServiceDiscovery<T>;\n\t}\n\n\t/**\n\t * Resets the singleton instance. Use only for testing purposes.\n\t * This clears all cached services and allows a fresh instance to be created.\n\t *\n\t * @example\n\t * ```typescript\n\t * // In test teardown\n\t * afterEach(() => {\n\t *   ServiceDiscovery.reset();\n\t * });\n\t * ```\n\t */\n\tstatic reset(): void {\n\t\tServiceDiscovery._instance = undefined as any;\n\t}\n\n\t/**\n\t *\n\t * @param envParser - Environment parser for service configuration\n\t */\n\tconstructor(readonly envParser: EnvironmentParser<{}>) {}\n\n\t/**\n\t * Register multiple services with the service discovery.\n\t * Services are instantiated lazily on first access.\n\t * Already instantiated services are returned from cache.\n\t *\n\t * @template T - Array type of services to register\n\t * @param services - Array of services to register\n\t * @returns Promise resolving to a record of service names to instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = await discovery.register([\n\t *   databaseService,\n\t *   cacheService,\n\t *   authService\n\t * ]);\n\t *\n\t * // services = {\n\t * //   database: Database instance,\n\t * //   cache: CacheService instance,\n\t * //   auth: AuthService instance\n\t * // }\n\t * ```\n\t */\n\tasync register<T extends Service[]>(services: T): Promise<ServiceRecord<T>> {\n\t\tconst registeredServices = {} as ServiceRecord<T>;\n\t\tfor (const service of services) {\n\t\t\tconst name = service.serviceName as T[number]['serviceName'];\n\t\t\tif (this.instances.has(name)) {\n\t\t\t\t(registeredServices as any)[name] = this.instances.get(\n\t\t\t\t\tname,\n\t\t\t\t) as TServices[keyof TServices];\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Pass both envParser and context to service\n\t\t\tconst instance = await service.register({\n\t\t\t\tenvParser: this.envParser,\n\t\t\t\tcontext: serviceContext,\n\t\t\t});\n\n\t\t\tthis.instances.set(name, instance as TServices[keyof TServices]);\n\t\t\t(registeredServices as any)[name] =\n\t\t\t\tinstance as TServices[keyof TServices];\n\t\t}\n\n\t\treturn registeredServices;\n\t}\n\n\t/**\n\t * Get a service from the service discovery.\n\t * Services are instantiated on first access if not already cached.\n\t *\n\t * @template K - The service name key\n\t * @param name - The name of the service to get\n\t * @returns Promise resolving to the service instance\n\t * @throws {Error} If the service is not registered\n\t *\n\t * @example\n\t * ```typescript\n\t * const database = await discovery.get('database');\n\t * const users = await database.query('SELECT * FROM users');\n\t * ```\n\t */\n\tget<K extends keyof TServices & string>(name: K): Promise<TServices[K]> {\n\t\tconst service = this.services.get(name);\n\n\t\tif (!service) {\n\t\t\tthrow new Error(`Service '${name}' not found in service discovery`);\n\t\t}\n\n\t\treturn service.register({\n\t\t\tenvParser: this.envParser,\n\t\t\tcontext: serviceContext,\n\t\t}) as Promise<TServices[K]>;\n\t}\n\t/**\n\t * Get multiple services from the service discovery.\n\t * Useful for retrieving multiple dependencies at once.\n\t *\n\t * @template K - Array of service name keys\n\t * @param names - Array of service names to retrieve\n\t * @returns Promise resolving to an object containing the service instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const { database, cache, auth } = await discovery.getMany([\n\t *   'database',\n\t *   'cache',\n\t *   'auth'\n\t * ]);\n\t * ```\n\t */\n\tasync getMany<K extends (keyof TServices & string)[]>(\n\t\tnames: [...K],\n\t): Promise<{ [P in K[number]]: TServices[P] }> {\n\t\tconst result = {} as { [P in K[number]]: TServices[P] };\n\n\t\tfor (const name of names) {\n\t\t\tresult[name] = await this.get(name);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/**\n\t * Check if a service exists in the service discovery.\n\t * Can check by service name or service instance.\n\t *\n\t * @param service - The service name or service instance to check\n\t * @returns True if the service exists, false otherwise\n\t *\n\t * @example\n\t * ```typescript\n\t * if (discovery.has('database')) {\n\t *   const db = await discovery.get('database');\n\t * }\n\t *\n\t * // Or check with service instance\n\t * if (!discovery.has(databaseService)) {\n\t *   await discovery.register([databaseService]);\n\t * }\n\t * ```\n\t */\n\thas(service: string | Service): boolean {\n\t\tif (typeof service === 'string') {\n\t\t\treturn this.services.has(service);\n\t\t}\n\n\t\treturn this.services.has(service.serviceName);\n\t}\n}\n\n/**\n * Utility type to extract service names from an array of services.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type Names = ExtractServiceNames<[typeof databaseService, typeof cacheService]>;\n * // type Names = 'database' | 'cache'\n * ```\n */\nexport type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];\n\n/**\n * Utility type to create a record type from an array of services.\n * Maps service names to their registered instance types.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type MyServiceRecord = ServiceRecord<[typeof databaseService, typeof cacheService]>;\n * // type MyServiceRecord = {\n * //   database: DatabaseInstance;\n * //   cache: CacheInstance;\n * // }\n * ```\n */\nexport type ServiceRecord<T extends Service[]> = {\n\t[K in T[number] as K['serviceName']]: K extends Service\n\t\t? Awaited<ReturnType<K['register']>>\n\t\t: never;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,mBAAb,MAAa,iBAAiE;;CAE7E,OAAe;;CAEf,AAAQ,2BAAW,IAAI;;CAEvB,AAAQ,4BAAY,IAAI;;;;;;;;;;;;;;CAexB,OAAO,YACNA,WACsB;AACtB,OAAK,iBAAiB,UACrB,kBAAiB,YAAY,IAAI,iBAAoB;AAEtD,SAAO,iBAAiB;CACxB;;;;;;;;;;;;;CAcD,OAAO,QAAc;AACpB,mBAAiB;CACjB;;;;;CAMD,YAAqBA,WAAkC;EAAlC;CAAoC;;;;;;;;;;;;;;;;;;;;;;;;;CA0BzD,MAAM,SAA8BC,UAAwC;EAC3E,MAAM,qBAAqB,CAAE;AAC7B,OAAK,MAAM,WAAW,UAAU;GAC/B,MAAM,OAAO,QAAQ;AACrB,OAAI,KAAK,UAAU,IAAI,KAAK,EAAE;AAC7B,IAAC,mBAA2B,QAAQ,KAAK,UAAU,IAClD,KACA;AACD;GACA;GAGD,MAAM,WAAW,MAAM,QAAQ,SAAS;IACvC,WAAW,KAAK;IAChB,SAASC;GACT,EAAC;AAEF,QAAK,UAAU,IAAI,MAAM,SAAuC;AAChE,GAAC,mBAA2B,QAC3B;EACD;AAED,SAAO;CACP;;;;;;;;;;;;;;;;CAiBD,IAAwCC,MAAgC;EACvE,MAAM,UAAU,KAAK,SAAS,IAAI,KAAK;AAEvC,OAAK,QACJ,OAAM,IAAI,OAAO,WAAW,KAAK;AAGlC,SAAO,QAAQ,SAAS;GACvB,WAAW,KAAK;GAChB,SAASD;EACT,EAAC;CACF;;;;;;;;;;;;;;;;;;CAkBD,MAAM,QACLE,OAC8C;EAC9C,MAAM,SAAS,CAAE;AAEjB,OAAK,MAAM,QAAQ,MAClB,QAAO,QAAQ,MAAM,KAAK,IAAI,KAAK;AAGpC,SAAO;CACP;;;;;;;;;;;;;;;;;;;;CAqBD,IAAIC,SAAoC;AACvC,aAAW,YAAY,SACtB,QAAO,KAAK,SAAS,IAAI,QAAQ;AAGlC,SAAO,KAAK,SAAS,IAAI,QAAQ,YAAY;CAC7C;AACD"}

package/dist/{ServiceDiscovery-Dvqa-Q1_.d.cts → ServiceDiscovery-DF4OKEZp.d.cts}

@@ -1,4 +1,4 @@
-import { Service } from "./types-D7d_yeU5.cjs";
+import { Service } from "./types-BY9yrY6Y.cjs";
 import { EnvironmentParser } from "@geekmidas/envkit";
 
 //#region src/ServiceDiscovery.d.ts
@@ -184,4 +184,4 @@ type ServiceRecord<T extends Service[]> = { [K in T[number] as K['serviceName']]
 //# sourceMappingURL=ServiceDiscovery.d.ts.map
 //#endregion
 export { ExtractServiceNames, ServiceDiscovery, ServiceRecord };
-//# sourceMappingURL=ServiceDiscovery-Dvqa-Q1_.d.cts.map
+//# sourceMappingURL=ServiceDiscovery-DF4OKEZp.d.cts.map

package/dist/{ServiceDiscovery-Dvqa-Q1_.d.cts.map → ServiceDiscovery-DF4OKEZp.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"ServiceDiscovery-Dvqa-Q1_.d.cts","names":[],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;AAgL8B;AAoB9B;AAA+B,cApMlB,gBAoMkB,CAAA,kBApMiB,MAoMjB,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAA,SAAW,SAAA,EAlJT,iBAkJS,CAAA,CAAA,CAAA,CAAA;EAAO;EAAO,eAAA,SAAA;EAiB5C;EAAa,QAAA,QAAA;EAAA;EAAkB,QACpC,SAAA;EAAC;;;;;;AACG;;;;;;;+BAlMmB,uCACjB,wBACT,iBAAiB;;;;;;;;;;;;;;;;;;yBA2BY;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BP,qBAAqB,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;sBAwCpD,0BAA0B,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;2BA6BrC,kCACnB,KACT,gBAAgB,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;wBA6BnB;;;;;;;;;;;;;KAoBX,8BAA8B,aAAa;;;;;;;;;;;;;;;;KAiB3C,wBAAwB,qBAC7B,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}
+{"version":3,"file":"ServiceDiscovery-DF4OKEZp.d.cts","names":[],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;AAgL8B;AAoB9B;AAA+B,cApMlB,gBAoMkB,CAAA,kBApMiB,MAoMjB,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAA,SAAW,SAAA,EAlJT,iBAkJS,CAAA,CAAA,CAAA,CAAA;EAAO;EAAO,eAAA,SAAA;EAiB5C;EAAa,QAAA,QAAA;EAAA;EAAkB,QACpC,SAAA;EAAC;;;;;;AACG;;;;;;;+BAlMmB,uCACjB,wBACT,iBAAiB;;;;;;;;;;;;;;;;;;yBA2BY;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BP,qBAAqB,IAAI,QAAQ,cAAc;;;;;;;;;;;;;;;;sBAwCpD,0BAA0B,IAAI,QAAQ,UAAU;;;;;;;;;;;;;;;;;;2BA6BrC,kCACnB,KACT,gBAAgB,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;wBA6BnB;;;;;;;;;;;;;KAoBX,8BAA8B,aAAa;;;;;;;;;;;;;;;;KAiB3C,wBAAwB,qBAC7B,aAAa,mBAAmB,UAAU,UAC7C,QAAQ,WAAW"}

package/dist/{ServiceDiscovery-tZ6VKHIZ.mjs → ServiceDiscovery-SujDuYHr.mjs}

@@ -1,4 +1,4 @@
-import { serviceContext } from "./context-BpYagzpr.mjs";
+import { serviceContext } from "./context-BojeLlxs.mjs";
 
 //#region src/ServiceDiscovery.ts
 /**
@@ -190,4 +190,4 @@ var ServiceDiscovery = class ServiceDiscovery {
 
 //#endregion
 export { ServiceDiscovery };
-//# sourceMappingURL=ServiceDiscovery-tZ6VKHIZ.mjs.map
+//# sourceMappingURL=ServiceDiscovery-SujDuYHr.mjs.map

package/dist/{ServiceDiscovery-tZ6VKHIZ.mjs.map → ServiceDiscovery-SujDuYHr.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"ServiceDiscovery-tZ6VKHIZ.mjs","names":["envParser: EnvironmentParser<{}>","services: T","name: K","names: [...K]","service: string | Service"],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport { serviceContext } from './context';\nimport type { Service } from './types';\n\n/**\n * Service discovery container that manages service registration and retrieval.\n * Implements a singleton pattern with lazy initialization of services.\n *\n * @template TServices - Record type mapping service names to their instance types\n *\n * @example\n * ```typescript\n * // Define service types\n * interface MyServices {\n *   database: Database;\n *   cache: CacheService;\n *   auth: AuthService;\n * }\n *\n * // Get service discovery instance\n * const discovery = ServiceDiscovery.getInstance<MyServices>(envParser);\n *\n * // Register services\n * await discovery.register([\n *   databaseService,\n *   cacheService,\n *   authService\n * ]);\n *\n * // Retrieve services\n * const db = await discovery.get('database');\n * const { cache, auth } = await discovery.getMany(['cache', 'auth']);\n * ```\n */\nexport class ServiceDiscovery<TServices extends Record<string, unknown> = {}> {\n\t/** Singleton instance of ServiceDiscovery */\n\tprivate static _instance: ServiceDiscovery<any>;\n\t/** Map of registered service definitions */\n\tprivate services = new Map<string, Service>();\n\t/** Map of instantiated service instances */\n\tprivate instances = new Map<keyof TServices, TServices[keyof TServices]>();\n\n\t/**\n\t * Gets the singleton instance of ServiceDiscovery.\n\t * Creates a new instance if one doesn't exist.\n\t *\n\t * @template T - Record type mapping service names to their instance types\n\t * @param envParser - Environment parser for service configuration\n\t * @returns The ServiceDiscovery singleton instance\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = ServiceDiscovery.getInstance<MyServices>(envParser);\n\t * ```\n\t */\n\tstatic getInstance<T extends Record<any, unknown> = any>(\n\t\tenvParser: EnvironmentParser<{}>,\n\t): ServiceDiscovery<T> {\n\t\tif (!ServiceDiscovery._instance) {\n\t\t\tServiceDiscovery._instance = new ServiceDiscovery<T>(envParser);\n\t\t}\n\t\treturn ServiceDiscovery._instance as ServiceDiscovery<T>;\n\t}\n\n\t/**\n\t * Resets the singleton instance. Use only for testing purposes.\n\t * This clears all cached services and allows a fresh instance to be created.\n\t *\n\t * @example\n\t * ```typescript\n\t * // In test teardown\n\t * afterEach(() => {\n\t *   ServiceDiscovery.reset();\n\t * });\n\t * ```\n\t */\n\tstatic reset(): void {\n\t\tServiceDiscovery._instance = undefined as any;\n\t}\n\n\t/**\n\t *\n\t * @param envParser - Environment parser for service configuration\n\t */\n\tconstructor(readonly envParser: EnvironmentParser<{}>) {}\n\n\t/**\n\t * Register multiple services with the service discovery.\n\t * Services are instantiated lazily on first access.\n\t * Already instantiated services are returned from cache.\n\t *\n\t * @template T - Array type of services to register\n\t * @param services - Array of services to register\n\t * @returns Promise resolving to a record of service names to instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = await discovery.register([\n\t *   databaseService,\n\t *   cacheService,\n\t *   authService\n\t * ]);\n\t *\n\t * // services = {\n\t * //   database: Database instance,\n\t * //   cache: CacheService instance,\n\t * //   auth: AuthService instance\n\t * // }\n\t * ```\n\t */\n\tasync register<T extends Service[]>(services: T): Promise<ServiceRecord<T>> {\n\t\tconst registeredServices = {} as ServiceRecord<T>;\n\t\tfor (const service of services) {\n\t\t\tconst name = service.serviceName as T[number]['serviceName'];\n\t\t\tif (this.instances.has(name)) {\n\t\t\t\t(registeredServices as any)[name] = this.instances.get(\n\t\t\t\t\tname,\n\t\t\t\t) as TServices[keyof TServices];\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Pass both envParser and context to service\n\t\t\tconst instance = await service.register({\n\t\t\t\tenvParser: this.envParser,\n\t\t\t\tcontext: serviceContext,\n\t\t\t});\n\n\t\t\tthis.instances.set(name, instance as TServices[keyof TServices]);\n\t\t\t(registeredServices as any)[name] =\n\t\t\t\tinstance as TServices[keyof TServices];\n\t\t}\n\n\t\treturn registeredServices;\n\t}\n\n\t/**\n\t * Get a service from the service discovery.\n\t * Services are instantiated on first access if not already cached.\n\t *\n\t * @template K - The service name key\n\t * @param name - The name of the service to get\n\t * @returns Promise resolving to the service instance\n\t * @throws {Error} If the service is not registered\n\t *\n\t * @example\n\t * ```typescript\n\t * const database = await discovery.get('database');\n\t * const users = await database.query('SELECT * FROM users');\n\t * ```\n\t */\n\tget<K extends keyof TServices & string>(name: K): Promise<TServices[K]> {\n\t\tconst service = this.services.get(name);\n\n\t\tif (!service) {\n\t\t\tthrow new Error(`Service '${name}' not found in service discovery`);\n\t\t}\n\n\t\treturn service.register({\n\t\t\tenvParser: this.envParser,\n\t\t\tcontext: serviceContext,\n\t\t}) as Promise<TServices[K]>;\n\t}\n\t/**\n\t * Get multiple services from the service discovery.\n\t * Useful for retrieving multiple dependencies at once.\n\t *\n\t * @template K - Array of service name keys\n\t * @param names - Array of service names to retrieve\n\t * @returns Promise resolving to an object containing the service instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const { database, cache, auth } = await discovery.getMany([\n\t *   'database',\n\t *   'cache',\n\t *   'auth'\n\t * ]);\n\t * ```\n\t */\n\tasync getMany<K extends (keyof TServices & string)[]>(\n\t\tnames: [...K],\n\t): Promise<{ [P in K[number]]: TServices[P] }> {\n\t\tconst result = {} as { [P in K[number]]: TServices[P] };\n\n\t\tfor (const name of names) {\n\t\t\tresult[name] = await this.get(name);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/**\n\t * Check if a service exists in the service discovery.\n\t * Can check by service name or service instance.\n\t *\n\t * @param service - The service name or service instance to check\n\t * @returns True if the service exists, false otherwise\n\t *\n\t * @example\n\t * ```typescript\n\t * if (discovery.has('database')) {\n\t *   const db = await discovery.get('database');\n\t * }\n\t *\n\t * // Or check with service instance\n\t * if (!discovery.has(databaseService)) {\n\t *   await discovery.register([databaseService]);\n\t * }\n\t * ```\n\t */\n\thas(service: string | Service): boolean {\n\t\tif (typeof service === 'string') {\n\t\t\treturn this.services.has(service);\n\t\t}\n\n\t\treturn this.services.has(service.serviceName);\n\t}\n}\n\n/**\n * Utility type to extract service names from an array of services.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type Names = ExtractServiceNames<[typeof databaseService, typeof cacheService]>;\n * // type Names = 'database' | 'cache'\n * ```\n */\nexport type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];\n\n/**\n * Utility type to create a record type from an array of services.\n * Maps service names to their registered instance types.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type MyServiceRecord = ServiceRecord<[typeof databaseService, typeof cacheService]>;\n * // type MyServiceRecord = {\n * //   database: DatabaseInstance;\n * //   cache: CacheInstance;\n * // }\n * ```\n */\nexport type ServiceRecord<T extends Service[]> = {\n\t[K in T[number] as K['serviceName']]: K extends Service\n\t\t? Awaited<ReturnType<K['register']>>\n\t\t: never;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,mBAAb,MAAa,iBAAiE;;CAE7E,OAAe;;CAEf,AAAQ,2BAAW,IAAI;;CAEvB,AAAQ,4BAAY,IAAI;;;;;;;;;;;;;;CAexB,OAAO,YACNA,WACsB;AACtB,OAAK,iBAAiB,UACrB,kBAAiB,YAAY,IAAI,iBAAoB;AAEtD,SAAO,iBAAiB;CACxB;;;;;;;;;;;;;CAcD,OAAO,QAAc;AACpB,mBAAiB;CACjB;;;;;CAMD,YAAqBA,WAAkC;EAAlC;CAAoC;;;;;;;;;;;;;;;;;;;;;;;;;CA0BzD,MAAM,SAA8BC,UAAwC;EAC3E,MAAM,qBAAqB,CAAE;AAC7B,OAAK,MAAM,WAAW,UAAU;GAC/B,MAAM,OAAO,QAAQ;AACrB,OAAI,KAAK,UAAU,IAAI,KAAK,EAAE;AAC7B,IAAC,mBAA2B,QAAQ,KAAK,UAAU,IAClD,KACA;AACD;GACA;GAGD,MAAM,WAAW,MAAM,QAAQ,SAAS;IACvC,WAAW,KAAK;IAChB,SAAS;GACT,EAAC;AAEF,QAAK,UAAU,IAAI,MAAM,SAAuC;AAChE,GAAC,mBAA2B,QAC3B;EACD;AAED,SAAO;CACP;;;;;;;;;;;;;;;;CAiBD,IAAwCC,MAAgC;EACvE,MAAM,UAAU,KAAK,SAAS,IAAI,KAAK;AAEvC,OAAK,QACJ,OAAM,IAAI,OAAO,WAAW,KAAK;AAGlC,SAAO,QAAQ,SAAS;GACvB,WAAW,KAAK;GAChB,SAAS;EACT,EAAC;CACF;;;;;;;;;;;;;;;;;;CAkBD,MAAM,QACLC,OAC8C;EAC9C,MAAM,SAAS,CAAE;AAEjB,OAAK,MAAM,QAAQ,MAClB,QAAO,QAAQ,MAAM,KAAK,IAAI,KAAK;AAGpC,SAAO;CACP;;;;;;;;;;;;;;;;;;;;CAqBD,IAAIC,SAAoC;AACvC,aAAW,YAAY,SACtB,QAAO,KAAK,SAAS,IAAI,QAAQ;AAGlC,SAAO,KAAK,SAAS,IAAI,QAAQ,YAAY;CAC7C;AACD"}
+{"version":3,"file":"ServiceDiscovery-SujDuYHr.mjs","names":["envParser: EnvironmentParser<{}>","services: T","name: K","names: [...K]","service: string | Service"],"sources":["../src/ServiceDiscovery.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport { serviceContext } from './context';\nimport type { Service } from './types';\n\n/**\n * Service discovery container that manages service registration and retrieval.\n * Implements a singleton pattern with lazy initialization of services.\n *\n * @template TServices - Record type mapping service names to their instance types\n *\n * @example\n * ```typescript\n * // Define service types\n * interface MyServices {\n *   database: Database;\n *   cache: CacheService;\n *   auth: AuthService;\n * }\n *\n * // Get service discovery instance\n * const discovery = ServiceDiscovery.getInstance<MyServices>(envParser);\n *\n * // Register services\n * await discovery.register([\n *   databaseService,\n *   cacheService,\n *   authService\n * ]);\n *\n * // Retrieve services\n * const db = await discovery.get('database');\n * const { cache, auth } = await discovery.getMany(['cache', 'auth']);\n * ```\n */\nexport class ServiceDiscovery<TServices extends Record<string, unknown> = {}> {\n\t/** Singleton instance of ServiceDiscovery */\n\tprivate static _instance: ServiceDiscovery<any>;\n\t/** Map of registered service definitions */\n\tprivate services = new Map<string, Service>();\n\t/** Map of instantiated service instances */\n\tprivate instances = new Map<keyof TServices, TServices[keyof TServices]>();\n\n\t/**\n\t * Gets the singleton instance of ServiceDiscovery.\n\t * Creates a new instance if one doesn't exist.\n\t *\n\t * @template T - Record type mapping service names to their instance types\n\t * @param envParser - Environment parser for service configuration\n\t * @returns The ServiceDiscovery singleton instance\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = ServiceDiscovery.getInstance<MyServices>(envParser);\n\t * ```\n\t */\n\tstatic getInstance<T extends Record<any, unknown> = any>(\n\t\tenvParser: EnvironmentParser<{}>,\n\t): ServiceDiscovery<T> {\n\t\tif (!ServiceDiscovery._instance) {\n\t\t\tServiceDiscovery._instance = new ServiceDiscovery<T>(envParser);\n\t\t}\n\t\treturn ServiceDiscovery._instance as ServiceDiscovery<T>;\n\t}\n\n\t/**\n\t * Resets the singleton instance. Use only for testing purposes.\n\t * This clears all cached services and allows a fresh instance to be created.\n\t *\n\t * @example\n\t * ```typescript\n\t * // In test teardown\n\t * afterEach(() => {\n\t *   ServiceDiscovery.reset();\n\t * });\n\t * ```\n\t */\n\tstatic reset(): void {\n\t\tServiceDiscovery._instance = undefined as any;\n\t}\n\n\t/**\n\t *\n\t * @param envParser - Environment parser for service configuration\n\t */\n\tconstructor(readonly envParser: EnvironmentParser<{}>) {}\n\n\t/**\n\t * Register multiple services with the service discovery.\n\t * Services are instantiated lazily on first access.\n\t * Already instantiated services are returned from cache.\n\t *\n\t * @template T - Array type of services to register\n\t * @param services - Array of services to register\n\t * @returns Promise resolving to a record of service names to instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const services = await discovery.register([\n\t *   databaseService,\n\t *   cacheService,\n\t *   authService\n\t * ]);\n\t *\n\t * // services = {\n\t * //   database: Database instance,\n\t * //   cache: CacheService instance,\n\t * //   auth: AuthService instance\n\t * // }\n\t * ```\n\t */\n\tasync register<T extends Service[]>(services: T): Promise<ServiceRecord<T>> {\n\t\tconst registeredServices = {} as ServiceRecord<T>;\n\t\tfor (const service of services) {\n\t\t\tconst name = service.serviceName as T[number]['serviceName'];\n\t\t\tif (this.instances.has(name)) {\n\t\t\t\t(registeredServices as any)[name] = this.instances.get(\n\t\t\t\t\tname,\n\t\t\t\t) as TServices[keyof TServices];\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Pass both envParser and context to service\n\t\t\tconst instance = await service.register({\n\t\t\t\tenvParser: this.envParser,\n\t\t\t\tcontext: serviceContext,\n\t\t\t});\n\n\t\t\tthis.instances.set(name, instance as TServices[keyof TServices]);\n\t\t\t(registeredServices as any)[name] =\n\t\t\t\tinstance as TServices[keyof TServices];\n\t\t}\n\n\t\treturn registeredServices;\n\t}\n\n\t/**\n\t * Get a service from the service discovery.\n\t * Services are instantiated on first access if not already cached.\n\t *\n\t * @template K - The service name key\n\t * @param name - The name of the service to get\n\t * @returns Promise resolving to the service instance\n\t * @throws {Error} If the service is not registered\n\t *\n\t * @example\n\t * ```typescript\n\t * const database = await discovery.get('database');\n\t * const users = await database.query('SELECT * FROM users');\n\t * ```\n\t */\n\tget<K extends keyof TServices & string>(name: K): Promise<TServices[K]> {\n\t\tconst service = this.services.get(name);\n\n\t\tif (!service) {\n\t\t\tthrow new Error(`Service '${name}' not found in service discovery`);\n\t\t}\n\n\t\treturn service.register({\n\t\t\tenvParser: this.envParser,\n\t\t\tcontext: serviceContext,\n\t\t}) as Promise<TServices[K]>;\n\t}\n\t/**\n\t * Get multiple services from the service discovery.\n\t * Useful for retrieving multiple dependencies at once.\n\t *\n\t * @template K - Array of service name keys\n\t * @param names - Array of service names to retrieve\n\t * @returns Promise resolving to an object containing the service instances\n\t *\n\t * @example\n\t * ```typescript\n\t * const { database, cache, auth } = await discovery.getMany([\n\t *   'database',\n\t *   'cache',\n\t *   'auth'\n\t * ]);\n\t * ```\n\t */\n\tasync getMany<K extends (keyof TServices & string)[]>(\n\t\tnames: [...K],\n\t): Promise<{ [P in K[number]]: TServices[P] }> {\n\t\tconst result = {} as { [P in K[number]]: TServices[P] };\n\n\t\tfor (const name of names) {\n\t\t\tresult[name] = await this.get(name);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/**\n\t * Check if a service exists in the service discovery.\n\t * Can check by service name or service instance.\n\t *\n\t * @param service - The service name or service instance to check\n\t * @returns True if the service exists, false otherwise\n\t *\n\t * @example\n\t * ```typescript\n\t * if (discovery.has('database')) {\n\t *   const db = await discovery.get('database');\n\t * }\n\t *\n\t * // Or check with service instance\n\t * if (!discovery.has(databaseService)) {\n\t *   await discovery.register([databaseService]);\n\t * }\n\t * ```\n\t */\n\thas(service: string | Service): boolean {\n\t\tif (typeof service === 'string') {\n\t\t\treturn this.services.has(service);\n\t\t}\n\n\t\treturn this.services.has(service.serviceName);\n\t}\n}\n\n/**\n * Utility type to extract service names from an array of services.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type Names = ExtractServiceNames<[typeof databaseService, typeof cacheService]>;\n * // type Names = 'database' | 'cache'\n * ```\n */\nexport type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];\n\n/**\n * Utility type to create a record type from an array of services.\n * Maps service names to their registered instance types.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type MyServiceRecord = ServiceRecord<[typeof databaseService, typeof cacheService]>;\n * // type MyServiceRecord = {\n * //   database: DatabaseInstance;\n * //   cache: CacheInstance;\n * // }\n * ```\n */\nexport type ServiceRecord<T extends Service[]> = {\n\t[K in T[number] as K['serviceName']]: K extends Service\n\t\t? Awaited<ReturnType<K['register']>>\n\t\t: never;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,mBAAb,MAAa,iBAAiE;;CAE7E,OAAe;;CAEf,AAAQ,2BAAW,IAAI;;CAEvB,AAAQ,4BAAY,IAAI;;;;;;;;;;;;;;CAexB,OAAO,YACNA,WACsB;AACtB,OAAK,iBAAiB,UACrB,kBAAiB,YAAY,IAAI,iBAAoB;AAEtD,SAAO,iBAAiB;CACxB;;;;;;;;;;;;;CAcD,OAAO,QAAc;AACpB,mBAAiB;CACjB;;;;;CAMD,YAAqBA,WAAkC;EAAlC;CAAoC;;;;;;;;;;;;;;;;;;;;;;;;;CA0BzD,MAAM,SAA8BC,UAAwC;EAC3E,MAAM,qBAAqB,CAAE;AAC7B,OAAK,MAAM,WAAW,UAAU;GAC/B,MAAM,OAAO,QAAQ;AACrB,OAAI,KAAK,UAAU,IAAI,KAAK,EAAE;AAC7B,IAAC,mBAA2B,QAAQ,KAAK,UAAU,IAClD,KACA;AACD;GACA;GAGD,MAAM,WAAW,MAAM,QAAQ,SAAS;IACvC,WAAW,KAAK;IAChB,SAAS;GACT,EAAC;AAEF,QAAK,UAAU,IAAI,MAAM,SAAuC;AAChE,GAAC,mBAA2B,QAC3B;EACD;AAED,SAAO;CACP;;;;;;;;;;;;;;;;CAiBD,IAAwCC,MAAgC;EACvE,MAAM,UAAU,KAAK,SAAS,IAAI,KAAK;AAEvC,OAAK,QACJ,OAAM,IAAI,OAAO,WAAW,KAAK;AAGlC,SAAO,QAAQ,SAAS;GACvB,WAAW,KAAK;GAChB,SAAS;EACT,EAAC;CACF;;;;;;;;;;;;;;;;;;CAkBD,MAAM,QACLC,OAC8C;EAC9C,MAAM,SAAS,CAAE;AAEjB,OAAK,MAAM,QAAQ,MAClB,QAAO,QAAQ,MAAM,KAAK,IAAI,KAAK;AAGpC,SAAO;CACP;;;;;;;;;;;;;;;;;;;;CAqBD,IAAIC,SAAoC;AACvC,aAAW,YAAY,SACtB,QAAO,KAAK,SAAS,IAAI,QAAQ;AAGlC,SAAO,KAAK,SAAS,IAAI,QAAQ,YAAY;CAC7C;AACD"}

package/dist/ServiceDiscovery.cjs

@@ -1,4 +1,4 @@
-require('./context-CoyHq8lH.cjs');
-const require_ServiceDiscovery = require('./ServiceDiscovery-C5x1wcN1.cjs');
+require('./context-CkCPt2Fe.cjs');
+const require_ServiceDiscovery = require('./ServiceDiscovery-Cxus7ber.cjs');
 
 exports.ServiceDiscovery = require_ServiceDiscovery.ServiceDiscovery;

package/dist/ServiceDiscovery.d.cts

@@ -1,3 +1,3 @@
-import "./types-D7d_yeU5.cjs";
-import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-Dvqa-Q1_.cjs";
+import "./types-BY9yrY6Y.cjs";
+import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-DF4OKEZp.cjs";
 export { ExtractServiceNames, ServiceDiscovery, ServiceRecord };

package/dist/ServiceDiscovery.d.mts

@@ -1,3 +1,3 @@
-import "./types-CcHmCx_U.mjs";
-import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-ykolgkIj.mjs";
+import "./types-B99KrvXR.mjs";
+import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-CadEgTKz.mjs";
 export { ExtractServiceNames, ServiceDiscovery, ServiceRecord };

package/dist/ServiceDiscovery.mjs

@@ -1,4 +1,4 @@
-import "./context-BpYagzpr.mjs";
-import { ServiceDiscovery } from "./ServiceDiscovery-tZ6VKHIZ.mjs";
+import "./context-BojeLlxs.mjs";
+import { ServiceDiscovery } from "./ServiceDiscovery-SujDuYHr.mjs";
 
 export { ServiceDiscovery };

package/dist/{context-BpYagzpr.mjs → context-BojeLlxs.mjs}

@@ -8,15 +8,72 @@ import { AsyncLocalStorage } from "node:async_hooks";
 */
 const requestContextStorage = new AsyncLocalStorage();
 /**
+* Resolve the logger for the current request, or throw if there is none.
+*/
+function resolveRequestLogger() {
+	const store = requestContextStorage.getStore();
+	if (!store) throw new Error("ServiceContext.getLogger() called outside request context. Ensure code runs within runWithRequestContext().");
+	return store.logger;
+}
+/**
+* Create a Logger that re-resolves its underlying logger on every call instead
+* of capturing it once.
+*
+* This is what makes it safe for a **singleton** service to grab the logger a
+* single time (e.g. during `register()`, which `ServiceDiscovery` only runs
+* once and then caches) and reuse that reference for every request: each log
+* call resolves the *current* request's logger from `AsyncLocalStorage`, so
+* requests no longer inherit the first request's logger (and its `requestId`,
+* user bindings, etc.).
+*
+* Implemented as a `Proxy` rather than a fixed list of methods so it forwards
+* the *entire* surface of whatever logger is supplied — including members
+* beyond the base `Logger` interface (e.g. a richer pino-backed logger's
+* `flush()` or `level`) and any methods added to `Logger` in the future.
+*
+* @param bindings - `child()` bindings applied, in order, on top of the
+*   resolved logger before each call.
+*/
+function createRequestScopedLogger(bindings = []) {
+	let cachedBase;
+	let cachedResolved;
+	const resolve = () => {
+		const base = resolveRequestLogger();
+		if (base !== cachedBase) {
+			cachedBase = base;
+			cachedResolved = bindings.reduce((log, obj) => log.child(obj), base);
+		}
+		return cachedResolved;
+	};
+	return new Proxy({}, {
+		get(_target, prop) {
+			if (prop === "child") return (obj) => createRequestScopedLogger([...bindings, obj]);
+			if (prop === "then" || typeof prop === "symbol") return void 0;
+			const value = resolve()[prop];
+			return typeof value === "function" ? (...args) => resolve()[prop](...args) : value;
+		},
+		has(_target, prop) {
+			if (prop === "child") return true;
+			if (prop === "then" || typeof prop === "symbol") return false;
+			return prop in resolve();
+		}
+	});
+}
+/**
+* Stable, process-wide request-scoped logger proxy. Shared across requests on
+* purpose — it carries no request state itself, delegating to the current
+* `AsyncLocalStorage` store on each call.
+*/
+const requestScopedLogger = createRequestScopedLogger();
+/**
 * ServiceContext implementation.
 * Singleton that reads from AsyncLocalStorage.
 * Methods throw if called outside a request context (catches bugs early).
 */
 const serviceContext = {
 	getLogger() {
-		const store = requestContextStorage.getStore();
-		if (!store) throw new Error("ServiceContext.getLogger() called outside request context. Ensure code runs within runWithRequestContext().");
-		return store.logger;
+		resolveRequestLogger();
+		return requestScopedLogger;
 	},
 	getRequestId() {
 		const store = requestContextStorage.getStore();
@@ -81,4 +138,4 @@ function exitRequestContext() {
 
 //#endregion
 export { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };
-//# sourceMappingURL=context-BpYagzpr.mjs.map
+//# sourceMappingURL=context-BojeLlxs.mjs.map

package/dist/context-BojeLlxs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-BojeLlxs.mjs","names":["bindings: object[]","cachedBase: Logger | undefined","cachedResolved: Logger | undefined","obj: object","serviceContext: ServiceContext","data: RequestContextData","fn: () => T | Promise<T>"],"sources":["../src/context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { Logger } from '@geekmidas/logger';\nimport type { ServiceContext } from './types';\n\n/**\n * Internal storage for request context data.\n * Not exported - services use ServiceContext interface.\n */\nexport interface RequestContextData {\n\tlogger: Logger;\n\trequestId: string;\n\tstartTime: number;\n}\n\n/**\n * Internal AsyncLocalStorage instance for request context.\n * Not exported - use runWithRequestContext() to establish context\n * and serviceContext to access it.\n */\nconst requestContextStorage = new AsyncLocalStorage<RequestContextData>();\n\n/**\n * Resolve the logger for the current request, or throw if there is none.\n */\nfunction resolveRequestLogger(): Logger {\n\tconst store = requestContextStorage.getStore();\n\tif (!store) {\n\t\tthrow new Error(\n\t\t\t'ServiceContext.getLogger() called outside request context. ' +\n\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t);\n\t}\n\treturn store.logger;\n}\n\n/**\n * Create a Logger that re-resolves its underlying logger on every call instead\n * of capturing it once.\n *\n * This is what makes it safe for a **singleton** service to grab the logger a\n * single time (e.g. during `register()`, which `ServiceDiscovery` only runs\n * once and then caches) and reuse that reference for every request: each log\n * call resolves the *current* request's logger from `AsyncLocalStorage`, so\n * requests no longer inherit the first request's logger (and its `requestId`,\n * user bindings, etc.).\n *\n * Implemented as a `Proxy` rather than a fixed list of methods so it forwards\n * the *entire* surface of whatever logger is supplied — including members\n * beyond the base `Logger` interface (e.g. a richer pino-backed logger's\n * `flush()` or `level`) and any methods added to `Logger` in the future.\n *\n * @param bindings - `child()` bindings applied, in order, on top of the\n *   resolved logger before each call.\n */\nfunction createRequestScopedLogger(bindings: object[] = []): Logger {\n\t// Memoise the resolved (optionally child) logger per underlying base logger\n\t// so we don't rebuild the child chain on every access within a request.\n\t// Recomputed whenever the current request's logger changes — there is no\n\t// await between the check and use, so this is safe under concurrency.\n\tlet cachedBase: Logger | undefined;\n\tlet cachedResolved: Logger | undefined;\n\n\tconst resolve = (): Logger => {\n\t\tconst base = resolveRequestLogger();\n\t\tif (base !== cachedBase) {\n\t\t\tcachedBase = base;\n\t\t\tcachedResolved = bindings.reduce<Logger>(\n\t\t\t\t(log, obj) => log.child(obj),\n\t\t\t\tbase,\n\t\t\t);\n\t\t}\n\t\treturn cachedResolved as Logger;\n\t};\n\n\treturn new Proxy({} as Logger, {\n\t\tget(_target, prop) {\n\t\t\t// `child()` must stay request-scoped: return a new proxy carrying the\n\t\t\t// extra binding, NOT the underlying logger's child (which would freeze\n\t\t\t// to the current request).\n\t\t\tif (prop === 'child') {\n\t\t\t\treturn (obj: object) => createRequestScopedLogger([...bindings, obj]);\n\t\t\t}\n\t\t\t// Never look like a thenable, and don't answer symbol/inspection probes\n\t\t\t// (util.inspect, Symbol.toPrimitive, etc.) with bound functions.\n\t\t\tif (prop === 'then' || typeof prop === 'symbol') {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tconst value = (resolve() as Record<string, unknown>)[prop];\n\t\t\t// Functions are re-resolved at *call* time so detached references\n\t\t\t// (`const info = logger.info`) still target the current request's\n\t\t\t// logger. Non-function members (e.g. `level`) forward as their live\n\t\t\t// value on the current request's logger.\n\t\t\treturn typeof value === 'function'\n\t\t\t\t? (...args: unknown[]) =>\n\t\t\t\t\t\t(resolve() as Record<string, (...a: unknown[]) => unknown>)[prop](\n\t\t\t\t\t\t\t...args,\n\t\t\t\t\t\t)\n\t\t\t\t: value;\n\t\t},\n\t\t// Keep `'prop' in logger` / hasOwnProperty truthful against the underlying\n\t\t// logger so feature-detection works.\n\t\thas(_target, prop) {\n\t\t\tif (prop === 'child') return true;\n\t\t\tif (prop === 'then' || typeof prop === 'symbol') return false;\n\t\t\treturn prop in (resolve() as object);\n\t\t},\n\t});\n}\n\n/**\n * Stable, process-wide request-scoped logger proxy. Shared across requests on\n * purpose — it carries no request state itself, delegating to the current\n * `AsyncLocalStorage` store on each call.\n */\nconst requestScopedLogger = createRequestScopedLogger();\n\n/**\n * ServiceContext implementation.\n * Singleton that reads from AsyncLocalStorage.\n * Methods throw if called outside a request context (catches bugs early).\n */\nexport const serviceContext: ServiceContext = {\n\tgetLogger() {\n\t\t// Throw eagerly if there is no context, preserving the \"catch bugs early\"\n\t\t// contract for callers that read the logger at an unexpected time.\n\t\tresolveRequestLogger();\n\t\t// Return the shared proxy rather than the raw `store.logger`. A service\n\t\t// that captures this once still logs against the correct per-request\n\t\t// logger because the proxy re-resolves on every call.\n\t\treturn requestScopedLogger;\n\t},\n\n\tgetRequestId() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestId() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.requestId;\n\t},\n\n\tgetRequestStartTime() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestStartTime() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.startTime;\n\t},\n\n\thasContext() {\n\t\treturn requestContextStorage.getStore() !== undefined;\n\t},\n};\n\n/**\n * Run a function with request context.\n * Used by endpoint/function/subscriber adaptors.\n *\n * @param data - Request context data (logger, requestId, startTime)\n * @param fn - Function to run with context\n * @returns Result of the function\n *\n * @example\n * ```typescript\n * const result = await runWithRequestContext(\n *   { logger, requestId, startTime: Date.now() },\n *   async () => {\n *     // Inside here, serviceContext.getLogger() returns `logger`\n *     // serviceContext.getRequestId() returns `requestId`\n *     return await handleRequest();\n *   }\n * );\n * ```\n */\nexport function runWithRequestContext<T>(\n\tdata: RequestContextData,\n\tfn: () => T | Promise<T>,\n): T | Promise<T> {\n\treturn requestContextStorage.run(data, fn);\n}\n\n/**\n * Mutate the current async task's store so that subsequent code in this task\n * (and any descendants) sees the supplied request context.\n *\n * Unlike `runWithRequestContext`, this does not scope the context to a\n * callback — useful when the caller can't wrap a function, for example in a\n * Vitest fixture that suspends on `use()` and yields control to the test\n * runner before the test body executes.\n *\n * **Test setup only.** In production handlers, prefer `runWithRequestContext`\n * so the frame is automatically cleaned up.\n */\nexport function enterRequestContext(data: RequestContextData): void {\n\trequestContextStorage.enterWith(data);\n}\n\n/**\n * Clear the request context for the current async task. Pairs with\n * `enterRequestContext`. After calling, `serviceContext.hasContext()` returns\n * false for the remainder of the current async resource.\n */\nexport function exitRequestContext(): void {\n\t// AsyncLocalStorage<T>.enterWith requires T, but Node accepts undefined at\n\t// runtime — passing it resets getStore() back to undefined.\n\t(requestContextStorage as unknown as AsyncLocalStorage<unknown>).enterWith(\n\t\tundefined,\n\t);\n}\n"],"mappings":";;;;;;;;AAmBA,MAAM,wBAAwB,IAAI;;;;AAKlC,SAAS,uBAA+B;CACvC,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,MAAK,MACJ,OAAM,IAAI,MACT;AAIF,QAAO,MAAM;AACb;;;;;;;;;;;;;;;;;;;;AAqBD,SAAS,0BAA0BA,WAAqB,CAAE,GAAU;CAKnE,IAAIC;CACJ,IAAIC;CAEJ,MAAM,UAAU,MAAc;EAC7B,MAAM,OAAO,sBAAsB;AACnC,MAAI,SAAS,YAAY;AACxB,gBAAa;AACb,oBAAiB,SAAS,OACzB,CAAC,KAAK,QAAQ,IAAI,MAAM,IAAI,EAC5B,KACA;EACD;AACD,SAAO;CACP;AAED,QAAO,IAAI,MAAM,CAAE,GAAY;EAC9B,IAAI,SAAS,MAAM;AAIlB,OAAI,SAAS,QACZ,QAAO,CAACC,QAAgB,0BAA0B,CAAC,GAAG,UAAU,GAAI,EAAC;AAItE,OAAI,SAAS,iBAAiB,SAAS,SACtC;GAED,MAAM,QAAS,SAAS,CAA6B;AAKrD,iBAAc,UAAU,aACrB,CAAC,GAAG,SACJ,AAAC,SAAS,CAAkD,MAC3D,GAAG,KACH,GACD;EACH;EAGD,IAAI,SAAS,MAAM;AAClB,OAAI,SAAS,QAAS,QAAO;AAC7B,OAAI,SAAS,iBAAiB,SAAS,SAAU,QAAO;AACxD,UAAO,QAAS,SAAS;EACzB;CACD;AACD;;;;;;AAOD,MAAM,sBAAsB,2BAA2B;;;;;;AAOvD,MAAaC,iBAAiC;CAC7C,YAAY;AAGX,wBAAsB;AAItB,SAAO;CACP;CAED,eAAe;EACd,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,sBAAsB;EACrB,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,aAAa;AACZ,SAAO,sBAAsB,UAAU;CACvC;AACD;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,sBACfC,MACAC,IACiB;AACjB,QAAO,sBAAsB,IAAI,MAAM,GAAG;AAC1C;;;;;;;;;;;;;AAcD,SAAgB,oBAAoBD,MAAgC;AACnE,uBAAsB,UAAU,KAAK;AACrC;;;;;;AAOD,SAAgB,qBAA2B;AAG1C,CAAC,sBAAgE,iBAEhE;AACD"}

package/dist/{context-CoyHq8lH.cjs → context-CkCPt2Fe.cjs}

@@ -31,15 +31,72 @@ const node_async_hooks = __toESM(require("node:async_hooks"));
 */
 const requestContextStorage = new node_async_hooks.AsyncLocalStorage();
 /**
+* Resolve the logger for the current request, or throw if there is none.
+*/
+function resolveRequestLogger() {
+	const store = requestContextStorage.getStore();
+	if (!store) throw new Error("ServiceContext.getLogger() called outside request context. Ensure code runs within runWithRequestContext().");
+	return store.logger;
+}
+/**
+* Create a Logger that re-resolves its underlying logger on every call instead
+* of capturing it once.
+*
+* This is what makes it safe for a **singleton** service to grab the logger a
+* single time (e.g. during `register()`, which `ServiceDiscovery` only runs
+* once and then caches) and reuse that reference for every request: each log
+* call resolves the *current* request's logger from `AsyncLocalStorage`, so
+* requests no longer inherit the first request's logger (and its `requestId`,
+* user bindings, etc.).
+*
+* Implemented as a `Proxy` rather than a fixed list of methods so it forwards
+* the *entire* surface of whatever logger is supplied — including members
+* beyond the base `Logger` interface (e.g. a richer pino-backed logger's
+* `flush()` or `level`) and any methods added to `Logger` in the future.
+*
+* @param bindings - `child()` bindings applied, in order, on top of the
+*   resolved logger before each call.
+*/
+function createRequestScopedLogger(bindings = []) {
+	let cachedBase;
+	let cachedResolved;
+	const resolve = () => {
+		const base = resolveRequestLogger();
+		if (base !== cachedBase) {
+			cachedBase = base;
+			cachedResolved = bindings.reduce((log, obj) => log.child(obj), base);
+		}
+		return cachedResolved;
+	};
+	return new Proxy({}, {
+		get(_target, prop) {
+			if (prop === "child") return (obj) => createRequestScopedLogger([...bindings, obj]);
+			if (prop === "then" || typeof prop === "symbol") return void 0;
+			const value = resolve()[prop];
+			return typeof value === "function" ? (...args) => resolve()[prop](...args) : value;
+		},
+		has(_target, prop) {
+			if (prop === "child") return true;
+			if (prop === "then" || typeof prop === "symbol") return false;
+			return prop in resolve();
+		}
+	});
+}
+/**
+* Stable, process-wide request-scoped logger proxy. Shared across requests on
+* purpose — it carries no request state itself, delegating to the current
+* `AsyncLocalStorage` store on each call.
+*/
+const requestScopedLogger = createRequestScopedLogger();
+/**
 * ServiceContext implementation.
 * Singleton that reads from AsyncLocalStorage.
 * Methods throw if called outside a request context (catches bugs early).
 */
 const serviceContext = {
 	getLogger() {
-		const store = requestContextStorage.getStore();
-		if (!store) throw new Error("ServiceContext.getLogger() called outside request context. Ensure code runs within runWithRequestContext().");
-		return store.logger;
+		resolveRequestLogger();
+		return requestScopedLogger;
 	},
 	getRequestId() {
 		const store = requestContextStorage.getStore();
@@ -127,4 +184,4 @@ Object.defineProperty(exports, 'serviceContext', {
     return serviceContext;
   }
 });
-//# sourceMappingURL=context-CoyHq8lH.cjs.map
+//# sourceMappingURL=context-CkCPt2Fe.cjs.map

package/dist/context-CkCPt2Fe.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-CkCPt2Fe.cjs","names":["AsyncLocalStorage","bindings: object[]","cachedBase: Logger | undefined","cachedResolved: Logger | undefined","obj: object","serviceContext: ServiceContext","data: RequestContextData","fn: () => T | Promise<T>"],"sources":["../src/context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { Logger } from '@geekmidas/logger';\nimport type { ServiceContext } from './types';\n\n/**\n * Internal storage for request context data.\n * Not exported - services use ServiceContext interface.\n */\nexport interface RequestContextData {\n\tlogger: Logger;\n\trequestId: string;\n\tstartTime: number;\n}\n\n/**\n * Internal AsyncLocalStorage instance for request context.\n * Not exported - use runWithRequestContext() to establish context\n * and serviceContext to access it.\n */\nconst requestContextStorage = new AsyncLocalStorage<RequestContextData>();\n\n/**\n * Resolve the logger for the current request, or throw if there is none.\n */\nfunction resolveRequestLogger(): Logger {\n\tconst store = requestContextStorage.getStore();\n\tif (!store) {\n\t\tthrow new Error(\n\t\t\t'ServiceContext.getLogger() called outside request context. ' +\n\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t);\n\t}\n\treturn store.logger;\n}\n\n/**\n * Create a Logger that re-resolves its underlying logger on every call instead\n * of capturing it once.\n *\n * This is what makes it safe for a **singleton** service to grab the logger a\n * single time (e.g. during `register()`, which `ServiceDiscovery` only runs\n * once and then caches) and reuse that reference for every request: each log\n * call resolves the *current* request's logger from `AsyncLocalStorage`, so\n * requests no longer inherit the first request's logger (and its `requestId`,\n * user bindings, etc.).\n *\n * Implemented as a `Proxy` rather than a fixed list of methods so it forwards\n * the *entire* surface of whatever logger is supplied — including members\n * beyond the base `Logger` interface (e.g. a richer pino-backed logger's\n * `flush()` or `level`) and any methods added to `Logger` in the future.\n *\n * @param bindings - `child()` bindings applied, in order, on top of the\n *   resolved logger before each call.\n */\nfunction createRequestScopedLogger(bindings: object[] = []): Logger {\n\t// Memoise the resolved (optionally child) logger per underlying base logger\n\t// so we don't rebuild the child chain on every access within a request.\n\t// Recomputed whenever the current request's logger changes — there is no\n\t// await between the check and use, so this is safe under concurrency.\n\tlet cachedBase: Logger | undefined;\n\tlet cachedResolved: Logger | undefined;\n\n\tconst resolve = (): Logger => {\n\t\tconst base = resolveRequestLogger();\n\t\tif (base !== cachedBase) {\n\t\t\tcachedBase = base;\n\t\t\tcachedResolved = bindings.reduce<Logger>(\n\t\t\t\t(log, obj) => log.child(obj),\n\t\t\t\tbase,\n\t\t\t);\n\t\t}\n\t\treturn cachedResolved as Logger;\n\t};\n\n\treturn new Proxy({} as Logger, {\n\t\tget(_target, prop) {\n\t\t\t// `child()` must stay request-scoped: return a new proxy carrying the\n\t\t\t// extra binding, NOT the underlying logger's child (which would freeze\n\t\t\t// to the current request).\n\t\t\tif (prop === 'child') {\n\t\t\t\treturn (obj: object) => createRequestScopedLogger([...bindings, obj]);\n\t\t\t}\n\t\t\t// Never look like a thenable, and don't answer symbol/inspection probes\n\t\t\t// (util.inspect, Symbol.toPrimitive, etc.) with bound functions.\n\t\t\tif (prop === 'then' || typeof prop === 'symbol') {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tconst value = (resolve() as Record<string, unknown>)[prop];\n\t\t\t// Functions are re-resolved at *call* time so detached references\n\t\t\t// (`const info = logger.info`) still target the current request's\n\t\t\t// logger. Non-function members (e.g. `level`) forward as their live\n\t\t\t// value on the current request's logger.\n\t\t\treturn typeof value === 'function'\n\t\t\t\t? (...args: unknown[]) =>\n\t\t\t\t\t\t(resolve() as Record<string, (...a: unknown[]) => unknown>)[prop](\n\t\t\t\t\t\t\t...args,\n\t\t\t\t\t\t)\n\t\t\t\t: value;\n\t\t},\n\t\t// Keep `'prop' in logger` / hasOwnProperty truthful against the underlying\n\t\t// logger so feature-detection works.\n\t\thas(_target, prop) {\n\t\t\tif (prop === 'child') return true;\n\t\t\tif (prop === 'then' || typeof prop === 'symbol') return false;\n\t\t\treturn prop in (resolve() as object);\n\t\t},\n\t});\n}\n\n/**\n * Stable, process-wide request-scoped logger proxy. Shared across requests on\n * purpose — it carries no request state itself, delegating to the current\n * `AsyncLocalStorage` store on each call.\n */\nconst requestScopedLogger = createRequestScopedLogger();\n\n/**\n * ServiceContext implementation.\n * Singleton that reads from AsyncLocalStorage.\n * Methods throw if called outside a request context (catches bugs early).\n */\nexport const serviceContext: ServiceContext = {\n\tgetLogger() {\n\t\t// Throw eagerly if there is no context, preserving the \"catch bugs early\"\n\t\t// contract for callers that read the logger at an unexpected time.\n\t\tresolveRequestLogger();\n\t\t// Return the shared proxy rather than the raw `store.logger`. A service\n\t\t// that captures this once still logs against the correct per-request\n\t\t// logger because the proxy re-resolves on every call.\n\t\treturn requestScopedLogger;\n\t},\n\n\tgetRequestId() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestId() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.requestId;\n\t},\n\n\tgetRequestStartTime() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestStartTime() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.startTime;\n\t},\n\n\thasContext() {\n\t\treturn requestContextStorage.getStore() !== undefined;\n\t},\n};\n\n/**\n * Run a function with request context.\n * Used by endpoint/function/subscriber adaptors.\n *\n * @param data - Request context data (logger, requestId, startTime)\n * @param fn - Function to run with context\n * @returns Result of the function\n *\n * @example\n * ```typescript\n * const result = await runWithRequestContext(\n *   { logger, requestId, startTime: Date.now() },\n *   async () => {\n *     // Inside here, serviceContext.getLogger() returns `logger`\n *     // serviceContext.getRequestId() returns `requestId`\n *     return await handleRequest();\n *   }\n * );\n * ```\n */\nexport function runWithRequestContext<T>(\n\tdata: RequestContextData,\n\tfn: () => T | Promise<T>,\n): T | Promise<T> {\n\treturn requestContextStorage.run(data, fn);\n}\n\n/**\n * Mutate the current async task's store so that subsequent code in this task\n * (and any descendants) sees the supplied request context.\n *\n * Unlike `runWithRequestContext`, this does not scope the context to a\n * callback — useful when the caller can't wrap a function, for example in a\n * Vitest fixture that suspends on `use()` and yields control to the test\n * runner before the test body executes.\n *\n * **Test setup only.** In production handlers, prefer `runWithRequestContext`\n * so the frame is automatically cleaned up.\n */\nexport function enterRequestContext(data: RequestContextData): void {\n\trequestContextStorage.enterWith(data);\n}\n\n/**\n * Clear the request context for the current async task. Pairs with\n * `enterRequestContext`. After calling, `serviceContext.hasContext()` returns\n * false for the remainder of the current async resource.\n */\nexport function exitRequestContext(): void {\n\t// AsyncLocalStorage<T>.enterWith requires T, but Node accepts undefined at\n\t// runtime — passing it resets getStore() back to undefined.\n\t(requestContextStorage as unknown as AsyncLocalStorage<unknown>).enterWith(\n\t\tundefined,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,MAAM,wBAAwB,IAAIA;;;;AAKlC,SAAS,uBAA+B;CACvC,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,MAAK,MACJ,OAAM,IAAI,MACT;AAIF,QAAO,MAAM;AACb;;;;;;;;;;;;;;;;;;;;AAqBD,SAAS,0BAA0BC,WAAqB,CAAE,GAAU;CAKnE,IAAIC;CACJ,IAAIC;CAEJ,MAAM,UAAU,MAAc;EAC7B,MAAM,OAAO,sBAAsB;AACnC,MAAI,SAAS,YAAY;AACxB,gBAAa;AACb,oBAAiB,SAAS,OACzB,CAAC,KAAK,QAAQ,IAAI,MAAM,IAAI,EAC5B,KACA;EACD;AACD,SAAO;CACP;AAED,QAAO,IAAI,MAAM,CAAE,GAAY;EAC9B,IAAI,SAAS,MAAM;AAIlB,OAAI,SAAS,QACZ,QAAO,CAACC,QAAgB,0BAA0B,CAAC,GAAG,UAAU,GAAI,EAAC;AAItE,OAAI,SAAS,iBAAiB,SAAS,SACtC;GAED,MAAM,QAAS,SAAS,CAA6B;AAKrD,iBAAc,UAAU,aACrB,CAAC,GAAG,SACJ,AAAC,SAAS,CAAkD,MAC3D,GAAG,KACH,GACD;EACH;EAGD,IAAI,SAAS,MAAM;AAClB,OAAI,SAAS,QAAS,QAAO;AAC7B,OAAI,SAAS,iBAAiB,SAAS,SAAU,QAAO;AACxD,UAAO,QAAS,SAAS;EACzB;CACD;AACD;;;;;;AAOD,MAAM,sBAAsB,2BAA2B;;;;;;AAOvD,MAAaC,iBAAiC;CAC7C,YAAY;AAGX,wBAAsB;AAItB,SAAO;CACP;CAED,eAAe;EACd,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,sBAAsB;EACrB,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,aAAa;AACZ,SAAO,sBAAsB,UAAU;CACvC;AACD;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,sBACfC,MACAC,IACiB;AACjB,QAAO,sBAAsB,IAAI,MAAM,GAAG;AAC1C;;;;;;;;;;;;;AAcD,SAAgB,oBAAoBD,MAAgC;AACnE,uBAAsB,UAAU,KAAK;AACrC;;;;;;AAOD,SAAgB,qBAA2B;AAG1C,CAAC,sBAAgE,iBAEhE;AACD"}

package/dist/{context-CaeISj3o.d.cts → context-D5pIUGkm.d.cts}

@@ -1,4 +1,4 @@
-import { ServiceContext } from "./types-D7d_yeU5.cjs";
+import { ServiceContext } from "./types-BY9yrY6Y.cjs";
 import { Logger } from "@geekmidas/logger";
 
 //#region src/context.d.ts
@@ -61,4 +61,4 @@ declare function exitRequestContext(): void;
 //# sourceMappingURL=context.d.ts.map
 //#endregion
 export { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };
-//# sourceMappingURL=context-CaeISj3o.d.cts.map
+//# sourceMappingURL=context-D5pIUGkm.d.cts.map

package/dist/context-D5pIUGkm.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-D5pIUGkm.d.cts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAiHA;AA0DgB,UA3KC,kBAAA,CA2KoB;EAAA,MAAA,EA1K5B,MA0K4B;EAAA,SAC9B,EAAA,MAAA;EAAkB,SACd,EAAA,MAAA;;;;;;AACG;AAgBE,cA7EH,cA6EsB,EA7EN,cA6Ea;AAS1C;;;;;;;;;;;;;;;;;;;;iBA5BgB,+BACT,8BACI,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;iBAgBC,mBAAA,OAA0B;;;;;;iBAS1B,kBAAA,CAAA"}

package/dist/{context-HGC2PJzv.d.mts → context-OmKid3Mr.d.mts}

@@ -1,4 +1,4 @@
-import { ServiceContext } from "./types-CcHmCx_U.mjs";
+import { ServiceContext } from "./types-B99KrvXR.mjs";
 import { Logger } from "@geekmidas/logger";
 
 //#region src/context.d.ts
@@ -61,4 +61,4 @@ declare function exitRequestContext(): void;
 //# sourceMappingURL=context.d.ts.map
 //#endregion
 export { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };
-//# sourceMappingURL=context-HGC2PJzv.d.mts.map
+//# sourceMappingURL=context-OmKid3Mr.d.mts.map

package/dist/context-OmKid3Mr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-OmKid3Mr.d.mts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAiHA;AA0DgB,UA3KC,kBAAA,CA2KoB;EAAA,MAAA,EA1K5B,MA0K4B;EAAA,SAC9B,EAAA,MAAA;EAAkB,SACd,EAAA,MAAA;;;;;;AACG;AAgBE,cA7EH,cA6EsB,EA7EN,cA6Ea;AAS1C;;;;;;;;;;;;;;;;;;;;iBA5BgB,+BACT,8BACI,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;iBAgBC,mBAAA,OAA0B;;;;;;iBAS1B,kBAAA,CAAA"}

package/dist/context.cjs

@@ -1,4 +1,4 @@
-const require_context = require('./context-CoyHq8lH.cjs');
+const require_context = require('./context-CkCPt2Fe.cjs');
 
 exports.enterRequestContext = require_context.enterRequestContext;
 exports.exitRequestContext = require_context.exitRequestContext;

package/dist/context.d.cts

@@ -1,3 +1,3 @@
-import "./types-D7d_yeU5.cjs";
-import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-CaeISj3o.cjs";
+import "./types-BY9yrY6Y.cjs";
+import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-D5pIUGkm.cjs";
 export { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/context.d.mts

@@ -1,3 +1,3 @@
-import "./types-CcHmCx_U.mjs";
-import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-HGC2PJzv.mjs";
+import "./types-B99KrvXR.mjs";
+import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-OmKid3Mr.mjs";
 export { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/context.mjs

@@ -1,3 +1,3 @@
-import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-BpYagzpr.mjs";
+import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-BojeLlxs.mjs";
 
 export { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/index.cjs

@@ -1,5 +1,5 @@
-const require_context = require('./context-CoyHq8lH.cjs');
-const require_ServiceDiscovery = require('./ServiceDiscovery-C5x1wcN1.cjs');
+const require_context = require('./context-CkCPt2Fe.cjs');
+const require_ServiceDiscovery = require('./ServiceDiscovery-Cxus7ber.cjs');
 
 exports.ServiceDiscovery = require_ServiceDiscovery.ServiceDiscovery;
 exports.enterRequestContext = require_context.enterRequestContext;

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { Service, ServiceContext, ServiceRegisterOptions } from "./types-D7d_yeU5.cjs";
-import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-Dvqa-Q1_.cjs";
-import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-CaeISj3o.cjs";
+import { Service, ServiceContext, ServiceRegisterOptions } from "./types-BY9yrY6Y.cjs";
+import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-DF4OKEZp.cjs";
+import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-D5pIUGkm.cjs";
 export { ExtractServiceNames, RequestContextData, Service, ServiceContext, ServiceDiscovery, ServiceRecord, ServiceRegisterOptions, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { Service, ServiceContext, ServiceRegisterOptions } from "./types-CcHmCx_U.mjs";
-import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-ykolgkIj.mjs";
-import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-HGC2PJzv.mjs";
+import { Service, ServiceContext, ServiceRegisterOptions } from "./types-B99KrvXR.mjs";
+import { ExtractServiceNames, ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-CadEgTKz.mjs";
+import { RequestContextData, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-OmKid3Mr.mjs";
 export { ExtractServiceNames, RequestContextData, Service, ServiceContext, ServiceDiscovery, ServiceRecord, ServiceRegisterOptions, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-BpYagzpr.mjs";
-import { ServiceDiscovery } from "./ServiceDiscovery-tZ6VKHIZ.mjs";
+import { enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext } from "./context-BojeLlxs.mjs";
+import { ServiceDiscovery } from "./ServiceDiscovery-SujDuYHr.mjs";
 
 export { ServiceDiscovery, enterRequestContext, exitRequestContext, runWithRequestContext, serviceContext };

package/dist/{types-CcHmCx_U.d.mts → types-B99KrvXR.d.mts}

@@ -11,6 +11,13 @@ import { Logger } from "@geekmidas/logger";
 interface ServiceContext {
   /**
    * Get the current request's logger.
+   *
+   * Returns a **request-scoped proxy** that re-resolves the underlying logger
+   * from AsyncLocalStorage on every call. This makes it safe for a singleton
+   * service to capture the logger once (e.g. during `register()`) and reuse it
+   * across requests — each log call routes to the current request's logger
+   * instead of freezing the first request's logger.
+   *
    * @throws Error if called outside a request context
    */
   getLogger(): Logger;
@@ -83,4 +90,4 @@ interface Service<TName extends string = string, TInstance = unknown> {
 //# sourceMappingURL=types.d.ts.map
 //#endregion
 export { Service, ServiceContext, ServiceRegisterOptions };
-//# sourceMappingURL=types-CcHmCx_U.d.mts.map
+//# sourceMappingURL=types-B99KrvXR.d.mts.map

package/dist/types-B99KrvXR.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-B99KrvXR.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAqCA;;AAEY,UAvCK,cAAA,CAuCL;EAAiB;AAEL;AA8BxB;;;;;;;AAW+D;;eAtEjD;;;;;;;;;;;;;;;;;;;;;UAyBG,sBAAA;;aAEL;;WAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO;;;;eAIH;;;;;;;oBAOK,yBAAyB,YAAY,QAAQ"}

package/dist/{types-D7d_yeU5.d.cts → types-BY9yrY6Y.d.cts}

@@ -11,6 +11,13 @@ import { Logger } from "@geekmidas/logger";
 interface ServiceContext {
   /**
    * Get the current request's logger.
+   *
+   * Returns a **request-scoped proxy** that re-resolves the underlying logger
+   * from AsyncLocalStorage on every call. This makes it safe for a singleton
+   * service to capture the logger once (e.g. during `register()`) and reuse it
+   * across requests — each log call routes to the current request's logger
+   * instead of freezing the first request's logger.
+   *
    * @throws Error if called outside a request context
    */
   getLogger(): Logger;
@@ -83,4 +90,4 @@ interface Service<TName extends string = string, TInstance = unknown> {
 //# sourceMappingURL=types.d.ts.map
 //#endregion
 export { Service, ServiceContext, ServiceRegisterOptions };
-//# sourceMappingURL=types-D7d_yeU5.d.cts.map
+//# sourceMappingURL=types-BY9yrY6Y.d.cts.map

package/dist/types-BY9yrY6Y.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BY9yrY6Y.d.cts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAqCA;;AAEY,UAvCK,cAAA,CAuCL;EAAiB;AAEL;AA8BxB;;;;;;;AAW+D;;eAtEjD;;;;;;;;;;;;;;;;;;;;;UAyBG,sBAAA;;aAEL;;WAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO;;;;eAIH;;;;;;;oBAOK,yBAAyB,YAAY,QAAQ"}

package/dist/types.d.cts

@@ -1,2 +1,2 @@
-import { Service, ServiceContext, ServiceRegisterOptions } from "./types-D7d_yeU5.cjs";
+import { Service, ServiceContext, ServiceRegisterOptions } from "./types-BY9yrY6Y.cjs";
 export { Service, ServiceContext, ServiceRegisterOptions };

package/dist/types.d.mts

@@ -1,2 +1,2 @@
-import { Service, ServiceContext, ServiceRegisterOptions } from "./types-CcHmCx_U.mjs";
+import { Service, ServiceContext, ServiceRegisterOptions } from "./types-B99KrvXR.mjs";
 export { Service, ServiceContext, ServiceRegisterOptions };

package/docs/request-scoped-logging.md

@@ -0,0 +1,153 @@
+# Request-Scoped Logging in Singleton Services
+
+## Problem
+
+Services in `@geekmidas/services` are **singletons**. `ServiceDiscovery.register()`
+(and `get()`) instantiates a service **once**, caches the instance in an internal
+`Map`, and returns that same instance for every subsequent request:
+
+```ts
+// ServiceDiscovery.register()
+if (this.instances.has(name)) {
+  return this.instances.get(name); // cached — register() does NOT run again
+}
+const instance = await service.register({ envParser, context: serviceContext });
+this.instances.set(name, instance);
+```
+
+The per-request logger, on the other hand, is **not** a singleton. On every request
+an adaptor builds a fresh child logger with request-specific bindings and stores it
+in `AsyncLocalStorage` via `runWithRequestContext`:
+
+```ts
+// e.g. HonoEndpointAdaptor
+const logger = endpoint.logger.child({
+  requestId,          // unique per request
+  endpoint, route, host, method, path,
+});
+
+return runWithRequestContext({ logger, requestId, startTime }, async () => {
+  const services = await serviceDiscovery.register(endpoint.services);
+  // ...handle request...
+});
+```
+
+### The bug
+
+`service.register()` runs **inside the first request's context**. If a service reads
+the logger **at registration time** and stores the concrete reference:
+
+```ts
+const databaseService = {
+  serviceName: 'database' as const,
+  register({ context }) {
+    const logger = context.getLogger(); // ❌ resolved ONCE, during request #1
+
+    return {
+      async query(sql: string) {
+        logger.debug({ sql }, 'Executing query'); // always request #1's logger
+      },
+    };
+  },
+} satisfies Service<'database', Database>;
+```
+
+…then `logger` is frozen to the **first** request's logger forever, because
+`register()` never runs again. Every later request reuses the cached service
+instance, so its logs carry the **first** request's `requestId` (and any user/session
+bindings).
+
+**Symptom:** logs make it look like the user who made the *first* request after a
+cold start is responsible for actions actually performed by *other* users on later
+requests. Request correlation, per-user log filtering, and audit trails are all
+silently wrong.
+
+This is an easy mistake to make because `register()` is handed a `context` object,
+and "grab the logger once and reuse it" looks reasonable — but it is incompatible
+with the singleton lifecycle.
+
+## Solution
+
+`serviceContext.getLogger()` returns a **stable, request-scoped proxy logger**
+instead of the raw logger. The proxy holds no logger of its own — on **every** log
+call it re-resolves the current request's logger from `AsyncLocalStorage`:
+
+```
+proxy.info('x')  →  asyncLocalStorage.getStore().logger.info('x')   // resolved at call time
+```
+
+Because resolution happens per call (not at capture time), capturing the logger once
+during `register()` is now **safe**: the single captured reference routes each call
+to whichever request is currently executing.
+
+```ts
+register({ context }) {
+  const logger = context.getLogger(); // ✅ now safe to capture — it's a live proxy
+
+  return {
+    async query(sql: string) {
+      logger.debug({ sql }, 'Executing query'); // logs to the CURRENT request
+    },
+  };
+}
+```
+
+### Child loggers compose correctly too
+
+`proxy.child(bindings)` returns **another** proxy carrying the bindings, applied lazily
+on top of the current request's logger at call time:
+
+```ts
+register({ context }) {
+  // Captured once. `{ svc: 'db' }` is the static part; the per-request bindings
+  // (requestId, user, ...) come from whichever base logger is current.
+  const logger = context.getLogger().child({ svc: 'db' });
+
+  return {
+    async query(sql: string) {
+      // request A → loggerA.child({ svc: 'db' }).debug(...)
+      // request B → loggerB.child({ svc: 'db' }).debug(...)
+      logger.debug({ sql }, 'Executing query');
+    },
+  };
+}
+```
+
+### Implementation
+
+See `createRequestScopedLogger` in
+[`src/context.ts`](../src/context.ts):
+
+- `getLogger()` still **throws eagerly** if called with no active request context,
+  preserving the "catch bugs early" contract.
+- The returned object is a shared, process-wide proxy. It carries no request state,
+  so sharing it across requests is safe — `AsyncLocalStorage` provides correct
+  per-async-context isolation, and each resolve/log call is synchronous (no `await`
+  between resolving and using the logger), so it is concurrency-safe.
+- Each `child()` call returns a new proxy that remembers its bindings and rebuilds
+  the child chain off the current base logger, memoised per underlying logger to
+  avoid rebuilding the chain on every log line.
+
+## Guidance for service authors
+
+- ✅ You **may** capture `context.getLogger()` (or a `.child()` of it) once in
+  `register()` and reuse it — it stays correct per request.
+- ✅ You **may** also call `context.getLogger()` inside each method; behaviour is
+  identical.
+- ⚠️ Do **not** wrap the proxy in something that snapshots a concrete logger, e.g.
+  `const real = someConcreteLogger; ...` outside the proxy. Resolution only stays
+  live while you go through the proxy returned by `getLogger()`/`.child()`.
+- ⚠️ Calling a log method outside any request context throws
+  (`called outside request context`). Guard background work with
+  `serviceContext.hasContext()` if it may run detached from a request.
+
+## Tests
+
+Regression coverage lives in
+[`src/__tests__/context.spec.ts`](../src/__tests__/context.spec.ts):
+
+- `captured-once logger follows each request (singleton service fix)` — a logger
+  captured during the first request still logs to the second request's logger.
+- `child loggers also follow the current request` — the same guarantee for
+  `.child()` proxies.
+- `should delegate to the current request logger` — basic delegation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/services",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "private": false,
   "type": "module",
   "exports": {

package/src/__tests__/context.spec.ts

@@ -1,7 +1,40 @@
+import type { Logger } from '@geekmidas/logger';
 import { ConsoleLogger } from '@geekmidas/logger/console';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { runWithRequestContext, serviceContext } from '../context';
 
+/** Minimal spy logger whose `child()` returns itself for easy assertions. */
+function makeSpyLogger(): Logger {
+	const logger: Logger = {
+		trace: vi.fn(),
+		debug: vi.fn(),
+		info: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		fatal: vi.fn(),
+		child: vi.fn(() => logger),
+	};
+	return logger;
+}
+
+/**
+ * A logger that carries MORE than the base `Logger` interface: an extra method
+ * (`flush`) and a data property (`level`). Models a richer real-world logger
+ * (e.g. pino) so we can assert the request-scoped proxy forwards the full
+ * surface, not just the known log methods.
+ */
+type ExtendedLogger = Logger & {
+	flush: ReturnType<typeof vi.fn>;
+	level: string;
+};
+
+function makeExtendedSpyLogger(level = 'info'): ExtendedLogger {
+	const logger = makeSpyLogger() as ExtendedLogger;
+	logger.flush = vi.fn();
+	logger.level = level;
+	return logger;
+}
+
 describe('Request Context', () => {
 	const logger = new ConsoleLogger({ app: 'test' });
 
@@ -28,13 +61,156 @@ describe('Request Context', () => {
 				);
 			});
 
-			it('should return logger inside request context', async () => {
+			it('should delegate to the current request logger', async () => {
+				const requestLogger = makeSpyLogger();
 				await runWithRequestContext(
-					{ logger, requestId: 'test-id', startTime: Date.now() },
+					{
+						logger: requestLogger,
+						requestId: 'test-id',
+						startTime: Date.now(),
+					},
 					async () => {
-						expect(serviceContext.getLogger()).toBe(logger);
+						serviceContext.getLogger().info('hello');
 					},
 				);
+				expect(requestLogger.info).toHaveBeenCalledWith('hello');
+			});
+
+			it('captured-once logger follows each request (singleton service fix)', async () => {
+				// Mimic a singleton service that grabs the logger ONCE (during its
+				// one-time register) and reuses that reference for every request.
+				let captured: Logger | undefined;
+				const handle = (requestLogger: Logger) =>
+					runWithRequestContext(
+						{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+						async () => {
+							captured ??= serviceContext.getLogger();
+							captured.info('handled');
+						},
+					);
+
+				const first = makeSpyLogger();
+				const second = makeSpyLogger();
+				await handle(first);
+				await handle(second);
+
+				// Before the fix, the captured logger stayed bound to `first`, so
+				// `second` never saw the call.
+				expect(first.info).toHaveBeenCalledTimes(1);
+				expect(second.info).toHaveBeenCalledTimes(1);
+			});
+
+			it('child loggers also follow the current request', async () => {
+				let capturedChild: Logger | undefined;
+				const handle = (requestLogger: Logger) =>
+					runWithRequestContext(
+						{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+						async () => {
+							capturedChild ??= serviceContext
+								.getLogger()
+								.child({ scope: 'svc' });
+							capturedChild.info('scoped');
+						},
+					);
+
+				const first = makeSpyLogger();
+				const second = makeSpyLogger();
+				await handle(first);
+				await handle(second);
+
+				expect(first.child).toHaveBeenCalledWith({ scope: 'svc' });
+				expect(second.child).toHaveBeenCalledWith({ scope: 'svc' });
+				expect(first.info).toHaveBeenCalledWith('scoped');
+				expect(second.info).toHaveBeenCalledWith('scoped');
+			});
+
+			describe('forwards the full logger surface (logger with more)', () => {
+				it('forwards an extra method beyond the Logger interface', async () => {
+					const requestLogger = makeExtendedSpyLogger();
+					await runWithRequestContext(
+						{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+						async () => {
+							(serviceContext.getLogger() as ExtendedLogger).flush();
+						},
+					);
+					expect(requestLogger.flush).toHaveBeenCalledTimes(1);
+				});
+
+				it('re-resolves an extra method per request when captured once', async () => {
+					let captured: ExtendedLogger | undefined;
+					const handle = (requestLogger: Logger) =>
+						runWithRequestContext(
+							{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+							async () => {
+								captured ??= serviceContext.getLogger() as ExtendedLogger;
+								captured.flush();
+							},
+						);
+
+					const first = makeExtendedSpyLogger();
+					const second = makeExtendedSpyLogger();
+					await handle(first);
+					await handle(second);
+
+					expect(first.flush).toHaveBeenCalledTimes(1);
+					expect(second.flush).toHaveBeenCalledTimes(1);
+				});
+
+				it('forwards a data property as the current request logger value', async () => {
+					const captureLevel = (requestLogger: Logger) =>
+						runWithRequestContext(
+							{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+							async () => (serviceContext.getLogger() as ExtendedLogger).level,
+						);
+
+					const debugLogger = makeExtendedSpyLogger('debug');
+					const warnLogger = makeExtendedSpyLogger('warn');
+
+					expect(await captureLevel(debugLogger)).toBe('debug');
+					expect(await captureLevel(warnLogger)).toBe('warn');
+				});
+
+				it('detached method reference still targets the current request', async () => {
+					const requestLogger = makeExtendedSpyLogger();
+					await runWithRequestContext(
+						{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+						async () => {
+							const { info } = serviceContext.getLogger();
+							info('detached');
+						},
+					);
+					expect(requestLogger.info).toHaveBeenCalledWith('detached');
+				});
+
+				it('reflects underlying membership via the `in` operator', async () => {
+					const requestLogger = makeExtendedSpyLogger();
+					await runWithRequestContext(
+						{ logger: requestLogger, requestId: 'r', startTime: Date.now() },
+						async () => {
+							const proxy = serviceContext.getLogger();
+							expect('flush' in proxy).toBe(true);
+							expect('child' in proxy).toBe(true);
+							expect('nope' in proxy).toBe(false);
+						},
+					);
+				});
+
+				it('is not thenable (safe to return from async / await)', async () => {
+					await runWithRequestContext(
+						{
+							logger: makeExtendedSpyLogger(),
+							requestId: 'r',
+							startTime: Date.now(),
+						},
+						async () => {
+							const proxy = serviceContext.getLogger();
+							expect((proxy as { then?: unknown }).then).toBeUndefined();
+							// Awaiting a non-thenable yields the value itself rather than
+							// hanging or invoking a spurious `then`.
+							expect(await proxy).toBe(proxy);
+						},
+					);
+				});
 			});
 		});
 

package/src/context.ts

@@ -19,6 +19,101 @@ export interface RequestContextData {
  */
 const requestContextStorage = new AsyncLocalStorage<RequestContextData>();
 
+/**
+ * Resolve the logger for the current request, or throw if there is none.
+ */
+function resolveRequestLogger(): Logger {
+	const store = requestContextStorage.getStore();
+	if (!store) {
+		throw new Error(
+			'ServiceContext.getLogger() called outside request context. ' +
+				'Ensure code runs within runWithRequestContext().',
+		);
+	}
+	return store.logger;
+}
+
+/**
+ * Create a Logger that re-resolves its underlying logger on every call instead
+ * of capturing it once.
+ *
+ * This is what makes it safe for a **singleton** service to grab the logger a
+ * single time (e.g. during `register()`, which `ServiceDiscovery` only runs
+ * once and then caches) and reuse that reference for every request: each log
+ * call resolves the *current* request's logger from `AsyncLocalStorage`, so
+ * requests no longer inherit the first request's logger (and its `requestId`,
+ * user bindings, etc.).
+ *
+ * Implemented as a `Proxy` rather than a fixed list of methods so it forwards
+ * the *entire* surface of whatever logger is supplied — including members
+ * beyond the base `Logger` interface (e.g. a richer pino-backed logger's
+ * `flush()` or `level`) and any methods added to `Logger` in the future.
+ *
+ * @param bindings - `child()` bindings applied, in order, on top of the
+ *   resolved logger before each call.
+ */
+function createRequestScopedLogger(bindings: object[] = []): Logger {
+	// Memoise the resolved (optionally child) logger per underlying base logger
+	// so we don't rebuild the child chain on every access within a request.
+	// Recomputed whenever the current request's logger changes — there is no
+	// await between the check and use, so this is safe under concurrency.
+	let cachedBase: Logger | undefined;
+	let cachedResolved: Logger | undefined;
+
+	const resolve = (): Logger => {
+		const base = resolveRequestLogger();
+		if (base !== cachedBase) {
+			cachedBase = base;
+			cachedResolved = bindings.reduce<Logger>(
+				(log, obj) => log.child(obj),
+				base,
+			);
+		}
+		return cachedResolved as Logger;
+	};
+
+	return new Proxy({} as Logger, {
+		get(_target, prop) {
+			// `child()` must stay request-scoped: return a new proxy carrying the
+			// extra binding, NOT the underlying logger's child (which would freeze
+			// to the current request).
+			if (prop === 'child') {
+				return (obj: object) => createRequestScopedLogger([...bindings, obj]);
+			}
+			// Never look like a thenable, and don't answer symbol/inspection probes
+			// (util.inspect, Symbol.toPrimitive, etc.) with bound functions.
+			if (prop === 'then' || typeof prop === 'symbol') {
+				return undefined;
+			}
+			const value = (resolve() as Record<string, unknown>)[prop];
+			// Functions are re-resolved at *call* time so detached references
+			// (`const info = logger.info`) still target the current request's
+			// logger. Non-function members (e.g. `level`) forward as their live
+			// value on the current request's logger.
+			return typeof value === 'function'
+				? (...args: unknown[]) =>
+						(resolve() as Record<string, (...a: unknown[]) => unknown>)[prop](
+							...args,
+						)
+				: value;
+		},
+		// Keep `'prop' in logger` / hasOwnProperty truthful against the underlying
+		// logger so feature-detection works.
+		has(_target, prop) {
+			if (prop === 'child') return true;
+			if (prop === 'then' || typeof prop === 'symbol') return false;
+			return prop in (resolve() as object);
+		},
+	});
+}
+
+/**
+ * Stable, process-wide request-scoped logger proxy. Shared across requests on
+ * purpose — it carries no request state itself, delegating to the current
+ * `AsyncLocalStorage` store on each call.
+ */
+const requestScopedLogger = createRequestScopedLogger();
+
 /**
  * ServiceContext implementation.
  * Singleton that reads from AsyncLocalStorage.
@@ -26,14 +121,13 @@ const requestContextStorage = new AsyncLocalStorage<RequestContextData>();
  */
 export const serviceContext: ServiceContext = {
 	getLogger() {
-		const store = requestContextStorage.getStore();
-		if (!store) {
-			throw new Error(
-				'ServiceContext.getLogger() called outside request context. ' +
-					'Ensure code runs within runWithRequestContext().',
-			);
-		}
-		return store.logger;
+		// Throw eagerly if there is no context, preserving the "catch bugs early"
+		// contract for callers that read the logger at an unexpected time.
+		resolveRequestLogger();
+		// Return the shared proxy rather than the raw `store.logger`. A service
+		// that captures this once still logs against the correct per-request
+		// logger because the proxy re-resolves on every call.
+		return requestScopedLogger;
 	},
 
 	getRequestId() {

package/src/types.ts

@@ -9,6 +9,13 @@ import type { Logger } from '@geekmidas/logger';
 export interface ServiceContext {
 	/**
 	 * Get the current request's logger.
+	 *
+	 * Returns a **request-scoped proxy** that re-resolves the underlying logger
+	 * from AsyncLocalStorage on every call. This makes it safe for a singleton
+	 * service to capture the logger once (e.g. during `register()`) and reuse it
+	 * across requests — each log call routes to the current request's logger
+	 * instead of freezing the first request's logger.
+	 *
 	 * @throws Error if called outside a request context
 	 */
 	getLogger(): Logger;

package/dist/context-BpYagzpr.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-BpYagzpr.mjs","names":["serviceContext: ServiceContext","data: RequestContextData","fn: () => T | Promise<T>"],"sources":["../src/context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { Logger } from '@geekmidas/logger';\nimport type { ServiceContext } from './types';\n\n/**\n * Internal storage for request context data.\n * Not exported - services use ServiceContext interface.\n */\nexport interface RequestContextData {\n\tlogger: Logger;\n\trequestId: string;\n\tstartTime: number;\n}\n\n/**\n * Internal AsyncLocalStorage instance for request context.\n * Not exported - use runWithRequestContext() to establish context\n * and serviceContext to access it.\n */\nconst requestContextStorage = new AsyncLocalStorage<RequestContextData>();\n\n/**\n * ServiceContext implementation.\n * Singleton that reads from AsyncLocalStorage.\n * Methods throw if called outside a request context (catches bugs early).\n */\nexport const serviceContext: ServiceContext = {\n\tgetLogger() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getLogger() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.logger;\n\t},\n\n\tgetRequestId() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestId() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.requestId;\n\t},\n\n\tgetRequestStartTime() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestStartTime() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.startTime;\n\t},\n\n\thasContext() {\n\t\treturn requestContextStorage.getStore() !== undefined;\n\t},\n};\n\n/**\n * Run a function with request context.\n * Used by endpoint/function/subscriber adaptors.\n *\n * @param data - Request context data (logger, requestId, startTime)\n * @param fn - Function to run with context\n * @returns Result of the function\n *\n * @example\n * ```typescript\n * const result = await runWithRequestContext(\n *   { logger, requestId, startTime: Date.now() },\n *   async () => {\n *     // Inside here, serviceContext.getLogger() returns `logger`\n *     // serviceContext.getRequestId() returns `requestId`\n *     return await handleRequest();\n *   }\n * );\n * ```\n */\nexport function runWithRequestContext<T>(\n\tdata: RequestContextData,\n\tfn: () => T | Promise<T>,\n): T | Promise<T> {\n\treturn requestContextStorage.run(data, fn);\n}\n\n/**\n * Mutate the current async task's store so that subsequent code in this task\n * (and any descendants) sees the supplied request context.\n *\n * Unlike `runWithRequestContext`, this does not scope the context to a\n * callback — useful when the caller can't wrap a function, for example in a\n * Vitest fixture that suspends on `use()` and yields control to the test\n * runner before the test body executes.\n *\n * **Test setup only.** In production handlers, prefer `runWithRequestContext`\n * so the frame is automatically cleaned up.\n */\nexport function enterRequestContext(data: RequestContextData): void {\n\trequestContextStorage.enterWith(data);\n}\n\n/**\n * Clear the request context for the current async task. Pairs with\n * `enterRequestContext`. After calling, `serviceContext.hasContext()` returns\n * false for the remainder of the current async resource.\n */\nexport function exitRequestContext(): void {\n\t// AsyncLocalStorage<T>.enterWith requires T, but Node accepts undefined at\n\t// runtime — passing it resets getStore() back to undefined.\n\t(requestContextStorage as unknown as AsyncLocalStorage<unknown>).enterWith(\n\t\tundefined,\n\t);\n}\n"],"mappings":";;;;;;;;AAmBA,MAAM,wBAAwB,IAAI;;;;;;AAOlC,MAAaA,iBAAiC;CAC7C,YAAY;EACX,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,eAAe;EACd,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,sBAAsB;EACrB,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,aAAa;AACZ,SAAO,sBAAsB,UAAU;CACvC;AACD;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,sBACfC,MACAC,IACiB;AACjB,QAAO,sBAAsB,IAAI,MAAM,GAAG;AAC1C;;;;;;;;;;;;;AAcD,SAAgB,oBAAoBD,MAAgC;AACnE,uBAAsB,UAAU,KAAK;AACrC;;;;;;AAOD,SAAgB,qBAA2B;AAG1C,CAAC,sBAAgE,iBAEhE;AACD"}

package/dist/context-CaeISj3o.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-CaeISj3o.d.cts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAkBA;AA2DgB,UA7EC,kBAAA,CA6EoB;EAAA,MAAA,EA5E5B,MA4E4B;EAAA,SAC9B,EAAA,MAAA;EAAkB,SACd,EAAA,MAAA;;;;;;AACG;AAgBE,cA9EH,cA8EsB,EA9EN,cA8Ea;AAS1C;;;;;;;;;;;;;;;;;;;;iBA5BgB,+BACT,8BACI,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;iBAgBC,mBAAA,OAA0B;;;;;;iBAS1B,kBAAA,CAAA"}

package/dist/context-CoyHq8lH.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-CoyHq8lH.cjs","names":["AsyncLocalStorage","serviceContext: ServiceContext","data: RequestContextData","fn: () => T | Promise<T>"],"sources":["../src/context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { Logger } from '@geekmidas/logger';\nimport type { ServiceContext } from './types';\n\n/**\n * Internal storage for request context data.\n * Not exported - services use ServiceContext interface.\n */\nexport interface RequestContextData {\n\tlogger: Logger;\n\trequestId: string;\n\tstartTime: number;\n}\n\n/**\n * Internal AsyncLocalStorage instance for request context.\n * Not exported - use runWithRequestContext() to establish context\n * and serviceContext to access it.\n */\nconst requestContextStorage = new AsyncLocalStorage<RequestContextData>();\n\n/**\n * ServiceContext implementation.\n * Singleton that reads from AsyncLocalStorage.\n * Methods throw if called outside a request context (catches bugs early).\n */\nexport const serviceContext: ServiceContext = {\n\tgetLogger() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getLogger() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.logger;\n\t},\n\n\tgetRequestId() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestId() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.requestId;\n\t},\n\n\tgetRequestStartTime() {\n\t\tconst store = requestContextStorage.getStore();\n\t\tif (!store) {\n\t\t\tthrow new Error(\n\t\t\t\t'ServiceContext.getRequestStartTime() called outside request context. ' +\n\t\t\t\t\t'Ensure code runs within runWithRequestContext().',\n\t\t\t);\n\t\t}\n\t\treturn store.startTime;\n\t},\n\n\thasContext() {\n\t\treturn requestContextStorage.getStore() !== undefined;\n\t},\n};\n\n/**\n * Run a function with request context.\n * Used by endpoint/function/subscriber adaptors.\n *\n * @param data - Request context data (logger, requestId, startTime)\n * @param fn - Function to run with context\n * @returns Result of the function\n *\n * @example\n * ```typescript\n * const result = await runWithRequestContext(\n *   { logger, requestId, startTime: Date.now() },\n *   async () => {\n *     // Inside here, serviceContext.getLogger() returns `logger`\n *     // serviceContext.getRequestId() returns `requestId`\n *     return await handleRequest();\n *   }\n * );\n * ```\n */\nexport function runWithRequestContext<T>(\n\tdata: RequestContextData,\n\tfn: () => T | Promise<T>,\n): T | Promise<T> {\n\treturn requestContextStorage.run(data, fn);\n}\n\n/**\n * Mutate the current async task's store so that subsequent code in this task\n * (and any descendants) sees the supplied request context.\n *\n * Unlike `runWithRequestContext`, this does not scope the context to a\n * callback — useful when the caller can't wrap a function, for example in a\n * Vitest fixture that suspends on `use()` and yields control to the test\n * runner before the test body executes.\n *\n * **Test setup only.** In production handlers, prefer `runWithRequestContext`\n * so the frame is automatically cleaned up.\n */\nexport function enterRequestContext(data: RequestContextData): void {\n\trequestContextStorage.enterWith(data);\n}\n\n/**\n * Clear the request context for the current async task. Pairs with\n * `enterRequestContext`. After calling, `serviceContext.hasContext()` returns\n * false for the remainder of the current async resource.\n */\nexport function exitRequestContext(): void {\n\t// AsyncLocalStorage<T>.enterWith requires T, but Node accepts undefined at\n\t// runtime — passing it resets getStore() back to undefined.\n\t(requestContextStorage as unknown as AsyncLocalStorage<unknown>).enterWith(\n\t\tundefined,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmBA,MAAM,wBAAwB,IAAIA;;;;;;AAOlC,MAAaC,iBAAiC;CAC7C,YAAY;EACX,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,eAAe;EACd,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,sBAAsB;EACrB,MAAM,QAAQ,sBAAsB,UAAU;AAC9C,OAAK,MACJ,OAAM,IAAI,MACT;AAIF,SAAO,MAAM;CACb;CAED,aAAa;AACZ,SAAO,sBAAsB,UAAU;CACvC;AACD;;;;;;;;;;;;;;;;;;;;;AAsBD,SAAgB,sBACfC,MACAC,IACiB;AACjB,QAAO,sBAAsB,IAAI,MAAM,GAAG;AAC1C;;;;;;;;;;;;;AAcD,SAAgB,oBAAoBD,MAAgC;AACnE,uBAAsB,UAAU,KAAK;AACrC;;;;;;AAOD,SAAgB,qBAA2B;AAG1C,CAAC,sBAAgE,iBAEhE;AACD"}

package/dist/context-HGC2PJzv.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-HGC2PJzv.d.mts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AAkBA;AA2DgB,UA7EC,kBAAA,CA6EoB;EAAA,MAAA,EA5E5B,MA4E4B;EAAA,SAC9B,EAAA,MAAA;EAAkB,SACd,EAAA,MAAA;;;;;;AACG;AAgBE,cA9EH,cA8EsB,EA9EN,cA8Ea;AAS1C;;;;;;;;;;;;;;;;;;;;iBA5BgB,+BACT,8BACI,IAAI,QAAQ,KACpB,IAAI,QAAQ;;;;;;;;;;;;;iBAgBC,mBAAA,OAA0B;;;;;;iBAS1B,kBAAA,CAAA"}

package/dist/types-CcHmCx_U.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-CcHmCx_U.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AA8BA;;AAEY,UAhCK,cAAA,CAgCL;EAAiB;AAEL;AA8BxB;;EAAwB,SAIV,EAAA,EA/DA,MA+DA;EAAK;;;;EAO4C,YAAA,EAAA,EAAA,MAAA;;;;;;;;;;;;;;;;UA7C9C,sBAAA;;aAEL;;WAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO;;;;eAIH;;;;;;;oBAOK,yBAAyB,YAAY,QAAQ"}

package/dist/types-D7d_yeU5.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-D7d_yeU5.d.cts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAQA;AA8BA;;AAEY,UAhCK,cAAA,CAgCL;EAAiB;AAEL;AA8BxB;;EAAwB,SAIV,EAAA,EA/DA,MA+DA;EAAK;;;;EAO4C,YAAA,EAAA,EAAA,MAAA;;;;;;;;;;;;;;;;UA7C9C,sBAAA;;aAEL;;WAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO;;;;eAIH;;;;;;;oBAOK,yBAAyB,YAAY,QAAQ"}