@geekmidas/services 10.0.0-alpha.9 → 10.0.0-alpha.91

package/dist/trpc.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"trpc.cjs","names":["mw: CreateMiddleware<TContext, TMeta>","envParser?: EnvironmentParser<{}>","services: [...T]"],"sources":["../src/trpc.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\nimport type {\n\tTRPCMiddlewareBuilder,\n\tTRPCMiddlewareFunction,\n} from '@trpc/server';\nimport { runWithRequestContext } from './context';\nimport { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';\nimport type { Service } from './types';\n\n/**\n * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the\n * initialized `t` object so callers retain ownership of their tRPC instance\n * (no double-initialization, no opinion on context/meta shape).\n */\ntype CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(\n\tfn: TRPCMiddlewareFunction<\n\t\tTContext,\n\t\tTMeta,\n\t\tobject,\n\t\t$ContextOverrides,\n\t\tunknown\n\t>,\n) => TRPCMiddlewareBuilder<TContext, TMeta, $ContextOverrides, unknown>;\n\n/**\n * Result of `createServicesMiddleware`: a function that accepts a service\n * tuple and returns a tRPC middleware that merges resolved services onto the\n * context.\n */\nexport type ServicesMiddleware<\n\tTContext extends object,\n\tTMeta extends object,\n> = <const T extends Service[]>(\n\tservices: [...T],\n) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;\n\n/**\n * Context shape required by `createServicesMiddleware` overload 2.\n * Procedures that pull services via context-stored discovery must expose it\n * under `serviceDiscovery`.\n */\nexport interface ContextWithServiceDiscovery {\n\tserviceDiscovery: ServiceDiscovery;\n}\n\n/**\n * Minimum context required for request-context propagation. `logger` must be\n * present so services can call `serviceContext.getLogger()`. `requestId` and\n * `startTime` are auto-generated if missing.\n */\nexport interface ContextWithLogger {\n\tlogger: Logger;\n\trequestId?: string;\n\tstartTime?: number;\n}\n\n/**\n * Create a tRPC middleware that:\n *\n * 1. Resolves the requested services via `ServiceDiscovery`.\n * 2. Wraps the downstream call in `runWithRequestContext` so any code reached\n *    by the procedure (including service method implementations) can read the\n *    current logger/request id via `serviceContext`.\n * 3. Merges the resolved services onto the tRPC context so handlers can access\n *    them by service name (`ctx.database`, `ctx.cache`, ...).\n *\n * Two overloads:\n * - Pass an `envParser` to create a per-request `ServiceDiscovery` instance.\n * - Omit `envParser` to read `ctx.serviceDiscovery` from the tRPC context.\n *\n * @example\n * ```ts\n * import { initTRPC } from '@trpc/server';\n * import { createServicesMiddleware } from '@geekmidas/services/trpc';\n *\n * const t = initTRPC.context<Context>().create();\n * const withServices = createServicesMiddleware(t.middleware, envParser);\n *\n * export const authedProcedure = t.procedure.use(\n *   withServices([databaseService, cacheService]),\n * );\n * ```\n */\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & ContextWithServiceDiscovery & object,\n\tTMeta extends object,\n>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser?: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta> {\n\treturn (<const T extends Service[]>(services: [...T]) => {\n\t\tconst builder = mw(async (opts) => {\n\t\t\tconst ctx = opts.ctx as TContext & Partial<ContextWithServiceDiscovery>;\n\n\t\t\tconst discovery =\n\t\t\t\tctx.serviceDiscovery ??\n\t\t\t\tServiceDiscovery.getInstance(\n\t\t\t\t\tenvParser ??\n\t\t\t\t\t\t(() => {\n\t\t\t\t\t\t\t// Hit only if overload 2 was selected but ctx.serviceDiscovery is\n\t\t\t\t\t\t\t// missing at runtime — surface the mistake immediately rather\n\t\t\t\t\t\t\t// than letting an undefined env parser fail deep inside register.\n\t\t\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t\t\t'createServicesMiddleware: no `envParser` provided and ' +\n\t\t\t\t\t\t\t\t\t'`ctx.serviceDiscovery` is missing. Pass an EnvironmentParser ' +\n\t\t\t\t\t\t\t\t\t'to createServicesMiddleware(), or attach a ServiceDiscovery ' +\n\t\t\t\t\t\t\t\t\t'instance to the tRPC context.',\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t})(),\n\t\t\t\t);\n\n\t\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\t\tconst startTime = ctx.startTime ?? Date.now();\n\n\t\t\treturn runWithRequestContext(\n\t\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t\tasync () => {\n\t\t\t\t\tconst resolved = await discovery.register(services);\n\t\t\t\t\treturn opts.next({\n\t\t\t\t\t\tctx: { ...opts.ctx, ...resolved } as typeof opts.ctx &\n\t\t\t\t\t\t\tServiceRecord<T>,\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t);\n\t\t});\n\n\t\t// Tag the inner middleware function with the requested services so external\n\t\t// tooling (e.g. detect-procedures route generators) can introspect a\n\t\t// procedure's service dependencies without re-executing middleware.\n\t\tconst middlewares = (\n\t\t\tbuilder as unknown as { _middlewares?: Array<{ _services?: Service[] }> }\n\t\t)._middlewares;\n\t\tif (middlewares?.length) {\n\t\t\tconst last = middlewares[middlewares.length - 1];\n\t\t\tif (last) last._services = services as unknown as Service[];\n\t\t}\n\n\t\treturn builder as TRPCMiddlewareBuilder<\n\t\t\tTContext,\n\t\t\tTMeta,\n\t\t\tServiceRecord<T>,\n\t\t\tunknown\n\t\t>;\n\t}) as ServicesMiddleware<TContext, TMeta>;\n}\n\n/**\n * Create a tRPC middleware that establishes a request context for downstream\n * code without resolving any services. Useful when services aren't needed on\n * a procedure but the handler (or libraries it calls) still wants to read\n * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.\n *\n * `requestId` and `startTime` are pulled from the tRPC context when present,\n * otherwise generated (`randomUUID()` and `Date.now()`).\n *\n * @example\n * ```ts\n * const withRequestContext = createRequestContextMiddleware(t.middleware);\n * export const baseProcedure = t.procedure.use(withRequestContext);\n * ```\n */\nexport function createRequestContextMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown> {\n\treturn mw(async (opts) => {\n\t\tconst ctx = opts.ctx as TContext;\n\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\tconst startTime = ctx.startTime ?? Date.now();\n\t\treturn runWithRequestContext(\n\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t() => opts.next(),\n\t\t);\n\t});\n}\n"],"mappings":";;;;;AAgGA,SAAgB,yBAIfA,IACAC,WACsC;AACtC,QAAQ,CAA4BC,aAAqB;EACxD,MAAM,UAAU,GAAG,OAAO,SAAS;GAClC,MAAM,MAAM,KAAK;GAEjB,MAAM,YACL,IAAI,oBACJ,0CAAiB,YAChB,aACC,CAAC,MAAM;AAIN,UAAM,IAAI,MACT;GAKD,IAAG,CACL;GAEF,MAAM,YAAY,IAAI,aAAa,6BAAY;GAC/C,MAAM,YAAY,IAAI,aAAa,KAAK,KAAK;AAE7C,UAAO,sCACN;IAAE,QAAQ,IAAI;IAAQ;IAAW;GAAW,GAC5C,YAAY;IACX,MAAM,WAAW,MAAM,UAAU,SAAS,SAAS;AACnD,WAAO,KAAK,KAAK,EAChB,KAAK;KAAE,GAAG,KAAK;KAAK,GAAG;IAAU,EAEjC,EAAC;GACF,EACD;EACD,EAAC;EAKF,MAAM,cACL,QACC;AACF,MAAI,aAAa,QAAQ;GACxB,MAAM,OAAO,YAAY,YAAY,SAAS;AAC9C,OAAI,KAAM,MAAK,YAAY;EAC3B;AAED,SAAO;CAMP;AACD;;;;;;;;;;;;;;;;AAiBD,SAAgB,+BAIfF,IAC0D;AAC1D,QAAO,GAAG,OAAO,SAAS;EACzB,MAAM,MAAM,KAAK;EACjB,MAAM,YAAY,IAAI,aAAa,6BAAY;EAC/C,MAAM,YAAY,IAAI,aAAa,KAAK,KAAK;AAC7C,SAAO,sCACN;GAAE,QAAQ,IAAI;GAAQ;GAAW;EAAW,GAC5C,MAAM,KAAK,MAAM,CACjB;CACD,EAAC;AACF"}
+{"version":3,"file":"trpc.cjs","names":["ServiceDiscovery","randomUUID","runWithRequestContext"],"sources":["../src/trpc.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\nimport type {\n\tTRPCMiddlewareBuilder,\n\tTRPCMiddlewareFunction,\n} from '@trpc/server';\nimport { runWithRequestContext } from './context';\nimport { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';\nimport type { Service } from './types';\n\n/**\n * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the\n * initialized `t` object so callers retain ownership of their tRPC instance\n * (no double-initialization, no opinion on context/meta shape).\n */\ntype CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(\n\tfn: TRPCMiddlewareFunction<\n\t\tTContext,\n\t\tTMeta,\n\t\tobject,\n\t\t$ContextOverrides,\n\t\tunknown\n\t>,\n) => TRPCMiddlewareBuilder<TContext, TMeta, $ContextOverrides, unknown>;\n\n/**\n * Result of `createServicesMiddleware`: a function that accepts a service\n * tuple and returns a tRPC middleware that merges resolved services onto the\n * context.\n */\nexport type ServicesMiddleware<\n\tTContext extends object,\n\tTMeta extends object,\n> = <const T extends Service[]>(\n\tservices: [...T],\n) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;\n\n/**\n * Context shape required by `createServicesMiddleware` overload 2.\n * Procedures that pull services via context-stored discovery must expose it\n * under `serviceDiscovery`.\n */\nexport interface ContextWithServiceDiscovery {\n\tserviceDiscovery: ServiceDiscovery;\n}\n\n/**\n * Minimum context required for request-context propagation. `logger` must be\n * present so services can call `serviceContext.getLogger()`. `requestId` and\n * `startTime` are auto-generated if missing.\n */\nexport interface ContextWithLogger {\n\tlogger: Logger;\n\trequestId?: string;\n\tstartTime?: number;\n}\n\n/**\n * Create a tRPC middleware that:\n *\n * 1. Resolves the requested services via `ServiceDiscovery`.\n * 2. Wraps the downstream call in `runWithRequestContext` so any code reached\n *    by the procedure (including service method implementations) can read the\n *    current logger/request id via `serviceContext`.\n * 3. Merges the resolved services onto the tRPC context so handlers can access\n *    them by service name (`ctx.database`, `ctx.cache`, ...).\n *\n * Two overloads:\n * - Pass an `envParser` to create a per-request `ServiceDiscovery` instance.\n * - Omit `envParser` to read `ctx.serviceDiscovery` from the tRPC context.\n *\n * @example\n * ```ts\n * import { initTRPC } from '@trpc/server';\n * import { createServicesMiddleware } from '@geekmidas/services/trpc';\n *\n * const t = initTRPC.context<Context>().create();\n * const withServices = createServicesMiddleware(t.middleware, envParser);\n *\n * export const authedProcedure = t.procedure.use(\n *   withServices([databaseService, cacheService]),\n * );\n * ```\n */\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & ContextWithServiceDiscovery & object,\n\tTMeta extends object,\n>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser?: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta> {\n\treturn (<const T extends Service[]>(services: [...T]) => {\n\t\tconst builder = mw(async (opts) => {\n\t\t\tconst ctx = opts.ctx as TContext & Partial<ContextWithServiceDiscovery>;\n\n\t\t\tconst discovery =\n\t\t\t\tctx.serviceDiscovery ??\n\t\t\t\tServiceDiscovery.getInstance(\n\t\t\t\t\tenvParser ??\n\t\t\t\t\t\t(() => {\n\t\t\t\t\t\t\t// Hit only if overload 2 was selected but ctx.serviceDiscovery is\n\t\t\t\t\t\t\t// missing at runtime — surface the mistake immediately rather\n\t\t\t\t\t\t\t// than letting an undefined env parser fail deep inside register.\n\t\t\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t\t\t'createServicesMiddleware: no `envParser` provided and ' +\n\t\t\t\t\t\t\t\t\t'`ctx.serviceDiscovery` is missing. Pass an EnvironmentParser ' +\n\t\t\t\t\t\t\t\t\t'to createServicesMiddleware(), or attach a ServiceDiscovery ' +\n\t\t\t\t\t\t\t\t\t'instance to the tRPC context.',\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t})(),\n\t\t\t\t);\n\n\t\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\t\tconst startTime = ctx.startTime ?? Date.now();\n\n\t\t\treturn runWithRequestContext(\n\t\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t\tasync () => {\n\t\t\t\t\tconst resolved = await discovery.register(services);\n\t\t\t\t\treturn opts.next({\n\t\t\t\t\t\tctx: { ...opts.ctx, ...resolved } as typeof opts.ctx &\n\t\t\t\t\t\t\tServiceRecord<T>,\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t);\n\t\t});\n\n\t\t// Tag the inner middleware function with the requested services so external\n\t\t// tooling (e.g. detect-procedures route generators) can introspect a\n\t\t// procedure's service dependencies without re-executing middleware.\n\t\tconst middlewares = (\n\t\t\tbuilder as unknown as { _middlewares?: Array<{ _services?: Service[] }> }\n\t\t)._middlewares;\n\t\tif (middlewares?.length) {\n\t\t\tconst last = middlewares[middlewares.length - 1];\n\t\t\tif (last) last._services = services as unknown as Service[];\n\t\t}\n\n\t\treturn builder as TRPCMiddlewareBuilder<\n\t\t\tTContext,\n\t\t\tTMeta,\n\t\t\tServiceRecord<T>,\n\t\t\tunknown\n\t\t>;\n\t}) as ServicesMiddleware<TContext, TMeta>;\n}\n\n/**\n * Create a tRPC middleware that establishes a request context for downstream\n * code without resolving any services. Useful when services aren't needed on\n * a procedure but the handler (or libraries it calls) still wants to read\n * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.\n *\n * `requestId` and `startTime` are pulled from the tRPC context when present,\n * otherwise generated (`randomUUID()` and `Date.now()`).\n *\n * @example\n * ```ts\n * const withRequestContext = createRequestContextMiddleware(t.middleware);\n * export const baseProcedure = t.procedure.use(withRequestContext);\n * ```\n */\nexport function createRequestContextMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown> {\n\treturn mw(async (opts) => {\n\t\tconst ctx = opts.ctx as TContext;\n\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\tconst startTime = ctx.startTime ?? Date.now();\n\t\treturn runWithRequestContext(\n\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t() => opts.next(),\n\t\t);\n\t});\n}\n"],"mappings":";;;;;AAgGA,SAAgB,yBAIf,IACA,WACsC;CACtC,SAAoC,aAAqB;EACxD,MAAM,UAAU,GAAG,OAAO,SAAS;GAClC,MAAM,MAAM,KAAK;GAEjB,MAAM,YACL,IAAI,oBACJA,yBAAAA,iBAAiB,YAChB,oBACQ;IAIN,MAAM,IAAI,MACT,8MAID;GACD,EAAA,CAAG,CACL;GAED,MAAM,YAAY,IAAI,cAAA,GAAaC,YAAAA,WAAAA,CAAW;GAC9C,MAAM,YAAY,IAAI,aAAa,KAAK,IAAI;GAE5C,OAAOC,gBAAAA,sBACN;IAAE,QAAQ,IAAI;IAAQ;IAAW;GAAU,GAC3C,YAAY;IACX,MAAM,WAAW,MAAM,UAAU,SAAS,QAAQ;IAClD,OAAO,KAAK,KAAK,EAChB,KAAK;KAAE,GAAG,KAAK;KAAK,GAAG;IAAS,EAEjC,CAAC;GACF,CACD;EACD,CAAC;EAKD,MAAM,cACL,QACC;EACF,IAAI,aAAa,QAAQ;GACxB,MAAM,OAAO,YAAY,YAAY,SAAS;GAC9C,IAAI,MAAM,KAAK,YAAY;EAC5B;EAEA,OAAO;CAMR;AACD;;;;;;;;;;;;;;;;AAiBA,SAAgB,+BAIf,IAC0D;CAC1D,OAAO,GAAG,OAAO,SAAS;EACzB,MAAM,MAAM,KAAK;EACjB,MAAM,YAAY,IAAI,cAAA,GAAaD,YAAAA,WAAAA,CAAW;EAC9C,MAAM,YAAY,IAAI,aAAa,KAAK,IAAI;EAC5C,OAAOC,gBAAAA,sBACN;GAAE,QAAQ,IAAI;GAAQ;GAAW;EAAU,SACrC,KAAK,KAAK,CACjB;CACD,CAAC;AACF"}

package/dist/trpc.d.cts

@@ -1,11 +1,9 @@
-import { Service } from "./types-Bgk-0NOO.cjs";
-import { ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-BO8W-RY8.cjs";
+import { t as Service } from "./types-DDxt5Kcu.cjs";
+import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-YbZxbSHi.cjs";
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
 import { TRPCMiddlewareBuilder, TRPCMiddlewareFunction } from "@trpc/server";
-
 //#region src/trpc.d.ts
-
 /**
  * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the
  * initialized `t` object so callers retain ownership of their tRPC instance
@@ -17,13 +15,13 @@ type CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(fn: TRPCMiddlewareF
  * tuple and returns a tRPC middleware that merges resolved services onto the
  * context.
  */
-type ServicesMiddleware<TContext extends object, TMeta extends object> = <const T extends Service[]>(services: [...T]) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;
+export type ServicesMiddleware<TContext extends object, TMeta extends object> = <const T extends Service[]>(services: [...T]) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;
 /**
  * Context shape required by `createServicesMiddleware` overload 2.
  * Procedures that pull services via context-stored discovery must expose it
  * under `serviceDiscovery`.
  */
-interface ContextWithServiceDiscovery {
+export interface ContextWithServiceDiscovery {
   serviceDiscovery: ServiceDiscovery;
 }
 /**
@@ -31,7 +29,7 @@ interface ContextWithServiceDiscovery {
  * present so services can call `serviceContext.getLogger()`. `requestId` and
  * `startTime` are auto-generated if missing.
  */
-interface ContextWithLogger {
+export interface ContextWithLogger {
   logger: Logger;
   requestId?: string;
   startTime?: number;
@@ -63,8 +61,8 @@ interface ContextWithLogger {
  * );
  * ```
  */
-declare function createServicesMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>, envParser: EnvironmentParser<{}>): ServicesMiddleware<TContext, TMeta>;
-declare function createServicesMiddleware<TContext extends ContextWithLogger & ContextWithServiceDiscovery & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
+export declare function createServicesMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>, envParser: EnvironmentParser<{}>): ServicesMiddleware<TContext, TMeta>;
+export declare function createServicesMiddleware<TContext extends ContextWithLogger & ContextWithServiceDiscovery & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
 /**
  * Create a tRPC middleware that establishes a request context for downstream
  * code without resolving any services. Useful when services aren't needed on
@@ -80,7 +78,6 @@ declare function createServicesMiddleware<TContext extends ContextWithLogger & C
  * export const baseProcedure = t.procedure.use(withRequestContext);
  * ```
  */
-declare function createRequestContextMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown>;
+export declare function createRequestContextMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown>;
 //#endregion
-export { ContextWithLogger, ContextWithServiceDiscovery, ServicesMiddleware, createRequestContextMiddleware, createServicesMiddleware };
 //# sourceMappingURL=trpc.d.cts.map

package/dist/trpc.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"trpc.d.cts","names":[],"sources":["../src/trpc.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AASuC;;;KAOlC,gBAGH,CAAA,QAAA,EAAA,KAAA,CAAA,GAAA,CAAA,iBAAA,CAAA,CAAA,EAAA,EAFG,sBAEH,CADA,QACA,EAAA,KAAA,EAAA,MAAA,EAEA,iBAFA,EAAA,OAAA,CAAA,EAAA,GAKG,qBALH,CAKyB,QALzB,EAKmC,KALnC,EAK0C,iBAL1C,EAAA,OAAA,CAAA;;;;;;AAKG,KAOO,kBAPP,CAAA,iBAAA,MAAA,EAAA,cAAA,MAAA,CAAA,GAAA,CAAA,gBAUgB,OAVhB,EAAA,CAAA,CAAA,QAAA,EAAA,CAAA,GAWU,CAXV,CAAA,EAAA,GAYA,qBAZA,CAYsB,QAZtB,EAYgC,KAZhC,EAYuC,aAZvC,CAYqD,CAZrD,CAAA,EAAA,OAAA,CAAA;AAAqB;AAO1B;;;;AAK2B,UAOV,2BAAA,CAPU;EAAQ,gBAAE,EAQlB,gBARkB;;;;AAAX;AAO1B;AASA;AAiCgB,UAjCC,iBAAA,CAiCuB;EAAA,MAAA,EAhC/B,MAgC+B;EAAA,SACtB,CAAA,EAAA,MAAA;EAAiB,SAGb,CAAA,EAAA,MAAA;;;;;;;AAED;AACrB;;;;;;;;;;AAG4D;AA+E5D;;;;;;;;;AAKwB;iBA9FR,0CACE,sDAGb,iBAAiB,UAAU,mBACpB,wBACT,mBAAmB,UAAU;iBAChB,0CACE,oBAAoB,gEAEhC,iBAAiB,UAAU,SAAS,mBAAmB,UAAU;;;;;;;;;;;;;;;;iBA+EvD,gDACE,sDAGb,iBAAiB,UAAU,SAC7B,sBAAsB,UAAU"}
+{"version":3,"file":"trpc.d.cts","names":[],"sources":["../src/trpc.ts"],"mappings":";;;;;;;;;;;KAgBK,iBAAiB,UAAU,UAAU,mBACzC,IAAI,uBACH,UACA,eAEA,gCAGG,sBAAsB,UAAU,OAAO;;;;;;YAOhC,mBACX,yBACA,+BACU,UAAU,WACpB,cAAc,OACV,sBAAsB,UAAU,OAAO,cAAc;;;;;;iBAOzC;EAChB,kBAAkB;;;;;;;iBAQF;EAChB,QAAQ;EACR;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8Be,yBACf,iBAAiB,4BACjB,sBAEA,IAAI,iBAAiB,UAAU,QAC/B,WAAW,wBACT,mBAAmB,UAAU;wBAChB,yBACf,iBAAiB,oBAAoB,sCACrC,sBACC,IAAI,iBAAiB,UAAU,SAAS,mBAAmB,UAAU;;;;;;;;;;;;;;;;wBA+EvD,+BACf,iBAAiB,4BACjB,sBAEA,IAAI,iBAAiB,UAAU,SAC7B,sBAAsB,UAAU"}

package/dist/trpc.d.mts

@@ -1,11 +1,9 @@
-import { Service } from "./types-BoyOCa57.mjs";
-import { ServiceDiscovery, ServiceRecord } from "./ServiceDiscovery-CRq_bGbi.mjs";
+import { t as Service } from "./types-DDxt5Kcu.mjs";
+import { n as ServiceDiscovery, r as ServiceRecord } from "./ServiceDiscovery-I7GKGDgi.mjs";
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
 import { TRPCMiddlewareBuilder, TRPCMiddlewareFunction } from "@trpc/server";
-
 //#region src/trpc.d.ts
-
 /**
  * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the
  * initialized `t` object so callers retain ownership of their tRPC instance
@@ -17,13 +15,13 @@ type CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(fn: TRPCMiddlewareF
  * tuple and returns a tRPC middleware that merges resolved services onto the
  * context.
  */
-type ServicesMiddleware<TContext extends object, TMeta extends object> = <const T extends Service[]>(services: [...T]) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;
+export type ServicesMiddleware<TContext extends object, TMeta extends object> = <const T extends Service[]>(services: [...T]) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;
 /**
  * Context shape required by `createServicesMiddleware` overload 2.
  * Procedures that pull services via context-stored discovery must expose it
  * under `serviceDiscovery`.
  */
-interface ContextWithServiceDiscovery {
+export interface ContextWithServiceDiscovery {
   serviceDiscovery: ServiceDiscovery;
 }
 /**
@@ -31,7 +29,7 @@ interface ContextWithServiceDiscovery {
  * present so services can call `serviceContext.getLogger()`. `requestId` and
  * `startTime` are auto-generated if missing.
  */
-interface ContextWithLogger {
+export interface ContextWithLogger {
   logger: Logger;
   requestId?: string;
   startTime?: number;
@@ -63,8 +61,8 @@ interface ContextWithLogger {
  * );
  * ```
  */
-declare function createServicesMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>, envParser: EnvironmentParser<{}>): ServicesMiddleware<TContext, TMeta>;
-declare function createServicesMiddleware<TContext extends ContextWithLogger & ContextWithServiceDiscovery & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
+export declare function createServicesMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>, envParser: EnvironmentParser<{}>): ServicesMiddleware<TContext, TMeta>;
+export declare function createServicesMiddleware<TContext extends ContextWithLogger & ContextWithServiceDiscovery & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;
 /**
  * Create a tRPC middleware that establishes a request context for downstream
  * code without resolving any services. Useful when services aren't needed on
@@ -80,7 +78,6 @@ declare function createServicesMiddleware<TContext extends ContextWithLogger & C
  * export const baseProcedure = t.procedure.use(withRequestContext);
  * ```
  */
-declare function createRequestContextMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown>;
+export declare function createRequestContextMiddleware<TContext extends ContextWithLogger & object, TMeta extends object>(mw: CreateMiddleware<TContext, TMeta>): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown>;
 //#endregion
-export { ContextWithLogger, ContextWithServiceDiscovery, ServicesMiddleware, createRequestContextMiddleware, createServicesMiddleware };
 //# sourceMappingURL=trpc.d.mts.map

package/dist/trpc.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"trpc.d.mts","names":[],"sources":["../src/trpc.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AASuC;;;KAOlC,gBAGH,CAAA,QAAA,EAAA,KAAA,CAAA,GAAA,CAAA,iBAAA,CAAA,CAAA,EAAA,EAFG,sBAEH,CADA,QACA,EAAA,KAAA,EAAA,MAAA,EAEA,iBAFA,EAAA,OAAA,CAAA,EAAA,GAKG,qBALH,CAKyB,QALzB,EAKmC,KALnC,EAK0C,iBAL1C,EAAA,OAAA,CAAA;;;;;;AAKG,KAOO,kBAPP,CAAA,iBAAA,MAAA,EAAA,cAAA,MAAA,CAAA,GAAA,CAAA,gBAUgB,OAVhB,EAAA,CAAA,CAAA,QAAA,EAAA,CAAA,GAWU,CAXV,CAAA,EAAA,GAYA,qBAZA,CAYsB,QAZtB,EAYgC,KAZhC,EAYuC,aAZvC,CAYqD,CAZrD,CAAA,EAAA,OAAA,CAAA;AAAqB;AAO1B;;;;AAK2B,UAOV,2BAAA,CAPU;EAAQ,gBAAE,EAQlB,gBARkB;;;;AAAX;AAO1B;AASA;AAiCgB,UAjCC,iBAAA,CAiCuB;EAAA,MAAA,EAhC/B,MAgC+B;EAAA,SACtB,CAAA,EAAA,MAAA;EAAiB,SAGb,CAAA,EAAA,MAAA;;;;;;;AAED;AACrB;;;;;;;;;;AAG4D;AA+E5D;;;;;;;;;AAKwB;iBA9FR,0CACE,sDAGb,iBAAiB,UAAU,mBACpB,wBACT,mBAAmB,UAAU;iBAChB,0CACE,oBAAoB,gEAEhC,iBAAiB,UAAU,SAAS,mBAAmB,UAAU;;;;;;;;;;;;;;;;iBA+EvD,gDACE,sDAGb,iBAAiB,UAAU,SAC7B,sBAAsB,UAAU"}
+{"version":3,"file":"trpc.d.mts","names":[],"sources":["../src/trpc.ts"],"mappings":";;;;;;;;;;;KAgBK,iBAAiB,UAAU,UAAU,mBACzC,IAAI,uBACH,UACA,eAEA,gCAGG,sBAAsB,UAAU,OAAO;;;;;;YAOhC,mBACX,yBACA,+BACU,UAAU,WACpB,cAAc,OACV,sBAAsB,UAAU,OAAO,cAAc;;;;;;iBAOzC;EAChB,kBAAkB;;;;;;;iBAQF;EAChB,QAAQ;EACR;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8Be,yBACf,iBAAiB,4BACjB,sBAEA,IAAI,iBAAiB,UAAU,QAC/B,WAAW,wBACT,mBAAmB,UAAU;wBAChB,yBACf,iBAAiB,oBAAoB,sCACrC,sBACC,IAAI,iBAAiB,UAAU,SAAS,mBAAmB,UAAU;;;;;;;;;;;;;;;;wBA+EvD,+BACf,iBAAiB,4BACjB,sBAEA,IAAI,iBAAiB,UAAU,SAC7B,sBAAsB,UAAU"}

package/dist/trpc.mjs

@@ -1,10 +1,9 @@
-import { runWithRequestContext } from "./context-CH2c0ftq.mjs";
-import { ServiceDiscovery } from "./ServiceDiscovery-WHikQSQv.mjs";
+import { runWithRequestContext } from "./context.mjs";
+import { t as ServiceDiscovery } from "./ServiceDiscovery-5LlW7BgD.mjs";
 import { randomUUID } from "node:crypto";
-
 //#region src/trpc.ts
 function createServicesMiddleware(mw, envParser) {
-	return (services) => {
+	return ((services) => {
 		const builder = mw(async (opts) => {
 			const ctx = opts.ctx;
 			const discovery = ctx.serviceDiscovery ?? ServiceDiscovery.getInstance(envParser ?? (() => {
@@ -30,7 +29,7 @@ function createServicesMiddleware(mw, envParser) {
 			if (last) last._services = services;
 		}
 		return builder;
-	};
+	});
 }
 /**
 * Create a tRPC middleware that establishes a request context for downstream
@@ -59,7 +58,7 @@ function createRequestContextMiddleware(mw) {
 		}, () => opts.next());
 	});
 }
-
 //#endregion
 export { createRequestContextMiddleware, createServicesMiddleware };
+
 //# sourceMappingURL=trpc.mjs.map

package/dist/trpc.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"trpc.mjs","names":["mw: CreateMiddleware<TContext, TMeta>","envParser?: EnvironmentParser<{}>","services: [...T]"],"sources":["../src/trpc.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\nimport type {\n\tTRPCMiddlewareBuilder,\n\tTRPCMiddlewareFunction,\n} from '@trpc/server';\nimport { runWithRequestContext } from './context';\nimport { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';\nimport type { Service } from './types';\n\n/**\n * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the\n * initialized `t` object so callers retain ownership of their tRPC instance\n * (no double-initialization, no opinion on context/meta shape).\n */\ntype CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(\n\tfn: TRPCMiddlewareFunction<\n\t\tTContext,\n\t\tTMeta,\n\t\tobject,\n\t\t$ContextOverrides,\n\t\tunknown\n\t>,\n) => TRPCMiddlewareBuilder<TContext, TMeta, $ContextOverrides, unknown>;\n\n/**\n * Result of `createServicesMiddleware`: a function that accepts a service\n * tuple and returns a tRPC middleware that merges resolved services onto the\n * context.\n */\nexport type ServicesMiddleware<\n\tTContext extends object,\n\tTMeta extends object,\n> = <const T extends Service[]>(\n\tservices: [...T],\n) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;\n\n/**\n * Context shape required by `createServicesMiddleware` overload 2.\n * Procedures that pull services via context-stored discovery must expose it\n * under `serviceDiscovery`.\n */\nexport interface ContextWithServiceDiscovery {\n\tserviceDiscovery: ServiceDiscovery;\n}\n\n/**\n * Minimum context required for request-context propagation. `logger` must be\n * present so services can call `serviceContext.getLogger()`. `requestId` and\n * `startTime` are auto-generated if missing.\n */\nexport interface ContextWithLogger {\n\tlogger: Logger;\n\trequestId?: string;\n\tstartTime?: number;\n}\n\n/**\n * Create a tRPC middleware that:\n *\n * 1. Resolves the requested services via `ServiceDiscovery`.\n * 2. Wraps the downstream call in `runWithRequestContext` so any code reached\n *    by the procedure (including service method implementations) can read the\n *    current logger/request id via `serviceContext`.\n * 3. Merges the resolved services onto the tRPC context so handlers can access\n *    them by service name (`ctx.database`, `ctx.cache`, ...).\n *\n * Two overloads:\n * - Pass an `envParser` to create a per-request `ServiceDiscovery` instance.\n * - Omit `envParser` to read `ctx.serviceDiscovery` from the tRPC context.\n *\n * @example\n * ```ts\n * import { initTRPC } from '@trpc/server';\n * import { createServicesMiddleware } from '@geekmidas/services/trpc';\n *\n * const t = initTRPC.context<Context>().create();\n * const withServices = createServicesMiddleware(t.middleware, envParser);\n *\n * export const authedProcedure = t.procedure.use(\n *   withServices([databaseService, cacheService]),\n * );\n * ```\n */\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & ContextWithServiceDiscovery & object,\n\tTMeta extends object,\n>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser?: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta> {\n\treturn (<const T extends Service[]>(services: [...T]) => {\n\t\tconst builder = mw(async (opts) => {\n\t\t\tconst ctx = opts.ctx as TContext & Partial<ContextWithServiceDiscovery>;\n\n\t\t\tconst discovery =\n\t\t\t\tctx.serviceDiscovery ??\n\t\t\t\tServiceDiscovery.getInstance(\n\t\t\t\t\tenvParser ??\n\t\t\t\t\t\t(() => {\n\t\t\t\t\t\t\t// Hit only if overload 2 was selected but ctx.serviceDiscovery is\n\t\t\t\t\t\t\t// missing at runtime — surface the mistake immediately rather\n\t\t\t\t\t\t\t// than letting an undefined env parser fail deep inside register.\n\t\t\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t\t\t'createServicesMiddleware: no `envParser` provided and ' +\n\t\t\t\t\t\t\t\t\t'`ctx.serviceDiscovery` is missing. Pass an EnvironmentParser ' +\n\t\t\t\t\t\t\t\t\t'to createServicesMiddleware(), or attach a ServiceDiscovery ' +\n\t\t\t\t\t\t\t\t\t'instance to the tRPC context.',\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t})(),\n\t\t\t\t);\n\n\t\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\t\tconst startTime = ctx.startTime ?? Date.now();\n\n\t\t\treturn runWithRequestContext(\n\t\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t\tasync () => {\n\t\t\t\t\tconst resolved = await discovery.register(services);\n\t\t\t\t\treturn opts.next({\n\t\t\t\t\t\tctx: { ...opts.ctx, ...resolved } as typeof opts.ctx &\n\t\t\t\t\t\t\tServiceRecord<T>,\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t);\n\t\t});\n\n\t\t// Tag the inner middleware function with the requested services so external\n\t\t// tooling (e.g. detect-procedures route generators) can introspect a\n\t\t// procedure's service dependencies without re-executing middleware.\n\t\tconst middlewares = (\n\t\t\tbuilder as unknown as { _middlewares?: Array<{ _services?: Service[] }> }\n\t\t)._middlewares;\n\t\tif (middlewares?.length) {\n\t\t\tconst last = middlewares[middlewares.length - 1];\n\t\t\tif (last) last._services = services as unknown as Service[];\n\t\t}\n\n\t\treturn builder as TRPCMiddlewareBuilder<\n\t\t\tTContext,\n\t\t\tTMeta,\n\t\t\tServiceRecord<T>,\n\t\t\tunknown\n\t\t>;\n\t}) as ServicesMiddleware<TContext, TMeta>;\n}\n\n/**\n * Create a tRPC middleware that establishes a request context for downstream\n * code without resolving any services. Useful when services aren't needed on\n * a procedure but the handler (or libraries it calls) still wants to read\n * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.\n *\n * `requestId` and `startTime` are pulled from the tRPC context when present,\n * otherwise generated (`randomUUID()` and `Date.now()`).\n *\n * @example\n * ```ts\n * const withRequestContext = createRequestContextMiddleware(t.middleware);\n * export const baseProcedure = t.procedure.use(withRequestContext);\n * ```\n */\nexport function createRequestContextMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown> {\n\treturn mw(async (opts) => {\n\t\tconst ctx = opts.ctx as TContext;\n\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\tconst startTime = ctx.startTime ?? Date.now();\n\t\treturn runWithRequestContext(\n\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t() => opts.next(),\n\t\t);\n\t});\n}\n"],"mappings":";;;;;AAgGA,SAAgB,yBAIfA,IACAC,WACsC;AACtC,QAAQ,CAA4BC,aAAqB;EACxD,MAAM,UAAU,GAAG,OAAO,SAAS;GAClC,MAAM,MAAM,KAAK;GAEjB,MAAM,YACL,IAAI,oBACJ,iBAAiB,YAChB,aACC,CAAC,MAAM;AAIN,UAAM,IAAI,MACT;GAKD,IAAG,CACL;GAEF,MAAM,YAAY,IAAI,aAAa,YAAY;GAC/C,MAAM,YAAY,IAAI,aAAa,KAAK,KAAK;AAE7C,UAAO,sBACN;IAAE,QAAQ,IAAI;IAAQ;IAAW;GAAW,GAC5C,YAAY;IACX,MAAM,WAAW,MAAM,UAAU,SAAS,SAAS;AACnD,WAAO,KAAK,KAAK,EAChB,KAAK;KAAE,GAAG,KAAK;KAAK,GAAG;IAAU,EAEjC,EAAC;GACF,EACD;EACD,EAAC;EAKF,MAAM,cACL,QACC;AACF,MAAI,aAAa,QAAQ;GACxB,MAAM,OAAO,YAAY,YAAY,SAAS;AAC9C,OAAI,KAAM,MAAK,YAAY;EAC3B;AAED,SAAO;CAMP;AACD;;;;;;;;;;;;;;;;AAiBD,SAAgB,+BAIfF,IAC0D;AAC1D,QAAO,GAAG,OAAO,SAAS;EACzB,MAAM,MAAM,KAAK;EACjB,MAAM,YAAY,IAAI,aAAa,YAAY;EAC/C,MAAM,YAAY,IAAI,aAAa,KAAK,KAAK;AAC7C,SAAO,sBACN;GAAE,QAAQ,IAAI;GAAQ;GAAW;EAAW,GAC5C,MAAM,KAAK,MAAM,CACjB;CACD,EAAC;AACF"}
+{"version":3,"file":"trpc.mjs","names":[],"sources":["../src/trpc.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto';\nimport type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\nimport type {\n\tTRPCMiddlewareBuilder,\n\tTRPCMiddlewareFunction,\n} from '@trpc/server';\nimport { runWithRequestContext } from './context';\nimport { ServiceDiscovery, type ServiceRecord } from './ServiceDiscovery';\nimport type { Service } from './types';\n\n/**\n * Shape of `t.middleware` from `@trpc/server`. We accept this rather than the\n * initialized `t` object so callers retain ownership of their tRPC instance\n * (no double-initialization, no opinion on context/meta shape).\n */\ntype CreateMiddleware<TContext, TMeta> = <$ContextOverrides>(\n\tfn: TRPCMiddlewareFunction<\n\t\tTContext,\n\t\tTMeta,\n\t\tobject,\n\t\t$ContextOverrides,\n\t\tunknown\n\t>,\n) => TRPCMiddlewareBuilder<TContext, TMeta, $ContextOverrides, unknown>;\n\n/**\n * Result of `createServicesMiddleware`: a function that accepts a service\n * tuple and returns a tRPC middleware that merges resolved services onto the\n * context.\n */\nexport type ServicesMiddleware<\n\tTContext extends object,\n\tTMeta extends object,\n> = <const T extends Service[]>(\n\tservices: [...T],\n) => TRPCMiddlewareBuilder<TContext, TMeta, ServiceRecord<T>, unknown>;\n\n/**\n * Context shape required by `createServicesMiddleware` overload 2.\n * Procedures that pull services via context-stored discovery must expose it\n * under `serviceDiscovery`.\n */\nexport interface ContextWithServiceDiscovery {\n\tserviceDiscovery: ServiceDiscovery;\n}\n\n/**\n * Minimum context required for request-context propagation. `logger` must be\n * present so services can call `serviceContext.getLogger()`. `requestId` and\n * `startTime` are auto-generated if missing.\n */\nexport interface ContextWithLogger {\n\tlogger: Logger;\n\trequestId?: string;\n\tstartTime?: number;\n}\n\n/**\n * Create a tRPC middleware that:\n *\n * 1. Resolves the requested services via `ServiceDiscovery`.\n * 2. Wraps the downstream call in `runWithRequestContext` so any code reached\n *    by the procedure (including service method implementations) can read the\n *    current logger/request id via `serviceContext`.\n * 3. Merges the resolved services onto the tRPC context so handlers can access\n *    them by service name (`ctx.database`, `ctx.cache`, ...).\n *\n * Two overloads:\n * - Pass an `envParser` to create a per-request `ServiceDiscovery` instance.\n * - Omit `envParser` to read `ctx.serviceDiscovery` from the tRPC context.\n *\n * @example\n * ```ts\n * import { initTRPC } from '@trpc/server';\n * import { createServicesMiddleware } from '@geekmidas/services/trpc';\n *\n * const t = initTRPC.context<Context>().create();\n * const withServices = createServicesMiddleware(t.middleware, envParser);\n *\n * export const authedProcedure = t.procedure.use(\n *   withServices([databaseService, cacheService]),\n * );\n * ```\n */\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & ContextWithServiceDiscovery & object,\n\tTMeta extends object,\n>(mw: CreateMiddleware<TContext, TMeta>): ServicesMiddleware<TContext, TMeta>;\nexport function createServicesMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n\tenvParser?: EnvironmentParser<{}>,\n): ServicesMiddleware<TContext, TMeta> {\n\treturn (<const T extends Service[]>(services: [...T]) => {\n\t\tconst builder = mw(async (opts) => {\n\t\t\tconst ctx = opts.ctx as TContext & Partial<ContextWithServiceDiscovery>;\n\n\t\t\tconst discovery =\n\t\t\t\tctx.serviceDiscovery ??\n\t\t\t\tServiceDiscovery.getInstance(\n\t\t\t\t\tenvParser ??\n\t\t\t\t\t\t(() => {\n\t\t\t\t\t\t\t// Hit only if overload 2 was selected but ctx.serviceDiscovery is\n\t\t\t\t\t\t\t// missing at runtime — surface the mistake immediately rather\n\t\t\t\t\t\t\t// than letting an undefined env parser fail deep inside register.\n\t\t\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t\t\t'createServicesMiddleware: no `envParser` provided and ' +\n\t\t\t\t\t\t\t\t\t'`ctx.serviceDiscovery` is missing. Pass an EnvironmentParser ' +\n\t\t\t\t\t\t\t\t\t'to createServicesMiddleware(), or attach a ServiceDiscovery ' +\n\t\t\t\t\t\t\t\t\t'instance to the tRPC context.',\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t})(),\n\t\t\t\t);\n\n\t\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\t\tconst startTime = ctx.startTime ?? Date.now();\n\n\t\t\treturn runWithRequestContext(\n\t\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t\tasync () => {\n\t\t\t\t\tconst resolved = await discovery.register(services);\n\t\t\t\t\treturn opts.next({\n\t\t\t\t\t\tctx: { ...opts.ctx, ...resolved } as typeof opts.ctx &\n\t\t\t\t\t\t\tServiceRecord<T>,\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t);\n\t\t});\n\n\t\t// Tag the inner middleware function with the requested services so external\n\t\t// tooling (e.g. detect-procedures route generators) can introspect a\n\t\t// procedure's service dependencies without re-executing middleware.\n\t\tconst middlewares = (\n\t\t\tbuilder as unknown as { _middlewares?: Array<{ _services?: Service[] }> }\n\t\t)._middlewares;\n\t\tif (middlewares?.length) {\n\t\t\tconst last = middlewares[middlewares.length - 1];\n\t\t\tif (last) last._services = services as unknown as Service[];\n\t\t}\n\n\t\treturn builder as TRPCMiddlewareBuilder<\n\t\t\tTContext,\n\t\t\tTMeta,\n\t\t\tServiceRecord<T>,\n\t\t\tunknown\n\t\t>;\n\t}) as ServicesMiddleware<TContext, TMeta>;\n}\n\n/**\n * Create a tRPC middleware that establishes a request context for downstream\n * code without resolving any services. Useful when services aren't needed on\n * a procedure but the handler (or libraries it calls) still wants to read\n * `serviceContext.getLogger()` / `getRequestId()` / `getRequestStartTime()`.\n *\n * `requestId` and `startTime` are pulled from the tRPC context when present,\n * otherwise generated (`randomUUID()` and `Date.now()`).\n *\n * @example\n * ```ts\n * const withRequestContext = createRequestContextMiddleware(t.middleware);\n * export const baseProcedure = t.procedure.use(withRequestContext);\n * ```\n */\nexport function createRequestContextMiddleware<\n\tTContext extends ContextWithLogger & object,\n\tTMeta extends object,\n>(\n\tmw: CreateMiddleware<TContext, TMeta>,\n): TRPCMiddlewareBuilder<TContext, TMeta, object, unknown> {\n\treturn mw(async (opts) => {\n\t\tconst ctx = opts.ctx as TContext;\n\t\tconst requestId = ctx.requestId ?? randomUUID();\n\t\tconst startTime = ctx.startTime ?? Date.now();\n\t\treturn runWithRequestContext(\n\t\t\t{ logger: ctx.logger, requestId, startTime },\n\t\t\t() => opts.next(),\n\t\t);\n\t});\n}\n"],"mappings":";;;;AAgGA,SAAgB,yBAIf,IACA,WACsC;CACtC,SAAoC,aAAqB;EACxD,MAAM,UAAU,GAAG,OAAO,SAAS;GAClC,MAAM,MAAM,KAAK;GAEjB,MAAM,YACL,IAAI,oBACJ,iBAAiB,YAChB,oBACQ;IAIN,MAAM,IAAI,MACT,8MAID;GACD,EAAA,CAAG,CACL;GAED,MAAM,YAAY,IAAI,aAAa,WAAW;GAC9C,MAAM,YAAY,IAAI,aAAa,KAAK,IAAI;GAE5C,OAAO,sBACN;IAAE,QAAQ,IAAI;IAAQ;IAAW;GAAU,GAC3C,YAAY;IACX,MAAM,WAAW,MAAM,UAAU,SAAS,QAAQ;IAClD,OAAO,KAAK,KAAK,EAChB,KAAK;KAAE,GAAG,KAAK;KAAK,GAAG;IAAS,EAEjC,CAAC;GACF,CACD;EACD,CAAC;EAKD,MAAM,cACL,QACC;EACF,IAAI,aAAa,QAAQ;GACxB,MAAM,OAAO,YAAY,YAAY,SAAS;GAC9C,IAAI,MAAM,KAAK,YAAY;EAC5B;EAEA,OAAO;CAMR;AACD;;;;;;;;;;;;;;;;AAiBA,SAAgB,+BAIf,IAC0D;CAC1D,OAAO,GAAG,OAAO,SAAS;EACzB,MAAM,MAAM,KAAK;EACjB,MAAM,YAAY,IAAI,aAAa,WAAW;EAC9C,MAAM,YAAY,IAAI,aAAa,KAAK,IAAI;EAC5C,OAAO,sBACN;GAAE,QAAQ,IAAI;GAAQ;GAAW;EAAU,SACrC,KAAK,KAAK,CACjB;CACD,CAAC;AACF"}

package/dist/{types-Bgk-0NOO.d.cts → types-DDxt5Kcu.d.cts}

@@ -1,8 +1,6 @@
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
-
 //#region src/types.d.ts
-
 /**
  * Request context available to services.
  * Methods are guaranteed to return values when called within a request context.
@@ -87,7 +85,6 @@ interface Service<TName extends string = string, TInstance = unknown> {
    */
   register(options: ServiceRegisterOptions): TInstance | Promise<TInstance>;
 }
-//# sourceMappingURL=types.d.ts.map
 //#endregion
-export { Service, ServiceContext, ServiceRegisterOptions };
-//# sourceMappingURL=types-Bgk-0NOO.d.cts.map
+export { ServiceContext as n, ServiceRegisterOptions as r, Service as t };
+//# sourceMappingURL=types-DDxt5Kcu.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-DDxt5Kcu.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;UAQiB;;;;;;;;;;;;EAYhB,aAAa;;;;;EAMb;;;;;;EAOA;;;;;EAMA;;;;;UAMgB;;EAEhB,WAAW;;EAEX,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO,QAAQ,+BAA+B;;;;EAIvD,aAAa;;;;;;;EAOb,SAAS,SAAS,yBAAyB,YAAY,QAAQ"}

package/dist/{types-BoyOCa57.d.mts → types-DDxt5Kcu.d.mts}

@@ -1,8 +1,6 @@
 import { Logger } from "@geekmidas/logger";
 import { EnvironmentParser } from "@geekmidas/envkit";
-
 //#region src/types.d.ts
-
 /**
  * Request context available to services.
  * Methods are guaranteed to return values when called within a request context.
@@ -87,7 +85,6 @@ interface Service<TName extends string = string, TInstance = unknown> {
    */
   register(options: ServiceRegisterOptions): TInstance | Promise<TInstance>;
 }
-//# sourceMappingURL=types.d.ts.map
 //#endregion
-export { Service, ServiceContext, ServiceRegisterOptions };
-//# sourceMappingURL=types-BoyOCa57.d.mts.map
+export { ServiceContext as n, ServiceRegisterOptions as r, Service as t };
+//# sourceMappingURL=types-DDxt5Kcu.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-DDxt5Kcu.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;UAQiB;;;;;;;;;;;;EAYhB,aAAa;;;;;EAMb;;;;;;EAOA;;;;;EAMA;;;;;UAMgB;;EAEhB,WAAW;;EAEX,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BO,QAAQ,+BAA+B;;;;EAIvD,aAAa;;;;;;;EAOb,SAAS,SAAS,yBAAyB,YAAY,QAAQ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/services",
-  "version": "10.0.0-alpha.9",
+  "version": "10.0.0-alpha.91",
   "private": false,
   "type": "module",
   "exports": {
@@ -61,8 +61,8 @@
     "@middy/core": ">=7.9.2",
     "@trpc/server": ">=11.19.0",
     "@types/aws-lambda": ">=8.10.163",
-    "@geekmidas/envkit": "^10.0.0-alpha.9",
-    "@geekmidas/logger": "^10.0.0-alpha.9"
+    "@geekmidas/envkit": "^10.0.0-alpha.91",
+    "@geekmidas/logger": "^10.0.0-alpha.91"
   },
   "peerDependenciesMeta": {
     "@geekmidas/envkit": {
@@ -86,10 +86,11 @@
     "@trpc/server": "~11.19.0",
     "@types/aws-lambda": "~8.10.163",
     "@types/node": "~24.9.1",
-    "@geekmidas/envkit": "^10.0.0-alpha.9",
-    "@geekmidas/logger": "^10.0.0-alpha.9"
+    "@geekmidas/envkit": "^10.0.0-alpha.91",
+    "@geekmidas/logger": "^10.0.0-alpha.91"
   },
   "scripts": {
-    "ts": "tsc --noEmit --skipLibCheck src/**/*.ts"
+    "ts": "tsc --noEmit --skipLibCheck src/**/*.ts",
+    "build": "tsdown --config ../../tsdown.config.ts --filter ."
   }
 }

package/dist/ServiceDiscovery-BO8W-RY8.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServiceDiscovery-BO8W-RY8.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-BrCUabG_.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServiceDiscovery-BrCUabG_.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-CRq_bGbi.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServiceDiscovery-CRq_bGbi.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-WHikQSQv.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ServiceDiscovery-WHikQSQv.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/context-1ROj3zvL.cjs

@@ -1,197 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-const node_async_hooks = __toESM(require("node:async_hooks"));
-
-//#region src/context.ts
-/**
-* Internal AsyncLocalStorage instance for request context.
-* Not exported - use runWithRequestContext() to establish context
-* and serviceContext to access it.
-*/
-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) => {
-				const resolved = resolve();
-				const fn = resolved[prop];
-				return fn.apply(resolved, 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() {
-		resolveRequestLogger();
-		return requestScopedLogger;
-	},
-	getRequestId() {
-		const store = requestContextStorage.getStore();
-		if (!store) throw new Error("ServiceContext.getRequestId() called outside request context. Ensure code runs within runWithRequestContext().");
-		return store.requestId;
-	},
-	getRequestStartTime() {
-		const store = requestContextStorage.getStore();
-		if (!store) throw new Error("ServiceContext.getRequestStartTime() called outside request context. Ensure code runs within runWithRequestContext().");
-		return store.startTime;
-	},
-	hasContext() {
-		return requestContextStorage.getStore() !== void 0;
-	}
-};
-/**
-* Run a function with request context.
-* Used by endpoint/function/subscriber adaptors.
-*
-* @param data - Request context data (logger, requestId, startTime)
-* @param fn - Function to run with context
-* @returns Result of the function
-*
-* @example
-* ```typescript
-* const result = await runWithRequestContext(
-*   { logger, requestId, startTime: Date.now() },
-*   async () => {
-*     // Inside here, serviceContext.getLogger() returns `logger`
-*     // serviceContext.getRequestId() returns `requestId`
-*     return await handleRequest();
-*   }
-* );
-* ```
-*/
-function runWithRequestContext(data, fn) {
-	return requestContextStorage.run(data, fn);
-}
-/**
-* Mutate the current async task's store so that subsequent code in this task
-* (and any descendants) sees the supplied request context.
-*
-* Unlike `runWithRequestContext`, this does not scope the context to a
-* callback — useful when the caller can't wrap a function, for example in a
-* Vitest fixture that suspends on `use()` and yields control to the test
-* runner before the test body executes.
-*
-* **Test setup only.** In production handlers, prefer `runWithRequestContext`
-* so the frame is automatically cleaned up.
-*/
-function enterRequestContext(data) {
-	requestContextStorage.enterWith(data);
-}
-/**
-* Clear the request context for the current async task. Pairs with
-* `enterRequestContext`. After calling, `serviceContext.hasContext()` returns
-* false for the remainder of the current async resource.
-*/
-function exitRequestContext() {
-	requestContextStorage.enterWith(void 0);
-}
-
-//#endregion
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});
-Object.defineProperty(exports, 'enterRequestContext', {
-  enumerable: true,
-  get: function () {
-    return enterRequestContext;
-  }
-});
-Object.defineProperty(exports, 'exitRequestContext', {
-  enumerable: true,
-  get: function () {
-    return exitRequestContext;
-  }
-});
-Object.defineProperty(exports, 'runWithRequestContext', {
-  enumerable: true,
-  get: function () {
-    return runWithRequestContext;
-  }
-});
-Object.defineProperty(exports, 'serviceContext', {
-  enumerable: true,
-  get: function () {
-    return serviceContext;
-  }
-});
-//# sourceMappingURL=context-1ROj3zvL.cjs.map

package/dist/context-1ROj3zvL.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-1ROj3zvL.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 unknown 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// Re-resolve at call time so detached references target the\n\t\t\t\t\t\t// current request's logger, and invoke with that logger as\n\t\t\t\t\t\t// `this`: pino's log methods read internal state off the\n\t\t\t\t\t\t// receiver (`this[Symbol(pino.msgPrefix)]`), so calling them\n\t\t\t\t\t\t// unbound throws \"Cannot read properties of undefined\".\n\t\t\t\t\t\tconst resolved = resolve();\n\t\t\t\t\t\tconst fn = (resolved as unknown as Record<string, unknown>)[\n\t\t\t\t\t\t\tprop\n\t\t\t\t\t\t] as (...a: unknown[]) => unknown;\n\t\t\t\t\t\treturn fn.apply(resolved, args);\n\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,CAAwC;AAKhE,iBAAc,UAAU,aACrB,CAAC,GAAG,SAAoB;IAMxB,MAAM,WAAW,SAAS;IAC1B,MAAM,KAAM,SACX;AAED,WAAO,GAAG,MAAM,UAAU,KAAK;GAC/B,IACA;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"}