evlog 2.19.1 → 2.20.0

package/dist/index.mjs

@@ -1,209 +1,9 @@
 import { isLevelEnabled } from "./utils.mjs";
-import { A as enricherPlugin, E as shouldKeep, O as definePlugin, _ as getEnvironment, a as auditEnricher, b as initLogger, c as buildAuditFields, d as signed, f as withAudit, g as createRequestLogger, h as createLogger, i as auditDiff, k as drainPlugin, l as defineAuditAction, m as _log, n as AuditDeniedError, o as auditOnly, p as withAuditMethods, r as audit, s as auditRedactPreset, t as AUDIT_SCHEMA_VERSION, u as mockAudit, x as isEnabled } from "./audit-BQt8yAHo.mjs";
+import { A as definePlugin, M as enricherPlugin, O as shouldKeep, S as isEnabled, _ as createRequestLogger, a as auditEnricher, c as buildAuditFields, d as mockAudit, f as signed, g as createLogger, h as _log, i as auditDiff, j as drainPlugin, m as withAuditMethods, n as AuditDeniedError, o as auditOnly, p as withAudit, r as audit, s as auditRedactPreset, t as AUDIT_SCHEMA_VERSION, v as getEnvironment, x as initLogger } from "./audit-BXCYMjcC.mjs";
 import { EvlogError, createError } from "./error.mjs";
+import { defineAuditAction } from "./audit-action.mjs";
+import { defineAuditCatalog, defineError, defineErrorCatalog } from "./catalog.mjs";
 import { useLogger } from "./runtime/server/useLogger.mjs";
 import { parseError } from "./runtime/utils/parseError.mjs";
 import { n as toLoggerConfig, r as toMiddlewareOptions, t as defineEvlog } from "./define-Bpaymi-h.mjs";
-//#region src/catalog.ts
-function buildEvlogError(code, entry, rawArgs) {
-	const { message: messageOverride, status, why, fix, link, cause, internal: callInternal, ...maybeParams } = rawArgs ?? {};
-	let message;
-	if (typeof messageOverride === "string") message = messageOverride;
-	else if (typeof entry.message === "function") message = entry.message(maybeParams);
-	else ({message} = entry);
-	let internal;
-	if (entry.internal || callInternal) internal = {
-		...entry.internal ?? {},
-		...callInternal ?? {}
-	};
-	return new EvlogError({
-		code,
-		message,
-		status: status ?? entry.status ?? 500,
-		why: why ?? entry.why,
-		fix: fix ?? entry.fix,
-		link: link ?? entry.link,
-		cause,
-		internal
-	});
-}
-/**
-* Define a single, standalone error factory bound to a stable `code`.
-*
-* Each factory produces an {@link EvlogError} with the entry's defaults
-* applied. Call-site overrides (`cause`, `internal`, `message`, ...) are
-* shallow-merged onto those defaults.
-*
-* @example
-* ```ts
-* import { defineError } from 'evlog'
-*
-* export const PaymentDeclined = defineError('billing.PAYMENT_DECLINED', {
-*   status: 402,
-*   message: 'Card declined',
-*   why: 'Issuer declined the charge',
-*   fix: 'Try another card',
-* })
-*
-* throw PaymentDeclined()
-* throw PaymentDeclined({ cause: stripeErr, internal: { ref: 'ch_x' } })
-* ```
-*
-* @example Templated message with typed params
-* ```ts
-* export const InsufficientFunds = defineError('billing.INSUFFICIENT_FUNDS', {
-*   status: 402,
-*   message: ({ available, required }: { available: number, required: number }) =>
-*     `Insufficient funds: $${available}/$${required}`,
-* })
-*
-* throw InsufficientFunds({ available: 5, required: 100 })
-* ```
-*/
-function defineError(code, entry) {
-	const factory = ((...args) => buildEvlogError(code, entry, args[0]));
-	Object.defineProperties(factory, {
-		code: {
-			value: code,
-			enumerable: true
-		},
-		status: {
-			value: entry.status ?? 500,
-			enumerable: true
-		},
-		message: {
-			value: entry.message,
-			enumerable: true
-		},
-		why: {
-			value: entry.why,
-			enumerable: true
-		},
-		fix: {
-			value: entry.fix,
-			enumerable: true
-		},
-		link: {
-			value: entry.link,
-			enumerable: true
-		},
-		tags: {
-			value: entry.tags,
-			enumerable: true
-		},
-		internal: {
-			value: entry.internal,
-			enumerable: true
-		}
-	});
-	return factory;
-}
-/**
-* Define a bundle of errors that share a common prefix. The wire `code` for
-* each entry is `${prefix}.${KEY}` (the key's casing is preserved — convention
-* is `UPPER_SNAKE_CASE`).
-*
-* Pair with `declare module 'evlog'` to surface autocomplete + literal-typed
-* `code` everywhere across the codebase.
-*
-* @example
-* ```ts
-* import { defineErrorCatalog } from 'evlog'
-*
-* export const billingErrors = defineErrorCatalog('billing', {
-*   PAYMENT_DECLINED: { status: 402, message: 'Card declined' },
-*   INSUFFICIENT_FUNDS: {
-*     status: 402,
-*     message: ({ available, required }: { available: number, required: number }) =>
-*       `Insufficient funds: $${available}/$${required}`,
-*   },
-* })
-*
-* declare module 'evlog' {
-*   interface RegisteredErrorCatalogs {
-*     billing: typeof billingErrors
-*   }
-* }
-*
-* throw billingErrors.PAYMENT_DECLINED()
-* throw billingErrors.INSUFFICIENT_FUNDS({ available: 5, required: 100 })
-* ```
-*/
-function defineErrorCatalog(prefix, map) {
-	const out = {};
-	const codes = [];
-	for (const key of Object.keys(map)) {
-		const code = `${prefix}.${key}`;
-		out[key] = defineError(code, map[key]);
-		codes.push(code);
-	}
-	Object.defineProperties(out, {
-		_prefix: {
-			value: prefix,
-			enumerable: false
-		},
-		_codes: {
-			value: Object.freeze(codes),
-			enumerable: false
-		}
-	});
-	return out;
-}
-/**
-* Define a bundle of audit actions that share a common prefix. The wire
-* `action` for each entry is `${prefix}.${KEY}`.
-*
-* Each entry produces a thin wrapper around {@link defineAuditAction} (target
-* type is fixed at definition time, action name is auto-prefixed).
-*
-* @example
-* ```ts
-* import { defineAuditCatalog } from 'evlog'
-*
-* export const billingAudit = defineAuditCatalog('billing', {
-*   INVOICE_REFUND: {
-*     target: 'invoice',
-*     severity: 'high',
-*     requiresChanges: true,
-*     description: 'Refund an invoice to the customer',
-*   },
-*   INVOICE_CREATE: { target: 'invoice' },
-* })
-*
-* declare module 'evlog' {
-*   interface RegisteredAuditCatalogs {
-*     billing: typeof billingAudit
-*   }
-* }
-*
-* log.audit(billingAudit.INVOICE_REFUND({
-*   actor: { type: 'user', id: u.id },
-*   target: { id: 'inv_889' },
-* }))
-* ```
-*/
-function defineAuditCatalog(prefix, map) {
-	const out = {};
-	const actions = [];
-	for (const key of Object.keys(map)) {
-		const action = `${prefix}.${key}`;
-		const entry = map[key];
-		out[key] = defineAuditAction(action, entry);
-		actions.push(action);
-	}
-	Object.defineProperties(out, {
-		_prefix: {
-			value: prefix,
-			enumerable: false
-		},
-		_actions: {
-			value: Object.freeze(actions),
-			enumerable: false
-		}
-	});
-	return out;
-}
-//#endregion
 export { AUDIT_SCHEMA_VERSION, AuditDeniedError, EvlogError, audit, auditDiff, auditEnricher, auditOnly, auditRedactPreset, buildAuditFields, createError, createError as createEvlogError, createLogger, createRequestLogger, defineAuditAction, defineAuditCatalog, defineError, defineErrorCatalog, defineEvlog, definePlugin, drainPlugin, enricherPlugin, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, mockAudit, parseError, shouldKeep, signed, toLoggerConfig, toMiddlewareOptions, useLogger, withAudit, withAuditMethods };
-
-//# sourceMappingURL=index.mjs.map

package/dist/{instrumentation-create-BrjQtSKD.d.mts → instrumentation-create-gSDk0leX.d.mts}

@@ -1,4 +1,4 @@
-import { B as DrainContext, H as EnvironmentContext, X as LogLevel, ot as SamplingConfig } from "./audit-D7v6JHj0.mjs";
+import { $ as LogLevel, G as EnvironmentContext, U as DrainContext, lt as SamplingConfig } from "./audit-BZrUvjfW.mjs";
 
 //#region src/next/instrumentation-gate.d.ts
 /** Request payload passed to Next.js `onRequestError` (App Router). */
@@ -112,4 +112,4 @@ interface InstrumentationResult {
 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
+//# sourceMappingURL=instrumentation-create-gSDk0leX.d.mts.map

package/dist/{instrumentation-create-BrjQtSKD.d.mts.map → instrumentation-create-gSDk0leX.d.mts.map}

@@ -1 +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"}
+{"version":3,"file":"instrumentation-create-gSDk0leX.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;;;;UCjFc,oBAAA;EDR0B;ECUzC,MAAA;EDPe;ECSf,MAAA;EDVA;;;;ECeA,MAAA,GAAS,KAAA,UAAe,MAAA;AAAA;;cAIb,6BAAA,EAA+B,KAAA,UAAe,MAAA;;;;;UAiB1C,sBAAA;ED3BH;EC6BZ,OAAA;EDtBe;ECwBf,OAAA;;EAEA,GAAA,GAAM,OAAA,CAAQ,kBAAA;EDvBiB;ECyB/B,MAAA;EDvBW;ECyBX,MAAA;EDxBmB;EC0BnB,QAAA,GAAW,cAAA;ED/BX;ECiCA,QAAA,GAAW,QAAA;EDhCX;ECkCA,SAAA;EDjC+B;ECmC/B,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EDlC3B;ECoCX,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-DYp2uw8O.mjs → integration-CeL90DtN.mjs}

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

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"integration-CeL90DtN.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-mHIWxBhJ.d.mts → logger-CxWz7QJ3.d.mts}

@@ -1,4 +1,4 @@
-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";
+import { G as EnvironmentContext, Q as Log, U as DrainContext, et as LoggerConfig, ht as WideEvent, l as AuditableLogger, pt as TailSamplingContext, st as RequestLoggerOptions, yt as PluginRunner } from "./audit-BZrUvjfW.mjs";
 
 //#region src/logger.d.ts
 /** Cross-bundle global slot for the native stdout write registered by captureOutput patching. */
@@ -38,6 +38,10 @@ declare function lockLogger(): void;
  * @internal Check if the logger has been locked by instrumentation.
  */
 declare function isLoggerLocked(): boolean;
+/**
+ * @internal Whether {@link initLogger} has completed at least once.
+ */
+declare function isLoggerInitialized(): boolean;
 /**
  * @internal Get the globally configured drain callback.
  * Used by framework middleware to fall back to the global drain
@@ -122,5 +126,5 @@ declare function createRequestLogger<T extends object = Record<string, unknown>>
  */
 declare function getEnvironment(): EnvironmentContext;
 //#endregion
-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
+export { getEnvironment as a, initLogger as c, isLoggerLocked as d, lockLogger as f, shouldKeep as h, createRequestLogger as i, isEnabled as l, mergeInto as m, _log as n, getGlobalDrain as o, markWideEventDrainStarted as p, createLogger as r, getGlobalPluginRunner as s, EvlogProcessOutputGlobal as t, isLoggerInitialized as u };
+//# sourceMappingURL=logger-CxWz7QJ3.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger-CxWz7QJ3.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;;;;;iBAuCjC,UAAA,CAAW,MAAA,GAAQ,YAAA;;;;;AAAnC;iBAyCgB,qBAAA,CAAA,GAAyB,YAAA;;;;iBAOzB,SAAA,CAAA;;;;;AAAhB;iBASgB,UAAA,CAAA;;;;iBAOA,cAAA,CAAA;;;;iBAOA,mBAAA,CAAA;AAPhB;;;;;AAAA,iBAgBgB,cAAA,CAAA,KAAoB,GAAA,EAAK,YAAA,YAAwB,OAAA;;;;;iBA8BjD,UAAA,CAAW,GAAA,EAAK,mBAAA;;;;;;;;;AAAhC;cAwgBM,IAAA,EAAM,GAAA;;;AAxfX;UAohBS,2BAAA;;;;AArBY;EA0BpB,WAAA;;;;EAIA,SAAA,IAAa,OAAA,EAAS,OAAA;AAAA;;;;AAkBxB;;;;;;;;;;;;iBAAgB,YAAA,oBAAgC,MAAA,kBAAA,CAAyB,cAAA,GAAgB,MAAA,mBAA8B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;;;;;;AAkOvL;;;;;;;;;;;;;;;;;;;;iBAAgB,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 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 };
+import { a as getEnvironment, c as initLogger, d as isLoggerLocked, f as lockLogger, h as shouldKeep, i as createRequestLogger, l as isEnabled, m as mergeInto, n as _log, o as getGlobalDrain, p as markWideEventDrainStarted, r as createLogger, s as getGlobalPluginRunner, t as EvlogProcessOutputGlobal, u as isLoggerInitialized } from "./logger-CxWz7QJ3.mjs";
+export { EvlogProcessOutputGlobal, createLogger, createRequestLogger, getEnvironment, getGlobalDrain, getGlobalPluginRunner, initLogger, isEnabled, isLoggerInitialized, 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-BQt8yAHo.mjs";
-export { createLogger, createRequestLogger, getEnvironment, getGlobalDrain, getGlobalPluginRunner, initLogger, isEnabled, isLoggerLocked, lockLogger, _log as log, markWideEventDrainStarted, mergeInto as mergeWideEventFields, shouldKeep };
+import { C as isLoggerInitialized, D as mergeInto, E as markWideEventDrainStarted, O as shouldKeep, S as isEnabled, T as lockLogger, _ as createRequestLogger, b as getGlobalPluginRunner, g as createLogger, h as _log, v as getEnvironment, w as isLoggerLocked, x as initLogger, y as getGlobalDrain } from "./audit-BXCYMjcC.mjs";
+export { createLogger, createRequestLogger, getEnvironment, getGlobalDrain, getGlobalPluginRunner, initLogger, isEnabled, isLoggerInitialized, isLoggerLocked, lockLogger, _log as log, markWideEventDrainStarted, mergeInto as mergeWideEventFields, shouldKeep };

package/dist/{fork-CgGlAaHa.mjs → middleware-Cdebyfdt.mjs}

@@ -1,4 +1,4 @@
-import { D as createPluginRunner, E as shouldKeep, F as resolveRedactConfig, M as isGloballyRedacted, P as redactEvent, g as createRequestLogger, j as getEmptyPluginRunner, v as getGlobalDrain, w as markWideEventDrainStarted, x as isEnabled, y as getGlobalPluginRunner } from "./audit-BQt8yAHo.mjs";
+import { E as markWideEventDrainStarted, I as redactEvent, L as resolveRedactConfig, N as getEmptyPluginRunner, O as shouldKeep, P as isGloballyRedacted, S as isEnabled, _ as createRequestLogger, b as getGlobalPluginRunner, k as createPluginRunner, y as getGlobalDrain } from "./audit-BXCYMjcC.mjs";
 import { t as extractErrorStatus } from "./errors-DA0cyr8q.mjs";
 import { n as shouldLog, t as getServiceForPath } from "./routes-4rMzRyTk.mjs";
 import { r as shouldDeferEmitForResponse, t as bindStreamingResponseLifecycle } from "./streamResponse-CmQ3qUbF.mjs";
@@ -182,72 +182,6 @@ function createMiddlewareLogger(options) {
 	};
 }
 //#endregion
-//#region src/shared/fork.ts
-/**
-* Attach {@link RequestLogger.fork} to a request logger. Replaces any existing `fork`.
-*/
-function attachForkToLogger(storage, parent, middlewareOptions, lifecycle) {
-	const log = parent;
-	log.fork = (label, fn) => {
-		forkBackgroundLogger({
-			storage,
-			parent,
-			middlewareOptions,
-			label,
-			fn,
-			lifecycle
-		});
-	};
-}
-/**
-* Run background work under a child request logger so `useLogger()` resolves to the
-* child while `fn` runs. The child emits a separate wide event when `fn` settles,
-* with `operation` and `_parentRequestId` set for correlation.
-*
-* @beta Part of `evlog/toolkit` — used by framework integrations; prefer `log.fork()`
-* on the request logger when available.
-*/
-function forkBackgroundLogger(options) {
-	const { storage, parent, middlewareOptions, label, fn, lifecycle } = options;
-	const parentCtx = parent.getContext();
-	const parentRequestId = parentCtx.requestId;
-	if (typeof parentRequestId !== "string" || parentRequestId.length === 0) throw new Error("[evlog] log.fork() requires the parent logger to have a requestId. Ensure the request was created by evlog middleware.");
-	const method = String(parentCtx.method ?? middlewareOptions.method);
-	const path = String(parentCtx.path ?? middlewareOptions.path);
-	const child = createRequestLogger({
-		method,
-		path,
-		requestId: crypto.randomUUID()
-	}, { _deferDrain: true });
-	child.set({
-		operation: label,
-		_parentRequestId: parentRequestId
-	});
-	const childRequestInfo = {
-		method,
-		path,
-		requestId: child.getContext().requestId
-	};
-	storage.run(child, () => {
-		lifecycle?.onChildEnter?.(child);
-		Promise.resolve().then(() => fn()).then(async () => {
-			const emittedEvent = child.emit();
-			const ctxStatus = child.getContext().status;
-			const status = emittedEvent?.status ?? (typeof ctxStatus === "number" ? ctxStatus : void 0);
-			if (emittedEvent && (middlewareOptions.enrich || middlewareOptions.drain || getGlobalDrain())) await runEnrichAndDrain(emittedEvent, middlewareOptions, childRequestInfo, status);
-		}).catch(async (err) => {
-			const error = err instanceof Error ? err : new Error(String(err));
-			child.error(error);
-			child.set({ status: extractErrorStatus(error) });
-			const emittedEvent = child.emit();
-			const status = extractErrorStatus(error);
-			if (emittedEvent && (middlewareOptions.enrich || middlewareOptions.drain || getGlobalDrain())) await runEnrichAndDrain(emittedEvent, middlewareOptions, childRequestInfo, status);
-		}).finally(() => {
-			lifecycle?.onChildExit?.(child);
-		});
-	});
-}
-//#endregion
-export { runEnrichAndDrain as a, resolveMiddlewarePluginRunner as i, forkBackgroundLogger as n, createMiddlewareLogger as r, attachForkToLogger as t };
+export { resolveMiddlewarePluginRunner as n, runEnrichAndDrain as r, createMiddlewareLogger as t };
 
-//# sourceMappingURL=fork-CgGlAaHa.mjs.map
+//# sourceMappingURL=middleware-Cdebyfdt.mjs.map

package/dist/middleware-Cdebyfdt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-Cdebyfdt.mjs","names":[],"sources":["../src/shared/middleware.ts"],"sourcesContent":["import type { DrainContext, EnrichContext, RedactConfig, RequestLogger, RouteConfig, TailSamplingContext, WideEvent } from '../types'\nimport type { AuditableLogger } from '../audit'\nimport { createRequestLogger, getGlobalDrain, getGlobalPluginRunner, isEnabled, markWideEventDrainStarted, shouldKeep } from '../logger'\nimport { isGloballyRedacted, redactEvent, resolveRedactConfig } from '../redact'\nimport { extractErrorStatus } from './errors'\nimport type { EvlogPlugin, PluginRunner } from './plugin'\nimport { createPluginRunner, getEmptyPluginRunner } from './plugin'\nimport { shouldLog, getServiceForPath } from './routes'\nimport { bindStreamingResponseLifecycle, shouldDeferEmitForResponse } from './streamResponse'\n\n/**\n * Base options shared by every framework integration. Re-exported via\n * `evlog/toolkit` so custom integrations can extend it.\n */\nexport interface BaseEvlogOptions {\n  /** Route glob patterns to include. If unset, all routes are logged. */\n  include?: string[]\n  /** Route glob patterns to exclude. Takes precedence over `include`. */\n  exclude?: string[]\n  /** Per-route service overrides. */\n  routes?: Record<string, RouteConfig>\n  /** Drain callback invoked with every emitted event. */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /** Enrich callback invoked after emit, before drain. */\n  enrich?: (ctx: EnrichContext) => void | Promise<void>\n  /** Tail sampling callback. Set `ctx.shouldKeep = true` to force-keep. */\n  keep?: (ctx: TailSamplingContext) => void | Promise<void>\n  /**\n   * PII auto-redaction. `true` enables built-in patterns; pass an object for\n   * fine-grained control. Applied before enrich/drain.\n   */\n  redact?: boolean | RedactConfig\n  /** Plugins for this middleware, merged with globally-registered ones. */\n  plugins?: EvlogPlugin[]\n}\n\n/** Internal options accepted by `createMiddlewareLogger`. */\nexport interface MiddlewareLoggerOptions extends BaseEvlogOptions {\n  method: string\n  path: string\n  requestId?: string\n  /** Pre-filtered safe request headers used for enrich/drain context. */\n  headers?: Record<string, string>\n}\n\nexport interface MiddlewareLoggerResult {\n  logger: AuditableLogger\n  finish: (opts?: { status?: number; error?: Error }) => Promise<WideEvent | null>\n  /**\n   * Finish request logging, deferring emit until a streaming response body completes.\n   * Returns the original response or a wrapped copy when the body is a stream.\n   */\n  finishResponse: (response: Response, opts?: { status?: number }) => Promise<Response>\n  skipped: boolean\n}\n\nconst noopResult: MiddlewareLoggerResult = {\n  logger: {\n    set() {},\n    error() {},\n    info() {},\n    warn() {},\n    setLevel() {},\n    emit() {\n      return null \n    },\n    getContext() {\n      return {} \n    },\n  },\n  finish: () => Promise.resolve(null),\n  finishResponse: (response) => Promise.resolve(response),\n  skipped: true,\n}\n\n// Memoizes the merged runner per local plugins array (stable across requests\n// because it lives in the middleware factory closure). Invalidated when\n// `initLogger` swaps the global runner, so the merge cost is paid once.\nconst runnerCache = new WeakMap<EvlogPlugin[], { global: PluginRunner; merged: PluginRunner }>()\n\n/**\n * Resolve the plugin runner for a middleware invocation by merging local\n * plugins with the globally-registered ones (deduplicated by `name`).\n */\nexport function resolveMiddlewarePluginRunner(options: { plugins?: EvlogPlugin[] }): PluginRunner {\n  const global = getGlobalPluginRunner()\n  const local = options.plugins\n  if (!local || local.length === 0) return global\n\n  const cached = runnerCache.get(local)\n  if (cached && cached.global === global) return cached.merged\n\n  const merged = new Map<string, EvlogPlugin>()\n  for (const plugin of global.plugins) merged.set(plugin.name, plugin)\n  for (const plugin of local) merged.set(plugin.name, plugin)\n  if (merged.size === 0) return getEmptyPluginRunner()\n\n  const runner = createPluginRunner(Array.from(merged.values()))\n  runnerCache.set(local, { global, merged: runner })\n  return runner\n}\n\n/** Copy redacted fields onto the emitted event without replacing its identity. */\nfunction assignRedactedEvent(target: WideEvent, redacted: Partial<WideEvent>): void {\n  for (const key of Object.keys(target) as Array<keyof WideEvent>) {\n    if (!(key in redacted)) {\n      delete target[key]\n    }\n  }\n  Object.assign(target, redacted)\n}\n\n/**\n * Apply redact, enrich, and drain to an emitted wide event — the same\n * pipeline used by {@link createMiddlewareLogger}'s `finish`.\n */\n// eslint-disable-next-line max-params\nexport async function runEnrichAndDrain(\n  emittedEvent: WideEvent,\n  options: MiddlewareLoggerOptions,\n  requestInfo: { method: string; path: string; requestId?: string },\n  responseStatus?: number,\n  plugins?: PluginRunner,\n): Promise<void> {\n  const runner = plugins ?? resolveMiddlewarePluginRunner(options)\n  const resolvedRedact = resolveRedactConfig(options.redact)\n  if (resolvedRedact && !isGloballyRedacted(emittedEvent)) {\n    assignRedactedEvent(emittedEvent, redactEvent(emittedEvent, resolvedRedact) as Partial<WideEvent>)\n  }\n\n  if (options.enrich || runner.hasEnrich) {\n    const enrichCtx: EnrichContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n      response: { status: responseStatus },\n    }\n    if (options.enrich) {\n      try {\n        await options.enrich(enrichCtx)\n      } catch (err) {\n        console.error('[evlog] enrich failed:', err)\n      }\n    }\n    if (runner.hasEnrich) {\n      await runner.runEnrich(enrichCtx)\n    }\n  }\n\n  markWideEventDrainStarted(emittedEvent)\n\n  const drain = options.drain ?? getGlobalDrain()\n  const hasUserDrain = !!drain\n  const hasPluginDrain = runner.hasDrain\n  if (hasUserDrain || hasPluginDrain) {\n    const drainCtx: DrainContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n    }\n    const tasks: Array<Promise<unknown>> = []\n    if (hasUserDrain) {\n      tasks.push(\n        (async () => {\n          try {\n            await drain!(drainCtx)\n          } catch (err) {\n            console.error('[evlog] drain failed:', err)\n          }\n        })(),\n      )\n    }\n    if (hasPluginDrain) {\n      tasks.push(runner.runDrain(drainCtx))\n    }\n    await Promise.all(tasks)\n  }\n}\n\n/**\n * Create a request logger with the full middleware pipeline: route filtering,\n * service overrides, duration tracking, tail sampling, emit, enrich, drain.\n *\n * Framework adapters extract method/path/requestId/headers, call this once\n * per request, and call `finish({ status | error })` when the response ends.\n * If `skipped` is `true`, the route was filtered out — bypass logging.\n */\nexport function createMiddlewareLogger(options: MiddlewareLoggerOptions): MiddlewareLoggerResult {\n  if (!isEnabled()) return noopResult\n\n  const { method, path, requestId, include, exclude, routes, keep } = options\n\n  if (!shouldLog(path, include, exclude)) {\n    return noopResult\n  }\n\n  const resolvedRequestId = requestId || crypto.randomUUID()\n\n  const logger = createRequestLogger({\n    method,\n    path,\n    requestId: resolvedRequestId,\n  }, { _deferDrain: true })\n\n  const routeService = getServiceForPath(path, routes)\n  if (routeService) {\n    logger.set({ service: routeService })\n  }\n\n  const pluginRunner = resolveMiddlewarePluginRunner(options)\n  if (pluginRunner.hasExtendLogger) {\n    pluginRunner.applyExtendLogger(logger)\n  }\n\n  const startTime = Date.now()\n  const requestInfo = { method, path, requestId: resolvedRequestId }\n\n  if (pluginRunner.hasRequestLifecycle) {\n    pluginRunner.runOnRequestStart({\n      logger,\n      request: requestInfo,\n      headers: options.headers,\n    })\n  }\n\n  const finish = (opts?: { status?: number; error?: Error }): Promise<WideEvent | null> => {\n    return performFinish(logger, opts)\n  }\n\n  const finishResponse = async (response: Response, opts?: { status?: number }): Promise<Response> => {\n    const status = opts?.status ?? response.status\n    if (!shouldDeferEmitForResponse(response)) {\n      await performFinish(logger, { status })\n      return response\n    }\n\n    return bindStreamingResponseLifecycle(response, async (meta) => {\n      await performFinish(logger, {\n        status: meta.status ?? status,\n        error: meta.error,\n      })\n    })\n  }\n\n  async function performFinish(\n    requestLogger: RequestLogger,\n    opts?: { status?: number; error?: Error },\n  ): Promise<WideEvent | null> {\n    const { status, error } = opts ?? {}\n\n    if (error) {\n      requestLogger.error(error)\n      const errorStatus = extractErrorStatus(error)\n      requestLogger.set({ status: errorStatus })\n    } else if (status !== undefined) {\n      requestLogger.set({ status })\n    }\n\n    const durationMs = Date.now() - startTime\n\n    const resolvedStatus = error\n      ? extractErrorStatus(error)\n      : status ?? (requestLogger.getContext().status as number | undefined)\n\n    const tailCtx: TailSamplingContext = {\n      status: resolvedStatus,\n      duration: durationMs,\n      path,\n      method,\n      context: requestLogger.getContext(),\n      shouldKeep: false,\n    }\n\n    if (keep) {\n      await keep(tailCtx)\n    }\n    if (pluginRunner.hasKeep) {\n      await pluginRunner.runKeep(tailCtx)\n    }\n\n    const forceKeep = tailCtx.shouldKeep || shouldKeep(tailCtx)\n    const emittedEvent = requestLogger.emit({ _forceKeep: forceKeep })\n\n    if (\n      emittedEvent\n      && (options.enrich || options.drain || pluginRunner.hasEnrich || pluginRunner.hasDrain || getGlobalDrain())\n    ) {\n      await runEnrichAndDrain(emittedEvent, options, requestInfo, resolvedStatus, pluginRunner)\n    }\n\n    if (pluginRunner.hasRequestLifecycle) {\n      pluginRunner.runOnRequestFinish({\n        logger: requestLogger,\n        request: requestInfo,\n        headers: options.headers,\n        event: emittedEvent,\n        status: resolvedStatus,\n        durationMs,\n        error,\n      })\n    }\n\n    return emittedEvent\n  }\n\n  return { logger, finish, finishResponse, skipped: false }\n}\n"],"mappings":"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"}

package/dist/{middleware-B_k4Mrzg.d.mts → middleware-fbtEs6bq.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-D7v6JHj0.mjs";
+import { U as DrainContext, W as EnrichContext, ct as RouteConfig, ht as WideEvent, l as AuditableLogger, nt as RedactConfig, pt as TailSamplingContext, vt as EvlogPlugin, yt as PluginRunner } from "./audit-BZrUvjfW.mjs";
 
 //#region src/shared/middleware.d.ts
 /**
@@ -35,7 +35,7 @@ interface MiddlewareLoggerOptions extends BaseEvlogOptions {
   headers?: Record<string, string>;
 }
 interface MiddlewareLoggerResult {
-  logger: RequestLogger;
+  logger: AuditableLogger;
   finish: (opts?: {
     status?: number;
     error?: Error;
@@ -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-B_k4Mrzg.d.mts.map
+//# sourceMappingURL=middleware-fbtEs6bq.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-fbtEs6bq.d.mts","names":[],"sources":["../src/shared/middleware.ts"],"mappings":";;;AAcA;;;;AAAA,UAAiB,gBAAA;EAQD;EANd,OAAA;EAQe;EANf,OAAA;EAQa;EANb,MAAA,GAAS,MAAA,SAAe,WAAA;EAWL;EATnB,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAWjB;EATrB,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EARxC;EAUA,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;EAN5C;;;;EAWA,MAAA,aAAmB,YAAA;EATV;EAWT,OAAA,GAAU,WAAA;AAAA;;UAIK,uBAAA,SAAgC,gBAAA;EAC/C,MAAA;EACA,IAAA;EACA,SAAA;EAdQ;EAgBR,OAAA,GAAU,MAAA;AAAA;AAAA,UAGK,sBAAA;EACf,MAAA,EAAQ,eAAA;EACR,MAAA,GAAS,IAAA;IAAS,MAAA;IAAiB,KAAA,GAAQ,KAAA;EAAA,MAAY,OAAA,CAAQ,SAAA;EAVxB;;;;EAevC,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,9 +1,9 @@
-import { rt as RequestLogger } from "../audit-D7v6JHj0.mjs";
-import { t as BaseEvlogOptions } from "../middleware-B_k4Mrzg.mjs";
+import { l as AuditableLogger } from "../audit-BZrUvjfW.mjs";
+import { t as BaseEvlogOptions } from "../middleware-fbtEs6bq.mjs";
 import { DynamicModule, MiddlewareConsumer, NestModule } from "@nestjs/common";
 
 //#region src/nestjs/index.d.ts
-declare const useLogger: <T extends object = Record<string, unknown>>() => RequestLogger<T>;
+declare const useLogger: <T extends object = Record<string, unknown>>() => AuditableLogger<T>;
 type EvlogNestJSOptions = BaseEvlogOptions;
 interface EvlogModuleAsyncOptions {
   /** Modules to import (for dependency injection into the factory) */
@@ -15,12 +15,12 @@ interface EvlogModuleAsyncOptions {
 }
 declare module 'http' {
   interface IncomingMessage {
-    log?: RequestLogger;
+    log?: AuditableLogger;
   }
 }
 declare module 'express-serve-static-core' {
   interface Request {
-    log?: RequestLogger;
+    log?: AuditableLogger;
   }
 }
 /**

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,8 @@
 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 { t as createMiddlewareLogger } from "../middleware-Cdebyfdt.mjs";
+import { t as attachForkToLogger } from "../fork-S9gpZmF8.mjs";
+import { t as bindNodeResponseLifecycle } from "../nodeResponse-Dsl7gZUf.mjs";
+import { t as createLoggerStorage } from "../storage-BeFdoGTI.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-BZrUvjfW.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-BZrUvjfW.mjs";
+import { n as createError } from "../error-BRymuv8U.mjs";
+import { n as _log } from "../logger-CxWz7QJ3.mjs";
+import { t as BaseEvlogOptions } from "../middleware-fbtEs6bq.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 { E as markWideEventDrainStarted, S as isEnabled, _ as createRequestLogger, h as _log, w as isLoggerLocked, x as initLogger, y as getGlobalDrain } from "../audit-BXCYMjcC.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-S9gpZmF8.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-KB0Oap7R.mjs");
 	enrichErrorStackFromNextDev(error);
 }
 //#endregion