evlog 2.19.1 → 2.19.2

package/dist/nitro-ClHmVj1H.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nitro-ClHmVj1H.mjs","names":[],"sources":["../src/nitro.ts"],"sourcesContent":["import type { EnvironmentContext, LogLevel, RedactConfig, RouteConfig, SamplingConfig } from './types'\nimport type { DevTerminalInput, DevTerminalResolveInput } from './shared/dev-terminal'\nimport { extractErrorStatus } from './shared/errors'\nimport { resolveDevTerminal, shouldShowFrameworkOverlay } from './shared/dev-terminal'\nimport { readEvlogConfigSync } from './shared/nitroConfigBridge'\n\nexport type { DevTerminalInput, DevTerminalPreset, DevPrettyErrorConfig, DevTerminalConfigObject, ResolvedPrettyError } from './shared/dev-terminal'\nexport { resolveDevTerminal, shouldShowFrameworkOverlay } from './shared/dev-terminal'\n\nexport { shouldLog, getServiceForPath } from './shared/routes'\n\nexport interface NitroModuleOptions {\n  /**\n   * Enable or disable all logging globally.\n   * @default true\n   */\n  enabled?: boolean\n\n  /**\n   * Environment context overrides.\n   */\n  env?: Partial<EnvironmentContext>\n\n  /**\n   * Enable pretty printing.\n   * @default true in development, false in production\n   */\n  pretty?: boolean\n\n  /**\n   * Dev terminal output: preset or explicit overlay + pretty-error settings.\n   * @default 'evlog' when pretty in development\n   */\n  dev?: DevTerminalInput\n\n  /**\n   * Suppress built-in console output.\n   * When true, events are still built, sampled, and passed to drains,\n   * but nothing is written to console. Use when drains own the output\n   * channel (e.g., stdout-based platforms like GCP Cloud Run, AWS Lambda).\n   * @default false\n   */\n  silent?: boolean\n\n  /**\n   * Route patterns to include in logging.\n   * Supports glob patterns like '/api/**'.\n   * If not set, all routes are logged.\n   */\n  include?: string[]\n\n  /**\n   * Route patterns to exclude from logging.\n   * Supports glob patterns like '/_nitro/**'.\n   * Exclusions take precedence over inclusions.\n   */\n  exclude?: string[]\n\n  /**\n   * Route-specific service configuration.\n   */\n  routes?: Record<string, RouteConfig>\n\n  /**\n   * Sampling configuration for filtering logs.\n   */\n  sampling?: SamplingConfig\n\n  /**\n   * Minimum severity for the global `log` API (not request wide events).\n   * Order: debug < info < warn < error.\n   * @default 'debug'\n   */\n  minLevel?: LogLevel\n\n  /**\n   * Auto-redaction configuration for PII protection.\n   * `true` enables all built-in PII patterns. Pass an object for fine-grained control.\n   */\n  redact?: boolean | RedactConfig\n}\n\n/**\n * JSON-friendly subset of evlog Nitro plugin options consumed by the Nitro/Nuxt\n * runtime (read from `runtimeConfig.evlog` or the `__EVLOG_CONFIG` env bridge).\n *\n * @internal Internal Nitro contract — do not use from application code. Use\n * {@link import('./shared/define').EvlogConfig} for the canonical user-facing\n * config shape.\n */\nexport interface NitroPluginEvlogConfig extends DevTerminalResolveInput {\n  enabled?: boolean\n  env?: Record<string, unknown>\n  silent?: boolean\n  include?: string[]\n  exclude?: string[]\n  routes?: Record<string, RouteConfig>\n  sampling?: SamplingConfig\n  minLevel?: LogLevel\n  redact?: boolean | RedactConfig | Record<string, unknown>\n}\n\n/** @deprecated Renamed to {@link NitroPluginEvlogConfig}. Kept for backward compat. */\nexport type EvlogConfig = NitroPluginEvlogConfig\n\n/**\n * Resolve an EvlogError from an error or its cause chain.\n * Both Nitro v2 (h3) and v3 wrap thrown errors — this unwraps them.\n */\nexport function resolveEvlogError(error: Error): Error | null {\n  if (error.name === 'EvlogError') return error\n  if ((error.cause as Error)?.name === 'EvlogError') return error.cause as Error\n  return null\n}\n\nexport { extractErrorStatus } from './shared/errors'\n\n/** Request metadata used to decide JSON vs framework error-page rendering. */\nexport interface NitroErrorRequestContext {\n  pathname: string\n  getHeader(name: string): string | undefined\n}\n\nfunction acceptIncludes(accept: string | undefined, mediaType: string): boolean {\n  return accept?.toLowerCase().includes(mediaType) ?? false\n}\n\nfunction isNitroApiPath(pathname: string): boolean {\n  return pathname === '/api' || pathname.startsWith('/api/')\n}\n\n/**\n * Whether evlog's Nitro error handler should flush a JSON body itself.\n *\n * Returns `false` for document/page requests so Nitro can delegate to the next\n * handler in the chain (e.g. Nuxt's `error.vue` renderer). EvlogError and API\n * routes always serialize as JSON.\n *\n * @internal\n */\nexport function shouldSerializeNitroErrorAsJson(\n  request: NitroErrorRequestContext,\n  evlogError: Error | null,\n): boolean {\n  if (evlogError) return true\n\n  const { pathname, getHeader } = request\n\n  if (isNitroApiPath(pathname)) return true\n\n  const secFetchDest = getHeader('sec-fetch-dest')\n  if (secFetchDest === 'document') return false\n\n  const secFetchMode = getHeader('sec-fetch-mode')\n  if (secFetchMode === 'navigate') return false\n\n  const accept = getHeader('accept')\n\n  if (getHeader('x-requested-with')?.toLowerCase() === 'xmlhttprequest') return true\n\n  if (acceptIncludes(accept, 'application/json') && !acceptIncludes(accept, 'text/html')) {\n    return true\n  }\n\n  if (acceptIncludes(accept, 'text/html')) return false\n\n  // fetch/curl without HTML signals — preserve standalone Nitro JSON behavior\n  return true\n}\n\n/**\n * Mark an h3 event handled synchronously.\n * Nitro chains a built-in dev handler after custom handlers; `send()` defers\n * `res.end`, so without this the Youch overlay still runs.\n * @internal\n */\nexport function markH3ErrorHandled(event: { _handled?: boolean }): void {\n  event._handled = true\n}\n\n/**\n * Prepend evlog's Nitro error handler so it runs before framework handlers (e.g. Nuxt).\n * @internal\n */\nexport function prependNitroErrorHandler(\n  errorHandler: string | string[] | undefined,\n  handlerPath: string,\n): string | string[] {\n  if (!errorHandler) return handlerPath\n  if (Array.isArray(errorHandler)) {\n    const rest = errorHandler.filter(h => h !== handlerPath)\n    return [handlerPath, ...rest]\n  }\n  if (errorHandler === handlerPath) return handlerPath\n  return [handlerPath, errorHandler]\n}\n\n/**\n * Whether the Nitro dev Youch overlay should be suppressed for this process.\n * @internal\n */\nlet cachedConfigKey: string | undefined\nlet cachedSuppressOverlay: boolean | undefined\n\nexport function shouldSuppressNitroDevOverlay(): boolean {\n  const config = readEvlogConfigSync()\n  const key = config ? JSON.stringify(config) : ''\n  if (cachedSuppressOverlay !== undefined && cachedConfigKey === key) {\n    return cachedSuppressOverlay\n  }\n\n  cachedConfigKey = key\n  cachedSuppressOverlay = !resolveDevTerminal(config ?? {}).frameworkOverlay\n  return cachedSuppressOverlay\n}\n\n/** @internal Reset overlay decision cache — tests only. */\nexport function resetNitroDevOverlayCache(): void {\n  cachedConfigKey = undefined\n  cachedSuppressOverlay = undefined\n}\n\n/**\n * Clear Nitro/h3 unhandled flags so the dev Youch logger skips this error.\n * @internal\n */\nexport function suppressNitroDevOverlay(error: Error): void {\n  const err = error as Error & { unhandled?: boolean; fatal?: boolean }\n  err.unhandled = false\n  err.fatal = false\n}\n\n/**\n * Build Nitro-compatible JSON for non-EvlogError throws.\n * Sanitizes 5xx messages in production.\n */\nexport function buildPlainNitroErrorBody(\n  error: Error,\n  url: string,\n  isDev = process.env.NODE_ENV === 'development',\n): Record<string, unknown> {\n  const status = extractErrorStatus(error)\n  const rawMessage = ((error as { statusText?: string }).statusText\n    ?? (error as { statusMessage?: string }).statusMessage\n    ?? error.message) || 'Internal Server Error'\n  const message = isDev\n    ? rawMessage\n    : (status >= 500 ? 'Internal Server Error' : rawMessage)\n\n  return {\n    url,\n    status,\n    statusCode: status,\n    statusText: message,\n    statusMessage: message,\n    message,\n    error: true,\n  }\n}\n\n/**\n * Build a standard evlog error JSON response body.\n * Used by both v2 and v3 error handlers to ensure consistent shape.\n */\nexport function serializeEvlogErrorResponse(error: Error, url: string): Record<string, unknown> {\n  const status = extractErrorStatus(error)\n  const { data } = error as { data?: unknown }\n  const statusMessage = (error as { statusMessage?: string }).statusMessage || error.message\n  return {\n    url,\n    status,\n    statusCode: status,\n    statusText: statusMessage,\n    statusMessage,\n    message: error.message,\n    error: true,\n    ...(data !== undefined && { data }),\n  }\n}\n\n"],"mappings":";;;;;;;;AA6GA,SAAgB,kBAAkB,OAA4B;AAC5D,KAAI,MAAM,SAAS,aAAc,QAAO;AACxC,KAAK,MAAM,OAAiB,SAAS,aAAc,QAAO,MAAM;AAChE,QAAO;;AAWT,SAAS,eAAe,QAA4B,WAA4B;AAC9E,QAAO,QAAQ,aAAa,CAAC,SAAS,UAAU,IAAI;;AAGtD,SAAS,eAAe,UAA2B;AACjD,QAAO,aAAa,UAAU,SAAS,WAAW,QAAQ;;;;;;;;;;;AAY5D,SAAgB,gCACd,SACA,YACS;AACT,KAAI,WAAY,QAAO;CAEvB,MAAM,EAAE,UAAU,cAAc;AAEhC,KAAI,eAAe,SAAS,CAAE,QAAO;AAGrC,KADqB,UAAU,iBACf,KAAK,WAAY,QAAO;AAGxC,KADqB,UAAU,iBACf,KAAK,WAAY,QAAO;CAExC,MAAM,SAAS,UAAU,SAAS;AAElC,KAAI,UAAU,mBAAmB,EAAE,aAAa,KAAK,iBAAkB,QAAO;AAE9E,KAAI,eAAe,QAAQ,mBAAmB,IAAI,CAAC,eAAe,QAAQ,YAAY,CACpF,QAAO;AAGT,KAAI,eAAe,QAAQ,YAAY,CAAE,QAAO;AAGhD,QAAO;;;;;;;;AAST,SAAgB,mBAAmB,OAAqC;AACtE,OAAM,WAAW;;;;;;AAOnB,SAAgB,yBACd,cACA,aACmB;AACnB,KAAI,CAAC,aAAc,QAAO;AAC1B,KAAI,MAAM,QAAQ,aAAa,CAE7B,QAAO,CAAC,aAAa,GADR,aAAa,QAAO,MAAK,MAAM,YAChB,CAAC;AAE/B,KAAI,iBAAiB,YAAa,QAAO;AACzC,QAAO,CAAC,aAAa,aAAa;;;;;;AAOpC,IAAI;AACJ,IAAI;AAEJ,SAAgB,gCAAyC;CACvD,MAAM,SAAS,qBAAqB;CACpC,MAAM,MAAM,SAAS,KAAK,UAAU,OAAO,GAAG;AAC9C,KAAI,0BAA0B,KAAA,KAAa,oBAAoB,IAC7D,QAAO;AAGT,mBAAkB;AAClB,yBAAwB,CAAC,mBAAmB,UAAU,EAAE,CAAC,CAAC;AAC1D,QAAO;;;;;;AAaT,SAAgB,wBAAwB,OAAoB;CAC1D,MAAM,MAAM;AACZ,KAAI,YAAY;AAChB,KAAI,QAAQ;;;;;;AAOd,SAAgB,yBACd,OACA,KACA,QAAQ,QAAQ,IAAI,aAAa,eACR;CACzB,MAAM,SAAS,mBAAmB,MAAM;CACxC,MAAM,cAAe,MAAkC,cACjD,MAAqC,iBACtC,MAAM,YAAY;CACvB,MAAM,UAAU,QACZ,aACC,UAAU,MAAM,0BAA0B;AAE/C,QAAO;EACL;EACA;EACA,YAAY;EACZ,YAAY;EACZ,eAAe;EACf;EACA,OAAO;EACR;;;;;;AAOH,SAAgB,4BAA4B,OAAc,KAAsC;CAC9F,MAAM,SAAS,mBAAmB,MAAM;CACxC,MAAM,EAAE,SAAS;CACjB,MAAM,gBAAiB,MAAqC,iBAAiB,MAAM;AACnF,QAAO;EACL;EACA;EACA,YAAY;EACZ,YAAY;EACZ;EACA,SAAS,MAAM;EACf,OAAO;EACP,GAAI,SAAS,KAAA,KAAa,EAAE,MAAM;EACnC"}

package/dist/{nodeResponse-CIEEbrNE.mjs → nodeResponse-DKrYWrxk.mjs}

@@ -39,4 +39,4 @@ function bindNodeResponseLifecycle(res, logger, finish) {
 //#endregion
 export { bindNodeResponseLifecycle as t };
 
-//# sourceMappingURL=nodeResponse-CIEEbrNE.mjs.map
+//# sourceMappingURL=nodeResponse-DKrYWrxk.mjs.map

package/dist/{nodeResponse-CIEEbrNE.mjs.map → nodeResponse-DKrYWrxk.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"nodeResponse-CIEEbrNE.mjs","names":[],"sources":["../src/shared/nodeResponse.ts"],"sourcesContent":["import type { ServerResponse } from 'node:http'\nimport type { RequestLogger } from '../types'\nimport type { MiddlewareLoggerResult } from './middleware'\n\n/**\n * Bind an evlog middleware {@link MiddlewareLoggerResult.finish | `finish()`}\n * to a Node {@link ServerResponse} lifecycle.\n *\n * Listens to **both** `finish` (response fully transmitted) and `close`\n * (underlying socket closed — including client disconnects mid-response).\n * Idempotent: only the first event to fire calls `finish()`.\n *\n * When `close` fires before `finish`, the client disconnected before the\n * response could complete. In that case the wide event is marked with\n * `connectionClosed: true` so disconnects are observable in the drain.\n *\n * @remarks\n * For background work that must outlive the HTTP response (e.g. resumable\n * streams, post-response usage accounting), use\n * {@link RequestLogger.fork | `req.log.fork(label, fn)`} instead of mutating\n * the request logger after the response has closed — once `finish()` has run,\n * the request logger is sealed.\n *\n * @internal Used by the Express and NestJS integrations.\n */\nexport function bindNodeResponseLifecycle(\n  res: ServerResponse,\n  logger: RequestLogger,\n  finish: MiddlewareLoggerResult['finish'],\n): void {\n  let settled = false\n\n  const onFinish = (): void => {\n    if (settled) return\n    settled = true\n    finish({ status: res.statusCode }).catch(() => {})\n  }\n\n  const onClose = (): void => {\n    if (settled) return\n    settled = true\n    logger.set({ connectionClosed: true })\n    finish({ status: res.statusCode }).catch(() => {})\n  }\n\n  res.once('finish', onFinish)\n  res.once('close', onClose)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,0BACd,KACA,QACA,QACM;CACN,IAAI,UAAU;CAEd,MAAM,iBAAuB;AAC3B,MAAI,QAAS;AACb,YAAU;AACV,SAAO,EAAE,QAAQ,IAAI,YAAY,CAAC,CAAC,YAAY,GAAG;;CAGpD,MAAM,gBAAsB;AAC1B,MAAI,QAAS;AACb,YAAU;AACV,SAAO,IAAI,EAAE,kBAAkB,MAAM,CAAC;AACtC,SAAO,EAAE,QAAQ,IAAI,YAAY,CAAC,CAAC,YAAY,GAAG;;AAGpD,KAAI,KAAK,UAAU,SAAS;AAC5B,KAAI,KAAK,SAAS,QAAQ"}
+{"version":3,"file":"nodeResponse-DKrYWrxk.mjs","names":[],"sources":["../src/shared/nodeResponse.ts"],"sourcesContent":["import type { ServerResponse } from 'node:http'\nimport type { RequestLogger } from '../types'\nimport type { MiddlewareLoggerResult } from './middleware'\n\n/**\n * Bind an evlog middleware {@link MiddlewareLoggerResult.finish | `finish()`}\n * to a Node {@link ServerResponse} lifecycle.\n *\n * Listens to **both** `finish` (response fully transmitted) and `close`\n * (underlying socket closed — including client disconnects mid-response).\n * Idempotent: only the first event to fire calls `finish()`.\n *\n * When `close` fires before `finish`, the client disconnected before the\n * response could complete. In that case the wide event is marked with\n * `connectionClosed: true` so disconnects are observable in the drain.\n *\n * @remarks\n * For background work that must outlive the HTTP response (e.g. resumable\n * streams, post-response usage accounting), use\n * {@link RequestLogger.fork | `req.log.fork(label, fn)`} instead of mutating\n * the request logger after the response has closed — once `finish()` has run,\n * the request logger is sealed.\n *\n * @internal Used by the Express and NestJS integrations.\n */\nexport function bindNodeResponseLifecycle(\n  res: ServerResponse,\n  logger: RequestLogger,\n  finish: MiddlewareLoggerResult['finish'],\n): void {\n  let settled = false\n\n  const onFinish = (): void => {\n    if (settled) return\n    settled = true\n    finish({ status: res.statusCode }).catch(() => {})\n  }\n\n  const onClose = (): void => {\n    if (settled) return\n    settled = true\n    logger.set({ connectionClosed: true })\n    finish({ status: res.statusCode }).catch(() => {})\n  }\n\n  res.once('finish', onFinish)\n  res.once('close', onClose)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,0BACd,KACA,QACA,QACM;CACN,IAAI,UAAU;CAEd,MAAM,iBAAuB;AAC3B,MAAI,QAAS;AACb,YAAU;AACV,SAAO,EAAE,QAAQ,IAAI,YAAY,CAAC,CAAC,YAAY,GAAG;;CAGpD,MAAM,gBAAsB;AAC1B,MAAI,QAAS;AACb,YAAU;AACV,SAAO,IAAI,EAAE,kBAAkB,MAAM,CAAC;AACtC,SAAO,EAAE,QAAQ,IAAI,YAAY,CAAC,CAAC,YAAY,GAAG;;AAGpD,KAAI,KAAK,UAAU,SAAS;AAC5B,KAAI,KAAK,SAAS,QAAQ"}

package/dist/nuxt/module.d.mts

@@ -1,4 +1,4 @@
-import { $ as RedactConfig, H as EnvironmentContext, X as LogLevel, at as RouteConfig, dt as TransportConfig, ot as SamplingConfig, pt as DevTerminalInput } from "../audit-D7v6JHj0.mjs";
+import { $ as LogLevel, G as EnvironmentContext, ct as RouteConfig, gt as DevTerminalInput, lt as SamplingConfig, mt as TransportConfig, nt as RedactConfig } from "../audit-CBfv3rl1.mjs";
 import { StreamServerOptions } from "../stream.mjs";
 import * as _$_nuxt_schema0 from "@nuxt/schema";
 

package/dist/nuxt/module.mjs

@@ -1,6 +1,6 @@
-import { r as prependNitroErrorHandler } from "../nitro-ClRZLD1g.mjs";
+import { r as prependNitroErrorHandler } from "../nitro-ClHmVj1H.mjs";
 import { n as createStripPlugin, t as createSourceLocationPlugin } from "../source-location-CHOPF2nd.mjs";
-import { n as version, t as name } from "../package-CNV_CXs8.mjs";
+import { n as version, t as name } from "../package-Bgs0VSDF.mjs";
 import { addImports, addPlugin, addServerHandler, addServerImports, addServerPlugin, addVitePlugin, createResolver, defineNuxtModule } from "@nuxt/kit";
 //#region src/nuxt/module.ts
 var module_default = defineNuxtModule({

package/dist/orpc/index.d.mts

@@ -1,9 +1,9 @@
-import { rt as RequestLogger } from "../audit-D7v6JHj0.mjs";
-import { t as BaseEvlogOptions } from "../middleware-B_k4Mrzg.mjs";
+import { l as AuditableLogger } from "../audit-CBfv3rl1.mjs";
+import { t as BaseEvlogOptions } from "../middleware-CjVyGyrG.mjs";
 import { Context, MiddlewareOptions, MiddlewareResult } from "@orpc/server";
 
 //#region src/orpc/index.d.ts
-declare const useLogger: <T extends object = Record<string, unknown>>() => RequestLogger<T>;
+declare const useLogger: <T extends object = Record<string, unknown>>() => AuditableLogger<T>;
 /** Options accepted by {@link withEvlog} for oRPC request instrumentation. */
 type EvlogOrpcOptions = BaseEvlogOptions;
 /**
@@ -19,7 +19,7 @@ type EvlogOrpcOptions = BaseEvlogOptions;
  * ```
  */
 interface EvlogOrpcContext {
-  log: RequestLogger;
+  log: AuditableLogger;
 }
 /**
  * Result shape of `handler.handle()` for oRPC's fetch adapter

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/orpc/index.ts"],"mappings":";;;;;cAQiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;;KAKd,gBAAA,GAAmB,gBAAA;;;;;;;;;AAA/B;;;;UAoBiB,gBAAA;EACf,GAAA,EAAK,aAAA;AAAA;;;;AACN;KAMI,qBAAA;EACC,OAAA;EAAe,QAAA,EAAU,QAAA;AAAA;EACzB,OAAA;EAAgB,QAAA;AAAA;;;;AAAQ;;;;;;UAWpB,oBAAA;EACR,MAAA,GACE,OAAA,EAAS,OAAA,EACT,OAAA,WACG,OAAA,CAAQ,qBAAA;AAAA;;;;;;;;AAkDf;;;;;;;;;;;;;;;;;;AA6EA;;;;;iBA7EgB,SAAA,kBAA2B,oBAAA,CAAA,CACzC,OAAA,EAAS,QAAA,EACT,OAAA,GAAS,gBAAA,GACR,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0Ea,KAAA,kBAAuB,OAAA,CAAQ,gBAAA,IAAoB,OAAA,GAAU,gBAAA,CAAA,CAAA,IAEzE,OAAA,EAAS,iBAAA,CAAkB,QAAA,yBAC1B,OAAA,CAAQ,gBAAA,CAAiB,MAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/orpc/index.ts"],"mappings":";;;;;cAQiB,SAAA,sBAAS,MAAA,wBAAA,eAAA,CAAA,CAAA;;KAKd,gBAAA,GAAmB,gBAAA;;;;;;;;;AAA/B;;;;UAoBiB,gBAAA;EACf,GAAA,EAAK,eAAA;AAAA;;;;AACN;KAMI,qBAAA;EACC,OAAA;EAAe,QAAA,EAAU,QAAA;AAAA;EACzB,OAAA;EAAgB,QAAA;AAAA;;;;AAAQ;;;;;;UAWpB,oBAAA;EACR,MAAA,GACE,OAAA,EAAS,OAAA,EACT,OAAA,WACG,OAAA,CAAQ,qBAAA;AAAA;;;;;;;;AAkDf;;;;;;;;;;;;;;;;;;AA6EA;;;;;iBA7EgB,SAAA,kBAA2B,oBAAA,CAAA,CACzC,OAAA,EAAS,QAAA,EACT,OAAA,GAAS,gBAAA,GACR,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0Ea,KAAA,kBAAuB,OAAA,CAAQ,gBAAA,IAAoB,OAAA,GAAU,gBAAA,CAAA,CAAA,IAEzE,OAAA,EAAS,iBAAA,CAAkB,QAAA,yBAC1B,OAAA,CAAQ,gBAAA,CAAiB,MAAA"}

package/dist/orpc/index.mjs

@@ -1,7 +1,7 @@
 import { EvlogError } from "../error.mjs";
 import { parseError } from "../runtime/utils/parseError.mjs";
-import { t as defineFrameworkIntegration } from "../integration-DYp2uw8O.mjs";
-import { t as createLoggerStorage } from "../storage-7X37OToT.mjs";
+import { t as defineFrameworkIntegration } from "../integration-2PpI-bCm.mjs";
+import { t as createLoggerStorage } from "../storage-D4sBVffQ.mjs";
 import { ORPCError } from "@orpc/server";
 //#region src/orpc/index.ts
 const { storage, useLogger } = createLoggerStorage("oRPC handler. Wrap your handler with `withEvlog()` from evlog/orpc.");

package/dist/orpc/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/orpc/index.ts"],"sourcesContent":["import { ORPCError, type Context, type MiddlewareOptions, type MiddlewareResult } from '@orpc/server'\nimport type { RequestLogger } from '../types'\nimport { EvlogError } from '../error'\nimport { parseError } from '../runtime/utils/parseError'\nimport { defineFrameworkIntegration } from '../shared/integration'\nimport type { BaseEvlogOptions } from '../shared/middleware'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'oRPC handler. Wrap your handler with `withEvlog()` from evlog/orpc.',\n)\n\n/** Options accepted by {@link withEvlog} for oRPC request instrumentation. */\nexport type EvlogOrpcOptions = BaseEvlogOptions\n\n/**\n * Access the current request-scoped logger outside oRPC context callbacks.\n * Requires {@link withEvlog} on the handler.\n */\nexport { useLogger }\n\n/**\n * Inject this type into your oRPC initial context to access `context.log`\n * inside procedures.\n *\n * @example\n * ```ts\n * import { os } from '@orpc/server'\n * import { evlog, type EvlogOrpcContext } from 'evlog/orpc'\n *\n * const base = os.$context<EvlogOrpcContext>().use(evlog())\n * ```\n */\nexport interface EvlogOrpcContext {\n  log: RequestLogger\n}\n\n/**\n * Result shape of `handler.handle()` for oRPC's fetch adapter\n * ({@link https://orpc.dev/docs/adapters/http RPCHandler / OpenAPIHandler}).\n */\ntype OrpcFetchHandleResult =\n  | { matched: true, response: Response }\n  | { matched: false, response: undefined }\n\n/**\n * Minimal subset of oRPC's `FetchHandler` that we need to wrap. Anything\n * compatible (RPCHandler, OpenAPIHandler, custom handler) plugs in.\n *\n * `options` is intentionally typed loosely so this matches both the\n * `(req, opts)` and `(req, opts?)` overloads that oRPC produces depending on\n * whether the router declares a non-empty initial context. The wrapper just\n * splats the original options through and injects `log` into `context`.\n */\ninterface OrpcFetchHandlerLike {\n  handle: (\n    request: Request,\n    options?: any,\n  ) => Promise<OrpcFetchHandleResult>\n}\n\nconst integration = defineFrameworkIntegration<{ request: Request }>({\n  name: 'orpc',\n  extractRequest: ({ request }) => {\n    const url = new URL(request.url)\n    return {\n      method: request.method,\n      path: url.pathname,\n      headers: request.headers,\n      requestId: request.headers.get('x-request-id') ?? undefined,\n    }\n  },\n  attachLogger: () => {\n    /* logger is injected into the oRPC context inside withEvlog() */\n  },\n  storage,\n})\n\n/**\n * Wrap an oRPC handler so each matched request emits a single wide event.\n * Works with any handler that exposes `.handle(request, options)` from\n * `@orpc/server/fetch` (RPCHandler, OpenAPIHandler, custom handlers).\n *\n * The returned proxy preserves the original handler's identity (instance\n * methods, plugins, etc.) and only intercepts `handle`. Inside procedures,\n * the request logger is exposed as `context.log` — pair this with\n * `os.use(evlog())` to also accumulate `operation` (`path.join('.')`) on the\n * wide event.\n *\n * Routes that are filtered out by `include`/`exclude` are passed straight to\n * the underlying handler with no instrumentation.\n *\n * @example\n * ```ts\n * import { RPCHandler } from '@orpc/server/fetch'\n * import { withEvlog } from 'evlog/orpc'\n * import { router } from './router'\n *\n * const handler = withEvlog(new RPCHandler(router), {\n *   include: ['/rpc/**'],\n * })\n *\n * export default async function fetch(request: Request) {\n *   const { matched, response } = await handler.handle(request, { prefix: '/rpc' })\n *   return matched ? response : new Response('Not Found', { status: 404 })\n * }\n * ```\n */\nexport function withEvlog<THandler extends OrpcFetchHandlerLike>(\n  handler: THandler,\n  options: EvlogOrpcOptions = {},\n): THandler {\n  const handle: THandler['handle'] = async (request, callOptions) => {\n    const { skipped, finish, finishResponse, runWith, logger } = integration.start({ request }, options)\n\n    const initialContext = (callOptions as { context?: Record<string, unknown> } | undefined)?.context ?? {}\n    const finalOptions = {\n      ...callOptions,\n      context: { ...initialContext, log: logger },\n    } as Parameters<THandler['handle']>[1]\n\n    if (skipped) {\n      return handler.handle(request, finalOptions)\n    }\n\n    try {\n      const result = await runWith(() => handler.handle(request, finalOptions))\n      if (result.matched) {\n        result.response = await finishResponse(result.response, { status: result.response.status })\n      } else {\n        await finish({ status: 404 })\n      }\n      return result\n    } catch (error) {\n      await finish({ error: error as Error })\n      throw error\n    }\n  }\n\n  return new Proxy(handler, {\n    get(target, prop, receiver) {\n      if (prop === 'handle') return handle\n      return Reflect.get(target, prop, receiver)\n    },\n  })\n}\n\nfunction isEvlogError(error: unknown): error is EvlogError {\n  return error instanceof EvlogError || (error instanceof Error && error.name === 'EvlogError')\n}\n\n/**\n * Procedure-level middleware. Three responsibilities:\n *\n * 1. Adds `operation` (the procedure path joined by `.`) to the wide event,\n *    so consumers can group events by procedure without parsing URLs.\n * 2. Captures errors thrown by the procedure on the wide event so the level\n *    is promoted to `error`.\n * 3. Converts {@link EvlogError} (from `createError()` / `defineErrorCatalog`)\n *    into a structurally-equivalent {@link ORPCError} before re-throwing, so\n *    the wire response carries the catalog `code`, status, message, and the\n *    `why` / `fix` / `link` guidance under `data` — instead of being wrapped\n *    as `INTERNAL_SERVER_ERROR` by oRPC's default handler. The catalog and\n *    `createError()` stay the canonical evlog way to author errors;\n *    `evlog/orpc` is the bridge.\n *\n * Requires `withEvlog()` to be wrapped around the handler — the request\n * logger flows in via `context.log`. Declare {@link EvlogOrpcContext} on\n * your oRPC base for typed access.\n *\n * @example\n * ```ts\n * import { os } from '@orpc/server'\n * import { evlog, type EvlogOrpcContext } from 'evlog/orpc'\n *\n * const base = os.$context<EvlogOrpcContext>().use(evlog())\n *\n * export const getUser = base\n *   .input(z.object({ id: z.string() }))\n *   .handler(async ({ input, context }) => {\n *     context.log.set({ user: { id: input.id } })\n *     return await db.user.findUnique(input)\n *   })\n * ```\n */\nexport function evlog<TContext extends Partial<EvlogOrpcContext> & Context = EvlogOrpcContext>() {\n  return async function evlogMiddleware(\n    options: MiddlewareOptions<TContext, unknown, any, any>,\n  ): Promise<MiddlewareResult<Record<never, never>, unknown>> {\n    const { context: { log }, path, next } = options\n    if (log && path.length > 0) {\n      log.set({ operation: path.join('.') })\n    }\n    try {\n      return await next()\n    } catch (error) {\n      if (log) log.error(error as Error)\n      if (isEvlogError(error)) {\n        throw toOrpcError(error)\n      }\n      throw error\n    }\n  }\n}\n\nfunction toOrpcError(error: EvlogError): ORPCError<string, Record<string, unknown>> {\n  const parsed = parseError(error)\n  const data: Record<string, unknown> = {}\n  if (parsed.why !== undefined) data.why = parsed.why\n  if (parsed.fix !== undefined) data.fix = parsed.fix\n  if (parsed.link !== undefined) data.link = parsed.link\n  return new ORPCError(parsed.code ?? 'EVLOG_ERROR', {\n    status: parsed.status,\n    message: parsed.message,\n    data,\n    cause: error,\n  })\n}\n"],"mappings":";;;;;;AAQA,MAAM,EAAE,SAAS,cAAc,oBAC7B,sEACD;AAmDD,MAAM,cAAc,2BAAiD;CACnE,MAAM;CACN,iBAAiB,EAAE,cAAc;EAC/B,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;AAChC,SAAO;GACL,QAAQ,QAAQ;GAChB,MAAM,IAAI;GACV,SAAS,QAAQ;GACjB,WAAW,QAAQ,QAAQ,IAAI,eAAe,IAAI,KAAA;GACnD;;CAEH,oBAAoB;CAGpB;CACD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCF,SAAgB,UACd,SACA,UAA4B,EAAE,EACpB;CACV,MAAM,SAA6B,OAAO,SAAS,gBAAgB;EACjE,MAAM,EAAE,SAAS,QAAQ,gBAAgB,SAAS,WAAW,YAAY,MAAM,EAAE,SAAS,EAAE,QAAQ;EAEpG,MAAM,iBAAkB,aAAmE,WAAW,EAAE;EACxG,MAAM,eAAe;GACnB,GAAG;GACH,SAAS;IAAE,GAAG;IAAgB,KAAK;IAAQ;GAC5C;AAED,MAAI,QACF,QAAO,QAAQ,OAAO,SAAS,aAAa;AAG9C,MAAI;GACF,MAAM,SAAS,MAAM,cAAc,QAAQ,OAAO,SAAS,aAAa,CAAC;AACzE,OAAI,OAAO,QACT,QAAO,WAAW,MAAM,eAAe,OAAO,UAAU,EAAE,QAAQ,OAAO,SAAS,QAAQ,CAAC;OAE3F,OAAM,OAAO,EAAE,QAAQ,KAAK,CAAC;AAE/B,UAAO;WACA,OAAO;AACd,SAAM,OAAO,EAAS,OAAgB,CAAC;AACvC,SAAM;;;AAIV,QAAO,IAAI,MAAM,SAAS,EACxB,IAAI,QAAQ,MAAM,UAAU;AAC1B,MAAI,SAAS,SAAU,QAAO;AAC9B,SAAO,QAAQ,IAAI,QAAQ,MAAM,SAAS;IAE7C,CAAC;;AAGJ,SAAS,aAAa,OAAqC;AACzD,QAAO,iBAAiB,cAAe,iBAAiB,SAAS,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqClF,SAAgB,QAAiF;AAC/F,QAAO,eAAe,gBACpB,SAC0D;EAC1D,MAAM,EAAE,SAAS,EAAE,OAAO,MAAM,SAAS;AACzC,MAAI,OAAO,KAAK,SAAS,EACvB,KAAI,IAAI,EAAE,WAAW,KAAK,KAAK,IAAI,EAAE,CAAC;AAExC,MAAI;AACF,UAAO,MAAM,MAAM;WACZ,OAAO;AACd,OAAI,IAAK,KAAI,MAAM,MAAe;AAClC,OAAI,aAAa,MAAM,CACrB,OAAM,YAAY,MAAM;AAE1B,SAAM;;;;AAKZ,SAAS,YAAY,OAA+D;CAClF,MAAM,SAAS,WAAW,MAAM;CAChC,MAAM,OAAgC,EAAE;AACxC,KAAI,OAAO,QAAQ,KAAA,EAAW,MAAK,MAAM,OAAO;AAChD,KAAI,OAAO,QAAQ,KAAA,EAAW,MAAK,MAAM,OAAO;AAChD,KAAI,OAAO,SAAS,KAAA,EAAW,MAAK,OAAO,OAAO;AAClD,QAAO,IAAI,UAAU,OAAO,QAAQ,eAAe;EACjD,QAAQ,OAAO;EACf,SAAS,OAAO;EAChB;EACA,OAAO;EACR,CAAC"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/orpc/index.ts"],"sourcesContent":["import { ORPCError, type Context, type MiddlewareOptions, type MiddlewareResult } from '@orpc/server'\nimport type { AuditableLogger } from '../audit'\nimport { EvlogError } from '../error'\nimport { parseError } from '../runtime/utils/parseError'\nimport { defineFrameworkIntegration } from '../shared/integration'\nimport type { BaseEvlogOptions } from '../shared/middleware'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'oRPC handler. Wrap your handler with `withEvlog()` from evlog/orpc.',\n)\n\n/** Options accepted by {@link withEvlog} for oRPC request instrumentation. */\nexport type EvlogOrpcOptions = BaseEvlogOptions\n\n/**\n * Access the current request-scoped logger outside oRPC context callbacks.\n * Requires {@link withEvlog} on the handler.\n */\nexport { useLogger }\n\n/**\n * Inject this type into your oRPC initial context to access `context.log`\n * inside procedures.\n *\n * @example\n * ```ts\n * import { os } from '@orpc/server'\n * import { evlog, type EvlogOrpcContext } from 'evlog/orpc'\n *\n * const base = os.$context<EvlogOrpcContext>().use(evlog())\n * ```\n */\nexport interface EvlogOrpcContext {\n  log: AuditableLogger\n}\n\n/**\n * Result shape of `handler.handle()` for oRPC's fetch adapter\n * ({@link https://orpc.dev/docs/adapters/http RPCHandler / OpenAPIHandler}).\n */\ntype OrpcFetchHandleResult =\n  | { matched: true, response: Response }\n  | { matched: false, response: undefined }\n\n/**\n * Minimal subset of oRPC's `FetchHandler` that we need to wrap. Anything\n * compatible (RPCHandler, OpenAPIHandler, custom handler) plugs in.\n *\n * `options` is intentionally typed loosely so this matches both the\n * `(req, opts)` and `(req, opts?)` overloads that oRPC produces depending on\n * whether the router declares a non-empty initial context. The wrapper just\n * splats the original options through and injects `log` into `context`.\n */\ninterface OrpcFetchHandlerLike {\n  handle: (\n    request: Request,\n    options?: any,\n  ) => Promise<OrpcFetchHandleResult>\n}\n\nconst integration = defineFrameworkIntegration<{ request: Request }>({\n  name: 'orpc',\n  extractRequest: ({ request }) => {\n    const url = new URL(request.url)\n    return {\n      method: request.method,\n      path: url.pathname,\n      headers: request.headers,\n      requestId: request.headers.get('x-request-id') ?? undefined,\n    }\n  },\n  attachLogger: () => {\n    /* logger is injected into the oRPC context inside withEvlog() */\n  },\n  storage,\n})\n\n/**\n * Wrap an oRPC handler so each matched request emits a single wide event.\n * Works with any handler that exposes `.handle(request, options)` from\n * `@orpc/server/fetch` (RPCHandler, OpenAPIHandler, custom handlers).\n *\n * The returned proxy preserves the original handler's identity (instance\n * methods, plugins, etc.) and only intercepts `handle`. Inside procedures,\n * the request logger is exposed as `context.log` — pair this with\n * `os.use(evlog())` to also accumulate `operation` (`path.join('.')`) on the\n * wide event.\n *\n * Routes that are filtered out by `include`/`exclude` are passed straight to\n * the underlying handler with no instrumentation.\n *\n * @example\n * ```ts\n * import { RPCHandler } from '@orpc/server/fetch'\n * import { withEvlog } from 'evlog/orpc'\n * import { router } from './router'\n *\n * const handler = withEvlog(new RPCHandler(router), {\n *   include: ['/rpc/**'],\n * })\n *\n * export default async function fetch(request: Request) {\n *   const { matched, response } = await handler.handle(request, { prefix: '/rpc' })\n *   return matched ? response : new Response('Not Found', { status: 404 })\n * }\n * ```\n */\nexport function withEvlog<THandler extends OrpcFetchHandlerLike>(\n  handler: THandler,\n  options: EvlogOrpcOptions = {},\n): THandler {\n  const handle: THandler['handle'] = async (request, callOptions) => {\n    const { skipped, finish, finishResponse, runWith, logger } = integration.start({ request }, options)\n\n    const initialContext = (callOptions as { context?: Record<string, unknown> } | undefined)?.context ?? {}\n    const finalOptions = {\n      ...callOptions,\n      context: { ...initialContext, log: logger },\n    } as Parameters<THandler['handle']>[1]\n\n    if (skipped) {\n      return handler.handle(request, finalOptions)\n    }\n\n    try {\n      const result = await runWith(() => handler.handle(request, finalOptions))\n      if (result.matched) {\n        result.response = await finishResponse(result.response, { status: result.response.status })\n      } else {\n        await finish({ status: 404 })\n      }\n      return result\n    } catch (error) {\n      await finish({ error: error as Error })\n      throw error\n    }\n  }\n\n  return new Proxy(handler, {\n    get(target, prop, receiver) {\n      if (prop === 'handle') return handle\n      return Reflect.get(target, prop, receiver)\n    },\n  })\n}\n\nfunction isEvlogError(error: unknown): error is EvlogError {\n  return error instanceof EvlogError || (error instanceof Error && error.name === 'EvlogError')\n}\n\n/**\n * Procedure-level middleware. Three responsibilities:\n *\n * 1. Adds `operation` (the procedure path joined by `.`) to the wide event,\n *    so consumers can group events by procedure without parsing URLs.\n * 2. Captures errors thrown by the procedure on the wide event so the level\n *    is promoted to `error`.\n * 3. Converts {@link EvlogError} (from `createError()` / `defineErrorCatalog`)\n *    into a structurally-equivalent {@link ORPCError} before re-throwing, so\n *    the wire response carries the catalog `code`, status, message, and the\n *    `why` / `fix` / `link` guidance under `data` — instead of being wrapped\n *    as `INTERNAL_SERVER_ERROR` by oRPC's default handler. The catalog and\n *    `createError()` stay the canonical evlog way to author errors;\n *    `evlog/orpc` is the bridge.\n *\n * Requires `withEvlog()` to be wrapped around the handler — the request\n * logger flows in via `context.log`. Declare {@link EvlogOrpcContext} on\n * your oRPC base for typed access.\n *\n * @example\n * ```ts\n * import { os } from '@orpc/server'\n * import { evlog, type EvlogOrpcContext } from 'evlog/orpc'\n *\n * const base = os.$context<EvlogOrpcContext>().use(evlog())\n *\n * export const getUser = base\n *   .input(z.object({ id: z.string() }))\n *   .handler(async ({ input, context }) => {\n *     context.log.set({ user: { id: input.id } })\n *     return await db.user.findUnique(input)\n *   })\n * ```\n */\nexport function evlog<TContext extends Partial<EvlogOrpcContext> & Context = EvlogOrpcContext>() {\n  return async function evlogMiddleware(\n    options: MiddlewareOptions<TContext, unknown, any, any>,\n  ): Promise<MiddlewareResult<Record<never, never>, unknown>> {\n    const { context: { log }, path, next } = options\n    if (log && path.length > 0) {\n      log.set({ operation: path.join('.') })\n    }\n    try {\n      return await next()\n    } catch (error) {\n      if (log) log.error(error as Error)\n      if (isEvlogError(error)) {\n        throw toOrpcError(error)\n      }\n      throw error\n    }\n  }\n}\n\nfunction toOrpcError(error: EvlogError): ORPCError<string, Record<string, unknown>> {\n  const parsed = parseError(error)\n  const data: Record<string, unknown> = {}\n  if (parsed.why !== undefined) data.why = parsed.why\n  if (parsed.fix !== undefined) data.fix = parsed.fix\n  if (parsed.link !== undefined) data.link = parsed.link\n  return new ORPCError(parsed.code ?? 'EVLOG_ERROR', {\n    status: parsed.status,\n    message: parsed.message,\n    data,\n    cause: error,\n  })\n}\n"],"mappings":";;;;;;AAQA,MAAM,EAAE,SAAS,cAAc,oBAC7B,sEACD;AAmDD,MAAM,cAAc,2BAAiD;CACnE,MAAM;CACN,iBAAiB,EAAE,cAAc;EAC/B,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;AAChC,SAAO;GACL,QAAQ,QAAQ;GAChB,MAAM,IAAI;GACV,SAAS,QAAQ;GACjB,WAAW,QAAQ,QAAQ,IAAI,eAAe,IAAI,KAAA;GACnD;;CAEH,oBAAoB;CAGpB;CACD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCF,SAAgB,UACd,SACA,UAA4B,EAAE,EACpB;CACV,MAAM,SAA6B,OAAO,SAAS,gBAAgB;EACjE,MAAM,EAAE,SAAS,QAAQ,gBAAgB,SAAS,WAAW,YAAY,MAAM,EAAE,SAAS,EAAE,QAAQ;EAEpG,MAAM,iBAAkB,aAAmE,WAAW,EAAE;EACxG,MAAM,eAAe;GACnB,GAAG;GACH,SAAS;IAAE,GAAG;IAAgB,KAAK;IAAQ;GAC5C;AAED,MAAI,QACF,QAAO,QAAQ,OAAO,SAAS,aAAa;AAG9C,MAAI;GACF,MAAM,SAAS,MAAM,cAAc,QAAQ,OAAO,SAAS,aAAa,CAAC;AACzE,OAAI,OAAO,QACT,QAAO,WAAW,MAAM,eAAe,OAAO,UAAU,EAAE,QAAQ,OAAO,SAAS,QAAQ,CAAC;OAE3F,OAAM,OAAO,EAAE,QAAQ,KAAK,CAAC;AAE/B,UAAO;WACA,OAAO;AACd,SAAM,OAAO,EAAS,OAAgB,CAAC;AACvC,SAAM;;;AAIV,QAAO,IAAI,MAAM,SAAS,EACxB,IAAI,QAAQ,MAAM,UAAU;AAC1B,MAAI,SAAS,SAAU,QAAO;AAC9B,SAAO,QAAQ,IAAI,QAAQ,MAAM,SAAS;IAE7C,CAAC;;AAGJ,SAAS,aAAa,OAAqC;AACzD,QAAO,iBAAiB,cAAe,iBAAiB,SAAS,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqClF,SAAgB,QAAiF;AAC/F,QAAO,eAAe,gBACpB,SAC0D;EAC1D,MAAM,EAAE,SAAS,EAAE,OAAO,MAAM,SAAS;AACzC,MAAI,OAAO,KAAK,SAAS,EACvB,KAAI,IAAI,EAAE,WAAW,KAAK,KAAK,IAAI,EAAE,CAAC;AAExC,MAAI;AACF,UAAO,MAAM,MAAM;WACZ,OAAO;AACd,OAAI,IAAK,KAAI,MAAM,MAAe;AAClC,OAAI,aAAa,MAAM,CACrB,OAAM,YAAY,MAAM;AAE1B,SAAM;;;;AAKZ,SAAS,YAAY,OAA+D;CAClF,MAAM,SAAS,WAAW,MAAM;CAChC,MAAM,OAAgC,EAAE;AACxC,KAAI,OAAO,QAAQ,KAAA,EAAW,MAAK,MAAM,OAAO;AAChD,KAAI,OAAO,QAAQ,KAAA,EAAW,MAAK,MAAM,OAAO;AAChD,KAAI,OAAO,SAAS,KAAA,EAAW,MAAK,OAAO,OAAO;AAClD,QAAO,IAAI,UAAU,OAAO,QAAQ,eAAe;EACjD,QAAQ,OAAO;EACf,SAAS,OAAO;EAChB;EACA,OAAO;EACR,CAAC"}

package/dist/{package-CNV_CXs8.mjs → package-Bgs0VSDF.mjs}

@@ -1,7 +1,7 @@
 //#region package.json
 var name = "evlog";
-var version = "2.19.1";
+var version = "2.19.2";
 //#endregion
 export { version as n, name as t };
 
-//# sourceMappingURL=package-CNV_CXs8.mjs.map
+//# sourceMappingURL=package-Bgs0VSDF.mjs.map

package/dist/package-Bgs0VSDF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-Bgs0VSDF.mjs","names":[],"sources":["../package.json"],"sourcesContent":[""],"mappings":""}

package/dist/{parseError-BeBXEd2V.d.mts → parseError-BwBg-iW4.d.mts}

@@ -1,7 +1,7 @@
-import { Q as ParsedError } from "./audit-D7v6JHj0.mjs";
+import { tt as ParsedError } from "./audit-CBfv3rl1.mjs";
 
 //#region src/runtime/utils/parseError.d.ts
 declare function parseError(error: unknown): ParsedError;
 //#endregion
 export { parseError as t };
-//# sourceMappingURL=parseError-BeBXEd2V.d.mts.map
+//# sourceMappingURL=parseError-BwBg-iW4.d.mts.map

package/dist/parseError-BwBg-iW4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseError-BwBg-iW4.d.mts","names":[],"sources":["../src/runtime/utils/parseError.ts"],"mappings":";;;iBAcgB,UAAA,CAAW,KAAA,YAAiB,WAAA"}

package/dist/react-router/index.d.mts

@@ -1,9 +1,9 @@
-import { rt as RequestLogger } from "../audit-D7v6JHj0.mjs";
-import { t as BaseEvlogOptions } from "../middleware-B_k4Mrzg.mjs";
+import { l as AuditableLogger } from "../audit-CBfv3rl1.mjs";
+import { t as BaseEvlogOptions } from "../middleware-CjVyGyrG.mjs";
 import * as _$react_router0 from "react-router";
 
 //#region src/react-router/index.d.ts
-declare const useLogger: <T extends object = Record<string, unknown>>() => RequestLogger<T>;
+declare const useLogger: <T extends object = Record<string, unknown>>() => AuditableLogger<T>;
 /**
  * Typed context key for accessing the evlog logger in loaders and actions.
  *
@@ -18,7 +18,7 @@ declare const useLogger: <T extends object = Record<string, unknown>>() => Reque
  * }
  * ```
  */
-declare const loggerContext: _$react_router0.RouterContext<RequestLogger<Record<string, unknown>>>;
+declare const loggerContext: _$react_router0.RouterContext<AuditableLogger>;
 type EvlogReactRouterOptions = BaseEvlogOptions;
 /**
  * Create an evlog middleware for React Router.

package/dist/react-router/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/react-router/index.ts"],"mappings":";;;;;cAOiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;;;AAL0D;;;;;;;;;;;;cAuBvE,aAAA,EAAa,eAAA,CAAA,aAAA,CAAA,aAAA,CAAA,MAAA;AAAA,KAEd,uBAAA,GAA0B,gBAAA;;;;;;;;;;;;;AAAtC;iBAiBgB,KAAA,CAAM,OAAA,GAAS,uBAAA;EAE3B,OAAA;EAAA;AAAA;EAAwB,OAAA,EAAS,OAAA;EAAS,OAAA;IAAW,GAAA,CAAI,GAAA,WAAc,KAAA;EAAA;AAAA,GACvE,IAAA,QAAY,OAAA,CAAQ,QAAA,MACnB,OAAA,CAAQ,QAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/react-router/index.ts"],"mappings":";;;;;cAOiB,SAAA,sBAAS,MAAA,wBAAA,eAAA,CAAA,CAAA;;;AAL0D;;;;;;;;;;;;cAuBvE,aAAA,EAAa,eAAA,CAAA,aAAA,CAAA,eAAA;AAAA,KAEd,uBAAA,GAA0B,gBAAA;;;;;AAAtC;;;;;AAiBA;;;;iBAAgB,KAAA,CAAM,OAAA,GAAS,uBAAA;EAE3B,OAAA;EAAA;AAAA;EAAwB,OAAA,EAAS,OAAA;EAAS,OAAA;IAAW,GAAA,CAAI,GAAA,WAAc,KAAA;EAAA;AAAA,GACvE,IAAA,QAAY,OAAA,CAAQ,QAAA,MACnB,OAAA,CAAQ,QAAA"}

package/dist/react-router/index.mjs

@@ -1,6 +1,6 @@
 import { t as extractSafeHeaders } from "../headers-VtmnWcfn.mjs";
-import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-CgGlAaHa.mjs";
-import { t as createLoggerStorage } from "../storage-7X37OToT.mjs";
+import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-Di44utlp.mjs";
+import { t as createLoggerStorage } from "../storage-D4sBVffQ.mjs";
 import { createContext } from "react-router";
 //#region src/react-router/index.ts
 const { storage, useLogger } = createLoggerStorage("middleware context. Make sure the evlog middleware is added to your route.");

package/dist/react-router/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/react-router/index.ts"],"sourcesContent":["import { createContext } from 'react-router'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'middleware context. Make sure the evlog middleware is added to your route.',\n)\n\n/**\n * Typed context key for accessing the evlog logger in loaders and actions.\n *\n * @example\n * ```ts\n * import { loggerContext } from 'evlog/react-router'\n *\n * export async function loader({ context }: Route.LoaderArgs) {\n *   const log = context.get(loggerContext)\n *   log.set({ user: { id: 'u-1' } })\n *   return { ok: true }\n * }\n * ```\n */\nexport const loggerContext = createContext<RequestLogger>()\n\nexport type EvlogReactRouterOptions = BaseEvlogOptions\n\nexport { useLogger }\n\n/**\n * Create an evlog middleware for React Router.\n *\n * @example\n * ```ts\n * // app/root.tsx\n * import { evlog } from 'evlog/react-router'\n *\n * export const middleware: Route.MiddlewareFunction[] = [\n *   evlog({ drain: createAxiomDrain() }),\n * ]\n * ```\n */\nexport function evlog(options: EvlogReactRouterOptions = {}) {\n  return async (\n    { request, context }: { request: Request; context: { set(ctx: unknown, value: unknown): void } },\n    next: () => Promise<Response>,\n  ): Promise<Response> => {\n    const url = new URL(request.url)\n    const middlewareOpts = {\n      method: request.method,\n      path: url.pathname,\n      requestId: request.headers.get('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeHeaders(request.headers),\n      ...options,\n    }\n    const { logger, finish, finishResponse, skipped } = createMiddlewareLogger(middlewareOpts)\n\n    if (skipped) {\n      return next()\n    }\n\n    attachForkToLogger(storage, logger, middlewareOpts)\n    context.set(loggerContext, logger)\n\n    try {\n      const response = await storage.run(logger, () => next())\n      return finishResponse(response, { status: response.status })\n    } catch (error) {\n      await finish({ error: error as Error })\n      throw error\n    }\n  }\n}\n"],"mappings":";;;;;AAOA,MAAM,EAAE,SAAS,cAAc,oBAC7B,6EACD;;;;;;;;;;;;;;;AAgBD,MAAa,gBAAgB,eAA8B;;;;;;;;;;;;;;AAmB3D,SAAgB,MAAM,UAAmC,EAAE,EAAE;AAC3D,QAAO,OACL,EAAE,SAAS,WACX,SACsB;EACtB,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;EAChC,MAAM,iBAAiB;GACrB,QAAQ,QAAQ;GAChB,MAAM,IAAI;GACV,WAAW,QAAQ,QAAQ,IAAI,eAAe,IAAI,OAAO,YAAY;GACrE,SAAS,mBAAmB,QAAQ,QAAQ;GAC5C,GAAG;GACJ;EACD,MAAM,EAAE,QAAQ,QAAQ,gBAAgB,YAAY,uBAAuB,eAAe;AAE1F,MAAI,QACF,QAAO,MAAM;AAGf,qBAAmB,SAAS,QAAQ,eAAe;AACnD,UAAQ,IAAI,eAAe,OAAO;AAElC,MAAI;GACF,MAAM,WAAW,MAAM,QAAQ,IAAI,cAAc,MAAM,CAAC;AACxD,UAAO,eAAe,UAAU,EAAE,QAAQ,SAAS,QAAQ,CAAC;WACrD,OAAO;AACd,SAAM,OAAO,EAAS,OAAgB,CAAC;AACvC,SAAM"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/react-router/index.ts"],"sourcesContent":["import { createContext } from 'react-router'\nimport type { AuditableLogger } from '../audit'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'middleware context. Make sure the evlog middleware is added to your route.',\n)\n\n/**\n * Typed context key for accessing the evlog logger in loaders and actions.\n *\n * @example\n * ```ts\n * import { loggerContext } from 'evlog/react-router'\n *\n * export async function loader({ context }: Route.LoaderArgs) {\n *   const log = context.get(loggerContext)\n *   log.set({ user: { id: 'u-1' } })\n *   return { ok: true }\n * }\n * ```\n */\nexport const loggerContext = createContext<AuditableLogger>()\n\nexport type EvlogReactRouterOptions = BaseEvlogOptions\n\nexport { useLogger }\n\n/**\n * Create an evlog middleware for React Router.\n *\n * @example\n * ```ts\n * // app/root.tsx\n * import { evlog } from 'evlog/react-router'\n *\n * export const middleware: Route.MiddlewareFunction[] = [\n *   evlog({ drain: createAxiomDrain() }),\n * ]\n * ```\n */\nexport function evlog(options: EvlogReactRouterOptions = {}) {\n  return async (\n    { request, context }: { request: Request; context: { set(ctx: unknown, value: unknown): void } },\n    next: () => Promise<Response>,\n  ): Promise<Response> => {\n    const url = new URL(request.url)\n    const middlewareOpts = {\n      method: request.method,\n      path: url.pathname,\n      requestId: request.headers.get('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeHeaders(request.headers),\n      ...options,\n    }\n    const { logger, finish, finishResponse, skipped } = createMiddlewareLogger(middlewareOpts)\n\n    if (skipped) {\n      return next()\n    }\n\n    attachForkToLogger(storage, logger, middlewareOpts)\n    context.set(loggerContext, logger)\n\n    try {\n      const response = await storage.run(logger, () => next())\n      return finishResponse(response, { status: response.status })\n    } catch (error) {\n      await finish({ error: error as Error })\n      throw error\n    }\n  }\n}\n"],"mappings":";;;;;AAOA,MAAM,EAAE,SAAS,cAAc,oBAC7B,6EACD;;;;;;;;;;;;;;;AAgBD,MAAa,gBAAgB,eAAgC;;;;;;;;;;;;;;AAmB7D,SAAgB,MAAM,UAAmC,EAAE,EAAE;AAC3D,QAAO,OACL,EAAE,SAAS,WACX,SACsB;EACtB,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;EAChC,MAAM,iBAAiB;GACrB,QAAQ,QAAQ;GAChB,MAAM,IAAI;GACV,WAAW,QAAQ,QAAQ,IAAI,eAAe,IAAI,OAAO,YAAY;GACrE,SAAS,mBAAmB,QAAQ,QAAQ;GAC5C,GAAG;GACJ;EACD,MAAM,EAAE,QAAQ,QAAQ,gBAAgB,YAAY,uBAAuB,eAAe;AAE1F,MAAI,QACF,QAAO,MAAM;AAGf,qBAAmB,SAAS,QAAQ,eAAe;AACnD,UAAQ,IAAI,eAAe,OAAO;AAElC,MAAI;GACF,MAAM,WAAW,MAAM,QAAQ,IAAI,cAAc,MAAM,CAAC;AACxD,UAAO,eAAe,UAAU,EAAE,QAAQ,SAAS,QAAQ,CAAC;WACrD,OAAO;AACd,SAAM,OAAO,EAAS,OAAgB,CAAC;AACvC,SAAM"}

package/dist/register-disk-snippet-B_JyhodL.mjs

@@ -0,0 +1,21 @@
+import { o as registerPrettyErrorSnippetReader } from "./pretty-error-THg0U0w9.mjs";
+//#region src/shared/register-disk-snippet.ts
+/**
+* Register the disk-backed pretty-error snippet reader when Node built-ins are available.
+*
+* Uses a dynamic import so Edge and non-Node bundles never parse `pretty-error-snippet.node`.
+*
+* @internal
+*/
+async function registerDiskPrettyErrorSnippetReader() {
+	try {
+		const { readCodeSnippetFromDisk } = await import("./pretty-error-snippet.node-itfCajBM.mjs").then((n) => n.t);
+		registerPrettyErrorSnippetReader(readCodeSnippetFromDisk);
+	} catch {
+		registerPrettyErrorSnippetReader(null);
+	}
+}
+//#endregion
+export { registerDiskPrettyErrorSnippetReader as t };
+
+//# sourceMappingURL=register-disk-snippet-B_JyhodL.mjs.map

package/dist/register-disk-snippet-B_JyhodL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-disk-snippet-B_JyhodL.mjs","names":[],"sources":["../src/shared/register-disk-snippet.ts"],"sourcesContent":["import { registerPrettyErrorSnippetReader } from './pretty-error'\n\n/**\n * Register the disk-backed pretty-error snippet reader when Node built-ins are available.\n *\n * Uses a dynamic import so Edge and non-Node bundles never parse `pretty-error-snippet.node`.\n *\n * @internal\n */\nexport async function registerDiskPrettyErrorSnippetReader(): Promise<void> {\n  try {\n    const { readCodeSnippetFromDisk } = await import('./pretty-error-snippet.node.js')\n    registerPrettyErrorSnippetReader(readCodeSnippetFromDisk)\n  } catch {\n    registerPrettyErrorSnippetReader(null)\n  }\n}\n"],"mappings":";;;;;;;;;AASA,eAAsB,uCAAsD;AAC1E,KAAI;EACF,MAAM,EAAE,4BAA4B,MAAM,OAAO,4CAAA,MAAA,MAAA,EAAA,EAAA;AACjD,mCAAiC,wBAAwB;SACnD;AACN,mCAAiC,KAAK"}

package/dist/runtime/client/log.d.mts

@@ -1,4 +1,4 @@
-import { X as LogLevel, Y as Log, dt as TransportConfig } from "../../audit-D7v6JHj0.mjs";
+import { $ as LogLevel, Q as Log, mt as TransportConfig } from "../../audit-CBfv3rl1.mjs";
 
 //#region src/runtime/client/log.d.ts
 declare function setIdentity(identity: Record<string, unknown>): void;

package/dist/runtime/server/routes/_evlog/ingest.post.mjs

@@ -1,5 +1,5 @@
 import { filterSafeHeaders } from "../../../../utils.mjs";
-import { _ as getEnvironment, y as getGlobalPluginRunner } from "../../../../audit-BQt8yAHo.mjs";
+import { b as getGlobalPluginRunner, v as getEnvironment } from "../../../../audit-CL0q7GJU.mjs";
 import { createError, defineEventHandler, getHeader, getHeaders, getRequestHost, readRawBody, setResponseStatus } from "h3";
 import { useNitroApp } from "nitropack/runtime";
 //#region src/runtime/server/routes/_evlog/ingest.post.ts

package/dist/runtime/server/useLogger.d.mts

@@ -1,2 +1,2 @@
-import { t as useLogger } from "../../useLogger-Cfv8Ck8b.mjs";
+import { t as useLogger } from "../../useLogger-DiRWGD33.mjs";
 export { useLogger };

package/dist/runtime/server/useLogger.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLogger.mjs","names":[],"sources":["../../../src/runtime/server/useLogger.ts"],"sourcesContent":["import type { RequestLogger, ServerEvent } from '../../types'\n\n/**\n * Returns the request logger attached to the given server event.\n *\n * @param event - The current server event containing the context with the logger.\n * @param service - Optional service name to override the default service.\n * @returns The request-scoped logger.\n * @throws Error if the logger is not initialized on the event context.\n *\n * @example\n * export default defineEventHandler((event) => {\n *   const log = useLogger(event)\n *   log.set({ foo: 'bar' })\n *   // ...\n * })\n *\n * @example\n * // Override service name for specific routes\n * export default defineEventHandler((event) => {\n *   const log = useLogger(event, 'payment-service')\n *   log.set({ foo: 'bar' })\n *   // ...\n * })\n *\n * @example\n * // Typed fields — must use explicit import for type checking to work\n * import { useLogger } from 'evlog'\n *\n * interface MyFields { user: { id: string; plan: string } }\n * const log = useLogger<MyFields>(event)\n * log.set({ user: { id: '123', plan: 'pro' } }) // OK\n * log.set({ foo: 'bar' })                        // TS error\n */\nexport function useLogger<T extends object = Record<string, unknown>>(event: ServerEvent, service?: string): RequestLogger<T> {\n  const log = event.context.log as RequestLogger<T> | undefined\n\n  if (!log) {\n    throw new Error(\n      '[evlog] Logger not initialized. Make sure the evlog Nitro plugin is registered. '\n      + 'If using Nuxt, add \"evlog\" to your modules.',\n    )\n  }\n\n  if (service) {\n    const untyped = log as unknown as RequestLogger\n    untyped.set({ service })\n  }\n\n  return log\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,UAAsD,OAAoB,SAAoC;CAC5H,MAAM,MAAM,MAAM,QAAQ;AAE1B,KAAI,CAAC,IACH,OAAM,IAAI,MACR,gIAED;AAGH,KAAI,QAEF,KAAQ,IAAI,EAAE,SAAS,CAAC;AAG1B,QAAO"}
+{"version":3,"file":"useLogger.mjs","names":[],"sources":["../../../src/runtime/server/useLogger.ts"],"sourcesContent":["import type { AuditableLogger } from '../../audit'\nimport type { ServerEvent } from '../../types'\n\n/**\n * Returns the request logger attached to the given server event.\n *\n * @param event - The current server event containing the context with the logger.\n * @param service - Optional service name to override the default service.\n * @returns The request-scoped logger.\n * @throws Error if the logger is not initialized on the event context.\n *\n * @example\n * export default defineEventHandler((event) => {\n *   const log = useLogger(event)\n *   log.set({ foo: 'bar' })\n *   // ...\n * })\n *\n * @example\n * // Override service name for specific routes\n * export default defineEventHandler((event) => {\n *   const log = useLogger(event, 'payment-service')\n *   log.set({ foo: 'bar' })\n *   // ...\n * })\n *\n * @example\n * // Typed fields — must use explicit import for type checking to work\n * import { useLogger } from 'evlog'\n *\n * interface MyFields { user: { id: string; plan: string } }\n * const log = useLogger<MyFields>(event)\n * log.set({ user: { id: '123', plan: 'pro' } }) // OK\n * log.set({ foo: 'bar' })                        // TS error\n */\nexport function useLogger<T extends object = Record<string, unknown>>(event: ServerEvent, service?: string): AuditableLogger<T> {\n  const log = event.context.log as AuditableLogger<T> | undefined\n\n  if (!log) {\n    throw new Error(\n      '[evlog] Logger not initialized. Make sure the evlog Nitro plugin is registered. '\n      + 'If using Nuxt, add \"evlog\" to your modules.',\n    )\n  }\n\n  if (service) {\n    log.set({ service })\n  }\n\n  return log\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,UAAsD,OAAoB,SAAsC;CAC9H,MAAM,MAAM,MAAM,QAAQ;AAE1B,KAAI,CAAC,IACH,OAAM,IAAI,MACR,gIAED;AAGH,KAAI,QACF,KAAI,IAAI,EAAE,SAAS,CAAC;AAGtB,QAAO"}

package/dist/runtime/utils/parseError.d.mts

@@ -1,3 +1,3 @@
-import { Q as ParsedError } from "../../audit-D7v6JHj0.mjs";
-import { t as parseError } from "../../parseError-BeBXEd2V.mjs";
+import { tt as ParsedError } from "../../audit-CBfv3rl1.mjs";
+import { t as parseError } from "../../parseError-BwBg-iW4.mjs";
 export { ParsedError, parseError };

package/dist/{storage-7X37OToT.mjs → storage-D4sBVffQ.mjs}

@@ -25,4 +25,4 @@ function createLoggerStorage(contextHint) {
 //#endregion
 export { createLoggerStorage as t };
 
-//# sourceMappingURL=storage-7X37OToT.mjs.map
+//# sourceMappingURL=storage-D4sBVffQ.mjs.map

package/dist/storage-D4sBVffQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-D4sBVffQ.mjs","names":[],"sources":["../src/shared/storage.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { AuditableLogger } from '../audit'\n\n/**\n * Create a request-scoped `AsyncLocalStorage` and matching `useLogger`\n * accessor. Every framework that exposes `useLogger()` (Express, Fastify,\n * NestJS, SvelteKit) calls this once at module level.\n *\n * @param contextHint - Appended to the error message when `useLogger()` is\n *   called outside of a request, e.g. `\"middleware context. Make sure\n *   app.use(evlog()) is registered before your routes.\"`.\n */\nexport function createLoggerStorage(contextHint: string) {\n  const storage = new AsyncLocalStorage<AuditableLogger>()\n\n  function useLogger<T extends object = Record<string, unknown>>(): AuditableLogger<T> {\n    const logger = storage.getStore()\n    if (!logger) {\n      throw new Error(\n        `[evlog] useLogger() was called outside of an evlog ${contextHint}`,\n      )\n    }\n    /** @internal ALS store is untyped; cast satisfies the caller's generic `T`. */\n    return logger as AuditableLogger<T>\n  }\n\n  return { storage, useLogger }\n}\n"],"mappings":";;;;;;;;;;;AAYA,SAAgB,oBAAoB,aAAqB;CACvD,MAAM,UAAU,IAAI,mBAAoC;CAExD,SAAS,YAA4E;EACnF,MAAM,SAAS,QAAQ,UAAU;AACjC,MAAI,CAAC,OACH,OAAM,IAAI,MACR,sDAAsD,cACvD;;AAGH,SAAO;;AAGT,QAAO;EAAE;EAAS;EAAW"}

package/dist/stream.d.mts

@@ -1,4 +1,4 @@
-import { B as DrainContext, ft as WideEvent } from "./audit-D7v6JHj0.mjs";
+import { U as DrainContext, ht as WideEvent } from "./audit-CBfv3rl1.mjs";
 
 //#region src/stream.d.ts
 /** Configuration accepted by {@link createStreamDrain}. */

package/dist/stream.mjs

@@ -1,4 +1,4 @@
-import { n as EVLOG_VERSION } from "./http-ChVS9GYc.mjs";
+import { n as EVLOG_VERSION } from "./http-DA3RWQrm.mjs";
 //#region src/stream.ts
 const DEFAULT_BUFFER = 500;
 const DEFAULT_QUEUE = 1e3;

package/dist/sveltekit/index.d.mts

@@ -1,8 +1,7 @@
-import { rt as RequestLogger } from "../audit-D7v6JHj0.mjs";
-import { t as BaseEvlogOptions } from "../middleware-B_k4Mrzg.mjs";
-
+import { l as AuditableLogger } from "../audit-CBfv3rl1.mjs";
+import { t as BaseEvlogOptions } from "../middleware-CjVyGyrG.mjs";
 //#region src/sveltekit/index.d.ts
-declare const useLogger: <T extends object = Record<string, unknown>>() => RequestLogger<T>;
+declare const useLogger: <T extends object = Record<string, unknown>>() => AuditableLogger<T>;
 type EvlogSvelteKitOptions = BaseEvlogOptions;
 /**
  * SvelteKit `Handle` function signature — avoids a hard dependency on `@sveltejs/kit`.

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/sveltekit/index.ts"],"mappings":";;;;cAQiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,qBAAA,GAAwB,gBAAA;;;;KAO/B,eAAA,IAAmB,KAAA;EACtB,KAAA;IAAS,OAAA,EAAS,OAAA;IAAS,GAAA,EAAK,GAAA;IAAK,MAAA,EAAQ,MAAA;EAAA;EAC7C,OAAA,MAAa,IAAA,YAAgB,QAAA,GAAW,OAAA,CAAQ,QAAA;AAAA,MAC5C,OAAA,CAAQ,QAAA;;;AAVd;KAeK,0BAAA,IAA8B,KAAA;EACjC,KAAA;EACA,KAAA;IAAS,OAAA,EAAS,OAAA;IAAS,GAAA,EAAK,GAAA;IAAK,MAAA,EAAQ,MAAA;EAAA;EAC7C,MAAA;EACA,OAAA;AAAA,MACI,YAAA,QAAoB,QAAA;AAAA,KAErB,YAAA,MAAkB,CAAA,GAAI,OAAA,CAAQ,CAAA;;UAGzB,QAAA;EACR,OAAA;EAAA,CACC,GAAA;AAAA;;;;;;;;;;;;;;;;;;;AAjBmB;;;;;;;;;;;;;;iBA2GN,KAAA,CAAM,OAAA,GAAS,qBAAA,GAA6B,eAAA;;;;;;;;;;;AAjG1B;;;;;;iBA0KlB,gBAAA,CAAA,GAAoB,0BAAA;;;;;;;;AAxKA;;;;;AA+FpC;;;;;;;;;AAyEA;;;;;AA2DA;;;;;;;;;iBAAgB,gBAAA,CAAiB,OAAA,GAAS,qBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/sveltekit/index.ts"],"mappings":";;;cASiB,SAAA,sBAAS,MAAA,wBAAA,eAAA,CAAA,CAAA;AAAA,KAMd,qBAAA,GAAwB,gBAAA;;AAbgD;;KAoB/E,eAAA,IAAmB,KAAA;EACtB,KAAA;IAAS,OAAA,EAAS,OAAA;IAAS,GAAA,EAAK,GAAA;IAAK,MAAA,EAAQ,MAAA;EAAA;EAC7C,OAAA,MAAa,IAAA,YAAgB,QAAA,GAAW,OAAA,CAAQ,QAAA;AAAA,MAC5C,OAAA,CAAQ,QAAA;;;;KAKT,0BAAA,IAA8B,KAAA;EACjC,KAAA;EACA,KAAA;IAAS,OAAA,EAAS,OAAA;IAAS,GAAA,EAAK,GAAA;IAAK,MAAA,EAAQ,MAAA;EAAA;EAC7C,MAAA;EACA,OAAA;AAAA,MACI,YAAA,QAAoB,QAAA;AAAA,KAErB,YAAA,MAAkB,CAAA,GAAI,OAAA,CAAQ,CAAA;;UAGzB,QAAA;EACR,OAAA;EAAA,CACC,GAAA;AAAA;;;;;;;;;;;;;;;;;;;;;AAjBmB;;;;;;;;;;;;iBA2GN,KAAA,CAAM,OAAA,GAAS,qBAAA,GAA6B,eAAA;;;;;;;;;;;;;AAjG1B;;;;iBA0KlB,gBAAA,CAAA,GAAoB,0BAAA;;;;;;;;;;AAxKA;;;;;AA+FpC;;;;;;;;;AAyEA;;;;;AA2DA;;;;;;;iBAAgB,gBAAA,CAAiB,OAAA,GAAS,qBAAA"}

package/dist/sveltekit/index.mjs

@@ -1,11 +1,13 @@
 import { EvlogError } from "../error.mjs";
 import { t as extractSafeHeaders } from "../headers-VtmnWcfn.mjs";
 import { t as extractErrorStatus } from "../errors-DA0cyr8q.mjs";
-import { a as serializeEvlogErrorResponse, i as resolveEvlogError } from "../nitro-ClRZLD1g.mjs";
-import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-CgGlAaHa.mjs";
-import { t as createLoggerStorage } from "../storage-7X37OToT.mjs";
+import { a as serializeEvlogErrorResponse, i as resolveEvlogError } from "../nitro-ClHmVj1H.mjs";
+import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-Di44utlp.mjs";
+import { t as registerDiskPrettyErrorSnippetReader } from "../register-disk-snippet-B_JyhodL.mjs";
+import { t as createLoggerStorage } from "../storage-D4sBVffQ.mjs";
 //#region src/sveltekit/index.ts
 const { storage, useLogger } = createLoggerStorage("handle context. Make sure evlog() handle is added to your hooks.server.ts.");
+registerDiskPrettyErrorSnippetReader();
 function isPlainObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/sveltekit/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/sveltekit/index.ts"],"sourcesContent":["import type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\nimport { resolveEvlogError, extractErrorStatus, serializeEvlogErrorResponse } from '../nitro'\nimport { EvlogError } from '../error'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'handle context. Make sure evlog() handle is added to your hooks.server.ts.',\n)\n\nexport type EvlogSvelteKitOptions = BaseEvlogOptions\n\nexport { useLogger }\n\n/**\n * SvelteKit `Handle` function signature — avoids a hard dependency on `@sveltejs/kit`.\n */\ntype SvelteKitHandle = (input: {\n  event: { request: Request; url: URL; locals: Record<string, any> }\n  resolve: (...args: any[]) => Response | Promise<Response>\n}) => Promise<Response>\n\n/**\n * SvelteKit `HandleServerError` signature — avoids a hard dependency on `@sveltejs/kit`.\n */\ntype SvelteKitHandleServerError = (input: {\n  error: unknown\n  event: { request: Request; url: URL; locals: Record<string, any> }\n  status: number\n  message: string\n}) => MaybePromise<void | AppError>\n\ntype MaybePromise<T> = T | Promise<T>\n\n/** Minimal SvelteKit `App.Error` shape */\ninterface AppError {\n  message: string\n  [key: string]: unknown\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nfunction isRequestLogger(value: unknown): value is RequestLogger {\n  return isPlainObject(value)\n    && typeof value.error === 'function'\n    && typeof value.emit === 'function'\n}\n\ninterface ContextEvlogError {\n  name: 'EvlogError'\n  status: number\n  message: string\n  why?: string\n  fix?: string\n  link?: string\n  code?: string\n}\n\nfunction isContextEvlogError(value: unknown): value is Record<string, unknown> & ContextEvlogError {\n  return isPlainObject(value)\n    && value.name === 'EvlogError'\n    && typeof value.status === 'number'\n    && typeof value.message === 'string'\n}\n\nfunction evlogErrorFromContext(errorData: Record<string, unknown>): EvlogError {\n  const nested = isPlainObject(errorData.data) ? errorData.data : undefined\n  const readString = (key: string): string | undefined => {\n    const direct = errorData[key]\n    if (typeof direct === 'string') return direct\n    const fromNested = nested?.[key]\n    return typeof fromNested === 'string' ? fromNested : undefined\n  }\n  return new EvlogError({\n    message: String(errorData.message),\n    status: errorData.status as number,\n    code: readString('code'),\n    why: readString('why'),\n    fix: readString('fix'),\n    link: readString('link'),\n  })\n}\n\nfunction readEvlogResponseData(response: Record<string, unknown>): { why?: string, fix?: string, link?: string } {\n  const { data } = response\n  if (!isPlainObject(data)) return {}\n  return {\n    why: typeof data.why === 'string' ? data.why : undefined,\n    fix: typeof data.fix === 'string' ? data.fix : undefined,\n    link: typeof data.link === 'string' ? data.link : undefined,\n  }\n}\n\n/**\n * Create an evlog handle hook for SvelteKit.\n *\n * Add it to your `src/hooks.server.ts` using SvelteKit's `sequence` helper\n * or as the sole handle export.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { initLogger } from 'evlog'\n * import { evlog } from 'evlog/sveltekit'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * initLogger({ env: { service: 'my-sveltekit-app' } })\n *\n * export const handle = evlog({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * })\n * ```\n *\n * @example\n * ```ts\n * // Compose with other hooks using sequence\n * import { sequence } from '@sveltejs/kit/hooks'\n * import { evlog } from 'evlog/sveltekit'\n *\n * export const handle = sequence(evlog(), yourOtherHook)\n * ```\n */\nexport function evlog(options: EvlogSvelteKitOptions = {}): SvelteKitHandle {\n  return async ({ event, resolve }) => {\n    const middlewareOpts = {\n      method: event.request.method,\n      path: event.url.pathname,\n      requestId: event.request.headers.get('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeHeaders(event.request.headers),\n      ...options,\n    }\n    const { logger, finish, finishResponse, skipped } = createMiddlewareLogger(middlewareOpts)\n\n    if (skipped) {\n      return await resolve(event)\n    }\n\n    attachForkToLogger(storage, logger, middlewareOpts)\n    event.locals.log = logger\n\n    return storage.run(logger, async () => {\n      try {\n        const response = await resolve(event)\n\n        // SvelteKit catches route errors internally and returns 500.\n        // If handleError already logged an EvlogError with a specific status,\n        // return a structured JSON response instead of SvelteKit's generic 500.\n        const ctx = logger.getContext()\n        const errorData = ctx.error\n        if (response.status >= 500 && isContextEvlogError(errorData)) {\n          const { status } = errorData\n          await finish({ status })\n          const body = serializeEvlogErrorResponse(evlogErrorFromContext(errorData), event.url.pathname)\n          return new Response(JSON.stringify(body), {\n            status,\n            headers: { 'content-type': 'application/json' },\n          })\n        }\n\n        return finishResponse(response)\n      } catch (error) {\n        await finish({ error: error instanceof Error ? error : new Error(String(error)) })\n\n        // Return structured JSON for EvlogError (like NextJS withEvlog / Nuxt errorHandler)\n        if (error instanceof EvlogError) {\n          const status = error.status ?? 500\n          const body = serializeEvlogErrorResponse(error, event.url.pathname)\n          return new Response(JSON.stringify(body), {\n            status,\n            headers: { 'content-type': 'application/json' },\n          })\n        }\n\n        throw error\n      }\n    })\n  }\n}\n\n/**\n * Create an evlog error handler for SvelteKit.\n *\n * Logs unhandled errors via `event.locals.log` (if available) and returns\n * structured error responses for `EvlogError` instances. For non-evlog errors,\n * returns a generic error response with sanitized messages in production.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { evlog, evlogHandleError } from 'evlog/sveltekit'\n *\n * export const handle = evlog()\n * export const handleError = evlogHandleError()\n * ```\n */\nexport function evlogHandleError(): SvelteKitHandleServerError {\n  return ({ error, event, status, message }) => {\n    const logger = isRequestLogger(event.locals.log) ? event.locals.log : undefined\n\n    if (logger && error instanceof Error) {\n      logger.error(error)\n    }\n\n    const evlogError = error instanceof Error ? resolveEvlogError(error) : null\n\n    if (evlogError) {\n      const errorStatus = extractErrorStatus(evlogError)\n      const response = serializeEvlogErrorResponse(evlogError, event.url.pathname)\n      return {\n        message: typeof response.message === 'string' ? response.message : message,\n        status: errorStatus,\n        ...readEvlogResponseData(response),\n      }\n    }\n\n    return { message, status }\n  }\n}\n\n/**\n * Create both `handle` and `handleError` hooks in a single call.\n *\n * This is the recommended setup for SvelteKit — it returns both hooks\n * pre-configured and ready to export from `hooks.server.ts`.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { initLogger } from 'evlog'\n * import { createEvlogHooks } from 'evlog/sveltekit'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * initLogger({ env: { service: 'my-app' } })\n *\n * export const { handle, handleError } = createEvlogHooks({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * })\n * ```\n *\n * @example\n * ```ts\n * // Compose with other hooks using sequence\n * import { sequence } from '@sveltejs/kit/hooks'\n * import { createEvlogHooks } from 'evlog/sveltekit'\n *\n * const evlogHooks = createEvlogHooks()\n *\n * export const handle = sequence(evlogHooks.handle, yourOtherHook)\n * export const handleError = evlogHooks.handleError\n * ```\n */\nexport function createEvlogHooks(options: EvlogSvelteKitOptions = {}) {\n  return {\n    handle: evlog(options),\n    handleError: evlogHandleError(),\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/sveltekit/index.ts"],"sourcesContent":["import type { RequestLogger } from '../types'\nimport { registerDiskPrettyErrorSnippetReader } from '../shared/register-disk-snippet'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\nimport { resolveEvlogError, extractErrorStatus, serializeEvlogErrorResponse } from '../nitro'\nimport { EvlogError } from '../error'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'handle context. Make sure evlog() handle is added to your hooks.server.ts.',\n)\n\nvoid registerDiskPrettyErrorSnippetReader()\n\nexport type EvlogSvelteKitOptions = BaseEvlogOptions\n\nexport { useLogger }\n\n/**\n * SvelteKit `Handle` function signature — avoids a hard dependency on `@sveltejs/kit`.\n */\ntype SvelteKitHandle = (input: {\n  event: { request: Request; url: URL; locals: Record<string, any> }\n  resolve: (...args: any[]) => Response | Promise<Response>\n}) => Promise<Response>\n\n/**\n * SvelteKit `HandleServerError` signature — avoids a hard dependency on `@sveltejs/kit`.\n */\ntype SvelteKitHandleServerError = (input: {\n  error: unknown\n  event: { request: Request; url: URL; locals: Record<string, any> }\n  status: number\n  message: string\n}) => MaybePromise<void | AppError>\n\ntype MaybePromise<T> = T | Promise<T>\n\n/** Minimal SvelteKit `App.Error` shape */\ninterface AppError {\n  message: string\n  [key: string]: unknown\n}\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nfunction isRequestLogger(value: unknown): value is RequestLogger {\n  return isPlainObject(value)\n    && typeof value.error === 'function'\n    && typeof value.emit === 'function'\n}\n\ninterface ContextEvlogError {\n  name: 'EvlogError'\n  status: number\n  message: string\n  why?: string\n  fix?: string\n  link?: string\n  code?: string\n}\n\nfunction isContextEvlogError(value: unknown): value is Record<string, unknown> & ContextEvlogError {\n  return isPlainObject(value)\n    && value.name === 'EvlogError'\n    && typeof value.status === 'number'\n    && typeof value.message === 'string'\n}\n\nfunction evlogErrorFromContext(errorData: Record<string, unknown>): EvlogError {\n  const nested = isPlainObject(errorData.data) ? errorData.data : undefined\n  const readString = (key: string): string | undefined => {\n    const direct = errorData[key]\n    if (typeof direct === 'string') return direct\n    const fromNested = nested?.[key]\n    return typeof fromNested === 'string' ? fromNested : undefined\n  }\n  return new EvlogError({\n    message: String(errorData.message),\n    status: errorData.status as number,\n    code: readString('code'),\n    why: readString('why'),\n    fix: readString('fix'),\n    link: readString('link'),\n  })\n}\n\nfunction readEvlogResponseData(response: Record<string, unknown>): { why?: string, fix?: string, link?: string } {\n  const { data } = response\n  if (!isPlainObject(data)) return {}\n  return {\n    why: typeof data.why === 'string' ? data.why : undefined,\n    fix: typeof data.fix === 'string' ? data.fix : undefined,\n    link: typeof data.link === 'string' ? data.link : undefined,\n  }\n}\n\n/**\n * Create an evlog handle hook for SvelteKit.\n *\n * Add it to your `src/hooks.server.ts` using SvelteKit's `sequence` helper\n * or as the sole handle export.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { initLogger } from 'evlog'\n * import { evlog } from 'evlog/sveltekit'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * initLogger({ env: { service: 'my-sveltekit-app' } })\n *\n * export const handle = evlog({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * })\n * ```\n *\n * @example\n * ```ts\n * // Compose with other hooks using sequence\n * import { sequence } from '@sveltejs/kit/hooks'\n * import { evlog } from 'evlog/sveltekit'\n *\n * export const handle = sequence(evlog(), yourOtherHook)\n * ```\n */\nexport function evlog(options: EvlogSvelteKitOptions = {}): SvelteKitHandle {\n  return async ({ event, resolve }) => {\n    const middlewareOpts = {\n      method: event.request.method,\n      path: event.url.pathname,\n      requestId: event.request.headers.get('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeHeaders(event.request.headers),\n      ...options,\n    }\n    const { logger, finish, finishResponse, skipped } = createMiddlewareLogger(middlewareOpts)\n\n    if (skipped) {\n      return await resolve(event)\n    }\n\n    attachForkToLogger(storage, logger, middlewareOpts)\n    event.locals.log = logger\n\n    return storage.run(logger, async () => {\n      try {\n        const response = await resolve(event)\n\n        // SvelteKit catches route errors internally and returns 500.\n        // If handleError already logged an EvlogError with a specific status,\n        // return a structured JSON response instead of SvelteKit's generic 500.\n        const ctx = logger.getContext()\n        const errorData = ctx.error\n        if (response.status >= 500 && isContextEvlogError(errorData)) {\n          const { status } = errorData\n          await finish({ status })\n          const body = serializeEvlogErrorResponse(evlogErrorFromContext(errorData), event.url.pathname)\n          return new Response(JSON.stringify(body), {\n            status,\n            headers: { 'content-type': 'application/json' },\n          })\n        }\n\n        return finishResponse(response)\n      } catch (error) {\n        await finish({ error: error instanceof Error ? error : new Error(String(error)) })\n\n        // Return structured JSON for EvlogError (like NextJS withEvlog / Nuxt errorHandler)\n        if (error instanceof EvlogError) {\n          const status = error.status ?? 500\n          const body = serializeEvlogErrorResponse(error, event.url.pathname)\n          return new Response(JSON.stringify(body), {\n            status,\n            headers: { 'content-type': 'application/json' },\n          })\n        }\n\n        throw error\n      }\n    })\n  }\n}\n\n/**\n * Create an evlog error handler for SvelteKit.\n *\n * Logs unhandled errors via `event.locals.log` (if available) and returns\n * structured error responses for `EvlogError` instances. For non-evlog errors,\n * returns a generic error response with sanitized messages in production.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { evlog, evlogHandleError } from 'evlog/sveltekit'\n *\n * export const handle = evlog()\n * export const handleError = evlogHandleError()\n * ```\n */\nexport function evlogHandleError(): SvelteKitHandleServerError {\n  return ({ error, event, status, message }) => {\n    const logger = isRequestLogger(event.locals.log) ? event.locals.log : undefined\n\n    if (logger && error instanceof Error) {\n      logger.error(error)\n    }\n\n    const evlogError = error instanceof Error ? resolveEvlogError(error) : null\n\n    if (evlogError) {\n      const errorStatus = extractErrorStatus(evlogError)\n      const response = serializeEvlogErrorResponse(evlogError, event.url.pathname)\n      return {\n        message: typeof response.message === 'string' ? response.message : message,\n        status: errorStatus,\n        ...readEvlogResponseData(response),\n      }\n    }\n\n    return { message, status }\n  }\n}\n\n/**\n * Create both `handle` and `handleError` hooks in a single call.\n *\n * This is the recommended setup for SvelteKit — it returns both hooks\n * pre-configured and ready to export from `hooks.server.ts`.\n *\n * @example\n * ```ts\n * // src/hooks.server.ts\n * import { initLogger } from 'evlog'\n * import { createEvlogHooks } from 'evlog/sveltekit'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * initLogger({ env: { service: 'my-app' } })\n *\n * export const { handle, handleError } = createEvlogHooks({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * })\n * ```\n *\n * @example\n * ```ts\n * // Compose with other hooks using sequence\n * import { sequence } from '@sveltejs/kit/hooks'\n * import { createEvlogHooks } from 'evlog/sveltekit'\n *\n * const evlogHooks = createEvlogHooks()\n *\n * export const handle = sequence(evlogHooks.handle, yourOtherHook)\n * export const handleError = evlogHooks.handleError\n * ```\n */\nexport function createEvlogHooks(options: EvlogSvelteKitOptions = {}) {\n  return {\n    handle: evlog(options),\n    handleError: evlogHandleError(),\n  }\n}\n"],"mappings":"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"}

package/dist/toolkit.d.mts

@@ -1,8 +1,8 @@
-import { B as DrainContext, Ct as enricherPlugin, St as drainPlugin, V as EnrichContext, X as LogLevel, _t as PluginSetupContext, bt as createPluginRunner, ft as WideEvent, gt as PluginRunner, ht as EvlogPlugin, mt as ClientLogContext, rt as RequestLogger, ut as TailSamplingContext, vt as RequestFinishContext, wt as getEmptyPluginRunner, xt as definePlugin, yt as RequestLifecycleContext } from "./audit-D7v6JHj0.mjs";
-import { a as resolveMiddlewarePluginRunner, i as createMiddlewareLogger, n as MiddlewareLoggerOptions, o as runEnrichAndDrain, r as MiddlewareLoggerResult, t as BaseEvlogOptions } from "./middleware-B_k4Mrzg.mjs";
-import { i as toMiddlewareOptions, n as defineEvlog, r as toLoggerConfig, t as EvlogConfig } from "./define-DTQpu4f6.mjs";
-import { n as EnricherOptions, r as defineEnricher, t as EnricherDefinition } from "./enricher-CBRmQw6e.mjs";
-import { n as getServiceForPath, r as shouldLog, t as extractErrorStatus } from "./errors-BLU4Tfpe.mjs";
+import { $ as LogLevel, Ct as createPluginRunner, Dt as getEmptyPluginRunner, Et as enricherPlugin, St as RequestLifecycleContext, Tt as drainPlugin, U as DrainContext, W as EnrichContext, _t as ClientLogContext, bt as PluginSetupContext, ht as WideEvent, l as AuditableLogger, ot as RequestLogger, pt as TailSamplingContext, vt as EvlogPlugin, wt as definePlugin, xt as RequestFinishContext, yt as PluginRunner } from "./audit-CBfv3rl1.mjs";
+import { a as resolveMiddlewarePluginRunner, i as createMiddlewareLogger, n as MiddlewareLoggerOptions, o as runEnrichAndDrain, r as MiddlewareLoggerResult, t as BaseEvlogOptions } from "./middleware-CjVyGyrG.mjs";
+import { i as toMiddlewareOptions, n as defineEvlog, r as toLoggerConfig, t as EvlogConfig } from "./define-BuDJpV2b.mjs";
+import { n as EnricherOptions, r as defineEnricher, t as EnricherDefinition } from "./enricher-VdBVX4oT.mjs";
+import { n as getServiceForPath, r as shouldLog, t as extractErrorStatus } from "./errors-ZdY6Ohi6.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/shared/streamResponse.d.ts
@@ -423,8 +423,8 @@ declare const OTEL_SEVERITY_TEXT: Record<LogLevel, string>;
  *   app.use(evlog()) is registered before your routes."`.
  */
 declare function createLoggerStorage(contextHint: string): {
-  storage: AsyncLocalStorage<RequestLogger<Record<string, unknown>>>;
-  useLogger: <T extends object = Record<string, unknown>>() => RequestLogger<T>;
+  storage: AsyncLocalStorage<AuditableLogger>;
+  useLogger: <T extends object = Record<string, unknown>>() => AuditableLogger<T>;
 };
 //#endregion
 export { AttributeValueKind, BaseEvlogOptions, ClientLogContext, ConfigField, DrainOptions, EVLOG_USER_AGENT, EVLOG_VERSION, EnricherDefinition, EnricherOptions, EvlogConfig, EvlogPlugin, ExtractedRequest, ForkBackgroundLoggerOptions, ForkLifecycle, FrameworkIntegrationHelpers, FrameworkIntegrationSpec, FrameworkRequestHandle, HttpDrainOptions, HttpDrainRequest, HttpPostOptions, MiddlewareLoggerOptions, MiddlewareLoggerResult, OTEL_SEVERITY_NUMBER, OTEL_SEVERITY_TEXT, PluginRunner, PluginSetupContext, RequestFinishContext, RequestLifecycleContext, StreamCompleteMeta, TypedAttributeValue, applyDeprecatedAlias, attachForkToLogger, bindStreamingResponseLifecycle, composeDrains, composeEnrichers, composeKeep, composePlugins, createLoggerStorage, createMiddlewareLogger, createPluginRunner, defineDrain, defineEnricher, defineEvlog, defineFrameworkIntegration, defineHttpDrain, definePlugin, drainPlugin, enricherPlugin, extractErrorStatus, extractSafeHeaders, extractSafeNodeHeaders, forkBackgroundLogger, formatPublicEnvKeys, getEmptyPluginRunner, getHeader, getRuntimeConfig, getServiceForPath, httpPost, isStreamingResponse, mergeEventField, normalizeNumber, resolveAdapterConfig, resolveMiddlewarePluginRunner, runEnrichAndDrain, shouldDeferEmitForResponse, shouldLog, toLoggerConfig, toMiddlewareOptions, toOtlpAttributeValue, toTypedAttributeValue, withEvlogIdentityHeaders };

package/dist/toolkit.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"toolkit.d.mts","names":[],"sources":["../src/shared/streamResponse.ts","../src/shared/compose.ts","../src/shared/config.ts","../src/shared/drain.ts","../src/shared/event.ts","../src/shared/fork.ts","../src/shared/headers.ts","../src/shared/http.ts","../src/shared/integration.ts","../src/shared/severity.ts","../src/shared/storage.ts"],"mappings":"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"}
+{"version":3,"file":"toolkit.d.mts","names":[],"sources":["../src/shared/streamResponse.ts","../src/shared/compose.ts","../src/shared/config.ts","../src/shared/drain.ts","../src/shared/event.ts","../src/shared/fork.ts","../src/shared/headers.ts","../src/shared/http.ts","../src/shared/integration.ts","../src/shared/severity.ts","../src/shared/storage.ts"],"mappings":"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"}

package/dist/toolkit.mjs

@@ -1,15 +1,15 @@
-import { A as enricherPlugin, D as createPluginRunner, O as definePlugin, j as getEmptyPluginRunner, k as drainPlugin } from "./audit-BQt8yAHo.mjs";
+import { A as drainPlugin, M as getEmptyPluginRunner, O as createPluginRunner, j as enricherPlugin, k as definePlugin } from "./audit-CL0q7GJU.mjs";
 import { i as normalizeNumber, n as extractSafeNodeHeaders, r as getHeader, t as extractSafeHeaders } from "./headers-VtmnWcfn.mjs";
 import { t as extractErrorStatus } from "./errors-DA0cyr8q.mjs";
 import { n as toLoggerConfig, r as toMiddlewareOptions, t as defineEvlog } from "./define-Bpaymi-h.mjs";
 import { n as shouldLog, t as getServiceForPath } from "./routes-4rMzRyTk.mjs";
 import { n as isStreamingResponse, r as shouldDeferEmitForResponse, t as bindStreamingResponseLifecycle } from "./streamResponse-CmQ3qUbF.mjs";
-import { i as withEvlogIdentityHeaders, n as EVLOG_VERSION, r as httpPost, t as EVLOG_USER_AGENT } from "./http-ChVS9GYc.mjs";
-import { a as getRuntimeConfig, i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig, r as applyDeprecatedAlias, t as defineDrain } from "./drain-fDb-eNwz.mjs";
+import { i as withEvlogIdentityHeaders, n as EVLOG_VERSION, r as httpPost, t as EVLOG_USER_AGENT } from "./http-DA3RWQrm.mjs";
+import { a as getRuntimeConfig, i as formatPublicEnvKeys, n as defineHttpDrain, o as resolveAdapterConfig, r as applyDeprecatedAlias, t as defineDrain } from "./drain-6lV-g7JB.mjs";
 import { n as toOtlpAttributeValue, r as toTypedAttributeValue, t as mergeEventField } from "./event-qwAv-7AZ.mjs";
 import { n as OTEL_SEVERITY_TEXT, t as OTEL_SEVERITY_NUMBER } from "./severity-CwXUSHt3.mjs";
 import { a as composePlugins, i as composeKeep, n as composeDrains, r as composeEnrichers, t as defineEnricher } from "./enricher-DAWf2-Fx.mjs";
-import { a as runEnrichAndDrain, i as resolveMiddlewarePluginRunner, n as forkBackgroundLogger, r as createMiddlewareLogger, t as attachForkToLogger } from "./fork-CgGlAaHa.mjs";
-import { t as defineFrameworkIntegration } from "./integration-DYp2uw8O.mjs";
-import { t as createLoggerStorage } from "./storage-7X37OToT.mjs";
+import { a as runEnrichAndDrain, i as resolveMiddlewarePluginRunner, n as forkBackgroundLogger, r as createMiddlewareLogger, t as attachForkToLogger } from "./fork-Di44utlp.mjs";
+import { t as defineFrameworkIntegration } from "./integration-2PpI-bCm.mjs";
+import { t as createLoggerStorage } from "./storage-D4sBVffQ.mjs";
 export { EVLOG_USER_AGENT, EVLOG_VERSION, OTEL_SEVERITY_NUMBER, OTEL_SEVERITY_TEXT, applyDeprecatedAlias, attachForkToLogger, bindStreamingResponseLifecycle, composeDrains, composeEnrichers, composeKeep, composePlugins, createLoggerStorage, createMiddlewareLogger, createPluginRunner, defineDrain, defineEnricher, defineEvlog, defineFrameworkIntegration, defineHttpDrain, definePlugin, drainPlugin, enricherPlugin, extractErrorStatus, extractSafeHeaders, extractSafeNodeHeaders, forkBackgroundLogger, formatPublicEnvKeys, getEmptyPluginRunner, getHeader, getRuntimeConfig, getServiceForPath, httpPost, isStreamingResponse, mergeEventField, normalizeNumber, resolveAdapterConfig, resolveMiddlewarePluginRunner, runEnrichAndDrain, shouldDeferEmitForResponse, shouldLog, toLoggerConfig, toMiddlewareOptions, toOtlpAttributeValue, toTypedAttributeValue, withEvlogIdentityHeaders };

package/dist/types.d.mts

@@ -1,2 +1,2 @@
-import { $ as RedactConfig, A as AuditActionDefinition, B as DrainContext, F as AuditPatchOp, G as FieldContext, H as EnvironmentContext, I as AuditSeverity, J as InternalFields, K as H3EventContext, L as AuditTarget, M as AuditChanges, N as AuditFields, P as AuditLoggerMethod, Q as ParsedError, R as BaseWideEvent, U as ErrorCode, V as EnrichContext, W as ErrorOptions, X as LogLevel, Y as Log, Z as LoggerConfig, at as RouteConfig, ct as ServerEvent, dt as TransportConfig, et as RegisteredAuditCatalogs, ft as WideEvent, it as RequestLoggerOptions, j as AuditActor, k as AuditAction, lt as TailSamplingCondition, nt as RequestLogEntry, ot as SamplingConfig, q as IngestPayload, rt as RequestLogger, st as SamplingRates, tt as RegisteredErrorCatalogs, ut as TailSamplingContext, z as DeepPartial } from "./audit-D7v6JHj0.mjs";
+import { $ as LogLevel, B as AuditTarget, F as AuditChanges, G as EnvironmentContext, H as DeepPartial, I as AuditFields, J as FieldContext, K as ErrorCode, L as AuditLoggerMethod, M as AuditAction, N as AuditActionDefinition, P as AuditActor, Q as Log, R as AuditPatchOp, U as DrainContext, V as BaseWideEvent, W as EnrichContext, X as IngestPayload, Y as H3EventContext, Z as InternalFields, at as RequestLogEntry, ct as RouteConfig, dt as ServerEvent, et as LoggerConfig, ft as TailSamplingCondition, ht as WideEvent, it as RegisteredErrorCatalogs, lt as SamplingConfig, mt as TransportConfig, nt as RedactConfig, ot as RequestLogger, pt as TailSamplingContext, q as ErrorOptions, rt as RegisteredAuditCatalogs, st as RequestLoggerOptions, tt as ParsedError, ut as SamplingRates, z as AuditSeverity } from "./audit-CBfv3rl1.mjs";
 export { AuditAction, AuditActionDefinition, AuditActor, AuditChanges, AuditFields, AuditLoggerMethod, AuditPatchOp, AuditSeverity, AuditTarget, BaseWideEvent, DeepPartial, DrainContext, EnrichContext, EnvironmentContext, ErrorCode, ErrorOptions, FieldContext, H3EventContext, IngestPayload, InternalFields, Log, LogLevel, LoggerConfig, ParsedError, RedactConfig, RegisteredAuditCatalogs, RegisteredErrorCatalogs, RequestLogEntry, RequestLogger, RequestLoggerOptions, RouteConfig, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, TransportConfig, WideEvent };

package/dist/{useLogger-Cfv8Ck8b.d.mts → useLogger-DiRWGD33.d.mts}

@@ -1,4 +1,4 @@
-import { ct as ServerEvent, rt as RequestLogger } from "./audit-D7v6JHj0.mjs";
+import { dt as ServerEvent, l as AuditableLogger } from "./audit-CBfv3rl1.mjs";
 
 //#region src/runtime/server/useLogger.d.ts
 /**
@@ -33,7 +33,7 @@ import { ct as ServerEvent, rt as RequestLogger } from "./audit-D7v6JHj0.mjs";
  * log.set({ user: { id: '123', plan: 'pro' } }) // OK
  * log.set({ foo: 'bar' })                        // TS error
  */
-declare function useLogger<T extends object = Record<string, unknown>>(event: ServerEvent, service?: string): RequestLogger<T>;
+declare function useLogger<T extends object = Record<string, unknown>>(event: ServerEvent, service?: string): AuditableLogger<T>;
 //#endregion
 export { useLogger as t };
-//# sourceMappingURL=useLogger-Cfv8Ck8b.d.mts.map
+//# sourceMappingURL=useLogger-DiRWGD33.d.mts.map

package/dist/useLogger-DiRWGD33.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLogger-DiRWGD33.d.mts","names":[],"sources":["../src/runtime/server/useLogger.ts"],"mappings":";;;;AAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,SAAA,oBAA6B,MAAA,kBAAA,CAAyB,KAAA,EAAO,WAAA,EAAa,OAAA,YAAmB,eAAA,CAAgB,CAAA"}

package/dist/{utils-CJJG0ZYW.d.mts → utils-XPMPENUK.d.mts}

@@ -1,4 +1,4 @@
-import { H as EnvironmentContext, X as LogLevel } from "./audit-D7v6JHj0.mjs";
+import { $ as LogLevel, G as EnvironmentContext } from "./audit-CBfv3rl1.mjs";
 
 //#region src/utils.d.ts
 declare function formatDuration(ms: number): string;
@@ -69,4 +69,4 @@ declare function globToRegExp(pattern: string, separator?: '/' | '.'): RegExp;
 declare function matchesPattern(path: string, pattern: string): boolean;
 //#endregion
 export { matchesPattern as _, escapeFormatString as a, getConsoleMethod as c, globToRegExp as d, isBrowser as f, isServer as g, isLevelEnabled as h, detectEnvironment as i, getCssLevelColor as l, isDev as m, colors as n, filterSafeHeaders as o, isClient as p, cssColors as r, formatDuration as s, SENSITIVE_HEADERS as t, getLevelColor as u };
-//# sourceMappingURL=utils-CJJG0ZYW.d.mts.map
+//# sourceMappingURL=utils-XPMPENUK.d.mts.map

package/dist/{utils-CJJG0ZYW.d.mts.map → utils-XPMPENUK.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"utils-CJJG0ZYW.d.mts","names":[],"sources":["../src/utils.ts"],"mappings":";;;iBAEgB,cAAA,CAAe,EAAA;AAAA,iBAOf,QAAA,CAAA;AAAA,iBAIA,QAAA,CAAA;AAAA,iBAIA,SAAA,CAAA;AAAA,iBAOA,KAAA,CAAA;AAAA,iBAUA,iBAAA,CAAA,GAAqB,OAAA,CAAQ,kBAAA;;AAzB7C;;iBAsDgB,cAAA,CAAe,KAAA,EAAO,QAAA,EAAU,QAAA,EAAU,QAAA;AAAA,iBAI1C,gBAAA,CAAiB,KAAA,EAAO,QAAA,GAAW,QAAA;AAAA,cAItC,MAAA;EAAA;;;;;;;;;;;;iBAgBG,aAAA,CAAc,KAAA;AAAA,cAIjB,SAAA;EAAA;;;;;;;;iBAYG,gBAAA,CAAiB,KAAA;;;;;;iBASjB,kBAAA,CAAmB,GAAA;;cAKtB,iBAAA;;;;;;;;;AA9Cb;iBAkEgB,iBAAA,CAAkB,OAAA,EAAS,OAAA,CAAQ,MAAA,gCAAsC,MAAA;;;;;;;;iBAqBzE,YAAA,CAAa,OAAA,UAAiB,SAAA,eAA6B,MAAA;;;;;iBAsB3D,cAAA,CAAe,IAAA,UAAc,OAAA"}
+{"version":3,"file":"utils-XPMPENUK.d.mts","names":[],"sources":["../src/utils.ts"],"mappings":";;;iBAEgB,cAAA,CAAe,EAAA;AAAA,iBAOf,QAAA,CAAA;AAAA,iBAIA,QAAA,CAAA;AAAA,iBAIA,SAAA,CAAA;AAAA,iBAOA,KAAA,CAAA;AAAA,iBAUA,iBAAA,CAAA,GAAqB,OAAA,CAAQ,kBAAA;;AAzB7C;;iBAsDgB,cAAA,CAAe,KAAA,EAAO,QAAA,EAAU,QAAA,EAAU,QAAA;AAAA,iBAI1C,gBAAA,CAAiB,KAAA,EAAO,QAAA,GAAW,QAAA;AAAA,cAItC,MAAA;EAAA;;;;;;;;;;;;iBAgBG,aAAA,CAAc,KAAA;AAAA,cAIjB,SAAA;EAAA;;;;;;;;iBAYG,gBAAA,CAAiB,KAAA;;;;;;iBASjB,kBAAA,CAAmB,GAAA;;cAKtB,iBAAA;;;;;;;;;AA9Cb;iBAkEgB,iBAAA,CAAkB,OAAA,EAAS,OAAA,CAAQ,MAAA,gCAAsC,MAAA;;;;;;;;iBAqBzE,YAAA,CAAa,OAAA,UAAiB,SAAA,eAA6B,MAAA;;;;;iBAsB3D,cAAA,CAAe,IAAA,UAAc,OAAA"}