evlog 2.5.0 → 2.7.0

package/dist/sveltekit/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/sveltekit/index.ts"],"sourcesContent":["import type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { extractSafeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\nimport { resolveEvlogError, extractErrorStatus, serializeEvlogErrorResponse } from '../nitro'\nimport { EvlogError } from '../error'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'handle context. Make sure evlog() handle is added to your hooks.server.ts.',\n)\n\nexport type EvlogSvelteKitOptions = BaseEvlogOptions\n\nexport { useLogger }\n\n/**\n * SvelteKit `Handle` function signature — avoids a hard dependency on `@sveltejs/kit`.\n */\ntype SvelteKitHandle = (input: {\n  event: { request: Request; url: URL; locals: Record<string, any> }\n  resolve: (event: any) => Promise<Response>\n}) => Promise<Response>\n\n/**\n * SvelteKit `HandleServerError` signature — avoids a hard dependency on `@sveltejs/kit`.\n */\ntype SvelteKitHandleServerError = (input: {\n  error: unknown\n  event: { request: Request; url: URL; locals: Record<string, any> }\n  status: number\n  message: string\n}) => MaybePromise<void | AppError>\n\ntype MaybePromise<T> = T | Promise<T>\n\n/** Minimal SvelteKit `App.Error` shape */\ninterface AppError {\n  message: string\n  [key: string]: unknown\n}\n\n/**\n * Create an evlog handle hook for SvelteKit.\n *\n * Add it to your `src/hooks.server.ts` using SvelteKit's `sequence` helper\n * or as the sole handle export.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { initLogger } from 'evlog'\n * import { evlog } from 'evlog/sveltekit'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * initLogger({ env: { service: 'my-sveltekit-app' } })\n *\n * export const handle = evlog({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * })\n * ```\n *\n * @example\n * ```ts\n * // Compose with other hooks using sequence\n * import { sequence } from '@sveltejs/kit/hooks'\n * import { evlog } from 'evlog/sveltekit'\n *\n * export const handle = sequence(evlog(), yourOtherHook)\n * ```\n */\nexport function evlog(options: EvlogSvelteKitOptions = {}): SvelteKitHandle {\n  return async ({ event, resolve }) => {\n    const { logger, finish, skipped } = createMiddlewareLogger({\n      method: event.request.method,\n      path: event.url.pathname,\n      requestId: event.request.headers.get('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeHeaders(event.request.headers),\n      ...options,\n    })\n\n    if (skipped) {\n      return await resolve(event)\n    }\n\n    event.locals.log = logger\n\n    return storage.run(logger, async () => {\n      try {\n        const response = await resolve(event)\n\n        // SvelteKit catches route errors internally and returns 500.\n        // If handleError already logged an EvlogError with a specific status,\n        // return a structured JSON response instead of SvelteKit's generic 500.\n        const ctx = logger.getContext()\n        const errorData = ctx.error as { name?: string; status?: number; message?: string; data?: unknown } | undefined\n        if (response.status >= 500 && errorData?.name === 'EvlogError' && errorData.status) {\n          const { status } = errorData\n          await finish({ status })\n          const body = serializeEvlogErrorResponse(errorData as EvlogError, event.url.pathname)\n          return new Response(JSON.stringify(body), {\n            status,\n            headers: { 'content-type': 'application/json' },\n          })\n        }\n\n        await finish({ status: response.status })\n        return response\n      } catch (error) {\n        await finish({ error: error as Error })\n\n        // Return structured JSON for EvlogError (like NextJS withEvlog / Nuxt errorHandler)\n        if (error instanceof EvlogError) {\n          const status = error.status ?? 500\n          const body = serializeEvlogErrorResponse(error, event.url.pathname)\n          return new Response(JSON.stringify(body), {\n            status,\n            headers: { 'content-type': 'application/json' },\n          })\n        }\n\n        throw error\n      }\n    })\n  }\n}\n\n/**\n * Create an evlog error handler for SvelteKit.\n *\n * Logs unhandled errors via `event.locals.log` (if available) and returns\n * structured error responses for `EvlogError` instances. For non-evlog errors,\n * returns a generic error response with sanitized messages in production.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { evlog, evlogHandleError } from 'evlog/sveltekit'\n *\n * export const handle = evlog()\n * export const handleError = evlogHandleError()\n * ```\n */\nexport function evlogHandleError(): SvelteKitHandleServerError {\n  return ({ error, event, status, message }) => {\n    const logger = event.locals.log as RequestLogger | undefined\n\n    if (logger && error instanceof Error) {\n      logger.error(error)\n    }\n\n    const evlogError = error instanceof Error ? resolveEvlogError(error) : null\n\n    if (evlogError) {\n      const errorStatus = extractErrorStatus(evlogError)\n      const response = serializeEvlogErrorResponse(evlogError, event.url.pathname)\n      return {\n        message: response.message as string,\n        status: errorStatus,\n        why: (response.data as { why?: string })?.why,\n        fix: (response.data as { fix?: string })?.fix,\n        link: (response.data as { link?: string })?.link,\n      } as AppError\n    }\n\n    return { message, status } as AppError\n  }\n}\n\n/**\n * Create both `handle` and `handleError` hooks in a single call.\n *\n * This is the recommended setup for SvelteKit — it returns both hooks\n * pre-configured and ready to export from `hooks.server.ts`.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { initLogger } from 'evlog'\n * import { createEvlogHooks } from 'evlog/sveltekit'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * initLogger({ env: { service: 'my-app' } })\n *\n * export const { handle, handleError } = createEvlogHooks({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * })\n * ```\n *\n * @example\n * ```ts\n * // Compose with other hooks using sequence\n * import { sequence } from '@sveltejs/kit/hooks'\n * import { createEvlogHooks } from 'evlog/sveltekit'\n *\n * const evlogHooks = createEvlogHooks()\n *\n * export const handle = sequence(evlogHooks.handle, yourOtherHook)\n * export const handleError = evlogHooks.handleError\n * ```\n */\nexport function createEvlogHooks(options: EvlogSvelteKitOptions = {}) {\n  return {\n    handle: evlog(options),\n    handleError: evlogHandleError(),\n  }\n}\n"],"mappings":";;;;;AAOA,MAAM,EAAE,SAAS,cAAc,oBAC7B,6EACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgED,SAAgB,MAAM,UAAiC,EAAE,EAAmB;AAC1E,QAAO,OAAO,EAAE,OAAO,cAAc;EACnC,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,MAAM,QAAQ;GACtB,MAAM,MAAM,IAAI;GAChB,WAAW,MAAM,QAAQ,QAAQ,IAAI,eAAe,IAAI,OAAO,YAAY;GAC3E,SAAS,mBAAmB,MAAM,QAAQ,QAAQ;GAClD,GAAG;GACJ,CAAC;AAEF,MAAI,QACF,QAAO,MAAM,QAAQ,MAAM;AAG7B,QAAM,OAAO,MAAM;AAEnB,SAAO,QAAQ,IAAI,QAAQ,YAAY;AACrC,OAAI;IACF,MAAM,WAAW,MAAM,QAAQ,MAAM;IAMrC,MAAM,YADM,OAAO,YAAY,CACT;AACtB,QAAI,SAAS,UAAU,OAAO,WAAW,SAAS,gBAAgB,UAAU,QAAQ;KAClF,MAAM,EAAE,WAAW;AACnB,WAAM,OAAO,EAAE,QAAQ,CAAC;KACxB,MAAM,OAAO,4BAA4B,WAAyB,MAAM,IAAI,SAAS;AACrF,YAAO,IAAI,SAAS,KAAK,UAAU,KAAK,EAAE;MACxC;MACA,SAAS,EAAE,gBAAgB,oBAAoB;MAChD,CAAC;;AAGJ,UAAM,OAAO,EAAE,QAAQ,SAAS,QAAQ,CAAC;AACzC,WAAO;YACA,OAAO;AACd,UAAM,OAAO,EAAS,OAAgB,CAAC;AAGvC,QAAI,iBAAiB,YAAY;KAC/B,MAAM,SAAS,MAAM,UAAU;KAC/B,MAAM,OAAO,4BAA4B,OAAO,MAAM,IAAI,SAAS;AACnE,YAAO,IAAI,SAAS,KAAK,UAAU,KAAK,EAAE;MACxC;MACA,SAAS,EAAE,gBAAgB,oBAAoB;MAChD,CAAC;;AAGJ,UAAM;;IAER;;;;;;;;;;;;;;;;;;;AAoBN,SAAgB,mBAA+C;AAC7D,SAAQ,EAAE,OAAO,OAAO,QAAQ,cAAc;EAC5C,MAAM,SAAS,MAAM,OAAO;AAE5B,MAAI,UAAU,iBAAiB,MAC7B,QAAO,MAAM,MAAM;EAGrB,MAAM,aAAa,iBAAiB,QAAQ,kBAAkB,MAAM,GAAG;AAEvE,MAAI,YAAY;GACd,MAAM,cAAc,mBAAmB,WAAW;GAClD,MAAM,WAAW,4BAA4B,YAAY,MAAM,IAAI,SAAS;AAC5E,UAAO;IACL,SAAS,SAAS;IAClB,QAAQ;IACR,KAAM,SAAS,MAA2B;IAC1C,KAAM,SAAS,MAA2B;IAC1C,MAAO,SAAS,MAA4B;IAC7C;;AAGH,SAAO;GAAE;GAAS;GAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuC9B,SAAgB,iBAAiB,UAAiC,EAAE,EAAE;AACpE,QAAO;EACL,QAAQ,MAAM,QAAQ;EACtB,aAAa,kBAAkB;EAChC"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/sveltekit/index.ts"],"sourcesContent":["import type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { extractSafeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\nimport { resolveEvlogError, extractErrorStatus, serializeEvlogErrorResponse } from '../nitro'\nimport { EvlogError } from '../error'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'handle context. Make sure evlog() handle is added to your hooks.server.ts.',\n)\n\nexport type EvlogSvelteKitOptions = BaseEvlogOptions\n\nexport { useLogger }\n\n/**\n * SvelteKit `Handle` function signature — avoids a hard dependency on `@sveltejs/kit`.\n */\ntype SvelteKitHandle = (input: {\n  event: { request: Request; url: URL; locals: Record<string, any> }\n  resolve: (event: any) => Promise<Response>\n}) => Promise<Response>\n\n/**\n * SvelteKit `HandleServerError` signature — avoids a hard dependency on `@sveltejs/kit`.\n */\ntype SvelteKitHandleServerError = (input: {\n  error: unknown\n  event: { request: Request; url: URL; locals: Record<string, any> }\n  status: number\n  message: string\n}) => MaybePromise<void | AppError>\n\ntype MaybePromise<T> = T | Promise<T>\n\n/** Minimal SvelteKit `App.Error` shape */\ninterface AppError {\n  message: string\n  [key: string]: unknown\n}\n\n/**\n * Create an evlog handle hook for SvelteKit.\n *\n * Add it to your `src/hooks.server.ts` using SvelteKit's `sequence` helper\n * or as the sole handle export.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { initLogger } from 'evlog'\n * import { evlog } from 'evlog/sveltekit'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * initLogger({ env: { service: 'my-sveltekit-app' } })\n *\n * export const handle = evlog({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * })\n * ```\n *\n * @example\n * ```ts\n * // Compose with other hooks using sequence\n * import { sequence } from '@sveltejs/kit/hooks'\n * import { evlog } from 'evlog/sveltekit'\n *\n * export const handle = sequence(evlog(), yourOtherHook)\n * ```\n */\nexport function evlog(options: EvlogSvelteKitOptions = {}): SvelteKitHandle {\n  return async ({ event, resolve }) => {\n    const { logger, finish, skipped } = createMiddlewareLogger({\n      method: event.request.method,\n      path: event.url.pathname,\n      requestId: event.request.headers.get('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeHeaders(event.request.headers),\n      ...options,\n    })\n\n    if (skipped) {\n      return await resolve(event)\n    }\n\n    event.locals.log = logger\n\n    return storage.run(logger, async () => {\n      try {\n        const response = await resolve(event)\n\n        // SvelteKit catches route errors internally and returns 500.\n        // If handleError already logged an EvlogError with a specific status,\n        // return a structured JSON response instead of SvelteKit's generic 500.\n        const ctx = logger.getContext()\n        const errorData = ctx.error as { name?: string; status?: number; message?: string; data?: unknown } | undefined\n        if (response.status >= 500 && errorData?.name === 'EvlogError' && errorData.status) {\n          const { status } = errorData\n          await finish({ status })\n          const body = serializeEvlogErrorResponse(errorData as EvlogError, event.url.pathname)\n          return new Response(JSON.stringify(body), {\n            status,\n            headers: { 'content-type': 'application/json' },\n          })\n        }\n\n        await finish({ status: response.status })\n        return response\n      } catch (error) {\n        await finish({ error: error as Error })\n\n        // Return structured JSON for EvlogError (like NextJS withEvlog / Nuxt errorHandler)\n        if (error instanceof EvlogError) {\n          const status = error.status ?? 500\n          const body = serializeEvlogErrorResponse(error, event.url.pathname)\n          return new Response(JSON.stringify(body), {\n            status,\n            headers: { 'content-type': 'application/json' },\n          })\n        }\n\n        throw error\n      }\n    })\n  }\n}\n\n/**\n * Create an evlog error handler for SvelteKit.\n *\n * Logs unhandled errors via `event.locals.log` (if available) and returns\n * structured error responses for `EvlogError` instances. For non-evlog errors,\n * returns a generic error response with sanitized messages in production.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { evlog, evlogHandleError } from 'evlog/sveltekit'\n *\n * export const handle = evlog()\n * export const handleError = evlogHandleError()\n * ```\n */\nexport function evlogHandleError(): SvelteKitHandleServerError {\n  return ({ error, event, status, message }) => {\n    const logger = event.locals.log as RequestLogger | undefined\n\n    if (logger && error instanceof Error) {\n      logger.error(error)\n    }\n\n    const evlogError = error instanceof Error ? resolveEvlogError(error) : null\n\n    if (evlogError) {\n      const errorStatus = extractErrorStatus(evlogError)\n      const response = serializeEvlogErrorResponse(evlogError, event.url.pathname)\n      return {\n        message: response.message as string,\n        status: errorStatus,\n        why: (response.data as { why?: string })?.why,\n        fix: (response.data as { fix?: string })?.fix,\n        link: (response.data as { link?: string })?.link,\n      } as AppError\n    }\n\n    return { message, status } as AppError\n  }\n}\n\n/**\n * Create both `handle` and `handleError` hooks in a single call.\n *\n * This is the recommended setup for SvelteKit — it returns both hooks\n * pre-configured and ready to export from `hooks.server.ts`.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { initLogger } from 'evlog'\n * import { createEvlogHooks } from 'evlog/sveltekit'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * initLogger({ env: { service: 'my-app' } })\n *\n * export const { handle, handleError } = createEvlogHooks({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * })\n * ```\n *\n * @example\n * ```ts\n * // Compose with other hooks using sequence\n * import { sequence } from '@sveltejs/kit/hooks'\n * import { createEvlogHooks } from 'evlog/sveltekit'\n *\n * const evlogHooks = createEvlogHooks()\n *\n * export const handle = sequence(evlogHooks.handle, yourOtherHook)\n * export const handleError = evlogHooks.handleError\n * ```\n */\nexport function createEvlogHooks(options: EvlogSvelteKitOptions = {}) {\n  return {\n    handle: evlog(options),\n    handleError: evlogHandleError(),\n  }\n}\n"],"mappings":";;;;;;AAOA,MAAM,EAAE,SAAS,cAAc,oBAC7B,6EACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgED,SAAgB,MAAM,UAAiC,EAAE,EAAmB;AAC1E,QAAO,OAAO,EAAE,OAAO,cAAc;EACnC,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,MAAM,QAAQ;GACtB,MAAM,MAAM,IAAI;GAChB,WAAW,MAAM,QAAQ,QAAQ,IAAI,eAAe,IAAI,OAAO,YAAY;GAC3E,SAAS,mBAAmB,MAAM,QAAQ,QAAQ;GAClD,GAAG;GACJ,CAAC;AAEF,MAAI,QACF,QAAO,MAAM,QAAQ,MAAM;AAG7B,QAAM,OAAO,MAAM;AAEnB,SAAO,QAAQ,IAAI,QAAQ,YAAY;AACrC,OAAI;IACF,MAAM,WAAW,MAAM,QAAQ,MAAM;IAMrC,MAAM,YADM,OAAO,YAAY,CACT;AACtB,QAAI,SAAS,UAAU,OAAO,WAAW,SAAS,gBAAgB,UAAU,QAAQ;KAClF,MAAM,EAAE,WAAW;AACnB,WAAM,OAAO,EAAE,QAAQ,CAAC;KACxB,MAAM,OAAO,4BAA4B,WAAyB,MAAM,IAAI,SAAS;AACrF,YAAO,IAAI,SAAS,KAAK,UAAU,KAAK,EAAE;MACxC;MACA,SAAS,EAAE,gBAAgB,oBAAoB;MAChD,CAAC;;AAGJ,UAAM,OAAO,EAAE,QAAQ,SAAS,QAAQ,CAAC;AACzC,WAAO;YACA,OAAO;AACd,UAAM,OAAO,EAAS,OAAgB,CAAC;AAGvC,QAAI,iBAAiB,YAAY;KAC/B,MAAM,SAAS,MAAM,UAAU;KAC/B,MAAM,OAAO,4BAA4B,OAAO,MAAM,IAAI,SAAS;AACnE,YAAO,IAAI,SAAS,KAAK,UAAU,KAAK,EAAE;MACxC;MACA,SAAS,EAAE,gBAAgB,oBAAoB;MAChD,CAAC;;AAGJ,UAAM;;IAER;;;;;;;;;;;;;;;;;;;AAoBN,SAAgB,mBAA+C;AAC7D,SAAQ,EAAE,OAAO,OAAO,QAAQ,cAAc;EAC5C,MAAM,SAAS,MAAM,OAAO;AAE5B,MAAI,UAAU,iBAAiB,MAC7B,QAAO,MAAM,MAAM;EAGrB,MAAM,aAAa,iBAAiB,QAAQ,kBAAkB,MAAM,GAAG;AAEvE,MAAI,YAAY;GACd,MAAM,cAAc,mBAAmB,WAAW;GAClD,MAAM,WAAW,4BAA4B,YAAY,MAAM,IAAI,SAAS;AAC5E,UAAO;IACL,SAAS,SAAS;IAClB,QAAQ;IACR,KAAM,SAAS,MAA2B;IAC1C,KAAM,SAAS,MAA2B;IAC1C,MAAO,SAAS,MAA4B;IAC7C;;AAGH,SAAO;GAAE;GAAS;GAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuC9B,SAAgB,iBAAiB,UAAiC,EAAE,EAAE;AACpE,QAAO;EACL,QAAQ,MAAM,QAAQ;EACtB,aAAa,kBAAkB;EAChC"}

package/dist/toolkit.d.mts

@@ -0,0 +1,38 @@
+import { g as RequestLogger } from "./types-US-1hJZl.mjs";
+import { i as createMiddlewareLogger, n as MiddlewareLoggerOptions, r as MiddlewareLoggerResult, t as BaseEvlogOptions } from "./middleware-CDLTVOBs.mjs";
+import { n as getServiceForPath, r as shouldLog, t as extractErrorStatus } from "./errors-nScQVwHW.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/shared/headers.d.ts
+/**
+ * Extract headers from a Web API `Headers` object and filter out sensitive ones.
+ * Works with any runtime that supports the standard `Headers` API (Hono, Elysia,
+ * Nitro v3, Cloudflare Workers, Bun, Deno, etc.).
+ */
+declare function extractSafeHeaders(headers: Headers): Record<string, string>;
+/**
+ * Extract headers from Node.js `IncomingHttpHeaders` and filter out sensitive ones.
+ * Works with Express, Fastify, and any Node.js HTTP server using `req.headers`.
+ */
+declare function extractSafeNodeHeaders(headers: Record<string, string | string[] | undefined>): Record<string, string>;
+//#endregion
+//#region src/shared/storage.d.ts
+/**
+ * Create a request-scoped `AsyncLocalStorage` and a matching `useLogger` accessor.
+ *
+ * Every framework that needs `useLogger()` (Express, Fastify, NestJS, SvelteKit)
+ * calls this once at module level to get its own isolated storage + accessor pair.
+ *
+ * @param contextHint - Human-readable hint appended to the error message when
+ *   `useLogger()` is called outside of a request (e.g.
+ *   `"middleware context. Make sure app.use(evlog()) is registered before your routes."`).
+ *
+ * @beta Part of `evlog/toolkit` — the public API for building custom integrations.
+ */
+declare function createLoggerStorage(contextHint: string): {
+  storage: AsyncLocalStorage<RequestLogger<Record<string, unknown>>>;
+  useLogger: <T extends object = Record<string, unknown>>() => RequestLogger<T>;
+};
+//#endregion
+export { BaseEvlogOptions, MiddlewareLoggerOptions, MiddlewareLoggerResult, createLoggerStorage, createMiddlewareLogger, extractErrorStatus, extractSafeHeaders, extractSafeNodeHeaders, getServiceForPath, shouldLog };
+//# sourceMappingURL=toolkit.d.mts.map

package/dist/toolkit.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolkit.d.mts","names":[],"sources":["../src/shared/headers.ts","../src/shared/storage.ts"],"mappings":";;;;;;;;;;;iBAOgB,kBAAA,CAAmB,OAAA,EAAS,OAAA,GAAU,MAAA;AAAtD;;;;AAAA,iBAYgB,sBAAA,CAAuB,OAAA,EAAS,MAAA,0CAAgD,MAAA;;;;;;;AAZhG;;;;;;;;iBCQgB,mBAAA,CAAoB,WAAA;;iCAmBC,MAAA,wBAA+B,aAAA,CAAc,CAAA;AAAA"}

package/dist/toolkit.mjs

@@ -0,0 +1,5 @@
+import { t as extractErrorStatus } from "./errors-BJRXUfMg.mjs";
+import { n as shouldLog, t as getServiceForPath } from "./routes-CE3_c-iZ.mjs";
+import { n as extractSafeNodeHeaders, r as createMiddlewareLogger, t as extractSafeHeaders } from "./headers-BSgpnR0c.mjs";
+import { t as createLoggerStorage } from "./storage-DHU1gGqV.mjs";
+export { createLoggerStorage, createMiddlewareLogger, extractErrorStatus, extractSafeHeaders, extractSafeNodeHeaders, getServiceForPath, shouldLog };

package/dist/{types-CRj5tGVA.d.mts → types-US-1hJZl.d.mts}

@@ -245,6 +245,14 @@ interface LoggerConfig {
    * @default true
    */
   stringify?: boolean;
+  /**
+   * Suppress built-in console output.
+   * When true, events are still built, sampled, and passed to drains,
+   * but nothing is written to console. Use when drains own the output
+   * channel (e.g., stdout-based platforms like GCP Cloud Run, AWS Lambda).
+   * @default false
+   */
+  silent?: boolean;
   /**
    * Drain callback called with every emitted event (fire-and-forget).
    * Use this to send logs to external services outside of Nitro.
@@ -277,6 +285,8 @@ interface LoggerConfig {
    * ```
    */
   drain?: (ctx: DrainContext) => void | Promise<void>;
+  /** @internal Suppress the "silent without drain" warning (used by hook-based frameworks like Nitro/Nuxt) */
+  _suppressDrainWarning?: boolean;
 }
 /**
  * Base structure for all wide events
@@ -493,4 +503,4 @@ interface ParsedError {
 }
 //#endregion
 export { TailSamplingContext as C, TailSamplingCondition as S, WideEvent as T, RequestLoggerOptions as _, EnvironmentContext as a, SamplingRates as b, H3EventContext as c, Log as d, LogLevel as f, RequestLogger as g, RequestLogEntry as h, EnrichContext as i, IngestPayload as l, ParsedError as m, DeepPartial as n, ErrorOptions as o, LoggerConfig as p, DrainContext as r, FieldContext as s, BaseWideEvent as t, InternalFields as u, RouteConfig as v, TransportConfig as w, ServerEvent as x, SamplingConfig as y };
-//# sourceMappingURL=types-CRj5tGVA.d.mts.map
+//# sourceMappingURL=types-US-1hJZl.d.mts.map

package/dist/types-US-1hJZl.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-US-1hJZl.d.mts","names":[],"sources":["../src/types.ts"],"mappings":"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"}

package/dist/types.d.mts

@@ -1,2 +1,2 @@
-import { C as TailSamplingContext, S as TailSamplingCondition, T as WideEvent, _ as RequestLoggerOptions, a as EnvironmentContext, b as SamplingRates, c as H3EventContext, d as Log, f as LogLevel, g as RequestLogger, h as RequestLogEntry, i as EnrichContext, l as IngestPayload, m as ParsedError, n as DeepPartial, o as ErrorOptions, p as LoggerConfig, r as DrainContext, s as FieldContext, t as BaseWideEvent, u as InternalFields, v as RouteConfig, w as TransportConfig, x as ServerEvent, y as SamplingConfig } from "./types-CRj5tGVA.mjs";
+import { C as TailSamplingContext, S as TailSamplingCondition, T as WideEvent, _ as RequestLoggerOptions, a as EnvironmentContext, b as SamplingRates, c as H3EventContext, d as Log, f as LogLevel, g as RequestLogger, h as RequestLogEntry, i as EnrichContext, l as IngestPayload, m as ParsedError, n as DeepPartial, o as ErrorOptions, p as LoggerConfig, r as DrainContext, s as FieldContext, t as BaseWideEvent, u as InternalFields, v as RouteConfig, w as TransportConfig, x as ServerEvent, y as SamplingConfig } from "./types-US-1hJZl.mjs";
 export { BaseWideEvent, DeepPartial, DrainContext, EnrichContext, EnvironmentContext, ErrorOptions, FieldContext, H3EventContext, IngestPayload, InternalFields, Log, LogLevel, LoggerConfig, ParsedError, RequestLogEntry, RequestLogger, RequestLoggerOptions, RouteConfig, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, TransportConfig, WideEvent };

package/dist/{useLogger-w7MZjqW_.d.mts → useLogger-DBHI03WK.d.mts}

@@ -1,4 +1,4 @@
-import { g as RequestLogger, x as ServerEvent } from "./types-CRj5tGVA.mjs";
+import { g as RequestLogger, x as ServerEvent } from "./types-US-1hJZl.mjs";
 
 //#region src/runtime/server/useLogger.d.ts
 /**
@@ -36,4 +36,4 @@ import { g as RequestLogger, x as ServerEvent } from "./types-CRj5tGVA.mjs";
 declare function useLogger<T extends object = Record<string, unknown>>(event: ServerEvent, service?: string): RequestLogger<T>;
 //#endregion
 export { useLogger as t };
-//# sourceMappingURL=useLogger-w7MZjqW_.d.mts.map
+//# sourceMappingURL=useLogger-DBHI03WK.d.mts.map

package/dist/{useLogger-w7MZjqW_.d.mts.map → useLogger-DBHI03WK.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"useLogger-w7MZjqW_.d.mts","names":[],"sources":["../src/runtime/server/useLogger.ts"],"mappings":";;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,SAAA,oBAA6B,MAAA,kBAAA,CAAyB,KAAA,EAAO,WAAA,EAAa,OAAA,YAAmB,aAAA,CAAc,CAAA"}
+{"version":3,"file":"useLogger-DBHI03WK.d.mts","names":[],"sources":["../src/runtime/server/useLogger.ts"],"mappings":";;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,SAAA,oBAA6B,MAAA,kBAAA,CAAyB,KAAA,EAAO,WAAA,EAAa,OAAA,YAAmB,aAAA,CAAc,CAAA"}

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-import { a as EnvironmentContext, f as LogLevel } from "./types-CRj5tGVA.mjs";
+import { a as EnvironmentContext, f as LogLevel } from "./types-US-1hJZl.mjs";
 
 //#region src/utils.d.ts
 declare function formatDuration(ms: number): string;
@@ -21,6 +21,22 @@ declare const colors: {
   readonly gray: "\u001B[90m";
 };
 declare function getLevelColor(level: string): string;
+declare const cssColors: {
+  readonly dim: "color: #6b7280";
+  readonly red: "color: #ef4444; font-weight: bold";
+  readonly green: "color: #22c55e";
+  readonly yellow: "color: #f59e0b; font-weight: bold";
+  readonly cyan: "color: #06b6d4; font-weight: bold";
+  readonly gray: "color: #6b7280; font-weight: bold";
+  readonly reset: "color: inherit; font-weight: normal";
+};
+declare function getCssLevelColor(level: string): string;
+/**
+ * Escape `%` in strings interpolated into `console.log` format strings
+ * to prevent `%c`, `%s`, `%d` etc. in user data from being interpreted
+ * as formatting directives.
+ */
+declare function escapeFormatString(str: string): string;
 /** Headers that should never be passed to hooks for security */
 declare const SENSITIVE_HEADERS: string[];
 declare function filterSafeHeaders(headers: Record<string, string>): Record<string, string>;
@@ -30,5 +46,5 @@ declare function filterSafeHeaders(headers: Record<string, string>): Record<stri
  */
 declare function matchesPattern(path: string, pattern: string): boolean;
 //#endregion
-export { SENSITIVE_HEADERS, colors, detectEnvironment, filterSafeHeaders, formatDuration, getConsoleMethod, getLevelColor, isClient, isDev, isServer, matchesPattern };
+export { SENSITIVE_HEADERS, colors, cssColors, detectEnvironment, escapeFormatString, filterSafeHeaders, formatDuration, getConsoleMethod, getCssLevelColor, getLevelColor, isClient, isDev, isServer, matchesPattern };
 //# sourceMappingURL=utils.d.mts.map

package/dist/utils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils.ts"],"mappings":";;;iBAEgB,cAAA,CAAe,EAAA;AAAA,iBAOf,QAAA,CAAA;AAAA,iBAIA,QAAA,CAAA;AAAA,iBAIA,KAAA,CAAA;AAAA,iBAUA,iBAAA,CAAA,GAAqB,OAAA,CAAQ,kBAAA;AAAA,iBAmB7B,gBAAA,CAAiB,KAAA,EAAO,QAAA,GAAW,QAAA;AAAA,cAItC,MAAA;EAAA;;;;;;;;;;;;iBAcG,aAAA,CAAc,KAAA;;cAgBjB,iBAAA;AAAA,iBASG,iBAAA,CAAkB,OAAA,EAAS,MAAA,mBAAyB,MAAA;;;;;iBAgBpD,cAAA,CAAe,IAAA,UAAc,OAAA"}
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils.ts"],"mappings":";;;iBAEgB,cAAA,CAAe,EAAA;AAAA,iBAOf,QAAA,CAAA;AAAA,iBAIA,QAAA,CAAA;AAAA,iBAIA,KAAA,CAAA;AAAA,iBAUA,iBAAA,CAAA,GAAqB,OAAA,CAAQ,kBAAA;AAAA,iBAmB7B,gBAAA,CAAiB,KAAA,EAAO,QAAA,GAAW,QAAA;AAAA,cAItC,MAAA;EAAA;;;;;;;;;;;;iBAcG,aAAA,CAAc,KAAA;AAAA,cAejB,SAAA;EAAA;;;;;;;;iBAUG,gBAAA,CAAiB,KAAA;;;;;;iBAoBjB,kBAAA,CAAmB,GAAA;AA3DnC;AAAA,cAgEa,iBAAA;AAAA,iBASG,iBAAA,CAAkB,OAAA,EAAS,MAAA,mBAAyB,MAAA;;;;;iBAgBpD,cAAA,CAAe,IAAA,UAAc,OAAA"}

package/dist/utils.mjs

@@ -50,6 +50,32 @@ function getLevelColor(level) {
 		default: return colors.white;
 	}
 }
+const cssColors = {
+	dim: "color: #6b7280",
+	red: "color: #ef4444; font-weight: bold",
+	green: "color: #22c55e",
+	yellow: "color: #f59e0b; font-weight: bold",
+	cyan: "color: #06b6d4; font-weight: bold",
+	gray: "color: #6b7280; font-weight: bold",
+	reset: "color: inherit; font-weight: normal"
+};
+function getCssLevelColor(level) {
+	switch (level) {
+		case "error": return cssColors.red;
+		case "warn": return cssColors.yellow;
+		case "info": return cssColors.cyan;
+		case "debug": return cssColors.gray;
+		default: return cssColors.reset;
+	}
+}
+/**
+* Escape `%` in strings interpolated into `console.log` format strings
+* to prevent `%c`, `%s`, `%d` etc. in user data from being interpreted
+* as formatting directives.
+*/
+function escapeFormatString(str) {
+	return str.replace(/%/g, "%%");
+}
 /** Headers that should never be passed to hooks for security */
 const SENSITIVE_HEADERS = [
 	"authorization",
@@ -73,6 +99,6 @@ function matchesPattern(path, pattern) {
 	return new RegExp(`^${regexPattern}$`).test(path);
 }
 //#endregion
-export { SENSITIVE_HEADERS, colors, detectEnvironment, filterSafeHeaders, formatDuration, getConsoleMethod, getLevelColor, isClient, isDev, isServer, matchesPattern };
+export { SENSITIVE_HEADERS, colors, cssColors, detectEnvironment, escapeFormatString, filterSafeHeaders, formatDuration, getConsoleMethod, getCssLevelColor, getLevelColor, isClient, isDev, isServer, matchesPattern };
 
 //# sourceMappingURL=utils.mjs.map

package/dist/utils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.mjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import type { EnvironmentContext, LogLevel } from './types'\n\nexport function formatDuration(ms: number): string {\n  if (ms < 1000) {\n    return `${Math.round(ms)}ms`\n  }\n  return `${(ms / 1000).toFixed(2)}s`\n}\n\nexport function isServer(): boolean {\n  return typeof window === 'undefined'\n}\n\nexport function isClient(): boolean {\n  return typeof window !== 'undefined'\n}\n\nexport function isDev(): boolean {\n  if (typeof process !== 'undefined') {\n    return process.env.NODE_ENV !== 'production'\n  }\n  if (typeof window !== 'undefined') {\n    return true\n  }\n  return false\n}\n\nexport function detectEnvironment(): Partial<EnvironmentContext> {\n  const env = typeof process !== 'undefined' ? process.env : {}\n  const defaultEnvironment = isDev() ? 'development' : 'production'\n\n  return {\n    environment: env.NODE_ENV || defaultEnvironment,\n    service: env.SERVICE_NAME || 'app',\n    version: env.APP_VERSION,\n    commitHash: env.COMMIT_SHA\n      || env.GITHUB_SHA\n      || env.VERCEL_GIT_COMMIT_SHA\n      || env.CF_PAGES_COMMIT_SHA,\n    region: env.VERCEL_REGION\n      || env.AWS_REGION\n      || env.FLY_REGION\n      || env.CF_REGION,\n  }\n}\n\nexport function getConsoleMethod(level: LogLevel): LogLevel {\n  return level\n}\n\nexport const colors = {\n  reset: '\\x1B[0m',\n  bold: '\\x1B[1m',\n  dim: '\\x1B[2m',\n  red: '\\x1B[31m',\n  green: '\\x1B[32m',\n  yellow: '\\x1B[33m',\n  blue: '\\x1B[34m',\n  magenta: '\\x1B[35m',\n  cyan: '\\x1B[36m',\n  white: '\\x1B[37m',\n  gray: '\\x1B[90m',\n} as const\n\nexport function getLevelColor(level: string): string {\n  switch (level) {\n    case 'error':\n      return colors.red\n    case 'warn':\n      return colors.yellow\n    case 'info':\n      return colors.cyan\n    case 'debug':\n      return colors.gray\n    default:\n      return colors.white\n  }\n}\n\n/** Headers that should never be passed to hooks for security */\nexport const SENSITIVE_HEADERS = [\n  'authorization',\n  'cookie',\n  'set-cookie',\n  'x-api-key',\n  'x-auth-token',\n  'proxy-authorization',\n]\n\nexport function filterSafeHeaders(headers: Record<string, string>): Record<string, string> {\n  const safeHeaders: Record<string, string> = {}\n\n  for (const [key, value] of Object.entries(headers)) {\n    if (!SENSITIVE_HEADERS.includes(key.toLowerCase())) {\n      safeHeaders[key] = value\n    }\n  }\n\n  return safeHeaders\n}\n\n/**\n * Match a path against a glob pattern.\n * Supports * (any chars except /) and ** (any chars including /).\n */\nexport function matchesPattern(path: string, pattern: string): boolean {\n  const regexPattern = pattern\n    .replace(/[.+^${}()|[\\]\\\\]/g, '\\\\$&') // Escape special regex chars except * and ?\n    .replace(/\\*\\*/g, '{{GLOBSTAR}}') // Temp placeholder for **\n    .replace(/\\*/g, '[^/]*') // * matches anything except /\n    .replace(/{{GLOBSTAR}}/g, '.*') // ** matches anything including /\n    .replace(/\\?/g, '[^/]') // ? matches single char except /\n\n  const regex = new RegExp(`^${regexPattern}$`)\n  return regex.test(path)\n}\n"],"mappings":";AAEA,SAAgB,eAAe,IAAoB;AACjD,KAAI,KAAK,IACP,QAAO,GAAG,KAAK,MAAM,GAAG,CAAC;AAE3B,QAAO,IAAI,KAAK,KAAM,QAAQ,EAAE,CAAC;;AAGnC,SAAgB,WAAoB;AAClC,QAAO,OAAO,WAAW;;AAG3B,SAAgB,WAAoB;AAClC,QAAO,OAAO,WAAW;;AAG3B,SAAgB,QAAiB;AAC/B,KAAI,OAAO,YAAY,YACrB,QAAO,QAAQ,IAAI,aAAa;AAElC,KAAI,OAAO,WAAW,YACpB,QAAO;AAET,QAAO;;AAGT,SAAgB,oBAAiD;CAC/D,MAAM,MAAM,OAAO,YAAY,cAAc,QAAQ,MAAM,EAAE;CAC7D,MAAM,qBAAqB,OAAO,GAAG,gBAAgB;AAErD,QAAO;EACL,aAAa,IAAI,YAAY;EAC7B,SAAS,IAAI,gBAAgB;EAC7B,SAAS,IAAI;EACb,YAAY,IAAI,cACX,IAAI,cACJ,IAAI,yBACJ,IAAI;EACT,QAAQ,IAAI,iBACP,IAAI,cACJ,IAAI,cACJ,IAAI;EACV;;AAGH,SAAgB,iBAAiB,OAA2B;AAC1D,QAAO;;AAGT,MAAa,SAAS;CACpB,OAAO;CACP,MAAM;CACN,KAAK;CACL,KAAK;CACL,OAAO;CACP,QAAQ;CACR,MAAM;CACN,SAAS;CACT,MAAM;CACN,OAAO;CACP,MAAM;CACP;AAED,SAAgB,cAAc,OAAuB;AACnD,SAAQ,OAAR;EACE,KAAK,QACH,QAAO,OAAO;EAChB,KAAK,OACH,QAAO,OAAO;EAChB,KAAK,OACH,QAAO,OAAO;EAChB,KAAK,QACH,QAAO,OAAO;EAChB,QACE,QAAO,OAAO;;;;AAKpB,MAAa,oBAAoB;CAC/B;CACA;CACA;CACA;CACA;CACA;CACD;AAED,SAAgB,kBAAkB,SAAyD;CACzF,MAAM,cAAsC,EAAE;AAE9C,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,CAChD,KAAI,CAAC,kBAAkB,SAAS,IAAI,aAAa,CAAC,CAChD,aAAY,OAAO;AAIvB,QAAO;;;;;;AAOT,SAAgB,eAAe,MAAc,SAA0B;CACrE,MAAM,eAAe,QAClB,QAAQ,qBAAqB,OAAO,CACpC,QAAQ,SAAS,eAAe,CAChC,QAAQ,OAAO,QAAQ,CACvB,QAAQ,iBAAiB,KAAK,CAC9B,QAAQ,OAAO,OAAO;AAGzB,QADc,IAAI,OAAO,IAAI,aAAa,GAAG,CAChC,KAAK,KAAK"}
+{"version":3,"file":"utils.mjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import type { EnvironmentContext, LogLevel } from './types'\n\nexport function formatDuration(ms: number): string {\n  if (ms < 1000) {\n    return `${Math.round(ms)}ms`\n  }\n  return `${(ms / 1000).toFixed(2)}s`\n}\n\nexport function isServer(): boolean {\n  return typeof window === 'undefined'\n}\n\nexport function isClient(): boolean {\n  return typeof window !== 'undefined'\n}\n\nexport function isDev(): boolean {\n  if (typeof process !== 'undefined') {\n    return process.env.NODE_ENV !== 'production'\n  }\n  if (typeof window !== 'undefined') {\n    return true\n  }\n  return false\n}\n\nexport function detectEnvironment(): Partial<EnvironmentContext> {\n  const env = typeof process !== 'undefined' ? process.env : {}\n  const defaultEnvironment = isDev() ? 'development' : 'production'\n\n  return {\n    environment: env.NODE_ENV || defaultEnvironment,\n    service: env.SERVICE_NAME || 'app',\n    version: env.APP_VERSION,\n    commitHash: env.COMMIT_SHA\n      || env.GITHUB_SHA\n      || env.VERCEL_GIT_COMMIT_SHA\n      || env.CF_PAGES_COMMIT_SHA,\n    region: env.VERCEL_REGION\n      || env.AWS_REGION\n      || env.FLY_REGION\n      || env.CF_REGION,\n  }\n}\n\nexport function getConsoleMethod(level: LogLevel): LogLevel {\n  return level\n}\n\nexport const colors = {\n  reset: '\\x1B[0m',\n  bold: '\\x1B[1m',\n  dim: '\\x1B[2m',\n  red: '\\x1B[31m',\n  green: '\\x1B[32m',\n  yellow: '\\x1B[33m',\n  blue: '\\x1B[34m',\n  magenta: '\\x1B[35m',\n  cyan: '\\x1B[36m',\n  white: '\\x1B[37m',\n  gray: '\\x1B[90m',\n} as const\n\nexport function getLevelColor(level: string): string {\n  switch (level) {\n    case 'error':\n      return colors.red\n    case 'warn':\n      return colors.yellow\n    case 'info':\n      return colors.cyan\n    case 'debug':\n      return colors.gray\n    default:\n      return colors.white\n  }\n}\n\nexport const cssColors = {\n  dim: 'color: #6b7280',\n  red: 'color: #ef4444; font-weight: bold',\n  green: 'color: #22c55e',\n  yellow: 'color: #f59e0b; font-weight: bold',\n  cyan: 'color: #06b6d4; font-weight: bold',\n  gray: 'color: #6b7280; font-weight: bold',\n  reset: 'color: inherit; font-weight: normal',\n} as const\n\nexport function getCssLevelColor(level: string): string {\n  switch (level) {\n    case 'error':\n      return cssColors.red\n    case 'warn':\n      return cssColors.yellow\n    case 'info':\n      return cssColors.cyan\n    case 'debug':\n      return cssColors.gray\n    default:\n      return cssColors.reset\n  }\n}\n\n/**\n * Escape `%` in strings interpolated into `console.log` format strings\n * to prevent `%c`, `%s`, `%d` etc. in user data from being interpreted\n * as formatting directives.\n */\nexport function escapeFormatString(str: string): string {\n  return str.replace(/%/g, '%%')\n}\n\n/** Headers that should never be passed to hooks for security */\nexport const SENSITIVE_HEADERS = [\n  'authorization',\n  'cookie',\n  'set-cookie',\n  'x-api-key',\n  'x-auth-token',\n  'proxy-authorization',\n]\n\nexport function filterSafeHeaders(headers: Record<string, string>): Record<string, string> {\n  const safeHeaders: Record<string, string> = {}\n\n  for (const [key, value] of Object.entries(headers)) {\n    if (!SENSITIVE_HEADERS.includes(key.toLowerCase())) {\n      safeHeaders[key] = value\n    }\n  }\n\n  return safeHeaders\n}\n\n/**\n * Match a path against a glob pattern.\n * Supports * (any chars except /) and ** (any chars including /).\n */\nexport function matchesPattern(path: string, pattern: string): boolean {\n  const regexPattern = pattern\n    .replace(/[.+^${}()|[\\]\\\\]/g, '\\\\$&') // Escape special regex chars except * and ?\n    .replace(/\\*\\*/g, '{{GLOBSTAR}}') // Temp placeholder for **\n    .replace(/\\*/g, '[^/]*') // * matches anything except /\n    .replace(/{{GLOBSTAR}}/g, '.*') // ** matches anything including /\n    .replace(/\\?/g, '[^/]') // ? matches single char except /\n\n  const regex = new RegExp(`^${regexPattern}$`)\n  return regex.test(path)\n}\n"],"mappings":";AAEA,SAAgB,eAAe,IAAoB;AACjD,KAAI,KAAK,IACP,QAAO,GAAG,KAAK,MAAM,GAAG,CAAC;AAE3B,QAAO,IAAI,KAAK,KAAM,QAAQ,EAAE,CAAC;;AAGnC,SAAgB,WAAoB;AAClC,QAAO,OAAO,WAAW;;AAG3B,SAAgB,WAAoB;AAClC,QAAO,OAAO,WAAW;;AAG3B,SAAgB,QAAiB;AAC/B,KAAI,OAAO,YAAY,YACrB,QAAO,QAAQ,IAAI,aAAa;AAElC,KAAI,OAAO,WAAW,YACpB,QAAO;AAET,QAAO;;AAGT,SAAgB,oBAAiD;CAC/D,MAAM,MAAM,OAAO,YAAY,cAAc,QAAQ,MAAM,EAAE;CAC7D,MAAM,qBAAqB,OAAO,GAAG,gBAAgB;AAErD,QAAO;EACL,aAAa,IAAI,YAAY;EAC7B,SAAS,IAAI,gBAAgB;EAC7B,SAAS,IAAI;EACb,YAAY,IAAI,cACX,IAAI,cACJ,IAAI,yBACJ,IAAI;EACT,QAAQ,IAAI,iBACP,IAAI,cACJ,IAAI,cACJ,IAAI;EACV;;AAGH,SAAgB,iBAAiB,OAA2B;AAC1D,QAAO;;AAGT,MAAa,SAAS;CACpB,OAAO;CACP,MAAM;CACN,KAAK;CACL,KAAK;CACL,OAAO;CACP,QAAQ;CACR,MAAM;CACN,SAAS;CACT,MAAM;CACN,OAAO;CACP,MAAM;CACP;AAED,SAAgB,cAAc,OAAuB;AACnD,SAAQ,OAAR;EACE,KAAK,QACH,QAAO,OAAO;EAChB,KAAK,OACH,QAAO,OAAO;EAChB,KAAK,OACH,QAAO,OAAO;EAChB,KAAK,QACH,QAAO,OAAO;EAChB,QACE,QAAO,OAAO;;;AAIpB,MAAa,YAAY;CACvB,KAAK;CACL,KAAK;CACL,OAAO;CACP,QAAQ;CACR,MAAM;CACN,MAAM;CACN,OAAO;CACR;AAED,SAAgB,iBAAiB,OAAuB;AACtD,SAAQ,OAAR;EACE,KAAK,QACH,QAAO,UAAU;EACnB,KAAK,OACH,QAAO,UAAU;EACnB,KAAK,OACH,QAAO,UAAU;EACnB,KAAK,QACH,QAAO,UAAU;EACnB,QACE,QAAO,UAAU;;;;;;;;AASvB,SAAgB,mBAAmB,KAAqB;AACtD,QAAO,IAAI,QAAQ,MAAM,KAAK;;;AAIhC,MAAa,oBAAoB;CAC/B;CACA;CACA;CACA;CACA;CACA;CACD;AAED,SAAgB,kBAAkB,SAAyD;CACzF,MAAM,cAAsC,EAAE;AAE9C,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,CAChD,KAAI,CAAC,kBAAkB,SAAS,IAAI,aAAa,CAAC,CAChD,aAAY,OAAO;AAIvB,QAAO;;;;;;AAOT,SAAgB,eAAe,MAAc,SAA0B;CACrE,MAAM,eAAe,QAClB,QAAQ,qBAAqB,OAAO,CACpC,QAAQ,SAAS,eAAe,CAChC,QAAQ,OAAO,QAAQ,CACvB,QAAQ,iBAAiB,KAAK,CAC9B,QAAQ,OAAO,OAAO;AAGzB,QADc,IAAI,OAAO,IAAI,aAAa,GAAG,CAChC,KAAK,KAAK"}

package/dist/workers.d.mts

@@ -1,4 +1,4 @@
-import { g as RequestLogger, p as LoggerConfig } from "./types-CRj5tGVA.mjs";
+import { g as RequestLogger, p as LoggerConfig } from "./types-US-1hJZl.mjs";
 
 //#region src/workers/index.d.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evlog",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "description": "Wide event logging library with structured error handling. Inspired by LoggingSucks.",
   "author": "HugoRCD <contact@hrcd.fr>",
   "homepage": "https://evlog.dev",
@@ -81,6 +81,11 @@
       "import": "./dist/adapters/better-stack.mjs",
       "default": "./dist/adapters/better-stack.mjs"
     },
+    "./fs": {
+      "types": "./dist/adapters/fs.d.mts",
+      "import": "./dist/adapters/fs.mjs",
+      "default": "./dist/adapters/fs.mjs"
+    },
     "./enrichers": {
       "types": "./dist/enrichers.d.mts",
       "import": "./dist/enrichers.mjs",
@@ -135,6 +140,11 @@
       "types": "./dist/sveltekit/index.d.mts",
       "import": "./dist/sveltekit/index.mjs",
       "default": "./dist/sveltekit/index.mjs"
+    },
+    "./toolkit": {
+      "types": "./dist/toolkit.d.mts",
+      "import": "./dist/toolkit.mjs",
+      "default": "./dist/toolkit.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -171,6 +181,9 @@
       "better-stack": [
         "./dist/adapters/better-stack.d.mts"
       ],
+      "fs": [
+        "./dist/adapters/fs.d.mts"
+      ],
       "enrichers": [
         "./dist/enrichers.d.mts"
       ],
@@ -203,6 +216,9 @@
       ],
       "sveltekit": [
         "./dist/sveltekit/index.d.mts"
+      ],
+      "toolkit": [
+        "./dist/toolkit.d.mts"
       ]
     }
   },
@@ -216,14 +232,20 @@
     "dev:prepare": "tsdown",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
+    "bench": "vitest bench bench/core/ && cp bench/results.json bench/baseline/bench.json && bun bench/scripts/report.ts",
+    "bench:compare": "vitest bench bench/comparison/ && cp bench/results.json bench/baseline/comparison.json && bun bench/scripts/report.ts",
+    "bench:report": "bun bench/scripts/report.ts",
+    "size": "bun bench/scripts/size.ts",
+    "size:json": "bun bench/scripts/size.ts --json",
     "test": "vitest run",
     "test:watch": "vitest watch",
     "test:coverage": "vitest run --coverage",
     "typecheck": "echo 'Typecheck handled by build'"
   },
   "devDependencies": {
+    "@nestjs/common": "^11.1.16",
     "@nuxt/devtools": "^3.2.3",
-    "@nuxt/schema": "^4.3.1",
+    "@nuxt/schema": "^4.4.2",
     "@nuxt/test-utils": "^4.0.0",
     "@types/express": "^5.0.6",
     "@types/supertest": "^7.2.0",
@@ -231,32 +253,32 @@
     "consola": "^3.4.2",
     "elysia": "^1.4.27",
     "express": "^5.2.1",
-    "@nestjs/common": "^11.1.16",
     "fastify": "^5.8.2",
     "h3": "^1.15.6",
     "happy-dom": "^20.8.3",
-    "nitro": "^3.0.1-alpha.2",
+    "nitro": "^3.0.260311-beta",
     "nitropack": "^2.13.1",
-    "nuxt": "^4.3.1",
+    "nuxt": "^4.4.2",
+    "pino": "^10.3.1",
     "supertest": "^7.2.2",
     "tsdown": "^0.21.1",
     "typescript": "^5.9.3",
-    "ufo": "^1.6.3"
+    "ufo": "^1.6.3",
+    "winston": "^3.19.0"
   },
   "peerDependencies": {
-    "@nuxt/kit": "^4.3.1",
+    "@nuxt/kit": "^4.4.2",
     "h3": "^1.15.6",
     "nitropack": "^2.13.1",
     "ofetch": "^1.5.1",
-    "nitro": "^3.0.1-alpha.2",
+    "nitro": "^3.0.260311-beta",
     "next": ">=16.1.6",
     "react": ">=19.2.4",
     "hono": "",
     "express": ">=5.2.1",
     "elysia": ">=1.4.27",
     "fastify": ">=5.8.2",
-    "@nestjs/common": ">=11.1.16",
-    "@sveltejs/kit": ">=2.53.4"
+    "@nestjs/common": ">=11.1.16"
   },
   "peerDependenciesMeta": {
     "@nuxt/kit": {
@@ -294,9 +316,6 @@
     },
     "@nestjs/common": {
       "optional": true
-    },
-    "@sveltejs/kit": {
-      "optional": true
     }
   }
 }

package/dist/_http-DHpGetLZ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"_http-DHpGetLZ.mjs","names":[],"sources":["../src/adapters/_config.ts","../src/adapters/_drain.ts","../src/adapters/_http.ts"],"sourcesContent":["/**\n * Try to get runtime config from Nitro/Nuxt environment.\n * Returns undefined if not in a Nitro context.\n */\nexport function getRuntimeConfig(): Record<string, any> | undefined {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const { useRuntimeConfig } = require('nitropack/runtime')\n    return useRuntimeConfig()\n  } catch {\n    return undefined\n  }\n}\n\nexport interface ConfigField<T> {\n  key: keyof T & string\n  env?: string[]\n}\n\nexport function resolveAdapterConfig<T>(\n  namespace: string,\n  fields: ConfigField<T>[],\n  overrides?: Partial<T>,\n): Partial<T> {\n  const runtimeConfig = getRuntimeConfig()\n  const evlogNs = runtimeConfig?.evlog?.[namespace]\n  const rootNs = runtimeConfig?.[namespace]\n\n  const config: Record<string, unknown> = {}\n\n  for (const { key, env } of fields) {\n    config[key] =\n      overrides?.[key]\n      ?? evlogNs?.[key]\n      ?? rootNs?.[key]\n      ?? resolveEnv(env)\n  }\n\n  return config as Partial<T>\n}\n\nfunction resolveEnv(envKeys?: string[]): string | undefined {\n  if (!envKeys) return undefined\n  for (const key of envKeys) {\n    const val = process.env[key]\n    if (val) return val\n  }\n  return undefined\n}\n","import type { DrainContext, WideEvent } from '../types'\n\nexport interface DrainOptions<TConfig> {\n  name: string\n  resolve: () => TConfig | null\n  send: (events: WideEvent[], config: TConfig) => Promise<void>\n}\n\nexport function defineDrain<TConfig>(options: DrainOptions<TConfig>): (ctx: DrainContext | DrainContext[]) => Promise<void> {\n  return async (ctx: DrainContext | DrainContext[]) => {\n    const contexts = Array.isArray(ctx) ? ctx : [ctx]\n    if (contexts.length === 0) return\n\n    const config = options.resolve()\n    if (!config) return\n\n    try {\n      await options.send(contexts.map(c => c.event), config)\n    } catch (error) {\n      console.error(`[evlog/${options.name}] Failed to send events:`, error)\n    }\n  }\n}\n","export interface HttpPostOptions {\n  url: string\n  headers: Record<string, string>\n  body: string\n  timeout: number\n  label: string\n}\n\nexport async function httpPost({ url, headers, body, timeout, label }: HttpPostOptions): Promise<void> {\n  const controller = new AbortController()\n  const timeoutId = setTimeout(() => controller.abort(), timeout)\n\n  try {\n    const response = await fetch(url, {\n      method: 'POST',\n      headers,\n      body,\n      signal: controller.signal,\n    })\n\n    if (!response.ok) {\n      const text = await response.text().catch(() => 'Unknown error')\n      const safeText = text.length > 200 ? `${text.slice(0, 200)}...[truncated]` : text\n      throw new Error(`${label} API error: ${response.status} ${response.statusText} - ${safeText}`)\n    }\n  } finally {\n    clearTimeout(timeoutId)\n  }\n}\n"],"mappings":";;;;;;;;;AAIA,SAAgB,mBAAoD;AAClE,KAAI;EAEF,MAAM,EAAE,qBAAA,UAA6B,oBAAoB;AACzD,SAAO,kBAAkB;SACnB;AACN;;;AASJ,SAAgB,qBACd,WACA,QACA,WACY;CACZ,MAAM,gBAAgB,kBAAkB;CACxC,MAAM,UAAU,eAAe,QAAQ;CACvC,MAAM,SAAS,gBAAgB;CAE/B,MAAM,SAAkC,EAAE;AAE1C,MAAK,MAAM,EAAE,KAAK,SAAS,OACzB,QAAO,OACL,YAAY,QACT,UAAU,QACV,SAAS,QACT,WAAW,IAAI;AAGtB,QAAO;;AAGT,SAAS,WAAW,SAAwC;AAC1D,KAAI,CAAC,QAAS,QAAO,KAAA;AACrB,MAAK,MAAM,OAAO,SAAS;EACzB,MAAM,MAAM,QAAQ,IAAI;AACxB,MAAI,IAAK,QAAO;;;;;ACrCpB,SAAgB,YAAqB,SAAuF;AAC1H,QAAO,OAAO,QAAuC;EACnD,MAAM,WAAW,MAAM,QAAQ,IAAI,GAAG,MAAM,CAAC,IAAI;AACjD,MAAI,SAAS,WAAW,EAAG;EAE3B,MAAM,SAAS,QAAQ,SAAS;AAChC,MAAI,CAAC,OAAQ;AAEb,MAAI;AACF,SAAM,QAAQ,KAAK,SAAS,KAAI,MAAK,EAAE,MAAM,EAAE,OAAO;WAC/C,OAAO;AACd,WAAQ,MAAM,UAAU,QAAQ,KAAK,2BAA2B,MAAM;;;;;;ACX5E,eAAsB,SAAS,EAAE,KAAK,SAAS,MAAM,SAAS,SAAyC;CACrG,MAAM,aAAa,IAAI,iBAAiB;CACxC,MAAM,YAAY,iBAAiB,WAAW,OAAO,EAAE,QAAQ;AAE/D,KAAI;EACF,MAAM,WAAW,MAAM,MAAM,KAAK;GAChC,QAAQ;GACR;GACA;GACA,QAAQ,WAAW;GACpB,CAAC;AAEF,MAAI,CAAC,SAAS,IAAI;GAChB,MAAM,OAAO,MAAM,SAAS,MAAM,CAAC,YAAY,gBAAgB;GAC/D,MAAM,WAAW,KAAK,SAAS,MAAM,GAAG,KAAK,MAAM,GAAG,IAAI,CAAC,kBAAkB;AAC7E,SAAM,IAAI,MAAM,GAAG,MAAM,cAAc,SAAS,OAAO,GAAG,SAAS,WAAW,KAAK,WAAW;;WAExF;AACR,eAAa,UAAU"}

package/dist/headers-C95MOQ4w.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"headers-C95MOQ4w.mjs","names":[],"sources":["../src/shared/middleware.ts","../src/shared/headers.ts"],"sourcesContent":["import type { DrainContext, EnrichContext, RequestLogger, RouteConfig, TailSamplingContext, WideEvent } from '../types'\nimport { createRequestLogger, isEnabled, shouldKeep } from '../logger'\nimport { extractErrorStatus } from '../nitro'\nimport { shouldLog, getServiceForPath } from './routes'\n\n/**\n * Base options shared by all framework integrations.\n *\n * Every framework-specific options interface (e.g. `EvlogExpressOptions`)\n * extends this type. If a framework needs extra fields it can add them\n * on top; otherwise the base is used as-is.\n */\nexport interface BaseEvlogOptions {\n  /** Route patterns to include in logging (glob). If not set, all routes are logged */\n  include?: string[]\n  /** Route patterns to exclude from logging. Exclusions take precedence over inclusions */\n  exclude?: string[]\n  /** Route-specific service configuration */\n  routes?: Record<string, RouteConfig>\n  /**\n   * Drain callback called with every emitted event.\n   * Use with drain adapters (Axiom, OTLP, Sentry, etc.) or custom endpoints.\n   */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /**\n   * Enrich callback called after emit, before drain.\n   * Use to add derived context (geo, deployment info, user agent, etc.).\n   */\n  enrich?: (ctx: EnrichContext) => void | Promise<void>\n  /**\n   * Custom tail sampling callback.\n   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.\n   */\n  keep?: (ctx: TailSamplingContext) => void | Promise<void>\n}\n\n/**\n * Internal options consumed by `createMiddlewareLogger`.\n * Extends `BaseEvlogOptions` with the request-specific fields\n * that framework adapters must provide.\n */\nexport interface MiddlewareLoggerOptions extends BaseEvlogOptions {\n  method: string\n  path: string\n  requestId?: string\n  /** Pre-filtered safe request headers (used for enrich/drain context) */\n  headers?: Record<string, string>\n}\n\nexport interface MiddlewareLoggerResult {\n  logger: RequestLogger\n  finish: (opts?: { status?: number; error?: Error }) => Promise<WideEvent | null>\n  skipped: boolean\n}\n\nconst noopResult: MiddlewareLoggerResult = {\n  logger: {\n    set() {},\n    error() {},\n    info() {},\n    warn() {},\n    emit() {\n      return null \n    },\n    getContext() {\n      return {} \n    },\n  },\n  finish: () => Promise.resolve(null),\n  skipped: true,\n}\n\nasync function runEnrichAndDrain(\n  emittedEvent: WideEvent,\n  options: MiddlewareLoggerOptions,\n  requestInfo: { method: string; path: string; requestId?: string },\n  responseStatus?: number,\n): Promise<void> {\n  if (options.enrich) {\n    const enrichCtx: EnrichContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n      response: { status: responseStatus },\n    }\n    try {\n      await options.enrich(enrichCtx)\n    } catch (err) {\n      console.error('[evlog] enrich failed:', err)\n    }\n  }\n\n  if (options.drain) {\n    const drainCtx: DrainContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n    }\n    try {\n      await options.drain(drainCtx)\n    } catch (err) {\n      console.error('[evlog] drain failed:', err)\n    }\n  }\n}\n\n/**\n * Create a middleware-aware request logger with full lifecycle management.\n *\n * Handles the complete pipeline shared across all framework integrations:\n * route filtering, logger creation, service overrides, duration tracking,\n * tail sampling evaluation, event emission, enrichment, and draining.\n *\n * Framework adapters only need to:\n * 1. Extract method/path/requestId/headers from the framework request\n * 2. Call `createMiddlewareLogger()` with those + user options\n * 3. Check `skipped` — if true, skip to next middleware\n * 4. Store `logger` in framework-specific context (e.g., `c.set('log', logger)`)\n * 5. Call `finish({ status })` or `finish({ error })` at response end\n */\nexport function createMiddlewareLogger(options: MiddlewareLoggerOptions): MiddlewareLoggerResult {\n  if (!isEnabled()) return noopResult\n\n  const { method, path, requestId, include, exclude, routes, keep } = options\n\n  if (!shouldLog(path, include, exclude)) {\n    return noopResult\n  }\n\n  const resolvedRequestId = requestId || crypto.randomUUID()\n\n  const logger = createRequestLogger({\n    method,\n    path,\n    requestId: resolvedRequestId,\n  })\n\n  const routeService = getServiceForPath(path, routes)\n  if (routeService) {\n    logger.set({ service: routeService })\n  }\n\n  const startTime = Date.now()\n  const requestInfo = { method, path, requestId: resolvedRequestId }\n\n  const finish = async (opts?: { status?: number; error?: Error }): Promise<WideEvent | null> => {\n    const { status, error } = opts ?? {}\n\n    if (error) {\n      logger.error(error)\n      const errorStatus = extractErrorStatus(error)\n      logger.set({ status: errorStatus })\n    } else if (status !== undefined) {\n      logger.set({ status })\n    }\n\n    const durationMs = Date.now() - startTime\n\n    const resolvedStatus = error\n      ? extractErrorStatus(error)\n      : status ?? (logger.getContext().status as number | undefined)\n\n    const tailCtx: TailSamplingContext = {\n      status: resolvedStatus,\n      duration: durationMs,\n      path,\n      method,\n      context: logger.getContext(),\n      shouldKeep: false,\n    }\n\n    if (keep) {\n      await keep(tailCtx)\n    }\n\n    const forceKeep = tailCtx.shouldKeep || shouldKeep(tailCtx)\n    const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n\n    if (emittedEvent && (options.enrich || options.drain)) {\n      await runEnrichAndDrain(emittedEvent, options, requestInfo, resolvedStatus)\n    }\n\n    return emittedEvent\n  }\n\n  return { logger, finish, skipped: false }\n}\n","import { filterSafeHeaders } from '../utils'\n\n/**\n * Extract headers from a Web API `Headers` object and filter out sensitive ones.\n * Works with any runtime that supports the standard `Headers` API (Hono, Elysia,\n * Nitro v3, Cloudflare Workers, Bun, Deno, etc.).\n */\nexport function extractSafeHeaders(headers: Headers): Record<string, string> {\n  const raw: Record<string, string> = {}\n  headers.forEach((value, key) => {\n    raw[key] = value\n  })\n  return filterSafeHeaders(raw)\n}\n\n/**\n * Extract headers from Node.js `IncomingHttpHeaders` and filter out sensitive ones.\n * Works with Express, Fastify, and any Node.js HTTP server using `req.headers`.\n */\nexport function extractSafeNodeHeaders(headers: Record<string, string | string[] | undefined>): Record<string, string> {\n  const raw: Record<string, string> = {}\n  for (const [key, value] of Object.entries(headers)) {\n    if (value === undefined) continue\n    raw[key] = Array.isArray(value) ? value.join(', ') : value\n  }\n  return filterSafeHeaders(raw)\n}\n"],"mappings":";;;;;AAuDA,MAAM,aAAqC;CACzC,QAAQ;EACN,MAAM;EACN,QAAQ;EACR,OAAO;EACP,OAAO;EACP,OAAO;AACL,UAAO;;EAET,aAAa;AACX,UAAO,EAAE;;EAEZ;CACD,cAAc,QAAQ,QAAQ,KAAK;CACnC,SAAS;CACV;AAED,eAAe,kBACb,cACA,SACA,aACA,gBACe;AACf,KAAI,QAAQ,QAAQ;EAClB,MAAM,YAA2B;GAC/B,OAAO;GACP,SAAS;GACT,SAAS,QAAQ;GACjB,UAAU,EAAE,QAAQ,gBAAgB;GACrC;AACD,MAAI;AACF,SAAM,QAAQ,OAAO,UAAU;WACxB,KAAK;AACZ,WAAQ,MAAM,0BAA0B,IAAI;;;AAIhD,KAAI,QAAQ,OAAO;EACjB,MAAM,WAAyB;GAC7B,OAAO;GACP,SAAS;GACT,SAAS,QAAQ;GAClB;AACD,MAAI;AACF,SAAM,QAAQ,MAAM,SAAS;WACtB,KAAK;AACZ,WAAQ,MAAM,yBAAyB,IAAI;;;;;;;;;;;;;;;;;;AAmBjD,SAAgB,uBAAuB,SAA0D;AAC/F,KAAI,CAAC,WAAW,CAAE,QAAO;CAEzB,MAAM,EAAE,QAAQ,MAAM,WAAW,SAAS,SAAS,QAAQ,SAAS;AAEpE,KAAI,CAAC,UAAU,MAAM,SAAS,QAAQ,CACpC,QAAO;CAGT,MAAM,oBAAoB,aAAa,OAAO,YAAY;CAE1D,MAAM,SAAS,oBAAoB;EACjC;EACA;EACA,WAAW;EACZ,CAAC;CAEF,MAAM,eAAe,kBAAkB,MAAM,OAAO;AACpD,KAAI,aACF,QAAO,IAAI,EAAE,SAAS,cAAc,CAAC;CAGvC,MAAM,YAAY,KAAK,KAAK;CAC5B,MAAM,cAAc;EAAE;EAAQ;EAAM,WAAW;EAAmB;CAElE,MAAM,SAAS,OAAO,SAAyE;EAC7F,MAAM,EAAE,QAAQ,UAAU,QAAQ,EAAE;AAEpC,MAAI,OAAO;AACT,UAAO,MAAM,MAAM;GACnB,MAAM,cAAc,mBAAmB,MAAM;AAC7C,UAAO,IAAI,EAAE,QAAQ,aAAa,CAAC;aAC1B,WAAW,KAAA,EACpB,QAAO,IAAI,EAAE,QAAQ,CAAC;EAGxB,MAAM,aAAa,KAAK,KAAK,GAAG;EAEhC,MAAM,iBAAiB,QACnB,mBAAmB,MAAM,GACzB,UAAW,OAAO,YAAY,CAAC;EAEnC,MAAM,UAA+B;GACnC,QAAQ;GACR,UAAU;GACV;GACA;GACA,SAAS,OAAO,YAAY;GAC5B,YAAY;GACb;AAED,MAAI,KACF,OAAM,KAAK,QAAQ;EAGrB,MAAM,YAAY,QAAQ,cAAc,WAAW,QAAQ;EAC3D,MAAM,eAAe,OAAO,KAAK,EAAE,YAAY,WAAW,CAAC;AAE3D,MAAI,iBAAiB,QAAQ,UAAU,QAAQ,OAC7C,OAAM,kBAAkB,cAAc,SAAS,aAAa,eAAe;AAG7E,SAAO;;AAGT,QAAO;EAAE;EAAQ;EAAQ,SAAS;EAAO;;;;;;;;;AClL3C,SAAgB,mBAAmB,SAA0C;CAC3E,MAAM,MAA8B,EAAE;AACtC,SAAQ,SAAS,OAAO,QAAQ;AAC9B,MAAI,OAAO;GACX;AACF,QAAO,kBAAkB,IAAI;;;;;;AAO/B,SAAgB,uBAAuB,SAAgF;CACrH,MAAM,MAA8B,EAAE;AACtC,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,EAAE;AAClD,MAAI,UAAU,KAAA,EAAW;AACzB,MAAI,OAAO,MAAM,QAAQ,MAAM,GAAG,MAAM,KAAK,KAAK,GAAG;;AAEvD,QAAO,kBAAkB,IAAI"}

package/dist/logger-BNxG5Kyd.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger-BNxG5Kyd.d.mts","names":[],"sources":["../src/logger.ts"],"mappings":";;;;;AAoCA;;iBAAgB,UAAA,CAAW,MAAA,GAAQ,YAAA;;;AAqBnC;iBAAgB,SAAA,CAAA;;;;AA8BhB;iBAAgB,UAAA,CAAW,GAAA,EAAK,mBAAA;;;;AAgB/B;;;;;AAkKD;cAjCM,IAAA,EAAM,GAAA;;;;;;;;;;;;iBAiCI,YAAA,oBAAgC,MAAA,kBAAA,CAAyB,cAAA,GAAgB,MAAA,oBAA+B,aAAA,CAAc,CAAA;;;AAsHtI;;;;;;;;;;iBAAgB,mBAAA,oBAAuC,MAAA,kBAAA,CAAyB,OAAA,GAAS,oBAAA,GAA4B,aAAA,CAAc,CAAA;;;;iBAWnH,cAAA,CAAA,GAAkB,kBAAA"}

package/dist/middleware-gCuB0w7F.d.mts

@@ -1,36 +0,0 @@
-import { C as TailSamplingContext, i as EnrichContext, r as DrainContext, v as RouteConfig } from "./types-CRj5tGVA.mjs";
-
-//#region src/shared/middleware.d.ts
-/**
- * Base options shared by all framework integrations.
- *
- * Every framework-specific options interface (e.g. `EvlogExpressOptions`)
- * extends this type. If a framework needs extra fields it can add them
- * on top; otherwise the base is used as-is.
- */
-interface BaseEvlogOptions {
-  /** Route patterns to include in logging (glob). If not set, all routes are logged */
-  include?: string[];
-  /** Route patterns to exclude from logging. Exclusions take precedence over inclusions */
-  exclude?: string[];
-  /** Route-specific service configuration */
-  routes?: Record<string, RouteConfig>;
-  /**
-   * Drain callback called with every emitted event.
-   * Use with drain adapters (Axiom, OTLP, Sentry, etc.) or custom endpoints.
-   */
-  drain?: (ctx: DrainContext) => void | Promise<void>;
-  /**
-   * Enrich callback called after emit, before drain.
-   * Use to add derived context (geo, deployment info, user agent, etc.).
-   */
-  enrich?: (ctx: EnrichContext) => void | Promise<void>;
-  /**
-   * Custom tail sampling callback.
-   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.
-   */
-  keep?: (ctx: TailSamplingContext) => void | Promise<void>;
-}
-//#endregion
-export { BaseEvlogOptions as t };
-//# sourceMappingURL=middleware-gCuB0w7F.d.mts.map

package/dist/middleware-gCuB0w7F.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"middleware-gCuB0w7F.d.mts","names":[],"sources":["../src/shared/middleware.ts"],"mappings":";;;;;AAYA;;;;;UAAiB,gBAAA;EAWuB;EATtC,OAAA;EAcwC;EAZxC,OAAA;EAiB4C;EAf5C,MAAA,GAAS,MAAA,SAAe,WAAA;EAe2B;;;;EAVnD,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EALd;;;;EAUxB,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EAAxC;;;;EAKA,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;AAAA"}

package/dist/nitro-B3vZrLGI.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"nitro-B3vZrLGI.mjs","names":[],"sources":["../src/nitro.ts"],"sourcesContent":["import type { EnvironmentContext, RouteConfig, SamplingConfig } from './types'\n\nexport { shouldLog, getServiceForPath } from './shared/routes'\n\nexport interface NitroModuleOptions {\n  /**\n   * Enable or disable all logging globally.\n   * @default true\n   */\n  enabled?: boolean\n\n  /**\n   * Environment context overrides.\n   */\n  env?: Partial<EnvironmentContext>\n\n  /**\n   * Enable pretty printing.\n   * @default true in development, false in production\n   */\n  pretty?: boolean\n\n  /**\n   * Route patterns to include in logging.\n   * Supports glob patterns like '/api/**'.\n   * If not set, all routes are logged.\n   */\n  include?: string[]\n\n  /**\n   * Route patterns to exclude from logging.\n   * Supports glob patterns like '/_nitro/**'.\n   * Exclusions take precedence over inclusions.\n   */\n  exclude?: string[]\n\n  /**\n   * Route-specific service configuration.\n   */\n  routes?: Record<string, RouteConfig>\n\n  /**\n   * Sampling configuration for filtering logs.\n   */\n  sampling?: SamplingConfig\n}\n\nexport interface EvlogConfig {\n  enabled?: boolean\n  env?: Record<string, unknown>\n  pretty?: boolean\n  include?: string[]\n  exclude?: string[]\n  routes?: Record<string, RouteConfig>\n  sampling?: SamplingConfig\n}\n\n/**\n * Resolve an EvlogError from an error or its cause chain.\n * Both Nitro v2 (h3) and v3 wrap thrown errors — this unwraps them.\n */\nexport function resolveEvlogError(error: Error): Error | null {\n  if (error.name === 'EvlogError') return error\n  if ((error.cause as Error)?.name === 'EvlogError') return error.cause as Error\n  return null\n}\n\n/**\n * Extract HTTP status from an error, checking both `status` and `statusCode`.\n */\nexport function extractErrorStatus(error: unknown): number {\n  return (error as { status?: number }).status\n    ?? (error as { statusCode?: number }).statusCode\n    ?? 500\n}\n\n/**\n * Build a standard evlog error JSON response body.\n * Used by both v2 and v3 error handlers to ensure consistent shape.\n */\nexport function serializeEvlogErrorResponse(error: Error, url: string): Record<string, unknown> {\n  const status = extractErrorStatus(error)\n  const { data } = error as { data?: unknown }\n  const statusMessage = (error as { statusMessage?: string }).statusMessage || error.message\n  return {\n    url,\n    status,\n    statusCode: status,\n    statusText: statusMessage,\n    statusMessage,\n    message: error.message,\n    error: true,\n    ...(data !== undefined && { data }),\n  }\n}\n\n"],"mappings":";;;;;AA6DA,SAAgB,kBAAkB,OAA4B;AAC5D,KAAI,MAAM,SAAS,aAAc,QAAO;AACxC,KAAK,MAAM,OAAiB,SAAS,aAAc,QAAO,MAAM;AAChE,QAAO;;;;;AAMT,SAAgB,mBAAmB,OAAwB;AACzD,QAAQ,MAA8B,UAChC,MAAkC,cACnC;;;;;;AAOP,SAAgB,4BAA4B,OAAc,KAAsC;CAC9F,MAAM,SAAS,mBAAmB,MAAM;CACxC,MAAM,EAAE,SAAS;CACjB,MAAM,gBAAiB,MAAqC,iBAAiB,MAAM;AACnF,QAAO;EACL;EACA;EACA,YAAY;EACZ,YAAY;EACZ;EACA,SAAS,MAAM;EACf,OAAO;EACP,GAAI,SAAS,KAAA,KAAa,EAAE,MAAM;EACnC"}

package/dist/nitro-wZ05H2wx.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nitro-wZ05H2wx.d.mts","names":[],"sources":["../src/nitro.ts"],"mappings":";;;UAIiB,kBAAA;EAAA;;;;EAKf,OAAA;EA8BwB;;;EAzBxB,GAAA,GAAM,OAAA,CAAQ,kBAAA;EA8BW;;;;EAxBzB,MAAA;EAAA;;;;;EAOA,OAAA;EAiBA;;;;;EAVA,OAAA;;;;EAKA,MAAA,GAAS,MAAA,SAAe,WAAA;;;;EAKxB,QAAA,GAAW,cAAA;AAAA"}

package/dist/parseError-BeVEVQBh.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseError-BeVEVQBh.d.mts","names":[],"sources":["../src/runtime/utils/parseError.ts"],"mappings":";;;iBAKgB,UAAA,CAAW,KAAA,YAAiB,WAAA"}

package/dist/storage-CRSAAEiG.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage-CRSAAEiG.mjs","names":[],"sources":["../src/shared/storage.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\n\n/**\n * Create a request-scoped `AsyncLocalStorage` and a matching `useLogger` accessor.\n *\n * Every framework that needs `useLogger()` (Express, Fastify, NestJS, SvelteKit)\n * calls this once at module level to get its own isolated storage + accessor pair.\n *\n * @param contextHint - Human-readable hint appended to the error message when\n *   `useLogger()` is called outside of a request (e.g.\n *   `\"middleware context. Make sure app.use(evlog()) is registered before your routes.\"`).\n */\nexport function createLoggerStorage(contextHint: string) {\n  const storage = new AsyncLocalStorage<RequestLogger>()\n\n  /**\n   * Access the request-scoped logger created by the evlog middleware.\n   *\n   * Must be called inside a request that is handled by the evlog middleware.\n   * Throws if called outside of a request context.\n   *\n   * @example\n   * ```ts\n   * import { useLogger } from 'evlog/express' // or /fastify, /nestjs, /sveltekit, /elysia\n   *\n   * function myService() {\n   *   const log = useLogger()\n   *   log.set({ users: { count: 42 } })\n   * }\n   * ```\n   */\n  function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n    const logger = storage.getStore()\n    if (!logger) {\n      throw new Error(\n        `[evlog] useLogger() was called outside of an evlog ${contextHint}`,\n      )\n    }\n    return logger as RequestLogger<T>\n  }\n\n  return { storage, useLogger }\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,oBAAoB,aAAqB;CACvD,MAAM,UAAU,IAAI,mBAAkC;;;;;;;;;;;;;;;;;CAkBtD,SAAS,YAA0E;EACjF,MAAM,SAAS,QAAQ,UAAU;AACjC,MAAI,CAAC,OACH,OAAM,IAAI,MACR,sDAAsD,cACvD;AAEH,SAAO;;AAGT,QAAO;EAAE;EAAS;EAAW"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"types-CRj5tGVA.d.mts","names":[],"sources":["../src/types.ts"],"mappings":"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"}