evlog 2.19.0 → 2.19.1

package/dist/instrumentation-create-BrjQtSKD.d.mts

@@ -0,0 +1,115 @@
+import { B as DrainContext, H as EnvironmentContext, X as LogLevel, ot as SamplingConfig } from "./audit-D7v6JHj0.mjs";
+
+//#region src/next/instrumentation-gate.d.ts
+/** Request payload passed to Next.js `onRequestError` (App Router). */
+interface NextInstrumentationRequest {
+  path: string;
+  method: string;
+  headers: Record<string, string>;
+}
+/** Routing context passed to Next.js `onRequestError`. */
+interface NextInstrumentationErrorContext {
+  routerKind: string;
+  routePath: string;
+  routeType: string;
+  renderSource: string;
+}
+/**
+ * What your instrumentation module should export for use with {@link defineNodeInstrumentation}
+ * (typically the return values of `createInstrumentation()` from `evlog/next/instrumentation/create`).
+ */
+interface NodeInstrumentationModule {
+  register: () => void | Promise<void>;
+  onRequestError: (error: {
+    digest?: string;
+  } & Error, request: NextInstrumentationRequest, context: NextInstrumentationErrorContext) => void | Promise<void>;
+}
+/**
+ * Hooks returned by {@link defineNodeInstrumentation} for root `instrumentation.ts`.
+ *
+ * - `register` — async startup hook; initializes the global logger on Node.js only.
+ * - `onRequestError` — logs SSR/RSC errors outside `withEvlog` via {@link NextInstrumentationRequest}
+ *   and {@link NextInstrumentationErrorContext}.
+ */
+type NodeInstrumentationHooks = {
+  /** Next.js instrumentation startup hook (Node.js runtime only). */register: () => Promise<void>; /** Next.js global request error handler (Node.js runtime only). */
+  onRequestError: (error: {
+    digest?: string;
+  } & Error, request: NextInstrumentationRequest, context: NextInstrumentationErrorContext) => Promise<void>;
+};
+/** Options for {@link defineNodeInstrumentation} or a custom Node-only module loader. */
+type DefineNodeInstrumentationInput = InstrumentationOptions | (() => Promise<NodeInstrumentationModule>);
+/**
+ * Root `instrumentation.ts` entry: load evlog only in the Node.js runtime so Edge bundles stay clean.
+ * Caches the dynamic `import()` so `register` and repeated `onRequestError` share one module instance.
+ *
+ * @example
+ * ```ts
+ * // instrumentation.ts
+ * import { defineNodeInstrumentation } from 'evlog/next/instrumentation'
+ *
+ * export const { register, onRequestError } = defineNodeInstrumentation({
+ *   service: 'my-app',
+ *   captureOutput: true,
+ * })
+ * ```
+ */
+declare function defineNodeInstrumentation(loaderOrOptions: DefineNodeInstrumentationInput): NodeInstrumentationHooks;
+//#endregion
+//#region src/next/instrumentation-create.d.ts
+/** Options for capturing process stdout/stderr as structured log events. */
+interface CaptureOutputOptions {
+  /** Capture stdout writes. @default true */
+  stdout?: boolean;
+  /** Capture stderr writes. @default true */
+  stderr?: boolean;
+  /**
+   * Skip re-emitting chunks that match these patterns as log events.
+   * When omitted, known Next.js Edge bundler warnings are ignored by default.
+   */
+  ignore?: Array<string | RegExp>;
+}
+/** Default patterns skipped by {@link CaptureOutputOptions.ignore}. */
+declare const DEFAULT_CAPTURE_OUTPUT_IGNORE: Array<string | RegExp>;
+/**
+ * Configuration for {@link createInstrumentation} and {@link defineNodeInstrumentation}.
+ * Controls global logger options and optional stdout/stderr capture (Node.js only).
+ */
+interface InstrumentationOptions {
+  /** Enable or disable all logging globally. @default true */
+  enabled?: boolean;
+  /** Service name for all logged events. */
+  service?: string;
+  /** Environment context overrides. */
+  env?: Partial<EnvironmentContext>;
+  /** Enable pretty printing. @default true in development */
+  pretty?: boolean;
+  /** Suppress built-in console output. @default false */
+  silent?: boolean;
+  /** Sampling configuration for filtering logs. */
+  sampling?: SamplingConfig;
+  /** Minimum severity for the global `log` API. @default 'debug' */
+  minLevel?: LogLevel;
+  /** When pretty is disabled, emit JSON strings or raw objects. @default true */
+  stringify?: boolean;
+  /** Drain callback called with every emitted event. */
+  drain?: (ctx: DrainContext) => void | Promise<void>;
+  /** Capture stdout/stderr as structured log events (Node.js only). */
+  captureOutput?: boolean | CaptureOutputOptions;
+}
+interface InstrumentationResult {
+  register: () => void | Promise<void>;
+  onRequestError: (error: {
+    digest?: string;
+  } & Error, request: NextInstrumentationRequest, context: NextInstrumentationErrorContext) => void | Promise<void>;
+}
+/**
+ * Create Next.js instrumentation hooks (`register`, `onRequestError`).
+ *
+ * Load via dynamic `import()` from root `instrumentation.ts` (Node.js runtime only).
+ * Load via dynamic `import()` from root `instrumentation.ts` with {@link defineNodeInstrumentation}.
+ */
+declare function createInstrumentation(options?: InstrumentationOptions): InstrumentationResult;
+//#endregion
+export { DefineNodeInstrumentationInput as a, NodeInstrumentationHooks as c, createInstrumentation as i, NodeInstrumentationModule as l, DEFAULT_CAPTURE_OUTPUT_IGNORE as n, NextInstrumentationErrorContext as o, InstrumentationOptions as r, NextInstrumentationRequest as s, CaptureOutputOptions as t, defineNodeInstrumentation as u };
+//# sourceMappingURL=instrumentation-create-BrjQtSKD.d.mts.map

package/dist/instrumentation-create-BrjQtSKD.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation-create-BrjQtSKD.d.mts","names":[],"sources":["../src/next/instrumentation-gate.ts","../src/next/instrumentation-create.ts"],"mappings":";;;;UAGiB,0BAAA;EACf,IAAA;EACA,MAAA;EACA,OAAA,EAAS,MAAA;AAAA;;UAIM,+BAAA;EACf,UAAA;EACA,SAAA;EACA,SAAA;EACA,YAAA;AAAA;;;;;UAOe,yBAAA;EACf,QAAA,eAAuB,OAAA;EACvB,cAAA,GACE,KAAA;IAAS,MAAA;EAAA,IAAoB,KAAA,EAC7B,OAAA,EAAS,0BAAA,EACT,OAAA,EAAS,+BAAA,YACC,OAAA;AAAA;;;;;;;;KAgCF,wBAAA;EAhCS,mEAkCnB,QAAA,QAAgB,OAAA,QAvCO;EAyCvB,cAAA,GACE,KAAA;IAAS,MAAA;EAAA,IAAoB,KAAA,EAC7B,OAAA,EAAS,0BAAA,EACT,OAAA,EAAS,+BAAA,KACN,OAAA;AAAA;;KAIK,8BAAA,GACR,sBAAA,UACO,OAAA,CAAQ,yBAAA;;;;;;AAdnB;;;;;;;;;;iBA+BgB,yBAAA,CACd,eAAA,EAAiB,8BAAA,GAChB,wBAAA;;;;UClFc,oBAAA;EDP0B;ECSzC,MAAA;EDNe;ECQf,MAAA;EDTA;;;;ECcA,MAAA,GAAS,KAAA,UAAe,MAAA;AAAA;;cAIb,6BAAA,EAA+B,KAAA,UAAe,MAAA;;;;;UAiB1C,sBAAA;ED1BH;EC4BZ,OAAA;EDrBe;ECuBf,OAAA;;EAEA,GAAA,GAAM,OAAA,CAAQ,kBAAA;EDtBiB;ECwB/B,MAAA;EDtBW;ECwBX,MAAA;EDvBmB;ECyBnB,QAAA,GAAW,cAAA;ED9BX;ECgCA,QAAA,GAAW,QAAA;ED/BX;ECiCA,SAAA;EDhC+B;ECkC/B,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EDjC3B;ECmCX,aAAA,aAA0B,oBAAA;AAAA;AAAA,UAGlB,qBAAA;EACR,QAAA,eAAuB,OAAA;EACvB,cAAA,GACE,KAAA;IAAS,MAAA;EAAA,IAAoB,KAAA,EAC7B,OAAA,EAAS,0BAAA,EACT,OAAA,EAAS,+BAAA,YACC,OAAA;AAAA;;;;;;;iBAkHE,qBAAA,CAAsB,OAAA,GAAS,sBAAA,GAA8B,qBAAA"}

package/dist/{integration-CR601uyW.mjs → integration-DYp2uw8O.mjs}

@@ -1,5 +1,5 @@
 import { n as extractSafeNodeHeaders, t as extractSafeHeaders } from "./headers-VtmnWcfn.mjs";
-import { r as createMiddlewareLogger, t as attachForkToLogger } from "./fork-CYm453dq.mjs";
+import { r as createMiddlewareLogger, t as attachForkToLogger } from "./fork-CgGlAaHa.mjs";
 //#region src/shared/integration.ts
 function normalizeHeaders(headers) {
 	if (!headers) return void 0;
@@ -72,4 +72,4 @@ function defineFrameworkIntegration(spec) {
 //#endregion
 export { defineFrameworkIntegration as t };
 
-//# sourceMappingURL=integration-CR601uyW.mjs.map
+//# sourceMappingURL=integration-DYp2uw8O.mjs.map

package/dist/{integration-CR601uyW.mjs.map → integration-DYp2uw8O.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"integration-CR601uyW.mjs","names":[],"sources":["../src/shared/integration.ts"],"sourcesContent":["import type { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\nimport { attachForkToLogger } from './fork'\nimport { extractSafeHeaders, extractSafeNodeHeaders } from './headers'\nimport type { BaseEvlogOptions, MiddlewareLoggerOptions, MiddlewareLoggerResult } from './middleware'\nimport { createMiddlewareLogger } from './middleware'\n\n/** Request shape extracted from a framework context. */\nexport interface ExtractedRequest {\n  method: string\n  path: string\n  /**\n   * Either a Web `Headers` (Hono / Elysia / Fetch) or a Node-style\n   * `IncomingHttpHeaders` record (Express / Fastify). Whichever is native\n   * to the framework — it gets filtered through the safe-header helpers.\n   */\n  headers?: Headers | Record<string, string | string[] | undefined>\n  /** Used as-is when present, otherwise auto-generated. */\n  requestId?: string\n}\n\n/** Manifest passed to {@link defineFrameworkIntegration}. */\nexport interface FrameworkIntegrationSpec<TCtx> {\n  /** Stable identifier used in error messages. */\n  name: string\n  extractRequest: (ctx: TCtx) => ExtractedRequest\n  /** Attach the request logger to the framework context (`c.set('log', logger)`). */\n  attachLogger: (ctx: TCtx, logger: RequestLogger) => void\n  /**\n   * AsyncLocalStorage instance backing `useLogger()`. Required for frameworks\n   * where the logger is accessed off the request context (Express, Fastify,\n   * NestJS). When set, `log.fork()` is auto-attached to the request logger.\n   */\n  storage?: AsyncLocalStorage<RequestLogger>\n  /** Fork lifecycle hooks (only used when `storage` is set). */\n  forkLifecycle?: import('./fork').ForkLifecycle\n}\n\n/** Result returned by {@link FrameworkIntegrationHelpers.start}. */\nexport interface FrameworkRequestHandle extends MiddlewareLoggerResult {\n  middlewareOptions: MiddlewareLoggerOptions\n  /**\n   * Run the downstream handler inside the integration's storage. When no\n   * storage is configured, the callback is invoked directly.\n   */\n  runWith: <T>(fn: () => T | Promise<T>) => Promise<T>\n}\n\n/** Helpers returned by {@link defineFrameworkIntegration}. */\nexport interface FrameworkIntegrationHelpers<TCtx> {\n  start: (ctx: TCtx, options?: BaseEvlogOptions) => FrameworkRequestHandle\n}\n\nfunction normalizeHeaders(headers: ExtractedRequest['headers']): Record<string, string> | undefined {\n  if (!headers) return undefined\n  if (typeof (headers as Headers).forEach === 'function' && typeof (headers as Headers).get === 'function') {\n    return extractSafeHeaders(headers as Headers)\n  }\n  return extractSafeNodeHeaders(headers as Record<string, string | string[] | undefined>)\n}\n\n/**\n * Build a manifest-driven framework integration. Captures the boilerplate\n * every middleware shares (request extraction, logger setup, attachment,\n * optional AsyncLocalStorage wrapping). The framework still owns its own\n * middleware function — it just declares *what* to extract and *where* to\n * attach the logger.\n *\n * @example\n * ```ts\n * const integration = defineFrameworkIntegration<HonoContext>({\n *   name: 'hono',\n *   extractRequest: (c) => ({\n *     method: c.req.method,\n *     path: c.req.path,\n *     headers: c.req.raw.headers,\n *     requestId: c.req.header('x-request-id'),\n *   }),\n *   attachLogger: (c, logger) => c.set('log', logger),\n * })\n *\n * export function evlog(options?: BaseEvlogOptions): MiddlewareHandler {\n *   return async (c, next) => {\n *     const { skipped, finish, runWith } = integration.start(c, options)\n *     if (skipped) return next()\n *     try {\n *       await runWith(() => next())\n *       await finish({ status: c.res.status })\n *     } catch (error) {\n *       await finish({ error: error as Error })\n *       throw error\n *     }\n *   }\n * }\n * ```\n */\nexport function defineFrameworkIntegration<TCtx>(\n  spec: FrameworkIntegrationSpec<TCtx>,\n): FrameworkIntegrationHelpers<TCtx> {\n  return {\n    start(ctx, options = {}) {\n      const extracted = spec.extractRequest(ctx)\n      const headers = normalizeHeaders(extracted.headers)\n      const middlewareOptions: MiddlewareLoggerOptions = {\n        method: extracted.method,\n        path: extracted.path,\n        requestId: extracted.requestId || crypto.randomUUID(),\n        headers,\n        ...options,\n      }\n      const result = createMiddlewareLogger(middlewareOptions)\n\n      if (!result.skipped) {\n        if (spec.storage) {\n          attachForkToLogger(spec.storage, result.logger, middlewareOptions, spec.forkLifecycle)\n        }\n        spec.attachLogger(ctx, result.logger)\n      }\n\n      const { storage } = spec\n      const runWith = async <T>(fn: () => T | Promise<T>): Promise<T> => {\n        if (!storage || result.skipped) return await fn()\n        return await storage.run(result.logger, fn)\n      }\n\n      return { ...result, middlewareOptions, runWith }\n    },\n  }\n}\n"],"mappings":";;;AAqDA,SAAS,iBAAiB,SAA0E;AAClG,KAAI,CAAC,QAAS,QAAO,KAAA;AACrB,KAAI,OAAQ,QAAoB,YAAY,cAAc,OAAQ,QAAoB,QAAQ,WAC5F,QAAO,mBAAmB,QAAmB;AAE/C,QAAO,uBAAuB,QAAyD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCzF,SAAgB,2BACd,MACmC;AACnC,QAAO,EACL,MAAM,KAAK,UAAU,EAAE,EAAE;EACvB,MAAM,YAAY,KAAK,eAAe,IAAI;EAC1C,MAAM,UAAU,iBAAiB,UAAU,QAAQ;EACnD,MAAM,oBAA6C;GACjD,QAAQ,UAAU;GAClB,MAAM,UAAU;GAChB,WAAW,UAAU,aAAa,OAAO,YAAY;GACrD;GACA,GAAG;GACJ;EACD,MAAM,SAAS,uBAAuB,kBAAkB;AAExD,MAAI,CAAC,OAAO,SAAS;AACnB,OAAI,KAAK,QACP,oBAAmB,KAAK,SAAS,OAAO,QAAQ,mBAAmB,KAAK,cAAc;AAExF,QAAK,aAAa,KAAK,OAAO,OAAO;;EAGvC,MAAM,EAAE,YAAY;EACpB,MAAM,UAAU,OAAU,OAAyC;AACjE,OAAI,CAAC,WAAW,OAAO,QAAS,QAAO,MAAM,IAAI;AACjD,UAAO,MAAM,QAAQ,IAAI,OAAO,QAAQ,GAAG;;AAG7C,SAAO;GAAE,GAAG;GAAQ;GAAmB;GAAS;IAEnD"}
+{"version":3,"file":"integration-DYp2uw8O.mjs","names":[],"sources":["../src/shared/integration.ts"],"sourcesContent":["import type { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\nimport { attachForkToLogger } from './fork'\nimport { extractSafeHeaders, extractSafeNodeHeaders } from './headers'\nimport type { BaseEvlogOptions, MiddlewareLoggerOptions, MiddlewareLoggerResult } from './middleware'\nimport { createMiddlewareLogger } from './middleware'\n\n/** Request shape extracted from a framework context. */\nexport interface ExtractedRequest {\n  method: string\n  path: string\n  /**\n   * Either a Web `Headers` (Hono / Elysia / Fetch) or a Node-style\n   * `IncomingHttpHeaders` record (Express / Fastify). Whichever is native\n   * to the framework — it gets filtered through the safe-header helpers.\n   */\n  headers?: Headers | Record<string, string | string[] | undefined>\n  /** Used as-is when present, otherwise auto-generated. */\n  requestId?: string\n}\n\n/** Manifest passed to {@link defineFrameworkIntegration}. */\nexport interface FrameworkIntegrationSpec<TCtx> {\n  /** Stable identifier used in error messages. */\n  name: string\n  extractRequest: (ctx: TCtx) => ExtractedRequest\n  /** Attach the request logger to the framework context (`c.set('log', logger)`). */\n  attachLogger: (ctx: TCtx, logger: RequestLogger) => void\n  /**\n   * AsyncLocalStorage instance backing `useLogger()`. Required for frameworks\n   * where the logger is accessed off the request context (Express, Fastify,\n   * NestJS). When set, `log.fork()` is auto-attached to the request logger.\n   */\n  storage?: AsyncLocalStorage<RequestLogger>\n  /** Fork lifecycle hooks (only used when `storage` is set). */\n  forkLifecycle?: import('./fork').ForkLifecycle\n}\n\n/** Result returned by {@link FrameworkIntegrationHelpers.start}. */\nexport interface FrameworkRequestHandle extends MiddlewareLoggerResult {\n  middlewareOptions: MiddlewareLoggerOptions\n  /**\n   * Run the downstream handler inside the integration's storage. When no\n   * storage is configured, the callback is invoked directly.\n   */\n  runWith: <T>(fn: () => T | Promise<T>) => Promise<T>\n}\n\n/** Helpers returned by {@link defineFrameworkIntegration}. */\nexport interface FrameworkIntegrationHelpers<TCtx> {\n  start: (ctx: TCtx, options?: BaseEvlogOptions) => FrameworkRequestHandle\n}\n\nfunction normalizeHeaders(headers: ExtractedRequest['headers']): Record<string, string> | undefined {\n  if (!headers) return undefined\n  if (typeof (headers as Headers).forEach === 'function' && typeof (headers as Headers).get === 'function') {\n    return extractSafeHeaders(headers as Headers)\n  }\n  return extractSafeNodeHeaders(headers as Record<string, string | string[] | undefined>)\n}\n\n/**\n * Build a manifest-driven framework integration. Captures the boilerplate\n * every middleware shares (request extraction, logger setup, attachment,\n * optional AsyncLocalStorage wrapping). The framework still owns its own\n * middleware function — it just declares *what* to extract and *where* to\n * attach the logger.\n *\n * @example\n * ```ts\n * const integration = defineFrameworkIntegration<HonoContext>({\n *   name: 'hono',\n *   extractRequest: (c) => ({\n *     method: c.req.method,\n *     path: c.req.path,\n *     headers: c.req.raw.headers,\n *     requestId: c.req.header('x-request-id'),\n *   }),\n *   attachLogger: (c, logger) => c.set('log', logger),\n * })\n *\n * export function evlog(options?: BaseEvlogOptions): MiddlewareHandler {\n *   return async (c, next) => {\n *     const { skipped, finish, runWith } = integration.start(c, options)\n *     if (skipped) return next()\n *     try {\n *       await runWith(() => next())\n *       await finish({ status: c.res.status })\n *     } catch (error) {\n *       await finish({ error: error as Error })\n *       throw error\n *     }\n *   }\n * }\n * ```\n */\nexport function defineFrameworkIntegration<TCtx>(\n  spec: FrameworkIntegrationSpec<TCtx>,\n): FrameworkIntegrationHelpers<TCtx> {\n  return {\n    start(ctx, options = {}) {\n      const extracted = spec.extractRequest(ctx)\n      const headers = normalizeHeaders(extracted.headers)\n      const middlewareOptions: MiddlewareLoggerOptions = {\n        method: extracted.method,\n        path: extracted.path,\n        requestId: extracted.requestId || crypto.randomUUID(),\n        headers,\n        ...options,\n      }\n      const result = createMiddlewareLogger(middlewareOptions)\n\n      if (!result.skipped) {\n        if (spec.storage) {\n          attachForkToLogger(spec.storage, result.logger, middlewareOptions, spec.forkLifecycle)\n        }\n        spec.attachLogger(ctx, result.logger)\n      }\n\n      const { storage } = spec\n      const runWith = async <T>(fn: () => T | Promise<T>): Promise<T> => {\n        if (!storage || result.skipped) return await fn()\n        return await storage.run(result.logger, fn)\n      }\n\n      return { ...result, middlewareOptions, runWith }\n    },\n  }\n}\n"],"mappings":";;;AAqDA,SAAS,iBAAiB,SAA0E;AAClG,KAAI,CAAC,QAAS,QAAO,KAAA;AACrB,KAAI,OAAQ,QAAoB,YAAY,cAAc,OAAQ,QAAoB,QAAQ,WAC5F,QAAO,mBAAmB,QAAmB;AAE/C,QAAO,uBAAuB,QAAyD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCzF,SAAgB,2BACd,MACmC;AACnC,QAAO,EACL,MAAM,KAAK,UAAU,EAAE,EAAE;EACvB,MAAM,YAAY,KAAK,eAAe,IAAI;EAC1C,MAAM,UAAU,iBAAiB,UAAU,QAAQ;EACnD,MAAM,oBAA6C;GACjD,QAAQ,UAAU;GAClB,MAAM,UAAU;GAChB,WAAW,UAAU,aAAa,OAAO,YAAY;GACrD;GACA,GAAG;GACJ;EACD,MAAM,SAAS,uBAAuB,kBAAkB;AAExD,MAAI,CAAC,OAAO,SAAS;AACnB,OAAI,KAAK,QACP,oBAAmB,KAAK,SAAS,OAAO,QAAQ,mBAAmB,KAAK,cAAc;AAExF,QAAK,aAAa,KAAK,OAAO,OAAO;;EAGvC,MAAM,EAAE,YAAY;EACpB,MAAM,UAAU,OAAU,OAAyC;AACjE,OAAI,CAAC,WAAW,OAAO,QAAS,QAAO,MAAM,IAAI;AACjD,UAAO,MAAM,QAAQ,IAAI,OAAO,QAAQ,GAAG;;AAG7C,SAAO;GAAE,GAAG;GAAQ;GAAmB;GAAS;IAEnD"}

package/dist/{logger-BccCJUyD.d.mts → logger-mHIWxBhJ.d.mts}

@@ -1,6 +1,10 @@
-import { B as DrainContext, H as EnvironmentContext, Y as Log, Z as LoggerConfig, ft as WideEvent, gt as PluginRunner, it as RequestLoggerOptions, l as AuditableLogger, ut as TailSamplingContext } from "./audit-BUAajsPU.mjs";
+import { B as DrainContext, H as EnvironmentContext, Y as Log, Z as LoggerConfig, ft as WideEvent, gt as PluginRunner, it as RequestLoggerOptions, l as AuditableLogger, ut as TailSamplingContext } from "./audit-D7v6JHj0.mjs";
 
 //#region src/logger.d.ts
+/** Cross-bundle global slot for the native stdout write registered by captureOutput patching. */
+interface EvlogProcessOutputGlobal {
+  __evlogNativeStdoutWrite?: typeof process.stdout.write;
+}
 declare function mergeInto(target: Record<string, unknown>, source: Record<string, unknown>): void;
 /**
  * Mark a wide event as past the post-emit AI merge window so late `log.set({ ai })`
@@ -118,5 +122,5 @@ declare function createRequestLogger<T extends object = Record<string, unknown>>
  */
 declare function getEnvironment(): EnvironmentContext;
 //#endregion
-export { getGlobalDrain as a, isEnabled as c, markWideEventDrainStarted as d, mergeInto as f, getEnvironment as i, isLoggerLocked as l, createLogger as n, getGlobalPluginRunner as o, shouldKeep as p, createRequestLogger as r, initLogger as s, _log as t, lockLogger as u };
-//# sourceMappingURL=logger-BccCJUyD.d.mts.map
+export { getEnvironment as a, initLogger as c, lockLogger as d, markWideEventDrainStarted as f, createRequestLogger as i, isEnabled as l, shouldKeep as m, _log as n, getGlobalDrain as o, mergeInto as p, createLogger as r, getGlobalPluginRunner as s, EvlogProcessOutputGlobal as t, isLoggerLocked as u };
+//# sourceMappingURL=logger-mHIWxBhJ.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger-mHIWxBhJ.d.mts","names":[],"sources":["../src/logger.ts"],"mappings":";;;AAkBA;AAAA,UAAiB,wBAAA;EACf,wBAAA,UAAkC,OAAA,CAAQ,MAAA,CAAO,KAAA;AAAA;AAAA,iBA6B1C,SAAA,CAAU,MAAA,EAAQ,MAAA,mBAAyB,MAAA,EAAQ,MAAA;;;;;;AA5B3D;iBAwDe,yBAAA,CAA0B,KAAA,EAAO,SAAA;;;;;iBAsCjC,UAAA,CAAW,MAAA,GAAQ,YAAA;;;;;AAAnC;iBA+CgB,qBAAA,CAAA,GAAyB,YAAA;;;;iBAOzB,SAAA,CAAA;;;;;AAAhB;iBASgB,UAAA,CAAA;;;;iBAOA,cAAA,CAAA;;;;;AAAhB;iBASgB,cAAA,CAAA,KAAoB,GAAA,EAAK,YAAA,YAAwB,OAAA;;;;AAAjE;iBA8BgB,UAAA,CAAW,GAAA,EAAK,mBAAA;;;;;;;;AAAhC;;cA4gBM,IAAA,EAAM,GAAA;;AA5fX;;UAwhBS,2BAAA;EA5BE;;AAOU;;EA0BpB,WAAA;EAI6B;;;EAA7B,SAAA,IAAa,OAAA,EAAS,OAAA;AAAA;;;AAkBxB;;;;;;;;;;;;;iBAAgB,YAAA,oBAAgC,MAAA,kBAAA,CAAyB,cAAA,GAAgB,MAAA,mBAA8B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;;;;;AAiOvL;;;;;;;;;;;;;;;;;;;;AAeA;iBAfgB,mBAAA,oBAAuC,MAAA,kBAAA,CAAyB,OAAA,GAAS,oBAAA,EAA2B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;;iBAepK,cAAA,CAAA,GAAkB,kBAAA"}

package/dist/logger.d.mts

@@ -1,2 +1,2 @@
-import { a as getGlobalDrain, c as isEnabled, d as markWideEventDrainStarted, f as mergeInto, i as getEnvironment, l as isLoggerLocked, n as createLogger, o as getGlobalPluginRunner, p as shouldKeep, r as createRequestLogger, s as initLogger, t as _log, u as lockLogger } from "./logger-BccCJUyD.mjs";
-export { createLogger, createRequestLogger, getEnvironment, getGlobalDrain, getGlobalPluginRunner, initLogger, isEnabled, isLoggerLocked, lockLogger, _log as log, markWideEventDrainStarted, mergeInto as mergeWideEventFields, shouldKeep };
+import { a as getEnvironment, c as initLogger, d as lockLogger, f as markWideEventDrainStarted, i as createRequestLogger, l as isEnabled, m as shouldKeep, n as _log, o as getGlobalDrain, p as mergeInto, r as createLogger, s as getGlobalPluginRunner, t as EvlogProcessOutputGlobal, u as isLoggerLocked } from "./logger-mHIWxBhJ.mjs";
+export { EvlogProcessOutputGlobal, createLogger, createRequestLogger, getEnvironment, getGlobalDrain, getGlobalPluginRunner, initLogger, isEnabled, isLoggerLocked, lockLogger, _log as log, markWideEventDrainStarted, mergeInto as mergeWideEventFields, shouldKeep };

package/dist/logger.mjs

@@ -1,2 +1,2 @@
-import { C as lockLogger, E as shouldKeep, S as isLoggerLocked, T as mergeInto, _ as getEnvironment, b as initLogger, g as createRequestLogger, h as createLogger, m as _log, v as getGlobalDrain, w as markWideEventDrainStarted, x as isEnabled, y as getGlobalPluginRunner } from "./audit-BFwTUxBJ.mjs";
+import { C as lockLogger, E as shouldKeep, S as isLoggerLocked, T as mergeInto, _ as getEnvironment, b as initLogger, g as createRequestLogger, h as createLogger, m as _log, v as getGlobalDrain, w as markWideEventDrainStarted, x as isEnabled, y as getGlobalPluginRunner } from "./audit-BQt8yAHo.mjs";
 export { createLogger, createRequestLogger, getEnvironment, getGlobalDrain, getGlobalPluginRunner, initLogger, isEnabled, isLoggerLocked, lockLogger, _log as log, markWideEventDrainStarted, mergeInto as mergeWideEventFields, shouldKeep };

package/dist/{middleware-DQ6-h8h0.d.mts → middleware-B_k4Mrzg.d.mts}

@@ -1,4 +1,4 @@
-import { $ as RedactConfig, B as DrainContext, V as EnrichContext, at as RouteConfig, ft as WideEvent, gt as PluginRunner, ht as EvlogPlugin, rt as RequestLogger, ut as TailSamplingContext } from "./audit-BUAajsPU.mjs";
+import { $ as RedactConfig, B as DrainContext, V as EnrichContext, at as RouteConfig, ft as WideEvent, gt as PluginRunner, ht as EvlogPlugin, rt as RequestLogger, ut as TailSamplingContext } from "./audit-D7v6JHj0.mjs";
 
 //#region src/shared/middleware.d.ts
 /**
@@ -76,4 +76,4 @@ declare function runEnrichAndDrain(emittedEvent: WideEvent, options: MiddlewareL
 declare function createMiddlewareLogger(options: MiddlewareLoggerOptions): MiddlewareLoggerResult;
 //#endregion
 export { resolveMiddlewarePluginRunner as a, createMiddlewareLogger as i, MiddlewareLoggerOptions as n, runEnrichAndDrain as o, MiddlewareLoggerResult as r, BaseEvlogOptions as t };
-//# sourceMappingURL=middleware-DQ6-h8h0.d.mts.map
+//# sourceMappingURL=middleware-B_k4Mrzg.d.mts.map

package/dist/{middleware-DQ6-h8h0.d.mts.map → middleware-B_k4Mrzg.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"middleware-DQ6-h8h0.d.mts","names":[],"sources":["../src/shared/middleware.ts"],"mappings":";;;;AAaA;;;UAAiB,gBAAA;EAMN;EAJT,OAAA;EAMsC;EAJtC,OAAA;EAMwC;EAJxC,MAAA,GAAS,MAAA,SAAe,WAAA;EAMoB;EAJ5C,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAW5B;EATV,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EASnB;EAPrB,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;EAR5C;;;;EAaA,MAAA,aAAmB,YAAA;EATL;EAWd,OAAA,GAAU,WAAA;AAAA;;UAIK,uBAAA,SAAgC,gBAAA;EAC/C,MAAA;EACA,IAAA;EACA,SAAA;EAda;EAgBb,OAAA,GAAU,MAAA;AAAA;AAAA,UAGK,sBAAA;EACf,MAAA,EAAQ,aAAA;EACR,MAAA,GAAS,IAAA;IAAS,MAAA;IAAiB,KAAA,GAAQ,KAAA;EAAA,MAAY,OAAA,CAAQ,SAAA;EAVhD;;;;EAef,cAAA,GAAiB,QAAA,EAAU,QAAA,EAAU,IAAA;IAAS,MAAA;EAAA,MAAsB,OAAA,CAAQ,QAAA;EAC5E,OAAA;AAAA;;;;AARF;iBAuCgB,6BAAA,CAA8B,OAAA;EAAW,OAAA,GAAU,WAAA;AAAA,IAAkB,YAAA;;;;;iBAiC/D,iBAAA,CACpB,YAAA,EAAc,SAAA,EACd,OAAA,EAAS,uBAAA,EACT,WAAA;EAAe,MAAA;EAAgB,IAAA;EAAc,SAAA;AAAA,GAC7C,cAAA,WACA,OAAA,GAAU,YAAA,GACT,OAAA;;;;;;;;;iBAgEa,sBAAA,CAAuB,OAAA,EAAS,uBAAA,GAA0B,sBAAA"}
+{"version":3,"file":"middleware-B_k4Mrzg.d.mts","names":[],"sources":["../src/shared/middleware.ts"],"mappings":";;;;AAaA;;;UAAiB,gBAAA;EAMN;EAJT,OAAA;EAMsC;EAJtC,OAAA;EAMwC;EAJxC,MAAA,GAAS,MAAA,SAAe,WAAA;EAMoB;EAJ5C,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAW5B;EATV,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EASnB;EAPrB,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;EAR5C;;;;EAaA,MAAA,aAAmB,YAAA;EATL;EAWd,OAAA,GAAU,WAAA;AAAA;;UAIK,uBAAA,SAAgC,gBAAA;EAC/C,MAAA;EACA,IAAA;EACA,SAAA;EAda;EAgBb,OAAA,GAAU,MAAA;AAAA;AAAA,UAGK,sBAAA;EACf,MAAA,EAAQ,aAAA;EACR,MAAA,GAAS,IAAA;IAAS,MAAA;IAAiB,KAAA,GAAQ,KAAA;EAAA,MAAY,OAAA,CAAQ,SAAA;EAVhD;;;;EAef,cAAA,GAAiB,QAAA,EAAU,QAAA,EAAU,IAAA;IAAS,MAAA;EAAA,MAAsB,OAAA,CAAQ,QAAA;EAC5E,OAAA;AAAA;;;;AARF;iBAuCgB,6BAAA,CAA8B,OAAA;EAAW,OAAA,GAAU,WAAA;AAAA,IAAkB,YAAA;;;;;iBAiC/D,iBAAA,CACpB,YAAA,EAAc,SAAA,EACd,OAAA,EAAS,uBAAA,EACT,WAAA;EAAe,MAAA;EAAgB,IAAA;EAAc,SAAA;AAAA,GAC7C,cAAA,WACA,OAAA,GAAU,YAAA,GACT,OAAA;;;;;;;;;iBAgEa,sBAAA,CAAuB,OAAA,EAAS,uBAAA,GAA0B,sBAAA"}

package/dist/nestjs/index.d.mts

@@ -1,5 +1,5 @@
-import { rt as RequestLogger } from "../audit-BUAajsPU.mjs";
-import { t as BaseEvlogOptions } from "../middleware-DQ6-h8h0.mjs";
+import { rt as RequestLogger } from "../audit-D7v6JHj0.mjs";
+import { t as BaseEvlogOptions } from "../middleware-B_k4Mrzg.mjs";
 import { DynamicModule, MiddlewareConsumer, NestModule } from "@nestjs/common";
 
 //#region src/nestjs/index.d.ts

package/dist/nestjs/index.mjs

@@ -1,5 +1,5 @@
 import { n as extractSafeNodeHeaders } from "../headers-VtmnWcfn.mjs";
-import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-CYm453dq.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";
 //#region src/nestjs/index.ts

package/dist/next/client.d.mts

@@ -1,4 +1,4 @@
-import { X as LogLevel, dt as TransportConfig } from "../audit-BUAajsPU.mjs";
+import { X as LogLevel, dt as TransportConfig } from "../audit-D7v6JHj0.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-BUAajsPU.mjs";
-import { n as createError } from "../error-DwajXSKM.mjs";
-import { t as _log } from "../logger-BccCJUyD.mjs";
-import { t as BaseEvlogOptions } from "../middleware-DQ6-h8h0.mjs";
+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 { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/next/types.d.ts

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;6DAWw0G,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,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"}

package/dist/next/index.mjs

@@ -1,10 +1,21 @@
 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-BFwTUxBJ.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 { 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-CYm453dq.mjs";
+import { t as attachForkToLogger } from "../fork-CgGlAaHa.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/next/enrich-error-stack.ts
+/**
+* Source-map stack enrichment for Next.js dev — isolated from Nitro to avoid bundling nitropack/youch.
+*/
+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");
+	enrichErrorStackFromNextDev(error);
+}
+//#endregion
 //#region src/next/storage.ts
 const evlogStorage = new AsyncLocalStorage();
 /**
@@ -201,7 +212,9 @@ function createWithEvlog(options) {
 				await emitRequestEvent(logger, requestInfo, headers, status);
 				return result;
 			} catch (error) {
-				logger.error(error instanceof Error ? error : new Error(String(error)));
+				const err = error instanceof Error ? error : new Error(String(error));
+				await enrichNextErrorStackForDev(err, { pretty: state.options.pretty });
+				logger.error(err);
 				const errorStatus = error.status ?? error.statusCode ?? 500;
 				logger.set({ status: errorStatus });
 				await emitRequestEvent(logger, {

package/dist/next/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/next/storage.ts","../../src/next/handler.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"sourcesContent":["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 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        logger.error(error instanceof Error ? error : new Error(String(error)))\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 { 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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"}

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

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

package/dist/next/instrumentation/create.mjs

@@ -0,0 +1,155 @@
+//#region src/next/instrumentation-create.ts
+/** Default patterns skipped by {@link CaptureOutputOptions.ignore}. */
+const DEFAULT_CAPTURE_OUTPUT_IGNORE = [
+	"node-module-in-edge-runtime",
+	"Edge Instrumentation",
+	"https://nextjs.org/docs/messages/node-module-in-edge-runtime",
+	"https://nextjs.org/docs/api-reference/edge-runtime",
+	"Ecmascript file had an error",
+	"A Node.js module is loaded",
+	"A Node.js API is used",
+	"not supported in the Edge Runtime",
+	"not supported inthe Edge Runtime",
+	"Import trace:"
+];
+let patching = false;
+let loggerPromise;
+let stdoutPatched = false;
+let stderrPatched = false;
+let activeCaptureOutput;
+function loadLogger() {
+	loggerPromise ??= import("../../logger.mjs");
+	return loggerPromise;
+}
+function resolveCaptureOutputOptions(captureOutput) {
+	if (!captureOutput) return void 0;
+	if (captureOutput === true) return {
+		stdout: true,
+		stderr: true,
+		ignore: DEFAULT_CAPTURE_OUTPUT_IGNORE
+	};
+	return {
+		stdout: captureOutput.stdout ?? true,
+		stderr: captureOutput.stderr ?? true,
+		ignore: captureOutput.ignore ?? DEFAULT_CAPTURE_OUTPUT_IGNORE
+	};
+}
+function shouldIgnoreCapturedOutput(message, ignore) {
+	return ignore.some((pattern) => {
+		if (typeof pattern === "string") return message.includes(pattern);
+		return pattern.test(message);
+	});
+}
+function applyCaptureOutput(config, logApi, silent) {
+	activeCaptureOutput = {
+		log: logApi,
+		ignore: config.ignore ?? DEFAULT_CAPTURE_OUTPUT_IGNORE,
+		stdout: config.stdout !== false,
+		stderr: config.stderr !== false,
+		silent
+	};
+	const proc = globalThis.process;
+	if (activeCaptureOutput.stdout && !stdoutPatched) {
+		const originalStdoutWrite = proc.stdout.write.bind(proc.stdout);
+		globalThis.__evlogNativeStdoutWrite = originalStdoutWrite;
+		stdoutPatched = true;
+		proc.stdout.write = function(chunk, ...args) {
+			const message = String(chunk).trimEnd();
+			const active = activeCaptureOutput;
+			if (!patching && message.length > 0 && active?.stdout && !shouldIgnoreCapturedOutput(message, active.ignore)) {
+				patching = true;
+				try {
+					active.log.info({
+						source: "stdout",
+						message
+					});
+				} finally {
+					patching = false;
+				}
+				if (!active.silent) return true;
+			}
+			return originalStdoutWrite(chunk, ...args);
+		};
+	}
+	if (activeCaptureOutput.stderr && !stderrPatched) {
+		const originalStderrWrite = proc.stderr.write.bind(proc.stderr);
+		stderrPatched = true;
+		proc.stderr.write = function(chunk, ...args) {
+			const message = String(chunk).trimEnd();
+			const active = activeCaptureOutput;
+			if (!patching && message.length > 0 && active?.stderr && !shouldIgnoreCapturedOutput(message, active.ignore)) {
+				patching = true;
+				try {
+					active.log.error({
+						source: "stderr",
+						message
+					});
+				} finally {
+					patching = false;
+				}
+				if (!active.silent) return true;
+			}
+			return originalStderrWrite(chunk, ...args);
+		};
+	}
+}
+/**
+* Create Next.js instrumentation hooks (`register`, `onRequestError`).
+*
+* Load via dynamic `import()` from root `instrumentation.ts` (Node.js runtime only).
+* Load via dynamic `import()` from root `instrumentation.ts` with {@link defineNodeInstrumentation}.
+*/
+function createInstrumentation(options = {}) {
+	let registered = false;
+	let registerPromise;
+	const captureOutputOptions = resolveCaptureOutputOptions(options.captureOutput);
+	function register() {
+		if (registered) return;
+		if (registerPromise) return registerPromise;
+		registerPromise = loadLogger().then(({ initLogger, lockLogger, log }) => {
+			initLogger({
+				enabled: options.enabled,
+				env: {
+					service: options.service,
+					...options.env
+				},
+				pretty: options.pretty,
+				silent: options.silent,
+				sampling: options.sampling,
+				minLevel: options.minLevel,
+				stringify: options.stringify,
+				drain: options.drain
+			});
+			lockLogger();
+			if (captureOutputOptions && process.env.NEXT_RUNTIME === "nodejs") applyCaptureOutput(captureOutputOptions, log, options.silent ?? false);
+			registered = true;
+		}).catch((error) => {
+			registerPromise = void 0;
+			throw error;
+		});
+		return registerPromise;
+	}
+	function onRequestError(error, request, context) {
+		return loadLogger().then(({ log }) => {
+			log.error({
+				message: error.message,
+				digest: error.digest,
+				stack: error.stack,
+				path: request.path,
+				method: request.method,
+				routerKind: context.routerKind,
+				routePath: context.routePath,
+				routeType: context.routeType,
+				renderSource: context.renderSource
+			});
+		});
+	}
+	return {
+		register,
+		onRequestError
+	};
+}
+//#endregion
+export { DEFAULT_CAPTURE_OUTPUT_IGNORE, createInstrumentation };
+
+//# sourceMappingURL=create.mjs.map

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

@@ -0,0 +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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"}