evlog 2.19.1 → 2.19.2

package/dist/nestjs/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/nestjs/index.ts"],"mappings":";;;;;cAUiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,kBAAA,GAAqB,gBAAA;AAAA,UAIhB,uBAAA;EANhB;EAQC,OAAA;EAVwB;EAYxB,UAAA,MAAgB,IAAA,YAAgB,kBAAA,GAAqB,OAAA,CAAQ,kBAAA;EAZrC;EAcxB,MAAA;AAAA;AAAA;EAAA,UAIU,eAAA;IACR,GAAA,GAAM,aAAA;EAAA;AAAA;AAAA;EAAA,UAKE,OAAA;IACR,GAAA,GAAM,aAAA;EAAA;AAAA;AAjBV;;;;;;;;;;;;;;;;;AAOC;;;;;;;AAPD,cA0Ea,WAAA,YAAuB,UAAA;EAAA,eAEnB,OAAA;EAjEM;AAAA;;;;;;;;;;EAAA,OA8Ed,OAAA,CAAQ,OAAA,GAAS,kBAAA,GAA0B,aAAA;EAf3B;;;;;;;;;;;;;;EAAA,OAqChB,YAAA,CAAa,YAAA,EAAc,uBAAA,GAA0B,aAAA;EAkB5D,SAAA,CAAU,QAAA,EAAU,kBAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/nestjs/index.ts"],"mappings":";;;;;cAUiB,SAAA,sBAAS,MAAA,wBAAA,eAAA,CAAA,CAAA;AAAA,KAId,kBAAA,GAAqB,gBAAA;AAAA,UAIhB,uBAAA;EANhB;EAQC,OAAA;EAVwB;EAYxB,UAAA,MAAgB,IAAA,YAAgB,kBAAA,GAAqB,OAAA,CAAQ,kBAAA;EAZrC;EAcxB,MAAA;AAAA;AAAA;EAAA,UAIU,eAAA;IACR,GAAA,GAAM,eAAA;EAAA;AAAA;AAAA;EAAA,UAKE,OAAA;IACR,GAAA,GAAM,eAAA;EAAA;AAAA;AAjBV;;;;;;;;;;;;;;;;;AAOC;;;;;;;AAPD,cA0Ea,WAAA,YAAuB,UAAA;EAAA,eAEnB,OAAA;EAjEQ;AAAA;;;;;;;;;;EAAA,OA8EhB,OAAA,CAAQ,OAAA,GAAS,kBAAA,GAA0B,aAAA;EAf3B;;;;;;;;;;;;;;EAAA,OAqChB,YAAA,CAAa,YAAA,EAAc,uBAAA,GAA0B,aAAA;EAkB5D,SAAA,CAAU,QAAA,EAAU,kBAAA;AAAA"}

package/dist/nestjs/index.mjs

@@ -1,7 +1,7 @@
 import { n as extractSafeNodeHeaders } from "../headers-VtmnWcfn.mjs";
-import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-CgGlAaHa.mjs";
-import { t as bindNodeResponseLifecycle } from "../nodeResponse-CIEEbrNE.mjs";
-import { t as createLoggerStorage } from "../storage-7X37OToT.mjs";
+import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-Di44utlp.mjs";
+import { t as bindNodeResponseLifecycle } from "../nodeResponse-DKrYWrxk.mjs";
+import { t as createLoggerStorage } from "../storage-D4sBVffQ.mjs";
 //#region src/nestjs/index.ts
 const { storage, useLogger } = createLoggerStorage("middleware context. Make sure EvlogModule.forRoot() is imported in your AppModule.");
 function createEvlogMiddleware(getOptions) {

package/dist/nestjs/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/nestjs/index.ts"],"sourcesContent":["import type { ServerResponse } from 'node:http'\nimport type { Request } from 'express'\nimport type { DynamicModule, MiddlewareConsumer, NestModule } from '@nestjs/common'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeNodeHeaders } from '../shared/headers'\nimport { bindNodeResponseLifecycle } from '../shared/nodeResponse'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'middleware context. Make sure EvlogModule.forRoot() is imported in your AppModule.',\n)\n\nexport type EvlogNestJSOptions = BaseEvlogOptions\n\nexport { useLogger }\n\nexport interface EvlogModuleAsyncOptions {\n  /** Modules to import (for dependency injection into the factory) */\n  imports?: any[]\n  /** Factory function that returns evlog options. Can be async. */\n  useFactory: (...args: any[]) => EvlogNestJSOptions | Promise<EvlogNestJSOptions>\n  /** Injection tokens to resolve and pass to the factory */\n  inject?: any[]\n}\n\ndeclare module 'http' {\n  interface IncomingMessage {\n    log?: RequestLogger\n  }\n}\n\ndeclare module 'express-serve-static-core' {\n  interface Request {\n    log?: RequestLogger\n  }\n}\n\nfunction createEvlogMiddleware(getOptions: () => EvlogNestJSOptions) {\n  return (req: Request, res: ServerResponse, next: () => void) => {\n    const options = getOptions()\n    const headers = extractSafeNodeHeaders(req.headers)\n    const url = new URL(req.originalUrl || req.url || '/', 'http://localhost')\n\n    const middlewareOpts = {\n      method: req.method || 'GET',\n      path: url.pathname,\n      requestId: headers['x-request-id'] || crypto.randomUUID(),\n      headers,\n      ...options,\n    }\n    const { logger, finish, skipped } = createMiddlewareLogger(middlewareOpts)\n\n    if (skipped) {\n      next()\n      return\n    }\n\n    attachForkToLogger(storage, logger, middlewareOpts)\n    req.log = logger\n\n    bindNodeResponseLifecycle(res, logger, finish)\n\n    storage.run(logger, () => next())\n  }\n}\n\n/**\n * NestJS module for evlog wide event logging.\n *\n * Registers a global middleware that creates a request-scoped logger\n * for every incoming request. Use `useLogger()` to access it anywhere\n * in the call stack, or `req.log` directly in controllers.\n *\n * @example\n * ```ts\n * import { Module } from '@nestjs/common'\n * import { EvlogModule } from 'evlog/nestjs'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * @Module({\n *   imports: [\n *     EvlogModule.forRoot({\n *       drain: createAxiomDrain(),\n *       exclude: ['/health'],\n *     }),\n *   ],\n * })\n * export class AppModule {}\n * ```\n */\nexport class EvlogModule implements NestModule {\n\n  private static options: EvlogNestJSOptions = {}\n\n  /**\n   * Register evlog with static configuration.\n   *\n   * @example\n   * ```ts\n   * EvlogModule.forRoot({\n   *   drain: createAxiomDrain(),\n   *   enrich: (ctx) => { ctx.event.region = process.env.FLY_REGION },\n   * })\n   * ```\n   */\n  static forRoot(options: EvlogNestJSOptions = {}): DynamicModule {\n    EvlogModule.options = options\n    return {\n      module: EvlogModule,\n      global: true,\n    }\n  }\n\n  /**\n   * Register evlog with async configuration (e.g. from `ConfigService`).\n   *\n   * @example\n   * ```ts\n   * EvlogModule.forRootAsync({\n   *   imports: [ConfigModule],\n   *   inject: [ConfigService],\n   *   useFactory: (config: ConfigService) => ({\n   *     drain: createAxiomDrain({ token: config.get('AXIOM_TOKEN') }),\n   *   }),\n   * })\n   * ```\n   */\n  static forRootAsync(asyncOptions: EvlogModuleAsyncOptions): DynamicModule {\n    return {\n      module: EvlogModule,\n      imports: asyncOptions.imports || [],\n      providers: [\n        {\n          provide: 'EVLOG_OPTIONS',\n          useFactory: async (...args: any[]) => {\n            EvlogModule.options = await asyncOptions.useFactory(...args)\n            return EvlogModule.options\n          },\n          inject: asyncOptions.inject || [],\n        },\n      ],\n      global: true,\n    }\n  }\n\n  configure(consumer: MiddlewareConsumer): void {\n    consumer\n      .apply(createEvlogMiddleware(() => EvlogModule.options))\n      .forRoutes('*')\n  }\n\n}\n"],"mappings":";;;;;AAUA,MAAM,EAAE,SAAS,cAAc,oBAC7B,qFACD;AA2BD,SAAS,sBAAsB,YAAsC;AACnE,SAAQ,KAAc,KAAqB,SAAqB;EAC9D,MAAM,UAAU,YAAY;EAC5B,MAAM,UAAU,uBAAuB,IAAI,QAAQ;EACnD,MAAM,MAAM,IAAI,IAAI,IAAI,eAAe,IAAI,OAAO,KAAK,mBAAmB;EAE1E,MAAM,iBAAiB;GACrB,QAAQ,IAAI,UAAU;GACtB,MAAM,IAAI;GACV,WAAW,QAAQ,mBAAmB,OAAO,YAAY;GACzD;GACA,GAAG;GACJ;EACD,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB,eAAe;AAE1E,MAAI,SAAS;AACX,SAAM;AACN;;AAGF,qBAAmB,SAAS,QAAQ,eAAe;AACnD,MAAI,MAAM;AAEV,4BAA0B,KAAK,QAAQ,OAAO;AAE9C,UAAQ,IAAI,cAAc,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BrC,IAAa,cAAb,MAAa,YAAkC;CAE7C,OAAe,UAA8B,EAAE;;;;;;;;;;;;CAa/C,OAAO,QAAQ,UAA8B,EAAE,EAAiB;AAC9D,cAAY,UAAU;AACtB,SAAO;GACL,QAAQ;GACR,QAAQ;GACT;;;;;;;;;;;;;;;;CAiBH,OAAO,aAAa,cAAsD;AACxE,SAAO;GACL,QAAQ;GACR,SAAS,aAAa,WAAW,EAAE;GACnC,WAAW,CACT;IACE,SAAS;IACT,YAAY,OAAO,GAAG,SAAgB;AACpC,iBAAY,UAAU,MAAM,aAAa,WAAW,GAAG,KAAK;AAC5D,YAAO,YAAY;;IAErB,QAAQ,aAAa,UAAU,EAAE;IAClC,CACF;GACD,QAAQ;GACT;;CAGH,UAAU,UAAoC;AAC5C,WACG,MAAM,4BAA4B,YAAY,QAAQ,CAAC,CACvD,UAAU,IAAI"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/nestjs/index.ts"],"sourcesContent":["import type { ServerResponse } from 'node:http'\nimport type { Request } from 'express'\nimport type { DynamicModule, MiddlewareConsumer, NestModule } from '@nestjs/common'\nimport type { AuditableLogger } from '../audit'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeNodeHeaders } from '../shared/headers'\nimport { bindNodeResponseLifecycle } from '../shared/nodeResponse'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'middleware context. Make sure EvlogModule.forRoot() is imported in your AppModule.',\n)\n\nexport type EvlogNestJSOptions = BaseEvlogOptions\n\nexport { useLogger }\n\nexport interface EvlogModuleAsyncOptions {\n  /** Modules to import (for dependency injection into the factory) */\n  imports?: any[]\n  /** Factory function that returns evlog options. Can be async. */\n  useFactory: (...args: any[]) => EvlogNestJSOptions | Promise<EvlogNestJSOptions>\n  /** Injection tokens to resolve and pass to the factory */\n  inject?: any[]\n}\n\ndeclare module 'http' {\n  interface IncomingMessage {\n    log?: AuditableLogger\n  }\n}\n\ndeclare module 'express-serve-static-core' {\n  interface Request {\n    log?: AuditableLogger\n  }\n}\n\nfunction createEvlogMiddleware(getOptions: () => EvlogNestJSOptions) {\n  return (req: Request, res: ServerResponse, next: () => void) => {\n    const options = getOptions()\n    const headers = extractSafeNodeHeaders(req.headers)\n    const url = new URL(req.originalUrl || req.url || '/', 'http://localhost')\n\n    const middlewareOpts = {\n      method: req.method || 'GET',\n      path: url.pathname,\n      requestId: headers['x-request-id'] || crypto.randomUUID(),\n      headers,\n      ...options,\n    }\n    const { logger, finish, skipped } = createMiddlewareLogger(middlewareOpts)\n\n    if (skipped) {\n      next()\n      return\n    }\n\n    attachForkToLogger(storage, logger, middlewareOpts)\n    req.log = logger\n\n    bindNodeResponseLifecycle(res, logger, finish)\n\n    storage.run(logger, () => next())\n  }\n}\n\n/**\n * NestJS module for evlog wide event logging.\n *\n * Registers a global middleware that creates a request-scoped logger\n * for every incoming request. Use `useLogger()` to access it anywhere\n * in the call stack, or `req.log` directly in controllers.\n *\n * @example\n * ```ts\n * import { Module } from '@nestjs/common'\n * import { EvlogModule } from 'evlog/nestjs'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * @Module({\n *   imports: [\n *     EvlogModule.forRoot({\n *       drain: createAxiomDrain(),\n *       exclude: ['/health'],\n *     }),\n *   ],\n * })\n * export class AppModule {}\n * ```\n */\nexport class EvlogModule implements NestModule {\n\n  private static options: EvlogNestJSOptions = {}\n\n  /**\n   * Register evlog with static configuration.\n   *\n   * @example\n   * ```ts\n   * EvlogModule.forRoot({\n   *   drain: createAxiomDrain(),\n   *   enrich: (ctx) => { ctx.event.region = process.env.FLY_REGION },\n   * })\n   * ```\n   */\n  static forRoot(options: EvlogNestJSOptions = {}): DynamicModule {\n    EvlogModule.options = options\n    return {\n      module: EvlogModule,\n      global: true,\n    }\n  }\n\n  /**\n   * Register evlog with async configuration (e.g. from `ConfigService`).\n   *\n   * @example\n   * ```ts\n   * EvlogModule.forRootAsync({\n   *   imports: [ConfigModule],\n   *   inject: [ConfigService],\n   *   useFactory: (config: ConfigService) => ({\n   *     drain: createAxiomDrain({ token: config.get('AXIOM_TOKEN') }),\n   *   }),\n   * })\n   * ```\n   */\n  static forRootAsync(asyncOptions: EvlogModuleAsyncOptions): DynamicModule {\n    return {\n      module: EvlogModule,\n      imports: asyncOptions.imports || [],\n      providers: [\n        {\n          provide: 'EVLOG_OPTIONS',\n          useFactory: async (...args: any[]) => {\n            EvlogModule.options = await asyncOptions.useFactory(...args)\n            return EvlogModule.options\n          },\n          inject: asyncOptions.inject || [],\n        },\n      ],\n      global: true,\n    }\n  }\n\n  configure(consumer: MiddlewareConsumer): void {\n    consumer\n      .apply(createEvlogMiddleware(() => EvlogModule.options))\n      .forRoutes('*')\n  }\n\n}\n"],"mappings":";;;;;AAUA,MAAM,EAAE,SAAS,cAAc,oBAC7B,qFACD;AA2BD,SAAS,sBAAsB,YAAsC;AACnE,SAAQ,KAAc,KAAqB,SAAqB;EAC9D,MAAM,UAAU,YAAY;EAC5B,MAAM,UAAU,uBAAuB,IAAI,QAAQ;EACnD,MAAM,MAAM,IAAI,IAAI,IAAI,eAAe,IAAI,OAAO,KAAK,mBAAmB;EAE1E,MAAM,iBAAiB;GACrB,QAAQ,IAAI,UAAU;GACtB,MAAM,IAAI;GACV,WAAW,QAAQ,mBAAmB,OAAO,YAAY;GACzD;GACA,GAAG;GACJ;EACD,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB,eAAe;AAE1E,MAAI,SAAS;AACX,SAAM;AACN;;AAGF,qBAAmB,SAAS,QAAQ,eAAe;AACnD,MAAI,MAAM;AAEV,4BAA0B,KAAK,QAAQ,OAAO;AAE9C,UAAQ,IAAI,cAAc,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BrC,IAAa,cAAb,MAAa,YAAkC;CAE7C,OAAe,UAA8B,EAAE;;;;;;;;;;;;CAa/C,OAAO,QAAQ,UAA8B,EAAE,EAAiB;AAC9D,cAAY,UAAU;AACtB,SAAO;GACL,QAAQ;GACR,QAAQ;GACT;;;;;;;;;;;;;;;;CAiBH,OAAO,aAAa,cAAsD;AACxE,SAAO;GACL,QAAQ;GACR,SAAS,aAAa,WAAW,EAAE;GACnC,WAAW,CACT;IACE,SAAS;IACT,YAAY,OAAO,GAAG,SAAgB;AACpC,iBAAY,UAAU,MAAM,aAAa,WAAW,GAAG,KAAK;AAC5D,YAAO,YAAY;;IAErB,QAAQ,aAAa,UAAU,EAAE;IAClC,CACF;GACD,QAAQ;GACT;;CAGH,UAAU,UAAoC;AAC5C,WACG,MAAM,4BAA4B,YAAY,QAAQ,CAAC,CACvD,UAAU,IAAI"}

package/dist/next/client.d.mts

@@ -1,4 +1,4 @@
-import { X as LogLevel, dt as TransportConfig } from "../audit-D7v6JHj0.mjs";
+import { $ as LogLevel, mt as TransportConfig } from "../audit-CBfv3rl1.mjs";
 import { clearIdentity, log as _clientLog, setIdentity, setMinLevel } from "../runtime/client/log.mjs";
 import * as _$react from "react";
 

package/dist/next/index.d.mts

@@ -1,7 +1,7 @@
-import { H as EnvironmentContext, X as LogLevel, Y as Log, ot as SamplingConfig, rt as RequestLogger } from "../audit-D7v6JHj0.mjs";
-import { n as createError } from "../error-CpghjrkY.mjs";
-import { n as _log } from "../logger-mHIWxBhJ.mjs";
-import { t as BaseEvlogOptions } from "../middleware-B_k4Mrzg.mjs";
+import { $ as LogLevel, G as EnvironmentContext, Q as Log, l as AuditableLogger, lt as SamplingConfig } from "../audit-CBfv3rl1.mjs";
+import { n as createError } from "../error-CPCM5a1D.mjs";
+import { n as _log } from "../logger-DWTPZ0c1.mjs";
+import { t as BaseEvlogOptions } from "../middleware-CjVyGyrG.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/next/types.d.ts
@@ -75,7 +75,7 @@ interface EvlogMiddlewareConfig {
  * })
  * ```
  */
-declare function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T>;
+declare function useLogger<T extends object = Record<string, unknown>>(): AuditableLogger<T>;
 //#endregion
 //#region src/next/middleware.d.ts
 type NextRequest = {

package/dist/next/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/next/types.ts","../../src/next/storage.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"mappings":";;;;;;;UAGiB,gBAAA,SAAyB,gBAAA;;;;;EAKxC,OAAA;EALe;;;EAUf,GAAA,GAAM,OAAA,CAAQ,kBAAA;EAAR;;;;EAMN,MAAA;EAhBwD;;;;EAsBxD,OAAA;EAZc;;;EAiBd,QAAA,GAAW,cAAA;EAAA;;;;EAMX,QAAA,GAAW,QAAA;EAaL;;AAGR;;EAVE,SAAA;EAeA;;;;;EARA,MAAA;AAAA;AAAA,UAGe,qBAAA;EChC4B;;;;EDqC3C,OAAA;ECrCwB;;;;ED2CxB,OAAA;AAAA;;;;;;;;AA5DF;;;;;;;;;;iBCiBgB,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,aAAA,CAAc,CAAA;;;KCjBlF,WAAA;EACH,OAAA;IAAW,QAAA;EAAA;EACX,OAAA;IAAW,GAAA,CAAI,IAAA;EAAA;AAAA;AAAA,KAGZ,YAAA;EACH,OAAA;IACE,GAAA,CAAI,IAAA,UAAc,KAAA;IAClB,GAAA,CAAI,IAAA;EAAA;AAAA;;;;;;;;;;;;;;iBAqBQ,eAAA,CAAgB,MAAA,GAAS,qBAAA,IACzB,OAAA,EAAS,WAAA,KAAW,OAAA,CAAA,YAAA;;;AF9BpC;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA;;;;AAjDA,iBGuCgB,WAAA,CAAY,OAAA,GAAS,gBAAA;6DAW04G,IAAA,EAAA,KAAA,KAAA,OAAA,SAAkC,IAAA,EAAA,KAAA,KAAA,OAAA,CAAA,OAAA,CAAA,OAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/next/types.ts","../../src/next/storage.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"mappings":";;;;;;;UAGiB,gBAAA,SAAyB,gBAAA;;;;;EAKxC,OAAA;EALe;;;EAUf,GAAA,GAAM,OAAA,CAAQ,kBAAA;EAAR;;;;EAMN,MAAA;EAhBwD;;;;EAsBxD,OAAA;EAZc;;;EAiBd,QAAA,GAAW,cAAA;EAAA;;;;EAMX,QAAA,GAAW,QAAA;EAaL;;AAGR;;EAVE,SAAA;EAeA;;;;;EARA,MAAA;AAAA;AAAA,UAGe,qBAAA;EChC4B;;;;EDqC3C,OAAA;ECrCwB;;;;ED2CxB,OAAA;AAAA;;;;;;;;AA5DF;;;;;;;;;;iBCiBgB,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,eAAA,CAAgB,CAAA;;;KCjBpF,WAAA;EACH,OAAA;IAAW,QAAA;EAAA;EACX,OAAA;IAAW,GAAA,CAAI,IAAA;EAAA;AAAA;AAAA,KAGZ,YAAA;EACH,OAAA;IACE,GAAA,CAAI,IAAA,UAAc,KAAA;IAClB,GAAA,CAAI,IAAA;EAAA;AAAA;;;;;;;;;;;;;;iBAqBQ,eAAA,CAAgB,MAAA,GAAS,qBAAA,IACzB,OAAA,EAAS,WAAA,KAAW,OAAA,CAAA,YAAA;;;AF9BpC;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA;;;;AAjDA,iBGuCgB,WAAA,CAAY,OAAA,GAAS,gBAAA;6DAW04G,IAAA,EAAA,KAAA,KAAA,OAAA,SAAkC,IAAA,EAAA,KAAA,KAAA,OAAA,CAAA,OAAA,CAAA,OAAA"}

package/dist/next/index.mjs

@@ -1,9 +1,9 @@
 import { filterSafeHeaders } from "../utils.mjs";
-import { S as isLoggerLocked, b as initLogger, g as createRequestLogger, m as _log, v as getGlobalDrain, w as markWideEventDrainStarted, x as isEnabled } from "../audit-BQt8yAHo.mjs";
+import { C as isLoggerLocked, S as isEnabled, T as markWideEventDrainStarted, _ as createRequestLogger, h as _log, x as initLogger, y as getGlobalDrain } from "../audit-CL0q7GJU.mjs";
 import { EvlogError, createError } from "../error.mjs";
 import { n as shouldLog, t as getServiceForPath } from "../routes-4rMzRyTk.mjs";
 import { r as shouldDeferEmitForResponse, t as bindStreamingResponseLifecycle } from "../streamResponse-CmQ3qUbF.mjs";
-import { t as attachForkToLogger } from "../fork-CgGlAaHa.mjs";
+import { t as attachForkToLogger } from "../fork-Di44utlp.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/next/enrich-error-stack.ts
 /**
@@ -12,7 +12,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 async function enrichNextErrorStackForDev(error, options = {}) {
 	if (process.env.NODE_ENV === "production") return;
 	if (options.pretty === false) return;
-	const { enrichErrorStackFromNextDev } = await import("../enrich-error-stack-next.node-Dgm_rCf5.mjs");
+	const { enrichErrorStackFromNextDev } = await import("../enrich-error-stack-next.node-BecxSKUc.mjs");
 	enrichErrorStackFromNextDev(error);
 }
 //#endregion

package/dist/next/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/next/enrich-error-stack.ts","../../src/next/storage.ts","../../src/next/handler.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"sourcesContent":["/**\n * Source-map stack enrichment for Next.js dev — isolated from Nitro to avoid bundling nitropack/youch.\n */\nexport async function enrichNextErrorStackForDev(\n  error: Error,\n  options: { pretty?: boolean } = {},\n): Promise<void> {\n  if (process.env.NODE_ENV === 'production') return\n  if (options.pretty === false) return\n\n  const { enrichErrorStackFromNextDev } = await import('../shared/enrich-error-stack-next.node')\n  enrichErrorStackFromNextDev(error)\n}\n","import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\n\nexport const evlogStorage = new AsyncLocalStorage<RequestLogger>()\n\n/**\n * Get the current request-scoped logger.\n * Must be called inside a `withEvlog()` wrapper.\n *\n * @throws {Error} if called outside of `withEvlog()` context\n *\n * @example\n * ```ts\n * export const POST = withEvlog(async (request) => {\n *   const log = useLogger()\n *   log.set({ user: { id: '123' } })\n *   return Response.json({ ok: true })\n * })\n * ```\n */\nexport function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n  const logger = evlogStorage.getStore()\n  if (!logger) {\n    throw new Error(\n      '[evlog] useLogger() was called outside of a withEvlog() context. '\n      + 'Wrap your route handler or server action with withEvlog().',\n    )\n  }\n  return logger as RequestLogger<T>\n}\n","import type { DrainContext, EnrichContext, TailSamplingContext, WideEvent } from '../types'\nimport { createRequestLogger, getGlobalDrain, initLogger, isEnabled, isLoggerLocked, markWideEventDrainStarted } from '../logger'\nimport { attachForkToLogger } from '../shared/fork'\nimport type { MiddlewareLoggerOptions } from '../shared/middleware'\nimport { shouldLog, getServiceForPath } from '../shared/routes'\nimport { bindStreamingResponseLifecycle, shouldDeferEmitForResponse } from '../shared/streamResponse'\nimport { filterSafeHeaders } from '../utils'\nimport { EvlogError } from '../error'\nimport { enrichNextErrorStackForDev } from './enrich-error-stack'\nimport type { NextEvlogOptions } from './types'\nimport { evlogStorage } from './storage'\n\ninterface WithEvlogState {\n  initialized: boolean\n  options: NextEvlogOptions\n}\n\nconst state: WithEvlogState = {\n  initialized: false,\n  options: {},\n}\n\nexport function configureHandler(options: NextEvlogOptions): void {\n  state.options = options\n  state.initialized = true\n\n  // Skip if instrumentation register() already configured the logger.\n  // Re-initializing would wipe the global drain.\n  if (isLoggerLocked()) return\n\n  // Don't pass drain to initLogger — the global drain fires inside emitWideEvent\n  // which doesn't have request/header context. Instead, we call drain ourselves\n  // in callEnrichAndDrain after enrich, with full context.\n  initLogger({\n    enabled: options.enabled,\n    env: {\n      service: options.service,\n      ...options.env,\n    },\n    pretty: options.pretty,\n    silent: options.silent,\n    sampling: options.sampling,\n    minLevel: options.minLevel,\n    stringify: options.stringify,\n    _suppressDrainWarning: true,\n  })\n}\n\nfunction extractRequestInfo(request: Request): { method: string, path: string, headers: Record<string, string> } {\n  const { method } = request\n  const url = new URL(request.url, 'http://localhost')\n  const path = url.pathname\n\n  const headers: Record<string, string> = {}\n  request.headers.forEach((value, key) => {\n    headers[key] = value\n  })\n\n  return { method, path, headers: filterSafeHeaders(headers) }\n}\n\nasync function callEnrichAndDrain(\n  emittedEvent: WideEvent | null,\n  requestInfo: { method: string, path: string, requestId: string },\n  headers: Record<string, string>,\n  responseStatus?: number,\n): Promise<void> {\n  if (!emittedEvent) return\n\n  const { enrich } = state.options\n  const drain = state.options.drain ?? getGlobalDrain()\n\n  const run = async () => {\n    if (enrich) {\n      const enrichCtx: EnrichContext = {\n        event: emittedEvent,\n        request: requestInfo,\n        headers,\n        response: { status: responseStatus },\n      }\n      try {\n        await enrich(enrichCtx)\n      } catch (err) {\n        console.error('[evlog] enrich failed:', err)\n      }\n    }\n\n    markWideEventDrainStarted(emittedEvent)\n\n    if (drain) {\n      const drainCtx: DrainContext = {\n        event: emittedEvent,\n        request: requestInfo,\n        headers,\n      }\n      try {\n        await drain(drainCtx)\n      } catch (err) {\n        console.error('[evlog] drain failed:', err)\n      }\n    }\n  }\n\n  // Use next/server after() if available to run enrich+drain after response\n  try {\n    const { after } = await import('next/server')\n    if (typeof after === 'function') {\n      after(run)\n      return\n    }\n  } catch {\n    // next/server not available or after() not exported — run inline\n  }\n\n  // Fallback: fire-and-forget (enrich still awaited for correctness)\n  run().catch(() => {})\n}\n\nasync function emitRequestEvent(\n  logger: ReturnType<typeof createRequestLogger>,\n  requestInfo: { method: string, path: string, requestId: string },\n  headers: Record<string, string>,\n  status: number,\n): Promise<void> {\n  let forceKeep = false\n  if (state.options.keep) {\n    try {\n      const tailCtx: TailSamplingContext = {\n        status,\n        path: requestInfo.path,\n        method: requestInfo.method,\n        context: logger.getContext(),\n        shouldKeep: false,\n      }\n      await state.options.keep(tailCtx)\n      forceKeep = tailCtx.shouldKeep ?? false\n    } catch (err) {\n      console.error('[evlog] keep callback failed:', err)\n    }\n  }\n\n  const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n  await callEnrichAndDrain(emittedEvent, requestInfo, headers, status)\n}\n\n/**\n * Wrap a Next.js route handler or server action with evlog request-scoped logging.\n *\n * @example\n * ```ts\n * // Route handler\n * export const POST = withEvlog(async (request: NextRequest) => {\n *   const log = useLogger()\n *   log.set({ user: { id: '123' } })\n *   return Response.json({ success: true })\n * })\n *\n * // Server action\n * export const checkout = withEvlog(async (formData: FormData) => {\n *   const log = useLogger()\n *   log.set({ action: 'checkout' })\n * })\n * ```\n */\nexport function createWithEvlog(options: NextEvlogOptions) {\n  configureHandler(options)\n\n  return function withEvlog<TArgs extends unknown[], TReturn>(\n    handler: (...args: TArgs) => TReturn,\n  ): (...args: TArgs) => Promise<Awaited<TReturn>> {\n    return async (...args: TArgs): Promise<Awaited<TReturn>> => {\n      if (!isEnabled()) {\n        return await handler(...args) as Awaited<TReturn>\n      }\n\n      // Extract request info from first argument if it's a Request\n      const [firstArg] = args\n      const isRequest = firstArg instanceof Request\n\n      let method = 'UNKNOWN'\n      let path = '/'\n      let headers: Record<string, string> = {}\n      let requestId = crypto.randomUUID()\n\n      if (isRequest) {\n        ({ method, path, headers } = extractRequestInfo(firstArg))\n\n        // Reuse request-id from middleware if present\n        const middlewareRequestId = firstArg.headers.get('x-request-id')\n        if (middlewareRequestId) requestId = middlewareRequestId\n      }\n\n      // Check include/exclude patterns\n      if (!shouldLog(path, state.options.include, state.options.exclude)) {\n        return await handler(...args) as Awaited<TReturn>\n      }\n\n      const logger = createRequestLogger({ method, path, requestId }, { _deferDrain: true })\n\n      const middlewareOpts: MiddlewareLoggerOptions = {\n        method,\n        path,\n        requestId,\n        headers,\n        include: state.options.include,\n        exclude: state.options.exclude,\n        routes: state.options.routes,\n        drain: state.options.drain,\n        enrich: state.options.enrich,\n        keep: state.options.keep,\n        redact: state.options.redact,\n      }\n      attachForkToLogger(evlogStorage, logger, middlewareOpts)\n\n      // Apply route-based service configuration\n      const routeService = getServiceForPath(path, state.options.routes)\n      if (routeService) {\n        logger.set({ service: routeService })\n      }\n\n      // Apply start time from middleware if present\n      if (isRequest) {\n        const startHeader = firstArg.headers.get('x-evlog-start')\n        if (startHeader) {\n          logger.set({ middlewareStart: Number(startHeader) })\n        }\n      }\n\n      try {\n        const result = await evlogStorage.run(logger, () => handler(...args))\n        const requestInfo = { method, path, requestId }\n\n        if (result instanceof Response && shouldDeferEmitForResponse(result)) {\n          const wrapped = bindStreamingResponseLifecycle(result, async (meta) => {\n            if (meta.error) {\n              logger.error(meta.error)\n            }\n            const finalStatus = meta.status ?? result.status\n            logger.set({ status: finalStatus })\n            await emitRequestEvent(logger, requestInfo, headers, finalStatus)\n          })\n          return wrapped as Awaited<TReturn>\n        }\n\n        // Extract response status\n        let { status } = { status: 200 }\n        if (result instanceof Response) {\n          ({ status } = result)\n        }\n        logger.set({ status })\n\n        await emitRequestEvent(logger, requestInfo, headers, status)\n\n        return result as Awaited<TReturn>\n      } catch (error) {\n        const err = error instanceof Error ? error : new Error(String(error))\n        await enrichNextErrorStackForDev(err, { pretty: state.options.pretty })\n        logger.error(err)\n\n        const errorStatus = (error as { status?: number }).status\n          ?? (error as { statusCode?: number }).statusCode\n          ?? 500\n        logger.set({ status: errorStatus })\n\n        await emitRequestEvent(logger, { method, path, requestId }, headers, errorStatus)\n\n        // Return structured JSON response for EvlogErrors (like H3 does for Nuxt)\n        if (isRequest && error instanceof EvlogError) {\n          return Response.json(error.toJSON(), { status: error.status }) as Awaited<TReturn>\n        }\n\n        throw error\n      }\n    }\n  }\n}\n","import { shouldLog } from '../shared/routes'\nimport type { EvlogMiddlewareConfig } from './types'\n\ntype NextRequest = {\n  nextUrl: { pathname: string }\n  headers: { get(name: string): string | null }\n}\n\ntype NextResponse = {\n  headers: {\n    set(name: string, value: string): void\n    get(name: string): string | null\n  }\n}\n\ntype NextResponseStatic = {\n  next(options?: { request?: { headers: Headers } }): NextResponse\n}\n\n/**\n * Create an evlog middleware for Next.js.\n * Sets `x-request-id` and `x-evlog-start` headers so `withEvlog()` can reuse them\n * for timing consistency across the middleware -> handler chain.\n *\n * @example\n * ```ts\n * // middleware.ts\n * import { evlogMiddleware } from 'evlog/next'\n * export const middleware = evlogMiddleware()\n * export const config = { matcher: ['/api/:path*'] }\n * ```\n */\nexport function evlogMiddleware(config?: EvlogMiddlewareConfig) {\n  return async (request: NextRequest) => {\n    const path = request.nextUrl.pathname\n\n    // Check include/exclude patterns\n    if (!shouldLog(path, config?.include, config?.exclude)) {\n      const { NextResponse: nextResponse } = await import('next/server') as { NextResponse: NextResponseStatic }\n      return nextResponse.next()\n    }\n\n    // Generate or reuse request ID\n    const existingId = request.headers.get('x-request-id')\n    const requestId = existingId || crypto.randomUUID()\n\n    // Forward modified headers to the route handler\n    const requestHeaders = new Headers(request.headers as HeadersInit)\n\n    requestHeaders.set('x-request-id', requestId)\n    requestHeaders.set('x-evlog-start', String(Date.now()))\n\n    const { NextResponse: nextResponse } = await import('next/server') as { NextResponse: NextResponseStatic }\n    const response = nextResponse.next({\n      request: { headers: requestHeaders },\n    })\n\n    // Also set on response for downstream consumers\n    response.headers.set('x-request-id', requestId)\n\n    return response\n  }\n}\n","import { log } from '../logger'\nimport { createError, createEvlogError } from '../error'\nimport type { NextEvlogOptions } from './types'\nimport { createWithEvlog } from './handler'\nimport { useLogger } from './storage'\n\nexport type { NextEvlogOptions, EvlogMiddlewareConfig } from './types'\n\nexport { evlogMiddleware } from './middleware'\nexport { useLogger } from './storage'\nexport { log } from '../logger'\nexport { createError, createEvlogError } from '../error'\n\n/**\n * Create an evlog instance configured for Next.js.\n * Returns all helpers needed for server-side logging.\n *\n * @example\n * ```ts\n * // lib/evlog.ts\n * import { createEvlog } from 'evlog/next'\n * import { createAxiomDrain } from 'evlog/axiom'\n * import { createDrainPipeline } from 'evlog/pipeline'\n *\n * const pipeline = createDrainPipeline({ batch: { size: 50 } })\n *\n * export const { withEvlog, useLogger, log, createEvlogError } = createEvlog({\n *   service: 'my-app',\n *   sampling: {\n *     rates: { info: 10 },\n *     keep: [{ status: 400 }, { duration: 1000 }],\n *   },\n *   drain: pipeline(createAxiomDrain({\n *     dataset: 'logs',\n *     apiKey: process.env.AXIOM_API_KEY!,\n *   })),\n *   enrich: (ctx) => {\n *     ctx.event.deploymentId = process.env.VERCEL_DEPLOYMENT_ID\n *   },\n * })\n * ```\n */\nexport function createEvlog(options: NextEvlogOptions = {}) {\n  const withEvlog = createWithEvlog(options)\n\n  return {\n    withEvlog,\n    useLogger,\n    log,\n    createError,\n    createEvlogError,\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/next/enrich-error-stack.ts","../../src/next/storage.ts","../../src/next/handler.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"sourcesContent":["/**\n * Source-map stack enrichment for Next.js dev — isolated from Nitro to avoid bundling nitropack/youch.\n */\nexport async function enrichNextErrorStackForDev(\n  error: Error,\n  options: { pretty?: boolean } = {},\n): Promise<void> {\n  if (process.env.NODE_ENV === 'production') return\n  if (options.pretty === false) return\n\n  const { enrichErrorStackFromNextDev } = await import('../shared/enrich-error-stack-next.node')\n  enrichErrorStackFromNextDev(error)\n}\n","import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { AuditableLogger } from '../audit'\n\nexport const evlogStorage = new AsyncLocalStorage<AuditableLogger>()\n\n/**\n * Get the current request-scoped logger.\n * Must be called inside a `withEvlog()` wrapper.\n *\n * @throws {Error} if called outside of `withEvlog()` context\n *\n * @example\n * ```ts\n * export const POST = withEvlog(async (request) => {\n *   const log = useLogger()\n *   log.set({ user: { id: '123' } })\n *   return Response.json({ ok: true })\n * })\n * ```\n */\nexport function useLogger<T extends object = Record<string, unknown>>(): AuditableLogger<T> {\n  const logger = evlogStorage.getStore()\n  if (!logger) {\n    throw new Error(\n      '[evlog] useLogger() was called outside of a withEvlog() context. '\n      + 'Wrap your route handler or server action with withEvlog().',\n    )\n  }\n  return logger as AuditableLogger<T>\n}\n","import type { DrainContext, EnrichContext, TailSamplingContext, WideEvent } from '../types'\nimport { createRequestLogger, getGlobalDrain, initLogger, isEnabled, isLoggerLocked, markWideEventDrainStarted } from '../logger'\nimport { attachForkToLogger } from '../shared/fork'\nimport type { MiddlewareLoggerOptions } from '../shared/middleware'\nimport { shouldLog, getServiceForPath } from '../shared/routes'\nimport { bindStreamingResponseLifecycle, shouldDeferEmitForResponse } from '../shared/streamResponse'\nimport { filterSafeHeaders } from '../utils'\nimport { EvlogError } from '../error'\nimport { enrichNextErrorStackForDev } from './enrich-error-stack'\nimport type { NextEvlogOptions } from './types'\nimport { evlogStorage } from './storage'\n\ninterface WithEvlogState {\n  initialized: boolean\n  options: NextEvlogOptions\n}\n\nconst state: WithEvlogState = {\n  initialized: false,\n  options: {},\n}\n\nexport function configureHandler(options: NextEvlogOptions): void {\n  state.options = options\n  state.initialized = true\n\n  // Skip if instrumentation register() already configured the logger.\n  // Re-initializing would wipe the global drain.\n  if (isLoggerLocked()) return\n\n  // Don't pass drain to initLogger — the global drain fires inside emitWideEvent\n  // which doesn't have request/header context. Instead, we call drain ourselves\n  // in callEnrichAndDrain after enrich, with full context.\n  initLogger({\n    enabled: options.enabled,\n    env: {\n      service: options.service,\n      ...options.env,\n    },\n    pretty: options.pretty,\n    silent: options.silent,\n    sampling: options.sampling,\n    minLevel: options.minLevel,\n    stringify: options.stringify,\n    _suppressDrainWarning: true,\n  })\n}\n\nfunction extractRequestInfo(request: Request): { method: string, path: string, headers: Record<string, string> } {\n  const { method } = request\n  const url = new URL(request.url, 'http://localhost')\n  const path = url.pathname\n\n  const headers: Record<string, string> = {}\n  request.headers.forEach((value, key) => {\n    headers[key] = value\n  })\n\n  return { method, path, headers: filterSafeHeaders(headers) }\n}\n\nasync function callEnrichAndDrain(\n  emittedEvent: WideEvent | null,\n  requestInfo: { method: string, path: string, requestId: string },\n  headers: Record<string, string>,\n  responseStatus?: number,\n): Promise<void> {\n  if (!emittedEvent) return\n\n  const { enrich } = state.options\n  const drain = state.options.drain ?? getGlobalDrain()\n\n  const run = async () => {\n    if (enrich) {\n      const enrichCtx: EnrichContext = {\n        event: emittedEvent,\n        request: requestInfo,\n        headers,\n        response: { status: responseStatus },\n      }\n      try {\n        await enrich(enrichCtx)\n      } catch (err) {\n        console.error('[evlog] enrich failed:', err)\n      }\n    }\n\n    markWideEventDrainStarted(emittedEvent)\n\n    if (drain) {\n      const drainCtx: DrainContext = {\n        event: emittedEvent,\n        request: requestInfo,\n        headers,\n      }\n      try {\n        await drain(drainCtx)\n      } catch (err) {\n        console.error('[evlog] drain failed:', err)\n      }\n    }\n  }\n\n  // Use next/server after() if available to run enrich+drain after response\n  try {\n    const { after } = await import('next/server')\n    if (typeof after === 'function') {\n      after(run)\n      return\n    }\n  } catch {\n    // next/server not available or after() not exported — run inline\n  }\n\n  // Fallback: fire-and-forget (enrich still awaited for correctness)\n  run().catch(() => {})\n}\n\nasync function emitRequestEvent(\n  logger: ReturnType<typeof createRequestLogger>,\n  requestInfo: { method: string, path: string, requestId: string },\n  headers: Record<string, string>,\n  status: number,\n): Promise<void> {\n  let forceKeep = false\n  if (state.options.keep) {\n    try {\n      const tailCtx: TailSamplingContext = {\n        status,\n        path: requestInfo.path,\n        method: requestInfo.method,\n        context: logger.getContext(),\n        shouldKeep: false,\n      }\n      await state.options.keep(tailCtx)\n      forceKeep = tailCtx.shouldKeep ?? false\n    } catch (err) {\n      console.error('[evlog] keep callback failed:', err)\n    }\n  }\n\n  const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n  await callEnrichAndDrain(emittedEvent, requestInfo, headers, status)\n}\n\n/**\n * Wrap a Next.js route handler or server action with evlog request-scoped logging.\n *\n * @example\n * ```ts\n * // Route handler\n * export const POST = withEvlog(async (request: NextRequest) => {\n *   const log = useLogger()\n *   log.set({ user: { id: '123' } })\n *   return Response.json({ success: true })\n * })\n *\n * // Server action\n * export const checkout = withEvlog(async (formData: FormData) => {\n *   const log = useLogger()\n *   log.set({ action: 'checkout' })\n * })\n * ```\n */\nexport function createWithEvlog(options: NextEvlogOptions) {\n  configureHandler(options)\n\n  return function withEvlog<TArgs extends unknown[], TReturn>(\n    handler: (...args: TArgs) => TReturn,\n  ): (...args: TArgs) => Promise<Awaited<TReturn>> {\n    return async (...args: TArgs): Promise<Awaited<TReturn>> => {\n      if (!isEnabled()) {\n        return await handler(...args) as Awaited<TReturn>\n      }\n\n      // Extract request info from first argument if it's a Request\n      const [firstArg] = args\n      const isRequest = firstArg instanceof Request\n\n      let method = 'UNKNOWN'\n      let path = '/'\n      let headers: Record<string, string> = {}\n      let requestId = crypto.randomUUID()\n\n      if (isRequest) {\n        ({ method, path, headers } = extractRequestInfo(firstArg))\n\n        // Reuse request-id from middleware if present\n        const middlewareRequestId = firstArg.headers.get('x-request-id')\n        if (middlewareRequestId) requestId = middlewareRequestId\n      }\n\n      // Check include/exclude patterns\n      if (!shouldLog(path, state.options.include, state.options.exclude)) {\n        return await handler(...args) as Awaited<TReturn>\n      }\n\n      const logger = createRequestLogger({ method, path, requestId }, { _deferDrain: true })\n\n      const middlewareOpts: MiddlewareLoggerOptions = {\n        method,\n        path,\n        requestId,\n        headers,\n        include: state.options.include,\n        exclude: state.options.exclude,\n        routes: state.options.routes,\n        drain: state.options.drain,\n        enrich: state.options.enrich,\n        keep: state.options.keep,\n        redact: state.options.redact,\n      }\n      attachForkToLogger(evlogStorage, logger, middlewareOpts)\n\n      // Apply route-based service configuration\n      const routeService = getServiceForPath(path, state.options.routes)\n      if (routeService) {\n        logger.set({ service: routeService })\n      }\n\n      // Apply start time from middleware if present\n      if (isRequest) {\n        const startHeader = firstArg.headers.get('x-evlog-start')\n        if (startHeader) {\n          logger.set({ middlewareStart: Number(startHeader) })\n        }\n      }\n\n      try {\n        const result = await evlogStorage.run(logger, () => handler(...args))\n        const requestInfo = { method, path, requestId }\n\n        if (result instanceof Response && shouldDeferEmitForResponse(result)) {\n          const wrapped = bindStreamingResponseLifecycle(result, async (meta) => {\n            if (meta.error) {\n              logger.error(meta.error)\n            }\n            const finalStatus = meta.status ?? result.status\n            logger.set({ status: finalStatus })\n            await emitRequestEvent(logger, requestInfo, headers, finalStatus)\n          })\n          return wrapped as Awaited<TReturn>\n        }\n\n        // Extract response status\n        let { status } = { status: 200 }\n        if (result instanceof Response) {\n          ({ status } = result)\n        }\n        logger.set({ status })\n\n        await emitRequestEvent(logger, requestInfo, headers, status)\n\n        return result as Awaited<TReturn>\n      } catch (error) {\n        const err = error instanceof Error ? error : new Error(String(error))\n        await enrichNextErrorStackForDev(err, { pretty: state.options.pretty })\n        logger.error(err)\n\n        const errorStatus = (error as { status?: number }).status\n          ?? (error as { statusCode?: number }).statusCode\n          ?? 500\n        logger.set({ status: errorStatus })\n\n        await emitRequestEvent(logger, { method, path, requestId }, headers, errorStatus)\n\n        // Return structured JSON response for EvlogErrors (like H3 does for Nuxt)\n        if (isRequest && error instanceof EvlogError) {\n          return Response.json(error.toJSON(), { status: error.status }) as Awaited<TReturn>\n        }\n\n        throw error\n      }\n    }\n  }\n}\n","import { shouldLog } from '../shared/routes'\nimport type { EvlogMiddlewareConfig } from './types'\n\ntype NextRequest = {\n  nextUrl: { pathname: string }\n  headers: { get(name: string): string | null }\n}\n\ntype NextResponse = {\n  headers: {\n    set(name: string, value: string): void\n    get(name: string): string | null\n  }\n}\n\ntype NextResponseStatic = {\n  next(options?: { request?: { headers: Headers } }): NextResponse\n}\n\n/**\n * Create an evlog middleware for Next.js.\n * Sets `x-request-id` and `x-evlog-start` headers so `withEvlog()` can reuse them\n * for timing consistency across the middleware -> handler chain.\n *\n * @example\n * ```ts\n * // middleware.ts\n * import { evlogMiddleware } from 'evlog/next'\n * export const middleware = evlogMiddleware()\n * export const config = { matcher: ['/api/:path*'] }\n * ```\n */\nexport function evlogMiddleware(config?: EvlogMiddlewareConfig) {\n  return async (request: NextRequest) => {\n    const path = request.nextUrl.pathname\n\n    // Check include/exclude patterns\n    if (!shouldLog(path, config?.include, config?.exclude)) {\n      const { NextResponse: nextResponse } = await import('next/server') as { NextResponse: NextResponseStatic }\n      return nextResponse.next()\n    }\n\n    // Generate or reuse request ID\n    const existingId = request.headers.get('x-request-id')\n    const requestId = existingId || crypto.randomUUID()\n\n    // Forward modified headers to the route handler\n    const requestHeaders = new Headers(request.headers as HeadersInit)\n\n    requestHeaders.set('x-request-id', requestId)\n    requestHeaders.set('x-evlog-start', String(Date.now()))\n\n    const { NextResponse: nextResponse } = await import('next/server') as { NextResponse: NextResponseStatic }\n    const response = nextResponse.next({\n      request: { headers: requestHeaders },\n    })\n\n    // Also set on response for downstream consumers\n    response.headers.set('x-request-id', requestId)\n\n    return response\n  }\n}\n","import { log } from '../logger'\nimport { createError, createEvlogError } from '../error'\nimport type { NextEvlogOptions } from './types'\nimport { createWithEvlog } from './handler'\nimport { useLogger } from './storage'\n\nexport type { NextEvlogOptions, EvlogMiddlewareConfig } from './types'\n\nexport { evlogMiddleware } from './middleware'\nexport { useLogger } from './storage'\nexport { log } from '../logger'\nexport { createError, createEvlogError } from '../error'\n\n/**\n * Create an evlog instance configured for Next.js.\n * Returns all helpers needed for server-side logging.\n *\n * @example\n * ```ts\n * // lib/evlog.ts\n * import { createEvlog } from 'evlog/next'\n * import { createAxiomDrain } from 'evlog/axiom'\n * import { createDrainPipeline } from 'evlog/pipeline'\n *\n * const pipeline = createDrainPipeline({ batch: { size: 50 } })\n *\n * export const { withEvlog, useLogger, log, createEvlogError } = createEvlog({\n *   service: 'my-app',\n *   sampling: {\n *     rates: { info: 10 },\n *     keep: [{ status: 400 }, { duration: 1000 }],\n *   },\n *   drain: pipeline(createAxiomDrain({\n *     dataset: 'logs',\n *     apiKey: process.env.AXIOM_API_KEY!,\n *   })),\n *   enrich: (ctx) => {\n *     ctx.event.deploymentId = process.env.VERCEL_DEPLOYMENT_ID\n *   },\n * })\n * ```\n */\nexport function createEvlog(options: NextEvlogOptions = {}) {\n  const withEvlog = createWithEvlog(options)\n\n  return {\n    withEvlog,\n    useLogger,\n    log,\n    createError,\n    createEvlogError,\n  }\n}\n"],"mappings":"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"}

package/dist/next/instrumentation/create.d.mts

@@ -1,2 +1,2 @@
-import { i as createInstrumentation, n as DEFAULT_CAPTURE_OUTPUT_IGNORE, r as InstrumentationOptions, t as CaptureOutputOptions } from "../../instrumentation-create-BrjQtSKD.mjs";
+import { i as createInstrumentation, n as DEFAULT_CAPTURE_OUTPUT_IGNORE, r as InstrumentationOptions, t as CaptureOutputOptions } from "../../instrumentation-create-STGmQGQt.mjs";
 export { CaptureOutputOptions, DEFAULT_CAPTURE_OUTPUT_IGNORE, InstrumentationOptions, createInstrumentation };

package/dist/next/instrumentation/create.mjs

@@ -1,3 +1,4 @@
+import { t as registerDiskPrettyErrorSnippetReader } from "../../register-disk-snippet-B_JyhodL.mjs";
 //#region src/next/instrumentation-create.ts
 /** Default patterns skipped by {@link CaptureOutputOptions.ignore}. */
 const DEFAULT_CAPTURE_OUTPUT_IGNORE = [
@@ -106,7 +107,7 @@ function createInstrumentation(options = {}) {
 	function register() {
 		if (registered) return;
 		if (registerPromise) return registerPromise;
-		registerPromise = loadLogger().then(({ initLogger, lockLogger, log }) => {
+		registerPromise = loadLogger().then(async ({ initLogger, lockLogger, log }) => {
 			initLogger({
 				enabled: options.enabled,
 				env: {
@@ -121,6 +122,7 @@ function createInstrumentation(options = {}) {
 				drain: options.drain
 			});
 			lockLogger();
+			if (process.env.NEXT_RUNTIME === "nodejs") await registerDiskPrettyErrorSnippetReader();
 			if (captureOutputOptions && process.env.NEXT_RUNTIME === "nodejs") applyCaptureOutput(captureOutputOptions, log, options.silent ?? false);
 			registered = true;
 		}).catch((error) => {

package/dist/next/instrumentation/create.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create.mjs","names":[],"sources":["../../../src/next/instrumentation-create.ts"],"sourcesContent":["import type { DrainContext, EnvironmentContext, LogLevel, Log, SamplingConfig } from '../types'\nimport type {\n  NextInstrumentationErrorContext,\n  NextInstrumentationRequest,\n} from './instrumentation-gate'\n\ntype LoggerModule = typeof import('../logger')\ntype EvlogProcessOutputGlobal = import('../logger').EvlogProcessOutputGlobal\n\n/** Options for capturing process stdout/stderr as structured log events. */\nexport interface CaptureOutputOptions {\n  /** Capture stdout writes. @default true */\n  stdout?: boolean\n  /** Capture stderr writes. @default true */\n  stderr?: boolean\n  /**\n   * Skip re-emitting chunks that match these patterns as log events.\n   * When omitted, known Next.js Edge bundler warnings are ignored by default.\n   */\n  ignore?: Array<string | RegExp>\n}\n\n/** Default patterns skipped by {@link CaptureOutputOptions.ignore}. */\nexport const DEFAULT_CAPTURE_OUTPUT_IGNORE: Array<string | RegExp> = [\n  'node-module-in-edge-runtime',\n  'Edge Instrumentation',\n  'https://nextjs.org/docs/messages/node-module-in-edge-runtime',\n  'https://nextjs.org/docs/api-reference/edge-runtime',\n  'Ecmascript file had an error',\n  'A Node.js module is loaded',\n  'A Node.js API is used',\n  'not supported in the Edge Runtime',\n  'not supported inthe Edge Runtime',\n  'Import trace:',\n]\n\n/**\n * Configuration for {@link createInstrumentation} and {@link defineNodeInstrumentation}.\n * Controls global logger options and optional stdout/stderr capture (Node.js only).\n */\nexport interface InstrumentationOptions {\n  /** Enable or disable all logging globally. @default true */\n  enabled?: boolean\n  /** Service name for all logged events. */\n  service?: string\n  /** Environment context overrides. */\n  env?: Partial<EnvironmentContext>\n  /** Enable pretty printing. @default true in development */\n  pretty?: boolean\n  /** Suppress built-in console output. @default false */\n  silent?: boolean\n  /** Sampling configuration for filtering logs. */\n  sampling?: SamplingConfig\n  /** Minimum severity for the global `log` API. @default 'debug' */\n  minLevel?: LogLevel\n  /** When pretty is disabled, emit JSON strings or raw objects. @default true */\n  stringify?: boolean\n  /** Drain callback called with every emitted event. */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /** Capture stdout/stderr as structured log events (Node.js only). */\n  captureOutput?: boolean | CaptureOutputOptions\n}\n\ninterface InstrumentationResult {\n  register: () => void | Promise<void>\n  onRequestError: (\n    error: { digest?: string } & Error,\n    request: NextInstrumentationRequest,\n    context: NextInstrumentationErrorContext,\n  ) => void | Promise<void>\n}\n\nlet patching = false\nlet loggerPromise: Promise<LoggerModule> | undefined\nlet stdoutPatched = false\nlet stderrPatched = false\nlet activeCaptureOutput:\n  | {\n      log: Log\n      ignore: Array<string | RegExp>\n      stdout: boolean\n      stderr: boolean\n      silent: boolean\n    }\n  | undefined\n\nfunction loadLogger(): Promise<LoggerModule> {\n  loggerPromise ??= import('../logger')\n  return loggerPromise\n}\n\nfunction resolveCaptureOutputOptions(\n  captureOutput: InstrumentationOptions['captureOutput'],\n): CaptureOutputOptions | undefined {\n  if (!captureOutput) return undefined\n  if (captureOutput === true) {\n    return { stdout: true, stderr: true, ignore: DEFAULT_CAPTURE_OUTPUT_IGNORE }\n  }\n  return {\n    stdout: captureOutput.stdout ?? true,\n    stderr: captureOutput.stderr ?? true,\n    ignore: captureOutput.ignore ?? DEFAULT_CAPTURE_OUTPUT_IGNORE,\n  }\n}\n\nfunction shouldIgnoreCapturedOutput(message: string, ignore: Array<string | RegExp>): boolean {\n  return ignore.some((pattern) => {\n    if (typeof pattern === 'string') return message.includes(pattern)\n    return pattern.test(message)\n  })\n}\n\nfunction applyCaptureOutput(config: CaptureOutputOptions, logApi: Log, silent: boolean): void {\n  activeCaptureOutput = {\n    log: logApi,\n    ignore: config.ignore ?? DEFAULT_CAPTURE_OUTPUT_IGNORE,\n    stdout: config.stdout !== false,\n    stderr: config.stderr !== false,\n    silent,\n  }\n\n  const proc = globalThis.process\n\n  if (activeCaptureOutput.stdout && !stdoutPatched) {\n    const originalStdoutWrite = proc.stdout.write.bind(proc.stdout)\n    ;(globalThis as EvlogProcessOutputGlobal).__evlogNativeStdoutWrite = originalStdoutWrite\n    stdoutPatched = true\n    proc.stdout.write = function(chunk: unknown, ...args: unknown[]): boolean {\n      const message = String(chunk).trimEnd()\n      const active = activeCaptureOutput\n      if (\n        !patching\n        && message.length > 0\n        && active?.stdout\n        && !shouldIgnoreCapturedOutput(message, active.ignore)\n      ) {\n        patching = true\n        try {\n          active.log.info({ source: 'stdout', message })\n        } finally {\n          patching = false\n        }\n        if (!active.silent) {\n          return true\n        }\n      }\n      return originalStdoutWrite(chunk as string, ...args as [])\n    } as typeof process.stdout.write\n  }\n\n  if (activeCaptureOutput.stderr && !stderrPatched) {\n    const originalStderrWrite = proc.stderr.write.bind(proc.stderr)\n    stderrPatched = true\n    proc.stderr.write = function(chunk: unknown, ...args: unknown[]): boolean {\n      const message = String(chunk).trimEnd()\n      const active = activeCaptureOutput\n      if (\n        !patching\n        && message.length > 0\n        && active?.stderr\n        && !shouldIgnoreCapturedOutput(message, active.ignore)\n      ) {\n        patching = true\n        try {\n          active.log.error({ source: 'stderr', message })\n        } finally {\n          patching = false\n        }\n        if (!active.silent) {\n          return true\n        }\n      }\n      return originalStderrWrite(chunk as string, ...args as [])\n    } as typeof process.stderr.write\n  }\n}\n\n/**\n * Create Next.js instrumentation hooks (`register`, `onRequestError`).\n *\n * Load via dynamic `import()` from root `instrumentation.ts` (Node.js runtime only).\n * Load via dynamic `import()` from root `instrumentation.ts` with {@link defineNodeInstrumentation}.\n */\nexport function createInstrumentation(options: InstrumentationOptions = {}): InstrumentationResult {\n  let registered = false\n  let registerPromise: Promise<void> | undefined\n  const captureOutputOptions = resolveCaptureOutputOptions(options.captureOutput)\n\n  function register(): void | Promise<void> {\n    if (registered) return\n    if (registerPromise) return registerPromise\n\n    registerPromise = loadLogger().then(({ initLogger, lockLogger, log }) => {\n      initLogger({\n        enabled: options.enabled,\n        env: {\n          service: options.service,\n          ...options.env,\n        },\n        pretty: options.pretty,\n        silent: options.silent,\n        sampling: options.sampling,\n        minLevel: options.minLevel,\n        stringify: options.stringify,\n        drain: options.drain,\n      })\n      lockLogger()\n\n      if (captureOutputOptions && process.env.NEXT_RUNTIME === 'nodejs') {\n        applyCaptureOutput(captureOutputOptions, log, options.silent ?? false)\n      }\n      registered = true\n    }).catch((error) => {\n      registerPromise = undefined\n      throw error\n    })\n    return registerPromise\n  }\n\n  function onRequestError(\n    error: { digest?: string } & Error,\n    request: { path: string; method: string; headers: Record<string, string> },\n    context: { routerKind: string; routePath: string; routeType: string; renderSource: string },\n  ): void | Promise<void> {\n    return loadLogger().then(({ log }) => {\n      log.error({\n        message: error.message,\n        digest: error.digest,\n        stack: error.stack,\n        path: request.path,\n        method: request.method,\n        routerKind: context.routerKind,\n        routePath: context.routePath,\n        routeType: context.routeType,\n        renderSource: context.renderSource,\n      })\n    })\n  }\n\n  return { register, onRequestError }\n}\n"],"mappings":"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"}
+{"version":3,"file":"create.mjs","names":[],"sources":["../../../src/next/instrumentation-create.ts"],"sourcesContent":["import { registerDiskPrettyErrorSnippetReader } from '../shared/register-disk-snippet'\nimport type { DrainContext, EnvironmentContext, LogLevel, Log, SamplingConfig } from '../types'\nimport type {\n  NextInstrumentationErrorContext,\n  NextInstrumentationRequest,\n} from './instrumentation-gate'\n\ntype LoggerModule = typeof import('../logger')\ntype EvlogProcessOutputGlobal = import('../logger').EvlogProcessOutputGlobal\n\n/** Options for capturing process stdout/stderr as structured log events. */\nexport interface CaptureOutputOptions {\n  /** Capture stdout writes. @default true */\n  stdout?: boolean\n  /** Capture stderr writes. @default true */\n  stderr?: boolean\n  /**\n   * Skip re-emitting chunks that match these patterns as log events.\n   * When omitted, known Next.js Edge bundler warnings are ignored by default.\n   */\n  ignore?: Array<string | RegExp>\n}\n\n/** Default patterns skipped by {@link CaptureOutputOptions.ignore}. */\nexport const DEFAULT_CAPTURE_OUTPUT_IGNORE: Array<string | RegExp> = [\n  'node-module-in-edge-runtime',\n  'Edge Instrumentation',\n  'https://nextjs.org/docs/messages/node-module-in-edge-runtime',\n  'https://nextjs.org/docs/api-reference/edge-runtime',\n  'Ecmascript file had an error',\n  'A Node.js module is loaded',\n  'A Node.js API is used',\n  'not supported in the Edge Runtime',\n  'not supported inthe Edge Runtime',\n  'Import trace:',\n]\n\n/**\n * Configuration for {@link createInstrumentation} and {@link defineNodeInstrumentation}.\n * Controls global logger options and optional stdout/stderr capture (Node.js only).\n */\nexport interface InstrumentationOptions {\n  /** Enable or disable all logging globally. @default true */\n  enabled?: boolean\n  /** Service name for all logged events. */\n  service?: string\n  /** Environment context overrides. */\n  env?: Partial<EnvironmentContext>\n  /** Enable pretty printing. @default true in development */\n  pretty?: boolean\n  /** Suppress built-in console output. @default false */\n  silent?: boolean\n  /** Sampling configuration for filtering logs. */\n  sampling?: SamplingConfig\n  /** Minimum severity for the global `log` API. @default 'debug' */\n  minLevel?: LogLevel\n  /** When pretty is disabled, emit JSON strings or raw objects. @default true */\n  stringify?: boolean\n  /** Drain callback called with every emitted event. */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /** Capture stdout/stderr as structured log events (Node.js only). */\n  captureOutput?: boolean | CaptureOutputOptions\n}\n\ninterface InstrumentationResult {\n  register: () => void | Promise<void>\n  onRequestError: (\n    error: { digest?: string } & Error,\n    request: NextInstrumentationRequest,\n    context: NextInstrumentationErrorContext,\n  ) => void | Promise<void>\n}\n\nlet patching = false\nlet loggerPromise: Promise<LoggerModule> | undefined\nlet stdoutPatched = false\nlet stderrPatched = false\nlet activeCaptureOutput:\n  | {\n      log: Log\n      ignore: Array<string | RegExp>\n      stdout: boolean\n      stderr: boolean\n      silent: boolean\n    }\n  | undefined\n\nfunction loadLogger(): Promise<LoggerModule> {\n  loggerPromise ??= import('../logger')\n  return loggerPromise\n}\n\nfunction resolveCaptureOutputOptions(\n  captureOutput: InstrumentationOptions['captureOutput'],\n): CaptureOutputOptions | undefined {\n  if (!captureOutput) return undefined\n  if (captureOutput === true) {\n    return { stdout: true, stderr: true, ignore: DEFAULT_CAPTURE_OUTPUT_IGNORE }\n  }\n  return {\n    stdout: captureOutput.stdout ?? true,\n    stderr: captureOutput.stderr ?? true,\n    ignore: captureOutput.ignore ?? DEFAULT_CAPTURE_OUTPUT_IGNORE,\n  }\n}\n\nfunction shouldIgnoreCapturedOutput(message: string, ignore: Array<string | RegExp>): boolean {\n  return ignore.some((pattern) => {\n    if (typeof pattern === 'string') return message.includes(pattern)\n    return pattern.test(message)\n  })\n}\n\nfunction applyCaptureOutput(config: CaptureOutputOptions, logApi: Log, silent: boolean): void {\n  activeCaptureOutput = {\n    log: logApi,\n    ignore: config.ignore ?? DEFAULT_CAPTURE_OUTPUT_IGNORE,\n    stdout: config.stdout !== false,\n    stderr: config.stderr !== false,\n    silent,\n  }\n\n  const proc = globalThis.process\n\n  if (activeCaptureOutput.stdout && !stdoutPatched) {\n    const originalStdoutWrite = proc.stdout.write.bind(proc.stdout)\n    ;(globalThis as EvlogProcessOutputGlobal).__evlogNativeStdoutWrite = originalStdoutWrite\n    stdoutPatched = true\n    proc.stdout.write = function(chunk: unknown, ...args: unknown[]): boolean {\n      const message = String(chunk).trimEnd()\n      const active = activeCaptureOutput\n      if (\n        !patching\n        && message.length > 0\n        && active?.stdout\n        && !shouldIgnoreCapturedOutput(message, active.ignore)\n      ) {\n        patching = true\n        try {\n          active.log.info({ source: 'stdout', message })\n        } finally {\n          patching = false\n        }\n        if (!active.silent) {\n          return true\n        }\n      }\n      return originalStdoutWrite(chunk as string, ...args as [])\n    } as typeof process.stdout.write\n  }\n\n  if (activeCaptureOutput.stderr && !stderrPatched) {\n    const originalStderrWrite = proc.stderr.write.bind(proc.stderr)\n    stderrPatched = true\n    proc.stderr.write = function(chunk: unknown, ...args: unknown[]): boolean {\n      const message = String(chunk).trimEnd()\n      const active = activeCaptureOutput\n      if (\n        !patching\n        && message.length > 0\n        && active?.stderr\n        && !shouldIgnoreCapturedOutput(message, active.ignore)\n      ) {\n        patching = true\n        try {\n          active.log.error({ source: 'stderr', message })\n        } finally {\n          patching = false\n        }\n        if (!active.silent) {\n          return true\n        }\n      }\n      return originalStderrWrite(chunk as string, ...args as [])\n    } as typeof process.stderr.write\n  }\n}\n\n/**\n * Create Next.js instrumentation hooks (`register`, `onRequestError`).\n *\n * Load via dynamic `import()` from root `instrumentation.ts` (Node.js runtime only).\n * Load via dynamic `import()` from root `instrumentation.ts` with {@link defineNodeInstrumentation}.\n */\nexport function createInstrumentation(options: InstrumentationOptions = {}): InstrumentationResult {\n  let registered = false\n  let registerPromise: Promise<void> | undefined\n  const captureOutputOptions = resolveCaptureOutputOptions(options.captureOutput)\n\n  function register(): void | Promise<void> {\n    if (registered) return\n    if (registerPromise) return registerPromise\n\n    registerPromise = loadLogger().then(async ({ initLogger, lockLogger, log }) => {\n      initLogger({\n        enabled: options.enabled,\n        env: {\n          service: options.service,\n          ...options.env,\n        },\n        pretty: options.pretty,\n        silent: options.silent,\n        sampling: options.sampling,\n        minLevel: options.minLevel,\n        stringify: options.stringify,\n        drain: options.drain,\n      })\n      lockLogger()\n      if (process.env.NEXT_RUNTIME === 'nodejs') {\n        await registerDiskPrettyErrorSnippetReader()\n      }\n\n      if (captureOutputOptions && process.env.NEXT_RUNTIME === 'nodejs') {\n        applyCaptureOutput(captureOutputOptions, log, options.silent ?? false)\n      }\n      registered = true\n    }).catch((error) => {\n      registerPromise = undefined\n      throw error\n    })\n    return registerPromise\n  }\n\n  function onRequestError(\n    error: { digest?: string } & Error,\n    request: { path: string; method: string; headers: Record<string, string> },\n    context: { routerKind: string; routePath: string; routeType: string; renderSource: string },\n  ): void | Promise<void> {\n    return loadLogger().then(({ log }) => {\n      log.error({\n        message: error.message,\n        digest: error.digest,\n        stack: error.stack,\n        path: request.path,\n        method: request.method,\n        routerKind: context.routerKind,\n        routePath: context.routePath,\n        routeType: context.routeType,\n        renderSource: context.renderSource,\n      })\n    })\n  }\n\n  return { register, onRequestError }\n}\n"],"mappings":"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"}

package/dist/next/instrumentation.d.mts

@@ -1,2 +1,2 @@
-import { a as DefineNodeInstrumentationInput, c as NodeInstrumentationHooks, l as NodeInstrumentationModule, o as NextInstrumentationErrorContext, r as InstrumentationOptions, s as NextInstrumentationRequest, t as CaptureOutputOptions, u as defineNodeInstrumentation } from "../instrumentation-create-BrjQtSKD.mjs";
+import { a as DefineNodeInstrumentationInput, c as NodeInstrumentationHooks, l as NodeInstrumentationModule, o as NextInstrumentationErrorContext, r as InstrumentationOptions, s as NextInstrumentationRequest, t as CaptureOutputOptions, u as defineNodeInstrumentation } from "../instrumentation-create-STGmQGQt.mjs";
 export { type CaptureOutputOptions, type DefineNodeInstrumentationInput, type InstrumentationOptions, type NextInstrumentationErrorContext, type NextInstrumentationRequest, type NodeInstrumentationHooks, type NodeInstrumentationModule, defineNodeInstrumentation };

package/dist/next/stream.d.mts

@@ -1,4 +1,4 @@
-import { i as createInstrumentation, r as InstrumentationOptions } from "../instrumentation-create-BrjQtSKD.mjs";
+import { i as createInstrumentation, r as InstrumentationOptions } from "../instrumentation-create-STGmQGQt.mjs";
 import { StreamServerOptions } from "../stream.mjs";
 
 //#region src/next/stream.d.ts

package/dist/nitro/errorHandler.mjs

@@ -1,6 +1,6 @@
 import { t as extractErrorStatus } from "../errors-DA0cyr8q.mjs";
-import { a as serializeEvlogErrorResponse, i as resolveEvlogError, n as markH3ErrorHandled, o as shouldSuppressNitroDevOverlay, s as suppressNitroDevOverlay, t as buildPlainNitroErrorBody } from "../nitro-ClRZLD1g.mjs";
-import { getRequestURL, setResponseHeader, setResponseStatus } from "h3";
+import { a as serializeEvlogErrorResponse, c as suppressNitroDevOverlay, i as resolveEvlogError, n as markH3ErrorHandled, o as shouldSerializeNitroErrorAsJson, s as shouldSuppressNitroDevOverlay, t as buildPlainNitroErrorBody } from "../nitro-ClHmVj1H.mjs";
+import { getRequestHeader, getRequestURL, setResponseHeader, setResponseStatus } from "h3";
 import { defineNitroErrorHandler } from "nitropack/runtime/internal/error/utils";
 //#region src/nitro/errorHandler.ts
 /**
@@ -23,13 +23,18 @@ function endNodeResponse(event, body) {
 * sanitizing internal error details in production for 5xx errors.
 */
 var errorHandler_default = defineNitroErrorHandler(async (error, event, ctx) => {
+	const evlogError = resolveEvlogError(error);
+	const requestUrl = getRequestURL(event, { xForwardedHost: true });
+	if (!shouldSerializeNitroErrorAsJson({
+		pathname: requestUrl.pathname,
+		getHeader: (name) => getRequestHeader(event, name)
+	}, evlogError)) return;
 	const suppressOverlay = shouldSuppressNitroDevOverlay();
 	if (!suppressOverlay && ctx?.defaultHandler) await ctx.defaultHandler(error, event, { silent: false });
 	markH3ErrorHandled(event);
 	if (suppressOverlay) suppressNitroDevOverlay(error);
-	const evlogError = resolveEvlogError(error);
 	const isDev = process.env.NODE_ENV === "development";
-	const url = getRequestURL(event, { xForwardedHost: true }).pathname;
+	const url = requestUrl.pathname;
 	if (!evlogError) {
 		const body = buildPlainNitroErrorBody(error, url, isDev);
 		setResponseStatus(event, body.status);

package/dist/nitro/errorHandler.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"errorHandler.mjs","names":[],"sources":["../../src/nitro/errorHandler.ts"],"sourcesContent":["// Import from specific subpath — the barrel 'nitropack/runtime' re-exports from\n// internal/app.mjs which imports virtual modules that crash outside rollup builds.\nimport { defineNitroErrorHandler } from 'nitropack/runtime/internal/error/utils'\nimport { getRequestURL, setResponseHeader, setResponseStatus } from 'h3'\nimport type { H3Event } from 'h3'\nimport {\n  resolveEvlogError,\n  extractErrorStatus,\n  buildPlainNitroErrorBody,\n  serializeEvlogErrorResponse,\n  markH3ErrorHandled,\n  shouldSuppressNitroDevOverlay,\n  suppressNitroDevOverlay,\n} from '../nitro'\n\n/**\n * Flush the error response by ending the Node response directly.\n *\n * h3 v1's `send()` is a no-op once the event is marked handled, and the event\n * must be marked handled *before* responding so Nitro's chained dev handler\n * (Youch overlay) does not run after us. Ending the Node response directly\n * resolves that tension: the flush is synchronous and unconditional (#374).\n */\nfunction endNodeResponse(event: H3Event, body: string): void {\n  if (!event.node.res.writableEnded) {\n    event.node.res.end(body)\n  }\n}\n\n/**\n * Custom Nitro error handler that properly serializes EvlogError.\n * This ensures that 'data' (containing 'why', 'fix', 'link') is preserved\n * in the JSON response regardless of the underlying HTTP framework.\n *\n * For non-EvlogError, it preserves Nitro's default response shape while\n * sanitizing internal error details in production for 5xx errors.\n */\nexport default defineNitroErrorHandler(async (error, event, ctx) => {\n  const suppressOverlay = shouldSuppressNitroDevOverlay()\n\n  // Nitro v2 always passes `ctx`, but a missing context (e.g. the handler\n  // invoked directly) must degrade to a flushed response, not a crash.\n  if (!suppressOverlay && ctx?.defaultHandler) {\n    await ctx.defaultHandler(error, event, { silent: false })\n  }\n\n  markH3ErrorHandled(event)\n  if (suppressOverlay) {\n    suppressNitroDevOverlay(error)\n  }\n\n  const evlogError = resolveEvlogError(error)\n\n  const isDev = process.env.NODE_ENV === 'development'\n  const url = getRequestURL(event, { xForwardedHost: true }).pathname\n\n  if (!evlogError) {\n    const body = buildPlainNitroErrorBody(error, url, isDev)\n    setResponseStatus(event, body.status as number)\n    setResponseHeader(event, 'Content-Type', 'application/json')\n    return endNodeResponse(event, JSON.stringify(body))\n  }\n\n  const status = extractErrorStatus(evlogError)\n\n  setResponseStatus(event, status)\n  setResponseHeader(event, 'Content-Type', 'application/json')\n\n  return endNodeResponse(event, JSON.stringify(serializeEvlogErrorResponse(evlogError, url)))\n})\n"],"mappings":";;;;;;;;;;;;;AAuBA,SAAS,gBAAgB,OAAgB,MAAoB;AAC3D,KAAI,CAAC,MAAM,KAAK,IAAI,cAClB,OAAM,KAAK,IAAI,IAAI,KAAK;;;;;;;;;;AAY5B,IAAA,uBAAe,wBAAwB,OAAO,OAAO,OAAO,QAAQ;CAClE,MAAM,kBAAkB,+BAA+B;AAIvD,KAAI,CAAC,mBAAmB,KAAK,eAC3B,OAAM,IAAI,eAAe,OAAO,OAAO,EAAE,QAAQ,OAAO,CAAC;AAG3D,oBAAmB,MAAM;AACzB,KAAI,gBACF,yBAAwB,MAAM;CAGhC,MAAM,aAAa,kBAAkB,MAAM;CAE3C,MAAM,QAAQ,QAAQ,IAAI,aAAa;CACvC,MAAM,MAAM,cAAc,OAAO,EAAE,gBAAgB,MAAM,CAAC,CAAC;AAE3D,KAAI,CAAC,YAAY;EACf,MAAM,OAAO,yBAAyB,OAAO,KAAK,MAAM;AACxD,oBAAkB,OAAO,KAAK,OAAiB;AAC/C,oBAAkB,OAAO,gBAAgB,mBAAmB;AAC5D,SAAO,gBAAgB,OAAO,KAAK,UAAU,KAAK,CAAC;;AAKrD,mBAAkB,OAFH,mBAAmB,WAEH,CAAC;AAChC,mBAAkB,OAAO,gBAAgB,mBAAmB;AAE5D,QAAO,gBAAgB,OAAO,KAAK,UAAU,4BAA4B,YAAY,IAAI,CAAC,CAAC;EAC3F"}
+{"version":3,"file":"errorHandler.mjs","names":[],"sources":["../../src/nitro/errorHandler.ts"],"sourcesContent":["// Import from specific subpath — the barrel 'nitropack/runtime' re-exports from\n// internal/app.mjs which imports virtual modules that crash outside rollup builds.\nimport { defineNitroErrorHandler } from 'nitropack/runtime/internal/error/utils'\nimport { getRequestHeader, getRequestURL, setResponseHeader, setResponseStatus } from 'h3'\nimport type { H3Event } from 'h3'\nimport {\n  resolveEvlogError,\n  extractErrorStatus,\n  buildPlainNitroErrorBody,\n  serializeEvlogErrorResponse,\n  markH3ErrorHandled,\n  shouldSerializeNitroErrorAsJson,\n  shouldSuppressNitroDevOverlay,\n  suppressNitroDevOverlay,\n} from '../nitro'\n\n/**\n * Flush the error response by ending the Node response directly.\n *\n * h3 v1's `send()` is a no-op once the event is marked handled, and the event\n * must be marked handled *before* responding so Nitro's chained dev handler\n * (Youch overlay) does not run after us. Ending the Node response directly\n * resolves that tension: the flush is synchronous and unconditional (#374).\n */\nfunction endNodeResponse(event: H3Event, body: string): void {\n  if (!event.node.res.writableEnded) {\n    event.node.res.end(body)\n  }\n}\n\n/**\n * Custom Nitro error handler that properly serializes EvlogError.\n * This ensures that 'data' (containing 'why', 'fix', 'link') is preserved\n * in the JSON response regardless of the underlying HTTP framework.\n *\n * For non-EvlogError, it preserves Nitro's default response shape while\n * sanitizing internal error details in production for 5xx errors.\n */\nexport default defineNitroErrorHandler(async (error, event, ctx) => {\n  const evlogError = resolveEvlogError(error)\n  const requestUrl = getRequestURL(event, { xForwardedHost: true })\n\n  if (!shouldSerializeNitroErrorAsJson({\n    pathname: requestUrl.pathname,\n    getHeader: name => getRequestHeader(event, name),\n  }, evlogError)) {\n    return\n  }\n\n  const suppressOverlay = shouldSuppressNitroDevOverlay()\n\n  // Nitro v2 always passes `ctx`, but a missing context (e.g. the handler\n  // invoked directly) must degrade to a flushed response, not a crash.\n  if (!suppressOverlay && ctx?.defaultHandler) {\n    await ctx.defaultHandler(error, event, { silent: false })\n  }\n\n  markH3ErrorHandled(event)\n  if (suppressOverlay) {\n    suppressNitroDevOverlay(error)\n  }\n\n  const isDev = process.env.NODE_ENV === 'development'\n  const url = requestUrl.pathname\n\n  if (!evlogError) {\n    const body = buildPlainNitroErrorBody(error, url, isDev)\n    setResponseStatus(event, body.status as number)\n    setResponseHeader(event, 'Content-Type', 'application/json')\n    return endNodeResponse(event, JSON.stringify(body))\n  }\n\n  const status = extractErrorStatus(evlogError)\n\n  setResponseStatus(event, status)\n  setResponseHeader(event, 'Content-Type', 'application/json')\n\n  return endNodeResponse(event, JSON.stringify(serializeEvlogErrorResponse(evlogError, url)))\n})\n"],"mappings":";;;;;;;;;;;;;AAwBA,SAAS,gBAAgB,OAAgB,MAAoB;AAC3D,KAAI,CAAC,MAAM,KAAK,IAAI,cAClB,OAAM,KAAK,IAAI,IAAI,KAAK;;;;;;;;;;AAY5B,IAAA,uBAAe,wBAAwB,OAAO,OAAO,OAAO,QAAQ;CAClE,MAAM,aAAa,kBAAkB,MAAM;CAC3C,MAAM,aAAa,cAAc,OAAO,EAAE,gBAAgB,MAAM,CAAC;AAEjE,KAAI,CAAC,gCAAgC;EACnC,UAAU,WAAW;EACrB,YAAW,SAAQ,iBAAiB,OAAO,KAAK;EACjD,EAAE,WAAW,CACZ;CAGF,MAAM,kBAAkB,+BAA+B;AAIvD,KAAI,CAAC,mBAAmB,KAAK,eAC3B,OAAM,IAAI,eAAe,OAAO,OAAO,EAAE,QAAQ,OAAO,CAAC;AAG3D,oBAAmB,MAAM;AACzB,KAAI,gBACF,yBAAwB,MAAM;CAGhC,MAAM,QAAQ,QAAQ,IAAI,aAAa;CACvC,MAAM,MAAM,WAAW;AAEvB,KAAI,CAAC,YAAY;EACf,MAAM,OAAO,yBAAyB,OAAO,KAAK,MAAM;AACxD,oBAAkB,OAAO,KAAK,OAAiB;AAC/C,oBAAkB,OAAO,gBAAgB,mBAAmB;AAC5D,SAAO,gBAAgB,OAAO,KAAK,UAAU,KAAK,CAAC;;AAKrD,mBAAkB,OAFH,mBAAmB,WAEH,CAAC;AAChC,mBAAkB,OAAO,gBAAgB,mBAAmB;AAE5D,QAAO,gBAAgB,OAAO,KAAK,UAAU,4BAA4B,YAAY,IAAI,CAAC,CAAC;EAC3F"}

package/dist/nitro/module.d.mts

@@ -1,5 +1,5 @@
-import { t as useLogger } from "../useLogger-Cfv8Ck8b.mjs";
-import { t as NitroModuleOptions } from "../nitro-_Hda8Deo.mjs";
+import { t as useLogger } from "../useLogger-DiRWGD33.mjs";
+import { t as NitroModuleOptions } from "../nitro--E4op34w.mjs";
 import { Nitro } from "nitropack";
 
 //#region src/nitro/module.d.ts

package/dist/nitro/module.mjs

@@ -1,5 +1,5 @@
 import { useLogger } from "../runtime/server/useLogger.mjs";
-import { r as prependNitroErrorHandler } from "../nitro-ClRZLD1g.mjs";
+import { r as prependNitroErrorHandler } from "../nitro-ClHmVj1H.mjs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/nitro/module.ts

package/dist/nitro/plugin.mjs

@@ -1,6 +1,6 @@
 import { n as readCodeSnippetFromDisk } from "../pretty-error-snippet.node-itfCajBM.mjs";
 import { filterSafeHeaders } from "../utils.mjs";
-import { N as normalizeRedactConfig, b as initLogger, g as createRequestLogger, x as isEnabled, y as getGlobalPluginRunner } from "../audit-BQt8yAHo.mjs";
+import { P as normalizeRedactConfig, S as isEnabled, _ as createRequestLogger, b as getGlobalPluginRunner, x as initLogger } from "../audit-CL0q7GJU.mjs";
 import { o as registerPrettyErrorSnippetReader } from "../pretty-error-THg0U0w9.mjs";
 import { t as extractErrorStatus } from "../errors-DA0cyr8q.mjs";
 import { i as setActiveNitroRuntime, r as resolveEvlogConfigForNitroPlugin } from "../nitroConfigBridge-BkVWnSV3.mjs";

package/dist/nitro/v3/errorHandler.d.mts

@@ -1,16 +1,6 @@
 import * as _$nitro_types0 from "nitro/types";
 
 //#region src/nitro-v3/errorHandler.d.ts
-/**
- * Custom Nitro v3 error handler that properly serializes EvlogError.
- * This ensures that 'data' (containing 'why', 'fix', 'link') is preserved
- * in the JSON response regardless of the underlying HTTP framework.
- *
- * Usage in nitro.config.ts:
- * ```ts
- * export { default } from 'evlog/nitro/v3/errorHandler'
- * ```
- */
 declare const _default: _$nitro_types0.NitroErrorHandler;
 //#endregion
 export { _default as default };

package/dist/nitro/v3/errorHandler.mjs

@@ -1,5 +1,5 @@
 import { t as extractErrorStatus } from "../../errors-DA0cyr8q.mjs";
-import { a as serializeEvlogErrorResponse, i as resolveEvlogError, n as markH3ErrorHandled, o as shouldSuppressNitroDevOverlay, s as suppressNitroDevOverlay, t as buildPlainNitroErrorBody } from "../../nitro-ClRZLD1g.mjs";
+import { a as serializeEvlogErrorResponse, c as suppressNitroDevOverlay, i as resolveEvlogError, n as markH3ErrorHandled, o as shouldSerializeNitroErrorAsJson, s as shouldSuppressNitroDevOverlay, t as buildPlainNitroErrorBody } from "../../nitro-ClHmVj1H.mjs";
 import { t as parseURL } from "../../dist-DdQWiZn8.mjs";
 import { defineErrorHandler } from "nitro";
 //#region src/nitro-v3/errorHandler.ts
@@ -13,14 +13,24 @@ import { defineErrorHandler } from "nitro";
 * export { default } from 'evlog/nitro/v3/errorHandler'
 * ```
 */
+function getNitroV3RequestHeader(headers, name) {
+	if (headers instanceof Headers) return headers.get(name) ?? void 0;
+	const value = headers[name.toLowerCase()] ?? headers[name];
+	return Array.isArray(value) ? value[0] : value;
+}
 var errorHandler_default = defineErrorHandler(async (error, event, ctx) => {
+	const evlogError = resolveEvlogError(error);
+	const requestUrl = parseURL(event.req.url);
+	if (!shouldSerializeNitroErrorAsJson({
+		pathname: requestUrl.pathname,
+		getHeader: (name) => getNitroV3RequestHeader(event.req.headers, name)
+	}, evlogError)) return;
 	const suppressOverlay = shouldSuppressNitroDevOverlay();
 	if (!suppressOverlay) await ctx.defaultHandler(error, event, { silent: false });
 	markH3ErrorHandled(event);
 	if (suppressOverlay) suppressNitroDevOverlay(error);
-	const url = parseURL(event.req.url).pathname;
+	const url = requestUrl.pathname;
 	const isDev = process.env.NODE_ENV === "development";
-	const evlogError = resolveEvlogError(error);
 	const body = evlogError ? serializeEvlogErrorResponse(evlogError, url) : buildPlainNitroErrorBody(error, url, isDev);
 	const status = extractErrorStatus(evlogError ?? error);
 	return new Response(JSON.stringify(body), {

package/dist/nitro/v3/errorHandler.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"errorHandler.mjs","names":[],"sources":["../../../src/nitro-v3/errorHandler.ts"],"sourcesContent":["import { parseURL } from 'ufo'\nimport { defineErrorHandler } from 'nitro'\nimport {\n  resolveEvlogError,\n  extractErrorStatus,\n  buildPlainNitroErrorBody,\n  serializeEvlogErrorResponse,\n  shouldSuppressNitroDevOverlay,\n  suppressNitroDevOverlay,\n  markH3ErrorHandled,\n} from '../nitro'\nimport type { NitroErrorHandlerContext } from '../shared/nitro-types'\n\n/**\n * Custom Nitro v3 error handler that properly serializes EvlogError.\n * This ensures that 'data' (containing 'why', 'fix', 'link') is preserved\n * in the JSON response regardless of the underlying HTTP framework.\n *\n * Usage in nitro.config.ts:\n * ```ts\n * export { default } from 'evlog/nitro/v3/errorHandler'\n * ```\n */\nexport default defineErrorHandler(async (error, event, ctx: NitroErrorHandlerContext) => {\n  const suppressOverlay = shouldSuppressNitroDevOverlay()\n\n  if (!suppressOverlay) {\n    await ctx.defaultHandler(error, event, { silent: false })\n  }\n\n  markH3ErrorHandled(event)\n\n  if (suppressOverlay) {\n    suppressNitroDevOverlay(error)\n  }\n\n  const url = parseURL(event.req.url).pathname\n  const isDev = process.env.NODE_ENV === 'development'\n  const evlogError = resolveEvlogError(error)\n\n  const body = evlogError\n    ? serializeEvlogErrorResponse(evlogError, url)\n    : buildPlainNitroErrorBody(error, url, isDev)\n  const status = extractErrorStatus(evlogError ?? error)\n\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: { 'Content-Type': 'application/json' },\n  })\n})\n"],"mappings":";;;;;;;;;;;;;;;AAuBA,IAAA,uBAAe,mBAAmB,OAAO,OAAO,OAAO,QAAkC;CACvF,MAAM,kBAAkB,+BAA+B;AAEvD,KAAI,CAAC,gBACH,OAAM,IAAI,eAAe,OAAO,OAAO,EAAE,QAAQ,OAAO,CAAC;AAG3D,oBAAmB,MAAM;AAEzB,KAAI,gBACF,yBAAwB,MAAM;CAGhC,MAAM,MAAM,SAAS,MAAM,IAAI,IAAI,CAAC;CACpC,MAAM,QAAQ,QAAQ,IAAI,aAAa;CACvC,MAAM,aAAa,kBAAkB,MAAM;CAE3C,MAAM,OAAO,aACT,4BAA4B,YAAY,IAAI,GAC5C,yBAAyB,OAAO,KAAK,MAAM;CAC/C,MAAM,SAAS,mBAAmB,cAAc,MAAM;AAEtD,QAAO,IAAI,SAAS,KAAK,UAAU,KAAK,EAAE;EACxC;EACA,SAAS,EAAE,gBAAgB,oBAAoB;EAChD,CAAC;EACF"}
+{"version":3,"file":"errorHandler.mjs","names":[],"sources":["../../../src/nitro-v3/errorHandler.ts"],"sourcesContent":["import { parseURL } from 'ufo'\nimport { defineErrorHandler } from 'nitro'\nimport {\n  resolveEvlogError,\n  extractErrorStatus,\n  buildPlainNitroErrorBody,\n  serializeEvlogErrorResponse,\n  shouldSerializeNitroErrorAsJson,\n  shouldSuppressNitroDevOverlay,\n  suppressNitroDevOverlay,\n  markH3ErrorHandled,\n} from '../nitro'\nimport type { NitroErrorHandlerContext } from '../shared/nitro-types'\n\n/**\n * Custom Nitro v3 error handler that properly serializes EvlogError.\n * This ensures that 'data' (containing 'why', 'fix', 'link') is preserved\n * in the JSON response regardless of the underlying HTTP framework.\n *\n * Usage in nitro.config.ts:\n * ```ts\n * export { default } from 'evlog/nitro/v3/errorHandler'\n * ```\n */\nfunction getNitroV3RequestHeader(\n  headers: Headers | Record<string, string | string[] | undefined>,\n  name: string,\n): string | undefined {\n  if (headers instanceof Headers) {\n    return headers.get(name) ?? undefined\n  }\n  const lower = name.toLowerCase()\n  const value = headers[lower] ?? headers[name]\n  return Array.isArray(value) ? value[0] : value\n}\n\nexport default defineErrorHandler(async (error, event, ctx: NitroErrorHandlerContext) => {\n  const evlogError = resolveEvlogError(error)\n  const requestUrl = parseURL(event.req.url)\n\n  if (!shouldSerializeNitroErrorAsJson({\n    pathname: requestUrl.pathname,\n    getHeader: name => getNitroV3RequestHeader(event.req.headers, name),\n  }, evlogError)) {\n    return\n  }\n\n  const suppressOverlay = shouldSuppressNitroDevOverlay()\n\n  if (!suppressOverlay) {\n    await ctx.defaultHandler(error, event, { silent: false })\n  }\n\n  markH3ErrorHandled(event)\n\n  if (suppressOverlay) {\n    suppressNitroDevOverlay(error)\n  }\n\n  const url = requestUrl.pathname\n  const isDev = process.env.NODE_ENV === 'development'\n\n  const body = evlogError\n    ? serializeEvlogErrorResponse(evlogError, url)\n    : buildPlainNitroErrorBody(error, url, isDev)\n  const status = extractErrorStatus(evlogError ?? error)\n\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: { 'Content-Type': 'application/json' },\n  })\n})\n"],"mappings":";;;;;;;;;;;;;;;AAwBA,SAAS,wBACP,SACA,MACoB;AACpB,KAAI,mBAAmB,QACrB,QAAO,QAAQ,IAAI,KAAK,IAAI,KAAA;CAG9B,MAAM,QAAQ,QADA,KAAK,aACQ,KAAK,QAAQ;AACxC,QAAO,MAAM,QAAQ,MAAM,GAAG,MAAM,KAAK;;AAG3C,IAAA,uBAAe,mBAAmB,OAAO,OAAO,OAAO,QAAkC;CACvF,MAAM,aAAa,kBAAkB,MAAM;CAC3C,MAAM,aAAa,SAAS,MAAM,IAAI,IAAI;AAE1C,KAAI,CAAC,gCAAgC;EACnC,UAAU,WAAW;EACrB,YAAW,SAAQ,wBAAwB,MAAM,IAAI,SAAS,KAAK;EACpE,EAAE,WAAW,CACZ;CAGF,MAAM,kBAAkB,+BAA+B;AAEvD,KAAI,CAAC,gBACH,OAAM,IAAI,eAAe,OAAO,OAAO,EAAE,QAAQ,OAAO,CAAC;AAG3D,oBAAmB,MAAM;AAEzB,KAAI,gBACF,yBAAwB,MAAM;CAGhC,MAAM,MAAM,WAAW;CACvB,MAAM,QAAQ,QAAQ,IAAI,aAAa;CAEvC,MAAM,OAAO,aACT,4BAA4B,YAAY,IAAI,GAC5C,yBAAyB,OAAO,KAAK,MAAM;CAC/C,MAAM,SAAS,mBAAmB,cAAc,MAAM;AAEtD,QAAO,IAAI,SAAS,KAAK,UAAU,KAAK,EAAE;EACxC;EACA,SAAS,EAAE,gBAAgB,oBAAoB;EAChD,CAAC;EACF"}

package/dist/nitro/v3/index.d.mts

@@ -1,5 +1,5 @@
-import { n as createError, t as EvlogError } from "../../error-CpghjrkY.mjs";
-import { t as parseError } from "../../parseError-BeBXEd2V.mjs";
+import { n as createError, t as EvlogError } from "../../error-CPCM5a1D.mjs";
+import { t as parseError } from "../../parseError-BwBg-iW4.mjs";
 import evlog from "./module.mjs";
 import { useLogger } from "./useLogger.mjs";
 import { evlogErrorHandler } from "./middleware.mjs";

package/dist/nitro/v3/module.d.mts

@@ -1,4 +1,4 @@
-import { t as NitroModuleOptions } from "../../nitro-_Hda8Deo.mjs";
+import { t as NitroModuleOptions } from "../../nitro--E4op34w.mjs";
 import { Nitro } from "nitro/types";
 
 //#region src/nitro-v3/module.d.ts

package/dist/nitro/v3/module.mjs

@@ -1,4 +1,4 @@
-import { r as prependNitroErrorHandler } from "../../nitro-ClRZLD1g.mjs";
+import { r as prependNitroErrorHandler } from "../../nitro-ClHmVj1H.mjs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/nitro-v3/module.ts

package/dist/nitro/v3/plugin.mjs

@@ -1,6 +1,6 @@
 import { n as readCodeSnippetFromDisk } from "../../pretty-error-snippet.node-itfCajBM.mjs";
 import { filterSafeHeaders } from "../../utils.mjs";
-import { N as normalizeRedactConfig, b as initLogger, g as createRequestLogger, w as markWideEventDrainStarted, x as isEnabled, y as getGlobalPluginRunner } from "../../audit-BQt8yAHo.mjs";
+import { P as normalizeRedactConfig, S as isEnabled, T as markWideEventDrainStarted, _ as createRequestLogger, b as getGlobalPluginRunner, x as initLogger } from "../../audit-CL0q7GJU.mjs";
 import { o as registerPrettyErrorSnippetReader } from "../../pretty-error-THg0U0w9.mjs";
 import { t as extractErrorStatus } from "../../errors-DA0cyr8q.mjs";
 import { i as setActiveNitroRuntime, r as resolveEvlogConfigForNitroPlugin } from "../../nitroConfigBridge-BkVWnSV3.mjs";

package/dist/nitro/v3/useLogger.d.mts

@@ -1,4 +1,4 @@
-import { rt as RequestLogger } from "../../audit-D7v6JHj0.mjs";
+import { l as AuditableLogger } from "../../audit-CBfv3rl1.mjs";
 import { HTTPEvent } from "nitro/h3";
 
 //#region src/nitro-v3/useLogger.d.ts
@@ -18,7 +18,7 @@ import { HTTPEvent } from "nitro/h3";
  *   log.set({ foo: 'bar' })
  * })
  */
-declare function useLogger<T extends object = Record<string, unknown>>(event: HTTPEvent, service?: string): RequestLogger<T>;
+declare function useLogger<T extends object = Record<string, unknown>>(event: HTTPEvent, service?: string): AuditableLogger<T>;
 //#endregion
 export { useLogger };
 //# sourceMappingURL=useLogger.d.mts.map

package/dist/nitro/v3/useLogger.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"useLogger.d.mts","names":[],"sources":["../../../src/nitro-v3/useLogger.ts"],"mappings":";;;;;;AAmBA;;;;;;;;;;;;;;iBAAgB,SAAA,oBAA6B,MAAA,kBAAA,CAAyB,KAAA,EAAO,SAAA,EAAW,OAAA,YAAmB,aAAA,CAAc,CAAA"}
+{"version":3,"file":"useLogger.d.mts","names":[],"sources":["../../../src/nitro-v3/useLogger.ts"],"mappings":";;;;;;AAmBA;;;;;;;;;;;;;;iBAAgB,SAAA,oBAA6B,MAAA,kBAAA,CAAyB,KAAA,EAAO,SAAA,EAAW,OAAA,YAAmB,eAAA,CAAgB,CAAA"}

package/dist/nitro/v3/useLogger.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLogger.mjs","names":[],"sources":["../../../src/nitro-v3/useLogger.ts"],"sourcesContent":["import type { HTTPEvent } from 'nitro/h3'\nimport type { RequestLogger } from '../types'\n\n/**\n * Returns the request logger attached to the given Nitro v3 HTTP event.\n *\n * @param event - The current HTTPEvent from Nitro v3.\n * @param service - Optional service name to override the default service.\n * @returns The request-scoped logger.\n * @throws Error if the logger is not initialized on the event context.\n *\n * @example\n * import { useLogger } from 'evlog/nitro/v3'\n *\n * export default defineHandler((event) => {\n *   const log = useLogger(event)\n *   log.set({ foo: 'bar' })\n * })\n */\nexport function useLogger<T extends object = Record<string, unknown>>(event: HTTPEvent, service?: string): RequestLogger<T> {\n  const ctx = event.req.context as Record<string, unknown> | undefined\n  const log = ctx?.log as RequestLogger<T> | undefined\n\n  if (!log) {\n    throw new Error(\n      '[evlog] Logger not initialized. Make sure the evlog Nitro module is registered in nitro.config.ts. '\n      + 'Example: modules: [evlog({ env: { service: \\'my-app\\' } })]',\n    )\n  }\n\n  if (service) {\n    const untyped = log as unknown as RequestLogger\n    untyped.set({ service })\n  }\n\n  return log\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,SAAgB,UAAsD,OAAkB,SAAoC;CAE1H,MAAM,MADM,MAAM,IAAI,SACL;AAEjB,KAAI,CAAC,IACH,OAAM,IAAI,MACR,+JAED;AAGH,KAAI,QAEF,KAAQ,IAAI,EAAE,SAAS,CAAC;AAG1B,QAAO"}
+{"version":3,"file":"useLogger.mjs","names":[],"sources":["../../../src/nitro-v3/useLogger.ts"],"sourcesContent":["import type { HTTPEvent } from 'nitro/h3'\nimport type { AuditableLogger } from '../audit'\n\n/**\n * Returns the request logger attached to the given Nitro v3 HTTP event.\n *\n * @param event - The current HTTPEvent from Nitro v3.\n * @param service - Optional service name to override the default service.\n * @returns The request-scoped logger.\n * @throws Error if the logger is not initialized on the event context.\n *\n * @example\n * import { useLogger } from 'evlog/nitro/v3'\n *\n * export default defineHandler((event) => {\n *   const log = useLogger(event)\n *   log.set({ foo: 'bar' })\n * })\n */\nexport function useLogger<T extends object = Record<string, unknown>>(event: HTTPEvent, service?: string): AuditableLogger<T> {\n  const ctx = event.req.context as Record<string, unknown> | undefined\n  const log = ctx?.log as AuditableLogger<T> | undefined\n\n  if (!log) {\n    throw new Error(\n      '[evlog] Logger not initialized. Make sure the evlog Nitro module is registered in nitro.config.ts. '\n      + 'Example: modules: [evlog({ env: { service: \\'my-app\\' } })]',\n    )\n  }\n\n  if (service) {\n    log.set({ service })\n  }\n\n  return log\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,SAAgB,UAAsD,OAAkB,SAAsC;CAE5H,MAAM,MADM,MAAM,IAAI,SACL;AAEjB,KAAI,CAAC,IACH,OAAM,IAAI,MACR,+JAED;AAGH,KAAI,QACF,KAAI,IAAI,EAAE,SAAS,CAAC;AAGtB,QAAO"}

package/dist/{nitro-_Hda8Deo.d.mts → nitro--E4op34w.d.mts}

@@ -1,4 +1,4 @@
-import { $ as RedactConfig, H as EnvironmentContext, X as LogLevel, at as RouteConfig, ot as SamplingConfig, pt as DevTerminalInput } from "./audit-D7v6JHj0.mjs";
+import { $ as LogLevel, G as EnvironmentContext, ct as RouteConfig, gt as DevTerminalInput, lt as SamplingConfig, nt as RedactConfig } from "./audit-CBfv3rl1.mjs";
 //#region src/nitro.d.ts
 interface NitroModuleOptions {
   /**
@@ -62,4 +62,4 @@ interface NitroModuleOptions {
 }
 //#endregion
 export { NitroModuleOptions as t };
-//# sourceMappingURL=nitro-_Hda8Deo.d.mts.map
+//# sourceMappingURL=nitro--E4op34w.d.mts.map

package/dist/{nitro-_Hda8Deo.d.mts.map → nitro--E4op34w.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"nitro-_Hda8Deo.d.mts","names":[],"sources":["../src/nitro.ts"],"mappings":";;UAWiB,kBAAA;;;;;EAKf,OAAA;EA6CS;;;EAxCT,GAAA,GAAM,OAAA,CAAQ,kBAAA;EA0DiB;;;;EApD/B,MAAA;EANc;;;;EAYd,GAAA,GAAM,gBAAA;EAgBN;;;;;;;EAPA,MAAA;EA+BW;;;;;EAxBX,OAAA;;;;;;EAOA,OAAA;;;;EAKA,MAAA,GAAS,MAAA,SAAe,WAAA;;;;EAKxB,QAAA,GAAW,cAAA;;;;;;EAOX,QAAA,GAAW,QAAA;;;;;EAMX,MAAA,aAAmB,YAAA;AAAA"}
+{"version":3,"file":"nitro--E4op34w.d.mts","names":[],"sources":["../src/nitro.ts"],"mappings":";;UAWiB,kBAAA;;;;;EAKf,OAAA;EA6CS;;;EAxCT,GAAA,GAAM,OAAA,CAAQ,kBAAA;EA0DiB;;;;EApD/B,MAAA;EANc;;;;EAYd,GAAA,GAAM,gBAAA;EAgBN;;;;;;;EAPA,MAAA;EA+BW;;;;;EAxBX,OAAA;;;;;;EAOA,OAAA;;;;EAKA,MAAA,GAAS,MAAA,SAAe,WAAA;;;;EAKxB,QAAA,GAAW,cAAA;;;;;;EAOX,QAAA,GAAW,QAAA;;;;;EAMX,MAAA,aAAmB,YAAA;AAAA"}

package/dist/{nitro-ClRZLD1g.mjs → nitro-ClHmVj1H.mjs}

@@ -11,6 +11,33 @@ function resolveEvlogError(error) {
 	if (error.cause?.name === "EvlogError") return error.cause;
 	return null;
 }
+function acceptIncludes(accept, mediaType) {
+	return accept?.toLowerCase().includes(mediaType) ?? false;
+}
+function isNitroApiPath(pathname) {
+	return pathname === "/api" || pathname.startsWith("/api/");
+}
+/**
+* Whether evlog's Nitro error handler should flush a JSON body itself.
+*
+* Returns `false` for document/page requests so Nitro can delegate to the next
+* handler in the chain (e.g. Nuxt's `error.vue` renderer). EvlogError and API
+* routes always serialize as JSON.
+*
+* @internal
+*/
+function shouldSerializeNitroErrorAsJson(request, evlogError) {
+	if (evlogError) return true;
+	const { pathname, getHeader } = request;
+	if (isNitroApiPath(pathname)) return true;
+	if (getHeader("sec-fetch-dest") === "document") return false;
+	if (getHeader("sec-fetch-mode") === "navigate") return false;
+	const accept = getHeader("accept");
+	if (getHeader("x-requested-with")?.toLowerCase() === "xmlhttprequest") return true;
+	if (acceptIncludes(accept, "application/json") && !acceptIncludes(accept, "text/html")) return true;
+	if (acceptIncludes(accept, "text/html")) return false;
+	return true;
+}
 /**
 * Mark an h3 event handled synchronously.
 * Nitro chains a built-in dev handler after custom handlers; `send()` defers
@@ -91,6 +118,6 @@ function serializeEvlogErrorResponse(error, url) {
 	};
 }
 //#endregion
-export { serializeEvlogErrorResponse as a, resolveEvlogError as i, markH3ErrorHandled as n, shouldSuppressNitroDevOverlay as o, prependNitroErrorHandler as r, suppressNitroDevOverlay as s, buildPlainNitroErrorBody as t };
+export { serializeEvlogErrorResponse as a, suppressNitroDevOverlay as c, resolveEvlogError as i, markH3ErrorHandled as n, shouldSerializeNitroErrorAsJson as o, prependNitroErrorHandler as r, shouldSuppressNitroDevOverlay as s, buildPlainNitroErrorBody as t };
 
-//# sourceMappingURL=nitro-ClRZLD1g.mjs.map
+//# sourceMappingURL=nitro-ClHmVj1H.mjs.map