evlog 2.12.0 → 2.14.0

package/dist/audit-mUutdf6A.d.mts.map

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

package/dist/better-auth/index.d.mts

@@ -0,0 +1,220 @@
+import { Y as RequestLogger } from "../audit-mUutdf6A.mjs";
+
+//#region src/better-auth/index.d.ts
+/**
+ * Minimal type for the Better Auth instance.
+ * Only requires `api.getSession` — compatible with any Better Auth configuration.
+ */
+interface BetterAuthInstance {
+  api: {
+    getSession: (opts: {
+      headers: Headers | Record<string, string | string[] | undefined>;
+    }) => Promise<{
+      user: Record<string, unknown>;
+      session: Record<string, unknown>;
+    } | null>;
+  };
+}
+/**
+ * User fields extracted from a Better Auth session.
+ */
+interface AuthUserData {
+  id: string;
+  name?: string;
+  email?: string;
+  image?: string;
+  emailVerified?: boolean;
+  createdAt?: string;
+}
+/**
+ * Session fields extracted from a Better Auth session.
+ */
+interface AuthSessionData {
+  id: string;
+  expiresAt?: string;
+  ipAddress?: string;
+  userAgent?: string;
+  createdAt?: string;
+}
+/**
+ * Options for `identifyUser`.
+ */
+interface IdentifyOptions {
+  /**
+   * Whether to mask the user email (e.g. `h***@domain.com`).
+   * @default false
+   */
+  maskEmail?: boolean;
+  /**
+   * Whether to include session metadata on the wide event.
+   * @default true
+   */
+  session?: boolean;
+  /**
+   * Whitelist of user fields to include.
+   * @default ['id', 'name', 'email', 'image', 'emailVerified', 'createdAt']
+   */
+  fields?: string[];
+  /**
+   * Extend the wide event with additional fields derived from the session.
+   * Useful for Better Auth plugins (organizations, roles, etc.).
+   *
+   * @example
+   * ```ts
+   * identifyUser(log, session, {
+   *   extend: (session) => ({
+   *     organization: session.user.activeOrganization,
+   *     role: session.user.role,
+   *   }),
+   * })
+   * ```
+   */
+  extend?: (session: {
+    user: Record<string, unknown>;
+    session: Record<string, unknown>;
+  }) => Record<string, unknown> | undefined;
+}
+/**
+ * Options for `createAuthMiddleware`.
+ */
+interface AuthMiddlewareOptions extends IdentifyOptions {
+  /**
+   * Route patterns to skip session resolution (glob).
+   * @default ['/api/auth/**']
+   */
+  exclude?: string[];
+  /**
+   * Route patterns to apply session resolution (glob).
+   * If set, only matching routes are resolved.
+   */
+  include?: string[];
+  /**
+   * Called after a user is successfully identified.
+   * Use to add conditional logic based on user data (e.g. force-keep logs for premium users).
+   */
+  onIdentify?: (log: RequestLogger, session: {
+    user: Record<string, unknown>;
+    session: Record<string, unknown>;
+  }) => void | Promise<void>;
+  /**
+   * Called when no session is found (anonymous request).
+   */
+  onAnonymous?: (log: RequestLogger) => void | Promise<void>;
+}
+/**
+ * Options for `createAuthIdentifier`.
+ */
+type AuthIdentifierOptions = AuthMiddlewareOptions;
+/**
+ * Mask an email address for safe logging: `hugo@example.com` -> `h***@example.com`.
+ */
+declare function maskEmail(email: string): string;
+/**
+ * Identify a user on a wide event from a Better Auth session result.
+ *
+ * Sets `userId`, `user`, and optionally `session` fields on the logger.
+ * Safe by default — only extracts whitelisted fields and never logs passwords or tokens.
+ *
+ * Returns `true` if the user was identified, `false` if session data was missing.
+ *
+ * @example
+ * ```ts
+ * import { identifyUser } from 'evlog/better-auth'
+ *
+ * const session = await auth.api.getSession({ headers: event.headers })
+ * if (session) {
+ *   identifyUser(log, session)
+ * }
+ * ```
+ *
+ * @example With email masking
+ * ```ts
+ * identifyUser(log, session, { maskEmail: true })
+ * // user.email → "h***@example.com"
+ * ```
+ *
+ * @example With extend for Better Auth plugins
+ * ```ts
+ * identifyUser(log, session, {
+ *   extend: (s) => ({
+ *     organization: s.user.activeOrganization,
+ *     role: s.user.role,
+ *   }),
+ * })
+ * ```
+ */
+declare function identifyUser(log: RequestLogger, session: {
+  user: Record<string, unknown>;
+  session: Record<string, unknown>;
+}, options?: IdentifyOptions): boolean;
+/**
+ * Create an async function that resolves a Better Auth session from headers
+ * and identifies the user on the logger.
+ *
+ * Works with any framework — just pass the auth instance and call the returned
+ * function with a logger and headers. Supports `include`/`exclude` route patterns
+ * and lifecycle hooks (`onIdentify`, `onAnonymous`).
+ *
+ * @example Nuxt server middleware
+ * ```ts
+ * import { createAuthMiddleware } from 'evlog/better-auth'
+ *
+ * const identify = createAuthMiddleware(auth, {
+ *   exclude: ['/api/auth/**', '/api/public/**'],
+ * })
+ *
+ * export default defineEventHandler(async (event) => {
+ *   if (!event.context.log) return
+ *   await identify(event.context.log, event.headers, event.path)
+ * })
+ * ```
+ *
+ * @example Express
+ * ```ts
+ * const identify = createAuthMiddleware(auth, { maskEmail: true })
+ *
+ * app.use(async (req, res, next) => {
+ *   await identify(req.log, req.headers, req.path)
+ *   next()
+ * })
+ * ```
+ */
+declare function createAuthMiddleware(auth: BetterAuthInstance, options?: AuthMiddlewareOptions): (log: RequestLogger, headers: Headers | Record<string, string | string[] | undefined>, path?: string) => Promise<boolean>;
+/**
+ * Create a Nitro `request` hook that auto-identifies users from Better Auth sessions.
+ *
+ * Resolves the session from request cookies on every request and sets user/session
+ * context on the evlog logger. Skips `/api/auth/**` by default to avoid resolving
+ * sessions during auth flows.
+ *
+ * @example
+ * ```ts
+ * // server/plugins/evlog-auth.ts
+ * import { createAuthIdentifier } from 'evlog/better-auth'
+ * import { auth } from '~/lib/auth'
+ *
+ * export default defineNitroPlugin((nitroApp) => {
+ *   nitroApp.hooks.hook('request', createAuthIdentifier(auth))
+ * })
+ * ```
+ *
+ * @example With options
+ * ```ts
+ * nitroApp.hooks.hook('request', createAuthIdentifier(auth, {
+ *   maskEmail: true,
+ *   exclude: ['/api/auth/**', '/api/public/**'],
+ * }))
+ * ```
+ */
+declare function createAuthIdentifier(auth: BetterAuthInstance, options?: AuthIdentifierOptions): (event: {
+  path: string;
+  headers: Headers | {
+    get(name: string): string | null;
+  };
+  context: {
+    log?: RequestLogger;
+  };
+}) => Promise<void>;
+//#endregion
+export { AuthIdentifierOptions, AuthMiddlewareOptions, AuthSessionData, AuthUserData, BetterAuthInstance, IdentifyOptions, createAuthIdentifier, createAuthMiddleware, identifyUser, maskEmail };
+//# sourceMappingURL=index.d.mts.map

package/dist/better-auth/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/better-auth/index.ts"],"mappings":";;;;;AAOA;;UAAiB,kBAAA;EACf,GAAA;IACE,UAAA,GAAa,IAAA;MACX,OAAA,EAAS,OAAA,GAAU,MAAA;IAAA,MACf,OAAA;MACJ,IAAA,EAAM,MAAA;MACN,OAAA,EAAS,MAAA;IAAA;EAAA;AAAA;;;;UAQE,YAAA;EACf,EAAA;EACA,IAAA;EACA,KAAA;EACA,KAAA;EACA,aAAA;EACA,SAAA;AAAA;AANF;;;AAAA,UAYiB,eAAA;EACf,EAAA;EACA,SAAA;EACA,SAAA;EACA,SAAA;EACA,SAAA;AAAA;;;AALF;UAWiB,eAAA;;;;;EAKf,SAAA;EAZA;;;;EAiBA,OAAA;EAV8B;;;;EAe9B,MAAA;EAeiG;;;;;;;;;;;;;;EAAjG,MAAA,IAAU,OAAA;IAAW,IAAA,EAAM,MAAA;IAAyB,OAAA,EAAS,MAAA;EAAA,MAA8B,MAAA;AAAA;;;;UAM5E,qBAAA,SAA8B,eAAA;EAAA;;;;EAK7C,OAAA;EAKA;;;;EAAA,OAAA;EAKmD;;;;EAAnD,UAAA,IAAc,GAAA,EAAK,aAAA,EAAe,OAAA;IAAW,IAAA,EAAM,MAAA;IAAyB,OAAA,EAAS,MAAA;EAAA,aAAqC,OAAA;EAI7E;;;EAA7C,WAAA,IAAe,GAAA,EAAK,aAAA,YAAyB,OAAA;AAAA;;;;KAMnC,qBAAA,GAAwB,qBAAA;;;;iBASpB,SAAA,CAAU,KAAA;AAyF1B;;;;;;;;;;;;;;;;;;;;AA4EA;;;;;;;;;;;;;;AA5EA,iBAAgB,YAAA,CACd,GAAA,EAAK,aAAA,EACL,OAAA;EAAW,IAAA,EAAM,MAAA;EAAyB,OAAA,EAAS,MAAA;AAAA,GACnD,OAAA,GAAU,eAAA;;;;;;;AAqIZ;;;;;;;;;;;;;;;;;;;;;;;;;;iBA5DgB,oBAAA,CACd,IAAA,EAAM,kBAAA,EACN,OAAA,GAAU,qBAAA,IACR,GAAA,EAAK,aAAA,EAAe,OAAA,EAAS,OAAA,GAAU,MAAA,yCAA+C,IAAA,cAAkB,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyD5F,oBAAA,CACd,IAAA,EAAM,kBAAA,EACN,OAAA,GAAU,qBAAA,IACR,KAAA;EAAS,IAAA;EAAc,OAAA,EAAS,OAAA;IAAY,GAAA,CAAI,IAAA;EAAA;EAAgC,OAAA;IAAW,GAAA,GAAM,aAAA;EAAA;AAAA,MAAsB,OAAA"}

package/dist/better-auth/index.mjs

@@ -0,0 +1,205 @@
+import { matchesPattern } from "../utils.mjs";
+//#region src/better-auth/index.ts
+const DEFAULT_USER_FIELDS = [
+	"id",
+	"name",
+	"email",
+	"image",
+	"emailVerified",
+	"createdAt"
+];
+const isDev = typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+/**
+* Mask an email address for safe logging: `hugo@example.com` -> `h***@example.com`.
+*/
+function maskEmail(email) {
+	const atIndex = email.indexOf("@");
+	if (atIndex <= 0) return "***";
+	return `${email[0]}***${email.slice(atIndex)}`;
+}
+function extractUserData(user, options) {
+	const fields = options?.fields ?? DEFAULT_USER_FIELDS;
+	const data = {};
+	if (user.id !== void 0 && user.id !== null) data.id = user.id;
+	for (const field of fields) {
+		if (field === "id") continue;
+		const value = user[field];
+		if (value === void 0 || value === null) continue;
+		if (field === "email" && options?.maskEmail && typeof value === "string") data[field] = maskEmail(value);
+		else if (field === "createdAt" && value instanceof Date) data[field] = value.toISOString();
+		else data[field] = value;
+	}
+	return data;
+}
+function extractSessionData(session) {
+	const data = { id: String(session.id) };
+	if (session.expiresAt) data.expiresAt = session.expiresAt instanceof Date ? session.expiresAt.toISOString() : String(session.expiresAt);
+	if (typeof session.ipAddress === "string") data.ipAddress = session.ipAddress;
+	if (typeof session.userAgent === "string") data.userAgent = session.userAgent;
+	if (session.createdAt) data.createdAt = session.createdAt instanceof Date ? session.createdAt.toISOString() : String(session.createdAt);
+	return data;
+}
+/**
+* Identify a user on a wide event from a Better Auth session result.
+*
+* Sets `userId`, `user`, and optionally `session` fields on the logger.
+* Safe by default — only extracts whitelisted fields and never logs passwords or tokens.
+*
+* Returns `true` if the user was identified, `false` if session data was missing.
+*
+* @example
+* ```ts
+* import { identifyUser } from 'evlog/better-auth'
+*
+* const session = await auth.api.getSession({ headers: event.headers })
+* if (session) {
+*   identifyUser(log, session)
+* }
+* ```
+*
+* @example With email masking
+* ```ts
+* identifyUser(log, session, { maskEmail: true })
+* // user.email → "h***@example.com"
+* ```
+*
+* @example With extend for Better Auth plugins
+* ```ts
+* identifyUser(log, session, {
+*   extend: (s) => ({
+*     organization: s.user.activeOrganization,
+*     role: s.user.role,
+*   }),
+* })
+* ```
+*/
+function identifyUser(log, session, options) {
+	const user = extractUserData(session.user, options);
+	if (!user.id) return false;
+	const includeSession = options?.session !== false;
+	const data = {
+		userId: user.id,
+		user
+	};
+	if (includeSession) data.session = extractSessionData(session.session);
+	if (options?.extend) {
+		const extra = options.extend(session);
+		if (extra) Object.assign(data, extra);
+	}
+	log.set(data);
+	return true;
+}
+function shouldResolve(path, options) {
+	const exclude = options?.exclude ?? ["/api/auth/**"];
+	for (const pattern of exclude) if (matchesPattern(path, pattern)) return false;
+	if (options?.include) {
+		for (const pattern of options.include) if (matchesPattern(path, pattern)) return true;
+		return false;
+	}
+	return true;
+}
+/**
+* Create an async function that resolves a Better Auth session from headers
+* and identifies the user on the logger.
+*
+* Works with any framework — just pass the auth instance and call the returned
+* function with a logger and headers. Supports `include`/`exclude` route patterns
+* and lifecycle hooks (`onIdentify`, `onAnonymous`).
+*
+* @example Nuxt server middleware
+* ```ts
+* import { createAuthMiddleware } from 'evlog/better-auth'
+*
+* const identify = createAuthMiddleware(auth, {
+*   exclude: ['/api/auth/**', '/api/public/**'],
+* })
+*
+* export default defineEventHandler(async (event) => {
+*   if (!event.context.log) return
+*   await identify(event.context.log, event.headers, event.path)
+* })
+* ```
+*
+* @example Express
+* ```ts
+* const identify = createAuthMiddleware(auth, { maskEmail: true })
+*
+* app.use(async (req, res, next) => {
+*   await identify(req.log, req.headers, req.path)
+*   next()
+* })
+* ```
+*/
+function createAuthMiddleware(auth, options) {
+	return async (log, headers, path) => {
+		if (path && !shouldResolve(path, options)) return false;
+		const start = Date.now();
+		try {
+			const session = await auth.api.getSession({ headers });
+			const resolvedIn = Date.now() - start;
+			if (session) {
+				if (identifyUser(log, session, options)) {
+					log.set({ auth: {
+						resolvedIn,
+						identified: true
+					} });
+					if (options?.onIdentify) await options.onIdentify(log, session);
+					return true;
+				}
+			}
+			log.set({ auth: {
+				resolvedIn,
+				identified: false
+			} });
+			if (options?.onAnonymous) await options.onAnonymous(log);
+			return false;
+		} catch (err) {
+			const resolvedIn = Date.now() - start;
+			log.set({ auth: {
+				resolvedIn,
+				identified: false,
+				error: true
+			} });
+			if (isDev) console.warn("[evlog/better-auth] Session resolution failed:", err);
+			if (options?.onAnonymous) await options.onAnonymous(log);
+			return false;
+		}
+	};
+}
+/**
+* Create a Nitro `request` hook that auto-identifies users from Better Auth sessions.
+*
+* Resolves the session from request cookies on every request and sets user/session
+* context on the evlog logger. Skips `/api/auth/**` by default to avoid resolving
+* sessions during auth flows.
+*
+* @example
+* ```ts
+* // server/plugins/evlog-auth.ts
+* import { createAuthIdentifier } from 'evlog/better-auth'
+* import { auth } from '~/lib/auth'
+*
+* export default defineNitroPlugin((nitroApp) => {
+*   nitroApp.hooks.hook('request', createAuthIdentifier(auth))
+* })
+* ```
+*
+* @example With options
+* ```ts
+* nitroApp.hooks.hook('request', createAuthIdentifier(auth, {
+*   maskEmail: true,
+*   exclude: ['/api/auth/**', '/api/public/**'],
+* }))
+* ```
+*/
+function createAuthIdentifier(auth, options) {
+	const middleware = createAuthMiddleware(auth, options);
+	return async (event) => {
+		if (!event.context.log) return;
+		await middleware(event.context.log, event.headers, event.path);
+	};
+}
+//#endregion
+export { createAuthIdentifier, createAuthMiddleware, identifyUser, maskEmail };
+
+//# sourceMappingURL=index.mjs.map

package/dist/better-auth/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/better-auth/index.ts"],"sourcesContent":["import type { RequestLogger } from '../types'\nimport { matchesPattern } from '../utils'\n\n/**\n * Minimal type for the Better Auth instance.\n * Only requires `api.getSession` — compatible with any Better Auth configuration.\n */\nexport interface BetterAuthInstance {\n  api: {\n    getSession: (opts: {\n      headers: Headers | Record<string, string | string[] | undefined>\n    }) => Promise<{\n      user: Record<string, unknown>\n      session: Record<string, unknown>\n    } | null>\n  }\n}\n\n/**\n * User fields extracted from a Better Auth session.\n */\nexport interface AuthUserData {\n  id: string\n  name?: string\n  email?: string\n  image?: string\n  emailVerified?: boolean\n  createdAt?: string\n}\n\n/**\n * Session fields extracted from a Better Auth session.\n */\nexport interface AuthSessionData {\n  id: string\n  expiresAt?: string\n  ipAddress?: string\n  userAgent?: string\n  createdAt?: string\n}\n\n/**\n * Options for `identifyUser`.\n */\nexport interface IdentifyOptions {\n  /**\n   * Whether to mask the user email (e.g. `h***@domain.com`).\n   * @default false\n   */\n  maskEmail?: boolean\n  /**\n   * Whether to include session metadata on the wide event.\n   * @default true\n   */\n  session?: boolean\n  /**\n   * Whitelist of user fields to include.\n   * @default ['id', 'name', 'email', 'image', 'emailVerified', 'createdAt']\n   */\n  fields?: string[]\n  /**\n   * Extend the wide event with additional fields derived from the session.\n   * Useful for Better Auth plugins (organizations, roles, etc.).\n   *\n   * @example\n   * ```ts\n   * identifyUser(log, session, {\n   *   extend: (session) => ({\n   *     organization: session.user.activeOrganization,\n   *     role: session.user.role,\n   *   }),\n   * })\n   * ```\n   */\n  extend?: (session: { user: Record<string, unknown>, session: Record<string, unknown> }) => Record<string, unknown> | undefined\n}\n\n/**\n * Options for `createAuthMiddleware`.\n */\nexport interface AuthMiddlewareOptions extends IdentifyOptions {\n  /**\n   * Route patterns to skip session resolution (glob).\n   * @default ['/api/auth/**']\n   */\n  exclude?: string[]\n  /**\n   * Route patterns to apply session resolution (glob).\n   * If set, only matching routes are resolved.\n   */\n  include?: string[]\n  /**\n   * Called after a user is successfully identified.\n   * Use to add conditional logic based on user data (e.g. force-keep logs for premium users).\n   */\n  onIdentify?: (log: RequestLogger, session: { user: Record<string, unknown>, session: Record<string, unknown> }) => void | Promise<void>\n  /**\n   * Called when no session is found (anonymous request).\n   */\n  onAnonymous?: (log: RequestLogger) => void | Promise<void>\n}\n\n/**\n * Options for `createAuthIdentifier`.\n */\nexport type AuthIdentifierOptions = AuthMiddlewareOptions\n\nconst DEFAULT_USER_FIELDS = ['id', 'name', 'email', 'image', 'emailVerified', 'createdAt']\n\nconst isDev = typeof process !== 'undefined' && process.env?.NODE_ENV !== 'production'\n\n/**\n * Mask an email address for safe logging: `hugo@example.com` -> `h***@example.com`.\n */\nexport function maskEmail(email: string): string {\n  const atIndex = email.indexOf('@')\n  if (atIndex <= 0) return '***'\n  return `${email[0]}***${email.slice(atIndex)}`\n}\n\nfunction extractUserData(\n  user: Record<string, unknown>,\n  options?: IdentifyOptions,\n): AuthUserData {\n  const fields = options?.fields ?? DEFAULT_USER_FIELDS\n  const data: Record<string, unknown> = {}\n\n  if (user.id !== undefined && user.id !== null) {\n    data.id = user.id\n  }\n\n  for (const field of fields) {\n    if (field === 'id') continue\n    const value = user[field]\n    if (value === undefined || value === null) continue\n\n    if (field === 'email' && options?.maskEmail && typeof value === 'string') {\n      data[field] = maskEmail(value)\n    } else if (field === 'createdAt' && value instanceof Date) {\n      data[field] = value.toISOString()\n    } else {\n      data[field] = value\n    }\n  }\n\n  return data as unknown as AuthUserData\n}\n\nfunction extractSessionData(\n  session: Record<string, unknown>,\n): AuthSessionData {\n  const data: AuthSessionData = { id: String(session.id) }\n\n  if (session.expiresAt) {\n    data.expiresAt = session.expiresAt instanceof Date\n      ? session.expiresAt.toISOString()\n      : String(session.expiresAt)\n  }\n  if (typeof session.ipAddress === 'string') data.ipAddress = session.ipAddress\n  if (typeof session.userAgent === 'string') data.userAgent = session.userAgent\n  if (session.createdAt) {\n    data.createdAt = session.createdAt instanceof Date\n      ? session.createdAt.toISOString()\n      : String(session.createdAt)\n  }\n\n  return data\n}\n\n/**\n * Identify a user on a wide event from a Better Auth session result.\n *\n * Sets `userId`, `user`, and optionally `session` fields on the logger.\n * Safe by default — only extracts whitelisted fields and never logs passwords or tokens.\n *\n * Returns `true` if the user was identified, `false` if session data was missing.\n *\n * @example\n * ```ts\n * import { identifyUser } from 'evlog/better-auth'\n *\n * const session = await auth.api.getSession({ headers: event.headers })\n * if (session) {\n *   identifyUser(log, session)\n * }\n * ```\n *\n * @example With email masking\n * ```ts\n * identifyUser(log, session, { maskEmail: true })\n * // user.email → \"h***@example.com\"\n * ```\n *\n * @example With extend for Better Auth plugins\n * ```ts\n * identifyUser(log, session, {\n *   extend: (s) => ({\n *     organization: s.user.activeOrganization,\n *     role: s.user.role,\n *   }),\n * })\n * ```\n */\nexport function identifyUser(\n  log: RequestLogger,\n  session: { user: Record<string, unknown>, session: Record<string, unknown> },\n  options?: IdentifyOptions,\n): boolean {\n  const user = extractUserData(session.user, options)\n  if (!user.id) return false\n\n  const includeSession = options?.session !== false\n\n  const data: Record<string, unknown> = {\n    userId: user.id,\n    user,\n  }\n\n  if (includeSession) {\n    data.session = extractSessionData(session.session)\n  }\n\n  if (options?.extend) {\n    const extra = options.extend(session)\n    if (extra) Object.assign(data, extra)\n  }\n\n  log.set(data)\n  return true\n}\n\nfunction shouldResolve(path: string, options?: { exclude?: string[], include?: string[] }): boolean {\n  const exclude = options?.exclude ?? ['/api/auth/**']\n  for (const pattern of exclude) {\n    if (matchesPattern(path, pattern)) return false\n  }\n\n  if (options?.include) {\n    for (const pattern of options.include) {\n      if (matchesPattern(path, pattern)) return true\n    }\n    return false\n  }\n\n  return true\n}\n\n/**\n * Create an async function that resolves a Better Auth session from headers\n * and identifies the user on the logger.\n *\n * Works with any framework — just pass the auth instance and call the returned\n * function with a logger and headers. Supports `include`/`exclude` route patterns\n * and lifecycle hooks (`onIdentify`, `onAnonymous`).\n *\n * @example Nuxt server middleware\n * ```ts\n * import { createAuthMiddleware } from 'evlog/better-auth'\n *\n * const identify = createAuthMiddleware(auth, {\n *   exclude: ['/api/auth/**', '/api/public/**'],\n * })\n *\n * export default defineEventHandler(async (event) => {\n *   if (!event.context.log) return\n *   await identify(event.context.log, event.headers, event.path)\n * })\n * ```\n *\n * @example Express\n * ```ts\n * const identify = createAuthMiddleware(auth, { maskEmail: true })\n *\n * app.use(async (req, res, next) => {\n *   await identify(req.log, req.headers, req.path)\n *   next()\n * })\n * ```\n */\nexport function createAuthMiddleware(\n  auth: BetterAuthInstance,\n  options?: AuthMiddlewareOptions,\n): (log: RequestLogger, headers: Headers | Record<string, string | string[] | undefined>, path?: string) => Promise<boolean> {\n  return async (log, headers, path?) => {\n    if (path && !shouldResolve(path, options)) return false\n\n    const start = Date.now()\n    try {\n      const session = await auth.api.getSession({ headers })\n      const resolvedIn = Date.now() - start\n\n      if (session) {\n        const identified = identifyUser(log, session, options)\n        if (identified) {\n          log.set({ auth: { resolvedIn, identified: true } } as Record<string, unknown>)\n          if (options?.onIdentify) await options.onIdentify(log, session)\n          return true\n        }\n      }\n\n      log.set({ auth: { resolvedIn, identified: false } } as Record<string, unknown>)\n      if (options?.onAnonymous) await options.onAnonymous(log)\n      return false\n    } catch (err) {\n      const resolvedIn = Date.now() - start\n      log.set({ auth: { resolvedIn, identified: false, error: true } } as Record<string, unknown>)\n      if (isDev) console.warn('[evlog/better-auth] Session resolution failed:', err)\n      if (options?.onAnonymous) await options.onAnonymous(log)\n      return false\n    }\n  }\n}\n\n/**\n * Create a Nitro `request` hook that auto-identifies users from Better Auth sessions.\n *\n * Resolves the session from request cookies on every request and sets user/session\n * context on the evlog logger. Skips `/api/auth/**` by default to avoid resolving\n * sessions during auth flows.\n *\n * @example\n * ```ts\n * // server/plugins/evlog-auth.ts\n * import { createAuthIdentifier } from 'evlog/better-auth'\n * import { auth } from '~/lib/auth'\n *\n * export default defineNitroPlugin((nitroApp) => {\n *   nitroApp.hooks.hook('request', createAuthIdentifier(auth))\n * })\n * ```\n *\n * @example With options\n * ```ts\n * nitroApp.hooks.hook('request', createAuthIdentifier(auth, {\n *   maskEmail: true,\n *   exclude: ['/api/auth/**', '/api/public/**'],\n * }))\n * ```\n */\nexport function createAuthIdentifier(\n  auth: BetterAuthInstance,\n  options?: AuthIdentifierOptions,\n): (event: { path: string, headers: Headers | { get(name: string): string | null }, context: { log?: RequestLogger } }) => Promise<void> {\n  const middleware = createAuthMiddleware(auth, options)\n\n  return async (event) => {\n    if (!event.context.log) return\n    await middleware(event.context.log, event.headers as Headers, event.path)\n  }\n}\n"],"mappings":"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"}

package/dist/browser.d.mts

@@ -1,4 +1,4 @@
-import { r as DrainContext } from "./types-D5OwxZCw.mjs";
+import { F as DrainContext } from "./audit-mUutdf6A.mjs";
 import { PipelineDrainFn } from "./pipeline.mjs";
 import { HttpDrainConfig, HttpLogDrainOptions } from "./http.mjs";
 

package/dist/elysia/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 { Elysia } from "elysia";
 
 //#region src/elysia/index.d.ts

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/elysia/index.ts"],"mappings":";;;;;KAeY,kBAAA,GAAqB,gBAAA;;AAAjC;;;;;AAoBA;;;;;;;;;;;;iBAAgB,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,aAAA,CAAc,CAAA;AAAA,iBAwCvE,KAAA,CAAM,OAAA,GAAS,kBAAA,GAAuB,MAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/elysia/index.ts"],"mappings":";;;;;KAgBY,kBAAA,GAAqB,gBAAA;;AAAjC;;;;;AAoBA;;;;;;;;;;;;iBAAgB,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,aAAA,CAAc,CAAA;AAAA,iBAwCvE,KAAA,CAAM,OAAA,GAAS,kBAAA,GAAuB,MAAA"}

package/dist/elysia/index.mjs

@@ -1,5 +1,6 @@
 import { filterSafeHeaders } from "../utils.mjs";
-import { r as createMiddlewareLogger } from "../headers-ht4yS2mx.mjs";
+import { t as createMiddlewareLogger } from "../middleware-BWOJ7JI0.mjs";
+import { t as attachForkToLogger } from "../fork-CTJXnpl8.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Elysia } from "elysia";
 //#region src/elysia/index.ts
@@ -32,14 +33,25 @@ function evlog(options = {}) {
 	const emitted = /* @__PURE__ */ new WeakSet();
 	const requestState = /* @__PURE__ */ new WeakMap();
 	return new Elysia({ name: "evlog" }).derive({ as: "global" }, ({ request, path, headers }) => {
-		const { logger, finish, skipped } = createMiddlewareLogger({
+		const middlewareOpts = {
 			method: request.method,
 			path,
 			requestId: headers["x-request-id"] || crypto.randomUUID(),
 			headers: filterSafeHeaders(headers),
 			...options
-		});
-		if (!skipped) activeLoggers.add(logger);
+		};
+		const { logger, finish, skipped } = createMiddlewareLogger(middlewareOpts);
+		if (!skipped) {
+			attachForkToLogger(storage, logger, middlewareOpts, {
+				onChildEnter: (child) => {
+					activeLoggers.add(child);
+				},
+				onChildExit: (child) => {
+					activeLoggers.delete(child);
+				}
+			});
+			activeLoggers.add(logger);
+		}
 		storage.enterWith(logger);
 		requestState.set(request, {
 			finish,

package/dist/elysia/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/elysia/index.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport { Elysia } from 'elysia'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { extractSafeHeaders } from '../shared/headers'\nimport { filterSafeHeaders } from '../utils'\n\nconst storage = new AsyncLocalStorage<RequestLogger>()\n\n// Tracks loggers that are currently active (within a live request).\n// Elysia uses storage.enterWith() which persists in the async context\n// even after the request ends, so we use this set to distinguish\n// an in-flight logger from a stale one.\nconst activeLoggers = new WeakSet<RequestLogger>()\n\nexport type EvlogElysiaOptions = BaseEvlogOptions\n\n/**\n * Get the request-scoped logger from anywhere in the call stack.\n * Must be called inside a request handled by the `evlog()` plugin.\n *\n * Unlike other frameworks, Elysia uses `storage.enterWith()` which persists\n * beyond the request lifecycle. This accessor additionally checks `activeLoggers`\n * to ensure the logger belongs to an in-flight request.\n *\n * @example\n * ```ts\n * import { useLogger } from 'evlog/elysia'\n *\n * function findUser(id: string) {\n *   const log = useLogger()\n *   log.set({ user: { id } })\n * }\n * ```\n */\nexport function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n  const logger = storage.getStore()\n  if (!logger || !activeLoggers.has(logger)) {\n    throw new Error(\n      '[evlog] useLogger() was called outside of an evlog plugin context. '\n      + 'Make sure app.use(evlog()) is registered before your routes.',\n    )\n  }\n  return logger as RequestLogger<T>\n}\n\n/**\n * Create an evlog plugin for Elysia.\n *\n * @example\n * ```ts\n * import { Elysia } from 'elysia'\n * import { evlog } from 'evlog/elysia'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = new Elysia()\n *   .use(evlog({\n *     drain: createAxiomDrain(),\n *     enrich: (ctx) => {\n *       ctx.event.region = process.env.FLY_REGION\n *     },\n *   }))\n *   .get('/health', ({ log }) => {\n *     log.set({ route: 'health' })\n *     return { ok: true }\n *   })\n *   .listen(3000)\n * ```\n */\ninterface RequestState {\n  finish: (opts?: { status?: number; error?: Error }) => Promise<unknown>\n  skipped: boolean\n  logger: RequestLogger\n}\n\nexport function evlog(options: EvlogElysiaOptions = {}) {\n  const emitted = new WeakSet<Request>()\n  const requestState = new WeakMap<Request, RequestState>()\n\n  return new Elysia({ name: 'evlog' })\n    .derive({ as: 'global' }, ({ request, path, headers }) => {\n      const { logger, finish, skipped } = createMiddlewareLogger({\n        method: request.method,\n        path,\n        requestId: headers['x-request-id'] || crypto.randomUUID(),\n        // It's recommended to use context.headers instead of context.request.headers\n        // because Elysia has fast path for getting headers on Bun\n        headers: filterSafeHeaders(headers as Record<string, string>),\n        ...options,\n      })\n\n      if (!skipped) activeLoggers.add(logger)\n      storage.enterWith(logger)\n      requestState.set(request, { finish, skipped, logger })\n\n      return { log: logger }\n    })\n    .onAfterResponse({ as: 'global' }, async ({ request, set }) => {\n      const state = requestState.get(request)\n      if (!state || state.skipped || emitted.has(request)) return\n      emitted.add(request)\n      await state.finish({ status: set.status as number || 200 })\n      activeLoggers.delete(state.logger)\n      storage.enterWith(undefined as unknown as RequestLogger)\n    })\n    .onError({ as: 'global' }, async ({ request, error }) => {\n      const state = requestState.get(request)\n      if (!state || state.skipped || emitted.has(request)) return\n      emitted.add(request)\n      const err = error instanceof Error ? error : new Error(String(error))\n      state.logger.error(err)\n      await state.finish({ error: err })\n      activeLoggers.delete(state.logger)\n      storage.enterWith(undefined as unknown as RequestLogger)\n    })\n}\n"],"mappings":";;;;;AAOA,MAAM,UAAU,IAAI,mBAAkC;AAMtD,MAAM,gCAAgB,IAAI,SAAwB;;;;;;;;;;;;;;;;;;;AAsBlD,SAAgB,YAA0E;CACxF,MAAM,SAAS,QAAQ,UAAU;AACjC,KAAI,CAAC,UAAU,CAAC,cAAc,IAAI,OAAO,CACvC,OAAM,IAAI,MACR,kIAED;AAEH,QAAO;;AAgCT,SAAgB,MAAM,UAA8B,EAAE,EAAE;CACtD,MAAM,0BAAU,IAAI,SAAkB;CACtC,MAAM,+BAAe,IAAI,SAAgC;AAEzD,QAAO,IAAI,OAAO,EAAE,MAAM,SAAS,CAAC,CACjC,OAAO,EAAE,IAAI,UAAU,GAAG,EAAE,SAAS,MAAM,cAAc;EACxD,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,QAAQ;GAChB;GACA,WAAW,QAAQ,mBAAmB,OAAO,YAAY;GAGzD,SAAS,kBAAkB,QAAkC;GAC7D,GAAG;GACJ,CAAC;AAEF,MAAI,CAAC,QAAS,eAAc,IAAI,OAAO;AACvC,UAAQ,UAAU,OAAO;AACzB,eAAa,IAAI,SAAS;GAAE;GAAQ;GAAS;GAAQ,CAAC;AAEtD,SAAO,EAAE,KAAK,QAAQ;GACtB,CACD,gBAAgB,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,SAAS,UAAU;EAC7D,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,MAAM,WAAW,QAAQ,IAAI,QAAQ,CAAE;AACrD,UAAQ,IAAI,QAAQ;AACpB,QAAM,MAAM,OAAO,EAAE,QAAQ,IAAI,UAAoB,KAAK,CAAC;AAC3D,gBAAc,OAAO,MAAM,OAAO;AAClC,UAAQ,UAAU,KAAA,EAAsC;GACxD,CACD,QAAQ,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,SAAS,YAAY;EACvD,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,MAAM,WAAW,QAAQ,IAAI,QAAQ,CAAE;AACrD,UAAQ,IAAI,QAAQ;EACpB,MAAM,MAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC;AACrE,QAAM,OAAO,MAAM,IAAI;AACvB,QAAM,MAAM,OAAO,EAAE,OAAO,KAAK,CAAC;AAClC,gBAAc,OAAO,MAAM,OAAO;AAClC,UAAQ,UAAU,KAAA,EAAsC;GACxD"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/elysia/index.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport { Elysia } from 'elysia'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeHeaders } from '../shared/headers'\nimport { filterSafeHeaders } from '../utils'\n\nconst storage = new AsyncLocalStorage<RequestLogger>()\n\n// Tracks loggers that are currently active (within a live request).\n// Elysia uses storage.enterWith() which persists in the async context\n// even after the request ends, so we use this set to distinguish\n// an in-flight logger from a stale one.\nconst activeLoggers = new WeakSet<RequestLogger>()\n\nexport type EvlogElysiaOptions = BaseEvlogOptions\n\n/**\n * Get the request-scoped logger from anywhere in the call stack.\n * Must be called inside a request handled by the `evlog()` plugin.\n *\n * Unlike other frameworks, Elysia uses `storage.enterWith()` which persists\n * beyond the request lifecycle. This accessor additionally checks `activeLoggers`\n * to ensure the logger belongs to an in-flight request.\n *\n * @example\n * ```ts\n * import { useLogger } from 'evlog/elysia'\n *\n * function findUser(id: string) {\n *   const log = useLogger()\n *   log.set({ user: { id } })\n * }\n * ```\n */\nexport function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n  const logger = storage.getStore()\n  if (!logger || !activeLoggers.has(logger)) {\n    throw new Error(\n      '[evlog] useLogger() was called outside of an evlog plugin context. '\n      + 'Make sure app.use(evlog()) is registered before your routes.',\n    )\n  }\n  return logger as RequestLogger<T>\n}\n\n/**\n * Create an evlog plugin for Elysia.\n *\n * @example\n * ```ts\n * import { Elysia } from 'elysia'\n * import { evlog } from 'evlog/elysia'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = new Elysia()\n *   .use(evlog({\n *     drain: createAxiomDrain(),\n *     enrich: (ctx) => {\n *       ctx.event.region = process.env.FLY_REGION\n *     },\n *   }))\n *   .get('/health', ({ log }) => {\n *     log.set({ route: 'health' })\n *     return { ok: true }\n *   })\n *   .listen(3000)\n * ```\n */\ninterface RequestState {\n  finish: (opts?: { status?: number; error?: Error }) => Promise<unknown>\n  skipped: boolean\n  logger: RequestLogger\n}\n\nexport function evlog(options: EvlogElysiaOptions = {}) {\n  const emitted = new WeakSet<Request>()\n  const requestState = new WeakMap<Request, RequestState>()\n\n  return new Elysia({ name: 'evlog' })\n    .derive({ as: 'global' }, ({ request, path, headers }) => {\n      const middlewareOpts = {\n        method: request.method,\n        path,\n        requestId: headers['x-request-id'] || crypto.randomUUID(),\n        // It's recommended to use context.headers instead of context.request.headers\n        // because Elysia has fast path for getting headers on Bun\n        headers: filterSafeHeaders(headers as Record<string, string>),\n        ...options,\n      }\n      const { logger, finish, skipped } = createMiddlewareLogger(middlewareOpts)\n\n      if (!skipped) {\n        attachForkToLogger(storage, logger, middlewareOpts, {\n          onChildEnter: (child) => {\n            activeLoggers.add(child)\n          },\n          onChildExit: (child) => {\n            activeLoggers.delete(child)\n          },\n        })\n        activeLoggers.add(logger)\n      }\n      storage.enterWith(logger)\n      requestState.set(request, { finish, skipped, logger })\n\n      return { log: logger }\n    })\n    .onAfterResponse({ as: 'global' }, async ({ request, set }) => {\n      const state = requestState.get(request)\n      if (!state || state.skipped || emitted.has(request)) return\n      emitted.add(request)\n      await state.finish({ status: set.status as number || 200 })\n      activeLoggers.delete(state.logger)\n      storage.enterWith(undefined as unknown as RequestLogger)\n    })\n    .onError({ as: 'global' }, async ({ request, error }) => {\n      const state = requestState.get(request)\n      if (!state || state.skipped || emitted.has(request)) return\n      emitted.add(request)\n      const err = error instanceof Error ? error : new Error(String(error))\n      state.logger.error(err)\n      await state.finish({ error: err })\n      activeLoggers.delete(state.logger)\n      storage.enterWith(undefined as unknown as RequestLogger)\n    })\n}\n"],"mappings":";;;;;;AAQA,MAAM,UAAU,IAAI,mBAAkC;AAMtD,MAAM,gCAAgB,IAAI,SAAwB;;;;;;;;;;;;;;;;;;;AAsBlD,SAAgB,YAA0E;CACxF,MAAM,SAAS,QAAQ,UAAU;AACjC,KAAI,CAAC,UAAU,CAAC,cAAc,IAAI,OAAO,CACvC,OAAM,IAAI,MACR,kIAED;AAEH,QAAO;;AAgCT,SAAgB,MAAM,UAA8B,EAAE,EAAE;CACtD,MAAM,0BAAU,IAAI,SAAkB;CACtC,MAAM,+BAAe,IAAI,SAAgC;AAEzD,QAAO,IAAI,OAAO,EAAE,MAAM,SAAS,CAAC,CACjC,OAAO,EAAE,IAAI,UAAU,GAAG,EAAE,SAAS,MAAM,cAAc;EACxD,MAAM,iBAAiB;GACrB,QAAQ,QAAQ;GAChB;GACA,WAAW,QAAQ,mBAAmB,OAAO,YAAY;GAGzD,SAAS,kBAAkB,QAAkC;GAC7D,GAAG;GACJ;EACD,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB,eAAe;AAE1E,MAAI,CAAC,SAAS;AACZ,sBAAmB,SAAS,QAAQ,gBAAgB;IAClD,eAAe,UAAU;AACvB,mBAAc,IAAI,MAAM;;IAE1B,cAAc,UAAU;AACtB,mBAAc,OAAO,MAAM;;IAE9B,CAAC;AACF,iBAAc,IAAI,OAAO;;AAE3B,UAAQ,UAAU,OAAO;AACzB,eAAa,IAAI,SAAS;GAAE;GAAQ;GAAS;GAAQ,CAAC;AAEtD,SAAO,EAAE,KAAK,QAAQ;GACtB,CACD,gBAAgB,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,SAAS,UAAU;EAC7D,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,MAAM,WAAW,QAAQ,IAAI,QAAQ,CAAE;AACrD,UAAQ,IAAI,QAAQ;AACpB,QAAM,MAAM,OAAO,EAAE,QAAQ,IAAI,UAAoB,KAAK,CAAC;AAC3D,gBAAc,OAAO,MAAM,OAAO;AAClC,UAAQ,UAAU,KAAA,EAAsC;GACxD,CACD,QAAQ,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,SAAS,YAAY;EACvD,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,MAAM,WAAW,QAAQ,IAAI,QAAQ,CAAE;AACrD,UAAQ,IAAI,QAAQ;EACpB,MAAM,MAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC;AACrE,QAAM,OAAO,MAAM,IAAI;AACvB,QAAM,MAAM,OAAO,EAAE,OAAO,KAAK,CAAC;AAClC,gBAAc,OAAO,MAAM,OAAO;AAClC,UAAQ,UAAU,KAAA,EAAsC;GACxD"}

package/dist/enrichers.d.mts

@@ -1,4 +1,4 @@
-import { i as EnrichContext } from "./types-D5OwxZCw.mjs";
+import { I as EnrichContext } from "./audit-mUutdf6A.mjs";
 
 //#region src/enrichers/index.d.ts
 interface EnricherOptions {

package/dist/{error-WRz4_F3W.d.mts → error-D1FZI2Kd.d.mts}

@@ -1,4 +1,4 @@
-import { o as ErrorOptions } from "./types-D5OwxZCw.mjs";
+import { R as ErrorOptions } from "./audit-mUutdf6A.mjs";
 
 //#region src/error.d.ts
 /**
@@ -67,4 +67,4 @@ declare class EvlogError extends Error {
 declare function createError(options: ErrorOptions | string): EvlogError;
 //#endregion
 export { createError as n, EvlogError as t };
-//# sourceMappingURL=error-WRz4_F3W.d.mts.map
+//# sourceMappingURL=error-D1FZI2Kd.d.mts.map

package/dist/{error-WRz4_F3W.d.mts.map → error-D1FZI2Kd.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"error-WRz4_F3W.d.mts","names":[],"sources":["../src/error.ts"],"mappings":";;;;;AAqBA;;;;;;;;;;;;;cAAa,UAAA,SAAmB,KAAA;EAY1B;EAAA,SATK,MAAA;EAAA,SACA,GAAA;EAAA,SACA,GAAA;EAAA,SACA,IAAA;EAqCL;;;;EAAA,IA/BA,QAAA,CAAA,GAAY,MAAA;cAIJ,OAAA,EAAS,YAAA;EA0CqB;EAAA,IAftC,UAAA,CAAA;EAuDJ;EAAA,IAlDI,UAAA,CAAA;EAkDY;EAAA,IA7CZ,aAAA,CAAA;EAiFU;EAAA,IA5EV,IAAA,CAAA;IAAU,GAAA;IAAc,GAAA;IAAc,IAAA;EAAA;EAOjC,QAAA,CAAA;EAiCT,MAAA,CAAA,GAAU,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;iBAoCI,WAAA,CAAY,OAAA,EAAS,YAAA,YAAwB,UAAA"}
+{"version":3,"file":"error-D1FZI2Kd.d.mts","names":[],"sources":["../src/error.ts"],"mappings":";;;;;AAqBA;;;;;;;;;;;;;cAAa,UAAA,SAAmB,KAAA;EAY1B;EAAA,SATK,MAAA;EAAA,SACA,GAAA;EAAA,SACA,GAAA;EAAA,SACA,IAAA;EAqCL;;;;EAAA,IA/BA,QAAA,CAAA,GAAY,MAAA;cAIJ,OAAA,EAAS,YAAA;EA0CqB;EAAA,IAftC,UAAA,CAAA;EAuDJ;EAAA,IAlDI,UAAA,CAAA;EAkDY;EAAA,IA7CZ,aAAA,CAAA;EAiFU;EAAA,IA5EV,IAAA,CAAA;IAAU,GAAA;IAAc,GAAA;IAAc,IAAA;EAAA;EAOjC,QAAA,CAAA;EAiCT,MAAA,CAAA,GAAU,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;iBAoCI,WAAA,CAAY,OAAA,EAAS,YAAA,YAAwB,UAAA"}

package/dist/error.d.mts

@@ -1,2 +1,2 @@
-import { n as createError, t as EvlogError } from "./error-WRz4_F3W.mjs";
+import { n as createError, t as EvlogError } from "./error-D1FZI2Kd.mjs";
 export { EvlogError, createError, createError as createEvlogError };

package/dist/{errors-J2kt7mZh.d.mts → errors-NIXCyk6I.d.mts}

@@ -1,4 +1,4 @@
-import { y as RouteConfig } from "./types-D5OwxZCw.mjs";
+import { Z as RouteConfig } from "./audit-mUutdf6A.mjs";
 
 //#region src/shared/routes.d.ts
 declare function shouldLog(path: string, include?: string[], exclude?: string[]): boolean;
@@ -36,4 +36,4 @@ declare function getServiceForPath(path: string, routes?: Record<string, RouteCo
 declare function extractErrorStatus(error: unknown): number;
 //#endregion
 export { getServiceForPath as n, shouldLog as r, extractErrorStatus as t };
-//# sourceMappingURL=errors-J2kt7mZh.d.mts.map
+//# sourceMappingURL=errors-NIXCyk6I.d.mts.map

package/dist/{errors-J2kt7mZh.d.mts.map → errors-NIXCyk6I.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"errors-J2kt7mZh.d.mts","names":[],"sources":["../src/shared/routes.ts","../src/shared/errors.ts"],"mappings":";;;iBAGgB,SAAA,CAAU,IAAA,UAAc,OAAA,aAAoB,OAAA;;AAA5D;;;;;;;;;AAsCA;;;;;;;;;;;iBAAgB,iBAAA,CAAkB,IAAA,UAAc,MAAA,GAAS,MAAA,SAAe,WAAA;;;;;;AAtCxE;;;;iBCIgB,kBAAA,CAAmB,KAAA"}
+{"version":3,"file":"errors-NIXCyk6I.d.mts","names":[],"sources":["../src/shared/routes.ts","../src/shared/errors.ts"],"mappings":";;;iBAGgB,SAAA,CAAU,IAAA,UAAc,OAAA,aAAoB,OAAA;;AAA5D;;;;;;;;;AAsCA;;;;;;;;;;;iBAAgB,iBAAA,CAAkB,IAAA,UAAc,MAAA,GAAS,MAAA,SAAe,WAAA;;;;;;AAtCxE;;;;iBCIgB,kBAAA,CAAmB,KAAA"}

package/dist/express/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 { RequestHandler } from "express";
 
 //#region src/express/index.d.ts

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/express/index.ts"],"mappings":";;;;;cAMiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,mBAAA,GAAsB,gBAAA;AAAA;EAAA,UAKtB,OAAA;IACR,GAAA,EAAK,aAAA;EAAA;AAAA;;;;;;;;;AANT;;;;;AAEoB;;;;;iBA0BJ,KAAA,CAAM,OAAA,GAAS,mBAAA,GAA2B,cAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/express/index.ts"],"mappings":";;;;;cAOiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,mBAAA,GAAsB,gBAAA;AAAA;EAAA,UAKtB,OAAA;IACR,GAAA,EAAK,aAAA;EAAA;AAAA;;;;;;;;;AANT;;;;;AAEoB;;;;;iBA0BJ,KAAA,CAAM,OAAA,GAAS,mBAAA,GAA2B,cAAA"}