evlog 2.12.0 → 2.14.0

package/dist/express/index.mjs

@@ -1,5 +1,7 @@
-import { n as extractSafeNodeHeaders, r as createMiddlewareLogger } from "../headers-ht4yS2mx.mjs";
-import { t as createLoggerStorage } from "../storage-DpLJYMoc.mjs";
+import { t as createMiddlewareLogger } from "../middleware-BWOJ7JI0.mjs";
+import { t as attachForkToLogger } from "../fork-CTJXnpl8.mjs";
+import { n as extractSafeNodeHeaders } from "../headers-D74M0wsg.mjs";
+import { t as createLoggerStorage } from "../storage-CFGTn37X.mjs";
 //#region src/express/index.ts
 const { storage, useLogger } = createLoggerStorage("middleware context. Make sure app.use(evlog()) is registered before your routes.");
 /**
@@ -22,17 +24,19 @@ const { storage, useLogger } = createLoggerStorage("middleware context. Make sur
 */
 function evlog(options = {}) {
 	return (req, res, next) => {
-		const { logger, finish, skipped } = createMiddlewareLogger({
+		const middlewareOpts = {
 			method: req.method,
 			path: new URL(req.originalUrl || req.url || "/", "http://localhost").pathname,
 			requestId: req.get("x-request-id") || crypto.randomUUID(),
 			headers: extractSafeNodeHeaders(req.headers),
 			...options
-		});
+		};
+		const { logger, finish, skipped } = createMiddlewareLogger(middlewareOpts);
 		if (skipped) {
 			next();
 			return;
 		}
+		attachForkToLogger(storage, logger, middlewareOpts);
 		req.log = logger;
 		res.on("finish", () => {
 			finish({ status: res.statusCode }).catch(() => {});

package/dist/express/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/express/index.ts"],"sourcesContent":["import type { Request, Response, NextFunction, RequestHandler } from 'express'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { extractSafeNodeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'middleware context. Make sure app.use(evlog()) is registered before your routes.',\n)\n\nexport type EvlogExpressOptions = BaseEvlogOptions\n\nexport { useLogger }\n\ndeclare module 'express-serve-static-core' {\n  interface Request {\n    log: RequestLogger\n  }\n}\n\n/**\n * Create an evlog middleware for Express.\n *\n * @example\n * ```ts\n * import express from 'express'\n * import { evlog } from 'evlog/express'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = express()\n * app.use(evlog({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * }))\n * ```\n */\nexport function evlog(options: EvlogExpressOptions = {}): RequestHandler {\n  return (req: Request, res: Response, next: NextFunction) => {\n    const { logger, finish, skipped } = createMiddlewareLogger({\n      method: req.method,\n      path: new URL(req.originalUrl || req.url || '/', 'http://localhost').pathname,\n      requestId: req.get('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeNodeHeaders(req.headers),\n      ...options,\n    })\n\n    if (skipped) {\n      next()\n      return\n    }\n\n    req.log = logger\n\n    res.on('finish', () => {\n      finish({ status: res.statusCode }).catch(() => {})\n    })\n\n    storage.run(logger, () => next())\n  }\n}\n"],"mappings":";;;AAMA,MAAM,EAAE,SAAS,cAAc,oBAC7B,mFACD;;;;;;;;;;;;;;;;;;;AA8BD,SAAgB,MAAM,UAA+B,EAAE,EAAkB;AACvE,SAAQ,KAAc,KAAe,SAAuB;EAC1D,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,IAAI;GACZ,MAAM,IAAI,IAAI,IAAI,eAAe,IAAI,OAAO,KAAK,mBAAmB,CAAC;GACrE,WAAW,IAAI,IAAI,eAAe,IAAI,OAAO,YAAY;GACzD,SAAS,uBAAuB,IAAI,QAAQ;GAC5C,GAAG;GACJ,CAAC;AAEF,MAAI,SAAS;AACX,SAAM;AACN;;AAGF,MAAI,MAAM;AAEV,MAAI,GAAG,gBAAgB;AACrB,UAAO,EAAE,QAAQ,IAAI,YAAY,CAAC,CAAC,YAAY,GAAG;IAClD;AAEF,UAAQ,IAAI,cAAc,MAAM,CAAC"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/express/index.ts"],"sourcesContent":["import type { Request, Response, NextFunction, RequestHandler } from 'express'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeNodeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'middleware context. Make sure app.use(evlog()) is registered before your routes.',\n)\n\nexport type EvlogExpressOptions = BaseEvlogOptions\n\nexport { useLogger }\n\ndeclare module 'express-serve-static-core' {\n  interface Request {\n    log: RequestLogger\n  }\n}\n\n/**\n * Create an evlog middleware for Express.\n *\n * @example\n * ```ts\n * import express from 'express'\n * import { evlog } from 'evlog/express'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = express()\n * app.use(evlog({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * }))\n * ```\n */\nexport function evlog(options: EvlogExpressOptions = {}): RequestHandler {\n  return (req: Request, res: Response, next: NextFunction) => {\n    const middlewareOpts = {\n      method: req.method,\n      path: new URL(req.originalUrl || req.url || '/', 'http://localhost').pathname,\n      requestId: req.get('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeNodeHeaders(req.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    res.on('finish', () => {\n      finish({ status: res.statusCode }).catch(() => {})\n    })\n\n    storage.run(logger, () => next())\n  }\n}\n"],"mappings":";;;;;AAOA,MAAM,EAAE,SAAS,cAAc,oBAC7B,mFACD;;;;;;;;;;;;;;;;;;;AA8BD,SAAgB,MAAM,UAA+B,EAAE,EAAkB;AACvE,SAAQ,KAAc,KAAe,SAAuB;EAC1D,MAAM,iBAAiB;GACrB,QAAQ,IAAI;GACZ,MAAM,IAAI,IAAI,IAAI,eAAe,IAAI,OAAO,KAAK,mBAAmB,CAAC;GACrE,WAAW,IAAI,IAAI,eAAe,IAAI,OAAO,YAAY;GACzD,SAAS,uBAAuB,IAAI,QAAQ;GAC5C,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,MAAI,GAAG,gBAAgB;AACrB,UAAO,EAAE,QAAQ,IAAI,YAAY,CAAC,CAAC,YAAY,GAAG;IAClD;AAEF,UAAQ,IAAI,cAAc,MAAM,CAAC"}

package/dist/fastify/index.d.mts

@@ -1,5 +1,5 @@
-import { _ as RequestLogger } from "../types-D5OwxZCw.mjs";
-import { t as BaseEvlogOptions } from "../middleware-D_igVy93.mjs";
+import { Y as RequestLogger } from "../audit-mUutdf6A.mjs";
+import { t as BaseEvlogOptions } from "../middleware-BYf26Lfu.mjs";
 import { FastifyPluginCallback } from "fastify";
 
 //#region src/fastify/index.d.ts

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/fastify/index.ts"],"mappings":";;;;;cAKiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,mBAAA,GAAsB,gBAAA;AAAA;EAAA,UAKtB,cAAA;IAER,GAAA;EAAA;AAAA;;;;;;;;;;;AAPJ;;;;;AAEoB;;;;;;cAyFP,KAAA,EAAK,qBAAA,CAAA,gBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/fastify/index.ts"],"mappings":";;;;;cAMiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,mBAAA,GAAsB,gBAAA;AAAA;EAAA,UAKtB,cAAA;IAER,GAAA;EAAA;AAAA;;;;;;;;;;;AAPJ;;;;;AAEoB;;;;;;cA4FP,KAAA,EAAK,qBAAA,CAAA,gBAAA"}

package/dist/fastify/index.mjs

@@ -1,5 +1,7 @@
-import { n as extractSafeNodeHeaders, r as createMiddlewareLogger } from "../headers-ht4yS2mx.mjs";
-import { t as createLoggerStorage } from "../storage-DpLJYMoc.mjs";
+import { t as createMiddlewareLogger } from "../middleware-BWOJ7JI0.mjs";
+import { t as attachForkToLogger } from "../fork-CTJXnpl8.mjs";
+import { n as extractSafeNodeHeaders } from "../headers-D74M0wsg.mjs";
+import { t as createLoggerStorage } from "../storage-CFGTn37X.mjs";
 //#region src/fastify/index.ts
 const { storage, useLogger } = createLoggerStorage("plugin context. Make sure app.register(evlog) is called before your routes.");
 const evlogPlugin = (fastify, options, done) => {
@@ -8,17 +10,19 @@ const evlogPlugin = (fastify, options, done) => {
 	fastify.addHook("onRequest", (request, _reply, done) => {
 		const headers = extractSafeNodeHeaders(request.headers);
 		const path = new URL(request.url, "http://localhost").pathname;
-		const { logger, finish, skipped } = createMiddlewareLogger({
+		const middlewareOpts = {
 			method: request.method,
 			path,
 			requestId: headers["x-request-id"] || crypto.randomUUID(),
 			headers,
 			...options
-		});
+		};
+		const { logger, finish, skipped } = createMiddlewareLogger(middlewareOpts);
 		if (skipped) {
 			done();
 			return;
 		}
+		attachForkToLogger(storage, logger, middlewareOpts);
 		const req = request;
 		req.log = logger;
 		requestState.set(request, { finish });

package/dist/fastify/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/fastify/index.ts"],"sourcesContent":["import type { FastifyPluginCallback } from 'fastify'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { extractSafeNodeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'plugin context. Make sure app.register(evlog) is called before your routes.',\n)\n\nexport type EvlogFastifyOptions = BaseEvlogOptions\n\nexport { useLogger }\n\ndeclare module 'fastify' {\n  interface FastifyRequest {\n    // Overrides Fastify's built-in pino logger on the request with evlog's RequestLogger.\n    log: any\n  }\n}\n\ninterface RequestState {\n  finish: (opts?: { status?: number; error?: Error }) => Promise<unknown>\n}\n\nconst evlogPlugin: FastifyPluginCallback<EvlogFastifyOptions> = (fastify, options, done) => {\n  const emitted = new WeakSet<object>()\n  const requestState = new WeakMap<object, RequestState>()\n\n  fastify.addHook('onRequest', (request, _reply, done) => {\n    const headers = extractSafeNodeHeaders(request.headers)\n    const path = new URL(request.url, 'http://localhost').pathname\n\n    const { logger, finish, skipped } = createMiddlewareLogger({\n      method: request.method,\n      path,\n      requestId: headers['x-request-id'] || crypto.randomUUID(),\n      headers,\n      ...options,\n    })\n\n    if (skipped) {\n      done()\n      return\n    }\n\n    // Shadow Fastify's built-in pino logger with evlog's request-scoped logger\n    const req = request as any\n    req.log = logger\n    requestState.set(request, { finish })\n\n    storage.run(logger, () => done())\n  })\n\n  fastify.addHook('onResponse', async (request, reply) => {\n    const state = requestState.get(request)\n    if (!state || emitted.has(request)) return\n    emitted.add(request)\n    await state.finish({ status: reply.statusCode })\n  })\n\n  fastify.addHook('onError', async (request, _reply, error) => {\n    const state = requestState.get(request)\n    if (!state || emitted.has(request)) return\n    emitted.add(request)\n    const logger = (request as any).log\n    const err = error instanceof Error ? error : new Error(String(error))\n    if (logger && typeof logger.error === 'function') logger.error(err)\n    await state.finish({ error: err })\n  })\n\n  done()\n}\n\n// Break Fastify plugin encapsulation without a runtime dependency on fastify-plugin.\n// This is the same mechanism fastify-plugin uses internally.\nconst plugin = evlogPlugin as any\nplugin[Symbol.for('skip-override')] = true\nplugin[Symbol.for('fastify.display-name')] = 'evlog'\n\n/**\n * Create an evlog plugin for Fastify.\n *\n * @example\n * ```ts\n * import Fastify from 'fastify'\n * import { initLogger } from 'evlog'\n * import { evlog } from 'evlog/fastify'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * initLogger({ env: { service: 'fastify-api' } })\n *\n * const app = Fastify()\n * await app.register(evlog, {\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * })\n * ```\n */\nexport const evlog = evlogPlugin\n"],"mappings":";;;AAKA,MAAM,EAAE,SAAS,cAAc,oBAC7B,8EACD;AAiBD,MAAM,eAA2D,SAAS,SAAS,SAAS;CAC1F,MAAM,0BAAU,IAAI,SAAiB;CACrC,MAAM,+BAAe,IAAI,SAA+B;AAExD,SAAQ,QAAQ,cAAc,SAAS,QAAQ,SAAS;EACtD,MAAM,UAAU,uBAAuB,QAAQ,QAAQ;EACvD,MAAM,OAAO,IAAI,IAAI,QAAQ,KAAK,mBAAmB,CAAC;EAEtD,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,QAAQ;GAChB;GACA,WAAW,QAAQ,mBAAmB,OAAO,YAAY;GACzD;GACA,GAAG;GACJ,CAAC;AAEF,MAAI,SAAS;AACX,SAAM;AACN;;EAIF,MAAM,MAAM;AACZ,MAAI,MAAM;AACV,eAAa,IAAI,SAAS,EAAE,QAAQ,CAAC;AAErC,UAAQ,IAAI,cAAc,MAAM,CAAC;GACjC;AAEF,SAAQ,QAAQ,cAAc,OAAO,SAAS,UAAU;EACtD,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,QAAQ,IAAI,QAAQ,CAAE;AACpC,UAAQ,IAAI,QAAQ;AACpB,QAAM,MAAM,OAAO,EAAE,QAAQ,MAAM,YAAY,CAAC;GAChD;AAEF,SAAQ,QAAQ,WAAW,OAAO,SAAS,QAAQ,UAAU;EAC3D,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,QAAQ,IAAI,QAAQ,CAAE;AACpC,UAAQ,IAAI,QAAQ;EACpB,MAAM,SAAU,QAAgB;EAChC,MAAM,MAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC;AACrE,MAAI,UAAU,OAAO,OAAO,UAAU,WAAY,QAAO,MAAM,IAAI;AACnE,QAAM,MAAM,OAAO,EAAE,OAAO,KAAK,CAAC;GAClC;AAEF,OAAM;;AAKR,MAAM,SAAS;AACf,OAAO,OAAO,IAAI,gBAAgB,IAAI;AACtC,OAAO,OAAO,IAAI,uBAAuB,IAAI;;;;;;;;;;;;;;;;;;;;;;AAuB7C,MAAa,QAAQ"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/fastify/index.ts"],"sourcesContent":["import type { FastifyPluginCallback } from 'fastify'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeNodeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'plugin context. Make sure app.register(evlog) is called before your routes.',\n)\n\nexport type EvlogFastifyOptions = BaseEvlogOptions\n\nexport { useLogger }\n\ndeclare module 'fastify' {\n  interface FastifyRequest {\n    // Overrides Fastify's built-in pino logger on the request with evlog's RequestLogger.\n    log: any\n  }\n}\n\ninterface RequestState {\n  finish: (opts?: { status?: number; error?: Error }) => Promise<unknown>\n}\n\nconst evlogPlugin: FastifyPluginCallback<EvlogFastifyOptions> = (fastify, options, done) => {\n  const emitted = new WeakSet<object>()\n  const requestState = new WeakMap<object, RequestState>()\n\n  fastify.addHook('onRequest', (request, _reply, done) => {\n    const headers = extractSafeNodeHeaders(request.headers)\n    const path = new URL(request.url, 'http://localhost').pathname\n\n    const middlewareOpts = {\n      method: request.method,\n      path,\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      done()\n      return\n    }\n\n    attachForkToLogger(storage, logger, middlewareOpts)\n\n    // Shadow Fastify's built-in pino logger with evlog's request-scoped logger\n    const req = request as any\n    req.log = logger\n    requestState.set(request, { finish })\n\n    storage.run(logger, () => done())\n  })\n\n  fastify.addHook('onResponse', async (request, reply) => {\n    const state = requestState.get(request)\n    if (!state || emitted.has(request)) return\n    emitted.add(request)\n    await state.finish({ status: reply.statusCode })\n  })\n\n  fastify.addHook('onError', async (request, _reply, error) => {\n    const state = requestState.get(request)\n    if (!state || emitted.has(request)) return\n    emitted.add(request)\n    const logger = (request as any).log\n    const err = error instanceof Error ? error : new Error(String(error))\n    if (logger && typeof logger.error === 'function') logger.error(err)\n    await state.finish({ error: err })\n  })\n\n  done()\n}\n\n// Break Fastify plugin encapsulation without a runtime dependency on fastify-plugin.\n// This is the same mechanism fastify-plugin uses internally.\nconst plugin = evlogPlugin as any\nplugin[Symbol.for('skip-override')] = true\nplugin[Symbol.for('fastify.display-name')] = 'evlog'\n\n/**\n * Create an evlog plugin for Fastify.\n *\n * @example\n * ```ts\n * import Fastify from 'fastify'\n * import { initLogger } from 'evlog'\n * import { evlog } from 'evlog/fastify'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * initLogger({ env: { service: 'fastify-api' } })\n *\n * const app = Fastify()\n * await app.register(evlog, {\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * })\n * ```\n */\nexport const evlog = evlogPlugin\n"],"mappings":";;;;;AAMA,MAAM,EAAE,SAAS,cAAc,oBAC7B,8EACD;AAiBD,MAAM,eAA2D,SAAS,SAAS,SAAS;CAC1F,MAAM,0BAAU,IAAI,SAAiB;CACrC,MAAM,+BAAe,IAAI,SAA+B;AAExD,SAAQ,QAAQ,cAAc,SAAS,QAAQ,SAAS;EACtD,MAAM,UAAU,uBAAuB,QAAQ,QAAQ;EACvD,MAAM,OAAO,IAAI,IAAI,QAAQ,KAAK,mBAAmB,CAAC;EAEtD,MAAM,iBAAiB;GACrB,QAAQ,QAAQ;GAChB;GACA,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;EAGnD,MAAM,MAAM;AACZ,MAAI,MAAM;AACV,eAAa,IAAI,SAAS,EAAE,QAAQ,CAAC;AAErC,UAAQ,IAAI,cAAc,MAAM,CAAC;GACjC;AAEF,SAAQ,QAAQ,cAAc,OAAO,SAAS,UAAU;EACtD,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,QAAQ,IAAI,QAAQ,CAAE;AACpC,UAAQ,IAAI,QAAQ;AACpB,QAAM,MAAM,OAAO,EAAE,QAAQ,MAAM,YAAY,CAAC;GAChD;AAEF,SAAQ,QAAQ,WAAW,OAAO,SAAS,QAAQ,UAAU;EAC3D,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,QAAQ,IAAI,QAAQ,CAAE;AACpC,UAAQ,IAAI,QAAQ;EACpB,MAAM,SAAU,QAAgB;EAChC,MAAM,MAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC;AACrE,MAAI,UAAU,OAAO,OAAO,UAAU,WAAY,QAAO,MAAM,IAAI;AACnE,QAAM,MAAM,OAAO,EAAE,OAAO,KAAK,CAAC;GAClC;AAEF,OAAM;;AAKR,MAAM,SAAS;AACf,OAAO,OAAO,IAAI,gBAAgB,IAAI;AACtC,OAAO,OAAO,IAAI,uBAAuB,IAAI;;;;;;;;;;;;;;;;;;;;;;AAuB7C,MAAa,QAAQ"}

package/dist/fork-CTJXnpl8.mjs

@@ -0,0 +1,72 @@
+import { g as createRequestLogger, v as getGlobalDrain } from "./audit-d9esRZOK.mjs";
+import { t as extractErrorStatus } from "./errors-BJRXUfMg.mjs";
+import { n as runEnrichAndDrain } from "./middleware-BWOJ7JI0.mjs";
+//#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 { forkBackgroundLogger as n, attachForkToLogger as t };
+
+//# sourceMappingURL=fork-CTJXnpl8.mjs.map

package/dist/fork-CTJXnpl8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork-CTJXnpl8.mjs","names":[],"sources":["../src/shared/fork.ts"],"sourcesContent":["import type { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\nimport { createRequestLogger, getGlobalDrain } from '../logger'\nimport { extractErrorStatus } from './errors'\nimport type { MiddlewareLoggerOptions } from './middleware'\nimport { runEnrichAndDrain } from './middleware'\n\n/**\n * Optional hooks for integrations that track active loggers (e.g. Elysia `activeLoggers`).\n */\nexport interface ForkLifecycle {\n  /** Called after the child logger is installed in storage, before `fn` runs. */\n  onChildEnter?: (child: RequestLogger) => void\n  /** Called after the child has finished (emit + enrich/drain), success or failure. */\n  onChildExit?: (child: RequestLogger) => void\n}\n\n/**\n * Options for {@link forkBackgroundLogger}.\n *\n * @beta Part of `evlog/toolkit`\n */\nexport interface ForkBackgroundLoggerOptions {\n  storage: AsyncLocalStorage<RequestLogger>\n  parent: RequestLogger\n  middlewareOptions: MiddlewareLoggerOptions\n  label: string\n  fn: () => void | Promise<void>\n  lifecycle?: ForkLifecycle\n}\n\n/**\n * Attach {@link RequestLogger.fork} to a request logger. Replaces any existing `fork`.\n */\nexport function attachForkToLogger(\n  storage: AsyncLocalStorage<RequestLogger>,\n  parent: RequestLogger,\n  middlewareOptions: MiddlewareLoggerOptions,\n  lifecycle?: ForkLifecycle,\n): void {\n  const log = parent as RequestLogger & { fork?: (label: string, fn: () => void | Promise<void>) => void }\n  log.fork = (label: string, fn: () => void | Promise<void>) => {\n    forkBackgroundLogger({ storage, parent, middlewareOptions, label, fn, lifecycle })\n  }\n}\n\n/**\n * Run background work under a child request logger so `useLogger()` resolves to the\n * child while `fn` runs. The child emits a separate wide event when `fn` settles,\n * with `operation` and `_parentRequestId` set for correlation.\n *\n * @beta Part of `evlog/toolkit` — used by framework integrations; prefer `log.fork()`\n * on the request logger when available.\n */\nexport function forkBackgroundLogger(options: ForkBackgroundLoggerOptions): void {\n  const { storage, parent, middlewareOptions, label, fn, lifecycle } = options\n\n  const parentCtx = parent.getContext() as Record<string, unknown>\n  const parentRequestId = parentCtx.requestId\n  if (typeof parentRequestId !== 'string' || parentRequestId.length === 0) {\n    throw new Error(\n      '[evlog] log.fork() requires the parent logger to have a requestId. '\n      + 'Ensure the request was created by evlog middleware.',\n    )\n  }\n\n  const method = String(parentCtx.method ?? middlewareOptions.method)\n  const path = String(parentCtx.path ?? middlewareOptions.path)\n\n  const child = createRequestLogger(\n    {\n      method,\n      path,\n      requestId: crypto.randomUUID(),\n    },\n    { _deferDrain: true },\n  )\n\n  child.set({\n    operation: label,\n    _parentRequestId: parentRequestId,\n  })\n\n  const childRequestInfo = {\n    method,\n    path,\n    requestId: child.getContext().requestId as string,\n  }\n\n  storage.run(child, () => {\n    lifecycle?.onChildEnter?.(child)\n    void Promise.resolve()\n      .then(() => fn())\n      .then(async () => {\n        const emittedEvent = child.emit()\n        const ctxStatus = child.getContext().status\n        const status = (emittedEvent?.status\n          ?? (typeof ctxStatus === 'number' ? ctxStatus : undefined)) as number | undefined\n        if (\n          emittedEvent\n          && (middlewareOptions.enrich || middlewareOptions.drain || getGlobalDrain())\n        ) {\n          await runEnrichAndDrain(emittedEvent, middlewareOptions, childRequestInfo, status)\n        }\n      })\n      .catch(async (err: unknown) => {\n        const error = err instanceof Error ? err : new Error(String(err))\n        child.error(error)\n        child.set({ status: extractErrorStatus(error) })\n        const emittedEvent = child.emit()\n        const status = extractErrorStatus(error)\n        if (\n          emittedEvent\n          && (middlewareOptions.enrich || middlewareOptions.drain || getGlobalDrain())\n        ) {\n          await runEnrichAndDrain(emittedEvent, middlewareOptions, childRequestInfo, status)\n        }\n      })\n      .finally(() => {\n        lifecycle?.onChildExit?.(child)\n      })\n  })\n}\n"],"mappings":";;;;;;;AAkCA,SAAgB,mBACd,SACA,QACA,mBACA,WACM;CACN,MAAM,MAAM;AACZ,KAAI,QAAQ,OAAe,OAAmC;AAC5D,uBAAqB;GAAE;GAAS;GAAQ;GAAmB;GAAO;GAAI;GAAW,CAAC;;;;;;;;;;;AAYtF,SAAgB,qBAAqB,SAA4C;CAC/E,MAAM,EAAE,SAAS,QAAQ,mBAAmB,OAAO,IAAI,cAAc;CAErE,MAAM,YAAY,OAAO,YAAY;CACrC,MAAM,kBAAkB,UAAU;AAClC,KAAI,OAAO,oBAAoB,YAAY,gBAAgB,WAAW,EACpE,OAAM,IAAI,MACR,yHAED;CAGH,MAAM,SAAS,OAAO,UAAU,UAAU,kBAAkB,OAAO;CACnE,MAAM,OAAO,OAAO,UAAU,QAAQ,kBAAkB,KAAK;CAE7D,MAAM,QAAQ,oBACZ;EACE;EACA;EACA,WAAW,OAAO,YAAY;EAC/B,EACD,EAAE,aAAa,MAAM,CACtB;AAED,OAAM,IAAI;EACR,WAAW;EACX,kBAAkB;EACnB,CAAC;CAEF,MAAM,mBAAmB;EACvB;EACA;EACA,WAAW,MAAM,YAAY,CAAC;EAC/B;AAED,SAAQ,IAAI,aAAa;AACvB,aAAW,eAAe,MAAM;AAC3B,UAAQ,SAAS,CACnB,WAAW,IAAI,CAAC,CAChB,KAAK,YAAY;GAChB,MAAM,eAAe,MAAM,MAAM;GACjC,MAAM,YAAY,MAAM,YAAY,CAAC;GACrC,MAAM,SAAU,cAAc,WACxB,OAAO,cAAc,WAAW,YAAY,KAAA;AAClD,OACE,iBACI,kBAAkB,UAAU,kBAAkB,SAAS,gBAAgB,EAE3E,OAAM,kBAAkB,cAAc,mBAAmB,kBAAkB,OAAO;IAEpF,CACD,MAAM,OAAO,QAAiB;GAC7B,MAAM,QAAQ,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,IAAI,CAAC;AACjE,SAAM,MAAM,MAAM;AAClB,SAAM,IAAI,EAAE,QAAQ,mBAAmB,MAAM,EAAE,CAAC;GAChD,MAAM,eAAe,MAAM,MAAM;GACjC,MAAM,SAAS,mBAAmB,MAAM;AACxC,OACE,iBACI,kBAAkB,UAAU,kBAAkB,SAAS,gBAAgB,EAE3E,OAAM,kBAAkB,cAAc,mBAAmB,kBAAkB,OAAO;IAEpF,CACD,cAAc;AACb,cAAW,cAAc,MAAM;IAC/B;GACJ"}

package/dist/headers-D74M0wsg.mjs

@@ -0,0 +1,30 @@
+import { filterSafeHeaders } from "./utils.mjs";
+//#region src/shared/headers.ts
+/**
+* Extract headers from a Web API `Headers` object and filter out sensitive ones.
+* Works with any runtime that supports the standard `Headers` API (Hono, Elysia,
+* Nitro v3, Cloudflare Workers, Bun, Deno, etc.).
+*/
+function extractSafeHeaders(headers) {
+	const raw = {};
+	headers.forEach((value, key) => {
+		raw[key] = value;
+	});
+	return filterSafeHeaders(raw);
+}
+/**
+* Extract headers from Node.js `IncomingHttpHeaders` and filter out sensitive ones.
+* Works with Express, Fastify, and any Node.js HTTP server using `req.headers`.
+*/
+function extractSafeNodeHeaders(headers) {
+	const raw = {};
+	for (const [key, value] of Object.entries(headers)) {
+		if (value === void 0) continue;
+		raw[key] = Array.isArray(value) ? value.join(", ") : value;
+	}
+	return filterSafeHeaders(raw);
+}
+//#endregion
+export { extractSafeNodeHeaders as n, extractSafeHeaders as t };
+
+//# sourceMappingURL=headers-D74M0wsg.mjs.map

package/dist/headers-D74M0wsg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers-D74M0wsg.mjs","names":[],"sources":["../src/shared/headers.ts"],"sourcesContent":["import { filterSafeHeaders } from '../utils'\n\n/**\n * Extract headers from a Web API `Headers` object and filter out sensitive ones.\n * Works with any runtime that supports the standard `Headers` API (Hono, Elysia,\n * Nitro v3, Cloudflare Workers, Bun, Deno, etc.).\n */\nexport function extractSafeHeaders(headers: Headers): Record<string, string> {\n  const raw: Record<string, string> = {}\n  headers.forEach((value, key) => {\n    raw[key] = value\n  })\n  return filterSafeHeaders(raw)\n}\n\n/**\n * Extract headers from Node.js `IncomingHttpHeaders` and filter out sensitive ones.\n * Works with Express, Fastify, and any Node.js HTTP server using `req.headers`.\n */\nexport function extractSafeNodeHeaders(headers: Record<string, string | string[] | undefined>): Record<string, string> {\n  const raw: Record<string, string> = {}\n  for (const [key, value] of Object.entries(headers)) {\n    if (value === undefined) continue\n    raw[key] = Array.isArray(value) ? value.join(', ') : value\n  }\n  return filterSafeHeaders(raw)\n}\n"],"mappings":";;;;;;;AAOA,SAAgB,mBAAmB,SAA0C;CAC3E,MAAM,MAA8B,EAAE;AACtC,SAAQ,SAAS,OAAO,QAAQ;AAC9B,MAAI,OAAO;GACX;AACF,QAAO,kBAAkB,IAAI;;;;;;AAO/B,SAAgB,uBAAuB,SAAgF;CACrH,MAAM,MAA8B,EAAE;AACtC,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,EAAE;AAClD,MAAI,UAAU,KAAA,EAAW;AACzB,MAAI,OAAO,MAAM,QAAQ,MAAM,GAAG,MAAM,KAAK,KAAK,GAAG;;AAEvD,QAAO,kBAAkB,IAAI"}

package/dist/hono/index.d.mts

@@ -1,5 +1,5 @@
-import { _ as RequestLogger } from "../types-D5OwxZCw.mjs";
-import { t as BaseEvlogOptions } from "../middleware-D_igVy93.mjs";
+import { Y as RequestLogger } from "../audit-mUutdf6A.mjs";
+import { t as BaseEvlogOptions } from "../middleware-BYf26Lfu.mjs";
 import { MiddlewareHandler } from "hono";
 
 //#region src/hono/index.d.ts

package/dist/hono/index.mjs

@@ -1,4 +1,5 @@
-import { r as createMiddlewareLogger, t as extractSafeHeaders } from "../headers-ht4yS2mx.mjs";
+import { t as createMiddlewareLogger } from "../middleware-BWOJ7JI0.mjs";
+import { t as extractSafeHeaders } from "../headers-D74M0wsg.mjs";
 //#region src/hono/index.ts
 /**
 * Create an evlog middleware for Hono.

package/dist/hono/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/hono/index.ts"],"sourcesContent":["import type { MiddlewareHandler } from 'hono'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { extractSafeHeaders } from '../shared/headers'\n\nexport type EvlogHonoOptions = BaseEvlogOptions\n\n/**\n * Hono variables type for typed `c.get('log')` access.\n *\n * @example\n * ```ts\n * const app = new Hono<EvlogVariables>()\n * app.use(evlog())\n * app.get('/api/users', (c) => {\n *   const log = c.get('log')\n *   log.set({ users: { count: 42 } })\n *   return c.json({ users: [] })\n * })\n * ```\n */\nexport type EvlogVariables = { Variables: { log: RequestLogger } }\n\n/**\n * Create an evlog middleware for Hono.\n *\n * @example\n * ```ts\n * import { Hono } from 'hono'\n * import { evlog, type EvlogVariables } from 'evlog/hono'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = new Hono<EvlogVariables>()\n * app.use(evlog({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * }))\n * ```\n */\nexport function evlog(options: EvlogHonoOptions = {}): MiddlewareHandler {\n  return async (c, next) => {\n    const { logger, finish, skipped } = createMiddlewareLogger({\n      method: c.req.method,\n      path: c.req.path,\n      requestId: c.req.header('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeHeaders(c.req.raw.headers),\n      ...options,\n    })\n\n    if (skipped) {\n      await next()\n      return\n    }\n\n    c.set('log', logger)\n\n    try {\n      await 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"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,MAAM,UAA4B,EAAE,EAAqB;AACvE,QAAO,OAAO,GAAG,SAAS;EACxB,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,EAAE,IAAI;GACd,MAAM,EAAE,IAAI;GACZ,WAAW,EAAE,IAAI,OAAO,eAAe,IAAI,OAAO,YAAY;GAC9D,SAAS,mBAAmB,EAAE,IAAI,IAAI,QAAQ;GAC9C,GAAG;GACJ,CAAC;AAEF,MAAI,SAAS;AACX,SAAM,MAAM;AACZ;;AAGF,IAAE,IAAI,OAAO,OAAO;AAEpB,MAAI;AACF,SAAM,MAAM;AACZ,SAAM,OAAO,EAAE,QAAQ,EAAE,IAAI,QAAQ,CAAC;WAC/B,OAAO;AACd,SAAM,OAAO,EAAS,OAAgB,CAAC;AACvC,SAAM"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/hono/index.ts"],"sourcesContent":["import type { MiddlewareHandler } from 'hono'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { extractSafeHeaders } from '../shared/headers'\n\nexport type EvlogHonoOptions = BaseEvlogOptions\n\n/**\n * Hono variables type for typed `c.get('log')` access.\n *\n * @example\n * ```ts\n * const app = new Hono<EvlogVariables>()\n * app.use(evlog())\n * app.get('/api/users', (c) => {\n *   const log = c.get('log')\n *   log.set({ users: { count: 42 } })\n *   return c.json({ users: [] })\n * })\n * ```\n */\nexport type EvlogVariables = { Variables: { log: RequestLogger } }\n\n/**\n * Create an evlog middleware for Hono.\n *\n * @example\n * ```ts\n * import { Hono } from 'hono'\n * import { evlog, type EvlogVariables } from 'evlog/hono'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = new Hono<EvlogVariables>()\n * app.use(evlog({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * }))\n * ```\n */\nexport function evlog(options: EvlogHonoOptions = {}): MiddlewareHandler {\n  return async (c, next) => {\n    const { logger, finish, skipped } = createMiddlewareLogger({\n      method: c.req.method,\n      path: c.req.path,\n      requestId: c.req.header('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeHeaders(c.req.raw.headers),\n      ...options,\n    })\n\n    if (skipped) {\n      await next()\n      return\n    }\n\n    c.set('log', logger)\n\n    try {\n      await 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"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,MAAM,UAA4B,EAAE,EAAqB;AACvE,QAAO,OAAO,GAAG,SAAS;EACxB,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,EAAE,IAAI;GACd,MAAM,EAAE,IAAI;GACZ,WAAW,EAAE,IAAI,OAAO,eAAe,IAAI,OAAO,YAAY;GAC9D,SAAS,mBAAmB,EAAE,IAAI,IAAI,QAAQ;GAC9C,GAAG;GACJ,CAAC;AAEF,MAAI,SAAS;AACX,SAAM,MAAM;AACZ;;AAGF,IAAE,IAAI,OAAO,OAAO;AAEpB,MAAI;AACF,SAAM,MAAM;AACZ,SAAM,OAAO,EAAE,QAAQ,EAAE,IAAI,QAAQ,CAAC;WAC/B,OAAO;AACd,SAAM,OAAO,EAAS,OAAgB,CAAC;AACvC,SAAM"}

package/dist/http.d.mts

@@ -1,4 +1,4 @@
-import { r as DrainContext } from "./types-D5OwxZCw.mjs";
+import { F as DrainContext } from "./audit-mUutdf6A.mjs";
 import { DrainPipelineOptions, PipelineDrainFn } from "./pipeline.mjs";
 
 //#region src/http.d.ts

package/dist/index.d.mts

@@ -1,7 +1,7 @@
-import { C as TailSamplingCondition, E as WideEvent, S as ServerEvent, T as TransportConfig, _ as RequestLogger, a as EnvironmentContext, b as SamplingConfig, c as H3EventContext, d as Log, f as LogLevel, h as RedactConfig, i as EnrichContext, l as IngestPayload, m as ParsedError, n as DeepPartial, o as ErrorOptions, p as LoggerConfig, r as DrainContext, s as FieldContext, t as BaseWideEvent, u as InternalFields, v as RequestLoggerOptions, w as TailSamplingContext, x as SamplingRates } from "./types-D5OwxZCw.mjs";
-import { n as createError, t as EvlogError } from "./error-WRz4_F3W.mjs";
-import { i as getEnvironment, n as createLogger, o as initLogger, r as createRequestLogger, s as isEnabled, t as _log, u as shouldKeep } from "./logger-Bm0k3Hf3.mjs";
-import { p as isLevelEnabled } from "./utils-Bnc95-VC.mjs";
-import { t as useLogger } from "./useLogger-Dcj1Nrsa.mjs";
-import { t as parseError } from "./parseError-DhXS_vzM.mjs";
-export { type BaseWideEvent, type DeepPartial, type DrainContext, type EnrichContext, type EnvironmentContext, type ErrorOptions, EvlogError, type FieldContext, type H3EventContext, type IngestPayload, type InternalFields, type Log, type LogLevel, type LoggerConfig, type ParsedError, type RedactConfig, type RequestLogger, type RequestLoggerOptions, type SamplingConfig, type SamplingRates, type ServerEvent, type TailSamplingCondition, type TailSamplingContext, type TransportConfig, type WideEvent, createError, createError as createEvlogError, createLogger, createRequestLogger, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, parseError, shouldKeep, useLogger };
+import { $ as SamplingRates, A as AuditFields, B as H3EventContext, C as buildAuditFields, D as withAudit, E as signed, F as DrainContext, G as LoggerConfig, H as InternalFields, I as EnrichContext, K as ParsedError, L as EnvironmentContext, M as AuditTarget, N as BaseWideEvent, O as withAuditMethods, P as DeepPartial, Q as SamplingConfig, R as ErrorOptions, S as auditRedactPreset, T as mockAudit, U as Log, V as IngestPayload, W as LogLevel, X as RequestLoggerOptions, Y as RequestLogger, _ as WithAuditOptions, a as AuditInput, b as auditEnricher, c as AuditOnlyOptions, d as DefinedAuditAction, et as ServerEvent, f as DrainFn, g as WithAuditContext, h as SignedOptions, i as AuditEnricherOptions, it as WideEvent, j as AuditLoggerMethod, k as AuditActor, l as AuditPatchOp, m as SignedChainState, n as AuditDeniedError, nt as TailSamplingContext, o as AuditMatcher, p as MockAudit, q as RedactConfig, r as AuditDiffOptions, rt as TransportConfig, s as AuditMethod, t as AUDIT_SCHEMA_VERSION, tt as TailSamplingCondition, u as AuditableLogger, v as audit, w as defineAuditAction, x as auditOnly, y as auditDiff, z as FieldContext } from "./audit-mUutdf6A.mjs";
+import { n as createError, t as EvlogError } from "./error-D1FZI2Kd.mjs";
+import { i as getEnvironment, n as createLogger, o as initLogger, r as createRequestLogger, s as isEnabled, t as _log, u as shouldKeep } from "./logger-b3epPH0N.mjs";
+import { p as isLevelEnabled } from "./utils-DzGCLRFe.mjs";
+import { t as useLogger } from "./useLogger-C56tDPwf.mjs";
+import { t as parseError } from "./parseError-BR9pocvY.mjs";
+export { AUDIT_SCHEMA_VERSION, type AuditActor, AuditDeniedError, type AuditDiffOptions, type AuditEnricherOptions, type AuditFields, type AuditInput, type AuditLoggerMethod, type AuditMatcher, type AuditMethod, type AuditOnlyOptions, type AuditPatchOp, type AuditTarget, type AuditableLogger, type BaseWideEvent, type DeepPartial, type DefinedAuditAction, type DrainContext, type DrainFn, type EnrichContext, type EnvironmentContext, type ErrorOptions, EvlogError, type FieldContext, type H3EventContext, type IngestPayload, type InternalFields, type Log, type LogLevel, type LoggerConfig, type MockAudit, type ParsedError, type RedactConfig, type RequestLogger, type RequestLoggerOptions, type SamplingConfig, type SamplingRates, type ServerEvent, type SignedChainState, type SignedOptions, type TailSamplingCondition, type TailSamplingContext, type TransportConfig, type WideEvent, type WithAuditContext, type WithAuditOptions, audit, auditDiff, auditEnricher, auditOnly, auditRedactPreset, buildAuditFields, createError, createError as createEvlogError, createLogger, createRequestLogger, defineAuditAction, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, mockAudit, parseError, shouldKeep, signed, useLogger, withAudit, withAuditMethods };

package/dist/index.mjs

@@ -1,6 +1,6 @@
+import { C as shouldKeep, _ as getEnvironment, a as auditEnricher, b as isEnabled, c as buildAuditFields, d as signed, f as withAudit, g as createRequestLogger, h as createLogger, i as auditDiff, 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, y as initLogger } from "./audit-d9esRZOK.mjs";
 import { isLevelEnabled } from "./utils.mjs";
 import { EvlogError, createError } from "./error.mjs";
-import { i as getEnvironment, n as createLogger, o as initLogger, r as createRequestLogger, s as isEnabled, t as _log, u as shouldKeep } from "./logger-DY0X5oQd.mjs";
 import { useLogger } from "./runtime/server/useLogger.mjs";
 import { parseError } from "./runtime/utils/parseError.mjs";
-export { EvlogError, createError, createError as createEvlogError, createLogger, createRequestLogger, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, parseError, shouldKeep, useLogger };
+export { AUDIT_SCHEMA_VERSION, AuditDeniedError, EvlogError, audit, auditDiff, auditEnricher, auditOnly, auditRedactPreset, buildAuditFields, createError, createError as createEvlogError, createLogger, createRequestLogger, defineAuditAction, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, mockAudit, parseError, shouldKeep, signed, useLogger, withAudit, withAuditMethods };

package/dist/{logger-Bm0k3Hf3.d.mts → logger-b3epPH0N.d.mts}

@@ -1,4 +1,4 @@
-import { _ as RequestLogger, a as EnvironmentContext, d as Log, p as LoggerConfig, r as DrainContext, v as RequestLoggerOptions, w as TailSamplingContext } from "./types-D5OwxZCw.mjs";
+import { F as DrainContext, G as LoggerConfig, L as EnvironmentContext, U as Log, X as RequestLoggerOptions, nt as TailSamplingContext, u as AuditableLogger } from "./audit-mUutdf6A.mjs";
 
 //#region src/logger.d.ts
 /**
@@ -55,6 +55,10 @@ interface CreateLoggerInternalOptions {
  * Create a scoped logger for building wide events.
  * Use this for any context: workflows, jobs, scripts, queues, etc.
  *
+ * After `emit()` (including when sampling returns `null`), the logger is sealed and
+ * further mutations log `[evlog]` warnings. Standalone loggers do not have `fork`;
+ * that method is only attached by supported framework integrations.
+ *
  * @example
  * ```ts
  * const log = createLogger({ jobId: job.id, queue: 'emails' })
@@ -62,7 +66,7 @@ interface CreateLoggerInternalOptions {
  * log.emit()
  * ```
  */
-declare function createLogger<T extends object = Record<string, unknown>>(initialContext?: Record<string, unknown>, internalOptions?: CreateLoggerInternalOptions): RequestLogger<T>;
+declare function createLogger<T extends object = Record<string, unknown>>(initialContext?: Record<string, unknown>, internalOptions?: CreateLoggerInternalOptions): AuditableLogger<T>;
 /**
  * Create a request-scoped logger for building wide events.
  * Convenience wrapper around `createLogger` that pre-populates HTTP request fields.
@@ -75,11 +79,11 @@ declare function createLogger<T extends object = Record<string, unknown>>(initia
  * log.emit()
  * ```
  */
-declare function createRequestLogger<T extends object = Record<string, unknown>>(options?: RequestLoggerOptions, internalOptions?: CreateLoggerInternalOptions): RequestLogger<T>;
+declare function createRequestLogger<T extends object = Record<string, unknown>>(options?: RequestLoggerOptions, internalOptions?: CreateLoggerInternalOptions): AuditableLogger<T>;
 /**
  * Get the current environment context.
  */
 declare function getEnvironment(): EnvironmentContext;
 //#endregion
 export { getGlobalDrain as a, isLoggerLocked as c, getEnvironment as i, lockLogger as l, createLogger as n, initLogger as o, createRequestLogger as r, isEnabled as s, _log as t, shouldKeep as u };
-//# sourceMappingURL=logger-Bm0k3Hf3.d.mts.map
+//# sourceMappingURL=logger-b3epPH0N.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger-b3epPH0N.d.mts","names":[],"sources":["../src/logger.ts"],"mappings":";;;;AA6DA;;;iBAAgB,UAAA,CAAW,MAAA,GAAQ,YAAA;;AA4BnC;;iBAAgB,SAAA,CAAA;;;AAShB;;;iBAAgB,UAAA,CAAA;;AAOhB;;iBAAgB,cAAA,CAAA;;;AAShB;;;iBAAgB,cAAA,CAAA,KAAoB,GAAA,EAAK,YAAA,YAAwB,OAAA;;;;;iBA8BjD,UAAA,CAAW,GAAA,EAAK,mBAAA;AAAhC;;;;;AAgBC;;;;AAhBD,cAgXM,IAAA,EAAM,GAAA;;;;UA2BF,2BAAA;EAuBM;;;;EAlBd,WAAA;AAAA;;;;;;;;;;;;;;;AAgMF;iBA9KgB,YAAA,oBAAgC,MAAA,kBAAA,CAAyB,cAAA,GAAgB,MAAA,mBAA8B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;;;;;;;;;;;iBA8KvK,mBAAA,oBAAuC,MAAA,kBAAA,CAAyB,OAAA,GAAS,oBAAA,EAA2B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;;iBAWpK,cAAA,CAAA,GAAkB,kBAAA"}

package/dist/logger.d.mts

@@ -1,2 +1,2 @@
-import { a as getGlobalDrain, c as isLoggerLocked, i as getEnvironment, l as lockLogger, n as createLogger, o as initLogger, r as createRequestLogger, s as isEnabled, t as _log, u as shouldKeep } from "./logger-Bm0k3Hf3.mjs";
+import { a as getGlobalDrain, c as isLoggerLocked, i as getEnvironment, l as lockLogger, n as createLogger, o as initLogger, r as createRequestLogger, s as isEnabled, t as _log, u as shouldKeep } from "./logger-b3epPH0N.mjs";
 export { createLogger, createRequestLogger, getEnvironment, getGlobalDrain, initLogger, isEnabled, isLoggerLocked, lockLogger, _log as log, shouldKeep };

package/dist/logger.mjs

@@ -1,2 +1,2 @@
-import { a as getGlobalDrain, c as isLoggerLocked, i as getEnvironment, l as lockLogger, n as createLogger, o as initLogger, r as createRequestLogger, s as isEnabled, t as _log, u as shouldKeep } from "./logger-DY0X5oQd.mjs";
+import { C as shouldKeep, S as lockLogger, _ as getEnvironment, b as isEnabled, g as createRequestLogger, h as createLogger, m as _log, v as getGlobalDrain, x as isLoggerLocked, y as initLogger } from "./audit-d9esRZOK.mjs";
 export { createLogger, createRequestLogger, getEnvironment, getGlobalDrain, initLogger, isEnabled, isLoggerLocked, lockLogger, _log as log, shouldKeep };

package/dist/{headers-ht4yS2mx.mjs → middleware-BWOJ7JI0.mjs}

@@ -1,5 +1,4 @@
-import { filterSafeHeaders } from "./utils.mjs";
-import { a as getGlobalDrain, f as redactEvent, p as resolveRedactConfig, r as createRequestLogger, s as isEnabled, u as shouldKeep } from "./logger-DY0X5oQd.mjs";
+import { C as shouldKeep, E as resolveRedactConfig, T as redactEvent, b as isEnabled, g as createRequestLogger, v as getGlobalDrain } from "./audit-d9esRZOK.mjs";
 import { t as extractErrorStatus } from "./errors-BJRXUfMg.mjs";
 import { n as shouldLog, t as getServiceForPath } from "./routes-CGPmbzCZ.mjs";
 //#region src/shared/middleware.ts
@@ -19,6 +18,12 @@ const noopResult = {
 	finish: () => Promise.resolve(null),
 	skipped: true
 };
+/**
+* Apply redact, enrich, and drain to an emitted wide event — same pipeline as
+* {@link createMiddlewareLogger}'s `finish`.
+*
+* @beta Part of `evlog/toolkit` — used by framework integrations and `fork()`.
+*/
 async function runEnrichAndDrain(emittedEvent, options, requestInfo, responseStatus) {
 	const resolvedRedact = resolveRedactConfig(options.redact);
 	if (resolvedRedact) redactEvent(emittedEvent, resolvedRedact);
@@ -113,32 +118,6 @@ function createMiddlewareLogger(options) {
 	};
 }
 //#endregion
-//#region src/shared/headers.ts
-/**
-* Extract headers from a Web API `Headers` object and filter out sensitive ones.
-* Works with any runtime that supports the standard `Headers` API (Hono, Elysia,
-* Nitro v3, Cloudflare Workers, Bun, Deno, etc.).
-*/
-function extractSafeHeaders(headers) {
-	const raw = {};
-	headers.forEach((value, key) => {
-		raw[key] = value;
-	});
-	return filterSafeHeaders(raw);
-}
-/**
-* Extract headers from Node.js `IncomingHttpHeaders` and filter out sensitive ones.
-* Works with Express, Fastify, and any Node.js HTTP server using `req.headers`.
-*/
-function extractSafeNodeHeaders(headers) {
-	const raw = {};
-	for (const [key, value] of Object.entries(headers)) {
-		if (value === void 0) continue;
-		raw[key] = Array.isArray(value) ? value.join(", ") : value;
-	}
-	return filterSafeHeaders(raw);
-}
-//#endregion
-export { extractSafeNodeHeaders as n, createMiddlewareLogger as r, extractSafeHeaders as t };
+export { runEnrichAndDrain as n, createMiddlewareLogger as t };
 
-//# sourceMappingURL=headers-ht4yS2mx.mjs.map
+//# sourceMappingURL=middleware-BWOJ7JI0.mjs.map

package/dist/middleware-BWOJ7JI0.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-BWOJ7JI0.mjs","names":[],"sources":["../src/shared/middleware.ts"],"sourcesContent":["import type { DrainContext, EnrichContext, RedactConfig, RequestLogger, RouteConfig, TailSamplingContext, WideEvent } from '../types'\nimport { createRequestLogger, getGlobalDrain, isEnabled, shouldKeep } from '../logger'\nimport { redactEvent, resolveRedactConfig } from '../redact'\nimport { extractErrorStatus } from './errors'\nimport { shouldLog, getServiceForPath } from './routes'\n\n/**\n * Base options shared by all framework integrations.\n *\n * Every framework-specific options interface (e.g. `EvlogExpressOptions`)\n * extends this type. If a framework needs extra fields it can add them\n * on top; otherwise the base is used as-is.\n *\n * @beta Part of `evlog/toolkit` — the public API for building custom integrations.\n */\nexport interface BaseEvlogOptions {\n  /** Route patterns to include in logging (glob). If not set, all routes are logged */\n  include?: string[]\n  /** Route patterns to exclude from logging. Exclusions take precedence over inclusions */\n  exclude?: string[]\n  /** Route-specific service configuration */\n  routes?: Record<string, RouteConfig>\n  /**\n   * Drain callback called with every emitted event.\n   * Use with drain adapters (Axiom, OTLP, Sentry, etc.) or custom endpoints.\n   */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /**\n   * Enrich callback called after emit, before drain.\n   * Use to add derived context (geo, deployment info, user agent, etc.).\n   */\n  enrich?: (ctx: EnrichContext) => void | Promise<void>\n  /**\n   * Custom tail sampling callback.\n   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.\n   */\n  keep?: (ctx: TailSamplingContext) => void | Promise<void>\n  /**\n   * Auto-redaction configuration for PII protection.\n   * `true` enables all built-in PII patterns. Pass an object for fine-grained control.\n   * Applied before enrich/drain. Also applied at the core `emitWideEvent` level\n   * when configured via `initLogger()`.\n   */\n  redact?: boolean | RedactConfig\n}\n\n/**\n * Internal options consumed by `createMiddlewareLogger`.\n * Extends `BaseEvlogOptions` with the request-specific fields\n * that framework adapters must provide.\n */\nexport interface MiddlewareLoggerOptions extends BaseEvlogOptions {\n  method: string\n  path: string\n  requestId?: string\n  /** Pre-filtered safe request headers (used for enrich/drain context) */\n  headers?: Record<string, string>\n}\n\nexport interface MiddlewareLoggerResult {\n  logger: RequestLogger\n  finish: (opts?: { status?: number; error?: Error }) => Promise<WideEvent | null>\n  skipped: boolean\n}\n\nconst noopResult: MiddlewareLoggerResult = {\n  logger: {\n    set() {},\n    error() {},\n    info() {},\n    warn() {},\n    emit() {\n      return null \n    },\n    getContext() {\n      return {} \n    },\n  },\n  finish: () => Promise.resolve(null),\n  skipped: true,\n}\n\n/**\n * Apply redact, enrich, and drain to an emitted wide event — same pipeline as\n * {@link createMiddlewareLogger}'s `finish`.\n *\n * @beta Part of `evlog/toolkit` — used by framework integrations and `fork()`.\n */\nexport async function runEnrichAndDrain(\n  emittedEvent: WideEvent,\n  options: MiddlewareLoggerOptions,\n  requestInfo: { method: string; path: string; requestId?: string },\n  responseStatus?: number,\n): Promise<void> {\n  const resolvedRedact = resolveRedactConfig(options.redact)\n  if (resolvedRedact) {\n    redactEvent(emittedEvent, resolvedRedact)\n  }\n\n  if (options.enrich) {\n    const enrichCtx: EnrichContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n      response: { status: responseStatus },\n    }\n    try {\n      await options.enrich(enrichCtx)\n    } catch (err) {\n      console.error('[evlog] enrich failed:', err)\n    }\n  }\n\n  const drain = options.drain ?? getGlobalDrain()\n  if (drain) {\n    const drainCtx: DrainContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n    }\n    try {\n      await drain(drainCtx)\n    } catch (err) {\n      console.error('[evlog] drain failed:', err)\n    }\n  }\n}\n\n/**\n * Create a middleware-aware request logger with full lifecycle management.\n *\n * Handles the complete pipeline shared across all framework integrations:\n * route filtering, logger creation, service overrides, duration tracking,\n * tail sampling evaluation, event emission, enrichment, and draining.\n *\n * Framework adapters only need to:\n * 1. Extract method/path/requestId/headers from the framework request\n * 2. Call `createMiddlewareLogger()` with those + user options\n * 3. Check `skipped` — if true, skip to next middleware\n * 4. Store `logger` in framework-specific context (e.g., `c.set('log', logger)`)\n * 5. Call `finish({ status })` or `finish({ error })` at response end\n *\n * @beta Part of `evlog/toolkit` — the public API for building custom integrations.\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 startTime = Date.now()\n  const requestInfo = { method, path, requestId: resolvedRequestId }\n\n  const finish = async (opts?: { status?: number; error?: Error }): Promise<WideEvent | null> => {\n    const { status, error } = opts ?? {}\n\n    if (error) {\n      logger.error(error)\n      const errorStatus = extractErrorStatus(error)\n      logger.set({ status: errorStatus })\n    } else if (status !== undefined) {\n      logger.set({ status })\n    }\n\n    const durationMs = Date.now() - startTime\n\n    const resolvedStatus = error\n      ? extractErrorStatus(error)\n      : status ?? (logger.getContext().status as number | undefined)\n\n    const tailCtx: TailSamplingContext = {\n      status: resolvedStatus,\n      duration: durationMs,\n      path,\n      method,\n      context: logger.getContext(),\n      shouldKeep: false,\n    }\n\n    if (keep) {\n      await keep(tailCtx)\n    }\n\n    const forceKeep = tailCtx.shouldKeep || shouldKeep(tailCtx)\n    const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n\n    if (emittedEvent && (options.enrich || options.drain || getGlobalDrain())) {\n      await runEnrichAndDrain(emittedEvent, options, requestInfo, resolvedStatus)\n    }\n\n    return emittedEvent\n  }\n\n  return { logger, finish, skipped: false }\n}\n"],"mappings":";;;;AAiEA,MAAM,aAAqC;CACzC,QAAQ;EACN,MAAM;EACN,QAAQ;EACR,OAAO;EACP,OAAO;EACP,OAAO;AACL,UAAO;;EAET,aAAa;AACX,UAAO,EAAE;;EAEZ;CACD,cAAc,QAAQ,QAAQ,KAAK;CACnC,SAAS;CACV;;;;;;;AAQD,eAAsB,kBACpB,cACA,SACA,aACA,gBACe;CACf,MAAM,iBAAiB,oBAAoB,QAAQ,OAAO;AAC1D,KAAI,eACF,aAAY,cAAc,eAAe;AAG3C,KAAI,QAAQ,QAAQ;EAClB,MAAM,YAA2B;GAC/B,OAAO;GACP,SAAS;GACT,SAAS,QAAQ;GACjB,UAAU,EAAE,QAAQ,gBAAgB;GACrC;AACD,MAAI;AACF,SAAM,QAAQ,OAAO,UAAU;WACxB,KAAK;AACZ,WAAQ,MAAM,0BAA0B,IAAI;;;CAIhD,MAAM,QAAQ,QAAQ,SAAS,gBAAgB;AAC/C,KAAI,OAAO;EACT,MAAM,WAAyB;GAC7B,OAAO;GACP,SAAS;GACT,SAAS,QAAQ;GAClB;AACD,MAAI;AACF,SAAM,MAAM,SAAS;WACd,KAAK;AACZ,WAAQ,MAAM,yBAAyB,IAAI;;;;;;;;;;;;;;;;;;;;AAqBjD,SAAgB,uBAAuB,SAA0D;AAC/F,KAAI,CAAC,WAAW,CAAE,QAAO;CAEzB,MAAM,EAAE,QAAQ,MAAM,WAAW,SAAS,SAAS,QAAQ,SAAS;AAEpE,KAAI,CAAC,UAAU,MAAM,SAAS,QAAQ,CACpC,QAAO;CAGT,MAAM,oBAAoB,aAAa,OAAO,YAAY;CAE1D,MAAM,SAAS,oBAAoB;EACjC;EACA;EACA,WAAW;EACZ,EAAE,EAAE,aAAa,MAAM,CAAC;CAEzB,MAAM,eAAe,kBAAkB,MAAM,OAAO;AACpD,KAAI,aACF,QAAO,IAAI,EAAE,SAAS,cAAc,CAAC;CAGvC,MAAM,YAAY,KAAK,KAAK;CAC5B,MAAM,cAAc;EAAE;EAAQ;EAAM,WAAW;EAAmB;CAElE,MAAM,SAAS,OAAO,SAAyE;EAC7F,MAAM,EAAE,QAAQ,UAAU,QAAQ,EAAE;AAEpC,MAAI,OAAO;AACT,UAAO,MAAM,MAAM;GACnB,MAAM,cAAc,mBAAmB,MAAM;AAC7C,UAAO,IAAI,EAAE,QAAQ,aAAa,CAAC;aAC1B,WAAW,KAAA,EACpB,QAAO,IAAI,EAAE,QAAQ,CAAC;EAGxB,MAAM,aAAa,KAAK,KAAK,GAAG;EAEhC,MAAM,iBAAiB,QACnB,mBAAmB,MAAM,GACzB,UAAW,OAAO,YAAY,CAAC;EAEnC,MAAM,UAA+B;GACnC,QAAQ;GACR,UAAU;GACV;GACA;GACA,SAAS,OAAO,YAAY;GAC5B,YAAY;GACb;AAED,MAAI,KACF,OAAM,KAAK,QAAQ;EAGrB,MAAM,YAAY,QAAQ,cAAc,WAAW,QAAQ;EAC3D,MAAM,eAAe,OAAO,KAAK,EAAE,YAAY,WAAW,CAAC;AAE3D,MAAI,iBAAiB,QAAQ,UAAU,QAAQ,SAAS,gBAAgB,EACtE,OAAM,kBAAkB,cAAc,SAAS,aAAa,eAAe;AAG7E,SAAO;;AAGT,QAAO;EAAE;EAAQ;EAAQ,SAAS;EAAO"}

package/dist/{middleware-D_igVy93.d.mts → middleware-BYf26Lfu.d.mts}

@@ -1,4 +1,4 @@
-import { E as WideEvent, _ as RequestLogger, h as RedactConfig, i as EnrichContext, r as DrainContext, w as TailSamplingContext, y as RouteConfig } from "./types-D5OwxZCw.mjs";
+import { F as DrainContext, I as EnrichContext, Y as RequestLogger, Z as RouteConfig, it as WideEvent, nt as TailSamplingContext, q as RedactConfig } from "./audit-mUutdf6A.mjs";
 
 //#region src/shared/middleware.d.ts
 /**
@@ -60,6 +60,17 @@ interface MiddlewareLoggerResult {
   }) => Promise<WideEvent | null>;
   skipped: boolean;
 }
+/**
+ * Apply redact, enrich, and drain to an emitted wide event — same pipeline as
+ * {@link createMiddlewareLogger}'s `finish`.
+ *
+ * @beta Part of `evlog/toolkit` — used by framework integrations and `fork()`.
+ */
+declare function runEnrichAndDrain(emittedEvent: WideEvent, options: MiddlewareLoggerOptions, requestInfo: {
+  method: string;
+  path: string;
+  requestId?: string;
+}, responseStatus?: number): Promise<void>;
 /**
  * Create a middleware-aware request logger with full lifecycle management.
  *
@@ -78,5 +89,5 @@ interface MiddlewareLoggerResult {
  */
 declare function createMiddlewareLogger(options: MiddlewareLoggerOptions): MiddlewareLoggerResult;
 //#endregion
-export { createMiddlewareLogger as i, MiddlewareLoggerOptions as n, MiddlewareLoggerResult as r, BaseEvlogOptions as t };
-//# sourceMappingURL=middleware-D_igVy93.d.mts.map
+export { runEnrichAndDrain as a, createMiddlewareLogger as i, MiddlewareLoggerOptions as n, MiddlewareLoggerResult as r, BaseEvlogOptions as t };
+//# sourceMappingURL=middleware-BYf26Lfu.d.mts.map

package/dist/{middleware-D_igVy93.d.mts.map → middleware-BYf26Lfu.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"middleware-D_igVy93.d.mts","names":[],"sources":["../src/shared/middleware.ts"],"mappings":";;;;;AAeA;;;;;;;UAAiB,gBAAA;EAgByB;EAdxC,OAAA;EAmB4C;EAjB5C,OAAA;EAwB+B;EAtB/B,MAAA,GAAS,MAAA,SAAe,WAAA;EAJxB;;;;EASA,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAAtC;;;;EAKA,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EAAzB;;;;EAKf,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;EAApC;;;;;;EAOR,MAAA,aAAmB,YAAA;AAAA;;;;;;UAQJ,uBAAA,SAAgC,gBAAA;EAC/C,MAAA;EACA,IAAA;EACA,SAAA;EAEgB;EAAhB,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;EAC/D,OAAA;AAAA;;;;;;;;;;;;AA4EF;;;;;iBAAgB,sBAAA,CAAuB,OAAA,EAAS,uBAAA,GAA0B,sBAAA"}
+{"version":3,"file":"middleware-BYf26Lfu.d.mts","names":[],"sources":["../src/shared/middleware.ts"],"mappings":";;;;;AAeA;;;;;;;UAAiB,gBAAA;EAgByB;EAdxC,OAAA;EAmB4C;EAjB5C,OAAA;EAwB+B;EAtB/B,MAAA,GAAS,MAAA,SAAe,WAAA;EAJxB;;;;EASA,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAAtC;;;;EAKA,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EAAzB;;;;EAKf,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;EAApC;;;;;;EAOR,MAAA,aAAmB,YAAA;AAAA;;;;;;UAQJ,uBAAA,SAAgC,gBAAA;EAC/C,MAAA;EACA,IAAA;EACA,SAAA;EAEgB;EAAhB,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;EAC/D,OAAA;AAAA;;;;;;;iBA0BoB,iBAAA,CACpB,YAAA,EAAc,SAAA,EACd,OAAA,EAAS,uBAAA,EACT,WAAA;EAAe,MAAA;EAAgB,IAAA;EAAc,SAAA;AAAA,GAC7C,cAAA,YACC,OAAA;AALH;;;;;;;;;;;;;;;;AAAA,iBAwDgB,sBAAA,CAAuB,OAAA,EAAS,uBAAA,GAA0B,sBAAA"}

package/dist/nestjs/index.d.mts

@@ -1,5 +1,5 @@
-import { _ as RequestLogger } from "../types-D5OwxZCw.mjs";
-import { t as BaseEvlogOptions } from "../middleware-D_igVy93.mjs";
+import { Y as RequestLogger } from "../audit-mUutdf6A.mjs";
+import { t as BaseEvlogOptions } from "../middleware-BYf26Lfu.mjs";
 import { DynamicModule, MiddlewareConsumer, NestModule } from "@nestjs/common";
 
 //#region src/nestjs/index.d.ts

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/nestjs/index.ts"],"mappings":";;;;;cAQiB,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":";;;;;cASiB,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,cA4Ea,WAAA,YAAuB,UAAA;EAAA,eAEnB,OAAA;EAnEM;AAAA;;;;;;;;;;EAAA,OAgFd,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,5 +1,7 @@
-import { n as extractSafeNodeHeaders, r as createMiddlewareLogger } from "../headers-ht4yS2mx.mjs";
-import { t as createLoggerStorage } from "../storage-DpLJYMoc.mjs";
+import { t as createMiddlewareLogger } from "../middleware-BWOJ7JI0.mjs";
+import { t as attachForkToLogger } from "../fork-CTJXnpl8.mjs";
+import { n as extractSafeNodeHeaders } from "../headers-D74M0wsg.mjs";
+import { t as createLoggerStorage } from "../storage-CFGTn37X.mjs";
 //#region src/nestjs/index.ts
 const { storage, useLogger } = createLoggerStorage("middleware context. Make sure EvlogModule.forRoot() is imported in your AppModule.");
 function createEvlogMiddleware(getOptions) {
@@ -7,17 +9,19 @@ function createEvlogMiddleware(getOptions) {
 		const options = getOptions();
 		const headers = extractSafeNodeHeaders(req.headers);
 		const url = new URL(req.originalUrl || req.url || "/", "http://localhost");
-		const { logger, finish, skipped } = createMiddlewareLogger({
+		const middlewareOpts = {
 			method: req.method || "GET",
 			path: url.pathname,
 			requestId: headers["x-request-id"] || crypto.randomUUID(),
 			headers,
 			...options
-		});
+		};
+		const { logger, finish, skipped } = createMiddlewareLogger(middlewareOpts);
 		if (skipped) {
 			next();
 			return;
 		}
+		attachForkToLogger(storage, logger, middlewareOpts);
 		req.log = logger;
 		res.on("finish", () => {
 			finish({ status: res.statusCode }).catch(() => {});

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 { extractSafeNodeHeaders } from '../shared/headers'\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 { logger, finish, skipped } = createMiddlewareLogger({\n      method: req.method || 'GET',\n      path: url.pathname,\n      requestId: headers['x-request-id'] || crypto.randomUUID(),\n      headers,\n      ...options,\n    })\n\n    if (skipped) {\n      next()\n      return\n    }\n\n    req.log = logger\n\n    res.on('finish', () => {\n      finish({ status: res.statusCode }).catch(() => {})\n    })\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":";;;AAQA,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,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,IAAI,UAAU;GACtB,MAAM,IAAI;GACV,WAAW,QAAQ,mBAAmB,OAAO,YAAY;GACzD;GACA,GAAG;GACJ,CAAC;AAEF,MAAI,SAAS;AACX,SAAM;AACN;;AAGF,MAAI,MAAM;AAEV,MAAI,GAAG,gBAAgB;AACrB,UAAO,EAAE,QAAQ,IAAI,YAAY,CAAC,CAAC,YAAY,GAAG;IAClD;AAEF,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 { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeNodeHeaders } from '../shared/headers'\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    res.on('finish', () => {\n      finish({ status: res.statusCode }).catch(() => {})\n    })\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":";;;;;AASA,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,MAAI,GAAG,gBAAgB;AACrB,UAAO,EAAE,QAAQ,IAAI,YAAY,CAAC,CAAC,YAAY,GAAG;IAClD;AAEF,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 { T as TransportConfig, f as LogLevel } from "../types-D5OwxZCw.mjs";
+import { W as LogLevel, rt as TransportConfig } from "../audit-mUutdf6A.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 { _ as RequestLogger, a as EnvironmentContext, b as SamplingConfig, d as Log, f as LogLevel } from "../types-D5OwxZCw.mjs";
-import { n as createError } from "../error-WRz4_F3W.mjs";
-import { t as _log } from "../logger-Bm0k3Hf3.mjs";
-import { t as BaseEvlogOptions } from "../middleware-D_igVy93.mjs";
+import { L as EnvironmentContext, Q as SamplingConfig, U as Log, W as LogLevel, Y as RequestLogger } from "../audit-mUutdf6A.mjs";
+import { n as createError } from "../error-D1FZI2Kd.mjs";
+import { t as _log } from "../logger-b3epPH0N.mjs";
+import { t as BaseEvlogOptions } from "../middleware-BYf26Lfu.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;IAAW,GAAA,CAAI,IAAA,UAAc,KAAA;EAAA;AAAA;;;;;;;;;;;;;;iBAoBf,eAAA,CAAgB,MAAA,GAAS,qBAAA,IACzB,OAAA,EAAS,WAAA,KAAW,OAAA,CAAA,YAAA;;;AF3BpC;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA;;;;AAjDA,iBGuCgB,WAAA,CAAY,OAAA,GAAS,gBAAA;6DAWuwE,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;IAAW,GAAA,CAAI,IAAA,UAAc,KAAA;EAAA;AAAA;;;;;;;;;;;;;;iBAoBf,eAAA,CAAgB,MAAA,GAAS,qBAAA,IACzB,OAAA,EAAS,WAAA,KAAW,OAAA,CAAA,YAAA;;;AF3BpC;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA;;;;AAjDA,iBGuCgB,WAAA,CAAY,OAAA,GAAS,gBAAA;6DAW+3E,IAAA,EAAA,KAAA,KAAA,OAAA,SAAkC,IAAA,EAAA,KAAA,KAAA,OAAA,CAAA,OAAA,CAAA,OAAA"}