evlog 2.17.0 → 2.18.1

package/dist/index.d.mts

@@ -1,9 +1,9 @@
-import { $ as RequestLogger, A as AuditActor, B as ErrorOptions, C as buildAuditFields, D as withAudit, E as signed, F as DeepPartial, G as Log, H as H3EventContext, I as DrainContext, J as ParsedError, K as LogLevel, L as EnrichContext, M as AuditLoggerMethod, N as AuditTarget, O as withAuditMethods, P as BaseWideEvent, R as EnvironmentContext, S as auditRedactPreset, T as mockAudit, U as IngestPayload, V as FieldContext, W as InternalFields, X as RegisteredAuditCatalogs, Y as RedactConfig, Z as RegisteredErrorCatalogs, _ as WithAuditOptions, _t as drainPlugin, a as AuditInput, at as TailSamplingCondition, b as auditEnricher, c as AuditOnlyOptions, ct as WideEvent, d as DefinedAuditAction, dt as PluginRunner, et as RequestLoggerOptions, f as DrainFn, ft as PluginSetupContext, g as WithAuditContext, gt as definePlugin, h as SignedOptions, i as AuditEnricherOptions, it as ServerEvent, j as AuditFields, k as AuditAction, l as AuditPatchOp, lt as ClientLogContext, m as SignedChainState, mt as RequestLifecycleContext, n as AuditDeniedError, nt as SamplingConfig, o as AuditMatcher, ot as TailSamplingContext, p as MockAudit, pt as RequestFinishContext, q as LoggerConfig, r as AuditDiffOptions, rt as SamplingRates, s as AuditMethod, st as TransportConfig, t as AUDIT_SCHEMA_VERSION, u as AuditableLogger, ut as EvlogPlugin, v as audit, vt as enricherPlugin, w as defineAuditAction, x as auditOnly, y as auditDiff, z as ErrorCode } from "./audit-CC8nfazi.mjs";
-import { n as createError, t as EvlogError } from "./error-CpbbtyXL.mjs";
-import { a as DefinedError, c as ErrorCatalogMap, d as defineAuditCatalog, f as defineError, i as DefinedCatalogAudit, l as ErrorFactoryOpts, n as AuditCatalogEntry, o as ErrorCatalog, p as defineErrorCatalog, r as AuditCatalogMap, s as ErrorCatalogEntry, t as AuditCatalog, u as ErrorFactoryOverrides } from "./index-o1_z4phv.mjs";
-import { c as isEnabled, d as shouldKeep, i as getEnvironment, n as createLogger, r as createRequestLogger, s as initLogger, t as _log } from "./logger-DntcxxHg.mjs";
-import { m as isLevelEnabled } from "./utils-DLCeShxL.mjs";
-import { t as useLogger } from "./useLogger-BsPL4AQm.mjs";
-import { t as parseError } from "./parseError-yVZ58wIK.mjs";
-import { i as toMiddlewareOptions, n as defineEvlog, r as toLoggerConfig, t as EvlogConfig } from "./define-MSdhzmXn.mjs";
+import { $ as RequestLogger, A as AuditActor, B as ErrorOptions, C as buildAuditFields, D as withAudit, E as signed, F as DeepPartial, G as Log, H as H3EventContext, I as DrainContext, J as ParsedError, K as LogLevel, L as EnrichContext, M as AuditLoggerMethod, N as AuditTarget, O as withAuditMethods, P as BaseWideEvent, R as EnvironmentContext, S as auditRedactPreset, T as mockAudit, U as IngestPayload, V as FieldContext, W as InternalFields, X as RegisteredAuditCatalogs, Y as RedactConfig, Z as RegisteredErrorCatalogs, _ as WithAuditOptions, _t as drainPlugin, a as AuditInput, at as TailSamplingCondition, b as auditEnricher, c as AuditOnlyOptions, ct as WideEvent, d as DefinedAuditAction, dt as PluginRunner, et as RequestLoggerOptions, f as DrainFn, ft as PluginSetupContext, g as WithAuditContext, gt as definePlugin, h as SignedOptions, i as AuditEnricherOptions, it as ServerEvent, j as AuditFields, k as AuditAction, l as AuditPatchOp, lt as ClientLogContext, m as SignedChainState, mt as RequestLifecycleContext, n as AuditDeniedError, nt as SamplingConfig, o as AuditMatcher, ot as TailSamplingContext, p as MockAudit, pt as RequestFinishContext, q as LoggerConfig, r as AuditDiffOptions, rt as SamplingRates, s as AuditMethod, st as TransportConfig, t as AUDIT_SCHEMA_VERSION, u as AuditableLogger, ut as EvlogPlugin, v as audit, vt as enricherPlugin, w as defineAuditAction, x as auditOnly, y as auditDiff, z as ErrorCode } from "./audit-DVdkntSO.mjs";
+import { n as createError, t as EvlogError } from "./error-CVtn5U7b.mjs";
+import { a as DefinedError, c as ErrorCatalogMap, d as defineAuditCatalog, f as defineError, i as DefinedCatalogAudit, l as ErrorFactoryOpts, n as AuditCatalogEntry, o as ErrorCatalog, p as defineErrorCatalog, r as AuditCatalogMap, s as ErrorCatalogEntry, t as AuditCatalog, u as ErrorFactoryOverrides } from "./index-ZSRQP_BI.mjs";
+import { c as isEnabled, f as shouldKeep, i as getEnvironment, n as createLogger, r as createRequestLogger, s as initLogger, t as _log } from "./logger-CTcvd5Cc.mjs";
+import { m as isLevelEnabled } from "./utils-DxqvIOyR.mjs";
+import { t as useLogger } from "./useLogger-CqvH6qOf.mjs";
+import { t as parseError } from "./parseError-D4PIxEWo.mjs";
+import { i as toMiddlewareOptions, n as defineEvlog, r as toLoggerConfig, t as EvlogConfig } from "./define-D-BVMf2l.mjs";
 export { AUDIT_SCHEMA_VERSION, AuditAction, AuditActor, AuditCatalog, AuditCatalogEntry, AuditCatalogMap, AuditDeniedError, AuditDiffOptions, AuditEnricherOptions, AuditFields, AuditInput, AuditLoggerMethod, AuditMatcher, AuditMethod, AuditOnlyOptions, AuditPatchOp, AuditTarget, AuditableLogger, BaseWideEvent, ClientLogContext, DeepPartial, DefinedAuditAction, DefinedCatalogAudit, DefinedError, DrainContext, DrainFn, EnrichContext, EnvironmentContext, ErrorCatalog, ErrorCatalogEntry, ErrorCatalogMap, ErrorCode, ErrorFactoryOpts, ErrorFactoryOverrides, ErrorOptions, EvlogConfig, EvlogError, EvlogPlugin, FieldContext, H3EventContext, IngestPayload, InternalFields, Log, LogLevel, LoggerConfig, MockAudit, ParsedError, PluginRunner, PluginSetupContext, RedactConfig, RegisteredAuditCatalogs, RegisteredErrorCatalogs, RequestFinishContext, RequestLifecycleContext, RequestLogger, RequestLoggerOptions, SamplingConfig, SamplingRates, ServerEvent, SignedChainState, SignedOptions, TailSamplingCondition, TailSamplingContext, TransportConfig, WideEvent, WithAuditContext, WithAuditOptions, audit, auditDiff, auditEnricher, auditOnly, auditRedactPreset, buildAuditFields, createError, createError as createEvlogError, createLogger, createRequestLogger, defineAuditAction, defineAuditCatalog, defineError, defineErrorCatalog, defineEvlog, definePlugin, drainPlugin, enricherPlugin, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, mockAudit, parseError, shouldKeep, signed, toLoggerConfig, toMiddlewareOptions, useLogger, withAudit, withAuditMethods };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { D as drainPlugin, E as definePlugin, O as enricherPlugin, _ as getEnvironment, a as auditEnricher, b as initLogger, c as buildAuditFields, d as signed, f as withAudit, g as createRequestLogger, h as createLogger, i as auditDiff, l as defineAuditAction, m as _log, n as AuditDeniedError, o as auditOnly, p as withAuditMethods, r as audit, s as auditRedactPreset, t as AUDIT_SCHEMA_VERSION, u as mockAudit, w as shouldKeep, x as isEnabled } from "./audit-pV5aLGP0.mjs";
+import { D as definePlugin, O as drainPlugin, T as shouldKeep, _ as getEnvironment, a as auditEnricher, b as initLogger, c as buildAuditFields, d as signed, f as withAudit, g as createRequestLogger, h as createLogger, i as auditDiff, k as enricherPlugin, l as defineAuditAction, m as _log, n as AuditDeniedError, o as auditOnly, p as withAuditMethods, r as audit, s as auditRedactPreset, t as AUDIT_SCHEMA_VERSION, u as mockAudit, x as isEnabled } from "./audit-BUI3af4w.mjs";
 import { isLevelEnabled } from "./utils.mjs";
 import { EvlogError, createError } from "./error.mjs";
 import { useLogger } from "./runtime/server/useLogger.mjs";

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/catalog.ts"],"sourcesContent":["import type { AuditInput } from './audit'\nimport type { AuditTarget } from './types'\nimport { defineAuditAction } from './audit'\nimport { EvlogError } from './error'\n\n/**\n * Static metadata for a single entry in an error catalog.\n *\n * `message` is either a constant string or a function that receives required\n * params at the call site (typed). All other fields are templated defaults\n * that can be overridden at the call site.\n */\nexport interface ErrorCatalogEntry {\n  /** HTTP status code (default: 500). */\n  status?: number\n  /**\n   * Either a constant string or a typed function whose params become required\n   * arguments at the call site (`factory({ available, required })`).\n   */\n  message: string | ((params: never) => string)\n  /** Why this error occurred (technical reason). */\n  why?: string\n  /** Actionable fix shown to the user. */\n  fix?: string\n  /** Link to documentation. */\n  link?: string\n  /** Free-form metadata for grouping / filtering (not surfaced on the wire). */\n  tags?: readonly string[]\n  /**\n   * Backend-only context defaults. Merged with call-site `internal` (call-site wins).\n   */\n  internal?: Record<string, unknown>\n}\n\n/**\n * Subset of {@link import('./types').ErrorOptions} that callers may override\n * when invoking a catalog factory. `code` is always derived from the catalog\n * and intentionally excluded — pass `cause` here for error chaining.\n */\nexport interface ErrorFactoryOverrides {\n  message?: string\n  status?: number\n  why?: string\n  fix?: string\n  link?: string\n  internal?: Record<string, unknown>\n  cause?: Error\n}\n\n/** @internal Extract the params object type from a templated message function. */\ntype MessageParams<TMessage> = TMessage extends (params: infer P) => string ? P : Record<string, never>\n\n/**\n * Call-site argument type for a catalog factory:\n * - if `message` is a function: required params object merged with overrides\n * - if `message` is a string: optional overrides only\n */\nexport type ErrorFactoryOpts<TEntry extends ErrorCatalogEntry> =\n  TEntry['message'] extends (params: infer _P) => string\n    ? MessageParams<TEntry['message']> & ErrorFactoryOverrides\n    : ErrorFactoryOverrides\n\n/** @internal When message is a string, the call-site argument is optional. */\ntype FactoryArgs<TEntry extends ErrorCatalogEntry> =\n  TEntry['message'] extends (params: never) => string\n    ? [opts: ErrorFactoryOpts<TEntry>]\n    : [opts?: ErrorFactoryOpts<TEntry>]\n\n/**\n * A factory produced by {@link defineError} or each entry of\n * {@link defineErrorCatalog}. Calling it returns a fully-formed\n * {@link EvlogError} with the catalog's defaults applied. Static metadata\n * is exposed as readonly properties for introspection / refactor-safe\n * comparisons (`err.code === MyError.code`).\n */\nexport type DefinedError<TCode extends string, TEntry extends ErrorCatalogEntry> =\n  & ((...args: FactoryArgs<TEntry>) => EvlogError)\n  & {\n    readonly code: TCode\n    readonly status: number\n    readonly message: TEntry['message']\n    readonly why: TEntry['why']\n    readonly fix: TEntry['fix']\n    readonly link: TEntry['link']\n    readonly tags: TEntry['tags']\n    readonly internal: TEntry['internal']\n  }\n\nfunction buildEvlogError(\n  code: string,\n  entry: ErrorCatalogEntry,\n  rawArgs: Record<string, unknown> | undefined,\n): EvlogError {\n  const args = rawArgs ?? {}\n  const {\n    message: messageOverride,\n    status,\n    why,\n    fix,\n    link,\n    cause,\n    internal: callInternal,\n    ...maybeParams\n  } = args as ErrorFactoryOverrides & Record<string, unknown>\n\n  let message: string\n  if (typeof messageOverride === 'string') {\n    message = messageOverride\n  } else if (typeof entry.message === 'function') {\n    message = (entry.message as (p: unknown) => string)(maybeParams)\n  } else {\n    ({ message } = entry as { message: string })\n  }\n\n  let internal: Record<string, unknown> | undefined\n  if (entry.internal || callInternal) {\n    internal = { ...(entry.internal ?? {}), ...(callInternal ?? {}) }\n  }\n\n  return new EvlogError({\n    code,\n    message,\n    status: status ?? entry.status ?? 500,\n    why: why ?? entry.why,\n    fix: fix ?? entry.fix,\n    link: link ?? entry.link,\n    cause: cause as Error | undefined,\n    internal,\n  })\n}\n\n/**\n * Define a single, standalone error factory bound to a stable `code`.\n *\n * Each factory produces an {@link EvlogError} with the entry's defaults\n * applied. Call-site overrides (`cause`, `internal`, `message`, ...) are\n * shallow-merged onto those defaults.\n *\n * @example\n * ```ts\n * import { defineError } from 'evlog'\n *\n * export const PaymentDeclined = defineError('billing.PAYMENT_DECLINED', {\n *   status: 402,\n *   message: 'Card declined',\n *   why: 'Issuer declined the charge',\n *   fix: 'Try another card',\n * })\n *\n * throw PaymentDeclined()\n * throw PaymentDeclined({ cause: stripeErr, internal: { ref: 'ch_x' } })\n * ```\n *\n * @example Templated message with typed params\n * ```ts\n * export const InsufficientFunds = defineError('billing.INSUFFICIENT_FUNDS', {\n *   status: 402,\n *   message: ({ available, required }: { available: number, required: number }) =>\n *     `Insufficient funds: $${available}/$${required}`,\n * })\n *\n * throw InsufficientFunds({ available: 5, required: 100 })\n * ```\n */\nexport function defineError<\n  const TCode extends string,\n  const TEntry extends ErrorCatalogEntry,\n>(code: TCode, entry: TEntry): DefinedError<TCode, TEntry> {\n  const factory = ((...args: unknown[]) =>\n    buildEvlogError(code, entry, args[0] as Record<string, unknown> | undefined)) as DefinedError<TCode, TEntry>\n\n  Object.defineProperties(factory, {\n    code: { value: code, enumerable: true },\n    status: { value: entry.status ?? 500, enumerable: true },\n    message: { value: entry.message, enumerable: true },\n    why: { value: entry.why, enumerable: true },\n    fix: { value: entry.fix, enumerable: true },\n    link: { value: entry.link, enumerable: true },\n    tags: { value: entry.tags, enumerable: true },\n    internal: { value: entry.internal, enumerable: true },\n  })\n\n  return factory\n}\n\n/** Map of error catalog entries keyed by their (UPPER_SNAKE) name. */\nexport interface ErrorCatalogMap {\n  readonly [key: string]: ErrorCatalogEntry\n}\n\n/**\n * The object returned by {@link defineErrorCatalog}. Each map key becomes a\n * dot-accessed factory whose `code` is `${prefix}.${key}` (preserved casing).\n *\n * Catalog metadata (`_prefix`, `_codes`) is exposed as non-enumerable readonly\n * properties so it does not pollute iteration but is available for typing\n * (`declare module 'evlog'`) and runtime introspection.\n */\nexport type ErrorCatalog<TPrefix extends string, TMap extends ErrorCatalogMap> =\n  & { [K in keyof TMap & string]: DefinedError<`${TPrefix}.${K}`, TMap[K]> }\n  & {\n    readonly _prefix: TPrefix\n    readonly _codes: ReadonlyArray<`${TPrefix}.${keyof TMap & string}`>\n  }\n\n/**\n * Define a bundle of errors that share a common prefix. The wire `code` for\n * each entry is `${prefix}.${KEY}` (the key's casing is preserved — convention\n * is `UPPER_SNAKE_CASE`).\n *\n * Pair with `declare module 'evlog'` to surface autocomplete + literal-typed\n * `code` everywhere across the codebase.\n *\n * @example\n * ```ts\n * import { defineErrorCatalog } from 'evlog'\n *\n * export const billingErrors = defineErrorCatalog('billing', {\n *   PAYMENT_DECLINED: { status: 402, message: 'Card declined' },\n *   INSUFFICIENT_FUNDS: {\n *     status: 402,\n *     message: ({ available, required }: { available: number, required: number }) =>\n *       `Insufficient funds: $${available}/$${required}`,\n *   },\n * })\n *\n * declare module 'evlog' {\n *   interface RegisteredErrorCatalogs {\n *     billing: typeof billingErrors\n *   }\n * }\n *\n * throw billingErrors.PAYMENT_DECLINED()\n * throw billingErrors.INSUFFICIENT_FUNDS({ available: 5, required: 100 })\n * ```\n */\nexport function defineErrorCatalog<\n  const TPrefix extends string,\n  const TMap extends ErrorCatalogMap,\n>(prefix: TPrefix, map: TMap): ErrorCatalog<TPrefix, TMap> {\n  const out: Record<string, unknown> = {}\n  const codes: string[] = []\n\n  for (const key of Object.keys(map)) {\n    const code = `${prefix}.${key}`\n    out[key] = defineError(code, map[key])\n    codes.push(code)\n  }\n\n  Object.defineProperties(out, {\n    _prefix: { value: prefix, enumerable: false },\n    _codes: { value: Object.freeze(codes), enumerable: false },\n  })\n\n  return out as ErrorCatalog<TPrefix, TMap>\n}\n\n/** Static metadata for a single entry in an audit catalog. */\nexport interface AuditCatalogEntry {\n  /** Default `target.type` for every audit emitted from this action. */\n  target?: string\n}\n\n/** Map of audit catalog entries keyed by their (UPPER_SNAKE) name. */\nexport interface AuditCatalogMap {\n  readonly [key: string]: AuditCatalogEntry\n}\n\n/** A factory produced by an audit catalog entry. Returns an {@link AuditInput}. */\nexport type DefinedCatalogAudit<TAction extends string, TEntry extends AuditCatalogEntry> =\n  & ((\n    input: TEntry['target'] extends string\n      ? Omit<AuditInput, 'action' | 'target'> & { target?: Omit<AuditTarget, 'type'> & { type?: TEntry['target'] } }\n      : Omit<AuditInput, 'action'>,\n  ) => AuditInput)\n  & {\n    readonly action: TAction\n    readonly target: TEntry['target']\n  }\n\n/**\n * The object returned by {@link defineAuditCatalog}. Mirrors\n * {@link ErrorCatalog} but each factory produces an {@link AuditInput}\n * (typically passed to `log.audit(...)`).\n */\nexport type AuditCatalog<TPrefix extends string, TMap extends AuditCatalogMap> =\n  & { [K in keyof TMap & string]: DefinedCatalogAudit<`${TPrefix}.${K}`, TMap[K]> }\n  & {\n    readonly _prefix: TPrefix\n    readonly _actions: ReadonlyArray<`${TPrefix}.${keyof TMap & string}`>\n  }\n\n/**\n * Define a bundle of audit actions that share a common prefix. The wire\n * `action` for each entry is `${prefix}.${KEY}`.\n *\n * Each entry produces a thin wrapper around {@link defineAuditAction} (target\n * type is fixed at definition time, action name is auto-prefixed).\n *\n * @example\n * ```ts\n * import { defineAuditCatalog } from 'evlog'\n *\n * export const billingAudit = defineAuditCatalog('billing', {\n *   INVOICE_REFUND: { target: 'invoice' },\n *   INVOICE_CREATE: { target: 'invoice' },\n * })\n *\n * declare module 'evlog' {\n *   interface RegisteredAuditCatalogs {\n *     billing: typeof billingAudit\n *   }\n * }\n *\n * log.audit(billingAudit.INVOICE_REFUND({\n *   actor: { type: 'user', id: u.id },\n *   target: { id: 'inv_889' },\n * }))\n * ```\n */\nexport function defineAuditCatalog<\n  const TPrefix extends string,\n  const TMap extends AuditCatalogMap,\n>(prefix: TPrefix, map: TMap): AuditCatalog<TPrefix, TMap> {\n  const out: Record<string, unknown> = {}\n  const actions: string[] = []\n\n  for (const key of Object.keys(map)) {\n    const action = `${prefix}.${key}`\n    const entry = map[key]\n    const fn = defineAuditAction(action, entry.target ? { target: entry.target } : undefined) as ((input: unknown) => AuditInput) & { action: string, target?: string }\n    Object.defineProperties(fn, {\n      action: { value: action, enumerable: true },\n      target: { value: entry.target, enumerable: true },\n    })\n    out[key] = fn\n    actions.push(action)\n  }\n\n  Object.defineProperties(out, {\n    _prefix: { value: prefix, enumerable: false },\n    _actions: { value: Object.freeze(actions), enumerable: false },\n  })\n\n  return out as AuditCatalog<TPrefix, TMap>\n}\n"],"mappings":";;;;;;;AAwFA,SAAS,gBACP,MACA,OACA,SACY;CAEZ,MAAM,EACJ,SAAS,iBACT,QACA,KACA,KACA,MACA,OACA,UAAU,cACV,GAAG,gBATQ,WAAW,EAAE;CAY1B,IAAI;AACJ,KAAI,OAAO,oBAAoB,SAC7B,WAAU;UACD,OAAO,MAAM,YAAY,WAClC,WAAW,MAAM,QAAmC,YAAY;KAEhE,EAAC,CAAE,WAAY;CAGjB,IAAI;AACJ,KAAI,MAAM,YAAY,aACpB,YAAW;EAAE,GAAI,MAAM,YAAY,EAAE;EAAG,GAAI,gBAAgB,EAAE;EAAG;AAGnE,QAAO,IAAI,WAAW;EACpB;EACA;EACA,QAAQ,UAAU,MAAM,UAAU;EAClC,KAAK,OAAO,MAAM;EAClB,KAAK,OAAO,MAAM;EAClB,MAAM,QAAQ,MAAM;EACb;EACP;EACD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCJ,SAAgB,YAGd,MAAa,OAA4C;CACzD,MAAM,YAAY,GAAG,SACnB,gBAAgB,MAAM,OAAO,KAAK,GAA0C;AAE9E,QAAO,iBAAiB,SAAS;EAC/B,MAAM;GAAE,OAAO;GAAM,YAAY;GAAM;EACvC,QAAQ;GAAE,OAAO,MAAM,UAAU;GAAK,YAAY;GAAM;EACxD,SAAS;GAAE,OAAO,MAAM;GAAS,YAAY;GAAM;EACnD,KAAK;GAAE,OAAO,MAAM;GAAK,YAAY;GAAM;EAC3C,KAAK;GAAE,OAAO,MAAM;GAAK,YAAY;GAAM;EAC3C,MAAM;GAAE,OAAO,MAAM;GAAM,YAAY;GAAM;EAC7C,MAAM;GAAE,OAAO,MAAM;GAAM,YAAY;GAAM;EAC7C,UAAU;GAAE,OAAO,MAAM;GAAU,YAAY;GAAM;EACtD,CAAC;AAEF,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDT,SAAgB,mBAGd,QAAiB,KAAwC;CACzD,MAAM,MAA+B,EAAE;CACvC,MAAM,QAAkB,EAAE;AAE1B,MAAK,MAAM,OAAO,OAAO,KAAK,IAAI,EAAE;EAClC,MAAM,OAAO,GAAG,OAAO,GAAG;AAC1B,MAAI,OAAO,YAAY,MAAM,IAAI,KAAK;AACtC,QAAM,KAAK,KAAK;;AAGlB,QAAO,iBAAiB,KAAK;EAC3B,SAAS;GAAE,OAAO;GAAQ,YAAY;GAAO;EAC7C,QAAQ;GAAE,OAAO,OAAO,OAAO,MAAM;GAAE,YAAY;GAAO;EAC3D,CAAC;AAEF,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkET,SAAgB,mBAGd,QAAiB,KAAwC;CACzD,MAAM,MAA+B,EAAE;CACvC,MAAM,UAAoB,EAAE;AAE5B,MAAK,MAAM,OAAO,OAAO,KAAK,IAAI,EAAE;EAClC,MAAM,SAAS,GAAG,OAAO,GAAG;EAC5B,MAAM,QAAQ,IAAI;EAClB,MAAM,KAAK,kBAAkB,QAAQ,MAAM,SAAS,EAAE,QAAQ,MAAM,QAAQ,GAAG,KAAA,EAAU;AACzF,SAAO,iBAAiB,IAAI;GAC1B,QAAQ;IAAE,OAAO;IAAQ,YAAY;IAAM;GAC3C,QAAQ;IAAE,OAAO,MAAM;IAAQ,YAAY;IAAM;GAClD,CAAC;AACF,MAAI,OAAO;AACX,UAAQ,KAAK,OAAO;;AAGtB,QAAO,iBAAiB,KAAK;EAC3B,SAAS;GAAE,OAAO;GAAQ,YAAY;GAAO;EAC7C,UAAU;GAAE,OAAO,OAAO,OAAO,QAAQ;GAAE,YAAY;GAAO;EAC/D,CAAC;AAEF,QAAO"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/catalog.ts"],"sourcesContent":["import type { AuditInput } from './audit'\nimport type { AuditTarget } from './types'\nimport { defineAuditAction } from './audit'\nimport { EvlogError } from './error'\n\n/**\n * Static metadata for a single entry in an error catalog.\n *\n * `message` is either a constant string or a function that receives required\n * params at the call site (typed). All other fields are templated defaults\n * that can be overridden at the call site.\n */\nexport interface ErrorCatalogEntry {\n  /** HTTP status code (default: 500). */\n  status?: number\n  /**\n   * Either a constant string or a typed function whose params become required\n   * arguments at the call site (`factory({ available, required })`).\n   */\n  message: string | ((params: never) => string)\n  /** Why this error occurred (technical reason). */\n  why?: string\n  /** Actionable fix shown to the user. */\n  fix?: string\n  /** Link to documentation. */\n  link?: string\n  /** Free-form metadata for grouping / filtering (not surfaced on the wire). */\n  tags?: readonly string[]\n  /**\n   * Backend-only context defaults. Merged with call-site `internal` (call-site wins).\n   */\n  internal?: Record<string, unknown>\n}\n\n/**\n * Subset of {@link import('./types').ErrorOptions} that callers may override\n * when invoking a catalog factory. `code` is always derived from the catalog\n * and intentionally excluded — pass `cause` here for error chaining.\n */\nexport interface ErrorFactoryOverrides {\n  message?: string\n  status?: number\n  why?: string\n  fix?: string\n  link?: string\n  internal?: Record<string, unknown>\n  cause?: Error\n}\n\n/** @internal Extract the params object type from a templated message function. */\ntype MessageParams<TMessage> = TMessage extends (params: infer P) => string ? P : Record<string, never>\n\n/**\n * Call-site argument type for a catalog factory:\n * - if `message` is a function: required params object merged with overrides\n * - if `message` is a string: optional overrides only\n */\nexport type ErrorFactoryOpts<TEntry extends ErrorCatalogEntry> =\n  TEntry['message'] extends (params: infer _P) => string\n    ? MessageParams<TEntry['message']> & ErrorFactoryOverrides\n    : ErrorFactoryOverrides\n\n/** @internal When message is a string, the call-site argument is optional. */\ntype FactoryArgs<TEntry extends ErrorCatalogEntry> =\n  TEntry['message'] extends (params: never) => string\n    ? [opts: ErrorFactoryOpts<TEntry>]\n    : [opts?: ErrorFactoryOpts<TEntry>]\n\n/**\n * A factory produced by {@link defineError} or each entry of\n * {@link defineErrorCatalog}. Calling it returns a fully-formed\n * {@link EvlogError} with the catalog's defaults applied. Static metadata\n * is exposed as readonly properties for introspection / refactor-safe\n * comparisons (`err.code === MyError.code`).\n */\nexport type DefinedError<TCode extends string, TEntry extends ErrorCatalogEntry> =\n  & ((...args: FactoryArgs<TEntry>) => EvlogError)\n  & {\n    readonly code: TCode\n    readonly status: number\n    readonly message: TEntry['message']\n    readonly why: TEntry['why']\n    readonly fix: TEntry['fix']\n    readonly link: TEntry['link']\n    readonly tags: TEntry['tags']\n    readonly internal: TEntry['internal']\n  }\n\nfunction buildEvlogError(\n  code: string,\n  entry: ErrorCatalogEntry,\n  rawArgs: Record<string, unknown> | undefined,\n): EvlogError {\n  const args = rawArgs ?? {}\n  const {\n    message: messageOverride,\n    status,\n    why,\n    fix,\n    link,\n    cause,\n    internal: callInternal,\n    ...maybeParams\n  } = args as ErrorFactoryOverrides & Record<string, unknown>\n\n  let message: string\n  if (typeof messageOverride === 'string') {\n    message = messageOverride\n  } else if (typeof entry.message === 'function') {\n    message = (entry.message as (p: unknown) => string)(maybeParams)\n  } else {\n    ({ message } = entry as { message: string })\n  }\n\n  let internal: Record<string, unknown> | undefined\n  if (entry.internal || callInternal) {\n    internal = { ...(entry.internal ?? {}), ...(callInternal ?? {}) }\n  }\n\n  return new EvlogError({\n    code,\n    message,\n    status: status ?? entry.status ?? 500,\n    why: why ?? entry.why,\n    fix: fix ?? entry.fix,\n    link: link ?? entry.link,\n    cause: cause as Error | undefined,\n    internal,\n  })\n}\n\n/**\n * Define a single, standalone error factory bound to a stable `code`.\n *\n * Each factory produces an {@link EvlogError} with the entry's defaults\n * applied. Call-site overrides (`cause`, `internal`, `message`, ...) are\n * shallow-merged onto those defaults.\n *\n * @example\n * ```ts\n * import { defineError } from 'evlog'\n *\n * export const PaymentDeclined = defineError('billing.PAYMENT_DECLINED', {\n *   status: 402,\n *   message: 'Card declined',\n *   why: 'Issuer declined the charge',\n *   fix: 'Try another card',\n * })\n *\n * throw PaymentDeclined()\n * throw PaymentDeclined({ cause: stripeErr, internal: { ref: 'ch_x' } })\n * ```\n *\n * @example Templated message with typed params\n * ```ts\n * export const InsufficientFunds = defineError('billing.INSUFFICIENT_FUNDS', {\n *   status: 402,\n *   message: ({ available, required }: { available: number, required: number }) =>\n *     `Insufficient funds: $${available}/$${required}`,\n * })\n *\n * throw InsufficientFunds({ available: 5, required: 100 })\n * ```\n */\nexport function defineError<\n  const TCode extends string,\n  const TEntry extends ErrorCatalogEntry,\n>(code: TCode, entry: TEntry): DefinedError<TCode, TEntry> {\n  const factory = ((...args: unknown[]) =>\n    buildEvlogError(code, entry, args[0] as Record<string, unknown> | undefined)) as unknown as DefinedError<TCode, TEntry>\n\n  Object.defineProperties(factory, {\n    code: { value: code, enumerable: true },\n    status: { value: entry.status ?? 500, enumerable: true },\n    message: { value: entry.message, enumerable: true },\n    why: { value: entry.why, enumerable: true },\n    fix: { value: entry.fix, enumerable: true },\n    link: { value: entry.link, enumerable: true },\n    tags: { value: entry.tags, enumerable: true },\n    internal: { value: entry.internal, enumerable: true },\n  })\n\n  return factory\n}\n\n/** Map of error catalog entries keyed by their (UPPER_SNAKE) name. */\nexport interface ErrorCatalogMap {\n  readonly [key: string]: ErrorCatalogEntry\n}\n\n/**\n * The object returned by {@link defineErrorCatalog}. Each map key becomes a\n * dot-accessed factory whose `code` is `${prefix}.${key}` (preserved casing).\n *\n * Catalog metadata (`_prefix`, `_codes`) is exposed as non-enumerable readonly\n * properties so it does not pollute iteration but is available for typing\n * (`declare module 'evlog'`) and runtime introspection.\n */\nexport type ErrorCatalog<TPrefix extends string, TMap extends ErrorCatalogMap> =\n  & { [K in keyof TMap & string]: DefinedError<`${TPrefix}.${K}`, TMap[K]> }\n  & {\n    readonly _prefix: TPrefix\n    readonly _codes: ReadonlyArray<`${TPrefix}.${keyof TMap & string}`>\n  }\n\n/**\n * Define a bundle of errors that share a common prefix. The wire `code` for\n * each entry is `${prefix}.${KEY}` (the key's casing is preserved — convention\n * is `UPPER_SNAKE_CASE`).\n *\n * Pair with `declare module 'evlog'` to surface autocomplete + literal-typed\n * `code` everywhere across the codebase.\n *\n * @example\n * ```ts\n * import { defineErrorCatalog } from 'evlog'\n *\n * export const billingErrors = defineErrorCatalog('billing', {\n *   PAYMENT_DECLINED: { status: 402, message: 'Card declined' },\n *   INSUFFICIENT_FUNDS: {\n *     status: 402,\n *     message: ({ available, required }: { available: number, required: number }) =>\n *       `Insufficient funds: $${available}/$${required}`,\n *   },\n * })\n *\n * declare module 'evlog' {\n *   interface RegisteredErrorCatalogs {\n *     billing: typeof billingErrors\n *   }\n * }\n *\n * throw billingErrors.PAYMENT_DECLINED()\n * throw billingErrors.INSUFFICIENT_FUNDS({ available: 5, required: 100 })\n * ```\n */\nexport function defineErrorCatalog<\n  const TPrefix extends string,\n  const TMap extends ErrorCatalogMap,\n>(prefix: TPrefix, map: TMap): ErrorCatalog<TPrefix, TMap> {\n  const out: Record<string, unknown> = {}\n  const codes: string[] = []\n\n  for (const key of Object.keys(map)) {\n    const code = `${prefix}.${key}`\n    out[key] = defineError(code, map[key])\n    codes.push(code)\n  }\n\n  Object.defineProperties(out, {\n    _prefix: { value: prefix, enumerable: false },\n    _codes: { value: Object.freeze(codes), enumerable: false },\n  })\n\n  return out as ErrorCatalog<TPrefix, TMap>\n}\n\n/** Static metadata for a single entry in an audit catalog. */\nexport interface AuditCatalogEntry {\n  /** Default `target.type` for every audit emitted from this action. */\n  target?: string\n}\n\n/** Map of audit catalog entries keyed by their (UPPER_SNAKE) name. */\nexport interface AuditCatalogMap {\n  readonly [key: string]: AuditCatalogEntry\n}\n\n/** A factory produced by an audit catalog entry. Returns an {@link AuditInput}. */\nexport type DefinedCatalogAudit<TAction extends string, TEntry extends AuditCatalogEntry> =\n  & ((\n    input: TEntry['target'] extends string\n      ? Omit<AuditInput, 'action' | 'target'> & { target?: Omit<AuditTarget, 'type'> & { type?: TEntry['target'] } }\n      : Omit<AuditInput, 'action'>,\n  ) => AuditInput)\n  & {\n    readonly action: TAction\n    readonly target: TEntry['target']\n  }\n\n/**\n * The object returned by {@link defineAuditCatalog}. Mirrors\n * {@link ErrorCatalog} but each factory produces an {@link AuditInput}\n * (typically passed to `log.audit(...)`).\n */\nexport type AuditCatalog<TPrefix extends string, TMap extends AuditCatalogMap> =\n  & { [K in keyof TMap & string]: DefinedCatalogAudit<`${TPrefix}.${K}`, TMap[K]> }\n  & {\n    readonly _prefix: TPrefix\n    readonly _actions: ReadonlyArray<`${TPrefix}.${keyof TMap & string}`>\n  }\n\n/**\n * Define a bundle of audit actions that share a common prefix. The wire\n * `action` for each entry is `${prefix}.${KEY}`.\n *\n * Each entry produces a thin wrapper around {@link defineAuditAction} (target\n * type is fixed at definition time, action name is auto-prefixed).\n *\n * @example\n * ```ts\n * import { defineAuditCatalog } from 'evlog'\n *\n * export const billingAudit = defineAuditCatalog('billing', {\n *   INVOICE_REFUND: { target: 'invoice' },\n *   INVOICE_CREATE: { target: 'invoice' },\n * })\n *\n * declare module 'evlog' {\n *   interface RegisteredAuditCatalogs {\n *     billing: typeof billingAudit\n *   }\n * }\n *\n * log.audit(billingAudit.INVOICE_REFUND({\n *   actor: { type: 'user', id: u.id },\n *   target: { id: 'inv_889' },\n * }))\n * ```\n */\nexport function defineAuditCatalog<\n  const TPrefix extends string,\n  const TMap extends AuditCatalogMap,\n>(prefix: TPrefix, map: TMap): AuditCatalog<TPrefix, TMap> {\n  const out: Record<string, unknown> = {}\n  const actions: string[] = []\n\n  for (const key of Object.keys(map)) {\n    const action = `${prefix}.${key}`\n    const entry = map[key]\n    const fn = defineAuditAction(action, entry.target ? { target: entry.target } : undefined) as ((input: unknown) => AuditInput) & { action: string, target?: string }\n    Object.defineProperties(fn, {\n      action: { value: action, enumerable: true },\n      target: { value: entry.target, enumerable: true },\n    })\n    out[key] = fn\n    actions.push(action)\n  }\n\n  Object.defineProperties(out, {\n    _prefix: { value: prefix, enumerable: false },\n    _actions: { value: Object.freeze(actions), enumerable: false },\n  })\n\n  return out as AuditCatalog<TPrefix, TMap>\n}\n"],"mappings":";;;;;;;AAwFA,SAAS,gBACP,MACA,OACA,SACY;CAEZ,MAAM,EACJ,SAAS,iBACT,QACA,KACA,KACA,MACA,OACA,UAAU,cACV,GAAG,gBATQ,WAAW,EAAE;CAY1B,IAAI;AACJ,KAAI,OAAO,oBAAoB,SAC7B,WAAU;UACD,OAAO,MAAM,YAAY,WAClC,WAAW,MAAM,QAAmC,YAAY;KAEhE,EAAC,CAAE,WAAY;CAGjB,IAAI;AACJ,KAAI,MAAM,YAAY,aACpB,YAAW;EAAE,GAAI,MAAM,YAAY,EAAE;EAAG,GAAI,gBAAgB,EAAE;EAAG;AAGnE,QAAO,IAAI,WAAW;EACpB;EACA;EACA,QAAQ,UAAU,MAAM,UAAU;EAClC,KAAK,OAAO,MAAM;EAClB,KAAK,OAAO,MAAM;EAClB,MAAM,QAAQ,MAAM;EACb;EACP;EACD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCJ,SAAgB,YAGd,MAAa,OAA4C;CACzD,MAAM,YAAY,GAAG,SACnB,gBAAgB,MAAM,OAAO,KAAK,GAA0C;AAE9E,QAAO,iBAAiB,SAAS;EAC/B,MAAM;GAAE,OAAO;GAAM,YAAY;GAAM;EACvC,QAAQ;GAAE,OAAO,MAAM,UAAU;GAAK,YAAY;GAAM;EACxD,SAAS;GAAE,OAAO,MAAM;GAAS,YAAY;GAAM;EACnD,KAAK;GAAE,OAAO,MAAM;GAAK,YAAY;GAAM;EAC3C,KAAK;GAAE,OAAO,MAAM;GAAK,YAAY;GAAM;EAC3C,MAAM;GAAE,OAAO,MAAM;GAAM,YAAY;GAAM;EAC7C,MAAM;GAAE,OAAO,MAAM;GAAM,YAAY;GAAM;EAC7C,UAAU;GAAE,OAAO,MAAM;GAAU,YAAY;GAAM;EACtD,CAAC;AAEF,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDT,SAAgB,mBAGd,QAAiB,KAAwC;CACzD,MAAM,MAA+B,EAAE;CACvC,MAAM,QAAkB,EAAE;AAE1B,MAAK,MAAM,OAAO,OAAO,KAAK,IAAI,EAAE;EAClC,MAAM,OAAO,GAAG,OAAO,GAAG;AAC1B,MAAI,OAAO,YAAY,MAAM,IAAI,KAAK;AACtC,QAAM,KAAK,KAAK;;AAGlB,QAAO,iBAAiB,KAAK;EAC3B,SAAS;GAAE,OAAO;GAAQ,YAAY;GAAO;EAC7C,QAAQ;GAAE,OAAO,OAAO,OAAO,MAAM;GAAE,YAAY;GAAO;EAC3D,CAAC;AAEF,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkET,SAAgB,mBAGd,QAAiB,KAAwC;CACzD,MAAM,MAA+B,EAAE;CACvC,MAAM,UAAoB,EAAE;AAE5B,MAAK,MAAM,OAAO,OAAO,KAAK,IAAI,EAAE;EAClC,MAAM,SAAS,GAAG,OAAO,GAAG;EAC5B,MAAM,QAAQ,IAAI;EAClB,MAAM,KAAK,kBAAkB,QAAQ,MAAM,SAAS,EAAE,QAAQ,MAAM,QAAQ,GAAG,KAAA,EAAU;AACzF,SAAO,iBAAiB,IAAI;GAC1B,QAAQ;IAAE,OAAO;IAAQ,YAAY;IAAM;GAC3C,QAAQ;IAAE,OAAO,MAAM;IAAQ,YAAY;IAAM;GAClD,CAAC;AACF,MAAI,OAAO;AACX,UAAQ,KAAK,OAAO;;AAGtB,QAAO,iBAAiB,KAAK;EAC3B,SAAS;GAAE,OAAO;GAAQ,YAAY;GAAO;EAC7C,UAAU;GAAE,OAAO,OAAO,OAAO,QAAQ;GAAE,YAAY;GAAO;EAC/D,CAAC;AAEF,QAAO"}

package/dist/{integration-DTZtjSqh.mjs → integration-Dhig7ae6.mjs}

@@ -1,5 +1,5 @@
 import { n as extractSafeNodeHeaders, t as extractSafeHeaders } from "./headers-CU-QqnYg.mjs";
-import { r as createMiddlewareLogger, t as attachForkToLogger } from "./fork-8u_zFOJq.mjs";
+import { r as createMiddlewareLogger, t as attachForkToLogger } from "./fork-Bga8x-X4.mjs";
 //#region src/shared/integration.ts
 function normalizeHeaders(headers) {
 	if (!headers) return void 0;
@@ -72,4 +72,4 @@ function defineFrameworkIntegration(spec) {
 //#endregion
 export { defineFrameworkIntegration as t };
 
-//# sourceMappingURL=integration-DTZtjSqh.mjs.map
+//# sourceMappingURL=integration-Dhig7ae6.mjs.map

package/dist/{integration-DTZtjSqh.mjs.map → integration-Dhig7ae6.mjs.map}

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

package/dist/{logger-DntcxxHg.d.mts → logger-CTcvd5Cc.d.mts}

@@ -1,6 +1,10 @@
-import { G as Log, I as DrainContext, R as EnvironmentContext, dt as PluginRunner, et as RequestLoggerOptions, ot as TailSamplingContext, q as LoggerConfig, u as AuditableLogger } from "./audit-CC8nfazi.mjs";
+import { G as Log, I as DrainContext, R as EnvironmentContext, dt as PluginRunner, et as RequestLoggerOptions, ot as TailSamplingContext, q as LoggerConfig, u as AuditableLogger } from "./audit-DVdkntSO.mjs";
 
 //#region src/logger.d.ts
+declare function mergeInto(target: Record<string, unknown>, source: Record<string, unknown>): void;
+/**
+ * @internal Wide-event field merge — exported for test mocks that mirror emit accumulation.
+ */
 /**
  * Initialize the logger with configuration.
  * Call this once at application startup.
@@ -110,5 +114,5 @@ declare function createRequestLogger<T extends object = Record<string, unknown>>
  */
 declare function getEnvironment(): EnvironmentContext;
 //#endregion
-export { getGlobalDrain as a, isEnabled as c, shouldKeep as d, getEnvironment as i, isLoggerLocked as l, createLogger as n, getGlobalPluginRunner as o, createRequestLogger as r, initLogger as s, _log as t, lockLogger as u };
-//# sourceMappingURL=logger-DntcxxHg.d.mts.map
+export { getGlobalDrain as a, isEnabled as c, mergeInto as d, shouldKeep as f, getEnvironment as i, isLoggerLocked as l, createLogger as n, getGlobalPluginRunner as o, createRequestLogger as r, initLogger as s, _log as t, lockLogger as u };
+//# sourceMappingURL=logger-CTcvd5Cc.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger-CTcvd5Cc.d.mts","names":[],"sources":["../src/logger.ts"],"mappings":";;;iBA4BS,SAAA,CAAU,MAAA,EAAQ,MAAA,mBAAyB,MAAA,EAAQ,MAAA;;;;;;;;iBAyC5C,UAAA,CAAW,MAAA,GAAQ,YAAA;AAAnC;;;;;AAAA,iBAsCgB,qBAAA,CAAA,GAAyB,YAAA;;;;iBAOzB,SAAA,CAAA;AAAhB;;;;;AAAA,iBASgB,UAAA,CAAA;;;;iBAOA,cAAA,CAAA;AAAhB;;;;;AAAA,iBASgB,cAAA,CAAA,KAAoB,GAAA,EAAK,YAAA,YAAwB,OAAA;;;;;iBA8BjD,UAAA,CAAW,GAAA,EAAK,mBAAA;;;;AAAhC;;;;;AAgBC;cAscK,IAAA,EAAM,GAAA;;;AAOU;UAqBZ,2BAAA;;;;;EAKR,WAAA;EAIa;;;EAAb,SAAA,IAAa,OAAA,EAAS,OAAA;AAAA;;;;;;;;;;;;;;;;iBAkBR,YAAA,oBAAgC,MAAA,kBAAA,CAAyB,cAAA,GAAgB,MAAA,mBAA8B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;AAuMvL;;;;;;;;;;;;;;;;;;;;AAeA;;;;;iBAfgB,mBAAA,oBAAuC,MAAA,kBAAA,CAAyB,OAAA,GAAS,oBAAA,EAA2B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;;iBAepK,cAAA,CAAA,GAAkB,kBAAA"}

package/dist/logger.d.mts

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

package/dist/logger.mjs

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

package/dist/{middleware-U-lIAzHg.d.mts → middleware-31KhtiEF.d.mts}

@@ -1,4 +1,4 @@
-import { $ as RequestLogger, I as DrainContext, L as EnrichContext, Y as RedactConfig, ct as WideEvent, dt as PluginRunner, ot as TailSamplingContext, tt as RouteConfig, ut as EvlogPlugin } from "./audit-CC8nfazi.mjs";
+import { $ as RequestLogger, I as DrainContext, L as EnrichContext, Y as RedactConfig, ct as WideEvent, dt as PluginRunner, ot as TailSamplingContext, tt as RouteConfig, ut as EvlogPlugin } from "./audit-DVdkntSO.mjs";
 
 //#region src/shared/middleware.d.ts
 /**
@@ -69,4 +69,4 @@ declare function runEnrichAndDrain(emittedEvent: WideEvent, options: MiddlewareL
 declare function createMiddlewareLogger(options: MiddlewareLoggerOptions): MiddlewareLoggerResult;
 //#endregion
 export { resolveMiddlewarePluginRunner as a, createMiddlewareLogger as i, MiddlewareLoggerOptions as n, runEnrichAndDrain as o, MiddlewareLoggerResult as r, BaseEvlogOptions as t };
-//# sourceMappingURL=middleware-U-lIAzHg.d.mts.map
+//# sourceMappingURL=middleware-31KhtiEF.d.mts.map

package/dist/{middleware-U-lIAzHg.d.mts.map → middleware-31KhtiEF.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"middleware-U-lIAzHg.d.mts","names":[],"sources":["../src/shared/middleware.ts"],"mappings":";;;;AAYA;;;UAAiB,gBAAA;EAMN;EAJT,OAAA;EAMsC;EAJtC,OAAA;EAMwC;EAJxC,MAAA,GAAS,MAAA,SAAe,WAAA;EAMoB;EAJ5C,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAW5B;EATV,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EASnB;EAPrB,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;EAR5C;;;;EAaA,MAAA,aAAmB,YAAA;EATL;EAWd,OAAA,GAAU,WAAA;AAAA;;UAIK,uBAAA,SAAgC,gBAAA;EAC/C,MAAA;EACA,IAAA;EACA,SAAA;EAda;EAgBb,OAAA,GAAU,MAAA;AAAA;AAAA,UAGK,sBAAA;EACf,MAAA,EAAQ,aAAA;EACR,MAAA,GAAS,IAAA;IAAS,MAAA;IAAiB,KAAA,GAAQ,KAAA;EAAA,MAAY,OAAA,CAAQ,SAAA;EAC/D,OAAA;AAAA;;;;;iBA6Bc,6BAAA,CAA8B,OAAA;EAAW,OAAA,GAAU,WAAA;AAAA,IAAkB,YAAA;;;;AAhCrF;iBAuDsB,iBAAA,CACpB,YAAA,EAAc,SAAA,EACd,OAAA,EAAS,uBAAA,EACT,WAAA;EAAe,MAAA;EAAgB,IAAA;EAAc,SAAA;AAAA,GAC7C,cAAA,WACA,OAAA,GAAU,YAAA,GACT,OAAA;;;;;;;;;iBA8Da,sBAAA,CAAuB,OAAA,EAAS,uBAAA,GAA0B,sBAAA"}
+{"version":3,"file":"middleware-31KhtiEF.d.mts","names":[],"sources":["../src/shared/middleware.ts"],"mappings":";;;;AAYA;;;UAAiB,gBAAA;EAMN;EAJT,OAAA;EAMsC;EAJtC,OAAA;EAMwC;EAJxC,MAAA,GAAS,MAAA,SAAe,WAAA;EAMoB;EAJ5C,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAW5B;EATV,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EASnB;EAPrB,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;EAR5C;;;;EAaA,MAAA,aAAmB,YAAA;EATL;EAWd,OAAA,GAAU,WAAA;AAAA;;UAIK,uBAAA,SAAgC,gBAAA;EAC/C,MAAA;EACA,IAAA;EACA,SAAA;EAda;EAgBb,OAAA,GAAU,MAAA;AAAA;AAAA,UAGK,sBAAA;EACf,MAAA,EAAQ,aAAA;EACR,MAAA,GAAS,IAAA;IAAS,MAAA;IAAiB,KAAA,GAAQ,KAAA;EAAA,MAAY,OAAA,CAAQ,SAAA;EAC/D,OAAA;AAAA;;;;;iBA8Bc,6BAAA,CAA8B,OAAA;EAAW,OAAA,GAAU,WAAA;AAAA,IAAkB,YAAA;;;;AAjCrF;iBAwDsB,iBAAA,CACpB,YAAA,EAAc,SAAA,EACd,OAAA,EAAS,uBAAA,EACT,WAAA;EAAe,MAAA;EAAgB,IAAA;EAAc,SAAA;AAAA,GAC7C,cAAA,WACA,OAAA,GAAU,YAAA,GACT,OAAA;;;;;;;;;iBA8Da,sBAAA,CAAuB,OAAA,EAAS,uBAAA,GAA0B,sBAAA"}

package/dist/nestjs/index.d.mts

@@ -1,5 +1,5 @@
-import { $ as RequestLogger } from "../audit-CC8nfazi.mjs";
-import { t as BaseEvlogOptions } from "../middleware-U-lIAzHg.mjs";
+import { $ as RequestLogger } from "../audit-DVdkntSO.mjs";
+import { t as BaseEvlogOptions } from "../middleware-31KhtiEF.mjs";
 import { DynamicModule, MiddlewareConsumer, NestModule } from "@nestjs/common";
 
 //#region src/nestjs/index.d.ts

package/dist/nestjs/index.mjs

@@ -1,7 +1,7 @@
 import { n as extractSafeNodeHeaders } from "../headers-CU-QqnYg.mjs";
-import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-8u_zFOJq.mjs";
+import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-Bga8x-X4.mjs";
 import { t as bindNodeResponseLifecycle } from "../nodeResponse-BkkionWl.mjs";
-import { t as createLoggerStorage } from "../storage-Dwinmg8P.mjs";
+import { t as createLoggerStorage } from "../storage-BNubsWwz.mjs";
 //#region src/nestjs/index.ts
 const { storage, useLogger } = createLoggerStorage("middleware context. Make sure EvlogModule.forRoot() is imported in your AppModule.");
 function createEvlogMiddleware(getOptions) {

package/dist/next/client.d.mts

@@ -1,4 +1,4 @@
-import { K as LogLevel, st as TransportConfig } from "../audit-CC8nfazi.mjs";
+import { K as LogLevel, st as TransportConfig } from "../audit-DVdkntSO.mjs";
 import { clearIdentity, log as _clientLog, setIdentity, setMinLevel } from "../runtime/client/log.mjs";
 import * as _$react from "react";
 

package/dist/next/index.d.mts

@@ -1,7 +1,7 @@
-import { $ as RequestLogger, G as Log, K as LogLevel, R as EnvironmentContext, nt as SamplingConfig } from "../audit-CC8nfazi.mjs";
-import { n as createError } from "../error-CpbbtyXL.mjs";
-import { t as _log } from "../logger-DntcxxHg.mjs";
-import { t as BaseEvlogOptions } from "../middleware-U-lIAzHg.mjs";
+import { $ as RequestLogger, G as Log, K as LogLevel, R as EnvironmentContext, nt as SamplingConfig } from "../audit-DVdkntSO.mjs";
+import { n as createError } from "../error-CVtn5U7b.mjs";
+import { t as _log } from "../logger-CTcvd5Cc.mjs";
+import { t as BaseEvlogOptions } from "../middleware-31KhtiEF.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/next/types.d.ts
@@ -89,6 +89,7 @@ type NextRequest = {
 type NextResponse = {
   headers: {
     set(name: string, value: string): void;
+    get(name: string): string | null;
   };
 };
 /**
@@ -128,7 +129,7 @@ declare function evlogMiddleware(config?: EvlogMiddlewareConfig): (request: Next
  *   },
  *   drain: pipeline(createAxiomDrain({
  *     dataset: 'logs',
- *     token: process.env.AXIOM_TOKEN!,
+ *     apiKey: process.env.AXIOM_API_KEY!,
  *   })),
  *   enrich: (ctx) => {
  *     ctx.event.deploymentId = process.env.VERCEL_DEPLOYMENT_ID

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/next/types.ts","../../src/next/storage.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"mappings":";;;;;;;UAGiB,gBAAA,SAAyB,gBAAA;;;;;EAKxC,OAAA;EALe;;;EAUf,GAAA,GAAM,OAAA,CAAQ,kBAAA;EAAR;;;;EAMN,MAAA;EAhBwD;;;;EAsBxD,OAAA;EAZc;;;EAiBd,QAAA,GAAW,cAAA;EAAA;;;;EAMX,QAAA,GAAW,QAAA;EAaL;;AAGR;;EAVE,SAAA;EAeA;;;;;EARA,MAAA;AAAA;AAAA,UAGe,qBAAA;EChC4B;;;;EDqC3C,OAAA;ECrCwB;;;;ED2CxB,OAAA;AAAA;;;;;;;;AA5DF;;;;;;;;;;iBCiBgB,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,aAAA,CAAc,CAAA;;;KCjBlF,WAAA;EACH,OAAA;IAAW,QAAA;EAAA;EACX,OAAA;IAAW,GAAA,CAAI,IAAA;EAAA;AAAA;AAAA,KAGZ,YAAA;EACH,OAAA;IAAW,GAAA,CAAI,IAAA,UAAc,KAAA;EAAA;AAAA;;;;;;;;;;;;;;iBAoBf,eAAA,CAAgB,MAAA,GAAS,qBAAA,IACzB,OAAA,EAAS,WAAA,KAAW,OAAA,CAAA,YAAA;;;AF3BpC;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA;;;;AAjDA,iBGuCgB,WAAA,CAAY,OAAA,GAAS,gBAAA;6DAW+3E,IAAA,EAAA,KAAA,KAAA,OAAA,SAAkC,IAAA,EAAA,KAAA,KAAA,OAAA,CAAA,OAAA,CAAA,OAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/next/types.ts","../../src/next/storage.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"mappings":";;;;;;;UAGiB,gBAAA,SAAyB,gBAAA;;;;;EAKxC,OAAA;EALe;;;EAUf,GAAA,GAAM,OAAA,CAAQ,kBAAA;EAAR;;;;EAMN,MAAA;EAhBwD;;;;EAsBxD,OAAA;EAZc;;;EAiBd,QAAA,GAAW,cAAA;EAAA;;;;EAMX,QAAA,GAAW,QAAA;EAaL;;AAGR;;EAVE,SAAA;EAeA;;;;;EARA,MAAA;AAAA;AAAA,UAGe,qBAAA;EChC4B;;;;EDqC3C,OAAA;ECrCwB;;;;ED2CxB,OAAA;AAAA;;;;;;;;AA5DF;;;;;;;;;;iBCiBgB,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,aAAA,CAAc,CAAA;;;KCjBlF,WAAA;EACH,OAAA;IAAW,QAAA;EAAA;EACX,OAAA;IAAW,GAAA,CAAI,IAAA;EAAA;AAAA;AAAA,KAGZ,YAAA;EACH,OAAA;IACE,GAAA,CAAI,IAAA,UAAc,KAAA;IAClB,GAAA,CAAI,IAAA;EAAA;AAAA;;;;;;;;;;;;;;iBAqBQ,eAAA,CAAgB,MAAA,GAAS,qBAAA,IACzB,OAAA,EAAS,WAAA,KAAW,OAAA,CAAA,YAAA;;;AF9BpC;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA;;;;AAjDA,iBGuCgB,WAAA,CAAY,OAAA,GAAS,gBAAA;6DAW43E,IAAA,EAAA,KAAA,KAAA,OAAA,SAAkC,IAAA,EAAA,KAAA,KAAA,OAAA,CAAA,OAAA,CAAA,OAAA"}

package/dist/next/index.mjs

@@ -1,8 +1,8 @@
-import { S as isLoggerLocked, b as initLogger, g as createRequestLogger, m as _log, v as getGlobalDrain, x as isEnabled } from "../audit-pV5aLGP0.mjs";
+import { S as isLoggerLocked, b as initLogger, g as createRequestLogger, m as _log, v as getGlobalDrain, x as isEnabled } from "../audit-BUI3af4w.mjs";
 import { filterSafeHeaders } from "../utils.mjs";
 import { EvlogError, createError } from "../error.mjs";
 import { n as shouldLog, t as getServiceForPath } from "../routes-CnIgYWf8.mjs";
-import { t as attachForkToLogger } from "../fork-8u_zFOJq.mjs";
+import { t as attachForkToLogger } from "../fork-Bga8x-X4.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/next/storage.ts
 const evlogStorage = new AsyncLocalStorage();
@@ -272,7 +272,7 @@ function evlogMiddleware(config) {
 *   },
 *   drain: pipeline(createAxiomDrain({
 *     dataset: 'logs',
-*     token: process.env.AXIOM_TOKEN!,
+*     apiKey: process.env.AXIOM_API_KEY!,
 *   })),
 *   enrich: (ctx) => {
 *     ctx.event.deploymentId = process.env.VERCEL_DEPLOYMENT_ID

package/dist/next/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/next/storage.ts","../../src/next/handler.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\n\nexport const evlogStorage = new AsyncLocalStorage<RequestLogger>()\n\n/**\n * Get the current request-scoped logger.\n * Must be called inside a `withEvlog()` wrapper.\n *\n * @throws {Error} if called outside of `withEvlog()` context\n *\n * @example\n * ```ts\n * export const POST = withEvlog(async (request) => {\n *   const log = useLogger()\n *   log.set({ user: { id: '123' } })\n *   return Response.json({ ok: true })\n * })\n * ```\n */\nexport function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n  const logger = evlogStorage.getStore()\n  if (!logger) {\n    throw new Error(\n      '[evlog] useLogger() was called outside of a withEvlog() context. '\n      + 'Wrap your route handler or server action with withEvlog().',\n    )\n  }\n  return logger as RequestLogger<T>\n}\n","import type { DrainContext, EnrichContext, TailSamplingContext, WideEvent } from '../types'\nimport { createRequestLogger, getGlobalDrain, initLogger, isEnabled, isLoggerLocked } from '../logger'\nimport { attachForkToLogger } from '../shared/fork'\nimport type { MiddlewareLoggerOptions } from '../shared/middleware'\nimport { shouldLog, getServiceForPath } from '../shared/routes'\nimport { filterSafeHeaders } from '../utils'\nimport { EvlogError } from '../error'\nimport type { NextEvlogOptions } from './types'\nimport { evlogStorage } from './storage'\n\ninterface WithEvlogState {\n  initialized: boolean\n  options: NextEvlogOptions\n}\n\nconst state: WithEvlogState = {\n  initialized: false,\n  options: {},\n}\n\nexport function configureHandler(options: NextEvlogOptions): void {\n  state.options = options\n  state.initialized = true\n\n  // Skip if instrumentation register() already configured the logger.\n  // Re-initializing would wipe the global drain.\n  if (isLoggerLocked()) return\n\n  // Don't pass drain to initLogger — the global drain fires inside emitWideEvent\n  // which doesn't have request/header context. Instead, we call drain ourselves\n  // in callEnrichAndDrain after enrich, with full context.\n  initLogger({\n    enabled: options.enabled,\n    env: {\n      service: options.service,\n      ...options.env,\n    },\n    pretty: options.pretty,\n    silent: options.silent,\n    sampling: options.sampling,\n    minLevel: options.minLevel,\n    stringify: options.stringify,\n    _suppressDrainWarning: true,\n  })\n}\n\nfunction extractRequestInfo(request: Request): { method: string, path: string, headers: Record<string, string> } {\n  const { method } = request\n  const url = new URL(request.url, 'http://localhost')\n  const path = url.pathname\n\n  const headers: Record<string, string> = {}\n  request.headers.forEach((value, key) => {\n    headers[key] = value\n  })\n\n  return { method, path, headers: filterSafeHeaders(headers) }\n}\n\nasync function callEnrichAndDrain(\n  emittedEvent: WideEvent | null,\n  requestInfo: { method: string, path: string, requestId: string },\n  headers: Record<string, string>,\n  responseStatus?: number,\n): Promise<void> {\n  if (!emittedEvent) return\n\n  const { enrich } = state.options\n  const drain = state.options.drain ?? getGlobalDrain()\n\n  const run = async () => {\n    if (enrich) {\n      const enrichCtx: EnrichContext = {\n        event: emittedEvent,\n        request: requestInfo,\n        headers,\n        response: { status: responseStatus },\n      }\n      try {\n        await enrich(enrichCtx)\n      } catch (err) {\n        console.error('[evlog] enrich failed:', err)\n      }\n    }\n\n    if (drain) {\n      const drainCtx: DrainContext = {\n        event: emittedEvent,\n        request: requestInfo,\n        headers,\n      }\n      try {\n        await drain(drainCtx)\n      } catch (err) {\n        console.error('[evlog] drain failed:', err)\n      }\n    }\n  }\n\n  // Use next/server after() if available to run enrich+drain after response\n  try {\n    const { after } = await import('next/server')\n    if (typeof after === 'function') {\n      after(run)\n      return\n    }\n  } catch {\n    // next/server not available or after() not exported — run inline\n  }\n\n  // Fallback: fire-and-forget (enrich still awaited for correctness)\n  run().catch(() => {})\n}\n\n/**\n * Wrap a Next.js route handler or server action with evlog request-scoped logging.\n *\n * @example\n * ```ts\n * // Route handler\n * export const POST = withEvlog(async (request: NextRequest) => {\n *   const log = useLogger()\n *   log.set({ user: { id: '123' } })\n *   return Response.json({ success: true })\n * })\n *\n * // Server action\n * export const checkout = withEvlog(async (formData: FormData) => {\n *   const log = useLogger()\n *   log.set({ action: 'checkout' })\n * })\n * ```\n */\nexport function createWithEvlog(options: NextEvlogOptions) {\n  configureHandler(options)\n\n  return function withEvlog<TArgs extends unknown[], TReturn>(\n    handler: (...args: TArgs) => TReturn,\n  ): (...args: TArgs) => Promise<Awaited<TReturn>> {\n    return async (...args: TArgs): Promise<Awaited<TReturn>> => {\n      if (!isEnabled()) {\n        return await handler(...args) as Awaited<TReturn>\n      }\n\n      // Extract request info from first argument if it's a Request\n      const [firstArg] = args\n      const isRequest = firstArg instanceof Request\n\n      let method = 'UNKNOWN'\n      let path = '/'\n      let headers: Record<string, string> = {}\n      let requestId = crypto.randomUUID()\n\n      if (isRequest) {\n        ({ method, path, headers } = extractRequestInfo(firstArg))\n\n        // Reuse request-id from middleware if present\n        const middlewareRequestId = firstArg.headers.get('x-request-id')\n        if (middlewareRequestId) requestId = middlewareRequestId\n      }\n\n      // Check include/exclude patterns\n      if (!shouldLog(path, state.options.include, state.options.exclude)) {\n        return await handler(...args) as Awaited<TReturn>\n      }\n\n      const logger = createRequestLogger({ method, path, requestId }, { _deferDrain: true })\n\n      const middlewareOpts: MiddlewareLoggerOptions = {\n        method,\n        path,\n        requestId,\n        headers,\n        include: state.options.include,\n        exclude: state.options.exclude,\n        routes: state.options.routes,\n        drain: state.options.drain,\n        enrich: state.options.enrich,\n        keep: state.options.keep,\n        redact: state.options.redact,\n      }\n      attachForkToLogger(evlogStorage, logger, middlewareOpts)\n\n      // Apply route-based service configuration\n      const routeService = getServiceForPath(path, state.options.routes)\n      if (routeService) {\n        logger.set({ service: routeService })\n      }\n\n      // Apply start time from middleware if present\n      if (isRequest) {\n        const startHeader = firstArg.headers.get('x-evlog-start')\n        if (startHeader) {\n          logger.set({ middlewareStart: Number(startHeader) })\n        }\n      }\n\n      try {\n        const result = await evlogStorage.run(logger, () => handler(...args))\n\n        // Extract response status\n        let { status } = { status: 200 }\n        if (result instanceof Response) {\n          ({ status } = result)\n        }\n        logger.set({ status })\n\n        // Build tail sampling context and call keep callback\n        let forceKeep = false\n        if (state.options.keep) {\n          try {\n            const tailCtx: TailSamplingContext = {\n              status,\n              path,\n              method,\n              context: logger.getContext(),\n              shouldKeep: false,\n            }\n            await state.options.keep(tailCtx)\n            forceKeep = tailCtx.shouldKeep ?? false\n          } catch (err) {\n            console.error('[evlog] keep callback failed:', err)\n          }\n        }\n\n        const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n        await callEnrichAndDrain(emittedEvent, { method, path, requestId }, headers, status)\n\n        return result as Awaited<TReturn>\n      } catch (error) {\n        logger.error(error instanceof Error ? error : new Error(String(error)))\n\n        const errorStatus = (error as { status?: number }).status\n          ?? (error as { statusCode?: number }).statusCode\n          ?? 500\n        logger.set({ status: errorStatus })\n\n        // Build tail sampling context and call keep callback\n        let forceKeep = false\n        if (state.options.keep) {\n          try {\n            const tailCtx: TailSamplingContext = {\n              status: errorStatus,\n              path,\n              method,\n              context: logger.getContext(),\n              shouldKeep: false,\n            }\n            await state.options.keep(tailCtx)\n            forceKeep = tailCtx.shouldKeep ?? false\n          } catch (err) {\n            console.error('[evlog] keep callback failed:', err)\n          }\n        }\n\n        const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n        await callEnrichAndDrain(emittedEvent, { method, path, requestId }, headers, errorStatus)\n\n        // Return structured JSON response for EvlogErrors (like H3 does for Nuxt)\n        if (isRequest && error instanceof EvlogError) {\n          return Response.json(error.toJSON(), { status: error.status }) as Awaited<TReturn>\n        }\n\n        throw error\n      }\n    }\n  }\n}\n","import { shouldLog } from '../shared/routes'\nimport type { EvlogMiddlewareConfig } from './types'\n\ntype NextRequest = {\n  nextUrl: { pathname: string }\n  headers: { get(name: string): string | null }\n}\n\ntype NextResponse = {\n  headers: { set(name: string, value: string): void }\n}\n\ntype NextResponseStatic = {\n  next(options?: { request?: { headers: Headers } }): NextResponse\n}\n\n/**\n * Create an evlog middleware for Next.js.\n * Sets `x-request-id` and `x-evlog-start` headers so `withEvlog()` can reuse them\n * for timing consistency across the middleware -> handler chain.\n *\n * @example\n * ```ts\n * // middleware.ts\n * import { evlogMiddleware } from 'evlog/next'\n * export const middleware = evlogMiddleware()\n * export const config = { matcher: ['/api/:path*'] }\n * ```\n */\nexport function evlogMiddleware(config?: EvlogMiddlewareConfig) {\n  return async (request: NextRequest) => {\n    const path = request.nextUrl.pathname\n\n    // Check include/exclude patterns\n    if (!shouldLog(path, config?.include, config?.exclude)) {\n      const { NextResponse: nextResponse } = await import('next/server') as { NextResponse: NextResponseStatic }\n      return nextResponse.next()\n    }\n\n    // Generate or reuse request ID\n    const existingId = request.headers.get('x-request-id')\n    const requestId = existingId || crypto.randomUUID()\n\n    // Forward modified headers to the route handler\n    const requestHeaders = new Headers(request.headers as HeadersInit)\n\n    requestHeaders.set('x-request-id', requestId)\n    requestHeaders.set('x-evlog-start', String(Date.now()))\n\n    const { NextResponse: nextResponse } = await import('next/server') as { NextResponse: NextResponseStatic }\n    const response = nextResponse.next({\n      request: { headers: requestHeaders },\n    })\n\n    // Also set on response for downstream consumers\n    response.headers.set('x-request-id', requestId)\n\n    return response\n  }\n}\n","import { log } from '../logger'\nimport { createError, createEvlogError } from '../error'\nimport type { NextEvlogOptions } from './types'\nimport { createWithEvlog } from './handler'\nimport { useLogger } from './storage'\n\nexport type { NextEvlogOptions, EvlogMiddlewareConfig } from './types'\n\nexport { evlogMiddleware } from './middleware'\nexport { useLogger } from './storage'\nexport { log } from '../logger'\nexport { createError, createEvlogError } from '../error'\n\n/**\n * Create an evlog instance configured for Next.js.\n * Returns all helpers needed for server-side logging.\n *\n * @example\n * ```ts\n * // lib/evlog.ts\n * import { createEvlog } from 'evlog/next'\n * import { createAxiomDrain } from 'evlog/axiom'\n * import { createDrainPipeline } from 'evlog/pipeline'\n *\n * const pipeline = createDrainPipeline({ batch: { size: 50 } })\n *\n * export const { withEvlog, useLogger, log, createEvlogError } = createEvlog({\n *   service: 'my-app',\n *   sampling: {\n *     rates: { info: 10 },\n *     keep: [{ status: 400 }, { duration: 1000 }],\n *   },\n *   drain: pipeline(createAxiomDrain({\n *     dataset: 'logs',\n *     token: process.env.AXIOM_TOKEN!,\n *   })),\n *   enrich: (ctx) => {\n *     ctx.event.deploymentId = process.env.VERCEL_DEPLOYMENT_ID\n *   },\n * })\n * ```\n */\nexport function createEvlog(options: NextEvlogOptions = {}) {\n  const withEvlog = createWithEvlog(options)\n\n  return {\n    withEvlog,\n    useLogger,\n    log,\n    createError,\n    createEvlogError,\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/next/storage.ts","../../src/next/handler.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\n\nexport const evlogStorage = new AsyncLocalStorage<RequestLogger>()\n\n/**\n * Get the current request-scoped logger.\n * Must be called inside a `withEvlog()` wrapper.\n *\n * @throws {Error} if called outside of `withEvlog()` context\n *\n * @example\n * ```ts\n * export const POST = withEvlog(async (request) => {\n *   const log = useLogger()\n *   log.set({ user: { id: '123' } })\n *   return Response.json({ ok: true })\n * })\n * ```\n */\nexport function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n  const logger = evlogStorage.getStore()\n  if (!logger) {\n    throw new Error(\n      '[evlog] useLogger() was called outside of a withEvlog() context. '\n      + 'Wrap your route handler or server action with withEvlog().',\n    )\n  }\n  return logger as RequestLogger<T>\n}\n","import type { DrainContext, EnrichContext, TailSamplingContext, WideEvent } from '../types'\nimport { createRequestLogger, getGlobalDrain, initLogger, isEnabled, isLoggerLocked } from '../logger'\nimport { attachForkToLogger } from '../shared/fork'\nimport type { MiddlewareLoggerOptions } from '../shared/middleware'\nimport { shouldLog, getServiceForPath } from '../shared/routes'\nimport { filterSafeHeaders } from '../utils'\nimport { EvlogError } from '../error'\nimport type { NextEvlogOptions } from './types'\nimport { evlogStorage } from './storage'\n\ninterface WithEvlogState {\n  initialized: boolean\n  options: NextEvlogOptions\n}\n\nconst state: WithEvlogState = {\n  initialized: false,\n  options: {},\n}\n\nexport function configureHandler(options: NextEvlogOptions): void {\n  state.options = options\n  state.initialized = true\n\n  // Skip if instrumentation register() already configured the logger.\n  // Re-initializing would wipe the global drain.\n  if (isLoggerLocked()) return\n\n  // Don't pass drain to initLogger — the global drain fires inside emitWideEvent\n  // which doesn't have request/header context. Instead, we call drain ourselves\n  // in callEnrichAndDrain after enrich, with full context.\n  initLogger({\n    enabled: options.enabled,\n    env: {\n      service: options.service,\n      ...options.env,\n    },\n    pretty: options.pretty,\n    silent: options.silent,\n    sampling: options.sampling,\n    minLevel: options.minLevel,\n    stringify: options.stringify,\n    _suppressDrainWarning: true,\n  })\n}\n\nfunction extractRequestInfo(request: Request): { method: string, path: string, headers: Record<string, string> } {\n  const { method } = request\n  const url = new URL(request.url, 'http://localhost')\n  const path = url.pathname\n\n  const headers: Record<string, string> = {}\n  request.headers.forEach((value, key) => {\n    headers[key] = value\n  })\n\n  return { method, path, headers: filterSafeHeaders(headers) }\n}\n\nasync function callEnrichAndDrain(\n  emittedEvent: WideEvent | null,\n  requestInfo: { method: string, path: string, requestId: string },\n  headers: Record<string, string>,\n  responseStatus?: number,\n): Promise<void> {\n  if (!emittedEvent) return\n\n  const { enrich } = state.options\n  const drain = state.options.drain ?? getGlobalDrain()\n\n  const run = async () => {\n    if (enrich) {\n      const enrichCtx: EnrichContext = {\n        event: emittedEvent,\n        request: requestInfo,\n        headers,\n        response: { status: responseStatus },\n      }\n      try {\n        await enrich(enrichCtx)\n      } catch (err) {\n        console.error('[evlog] enrich failed:', err)\n      }\n    }\n\n    if (drain) {\n      const drainCtx: DrainContext = {\n        event: emittedEvent,\n        request: requestInfo,\n        headers,\n      }\n      try {\n        await drain(drainCtx)\n      } catch (err) {\n        console.error('[evlog] drain failed:', err)\n      }\n    }\n  }\n\n  // Use next/server after() if available to run enrich+drain after response\n  try {\n    const { after } = await import('next/server')\n    if (typeof after === 'function') {\n      after(run)\n      return\n    }\n  } catch {\n    // next/server not available or after() not exported — run inline\n  }\n\n  // Fallback: fire-and-forget (enrich still awaited for correctness)\n  run().catch(() => {})\n}\n\n/**\n * Wrap a Next.js route handler or server action with evlog request-scoped logging.\n *\n * @example\n * ```ts\n * // Route handler\n * export const POST = withEvlog(async (request: NextRequest) => {\n *   const log = useLogger()\n *   log.set({ user: { id: '123' } })\n *   return Response.json({ success: true })\n * })\n *\n * // Server action\n * export const checkout = withEvlog(async (formData: FormData) => {\n *   const log = useLogger()\n *   log.set({ action: 'checkout' })\n * })\n * ```\n */\nexport function createWithEvlog(options: NextEvlogOptions) {\n  configureHandler(options)\n\n  return function withEvlog<TArgs extends unknown[], TReturn>(\n    handler: (...args: TArgs) => TReturn,\n  ): (...args: TArgs) => Promise<Awaited<TReturn>> {\n    return async (...args: TArgs): Promise<Awaited<TReturn>> => {\n      if (!isEnabled()) {\n        return await handler(...args) as Awaited<TReturn>\n      }\n\n      // Extract request info from first argument if it's a Request\n      const [firstArg] = args\n      const isRequest = firstArg instanceof Request\n\n      let method = 'UNKNOWN'\n      let path = '/'\n      let headers: Record<string, string> = {}\n      let requestId = crypto.randomUUID()\n\n      if (isRequest) {\n        ({ method, path, headers } = extractRequestInfo(firstArg))\n\n        // Reuse request-id from middleware if present\n        const middlewareRequestId = firstArg.headers.get('x-request-id')\n        if (middlewareRequestId) requestId = middlewareRequestId\n      }\n\n      // Check include/exclude patterns\n      if (!shouldLog(path, state.options.include, state.options.exclude)) {\n        return await handler(...args) as Awaited<TReturn>\n      }\n\n      const logger = createRequestLogger({ method, path, requestId }, { _deferDrain: true })\n\n      const middlewareOpts: MiddlewareLoggerOptions = {\n        method,\n        path,\n        requestId,\n        headers,\n        include: state.options.include,\n        exclude: state.options.exclude,\n        routes: state.options.routes,\n        drain: state.options.drain,\n        enrich: state.options.enrich,\n        keep: state.options.keep,\n        redact: state.options.redact,\n      }\n      attachForkToLogger(evlogStorage, logger, middlewareOpts)\n\n      // Apply route-based service configuration\n      const routeService = getServiceForPath(path, state.options.routes)\n      if (routeService) {\n        logger.set({ service: routeService })\n      }\n\n      // Apply start time from middleware if present\n      if (isRequest) {\n        const startHeader = firstArg.headers.get('x-evlog-start')\n        if (startHeader) {\n          logger.set({ middlewareStart: Number(startHeader) })\n        }\n      }\n\n      try {\n        const result = await evlogStorage.run(logger, () => handler(...args))\n\n        // Extract response status\n        let { status } = { status: 200 }\n        if (result instanceof Response) {\n          ({ status } = result)\n        }\n        logger.set({ status })\n\n        // Build tail sampling context and call keep callback\n        let forceKeep = false\n        if (state.options.keep) {\n          try {\n            const tailCtx: TailSamplingContext = {\n              status,\n              path,\n              method,\n              context: logger.getContext(),\n              shouldKeep: false,\n            }\n            await state.options.keep(tailCtx)\n            forceKeep = tailCtx.shouldKeep ?? false\n          } catch (err) {\n            console.error('[evlog] keep callback failed:', err)\n          }\n        }\n\n        const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n        await callEnrichAndDrain(emittedEvent, { method, path, requestId }, headers, status)\n\n        return result as Awaited<TReturn>\n      } catch (error) {\n        logger.error(error instanceof Error ? error : new Error(String(error)))\n\n        const errorStatus = (error as { status?: number }).status\n          ?? (error as { statusCode?: number }).statusCode\n          ?? 500\n        logger.set({ status: errorStatus })\n\n        // Build tail sampling context and call keep callback\n        let forceKeep = false\n        if (state.options.keep) {\n          try {\n            const tailCtx: TailSamplingContext = {\n              status: errorStatus,\n              path,\n              method,\n              context: logger.getContext(),\n              shouldKeep: false,\n            }\n            await state.options.keep(tailCtx)\n            forceKeep = tailCtx.shouldKeep ?? false\n          } catch (err) {\n            console.error('[evlog] keep callback failed:', err)\n          }\n        }\n\n        const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n        await callEnrichAndDrain(emittedEvent, { method, path, requestId }, headers, errorStatus)\n\n        // Return structured JSON response for EvlogErrors (like H3 does for Nuxt)\n        if (isRequest && error instanceof EvlogError) {\n          return Response.json(error.toJSON(), { status: error.status }) as Awaited<TReturn>\n        }\n\n        throw error\n      }\n    }\n  }\n}\n","import { shouldLog } from '../shared/routes'\nimport type { EvlogMiddlewareConfig } from './types'\n\ntype NextRequest = {\n  nextUrl: { pathname: string }\n  headers: { get(name: string): string | null }\n}\n\ntype NextResponse = {\n  headers: {\n    set(name: string, value: string): void\n    get(name: string): string | null\n  }\n}\n\ntype NextResponseStatic = {\n  next(options?: { request?: { headers: Headers } }): NextResponse\n}\n\n/**\n * Create an evlog middleware for Next.js.\n * Sets `x-request-id` and `x-evlog-start` headers so `withEvlog()` can reuse them\n * for timing consistency across the middleware -> handler chain.\n *\n * @example\n * ```ts\n * // middleware.ts\n * import { evlogMiddleware } from 'evlog/next'\n * export const middleware = evlogMiddleware()\n * export const config = { matcher: ['/api/:path*'] }\n * ```\n */\nexport function evlogMiddleware(config?: EvlogMiddlewareConfig) {\n  return async (request: NextRequest) => {\n    const path = request.nextUrl.pathname\n\n    // Check include/exclude patterns\n    if (!shouldLog(path, config?.include, config?.exclude)) {\n      const { NextResponse: nextResponse } = await import('next/server') as { NextResponse: NextResponseStatic }\n      return nextResponse.next()\n    }\n\n    // Generate or reuse request ID\n    const existingId = request.headers.get('x-request-id')\n    const requestId = existingId || crypto.randomUUID()\n\n    // Forward modified headers to the route handler\n    const requestHeaders = new Headers(request.headers as HeadersInit)\n\n    requestHeaders.set('x-request-id', requestId)\n    requestHeaders.set('x-evlog-start', String(Date.now()))\n\n    const { NextResponse: nextResponse } = await import('next/server') as { NextResponse: NextResponseStatic }\n    const response = nextResponse.next({\n      request: { headers: requestHeaders },\n    })\n\n    // Also set on response for downstream consumers\n    response.headers.set('x-request-id', requestId)\n\n    return response\n  }\n}\n","import { log } from '../logger'\nimport { createError, createEvlogError } from '../error'\nimport type { NextEvlogOptions } from './types'\nimport { createWithEvlog } from './handler'\nimport { useLogger } from './storage'\n\nexport type { NextEvlogOptions, EvlogMiddlewareConfig } from './types'\n\nexport { evlogMiddleware } from './middleware'\nexport { useLogger } from './storage'\nexport { log } from '../logger'\nexport { createError, createEvlogError } from '../error'\n\n/**\n * Create an evlog instance configured for Next.js.\n * Returns all helpers needed for server-side logging.\n *\n * @example\n * ```ts\n * // lib/evlog.ts\n * import { createEvlog } from 'evlog/next'\n * import { createAxiomDrain } from 'evlog/axiom'\n * import { createDrainPipeline } from 'evlog/pipeline'\n *\n * const pipeline = createDrainPipeline({ batch: { size: 50 } })\n *\n * export const { withEvlog, useLogger, log, createEvlogError } = createEvlog({\n *   service: 'my-app',\n *   sampling: {\n *     rates: { info: 10 },\n *     keep: [{ status: 400 }, { duration: 1000 }],\n *   },\n *   drain: pipeline(createAxiomDrain({\n *     dataset: 'logs',\n *     apiKey: process.env.AXIOM_API_KEY!,\n *   })),\n *   enrich: (ctx) => {\n *     ctx.event.deploymentId = process.env.VERCEL_DEPLOYMENT_ID\n *   },\n * })\n * ```\n */\nexport function createEvlog(options: NextEvlogOptions = {}) {\n  const withEvlog = createWithEvlog(options)\n\n  return {\n    withEvlog,\n    useLogger,\n    log,\n    createError,\n    createEvlogError,\n  }\n}\n"],"mappings":"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"}

package/dist/next/instrumentation.d.mts

@@ -1,4 +1,4 @@
-import { I as DrainContext, K as LogLevel, R as EnvironmentContext, nt as SamplingConfig } from "../audit-CC8nfazi.mjs";
+import { I as DrainContext, K as LogLevel, R as EnvironmentContext, nt as SamplingConfig } from "../audit-DVdkntSO.mjs";
 
 //#region src/next/instrumentation.d.ts
 /** Request payload passed to Next.js `onRequestError` (App Router). */

package/dist/next/instrumentation.mjs

@@ -1,4 +1,4 @@
-import { C as lockLogger, b as initLogger, m as _log } from "../audit-pV5aLGP0.mjs";
+import { C as lockLogger, b as initLogger, m as _log } from "../audit-BUI3af4w.mjs";
 //#region src/next/instrumentation.ts
 /**
 * Root `instrumentation.ts` entry: load your real config only in the Node.js runtime so Edge

package/dist/next/instrumentation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.mjs","names":[],"sources":["../../src/next/instrumentation.ts"],"sourcesContent":["import type { DrainContext, EnvironmentContext, LogLevel, SamplingConfig } from '../types'\nimport { initLogger, log, lockLogger } from '../logger'\n\n/** Request payload passed to Next.js `onRequestError` (App Router). */\nexport interface NextInstrumentationRequest {\n  path: string\n  method: string\n  headers: Record<string, string>\n}\n\n/** Routing context passed to Next.js `onRequestError`. */\nexport interface NextInstrumentationErrorContext {\n  routerKind: string\n  routePath: string\n  routeType: string\n  renderSource: string\n}\n\n/**\n * What `lib/evlog.ts` should export for use with {@link defineNodeInstrumentation}\n * (typically the return values of `createInstrumentation()`).\n */\nexport interface NodeInstrumentationModule {\n  register: () => void | Promise<void>\n  onRequestError: (\n    error: { digest?: string } & Error,\n    request: NextInstrumentationRequest,\n    context: NextInstrumentationErrorContext,\n  ) => void | Promise<void>\n}\n\n/**\n * Root `instrumentation.ts` entry: load your real config only in the Node.js runtime so Edge\n * bundles never pull Node-only drains/adapters. Caches the dynamic `import()` so `register` and\n * repeated `onRequestError` calls share one module instance (avoids re-importing on every error).\n *\n * @example\n * ```ts\n * // instrumentation.ts\n * import { defineNodeInstrumentation } from 'evlog/next/instrumentation'\n *\n * export const { register, onRequestError } = defineNodeInstrumentation(() => import('./lib/evlog'))\n * ```\n */\nexport function defineNodeInstrumentation(loader: () => Promise<NodeInstrumentationModule>) {\n  let cached: Promise<NodeInstrumentationModule> | undefined\n\n  function load(): Promise<NodeInstrumentationModule> {\n    cached ??= loader()\n    return cached\n  }\n\n  return {\n    async register() {\n      if (process.env.NEXT_RUNTIME !== 'nodejs') return\n      const mod = await load()\n      await mod.register()\n    },\n    async onRequestError(\n      error: { digest?: string } & Error,\n      request: NextInstrumentationRequest,\n      context: NextInstrumentationErrorContext,\n    ) {\n      if (process.env.NEXT_RUNTIME !== 'nodejs') return\n      const mod = await load()\n      await mod.onRequestError(error, request, context)\n    },\n  }\n}\n\nexport interface InstrumentationOptions {\n  /** Enable or disable all logging globally. @default true */\n  enabled?: boolean\n  /** Service name for all logged events. */\n  service?: string\n  /** Environment context overrides. */\n  env?: Partial<EnvironmentContext>\n  /** Enable pretty printing. @default true in development */\n  pretty?: boolean\n  /** Suppress built-in console output. @default false */\n  silent?: boolean\n  /** Sampling configuration for filtering logs. */\n  sampling?: SamplingConfig\n  /** Minimum severity for the global `log` API. @default 'debug' */\n  minLevel?: LogLevel\n  /** When pretty is disabled, emit JSON strings or raw objects. @default true */\n  stringify?: boolean\n  /** Drain callback called with every emitted event. */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /** Capture stdout/stderr output as log events (Node.js only). */\n  captureOutput?: boolean\n}\n\ninterface InstrumentationResult {\n  register: () => void\n  onRequestError: (\n    error: { digest?: string } & Error,\n    request: NextInstrumentationRequest,\n    context: NextInstrumentationErrorContext,\n  ) => void\n}\n\nlet patching = false\n\nexport function createInstrumentation(options: InstrumentationOptions = {}): InstrumentationResult {\n  let registered = false\n\n  function register(): void {\n    if (registered) return\n    registered = true\n\n    initLogger({\n      enabled: options.enabled,\n      env: {\n        service: options.service,\n        ...options.env,\n      },\n      pretty: options.pretty,\n      silent: options.silent,\n      sampling: options.sampling,\n      minLevel: options.minLevel,\n      stringify: options.stringify,\n      drain: options.drain,\n    })\n    lockLogger()\n\n    if (options.captureOutput && process.env.NEXT_RUNTIME === 'nodejs') {\n      patchOutput()\n    }\n  }\n\n  function patchOutput(): void {\n    const proc = globalThis.process\n    const originalStdoutWrite = proc.stdout.write.bind(proc.stdout)\n    const originalStderrWrite = proc.stderr.write.bind(proc.stderr)\n\n    proc.stdout.write = function(chunk: unknown, ...args: unknown[]): boolean {\n      if (!patching) {\n        patching = true\n        try {\n          log.info({ source: 'stdout', message: String(chunk).trimEnd() })\n        } finally {\n          patching = false\n        }\n      }\n      return originalStdoutWrite(chunk, ...args as [])\n    } as typeof process.stdout.write\n\n    proc.stderr.write = function(chunk: unknown, ...args: unknown[]): boolean {\n      if (!patching) {\n        patching = true\n        try {\n          log.error({ source: 'stderr', message: String(chunk).trimEnd() })\n        } finally {\n          patching = false\n        }\n      }\n      return originalStderrWrite(chunk, ...args as [])\n    } as typeof process.stderr.write\n  }\n\n  function onRequestError(\n    error: { digest?: string } & Error,\n    request: { path: string; method: string; headers: Record<string, string> },\n    context: { routerKind: string; routePath: string; routeType: string; renderSource: string },\n  ): void {\n    log.error({\n      message: error.message,\n      digest: error.digest,\n      stack: error.stack,\n      path: request.path,\n      method: request.method,\n      routerKind: context.routerKind,\n      routePath: context.routePath,\n      routeType: context.routeType,\n      renderSource: context.renderSource,\n    })\n  }\n\n  return { register, onRequestError }\n}\n"],"mappings":";;;;;;;;;;;;;;;AA4CA,SAAgB,0BAA0B,QAAkD;CAC1F,IAAI;CAEJ,SAAS,OAA2C;AAClD,aAAW,QAAQ;AACnB,SAAO;;AAGT,QAAO;EACL,MAAM,WAAW;AACf,OAAI,QAAQ,IAAI,iBAAiB,SAAU;AAE3C,UAAM,MADY,MAAM,EACd,UAAU;;EAEtB,MAAM,eACJ,OACA,SACA,SACA;AACA,OAAI,QAAQ,IAAI,iBAAiB,SAAU;AAE3C,UAAM,MADY,MAAM,EACd,eAAe,OAAO,SAAS,QAAQ;;EAEpD;;AAmCH,IAAI,WAAW;AAEf,SAAgB,sBAAsB,UAAkC,EAAE,EAAyB;CACjG,IAAI,aAAa;CAEjB,SAAS,WAAiB;AACxB,MAAI,WAAY;AAChB,eAAa;AAEb,aAAW;GACT,SAAS,QAAQ;GACjB,KAAK;IACH,SAAS,QAAQ;IACjB,GAAG,QAAQ;IACZ;GACD,QAAQ,QAAQ;GAChB,QAAQ,QAAQ;GAChB,UAAU,QAAQ;GAClB,UAAU,QAAQ;GAClB,WAAW,QAAQ;GACnB,OAAO,QAAQ;GAChB,CAAC;AACF,cAAY;AAEZ,MAAI,QAAQ,iBAAiB,QAAQ,IAAI,iBAAiB,SACxD,cAAa;;CAIjB,SAAS,cAAoB;EAC3B,MAAM,OAAO,WAAW;EACxB,MAAM,sBAAsB,KAAK,OAAO,MAAM,KAAK,KAAK,OAAO;EAC/D,MAAM,sBAAsB,KAAK,OAAO,MAAM,KAAK,KAAK,OAAO;AAE/D,OAAK,OAAO,QAAQ,SAAS,OAAgB,GAAG,MAA0B;AACxE,OAAI,CAAC,UAAU;AACb,eAAW;AACX,QAAI;AACF,UAAI,KAAK;MAAE,QAAQ;MAAU,SAAS,OAAO,MAAM,CAAC,SAAS;MAAE,CAAC;cACxD;AACR,gBAAW;;;AAGf,UAAO,oBAAoB,OAAO,GAAG,KAAW;;AAGlD,OAAK,OAAO,QAAQ,SAAS,OAAgB,GAAG,MAA0B;AACxE,OAAI,CAAC,UAAU;AACb,eAAW;AACX,QAAI;AACF,UAAI,MAAM;MAAE,QAAQ;MAAU,SAAS,OAAO,MAAM,CAAC,SAAS;MAAE,CAAC;cACzD;AACR,gBAAW;;;AAGf,UAAO,oBAAoB,OAAO,GAAG,KAAW;;;CAIpD,SAAS,eACP,OACA,SACA,SACM;AACN,OAAI,MAAM;GACR,SAAS,MAAM;GACf,QAAQ,MAAM;GACd,OAAO,MAAM;GACb,MAAM,QAAQ;GACd,QAAQ,QAAQ;GAChB,YAAY,QAAQ;GACpB,WAAW,QAAQ;GACnB,WAAW,QAAQ;GACnB,cAAc,QAAQ;GACvB,CAAC;;AAGJ,QAAO;EAAE;EAAU;EAAgB"}
+{"version":3,"file":"instrumentation.mjs","names":[],"sources":["../../src/next/instrumentation.ts"],"sourcesContent":["import type { DrainContext, EnvironmentContext, LogLevel, SamplingConfig } from '../types'\nimport { initLogger, log, lockLogger } from '../logger'\n\n/** Request payload passed to Next.js `onRequestError` (App Router). */\nexport interface NextInstrumentationRequest {\n  path: string\n  method: string\n  headers: Record<string, string>\n}\n\n/** Routing context passed to Next.js `onRequestError`. */\nexport interface NextInstrumentationErrorContext {\n  routerKind: string\n  routePath: string\n  routeType: string\n  renderSource: string\n}\n\n/**\n * What `lib/evlog.ts` should export for use with {@link defineNodeInstrumentation}\n * (typically the return values of `createInstrumentation()`).\n */\nexport interface NodeInstrumentationModule {\n  register: () => void | Promise<void>\n  onRequestError: (\n    error: { digest?: string } & Error,\n    request: NextInstrumentationRequest,\n    context: NextInstrumentationErrorContext,\n  ) => void | Promise<void>\n}\n\n/**\n * Root `instrumentation.ts` entry: load your real config only in the Node.js runtime so Edge\n * bundles never pull Node-only drains/adapters. Caches the dynamic `import()` so `register` and\n * repeated `onRequestError` calls share one module instance (avoids re-importing on every error).\n *\n * @example\n * ```ts\n * // instrumentation.ts\n * import { defineNodeInstrumentation } from 'evlog/next/instrumentation'\n *\n * export const { register, onRequestError } = defineNodeInstrumentation(() => import('./lib/evlog'))\n * ```\n */\nexport function defineNodeInstrumentation(loader: () => Promise<NodeInstrumentationModule>) {\n  let cached: Promise<NodeInstrumentationModule> | undefined\n\n  function load(): Promise<NodeInstrumentationModule> {\n    cached ??= loader()\n    return cached\n  }\n\n  return {\n    async register() {\n      if (process.env.NEXT_RUNTIME !== 'nodejs') return\n      const mod = await load()\n      await mod.register()\n    },\n    async onRequestError(\n      error: { digest?: string } & Error,\n      request: NextInstrumentationRequest,\n      context: NextInstrumentationErrorContext,\n    ) {\n      if (process.env.NEXT_RUNTIME !== 'nodejs') return\n      const mod = await load()\n      await mod.onRequestError(error, request, context)\n    },\n  }\n}\n\nexport interface InstrumentationOptions {\n  /** Enable or disable all logging globally. @default true */\n  enabled?: boolean\n  /** Service name for all logged events. */\n  service?: string\n  /** Environment context overrides. */\n  env?: Partial<EnvironmentContext>\n  /** Enable pretty printing. @default true in development */\n  pretty?: boolean\n  /** Suppress built-in console output. @default false */\n  silent?: boolean\n  /** Sampling configuration for filtering logs. */\n  sampling?: SamplingConfig\n  /** Minimum severity for the global `log` API. @default 'debug' */\n  minLevel?: LogLevel\n  /** When pretty is disabled, emit JSON strings or raw objects. @default true */\n  stringify?: boolean\n  /** Drain callback called with every emitted event. */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /** Capture stdout/stderr output as log events (Node.js only). */\n  captureOutput?: boolean\n}\n\ninterface InstrumentationResult {\n  register: () => void\n  onRequestError: (\n    error: { digest?: string } & Error,\n    request: NextInstrumentationRequest,\n    context: NextInstrumentationErrorContext,\n  ) => void\n}\n\nlet patching = false\n\nexport function createInstrumentation(options: InstrumentationOptions = {}): InstrumentationResult {\n  let registered = false\n\n  function register(): void {\n    if (registered) return\n    registered = true\n\n    initLogger({\n      enabled: options.enabled,\n      env: {\n        service: options.service,\n        ...options.env,\n      },\n      pretty: options.pretty,\n      silent: options.silent,\n      sampling: options.sampling,\n      minLevel: options.minLevel,\n      stringify: options.stringify,\n      drain: options.drain,\n    })\n    lockLogger()\n\n    if (options.captureOutput && process.env.NEXT_RUNTIME === 'nodejs') {\n      patchOutput()\n    }\n  }\n\n  function patchOutput(): void {\n    const proc = globalThis.process\n    const originalStdoutWrite = proc.stdout.write.bind(proc.stdout)\n    const originalStderrWrite = proc.stderr.write.bind(proc.stderr)\n\n    proc.stdout.write = function(chunk: unknown, ...args: unknown[]): boolean {\n      if (!patching) {\n        patching = true\n        try {\n          log.info({ source: 'stdout', message: String(chunk).trimEnd() })\n        } finally {\n          patching = false\n        }\n      }\n      return originalStdoutWrite(chunk as string, ...args as [])\n    } as typeof process.stdout.write\n\n    proc.stderr.write = function(chunk: unknown, ...args: unknown[]): boolean {\n      if (!patching) {\n        patching = true\n        try {\n          log.error({ source: 'stderr', message: String(chunk).trimEnd() })\n        } finally {\n          patching = false\n        }\n      }\n      return originalStderrWrite(chunk as string, ...args as [])\n    } as typeof process.stderr.write\n  }\n\n  function onRequestError(\n    error: { digest?: string } & Error,\n    request: { path: string; method: string; headers: Record<string, string> },\n    context: { routerKind: string; routePath: string; routeType: string; renderSource: string },\n  ): void {\n    log.error({\n      message: error.message,\n      digest: error.digest,\n      stack: error.stack,\n      path: request.path,\n      method: request.method,\n      routerKind: context.routerKind,\n      routePath: context.routePath,\n      routeType: context.routeType,\n      renderSource: context.renderSource,\n    })\n  }\n\n  return { register, onRequestError }\n}\n"],"mappings":";;;;;;;;;;;;;;;AA4CA,SAAgB,0BAA0B,QAAkD;CAC1F,IAAI;CAEJ,SAAS,OAA2C;AAClD,aAAW,QAAQ;AACnB,SAAO;;AAGT,QAAO;EACL,MAAM,WAAW;AACf,OAAI,QAAQ,IAAI,iBAAiB,SAAU;AAE3C,UAAM,MADY,MAAM,EACd,UAAU;;EAEtB,MAAM,eACJ,OACA,SACA,SACA;AACA,OAAI,QAAQ,IAAI,iBAAiB,SAAU;AAE3C,UAAM,MADY,MAAM,EACd,eAAe,OAAO,SAAS,QAAQ;;EAEpD;;AAmCH,IAAI,WAAW;AAEf,SAAgB,sBAAsB,UAAkC,EAAE,EAAyB;CACjG,IAAI,aAAa;CAEjB,SAAS,WAAiB;AACxB,MAAI,WAAY;AAChB,eAAa;AAEb,aAAW;GACT,SAAS,QAAQ;GACjB,KAAK;IACH,SAAS,QAAQ;IACjB,GAAG,QAAQ;IACZ;GACD,QAAQ,QAAQ;GAChB,QAAQ,QAAQ;GAChB,UAAU,QAAQ;GAClB,UAAU,QAAQ;GAClB,WAAW,QAAQ;GACnB,OAAO,QAAQ;GAChB,CAAC;AACF,cAAY;AAEZ,MAAI,QAAQ,iBAAiB,QAAQ,IAAI,iBAAiB,SACxD,cAAa;;CAIjB,SAAS,cAAoB;EAC3B,MAAM,OAAO,WAAW;EACxB,MAAM,sBAAsB,KAAK,OAAO,MAAM,KAAK,KAAK,OAAO;EAC/D,MAAM,sBAAsB,KAAK,OAAO,MAAM,KAAK,KAAK,OAAO;AAE/D,OAAK,OAAO,QAAQ,SAAS,OAAgB,GAAG,MAA0B;AACxE,OAAI,CAAC,UAAU;AACb,eAAW;AACX,QAAI;AACF,UAAI,KAAK;MAAE,QAAQ;MAAU,SAAS,OAAO,MAAM,CAAC,SAAS;MAAE,CAAC;cACxD;AACR,gBAAW;;;AAGf,UAAO,oBAAoB,OAAiB,GAAG,KAAW;;AAG5D,OAAK,OAAO,QAAQ,SAAS,OAAgB,GAAG,MAA0B;AACxE,OAAI,CAAC,UAAU;AACb,eAAW;AACX,QAAI;AACF,UAAI,MAAM;MAAE,QAAQ;MAAU,SAAS,OAAO,MAAM,CAAC,SAAS;MAAE,CAAC;cACzD;AACR,gBAAW;;;AAGf,UAAO,oBAAoB,OAAiB,GAAG,KAAW;;;CAI9D,SAAS,eACP,OACA,SACA,SACM;AACN,OAAI,MAAM;GACR,SAAS,MAAM;GACf,QAAQ,MAAM;GACd,OAAO,MAAM;GACb,MAAM,QAAQ;GACd,QAAQ,QAAQ;GAChB,YAAY,QAAQ;GACpB,WAAW,QAAQ;GACnB,WAAW,QAAQ;GACnB,cAAc,QAAQ;GACvB,CAAC;;AAGJ,QAAO;EAAE;EAAU;EAAgB"}

package/dist/nitro/module.d.mts

@@ -1,5 +1,5 @@
-import { t as useLogger } from "../useLogger-BsPL4AQm.mjs";
-import { t as NitroModuleOptions } from "../nitro-oZre8ab3.mjs";
+import { t as useLogger } from "../useLogger-CqvH6qOf.mjs";
+import { t as NitroModuleOptions } from "../nitro-BRddgqSb.mjs";
 import { Nitro } from "nitropack";
 
 //#region src/nitro/module.d.ts

package/dist/nitro/module.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"module.d.mts","names":[],"sources":["../../src/nitro/module.ts"],"mappings":";;;;;iBASwB,KAAA,CAAM,OAAA,GAAU,kBAAA;;eAGvB,KAAA;AAAA"}
+{"version":3,"file":"module.d.mts","names":[],"sources":["../../src/nitro/module.ts"],"mappings":";;;;;iBAiBwB,KAAA,CAAM,OAAA,GAAU,kBAAA;;eAGvB,KAAA;AAAA"}

package/dist/nitro/module.mjs

@@ -3,16 +3,21 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/nitro/module.ts
 const _dir = dirname(fileURLToPath(import.meta.url));
+function resolveModulePath(name) {
+	return resolve(_dir, name).replace(/\\/g, "/");
+}
 function evlog(options) {
 	return {
 		name: "evlog",
 		setup(nitro) {
 			nitro.options.plugins = nitro.options.plugins || [];
-			nitro.options.plugins.push(resolve(_dir, "plugin"));
-			if (!nitro.options.errorHandler) nitro.options.errorHandler = resolve(_dir, "errorHandler");
+			nitro.options.plugins.push(resolveModulePath("plugin"));
+			if (!nitro.options.errorHandler) nitro.options.errorHandler = resolveModulePath("errorHandler");
 			nitro.options.noExternals = true;
 			nitro.options.runtimeConfig = nitro.options.runtimeConfig || {};
 			nitro.options.runtimeConfig.evlog = options || {};
+			nitro.options.replace = nitro.options.replace || {};
+			nitro.options.replace.__EVLOG_CONFIG__ = JSON.stringify(options || {});
 			process.env.__EVLOG_CONFIG = JSON.stringify(options || {});
 		}
 	};

package/dist/nitro/module.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"module.mjs","names":[],"sources":["../../src/nitro/module.ts"],"sourcesContent":["import { dirname, resolve } from 'node:path'\nimport { fileURLToPath } from 'node:url'\nimport type { Nitro } from 'nitropack'\nimport type { NitroModuleOptions } from '../nitro'\n\nexport type { NitroModuleOptions }\n\nconst _dir = dirname(fileURLToPath(import.meta.url))\n\nexport default function evlog(options?: NitroModuleOptions) {\n  return {\n    name: 'evlog',\n    setup(nitro: Nitro) {\n      // Push the plugin (no extension — Nitro's bundler resolves it)\n      nitro.options.plugins = nitro.options.plugins || []\n      nitro.options.plugins.push(resolve(_dir, 'plugin'))\n\n      // Set error handler only if not already configured by user\n      if (!nitro.options.errorHandler) {\n        nitro.options.errorHandler = resolve(_dir, 'errorHandler')\n      }\n\n      // explicitly tell nitro to bundle evlog's files to correctly resolve nitro dependencies\n      // in nitro v2 we can only disable externals globally\n\n      nitro.options.noExternals = true\n\n      // Inject config into runtimeConfig — works in production where the\n      // plugin is bundled through Nitro's builder and the virtual\n      // runtime-config module resolves correctly.\n      nitro.options.runtimeConfig = nitro.options.runtimeConfig || {}\n      nitro.options.runtimeConfig.evlog = options || {}\n\n      // In dev mode, Nitro loads plugins externally (not bundled), so the\n      // virtual runtime-config module is unreachable and useRuntimeConfig()\n      // returns a stub without our values. process.env is inherited by the\n      // Worker Threads that run the dev server, making it a reliable bridge.\n      // The plugin reads: useRuntimeConfig().evlog ?? process.env.__EVLOG_CONFIG\n      process.env.__EVLOG_CONFIG = JSON.stringify(options || {})\n    },\n  }\n}\n\nexport { useLogger } from '../runtime/server/useLogger'\n"],"mappings":";;;;AAOA,MAAM,OAAO,QAAQ,cAAc,OAAO,KAAK,IAAI,CAAC;AAEpD,SAAwB,MAAM,SAA8B;AAC1D,QAAO;EACL,MAAM;EACN,MAAM,OAAc;AAElB,SAAM,QAAQ,UAAU,MAAM,QAAQ,WAAW,EAAE;AACnD,SAAM,QAAQ,QAAQ,KAAK,QAAQ,MAAM,SAAS,CAAC;AAGnD,OAAI,CAAC,MAAM,QAAQ,aACjB,OAAM,QAAQ,eAAe,QAAQ,MAAM,eAAe;AAM5D,SAAM,QAAQ,cAAc;AAK5B,SAAM,QAAQ,gBAAgB,MAAM,QAAQ,iBAAiB,EAAE;AAC/D,SAAM,QAAQ,cAAc,QAAQ,WAAW,EAAE;AAOjD,WAAQ,IAAI,iBAAiB,KAAK,UAAU,WAAW,EAAE,CAAC;;EAE7D"}
+{"version":3,"file":"module.mjs","names":[],"sources":["../../src/nitro/module.ts"],"sourcesContent":["import { dirname, resolve } from 'node:path'\nimport { fileURLToPath } from 'node:url'\nimport type { Nitro } from 'nitropack'\nimport type { NitroModuleOptions } from '../nitro'\n\nexport type { NitroModuleOptions }\n\nconst _dir = dirname(fileURLToPath(import.meta.url))\n\n// Nitro raw-interpolates these paths into JS string literals when generating\n// the #nitro/virtual/plugins and #nitro/virtual/error-handler modules, so\n// Windows backslashes would be parsed as escape sequences (\\n, \\v, …) and\n// break module resolution. Normalize to POSIX separators.\nfunction resolveModulePath(name: string): string {\n  return resolve(_dir, name).replace(/\\\\/g, '/')\n}\n\nexport default function evlog(options?: NitroModuleOptions) {\n  return {\n    name: 'evlog',\n    setup(nitro: Nitro) {\n      // Push the plugin (no extension — Nitro's bundler resolves it)\n      nitro.options.plugins = nitro.options.plugins || []\n      nitro.options.plugins.push(resolveModulePath('plugin'))\n\n      // Set error handler only if not already configured by user\n      if (!nitro.options.errorHandler) {\n        nitro.options.errorHandler = resolveModulePath('errorHandler')\n      }\n\n      // explicitly tell nitro to bundle evlog's files to correctly resolve nitro dependencies\n      // in nitro v2 we can only disable externals globally\n\n      nitro.options.noExternals = true\n\n      // Inject config into runtimeConfig — works in production where the\n      // plugin is bundled through Nitro's builder and the virtual\n      // runtime-config module resolves correctly.\n      nitro.options.runtimeConfig = nitro.options.runtimeConfig || {}\n      nitro.options.runtimeConfig.evlog = options || {}\n\n      // Bake the config into the bundle as a literal so the plugin never has\n      // to do a runtime `import('nitropack/runtime/internal/config')` to\n      // discover it. The dynamic probe transitively imports a build-only\n      // virtual module; on Vercel + Bun the missing virtual triggers Bun's\n      // auto-installer and crashes with `ReadOnlyFileSystem` (issue #312).\n      nitro.options.replace = nitro.options.replace || {}\n      nitro.options.replace.__EVLOG_CONFIG__ = JSON.stringify(options || {})\n\n      // In dev mode, Nitro loads plugins externally (not bundled), so the\n      // virtual runtime-config module is unreachable and useRuntimeConfig()\n      // returns a stub without our values. process.env is inherited by the\n      // Worker Threads that run the dev server, making it a reliable bridge.\n      // The plugin reads: useRuntimeConfig().evlog ?? process.env.__EVLOG_CONFIG\n      process.env.__EVLOG_CONFIG = JSON.stringify(options || {})\n    },\n  }\n}\n\nexport { useLogger } from '../runtime/server/useLogger'\n"],"mappings":";;;;AAOA,MAAM,OAAO,QAAQ,cAAc,OAAO,KAAK,IAAI,CAAC;AAMpD,SAAS,kBAAkB,MAAsB;AAC/C,QAAO,QAAQ,MAAM,KAAK,CAAC,QAAQ,OAAO,IAAI;;AAGhD,SAAwB,MAAM,SAA8B;AAC1D,QAAO;EACL,MAAM;EACN,MAAM,OAAc;AAElB,SAAM,QAAQ,UAAU,MAAM,QAAQ,WAAW,EAAE;AACnD,SAAM,QAAQ,QAAQ,KAAK,kBAAkB,SAAS,CAAC;AAGvD,OAAI,CAAC,MAAM,QAAQ,aACjB,OAAM,QAAQ,eAAe,kBAAkB,eAAe;AAMhE,SAAM,QAAQ,cAAc;AAK5B,SAAM,QAAQ,gBAAgB,MAAM,QAAQ,iBAAiB,EAAE;AAC/D,SAAM,QAAQ,cAAc,QAAQ,WAAW,EAAE;AAOjD,SAAM,QAAQ,UAAU,MAAM,QAAQ,WAAW,EAAE;AACnD,SAAM,QAAQ,QAAQ,mBAAmB,KAAK,UAAU,WAAW,EAAE,CAAC;AAOtE,WAAQ,IAAI,iBAAiB,KAAK,UAAU,WAAW,EAAE,CAAC;;EAE7D"}

package/dist/nitro/plugin.mjs

@@ -1,8 +1,8 @@
-import { A as normalizeRedactConfig, b as initLogger, g as createRequestLogger, x as isEnabled, y as getGlobalPluginRunner } from "../audit-pV5aLGP0.mjs";
+import { b as initLogger, g as createRequestLogger, j as normalizeRedactConfig, x as isEnabled, y as getGlobalPluginRunner } from "../audit-BUI3af4w.mjs";
 import { filterSafeHeaders } from "../utils.mjs";
 import { t as extractErrorStatus } from "../errors-BQgyQ9xe.mjs";
 import { n as shouldLog, t as getServiceForPath } from "../routes-CnIgYWf8.mjs";
-import { n as resolveEvlogConfigForNitroPlugin } from "../nitroConfigBridge-DKk7eOn-.mjs";
+import { n as resolveEvlogConfigForNitroPlugin, r as setActiveNitroRuntime } from "../nitroConfigBridge-NbFn-sIK.mjs";
 import { startStreamServer } from "../stream.mjs";
 import { defineNitroPlugin } from "nitropack/runtime/internal/plugin";
 import { getHeaders } from "h3";
@@ -72,6 +72,7 @@ async function callEnrichAndDrain(nitroApp, emittedEvent, event) {
 	else await drainPromise;
 }
 var plugin_default = defineNitroPlugin(async (nitroApp) => {
+	setActiveNitroRuntime("v2");
 	const evlogConfig = await resolveEvlogConfigForNitroPlugin();
 	const redact = normalizeRedactConfig(evlogConfig?.redact);
 	initLogger({