evlog 2.19.0 → 2.19.2

package/dist/catalog.mjs

@@ -0,0 +1,205 @@
+import { EvlogError } from "./error.mjs";
+import { defineAuditAction } from "./audit-action.mjs";
+//#region src/catalog.ts
+function buildEvlogError(code, entry, rawArgs) {
+	const { message: messageOverride, status, why, fix, link, cause, internal: callInternal, ...maybeParams } = rawArgs ?? {};
+	let message;
+	if (typeof messageOverride === "string") message = messageOverride;
+	else if (typeof entry.message === "function") message = entry.message(maybeParams);
+	else ({message} = entry);
+	let internal;
+	if (entry.internal || callInternal) internal = {
+		...entry.internal ?? {},
+		...callInternal ?? {}
+	};
+	return new EvlogError({
+		code,
+		message,
+		status: status ?? entry.status ?? 500,
+		why: why ?? entry.why,
+		fix: fix ?? entry.fix,
+		link: link ?? entry.link,
+		cause,
+		internal
+	});
+}
+/**
+* Define a single, standalone error factory bound to a stable `code`.
+*
+* Each factory produces an {@link EvlogError} with the entry's defaults
+* applied. Call-site overrides (`cause`, `internal`, `message`, ...) are
+* shallow-merged onto those defaults.
+*
+* @example
+* ```ts
+* import { defineError } from 'evlog'
+*
+* export const PaymentDeclined = defineError('billing.PAYMENT_DECLINED', {
+*   status: 402,
+*   message: 'Card declined',
+*   why: 'Issuer declined the charge',
+*   fix: 'Try another card',
+* })
+*
+* throw PaymentDeclined()
+* throw PaymentDeclined({ cause: stripeErr, internal: { ref: 'ch_x' } })
+* ```
+*
+* @example Templated message with typed params
+* ```ts
+* export const InsufficientFunds = defineError('billing.INSUFFICIENT_FUNDS', {
+*   status: 402,
+*   message: ({ available, required }: { available: number, required: number }) =>
+*     `Insufficient funds: $${available}/$${required}`,
+* })
+*
+* throw InsufficientFunds({ available: 5, required: 100 })
+* ```
+*/
+function defineError(code, entry) {
+	const factory = ((...args) => buildEvlogError(code, entry, args[0]));
+	Object.defineProperties(factory, {
+		code: {
+			value: code,
+			enumerable: true
+		},
+		status: {
+			value: entry.status ?? 500,
+			enumerable: true
+		},
+		message: {
+			value: entry.message,
+			enumerable: true
+		},
+		why: {
+			value: entry.why,
+			enumerable: true
+		},
+		fix: {
+			value: entry.fix,
+			enumerable: true
+		},
+		link: {
+			value: entry.link,
+			enumerable: true
+		},
+		tags: {
+			value: entry.tags,
+			enumerable: true
+		},
+		internal: {
+			value: entry.internal,
+			enumerable: true
+		}
+	});
+	return factory;
+}
+/**
+* Define a bundle of errors that share a common prefix. The wire `code` for
+* each entry is `${prefix}.${KEY}` (the key's casing is preserved — convention
+* is `UPPER_SNAKE_CASE`).
+*
+* Pair with `declare module 'evlog'` to surface autocomplete + literal-typed
+* `code` everywhere across the codebase.
+*
+* @example
+* ```ts
+* import { defineErrorCatalog } from 'evlog'
+*
+* export const billingErrors = defineErrorCatalog('billing', {
+*   PAYMENT_DECLINED: { status: 402, message: 'Card declined' },
+*   INSUFFICIENT_FUNDS: {
+*     status: 402,
+*     message: ({ available, required }: { available: number, required: number }) =>
+*       `Insufficient funds: $${available}/$${required}`,
+*   },
+* })
+*
+* declare module 'evlog' {
+*   interface RegisteredErrorCatalogs {
+*     billing: typeof billingErrors
+*   }
+* }
+*
+* throw billingErrors.PAYMENT_DECLINED()
+* throw billingErrors.INSUFFICIENT_FUNDS({ available: 5, required: 100 })
+* ```
+*/
+function defineErrorCatalog(prefix, map) {
+	const out = {};
+	const codes = [];
+	for (const key of Object.keys(map)) {
+		const code = `${prefix}.${key}`;
+		out[key] = defineError(code, map[key]);
+		codes.push(code);
+	}
+	Object.defineProperties(out, {
+		_prefix: {
+			value: prefix,
+			enumerable: false
+		},
+		_codes: {
+			value: Object.freeze(codes),
+			enumerable: false
+		}
+	});
+	return out;
+}
+/**
+* Define a bundle of audit actions that share a common prefix. The wire
+* `action` for each entry is `${prefix}.${KEY}`.
+*
+* Each entry produces a thin wrapper around {@link defineAuditAction} (target
+* type is fixed at definition time, action name is auto-prefixed).
+*
+* @example
+* ```ts
+* import { defineAuditCatalog } from 'evlog'
+*
+* export const billingAudit = defineAuditCatalog('billing', {
+*   INVOICE_REFUND: {
+*     target: 'invoice',
+*     severity: 'high',
+*     requiresChanges: true,
+*     description: 'Refund an invoice to the customer',
+*   },
+*   INVOICE_CREATE: { target: 'invoice' },
+* })
+*
+* declare module 'evlog' {
+*   interface RegisteredAuditCatalogs {
+*     billing: typeof billingAudit
+*   }
+* }
+*
+* log.audit(billingAudit.INVOICE_REFUND({
+*   actor: { type: 'user', id: u.id },
+*   target: { id: 'inv_889' },
+* }))
+* ```
+*/
+function defineAuditCatalog(prefix, map) {
+	const out = {};
+	const actions = [];
+	for (const key of Object.keys(map)) {
+		const action = `${prefix}.${key}`;
+		const entry = map[key];
+		out[key] = defineAuditAction(action, entry);
+		actions.push(action);
+	}
+	Object.defineProperties(out, {
+		_prefix: {
+			value: prefix,
+			enumerable: false
+		},
+		_actions: {
+			value: Object.freeze(actions),
+			enumerable: false
+		}
+	});
+	return out;
+}
+//#endregion
+export { defineAuditCatalog, defineError, defineErrorCatalog };
+
+//# sourceMappingURL=catalog.mjs.map

package/dist/catalog.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.mjs","names":[],"sources":["../src/catalog.ts"],"sourcesContent":["import type { AuditActionDefinition, AuditTarget } from './types'\nimport { defineAuditAction, type AuditInput } from './audit-action'\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 type AuditCatalogEntry = AuditActionDefinition\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    readonly description: TEntry['description']\n    readonly severity: TEntry['severity']\n    readonly requiresChanges: TEntry['requiresChanges']\n    readonly requiresReason: TEntry['requiresReason']\n    readonly redactPaths: TEntry['redactPaths']\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: {\n *     target: 'invoice',\n *     severity: 'high',\n *     requiresChanges: true,\n *     description: 'Refund an invoice to the customer',\n *   },\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    out[key] = defineAuditAction(action, entry)\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":";;;AAuFA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyET,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;AAClB,MAAI,OAAO,kBAAkB,QAAQ,MAAM;AAC3C,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/deferred-drain-jeajC8QF.mjs

@@ -0,0 +1,36 @@
+//#region src/shared/enrich-error-stack.node.ts
+function shouldEnrichStackFromConfig() {
+	try {
+		const raw = process.env.__EVLOG_CONFIG;
+		if (raw) return JSON.parse(raw).pretty ?? process.env.NODE_ENV !== "production";
+	} catch {}
+	return process.env.NODE_ENV !== "production";
+}
+/**
+* Rewrite `error.stack` with source-mapped frames when the Nitro dev runtime is available.
+* Matches Nitro's Youch output (e.g. `server/api/foo.ts:100` instead of `.nuxt/dev/index.mjs`).
+*/
+async function enrichErrorStackForDev(error, options = {}) {
+	if (process.env.NODE_ENV === "production") return;
+	if (!(options.pretty ?? shouldEnrichStackFromConfig())) return;
+	for (const specifier of ["nitropack/runtime/internal/error/dev", "nitro/runtime/internal/error/dev"]) try {
+		const mod = await import(specifier);
+		if (typeof mod.loadStackTrace === "function") {
+			await mod.loadStackTrace(error).catch(() => {});
+			return;
+		}
+	} catch {}
+}
+//#endregion
+//#region src/nitro/deferred-drain.ts
+/** @internal Extend drain lifetime on Cloudflare without blocking Nitro Node responses. */
+function extendDeferredDrain(drainPromise, waitUntil) {
+	drainPromise.catch((err) => {
+		console.error("[evlog] background drain failed:", err);
+	});
+	if (typeof waitUntil === "function") waitUntil(drainPromise);
+}
+//#endregion
+export { enrichErrorStackForDev as n, extendDeferredDrain as t };
+
+//# sourceMappingURL=deferred-drain-jeajC8QF.mjs.map

package/dist/deferred-drain-jeajC8QF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deferred-drain-jeajC8QF.mjs","names":[],"sources":["../src/shared/enrich-error-stack.node.ts","../src/nitro/deferred-drain.ts"],"sourcesContent":["/** Options for {@link enrichErrorStackForDev}. */\nexport interface EnrichErrorStackOptions {\n  /** When false, skip Nitro source-map stack enrichment. @default true in dev when pretty is enabled */\n  pretty?: boolean\n}\n\nfunction shouldEnrichStackFromConfig(): boolean {\n  try {\n    const raw = process.env.__EVLOG_CONFIG\n    if (raw) {\n      const config = JSON.parse(raw) as { pretty?: boolean }\n      return config.pretty ?? process.env.NODE_ENV !== 'production'\n    }\n  } catch {\n    // ignore malformed config\n  }\n  return process.env.NODE_ENV !== 'production'\n}\n\n/**\n * Rewrite `error.stack` with source-mapped frames when the Nitro dev runtime is available.\n * Matches Nitro's Youch output (e.g. `server/api/foo.ts:100` instead of `.nuxt/dev/index.mjs`).\n */\nexport async function enrichErrorStackForDev(\n  error: Error,\n  options: EnrichErrorStackOptions = {},\n): Promise<void> {\n  if (process.env.NODE_ENV === 'production') return\n  const pretty = options.pretty ?? shouldEnrichStackFromConfig()\n  if (!pretty) return\n\n  const specifiers = [\n    'nitropack/runtime/internal/error/dev',\n    'nitro/runtime/internal/error/dev',\n  ]\n  for (const specifier of specifiers) {\n    try {\n      const mod = await import(specifier)\n      if (typeof mod.loadStackTrace === 'function') {\n        await mod.loadStackTrace(error).catch(() => {})\n        return\n      }\n    } catch {\n      // try next runtime\n    }\n  }\n}\n","/** @internal Extend drain lifetime on Cloudflare without blocking Nitro Node responses. */\nexport function extendDeferredDrain(\n  drainPromise: Promise<unknown>,\n  waitUntil?: (promise: Promise<unknown>) => void,\n): void {\n  void drainPromise.catch((err) => {\n    console.error('[evlog] background drain failed:', err)\n  })\n  if (typeof waitUntil === 'function') {\n    waitUntil(drainPromise)\n  }\n}\n"],"mappings":";AAMA,SAAS,8BAAuC;AAC9C,KAAI;EACF,MAAM,MAAM,QAAQ,IAAI;AACxB,MAAI,IAEF,QADe,KAAK,MAAM,IACb,CAAC,UAAU,QAAQ,IAAI,aAAa;SAE7C;AAGR,QAAO,QAAQ,IAAI,aAAa;;;;;;AAOlC,eAAsB,uBACpB,OACA,UAAmC,EAAE,EACtB;AACf,KAAI,QAAQ,IAAI,aAAa,aAAc;AAE3C,KAAI,EADW,QAAQ,UAAU,6BAA6B,EACjD;AAMb,MAAK,MAAM,aAAa,CAHtB,wCACA,mCAEgC,CAChC,KAAI;EACF,MAAM,MAAM,MAAM,OAAO;AACzB,MAAI,OAAO,IAAI,mBAAmB,YAAY;AAC5C,SAAM,IAAI,eAAe,MAAM,CAAC,YAAY,GAAG;AAC/C;;SAEI;;;;;ACzCZ,SAAgB,oBACd,cACA,WACM;AACD,cAAa,OAAO,QAAQ;AAC/B,UAAQ,MAAM,oCAAoC,IAAI;GACtD;AACF,KAAI,OAAO,cAAc,WACvB,WAAU,aAAa"}

package/dist/{define-DGwZkZ7x.d.mts → define-BuDJpV2b.d.mts}

@@ -1,5 +1,5 @@
-import { H as EnvironmentContext, Z as LoggerConfig, ot as SamplingConfig, pt as DevTerminalInput } from "./audit-BUAajsPU.mjs";
-import { t as BaseEvlogOptions } from "./middleware-DQ6-h8h0.mjs";
+import { G as EnvironmentContext, et as LoggerConfig, gt as DevTerminalInput, lt as SamplingConfig } from "./audit-CBfv3rl1.mjs";
+import { t as BaseEvlogOptions } from "./middleware-CjVyGyrG.mjs";
 
 //#region src/shared/define.d.ts
 /**
@@ -59,4 +59,4 @@ declare function toLoggerConfig(config: EvlogConfig): LoggerConfig;
 declare function toMiddlewareOptions<T extends BaseEvlogOptions>(config: EvlogConfig): T;
 //#endregion
 export { toMiddlewareOptions as i, defineEvlog as n, toLoggerConfig as r, EvlogConfig as t };
-//# sourceMappingURL=define-DGwZkZ7x.d.mts.map
+//# sourceMappingURL=define-BuDJpV2b.d.mts.map

package/dist/{define-DGwZkZ7x.d.mts.map → define-BuDJpV2b.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"define-DGwZkZ7x.d.mts","names":[],"sources":["../src/shared/define.ts"],"mappings":";;;;;AAUA;;;;;UAAiB,WAAA,SAAoB,gBAAA;EACnC,OAAA;EACA,WAAA;EAFmC;EAInC,GAAA,GAAM,OAAA,CAAQ,kBAAA;EAJqC;EAMnD,OAAA;EALA;EAOA,MAAA;EAJA;;;;EASA,GAAA,GAAM,gBAAA;EACN,QAAA,GAAW,cAAA;EADL;EAGN,MAAA;EAFW;EAIX,SAAA;EAAA;EAEA,QAAA,GAAW,YAAA;AAAA;;;AAqBb;;;;;;;;;;;;;;;AASA;iBATgB,WAAA,WAAsB,WAAA,CAAA,CAAa,MAAA,EAAQ,CAAA,GAAI,CAAA;;;;;;iBAS/C,cAAA,CAAe,MAAA,EAAQ,WAAA,GAAc,YAAA;;iBA0BrC,mBAAA,WAA8B,gBAAA,CAAA,CAAkB,MAAA,EAAQ,WAAA,GAAc,CAAA"}
+{"version":3,"file":"define-BuDJpV2b.d.mts","names":[],"sources":["../src/shared/define.ts"],"mappings":";;;;;AAUA;;;;;UAAiB,WAAA,SAAoB,gBAAA;EACnC,OAAA;EACA,WAAA;EAFmC;EAInC,GAAA,GAAM,OAAA,CAAQ,kBAAA;EAJqC;EAMnD,OAAA;EALA;EAOA,MAAA;EAJA;;;;EASA,GAAA,GAAM,gBAAA;EACN,QAAA,GAAW,cAAA;EADL;EAGN,MAAA;EAFW;EAIX,SAAA;EAAA;EAEA,QAAA,GAAW,YAAA;AAAA;;;AAqBb;;;;;;;;;;;;;;;AASA;iBATgB,WAAA,WAAsB,WAAA,CAAA,CAAa,MAAA,EAAQ,CAAA,GAAI,CAAA;;;;;;iBAS/C,cAAA,CAAe,MAAA,EAAQ,WAAA,GAAc,YAAA;;iBA0BrC,mBAAA,WAA8B,gBAAA,CAAA,CAAkB,MAAA,EAAQ,WAAA,GAAc,CAAA"}

package/dist/{drain-D_fy7m0n.mjs → drain-6lV-g7JB.mjs}

@@ -1,5 +1,5 @@
 import { t as getNitroRuntimeConfigRecord } from "./nitroConfigBridge-BkVWnSV3.mjs";
-import { r as httpPost } from "./http-Bept5EIC.mjs";
+import { r as httpPost } from "./http-DA3RWQrm.mjs";
 //#region src/shared/config.ts
 /** Read the full Nitro `useRuntimeConfig()` record (or `undefined` outside Nitro). */
 function getRuntimeConfig() {
@@ -21,6 +21,37 @@ async function resolveAdapterConfig(namespace, fields, overrides) {
 	for (const { key, env } of fields) config[key] = overrides?.[key] ?? evlogNs?.[key] ?? rootNs?.[key] ?? resolveEnv(env);
 	return config;
 }
+/**
+* Format environment variable names for user-facing messages.
+* Drops internal `NUXT_*` aliases; joins alternatives with `, ` and fields with `/`.
+*/
+function formatPublicEnvKeys(...envLists) {
+	return envLists.map((list) => {
+		const all = (list ?? []).filter((k) => !!k);
+		const publicKeys = all.filter((k) => !k.startsWith("NUXT_"));
+		return [...new Set(publicKeys.length > 0 ? publicKeys : all)].join(", ");
+	}).filter((part) => part.length > 0).join("/");
+}
+const warnedDeprecatedAliases = /* @__PURE__ */ new Set();
+/**
+* Copy a deprecated config field onto its replacement when the replacement is
+* unset, warning once per adapter/field pair.
+*/
+function applyDeprecatedAlias(config, opts) {
+	const record = config;
+	if (record[opts.to] === void 0 || record[opts.to] === null) {
+		const fromValue = record[opts.from];
+		if (fromValue !== void 0 && fromValue !== null) {
+			const warnKey = `${opts.adapter}:${opts.from}`;
+			if (!warnedDeprecatedAliases.has(warnKey)) {
+				warnedDeprecatedAliases.add(warnKey);
+				console.warn(`[evlog/${opts.adapter}] \`${opts.from}\` is deprecated, use \`${opts.to}\` instead.`);
+			}
+			record[opts.to] = fromValue;
+		}
+	}
+	return config;
+}
 function shouldProbeRuntimeConfig(fields, overrides) {
 	return fields.some(({ key, env }) => {
 		if (overrides?.[key] !== void 0) return false;
@@ -112,6 +143,6 @@ function defineHttpDrain(options) {
 	});
 }
 //#endregion
-export { resolveAdapterConfig as i, defineHttpDrain as n, getRuntimeConfig as r, defineDrain as t };
+export { getRuntimeConfig as a, formatPublicEnvKeys as i, defineHttpDrain as n, resolveAdapterConfig as o, applyDeprecatedAlias as r, defineDrain as t };
 
-//# sourceMappingURL=drain-D_fy7m0n.mjs.map
+//# sourceMappingURL=drain-6lV-g7JB.mjs.map

package/dist/drain-6lV-g7JB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"drain-6lV-g7JB.mjs","names":[],"sources":["../src/shared/config.ts","../src/shared/drain.ts"],"sourcesContent":["import { getNitroRuntimeConfigRecord } from './nitroConfigBridge'\n\n/** Read the full Nitro `useRuntimeConfig()` record (or `undefined` outside Nitro). */\nexport function getRuntimeConfig(): Promise<Record<string, any> | undefined> {\n  return getNitroRuntimeConfigRecord()\n}\n\n/**\n * Description of a single adapter config field. `env` is the ordered list of\n * environment variables to fall back to, e.g. `['NUXT_AXIOM_API_KEY', 'AXIOM_API_KEY']`.\n */\nexport interface ConfigField<T> {\n  key: keyof T & string\n  env?: string[]\n}\n\n/**\n * Resolve adapter configuration with the standard priority chain:\n *\n * 1. `overrides` passed to the drain factory\n * 2. `runtimeConfig.evlog.{namespace}.{key}` (Nitro)\n * 3. `runtimeConfig.{namespace}.{key}` (Nitro)\n * 4. `process.env[envKey]` for each env in `field.env`\n */\nexport async function resolveAdapterConfig<T>(\n  namespace: string,\n  fields: ConfigField<T>[],\n  overrides?: Partial<T>,\n): Promise<Partial<T>> {\n  const runtimeConfig = shouldProbeRuntimeConfig(fields, overrides)\n    ? await getRuntimeConfig()\n    : undefined\n  const evlogNs = runtimeConfig?.evlog?.[namespace]\n  const rootNs = runtimeConfig?.[namespace]\n\n  const config: Record<string, unknown> = {}\n\n  for (const { key, env } of fields) {\n    config[key] =\n      overrides?.[key]\n      ?? evlogNs?.[key]\n      ?? rootNs?.[key]\n      ?? resolveEnv(env)\n  }\n\n  return config as Partial<T>\n}\n\n/**\n * Format environment variable names for user-facing messages.\n * Drops internal `NUXT_*` aliases; joins alternatives with `, ` and fields with `/`.\n */\nexport function formatPublicEnvKeys(...envLists: (string[] | undefined)[]): string {\n  return envLists\n    .map((list) => {\n      const all = (list ?? []).filter((k): k is string => !!k)\n      const publicKeys = all.filter(k => !k.startsWith('NUXT_'))\n      const keys = [...new Set(publicKeys.length > 0 ? publicKeys : all)]\n      return keys.join(', ')\n    })\n    .filter(part => part.length > 0)\n    .join('/')\n}\n\nconst warnedDeprecatedAliases = new Set<string>()\n\n/**\n * Copy a deprecated config field onto its replacement when the replacement is\n * unset, warning once per adapter/field pair.\n */\nexport function applyDeprecatedAlias<T extends object>(\n  config: T,\n  opts: {\n    adapter: string\n    from: keyof T & string\n    to: keyof T & string\n  },\n): T {\n  const record = config as Record<string, unknown>\n  if (record[opts.to] === undefined || record[opts.to] === null) {\n    const fromValue = record[opts.from]\n    if (fromValue !== undefined && fromValue !== null) {\n      const warnKey = `${opts.adapter}:${opts.from}`\n      if (!warnedDeprecatedAliases.has(warnKey)) {\n        warnedDeprecatedAliases.add(warnKey)\n        console.warn(`[evlog/${opts.adapter}] \\`${opts.from}\\` is deprecated, use \\`${opts.to}\\` instead.`)\n      }\n      record[opts.to] = fromValue\n    }\n  }\n  return config\n}\n\n// Avoid the Nitro virtual-module import when env/overrides already resolve\n// every env-backed field — optional tuning fields (timeout, retries) should\n// not trigger a runtime probe in non-Nitro runtimes.\nfunction shouldProbeRuntimeConfig<T>(\n  fields: ConfigField<T>[],\n  overrides?: Partial<T>,\n): boolean {\n  return fields.some(({ key, env }) => {\n    if (overrides?.[key] !== undefined) return false\n    if (!env) return false\n    return resolveEnv(env) === undefined\n  })\n}\n\nfunction resolveEnv(envKeys?: string[]): string | undefined {\n  if (!envKeys) return undefined\n  for (const key of envKeys) {\n    const val = process.env[key]\n    if (val) return val\n  }\n  return undefined\n}\n","import type { DrainContext, WideEvent } from '../types'\nimport { httpPost } from './http'\n\n/**\n * Drain definition backed by an arbitrary `send` function. Use this for\n * non-HTTP transports (filesystem, in-memory queue, native SDK). For HTTP\n * backends, use `defineHttpDrain` instead.\n */\nexport interface DrainOptions<TConfig> {\n  /** Stable identifier used in error logs. */\n  name: string\n  /** Return `null` to skip draining (e.g. missing API key in dev). */\n  resolve: () => TConfig | null | Promise<TConfig | null>\n  send: (events: WideEvent[], config: TConfig) => Promise<void>\n}\n\n/**\n * Build a drain callback. Errors raised by `send` are logged with the drain\n * name and swallowed, so a failing drain never breaks the request pipeline.\n *\n * @example\n * ```ts\n * export function createMyDrain(overrides?: Partial<MyConfig>) {\n *   return defineDrain<MyConfig>({\n *     name: 'my-drain',\n *     resolve: () => ({ url: process.env.MY_URL ?? null }),\n *     send: async (events, config) => { ... },\n *   })\n * }\n * ```\n */\nexport function defineDrain<TConfig>(options: DrainOptions<TConfig>): (ctx: DrainContext | DrainContext[]) => Promise<void> {\n  return async (ctx: DrainContext | DrainContext[]) => {\n    const contexts = Array.isArray(ctx) ? ctx : [ctx]\n    if (contexts.length === 0) return\n\n    const config = await options.resolve()\n    if (!config) return\n\n    try {\n      await options.send(contexts.map(c => c.event), config)\n    } catch (error) {\n      console.error(`[evlog/${options.name}] Failed to send events:`, error)\n    }\n  }\n}\n\nexport interface HttpDrainRequest {\n  url: string\n  /** Caller is responsible for `Content-Type`. */\n  headers: Record<string, string>\n  body: string\n}\n\n/** Adapters only need to ship config + `encode()` — no manual `fetch`. */\nexport interface HttpDrainOptions<TConfig> {\n  /** Stable identifier used in error logs. */\n  name: string\n  /** Return `null` to skip draining (e.g. missing API key in dev). */\n  resolve: () => TConfig | null | Promise<TConfig | null>\n  /** Return `null` to skip the batch without raising. */\n  encode: (events: WideEvent[], config: TConfig) => HttpDrainRequest | null\n  /** @default 5000 */\n  timeout?: number\n  /** @default 2 */\n  retries?: number\n  /** Read the timeout off the resolved config (falls back to `timeout`). */\n  resolveTimeout?: (config: TConfig) => number | undefined\n  /** Read the retry count off the resolved config (falls back to `retries`). */\n  resolveRetries?: (config: TConfig) => number | undefined\n}\n\nconst DEFAULT_HTTP_TIMEOUT = 5000\n\n/**\n * Build an HTTP drain. Timeouts/retries are resolved from the config (with\n * overrides via `resolveTimeout` / `resolveRetries`) and forwarded to\n * {@link httpPost}.\n *\n * @example\n * ```ts\n * export function createMyDrain(overrides?: Partial<MyConfig>) {\n *   return defineHttpDrain<MyConfig>({\n *     name: 'my',\n *     resolve: async () => {\n *       const cfg = await resolveAdapterConfig<MyConfig>('my', FIELDS, overrides)\n *       return cfg.apiKey ? cfg as MyConfig : null\n *     },\n *     encode: (events, config) => ({\n *       url: `${config.endpoint ?? 'https://api.my.com'}/ingest`,\n *       headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${config.apiKey}` },\n *       body: JSON.stringify(events),\n *     }),\n *   })\n * }\n * ```\n */\nexport function defineHttpDrain<TConfig>(options: HttpDrainOptions<TConfig>): (ctx: DrainContext | DrainContext[]) => Promise<void> {\n  return defineDrain<TConfig>({\n    name: options.name,\n    resolve: options.resolve,\n    send: async (events, config) => {\n      if (events.length === 0) return\n      const request = options.encode(events, config)\n      if (!request) return\n      const timeout = options.resolveTimeout?.(config)\n        ?? (config as { timeout?: number }).timeout\n        ?? options.timeout\n        ?? DEFAULT_HTTP_TIMEOUT\n      const retries = options.resolveRetries?.(config)\n        ?? (config as { retries?: number }).retries\n        ?? options.retries\n      await httpPost({\n        url: request.url,\n        headers: request.headers,\n        body: request.body,\n        timeout,\n        retries,\n        label: options.name,\n        source: options.name,\n      })\n    },\n  })\n}\n"],"mappings":"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"}

package/dist/elysia/index.d.mts

@@ -1,5 +1,5 @@
-import { rt as RequestLogger } from "../audit-BUAajsPU.mjs";
-import { t as BaseEvlogOptions } from "../middleware-DQ6-h8h0.mjs";
+import { l as AuditableLogger } from "../audit-CBfv3rl1.mjs";
+import { t as BaseEvlogOptions } from "../middleware-CjVyGyrG.mjs";
 import { Elysia } from "elysia";
 
 //#region src/elysia/index.d.ts
@@ -22,7 +22,7 @@ type EvlogElysiaOptions = BaseEvlogOptions;
  * }
  * ```
  */
-declare function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T>;
+declare function useLogger<T extends object = Record<string, unknown>>(): AuditableLogger<T>;
 /**
  * Create an evlog plugin for Elysia.
  *
@@ -50,7 +50,7 @@ declare function evlog(options?: EvlogElysiaOptions): Elysia<"", {
   decorator: {};
   store: {};
   derive: {
-    readonly log: RequestLogger;
+    readonly log: AuditableLogger;
   };
   resolve: {};
 }, {

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

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

package/dist/elysia/index.mjs

@@ -1,5 +1,5 @@
-import { t as attachForkToLogger } from "../fork-CYm453dq.mjs";
-import { t as defineFrameworkIntegration } from "../integration-CR601uyW.mjs";
+import { t as attachForkToLogger } from "../fork-Di44utlp.mjs";
+import { t as defineFrameworkIntegration } from "../integration-2PpI-bCm.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Elysia } from "elysia";
 //#region src/elysia/index.ts

package/dist/elysia/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/elysia/index.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport { Elysia } from 'elysia'\nimport type { RequestLogger } from '../types'\nimport { defineFrameworkIntegration } from '../shared/integration'\nimport type { BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\n\nconst storage = new AsyncLocalStorage<RequestLogger>()\n\nconst activeLoggers = new WeakSet<RequestLogger>()\n\nexport type EvlogElysiaOptions = BaseEvlogOptions\n\n/**\n * Get the request-scoped logger from anywhere in the call stack.\n * Must be called inside a request handled by the `evlog()` plugin.\n *\n * Unlike other frameworks, Elysia uses `storage.enterWith()` which persists\n * beyond the request lifecycle. This accessor additionally checks `activeLoggers`\n * to ensure the logger belongs to an in-flight request.\n *\n * @example\n * ```ts\n * import { useLogger } from 'evlog/elysia'\n *\n * function findUser(id: string) {\n *   const log = useLogger()\n *   log.set({ user: { id } })\n * }\n * ```\n */\nexport function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n  const logger = storage.getStore()\n  if (!logger || !activeLoggers.has(logger)) {\n    throw new Error(\n      '[evlog] useLogger() was called outside of an evlog plugin context. '\n      + 'Make sure app.use(evlog()) is registered before your routes.',\n    )\n  }\n  return logger as RequestLogger<T>\n}\n\ninterface ElysiaContext {\n  request: Request\n  path: string\n  headers: Record<string, string>\n}\n\nconst integration = defineFrameworkIntegration<ElysiaContext>({\n  name: 'elysia',\n  extractRequest: ({ request, path, headers }) => ({\n    method: request.method,\n    path,\n    headers,\n    requestId: headers['x-request-id'],\n  }),\n  attachLogger: ({ request, path, headers }, logger) => {\n    attachForkToLogger(storage, logger, {\n      method: request.method,\n      path,\n      requestId: headers['x-request-id'],\n    }, {\n      onChildEnter: (child) => {\n        activeLoggers.add(child)\n      },\n      onChildExit: (child) => {\n        activeLoggers.delete(child)\n      },\n    })\n    activeLoggers.add(logger)\n  },\n})\n\ninterface RequestState {\n  finish: (opts?: { status?: number; error?: Error }) => Promise<unknown>\n  skipped: boolean\n  logger: RequestLogger\n}\n\n/**\n * Create an evlog plugin for Elysia.\n *\n * @example\n * ```ts\n * import { Elysia } from 'elysia'\n * import { evlog } from 'evlog/elysia'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = new Elysia()\n *   .use(evlog({\n *     drain: createAxiomDrain(),\n *     enrich: (ctx) => {\n *       ctx.event.region = process.env.FLY_REGION\n *     },\n *   }))\n *   .get('/health', ({ log }) => {\n *     log.set({ route: 'health' })\n *     return { ok: true }\n *   })\n *   .listen(3000)\n * ```\n */\nexport function evlog(options: EvlogElysiaOptions = {}) {\n  const emitted = new WeakSet<Request>()\n  const requestState = new WeakMap<Request, RequestState>()\n\n  return new Elysia({ name: 'evlog' })\n    .onRequest(({ request }) => {\n      const url = new URL(request.url)\n      const headers = (request.headers).toJSON?.() ?? Object.fromEntries(request.headers.entries())\n      const ctx: ElysiaContext = { request, path: url.pathname, headers }\n      const { logger, finish, skipped } = integration.start(ctx, options)\n      storage.enterWith(logger)\n      requestState.set(request, { finish, skipped, logger })\n    })\n    .derive({ as: 'global' }, ({ request }) => {\n      return { log: requestState.get(request)?.logger as RequestLogger }\n    })\n    .onAfterResponse({ as: 'global' }, async ({ request, set }) => {\n      const state = requestState.get(request)\n      if (!state || state.skipped || emitted.has(request)) return\n      emitted.add(request)\n      await state.finish({ status: set.status as number || 200 })\n      activeLoggers.delete(state.logger)\n      storage.enterWith(undefined as unknown as RequestLogger)\n    })\n    .onError({ as: 'global' }, async ({ request, error }) => {\n      const state = requestState.get(request)\n      if (!state || state.skipped || emitted.has(request)) return\n      emitted.add(request)\n      const err = error instanceof Error ? error : new Error(String(error))\n      state.logger.error(err)\n      await state.finish({ error: err })\n      activeLoggers.delete(state.logger)\n      storage.enterWith(undefined as unknown as RequestLogger)\n    })\n}\n"],"mappings":";;;;;AAOA,MAAM,UAAU,IAAI,mBAAkC;AAEtD,MAAM,gCAAgB,IAAI,SAAwB;;;;;;;;;;;;;;;;;;;AAsBlD,SAAgB,YAA0E;CACxF,MAAM,SAAS,QAAQ,UAAU;AACjC,KAAI,CAAC,UAAU,CAAC,cAAc,IAAI,OAAO,CACvC,OAAM,IAAI,MACR,kIAED;AAEH,QAAO;;AAST,MAAM,cAAc,2BAA0C;CAC5D,MAAM;CACN,iBAAiB,EAAE,SAAS,MAAM,eAAe;EAC/C,QAAQ,QAAQ;EAChB;EACA;EACA,WAAW,QAAQ;EACpB;CACD,eAAe,EAAE,SAAS,MAAM,WAAW,WAAW;AACpD,qBAAmB,SAAS,QAAQ;GAClC,QAAQ,QAAQ;GAChB;GACA,WAAW,QAAQ;GACpB,EAAE;GACD,eAAe,UAAU;AACvB,kBAAc,IAAI,MAAM;;GAE1B,cAAc,UAAU;AACtB,kBAAc,OAAO,MAAM;;GAE9B,CAAC;AACF,gBAAc,IAAI,OAAO;;CAE5B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AA+BF,SAAgB,MAAM,UAA8B,EAAE,EAAE;CACtD,MAAM,0BAAU,IAAI,SAAkB;CACtC,MAAM,+BAAe,IAAI,SAAgC;AAEzD,QAAO,IAAI,OAAO,EAAE,MAAM,SAAS,CAAC,CACjC,WAAW,EAAE,cAAc;EAC1B,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;EAChC,MAAM,UAAW,QAAQ,QAAS,UAAU,IAAI,OAAO,YAAY,QAAQ,QAAQ,SAAS,CAAC;EAC7F,MAAM,MAAqB;GAAE;GAAS,MAAM,IAAI;GAAU;GAAS;EACnE,MAAM,EAAE,QAAQ,QAAQ,YAAY,YAAY,MAAM,KAAK,QAAQ;AACnE,UAAQ,UAAU,OAAO;AACzB,eAAa,IAAI,SAAS;GAAE;GAAQ;GAAS;GAAQ,CAAC;GACtD,CACD,OAAO,EAAE,IAAI,UAAU,GAAG,EAAE,cAAc;AACzC,SAAO,EAAE,KAAK,aAAa,IAAI,QAAQ,EAAE,QAAyB;GAClE,CACD,gBAAgB,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,SAAS,UAAU;EAC7D,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,MAAM,WAAW,QAAQ,IAAI,QAAQ,CAAE;AACrD,UAAQ,IAAI,QAAQ;AACpB,QAAM,MAAM,OAAO,EAAE,QAAQ,IAAI,UAAoB,KAAK,CAAC;AAC3D,gBAAc,OAAO,MAAM,OAAO;AAClC,UAAQ,UAAU,KAAA,EAAsC;GACxD,CACD,QAAQ,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,SAAS,YAAY;EACvD,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,MAAM,WAAW,QAAQ,IAAI,QAAQ,CAAE;AACrD,UAAQ,IAAI,QAAQ;EACpB,MAAM,MAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC;AACrE,QAAM,OAAO,MAAM,IAAI;AACvB,QAAM,MAAM,OAAO,EAAE,OAAO,KAAK,CAAC;AAClC,gBAAc,OAAO,MAAM,OAAO;AAClC,UAAQ,UAAU,KAAA,EAAsC;GACxD"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/elysia/index.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport { Elysia } from 'elysia'\nimport type { AuditableLogger } from '../audit'\nimport { defineFrameworkIntegration } from '../shared/integration'\nimport type { BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\n\nconst storage = new AsyncLocalStorage<AuditableLogger>()\n\nconst activeLoggers = new WeakSet<AuditableLogger>()\n\nexport type EvlogElysiaOptions = BaseEvlogOptions\n\n/**\n * Get the request-scoped logger from anywhere in the call stack.\n * Must be called inside a request handled by the `evlog()` plugin.\n *\n * Unlike other frameworks, Elysia uses `storage.enterWith()` which persists\n * beyond the request lifecycle. This accessor additionally checks `activeLoggers`\n * to ensure the logger belongs to an in-flight request.\n *\n * @example\n * ```ts\n * import { useLogger } from 'evlog/elysia'\n *\n * function findUser(id: string) {\n *   const log = useLogger()\n *   log.set({ user: { id } })\n * }\n * ```\n */\nexport function useLogger<T extends object = Record<string, unknown>>(): AuditableLogger<T> {\n  const logger = storage.getStore()\n  if (!logger || !activeLoggers.has(logger)) {\n    throw new Error(\n      '[evlog] useLogger() was called outside of an evlog plugin context. '\n      + 'Make sure app.use(evlog()) is registered before your routes.',\n    )\n  }\n  return logger as AuditableLogger<T>\n}\n\ninterface ElysiaContext {\n  request: Request\n  path: string\n  headers: Record<string, string>\n}\n\nconst integration = defineFrameworkIntegration<ElysiaContext>({\n  name: 'elysia',\n  extractRequest: ({ request, path, headers }) => ({\n    method: request.method,\n    path,\n    headers,\n    requestId: headers['x-request-id'],\n  }),\n  attachLogger: ({ request, path, headers }, logger) => {\n    attachForkToLogger(storage, logger, {\n      method: request.method,\n      path,\n      requestId: headers['x-request-id'],\n    }, {\n      onChildEnter: (child) => {\n        activeLoggers.add(child)\n      },\n      onChildExit: (child) => {\n        activeLoggers.delete(child)\n      },\n    })\n    activeLoggers.add(logger)\n  },\n})\n\ninterface RequestState {\n  finish: (opts?: { status?: number; error?: Error }) => Promise<unknown>\n  skipped: boolean\n  logger: AuditableLogger\n}\n\n/**\n * Create an evlog plugin for Elysia.\n *\n * @example\n * ```ts\n * import { Elysia } from 'elysia'\n * import { evlog } from 'evlog/elysia'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = new Elysia()\n *   .use(evlog({\n *     drain: createAxiomDrain(),\n *     enrich: (ctx) => {\n *       ctx.event.region = process.env.FLY_REGION\n *     },\n *   }))\n *   .get('/health', ({ log }) => {\n *     log.set({ route: 'health' })\n *     return { ok: true }\n *   })\n *   .listen(3000)\n * ```\n */\nexport function evlog(options: EvlogElysiaOptions = {}) {\n  const emitted = new WeakSet<Request>()\n  const requestState = new WeakMap<Request, RequestState>()\n\n  return new Elysia({ name: 'evlog' })\n    .onRequest(({ request }) => {\n      const url = new URL(request.url)\n      const headers = (request.headers).toJSON?.() ?? Object.fromEntries(request.headers.entries())\n      const ctx: ElysiaContext = { request, path: url.pathname, headers }\n      const { logger, finish, skipped } = integration.start(ctx, options)\n      storage.enterWith(logger)\n      requestState.set(request, { finish, skipped, logger })\n    })\n    .derive({ as: 'global' }, ({ request }) => {\n      return { log: requestState.get(request)?.logger as AuditableLogger }\n    })\n    .onAfterResponse({ as: 'global' }, async ({ request, set }) => {\n      const state = requestState.get(request)\n      if (!state || state.skipped || emitted.has(request)) return\n      emitted.add(request)\n      await state.finish({ status: set.status as number || 200 })\n      activeLoggers.delete(state.logger)\n      storage.enterWith(undefined as unknown as AuditableLogger)\n    })\n    .onError({ as: 'global' }, async ({ request, error }) => {\n      const state = requestState.get(request)\n      if (!state || state.skipped || emitted.has(request)) return\n      emitted.add(request)\n      const err = error instanceof Error ? error : new Error(String(error))\n      state.logger.error(err)\n      await state.finish({ error: err })\n      activeLoggers.delete(state.logger)\n      storage.enterWith(undefined as unknown as AuditableLogger)\n    })\n}\n"],"mappings":";;;;;AAOA,MAAM,UAAU,IAAI,mBAAoC;AAExD,MAAM,gCAAgB,IAAI,SAA0B;;;;;;;;;;;;;;;;;;;AAsBpD,SAAgB,YAA4E;CAC1F,MAAM,SAAS,QAAQ,UAAU;AACjC,KAAI,CAAC,UAAU,CAAC,cAAc,IAAI,OAAO,CACvC,OAAM,IAAI,MACR,kIAED;AAEH,QAAO;;AAST,MAAM,cAAc,2BAA0C;CAC5D,MAAM;CACN,iBAAiB,EAAE,SAAS,MAAM,eAAe;EAC/C,QAAQ,QAAQ;EAChB;EACA;EACA,WAAW,QAAQ;EACpB;CACD,eAAe,EAAE,SAAS,MAAM,WAAW,WAAW;AACpD,qBAAmB,SAAS,QAAQ;GAClC,QAAQ,QAAQ;GAChB;GACA,WAAW,QAAQ;GACpB,EAAE;GACD,eAAe,UAAU;AACvB,kBAAc,IAAI,MAAM;;GAE1B,cAAc,UAAU;AACtB,kBAAc,OAAO,MAAM;;GAE9B,CAAC;AACF,gBAAc,IAAI,OAAO;;CAE5B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AA+BF,SAAgB,MAAM,UAA8B,EAAE,EAAE;CACtD,MAAM,0BAAU,IAAI,SAAkB;CACtC,MAAM,+BAAe,IAAI,SAAgC;AAEzD,QAAO,IAAI,OAAO,EAAE,MAAM,SAAS,CAAC,CACjC,WAAW,EAAE,cAAc;EAC1B,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;EAChC,MAAM,UAAW,QAAQ,QAAS,UAAU,IAAI,OAAO,YAAY,QAAQ,QAAQ,SAAS,CAAC;EAC7F,MAAM,MAAqB;GAAE;GAAS,MAAM,IAAI;GAAU;GAAS;EACnE,MAAM,EAAE,QAAQ,QAAQ,YAAY,YAAY,MAAM,KAAK,QAAQ;AACnE,UAAQ,UAAU,OAAO;AACzB,eAAa,IAAI,SAAS;GAAE;GAAQ;GAAS;GAAQ,CAAC;GACtD,CACD,OAAO,EAAE,IAAI,UAAU,GAAG,EAAE,cAAc;AACzC,SAAO,EAAE,KAAK,aAAa,IAAI,QAAQ,EAAE,QAA2B;GACpE,CACD,gBAAgB,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,SAAS,UAAU;EAC7D,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,MAAM,WAAW,QAAQ,IAAI,QAAQ,CAAE;AACrD,UAAQ,IAAI,QAAQ;AACpB,QAAM,MAAM,OAAO,EAAE,QAAQ,IAAI,UAAoB,KAAK,CAAC;AAC3D,gBAAc,OAAO,MAAM,OAAO;AAClC,UAAQ,UAAU,KAAA,EAAwC;GAC1D,CACD,QAAQ,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,SAAS,YAAY;EACvD,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,MAAM,WAAW,QAAQ,IAAI,QAAQ,CAAE;AACrD,UAAQ,IAAI,QAAQ;EACpB,MAAM,MAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC;AACrE,QAAM,OAAO,MAAM,IAAI;AACvB,QAAM,MAAM,OAAO,EAAE,OAAO,KAAK,CAAC;AAClC,gBAAc,OAAO,MAAM,OAAO;AAClC,UAAQ,UAAU,KAAA,EAAwC;GAC1D"}

package/dist/enrich-error-stack-next.node-BecxSKUc.mjs

@@ -0,0 +1,120 @@
+import { a as isFrameworkRuntimePath } from "./pretty-error-THg0U0w9.mjs";
+import { createRequire } from "node:module";
+import { isAbsolute, relative } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/shared/enrich-error-stack-next.node.ts
+const require = createRequire(import.meta.url);
+function formatMappedFrame(methodName, sourceURL, line1, column1) {
+	let sourceLocation = line1 !== null ? `:${line1}` : "";
+	if (column1 !== null && sourceLocation !== "") sourceLocation += `:${column1}`;
+	let fileLocation;
+	if (sourceURL !== null && sourceURL.startsWith("file://") && URL.canParse(sourceURL)) fileLocation = relative(process.cwd(), fileURLToPath(sourceURL));
+	else if (sourceURL !== null && sourceURL.startsWith("/")) fileLocation = relative(process.cwd(), sourceURL);
+	else fileLocation = sourceURL ?? "unknown";
+	return methodName ? `    at ${methodName} (${fileLocation}${sourceLocation})` : `    at ${fileLocation}${sourceLocation}`;
+}
+function shouldSkipMappedSource(source) {
+	const normalized = source.replace(/\\/g, "/");
+	return normalized.includes("node_modules") || normalized.includes("/packages/evlog/") || isFrameworkRuntimePath(normalized);
+}
+function resolveFrameFile(frame) {
+	if (!frame.file) return null;
+	if (frame.file.startsWith("file://")) try {
+		return fileURLToPath(frame.file);
+	} catch {
+		return frame.file;
+	}
+	if (isAbsolute(frame.file)) return frame.file;
+	return null;
+}
+function getSourceMapConsumer(frameFile, cache) {
+	const cached = cache.get(frameFile);
+	if (cached !== void 0) return cached;
+	const mapPath = `${frameFile}.map`;
+	if (!existsSync(mapPath)) {
+		cache.set(frameFile, null);
+		return null;
+	}
+	try {
+		const sourceMapModule = require("next/dist/compiled/source-map");
+		const payload = JSON.parse(readFileSync(mapPath, "utf8"));
+		const chunkUrl = pathToFileURL(frameFile).href;
+		const consumer = new sourceMapModule.SourceMapConsumer(payload, `${chunkUrl}.map`);
+		cache.set(frameFile, consumer);
+		return consumer;
+	} catch {
+		cache.set(frameFile, null);
+		return null;
+	}
+}
+function mapFrame(frame, cache) {
+	if (frame.file?.startsWith("node:")) return {
+		frame,
+		skipped: true
+	};
+	const frameFile = resolveFrameFile(frame);
+	if (!frameFile || frame.line1 === null) return {
+		frame,
+		skipped: false
+	};
+	const consumer = getSourceMapConsumer(frameFile, cache);
+	if (!consumer) {
+		if (frameFile.includes(".next/")) return {
+			frame,
+			skipped: true
+		};
+		return {
+			frame,
+			skipped: false
+		};
+	}
+	const sourcePosition = consumer.originalPositionFor({
+		line: frame.line1,
+		column: (frame.column1 ?? 1) - 1
+	});
+	if (!sourcePosition.source || sourcePosition.line === null) return {
+		frame,
+		skipped: frameFile.includes(".next/")
+	};
+	if (shouldSkipMappedSource(sourcePosition.source)) return {
+		frame,
+		skipped: true
+	};
+	return {
+		frame: {
+			...frame,
+			file: sourcePosition.source,
+			line1: sourcePosition.line,
+			column1: sourcePosition.column === null ? null : sourcePosition.column + 1,
+			methodName: sourcePosition.name ?? frame.methodName
+		},
+		skipped: false
+	};
+}
+/**
+* Rewrite `error.stack` with Turbopack/Webpack source-mapped frames in Next.js dev.
+* Reads sibling `.map` files for `.next` chunks (same resolution as the dev overlay).
+*/
+function enrichErrorStackFromNextDev(error) {
+	if (process.env.NODE_ENV === "production") return;
+	if (!error.stack) return;
+	try {
+		const { parseStack } = require("next/dist/server/lib/parse-stack");
+		const frames = parseStack(error.stack);
+		if (frames.length === 0) return;
+		const cache = /* @__PURE__ */ new Map();
+		const mappedLines = [];
+		for (const frame of frames) {
+			const { frame: mapped, skipped } = mapFrame(frame, cache);
+			if (skipped) continue;
+			mappedLines.push(formatMappedFrame(mapped.methodName, mapped.file, mapped.line1, mapped.column1));
+		}
+		if (mappedLines.length === 0) return;
+		error.stack = `${error.name || "Error"}: ${error.message}\n${mappedLines.join("\n")}`;
+	} catch {}
+}
+//#endregion
+export { enrichErrorStackFromNextDev };
+
+//# sourceMappingURL=enrich-error-stack-next.node-BecxSKUc.mjs.map

package/dist/enrich-error-stack-next.node-BecxSKUc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enrich-error-stack-next.node-BecxSKUc.mjs","names":[],"sources":["../src/shared/enrich-error-stack-next.node.ts"],"sourcesContent":["import { existsSync, readFileSync } from 'node:fs'\nimport { createRequire } from 'node:module'\nimport { isAbsolute, relative } from 'node:path'\nimport { pathToFileURL, fileURLToPath } from 'node:url'\nimport { isFrameworkRuntimePath } from './pretty-error'\n\n/** Parsed stack frame from Next.js `parseStack`. */\ninterface NextParsedFrame {\n  file: string | null\n  line1: number | null\n  column1: number | null\n  methodName: string | null\n  arguments: string[]\n}\n\ntype SourceMapConsumerInstance = {\n  originalPositionFor: (pos: { line: number, column: number }) => {\n    source: string | null\n    line: number | null\n    column: number | null\n    name: string | null\n  }\n}\n\nconst require = createRequire(import.meta.url)\n\nfunction formatMappedFrame(\n  methodName: string | null,\n  sourceURL: string | null,\n  line1: number | null,\n  column1: number | null,\n): string {\n  let sourceLocation = line1 !== null ? `:${line1}` : ''\n  if (column1 !== null && sourceLocation !== '') {\n    sourceLocation += `:${column1}`\n  }\n\n  let fileLocation: string\n  if (sourceURL !== null && sourceURL.startsWith('file://') && URL.canParse(sourceURL)) {\n    fileLocation = relative(process.cwd(), fileURLToPath(sourceURL))\n  } else if (sourceURL !== null && sourceURL.startsWith('/')) {\n    fileLocation = relative(process.cwd(), sourceURL)\n  } else {\n    fileLocation = sourceURL ?? 'unknown'\n  }\n\n  return methodName\n    ? `    at ${methodName} (${fileLocation}${sourceLocation})`\n    : `    at ${fileLocation}${sourceLocation}`\n}\n\nfunction shouldSkipMappedSource(source: string): boolean {\n  const normalized = source.replace(/\\\\/g, '/')\n  return normalized.includes('node_modules')\n    || normalized.includes('/packages/evlog/')\n    || isFrameworkRuntimePath(normalized)\n}\n\nfunction resolveFrameFile(frame: NextParsedFrame): string | null {\n  if (!frame.file) return null\n  if (frame.file.startsWith('file://')) {\n    try {\n      return fileURLToPath(frame.file)\n    } catch {\n      return frame.file\n    }\n  }\n  if (isAbsolute(frame.file)) return frame.file\n  return null\n}\n\nfunction getSourceMapConsumer(\n  frameFile: string,\n  cache: Map<string, SourceMapConsumerInstance | null>,\n): SourceMapConsumerInstance | null {\n  const cached = cache.get(frameFile)\n  if (cached !== undefined) return cached\n\n  const mapPath = `${frameFile}.map`\n  if (!existsSync(mapPath)) {\n    cache.set(frameFile, null)\n    return null\n  }\n\n  try {\n    const sourceMapModule = require('next/dist/compiled/source-map') as {\n      SourceMapConsumer: new(payload: unknown, sourceMapURL: string) => SourceMapConsumerInstance\n    }\n    const payload = JSON.parse(readFileSync(mapPath, 'utf8')) as unknown\n    const chunkUrl = pathToFileURL(frameFile).href\n    const consumer = new sourceMapModule.SourceMapConsumer(payload, `${chunkUrl}.map`)\n    cache.set(frameFile, consumer)\n    return consumer\n  } catch {\n    cache.set(frameFile, null)\n    return null\n  }\n}\n\nfunction mapFrame(\n  frame: NextParsedFrame,\n  cache: Map<string, SourceMapConsumerInstance | null>,\n): { frame: NextParsedFrame, skipped: boolean } {\n  if (frame.file?.startsWith('node:')) {\n    return { frame, skipped: true }\n  }\n\n  const frameFile = resolveFrameFile(frame)\n  if (!frameFile || frame.line1 === null) {\n    return { frame, skipped: false }\n  }\n\n  const consumer = getSourceMapConsumer(frameFile, cache)\n  if (!consumer) {\n    if (frameFile.includes('.next/')) {\n      return { frame, skipped: true }\n    }\n    return { frame, skipped: false }\n  }\n\n  const sourcePosition = consumer.originalPositionFor({\n    line: frame.line1,\n    column: (frame.column1 ?? 1) - 1,\n  })\n\n  if (!sourcePosition.source || sourcePosition.line === null) {\n    return { frame, skipped: frameFile.includes('.next/') }\n  }\n\n  if (shouldSkipMappedSource(sourcePosition.source)) {\n    return { frame, skipped: true }\n  }\n\n  return {\n    frame: {\n      ...frame,\n      file: sourcePosition.source,\n      line1: sourcePosition.line,\n      column1: sourcePosition.column === null ? null : sourcePosition.column + 1,\n      methodName: sourcePosition.name ?? frame.methodName,\n    },\n    skipped: false,\n  }\n}\n\n/**\n * Rewrite `error.stack` with Turbopack/Webpack source-mapped frames in Next.js dev.\n * Reads sibling `.map` files for `.next` chunks (same resolution as the dev overlay).\n */\nexport function enrichErrorStackFromNextDev(error: Error): void {\n  if (process.env.NODE_ENV === 'production') return\n  if (!error.stack) return\n\n  try {\n    const { parseStack } = require('next/dist/server/lib/parse-stack') as {\n      parseStack: (stack: string, distDir?: string) => NextParsedFrame[]\n    }\n\n    const frames = parseStack(error.stack)\n    if (frames.length === 0) return\n\n    const cache = new Map<string, SourceMapConsumerInstance | null>()\n    const mappedLines: string[] = []\n\n    for (const frame of frames) {\n      const { frame: mapped, skipped } = mapFrame(frame, cache)\n      if (skipped) continue\n      mappedLines.push(formatMappedFrame(mapped.methodName, mapped.file, mapped.line1, mapped.column1))\n    }\n\n    if (mappedLines.length === 0) return\n\n    error.stack = `${error.name || 'Error'}: ${error.message}\\n${mappedLines.join('\\n')}`\n  } catch {\n    // Next internals unavailable — keep the original stack\n  }\n}\n"],"mappings":";;;;;;AAwBA,MAAM,UAAU,cAAc,OAAO,KAAK,IAAI;AAE9C,SAAS,kBACP,YACA,WACA,OACA,SACQ;CACR,IAAI,iBAAiB,UAAU,OAAO,IAAI,UAAU;AACpD,KAAI,YAAY,QAAQ,mBAAmB,GACzC,mBAAkB,IAAI;CAGxB,IAAI;AACJ,KAAI,cAAc,QAAQ,UAAU,WAAW,UAAU,IAAI,IAAI,SAAS,UAAU,CAClF,gBAAe,SAAS,QAAQ,KAAK,EAAE,cAAc,UAAU,CAAC;UACvD,cAAc,QAAQ,UAAU,WAAW,IAAI,CACxD,gBAAe,SAAS,QAAQ,KAAK,EAAE,UAAU;KAEjD,gBAAe,aAAa;AAG9B,QAAO,aACH,UAAU,WAAW,IAAI,eAAe,eAAe,KACvD,UAAU,eAAe;;AAG/B,SAAS,uBAAuB,QAAyB;CACvD,MAAM,aAAa,OAAO,QAAQ,OAAO,IAAI;AAC7C,QAAO,WAAW,SAAS,eAAe,IACrC,WAAW,SAAS,mBAAmB,IACvC,uBAAuB,WAAW;;AAGzC,SAAS,iBAAiB,OAAuC;AAC/D,KAAI,CAAC,MAAM,KAAM,QAAO;AACxB,KAAI,MAAM,KAAK,WAAW,UAAU,CAClC,KAAI;AACF,SAAO,cAAc,MAAM,KAAK;SAC1B;AACN,SAAO,MAAM;;AAGjB,KAAI,WAAW,MAAM,KAAK,CAAE,QAAO,MAAM;AACzC,QAAO;;AAGT,SAAS,qBACP,WACA,OACkC;CAClC,MAAM,SAAS,MAAM,IAAI,UAAU;AACnC,KAAI,WAAW,KAAA,EAAW,QAAO;CAEjC,MAAM,UAAU,GAAG,UAAU;AAC7B,KAAI,CAAC,WAAW,QAAQ,EAAE;AACxB,QAAM,IAAI,WAAW,KAAK;AAC1B,SAAO;;AAGT,KAAI;EACF,MAAM,kBAAkB,QAAQ,gCAAgC;EAGhE,MAAM,UAAU,KAAK,MAAM,aAAa,SAAS,OAAO,CAAC;EACzD,MAAM,WAAW,cAAc,UAAU,CAAC;EAC1C,MAAM,WAAW,IAAI,gBAAgB,kBAAkB,SAAS,GAAG,SAAS,MAAM;AAClF,QAAM,IAAI,WAAW,SAAS;AAC9B,SAAO;SACD;AACN,QAAM,IAAI,WAAW,KAAK;AAC1B,SAAO;;;AAIX,SAAS,SACP,OACA,OAC8C;AAC9C,KAAI,MAAM,MAAM,WAAW,QAAQ,CACjC,QAAO;EAAE;EAAO,SAAS;EAAM;CAGjC,MAAM,YAAY,iBAAiB,MAAM;AACzC,KAAI,CAAC,aAAa,MAAM,UAAU,KAChC,QAAO;EAAE;EAAO,SAAS;EAAO;CAGlC,MAAM,WAAW,qBAAqB,WAAW,MAAM;AACvD,KAAI,CAAC,UAAU;AACb,MAAI,UAAU,SAAS,SAAS,CAC9B,QAAO;GAAE;GAAO,SAAS;GAAM;AAEjC,SAAO;GAAE;GAAO,SAAS;GAAO;;CAGlC,MAAM,iBAAiB,SAAS,oBAAoB;EAClD,MAAM,MAAM;EACZ,SAAS,MAAM,WAAW,KAAK;EAChC,CAAC;AAEF,KAAI,CAAC,eAAe,UAAU,eAAe,SAAS,KACpD,QAAO;EAAE;EAAO,SAAS,UAAU,SAAS,SAAS;EAAE;AAGzD,KAAI,uBAAuB,eAAe,OAAO,CAC/C,QAAO;EAAE;EAAO,SAAS;EAAM;AAGjC,QAAO;EACL,OAAO;GACL,GAAG;GACH,MAAM,eAAe;GACrB,OAAO,eAAe;GACtB,SAAS,eAAe,WAAW,OAAO,OAAO,eAAe,SAAS;GACzE,YAAY,eAAe,QAAQ,MAAM;GAC1C;EACD,SAAS;EACV;;;;;;AAOH,SAAgB,4BAA4B,OAAoB;AAC9D,KAAI,QAAQ,IAAI,aAAa,aAAc;AAC3C,KAAI,CAAC,MAAM,MAAO;AAElB,KAAI;EACF,MAAM,EAAE,eAAe,QAAQ,mCAAmC;EAIlE,MAAM,SAAS,WAAW,MAAM,MAAM;AACtC,MAAI,OAAO,WAAW,EAAG;EAEzB,MAAM,wBAAQ,IAAI,KAA+C;EACjE,MAAM,cAAwB,EAAE;AAEhC,OAAK,MAAM,SAAS,QAAQ;GAC1B,MAAM,EAAE,OAAO,QAAQ,YAAY,SAAS,OAAO,MAAM;AACzD,OAAI,QAAS;AACb,eAAY,KAAK,kBAAkB,OAAO,YAAY,OAAO,MAAM,OAAO,OAAO,OAAO,QAAQ,CAAC;;AAGnG,MAAI,YAAY,WAAW,EAAG;AAE9B,QAAM,QAAQ,GAAG,MAAM,QAAQ,QAAQ,IAAI,MAAM,QAAQ,IAAI,YAAY,KAAK,KAAK;SAC7E"}

package/dist/{enricher-CuMbbdqp.d.mts → enricher-VdBVX4oT.d.mts}

@@ -1,4 +1,4 @@
-import { V as EnrichContext, ft as WideEvent } from "./audit-BUAajsPU.mjs";
+import { W as EnrichContext, ht as WideEvent } from "./audit-CBfv3rl1.mjs";
 
 //#region src/shared/enricher.d.ts
 interface EnricherOptions {
@@ -39,4 +39,4 @@ interface EnricherDefinition<T> {
 declare function defineEnricher<T>(def: EnricherDefinition<T>, options?: EnricherOptions): (ctx: EnrichContext) => void;
 //#endregion
 export { EnricherOptions as n, defineEnricher as r, EnricherDefinition as t };
-//# sourceMappingURL=enricher-CuMbbdqp.d.mts.map
+//# sourceMappingURL=enricher-VdBVX4oT.d.mts.map

package/dist/{enricher-CuMbbdqp.d.mts.map → enricher-VdBVX4oT.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"enricher-CuMbbdqp.d.mts","names":[],"sources":["../src/shared/enricher.ts"],"mappings":";;;UAGiB,eAAA;;AAAjB;;;EAKE,SAAA;AAAA;AAAA,UAGe,kBAAA;EAAkB;EAEjC,IAAA;EAKc;;;;EAAd,KAAA,SAAc,SAAA;EAPoB;EASlC,OAAA,GAAU,GAAA,EAAK,aAAA,KAAkB,CAAA;AAAA;;;;;;;;AAoBnC;;;;;;;;;;iBAAgB,cAAA,GAAA,CACd,GAAA,EAAK,kBAAA,CAAmB,CAAA,GACxB,OAAA,GAAS,eAAA,IACP,GAAA,EAAK,aAAA"}
+{"version":3,"file":"enricher-VdBVX4oT.d.mts","names":[],"sources":["../src/shared/enricher.ts"],"mappings":";;;UAGiB,eAAA;;AAAjB;;;EAKE,SAAA;AAAA;AAAA,UAGe,kBAAA;EAAkB;EAEjC,IAAA;EAKc;;;;EAAd,KAAA,SAAc,SAAA;EAPoB;EASlC,OAAA,GAAU,GAAA,EAAK,aAAA,KAAkB,CAAA;AAAA;;;;;;;;AAoBnC;;;;;;;;;;iBAAgB,cAAA,GAAA,CACd,GAAA,EAAK,kBAAA,CAAmB,CAAA,GACxB,OAAA,GAAS,eAAA,IACP,GAAA,EAAK,aAAA"}

package/dist/enrichers.d.mts

@@ -1,5 +1,5 @@
-import { V as EnrichContext } from "./audit-BUAajsPU.mjs";
-import { n as EnricherOptions } from "./enricher-CuMbbdqp.mjs";
+import { W as EnrichContext } from "./audit-CBfv3rl1.mjs";
+import { n as EnricherOptions } from "./enricher-VdBVX4oT.mjs";
 
 //#region src/enrichers/index.d.ts
 interface UserAgentInfo {

package/dist/{error-DwajXSKM.d.mts → error-CPCM5a1D.d.mts}

@@ -1,4 +1,4 @@
-import { W as ErrorOptions } from "./audit-BUAajsPU.mjs";
+import { q as ErrorOptions } from "./audit-CBfv3rl1.mjs";
 
 //#region src/error.d.ts
 /**
@@ -72,4 +72,4 @@ declare class EvlogError extends Error {
 declare function createError(options: ErrorOptions | string): EvlogError;
 //#endregion
 export { createError as n, EvlogError as t };
-//# sourceMappingURL=error-DwajXSKM.d.mts.map
+//# sourceMappingURL=error-CPCM5a1D.d.mts.map

package/dist/{error-DwajXSKM.d.mts.map → error-CPCM5a1D.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"error-DwajXSKM.d.mts","names":[],"sources":["../src/error.ts"],"mappings":";;;;;AAsBA;;;;;;;;;;;;;;cAAa,UAAA,SAAmB,KAAA;EAc1B;EAAA,SAXK,IAAA;;WAEA,MAAA;EAAA,SACA,GAAA;EAAA,SACA,GAAA;EAAA,SACA,IAAA;EAgDL;;;;EAAA,IA1CA,QAAA,CAAA,GAAY,MAAA;cAIJ,OAAA,EAAS,YAAA;EAkDZ;EAAA,IAtBL,UAAA,CAAA;EA2DM;EAAA,IAtDN,UAAA,CAAA;EAsDY;EAAA,IAjDZ,aAAA,CAAA;EAsFqB;EAAA,IAjFrB,IAAA,CAAA;IAAU,IAAA;IAAe,GAAA;IAAc,GAAA;IAAc,IAAA;EAAA;EAOhD,QAAA,CAAA;EAqCT,MAAA,CAAA,GAAU,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;iBAqCI,WAAA,CAAY,OAAA,EAAS,YAAA,YAAwB,UAAA"}
+{"version":3,"file":"error-CPCM5a1D.d.mts","names":[],"sources":["../src/error.ts"],"mappings":";;;;;AAsBA;;;;;;;;;;;;;;cAAa,UAAA,SAAmB,KAAA;EAc1B;EAAA,SAXK,IAAA;;WAEA,MAAA;EAAA,SACA,GAAA;EAAA,SACA,GAAA;EAAA,SACA,IAAA;EAgDL;;;;EAAA,IA1CA,QAAA,CAAA,GAAY,MAAA;cAIJ,OAAA,EAAS,YAAA;EAkDZ;EAAA,IAtBL,UAAA,CAAA;EA2DM;EAAA,IAtDN,UAAA,CAAA;EAsDY;EAAA,IAjDZ,aAAA,CAAA;EAsFqB;EAAA,IAjFrB,IAAA,CAAA;IAAU,IAAA;IAAe,GAAA;IAAc,GAAA;IAAc,IAAA;EAAA;EAOhD,QAAA,CAAA;EAqCT,MAAA,CAAA,GAAU,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;iBAqCI,WAAA,CAAY,OAAA,EAAS,YAAA,YAAwB,UAAA"}