evlog 2.16.0 → 2.17.0

package/dist/index.mjs

@@ -4,4 +4,212 @@ import { EvlogError, createError } from "./error.mjs";
 import { useLogger } from "./runtime/server/useLogger.mjs";
 import { parseError } from "./runtime/utils/parseError.mjs";
 import { n as toLoggerConfig, r as toMiddlewareOptions, t as defineEvlog } from "./define-D6OJdSUH.mjs";
-export { AUDIT_SCHEMA_VERSION, AuditDeniedError, EvlogError, audit, auditDiff, auditEnricher, auditOnly, auditRedactPreset, buildAuditFields, createError, createError as createEvlogError, createLogger, createRequestLogger, defineAuditAction, defineEvlog, definePlugin, drainPlugin, enricherPlugin, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, mockAudit, parseError, shouldKeep, signed, toLoggerConfig, toMiddlewareOptions, useLogger, withAudit, withAuditMethods };
+//#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' },
+*   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];
+		const fn = defineAuditAction(action, entry.target ? { target: entry.target } : void 0);
+		Object.defineProperties(fn, {
+			action: {
+				value: action,
+				enumerable: true
+			},
+			target: {
+				value: entry.target,
+				enumerable: true
+			}
+		});
+		out[key] = fn;
+		actions.push(action);
+	}
+	Object.defineProperties(out, {
+		_prefix: {
+			value: prefix,
+			enumerable: false
+		},
+		_actions: {
+			value: Object.freeze(actions),
+			enumerable: false
+		}
+	});
+	return out;
+}
+//#endregion
+export { AUDIT_SCHEMA_VERSION, AuditDeniedError, EvlogError, 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 };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +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"}

package/dist/{integration-DSZPbI9N.mjs → integration-DTZtjSqh.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-DPN8aL8O.mjs";
+import { r as createMiddlewareLogger, t as attachForkToLogger } from "./fork-8u_zFOJq.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-DSZPbI9N.mjs.map
+//# sourceMappingURL=integration-DTZtjSqh.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"integration-DSZPbI9N.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-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"}

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

@@ -1,4 +1,4 @@
-import { F as DrainContext, G as LoggerConfig, L as EnvironmentContext, U as Log, X as RequestLoggerOptions, nt as TailSamplingContext, st as PluginRunner, u as AuditableLogger } from "./audit-X1uUukm3.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-CC8nfazi.mjs";
 
 //#region src/logger.d.ts
 /**
@@ -111,4 +111,4 @@ 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-U8lgdc9x.d.mts.map
+//# sourceMappingURL=logger-DntcxxHg.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"logger-U8lgdc9x.d.mts","names":[],"sources":["../src/logger.ts"],"mappings":";;;AAgEA;;;;AAAA,iBAAgB,UAAA,CAAW,MAAA,GAAQ,YAAA;AAsCnC;;;;;AAAA,iBAAgB,qBAAA,CAAA,GAAyB,YAAA;;;;iBAOzB,SAAA,CAAA;AAShB;;;;;AAAA,iBAAgB,UAAA,CAAA;;;;iBAOA,cAAA,CAAA;AAShB;;;;;AAAA,iBAAgB,cAAA,CAAA,KAAoB,GAAA,EAAK,YAAA,YAAwB,OAAA;;;;AA8BjE;iBAAgB,UAAA,CAAW,GAAA,EAAK,mBAAA;;;;AAgB/B;;;;;AAiYqB;cAPhB,IAAA,EAAM,GAAA;;;;UA2BF,2BAAA;EASK;;;AAkBf;EAtBE,WAAA;EAsB0B;;;EAlB1B,SAAA,IAAa,OAAA,EAAS,OAAA;AAAA;;;;;;;;;;;;;;AAgNxB;;iBA9LgB,YAAA,oBAAgC,MAAA,kBAAA,CAAyB,cAAA,GAAgB,MAAA,mBAA8B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;;;;;;;;;;;;;;;;AA6MvL;;;;;;;;;;iBAfgB,mBAAA,oBAAuC,MAAA,kBAAA,CAAyB,OAAA,GAAS,oBAAA,EAA2B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;;iBAepK,cAAA,CAAA,GAAkB,kBAAA"}
+{"version":3,"file":"logger-DntcxxHg.d.mts","names":[],"sources":["../src/logger.ts"],"mappings":";;;AAgEA;;;;AAAA,iBAAgB,UAAA,CAAW,MAAA,GAAQ,YAAA;AAsCnC;;;;;AAAA,iBAAgB,qBAAA,CAAA,GAAyB,YAAA;;;;iBAOzB,SAAA,CAAA;AAShB;;;;;AAAA,iBAAgB,UAAA,CAAA;;;;iBAOA,cAAA,CAAA;AAShB;;;;;AAAA,iBAAgB,cAAA,CAAA,KAAoB,GAAA,EAAK,YAAA,YAAwB,OAAA;;;;AA8BjE;iBAAgB,UAAA,CAAW,GAAA,EAAK,mBAAA;;;;AAgB/B;;;;;AAiYqB;cAPhB,IAAA,EAAM,GAAA;;;;UA2BF,2BAAA;EASK;;;AAkBf;EAtBE,WAAA;EAsB0B;;;EAlB1B,SAAA,IAAa,OAAA,EAAS,OAAA;AAAA;;;;;;;;;;;;;;AAgNxB;;iBA9LgB,YAAA,oBAAgC,MAAA,kBAAA,CAAyB,cAAA,GAAgB,MAAA,mBAA8B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;;;;;;;;;;;;;;;;AA6MvL;;;;;;;;;;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-U8lgdc9x.mjs";
+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 };

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

@@ -1,4 +1,4 @@
-import { F as DrainContext, I as EnrichContext, Y as RequestLogger, Z as RouteConfig, it as WideEvent, nt as TailSamplingContext, ot as EvlogPlugin, q as RedactConfig, st as PluginRunner } from "./audit-X1uUukm3.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-CC8nfazi.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-CAQHJRN1.d.mts.map
+//# sourceMappingURL=middleware-U-lIAzHg.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"middleware-CAQHJRN1.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-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"}

package/dist/nestjs/index.d.mts

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/nestjs/index.ts"],"mappings":";;;;;cASiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,kBAAA,GAAqB,gBAAA;AAAA,UAIhB,uBAAA;EANhB;EAQC,OAAA;EAVwB;EAYxB,UAAA,MAAgB,IAAA,YAAgB,kBAAA,GAAqB,OAAA,CAAQ,kBAAA;EAZrC;EAcxB,MAAA;AAAA;AAAA;EAAA,UAIU,eAAA;IACR,GAAA,GAAM,aAAA;EAAA;AAAA;AAAA;EAAA,UAKE,OAAA;IACR,GAAA,GAAM,aAAA;EAAA;AAAA;AAjBV;;;;;;;;;;;;;;;;;AAOC;;;;;;;AAPD,cA4Ea,WAAA,YAAuB,UAAA;EAAA,eAEnB,OAAA;EAnEM;AAAA;;;;;;;;;;EAAA,OAgFd,OAAA,CAAQ,OAAA,GAAS,kBAAA,GAA0B,aAAA;EAf3B;;;;;;;;;;;;;;EAAA,OAqChB,YAAA,CAAa,YAAA,EAAc,uBAAA,GAA0B,aAAA;EAkB5D,SAAA,CAAU,QAAA,EAAU,kBAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/nestjs/index.ts"],"mappings":";;;;;cAUiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,kBAAA,GAAqB,gBAAA;AAAA,UAIhB,uBAAA;EANhB;EAQC,OAAA;EAVwB;EAYxB,UAAA,MAAgB,IAAA,YAAgB,kBAAA,GAAqB,OAAA,CAAQ,kBAAA;EAZrC;EAcxB,MAAA;AAAA;AAAA;EAAA,UAIU,eAAA;IACR,GAAA,GAAM,aAAA;EAAA;AAAA;AAAA;EAAA,UAKE,OAAA;IACR,GAAA,GAAM,aAAA;EAAA;AAAA;AAjBV;;;;;;;;;;;;;;;;;AAOC;;;;;;;AAPD,cA0Ea,WAAA,YAAuB,UAAA;EAAA,eAEnB,OAAA;EAjEM;AAAA;;;;;;;;;;EAAA,OA8Ed,OAAA,CAAQ,OAAA,GAAS,kBAAA,GAA0B,aAAA;EAf3B;;;;;;;;;;;;;;EAAA,OAqChB,YAAA,CAAa,YAAA,EAAc,uBAAA,GAA0B,aAAA;EAkB5D,SAAA,CAAU,QAAA,EAAU,kBAAA;AAAA"}

package/dist/nestjs/index.mjs

@@ -1,6 +1,7 @@
 import { n as extractSafeNodeHeaders } from "../headers-CU-QqnYg.mjs";
-import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-DPN8aL8O.mjs";
-import { t as createLoggerStorage } from "../storage-BT-3fT1-.mjs";
+import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-8u_zFOJq.mjs";
+import { t as bindNodeResponseLifecycle } from "../nodeResponse-BkkionWl.mjs";
+import { t as createLoggerStorage } from "../storage-Dwinmg8P.mjs";
 //#region src/nestjs/index.ts
 const { storage, useLogger } = createLoggerStorage("middleware context. Make sure EvlogModule.forRoot() is imported in your AppModule.");
 function createEvlogMiddleware(getOptions) {
@@ -22,9 +23,7 @@ function createEvlogMiddleware(getOptions) {
 		}
 		attachForkToLogger(storage, logger, middlewareOpts);
 		req.log = logger;
-		res.on("finish", () => {
-			finish({ status: res.statusCode }).catch(() => {});
-		});
+		bindNodeResponseLifecycle(res, logger, finish);
 		storage.run(logger, () => next());
 	};
 }

package/dist/nestjs/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/nestjs/index.ts"],"sourcesContent":["import type { ServerResponse } from 'node:http'\nimport type { Request } from 'express'\nimport type { DynamicModule, MiddlewareConsumer, NestModule } from '@nestjs/common'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeNodeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'middleware context. Make sure EvlogModule.forRoot() is imported in your AppModule.',\n)\n\nexport type EvlogNestJSOptions = BaseEvlogOptions\n\nexport { useLogger }\n\nexport interface EvlogModuleAsyncOptions {\n  /** Modules to import (for dependency injection into the factory) */\n  imports?: any[]\n  /** Factory function that returns evlog options. Can be async. */\n  useFactory: (...args: any[]) => EvlogNestJSOptions | Promise<EvlogNestJSOptions>\n  /** Injection tokens to resolve and pass to the factory */\n  inject?: any[]\n}\n\ndeclare module 'http' {\n  interface IncomingMessage {\n    log?: RequestLogger\n  }\n}\n\ndeclare module 'express-serve-static-core' {\n  interface Request {\n    log?: RequestLogger\n  }\n}\n\nfunction createEvlogMiddleware(getOptions: () => EvlogNestJSOptions) {\n  return (req: Request, res: ServerResponse, next: () => void) => {\n    const options = getOptions()\n    const headers = extractSafeNodeHeaders(req.headers)\n    const url = new URL(req.originalUrl || req.url || '/', 'http://localhost')\n\n    const middlewareOpts = {\n      method: req.method || 'GET',\n      path: url.pathname,\n      requestId: headers['x-request-id'] || crypto.randomUUID(),\n      headers,\n      ...options,\n    }\n    const { logger, finish, skipped } = createMiddlewareLogger(middlewareOpts)\n\n    if (skipped) {\n      next()\n      return\n    }\n\n    attachForkToLogger(storage, logger, middlewareOpts)\n    req.log = logger\n\n    res.on('finish', () => {\n      finish({ status: res.statusCode }).catch(() => {})\n    })\n\n    storage.run(logger, () => next())\n  }\n}\n\n/**\n * NestJS module for evlog wide event logging.\n *\n * Registers a global middleware that creates a request-scoped logger\n * for every incoming request. Use `useLogger()` to access it anywhere\n * in the call stack, or `req.log` directly in controllers.\n *\n * @example\n * ```ts\n * import { Module } from '@nestjs/common'\n * import { EvlogModule } from 'evlog/nestjs'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * @Module({\n *   imports: [\n *     EvlogModule.forRoot({\n *       drain: createAxiomDrain(),\n *       exclude: ['/health'],\n *     }),\n *   ],\n * })\n * export class AppModule {}\n * ```\n */\nexport class EvlogModule implements NestModule {\n\n  private static options: EvlogNestJSOptions = {}\n\n  /**\n   * Register evlog with static configuration.\n   *\n   * @example\n   * ```ts\n   * EvlogModule.forRoot({\n   *   drain: createAxiomDrain(),\n   *   enrich: (ctx) => { ctx.event.region = process.env.FLY_REGION },\n   * })\n   * ```\n   */\n  static forRoot(options: EvlogNestJSOptions = {}): DynamicModule {\n    EvlogModule.options = options\n    return {\n      module: EvlogModule,\n      global: true,\n    }\n  }\n\n  /**\n   * Register evlog with async configuration (e.g. from `ConfigService`).\n   *\n   * @example\n   * ```ts\n   * EvlogModule.forRootAsync({\n   *   imports: [ConfigModule],\n   *   inject: [ConfigService],\n   *   useFactory: (config: ConfigService) => ({\n   *     drain: createAxiomDrain({ token: config.get('AXIOM_TOKEN') }),\n   *   }),\n   * })\n   * ```\n   */\n  static forRootAsync(asyncOptions: EvlogModuleAsyncOptions): DynamicModule {\n    return {\n      module: EvlogModule,\n      imports: asyncOptions.imports || [],\n      providers: [\n        {\n          provide: 'EVLOG_OPTIONS',\n          useFactory: async (...args: any[]) => {\n            EvlogModule.options = await asyncOptions.useFactory(...args)\n            return EvlogModule.options\n          },\n          inject: asyncOptions.inject || [],\n        },\n      ],\n      global: true,\n    }\n  }\n\n  configure(consumer: MiddlewareConsumer): void {\n    consumer\n      .apply(createEvlogMiddleware(() => EvlogModule.options))\n      .forRoutes('*')\n  }\n\n}\n"],"mappings":";;;;AASA,MAAM,EAAE,SAAS,cAAc,oBAC7B,qFACD;AA2BD,SAAS,sBAAsB,YAAsC;AACnE,SAAQ,KAAc,KAAqB,SAAqB;EAC9D,MAAM,UAAU,YAAY;EAC5B,MAAM,UAAU,uBAAuB,IAAI,QAAQ;EACnD,MAAM,MAAM,IAAI,IAAI,IAAI,eAAe,IAAI,OAAO,KAAK,mBAAmB;EAE1E,MAAM,iBAAiB;GACrB,QAAQ,IAAI,UAAU;GACtB,MAAM,IAAI;GACV,WAAW,QAAQ,mBAAmB,OAAO,YAAY;GACzD;GACA,GAAG;GACJ;EACD,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB,eAAe;AAE1E,MAAI,SAAS;AACX,SAAM;AACN;;AAGF,qBAAmB,SAAS,QAAQ,eAAe;AACnD,MAAI,MAAM;AAEV,MAAI,GAAG,gBAAgB;AACrB,UAAO,EAAE,QAAQ,IAAI,YAAY,CAAC,CAAC,YAAY,GAAG;IAClD;AAEF,UAAQ,IAAI,cAAc,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BrC,IAAa,cAAb,MAAa,YAAkC;CAE7C,OAAe,UAA8B,EAAE;;;;;;;;;;;;CAa/C,OAAO,QAAQ,UAA8B,EAAE,EAAiB;AAC9D,cAAY,UAAU;AACtB,SAAO;GACL,QAAQ;GACR,QAAQ;GACT;;;;;;;;;;;;;;;;CAiBH,OAAO,aAAa,cAAsD;AACxE,SAAO;GACL,QAAQ;GACR,SAAS,aAAa,WAAW,EAAE;GACnC,WAAW,CACT;IACE,SAAS;IACT,YAAY,OAAO,GAAG,SAAgB;AACpC,iBAAY,UAAU,MAAM,aAAa,WAAW,GAAG,KAAK;AAC5D,YAAO,YAAY;;IAErB,QAAQ,aAAa,UAAU,EAAE;IAClC,CACF;GACD,QAAQ;GACT;;CAGH,UAAU,UAAoC;AAC5C,WACG,MAAM,4BAA4B,YAAY,QAAQ,CAAC,CACvD,UAAU,IAAI"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/nestjs/index.ts"],"sourcesContent":["import type { ServerResponse } from 'node:http'\nimport type { Request } from 'express'\nimport type { DynamicModule, MiddlewareConsumer, NestModule } from '@nestjs/common'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { attachForkToLogger } from '../shared/fork'\nimport { extractSafeNodeHeaders } from '../shared/headers'\nimport { bindNodeResponseLifecycle } from '../shared/nodeResponse'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'middleware context. Make sure EvlogModule.forRoot() is imported in your AppModule.',\n)\n\nexport type EvlogNestJSOptions = BaseEvlogOptions\n\nexport { useLogger }\n\nexport interface EvlogModuleAsyncOptions {\n  /** Modules to import (for dependency injection into the factory) */\n  imports?: any[]\n  /** Factory function that returns evlog options. Can be async. */\n  useFactory: (...args: any[]) => EvlogNestJSOptions | Promise<EvlogNestJSOptions>\n  /** Injection tokens to resolve and pass to the factory */\n  inject?: any[]\n}\n\ndeclare module 'http' {\n  interface IncomingMessage {\n    log?: RequestLogger\n  }\n}\n\ndeclare module 'express-serve-static-core' {\n  interface Request {\n    log?: RequestLogger\n  }\n}\n\nfunction createEvlogMiddleware(getOptions: () => EvlogNestJSOptions) {\n  return (req: Request, res: ServerResponse, next: () => void) => {\n    const options = getOptions()\n    const headers = extractSafeNodeHeaders(req.headers)\n    const url = new URL(req.originalUrl || req.url || '/', 'http://localhost')\n\n    const middlewareOpts = {\n      method: req.method || 'GET',\n      path: url.pathname,\n      requestId: headers['x-request-id'] || crypto.randomUUID(),\n      headers,\n      ...options,\n    }\n    const { logger, finish, skipped } = createMiddlewareLogger(middlewareOpts)\n\n    if (skipped) {\n      next()\n      return\n    }\n\n    attachForkToLogger(storage, logger, middlewareOpts)\n    req.log = logger\n\n    bindNodeResponseLifecycle(res, logger, finish)\n\n    storage.run(logger, () => next())\n  }\n}\n\n/**\n * NestJS module for evlog wide event logging.\n *\n * Registers a global middleware that creates a request-scoped logger\n * for every incoming request. Use `useLogger()` to access it anywhere\n * in the call stack, or `req.log` directly in controllers.\n *\n * @example\n * ```ts\n * import { Module } from '@nestjs/common'\n * import { EvlogModule } from 'evlog/nestjs'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * @Module({\n *   imports: [\n *     EvlogModule.forRoot({\n *       drain: createAxiomDrain(),\n *       exclude: ['/health'],\n *     }),\n *   ],\n * })\n * export class AppModule {}\n * ```\n */\nexport class EvlogModule implements NestModule {\n\n  private static options: EvlogNestJSOptions = {}\n\n  /**\n   * Register evlog with static configuration.\n   *\n   * @example\n   * ```ts\n   * EvlogModule.forRoot({\n   *   drain: createAxiomDrain(),\n   *   enrich: (ctx) => { ctx.event.region = process.env.FLY_REGION },\n   * })\n   * ```\n   */\n  static forRoot(options: EvlogNestJSOptions = {}): DynamicModule {\n    EvlogModule.options = options\n    return {\n      module: EvlogModule,\n      global: true,\n    }\n  }\n\n  /**\n   * Register evlog with async configuration (e.g. from `ConfigService`).\n   *\n   * @example\n   * ```ts\n   * EvlogModule.forRootAsync({\n   *   imports: [ConfigModule],\n   *   inject: [ConfigService],\n   *   useFactory: (config: ConfigService) => ({\n   *     drain: createAxiomDrain({ token: config.get('AXIOM_TOKEN') }),\n   *   }),\n   * })\n   * ```\n   */\n  static forRootAsync(asyncOptions: EvlogModuleAsyncOptions): DynamicModule {\n    return {\n      module: EvlogModule,\n      imports: asyncOptions.imports || [],\n      providers: [\n        {\n          provide: 'EVLOG_OPTIONS',\n          useFactory: async (...args: any[]) => {\n            EvlogModule.options = await asyncOptions.useFactory(...args)\n            return EvlogModule.options\n          },\n          inject: asyncOptions.inject || [],\n        },\n      ],\n      global: true,\n    }\n  }\n\n  configure(consumer: MiddlewareConsumer): void {\n    consumer\n      .apply(createEvlogMiddleware(() => EvlogModule.options))\n      .forRoutes('*')\n  }\n\n}\n"],"mappings":";;;;;AAUA,MAAM,EAAE,SAAS,cAAc,oBAC7B,qFACD;AA2BD,SAAS,sBAAsB,YAAsC;AACnE,SAAQ,KAAc,KAAqB,SAAqB;EAC9D,MAAM,UAAU,YAAY;EAC5B,MAAM,UAAU,uBAAuB,IAAI,QAAQ;EACnD,MAAM,MAAM,IAAI,IAAI,IAAI,eAAe,IAAI,OAAO,KAAK,mBAAmB;EAE1E,MAAM,iBAAiB;GACrB,QAAQ,IAAI,UAAU;GACtB,MAAM,IAAI;GACV,WAAW,QAAQ,mBAAmB,OAAO,YAAY;GACzD;GACA,GAAG;GACJ;EACD,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB,eAAe;AAE1E,MAAI,SAAS;AACX,SAAM;AACN;;AAGF,qBAAmB,SAAS,QAAQ,eAAe;AACnD,MAAI,MAAM;AAEV,4BAA0B,KAAK,QAAQ,OAAO;AAE9C,UAAQ,IAAI,cAAc,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BrC,IAAa,cAAb,MAAa,YAAkC;CAE7C,OAAe,UAA8B,EAAE;;;;;;;;;;;;CAa/C,OAAO,QAAQ,UAA8B,EAAE,EAAiB;AAC9D,cAAY,UAAU;AACtB,SAAO;GACL,QAAQ;GACR,QAAQ;GACT;;;;;;;;;;;;;;;;CAiBH,OAAO,aAAa,cAAsD;AACxE,SAAO;GACL,QAAQ;GACR,SAAS,aAAa,WAAW,EAAE;GACnC,WAAW,CACT;IACE,SAAS;IACT,YAAY,OAAO,GAAG,SAAgB;AACpC,iBAAY,UAAU,MAAM,aAAa,WAAW,GAAG,KAAK;AAC5D,YAAO,YAAY;;IAErB,QAAQ,aAAa,UAAU,EAAE;IAClC,CACF;GACD,QAAQ;GACT;;CAGH,UAAU,UAAoC;AAC5C,WACG,MAAM,4BAA4B,YAAY,QAAQ,CAAC,CACvD,UAAU,IAAI"}

package/dist/next/client.d.mts

@@ -1,4 +1,4 @@
-import { W as LogLevel, rt as TransportConfig } from "../audit-X1uUukm3.mjs";
+import { K as LogLevel, st as TransportConfig } from "../audit-CC8nfazi.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 { L as EnvironmentContext, Q as SamplingConfig, U as Log, W as LogLevel, Y as RequestLogger } from "../audit-X1uUukm3.mjs";
-import { n as createError } from "../error-Cpc7RVz6.mjs";
-import { t as _log } from "../logger-U8lgdc9x.mjs";
-import { t as BaseEvlogOptions } from "../middleware-CAQHJRN1.mjs";
+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 { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/next/types.d.ts

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 { filterSafeHeaders } from "../utils.mjs";
 import { EvlogError, createError } from "../error.mjs";
-import { n as shouldLog, t as getServiceForPath } from "../routes-B48wm7Pb.mjs";
-import { t as attachForkToLogger } from "../fork-DPN8aL8O.mjs";
+import { n as shouldLog, t as getServiceForPath } from "../routes-CnIgYWf8.mjs";
+import { t as attachForkToLogger } from "../fork-8u_zFOJq.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/next/storage.ts
 const evlogStorage = new AsyncLocalStorage();

package/dist/next/instrumentation.d.mts

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

package/dist/next/stream.d.mts

@@ -0,0 +1,29 @@
+import { InstrumentationOptions, createInstrumentation } from "./instrumentation.mjs";
+import { StreamServerOptions } from "../stream.mjs";
+
+//#region src/next/stream.d.ts
+interface StreamedInstrumentationOptions extends InstrumentationOptions {
+  /**
+   * Live stream server.
+   *
+   * Strict opt-in — nothing starts unless this is set explicitly.
+   *
+   * - `true` — enable with defaults
+   * - `false` — off (same as omitting)
+   * - `StreamServerOptions` — full config (port, host, token, ...)
+   * - `undefined` (default) — off
+   */
+  stream?: boolean | StreamServerOptions;
+}
+interface InstrumentationResult {
+  register: () => Promise<void>;
+  onRequestError: ReturnType<typeof createInstrumentation>['onRequestError'];
+}
+/**
+ * Drop-in replacement for `createInstrumentation` that adds the local
+ * stream server lifecycle.
+ */
+declare function defineStreamedInstrumentation(options?: StreamedInstrumentationOptions): InstrumentationResult;
+//#endregion
+export { StreamedInstrumentationOptions, defineStreamedInstrumentation };
+//# sourceMappingURL=stream.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.mts","names":[],"sources":["../../src/next/stream.ts"],"mappings":";;;;UAkCiB,8BAAA,SAAuC,sBAAA;EAuBD;;;;;;;;;;EAZrD,MAAA,aAAmB,mBAAA;AAAA;AAAA,UAGX,qBAAA;EACR,QAAA,QAAgB,OAAA;EAChB,cAAA,EAAgB,UAAA,QAAkB,qBAAA;AAAA;;;;;iBAOpB,6BAAA,CAA8B,OAAA,GAAS,8BAAA,GAAsC,qBAAA"}

package/dist/next/stream.mjs

@@ -0,0 +1,78 @@
+import { startStreamServer } from "../stream.mjs";
+import { createInstrumentation } from "./instrumentation.mjs";
+//#region src/next/stream.ts
+/**
+* Next.js helper that wires the local stream server into the standard
+* `instrumentation.ts` pattern. Strict opt-in: nothing starts unless
+* `stream: true` (or a config object) is passed explicitly.
+*
+* @example
+* ```ts
+* // lib/evlog.ts
+* import { defineStreamedInstrumentation } from 'evlog/next/stream'
+*
+* export const { register, onRequestError } = defineStreamedInstrumentation({
+*   service: 'my-app',
+*   stream: true,            // opt in to the local SSE stream server
+* })
+* ```
+*
+* ```ts
+* // instrumentation.ts
+* import { defineNodeInstrumentation } from 'evlog/next/instrumentation'
+*
+* export const { register, onRequestError } = defineNodeInstrumentation(() =>
+*   import('./lib/evlog')
+* )
+* ```
+*
+* When enabled, the mini server boots on first `register()` call and prints
+* `[evlog] Stream → http://127.0.0.1:<port>`. Without `stream`, this is a
+* straight pass-through to `createInstrumentation()`.
+*/
+/**
+* Drop-in replacement for `createInstrumentation` that adds the local
+* stream server lifecycle.
+*/
+function defineStreamedInstrumentation(options = {}) {
+	const { stream: streamOpt, drain: userDrain, ...rest } = options;
+	function shouldStartServer() {
+		if (streamOpt === true) return true;
+		if (streamOpt && typeof streamOpt === "object") return true;
+		return false;
+	}
+	const start = shouldStartServer();
+	let serverDrain = null;
+	async function register() {
+		if (start) {
+			const cfg = streamOpt && typeof streamOpt === "object" ? streamOpt : {};
+			try {
+				const server = await startStreamServer(cfg);
+				serverDrain = (ctx) => server.drain(ctx);
+			} catch (err) {
+				console.error("[evlog/next] failed to start stream server:", err);
+			}
+		}
+		const composedDrain = composeDrains(userDrain, serverDrain);
+		createInstrumentation({
+			...rest,
+			drain: composedDrain
+		}).register();
+	}
+	return {
+		register,
+		onRequestError: createInstrumentation({ ...rest }).onRequestError
+	};
+}
+function composeDrains(user, server) {
+	if (!user && !server) return void 0;
+	if (!user) return server;
+	if (!server) return user;
+	return async (ctx) => {
+		await Promise.all([Promise.resolve(user(ctx)), Promise.resolve(server(ctx))]);
+	};
+}
+//#endregion
+export { defineStreamedInstrumentation };
+
+//# sourceMappingURL=stream.mjs.map

package/dist/next/stream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.mjs","names":[],"sources":["../../src/next/stream.ts"],"sourcesContent":["/**\n * Next.js helper that wires the local stream server into the standard\n * `instrumentation.ts` pattern. Strict opt-in: nothing starts unless\n * `stream: true` (or a config object) is passed explicitly.\n *\n * @example\n * ```ts\n * // lib/evlog.ts\n * import { defineStreamedInstrumentation } from 'evlog/next/stream'\n *\n * export const { register, onRequestError } = defineStreamedInstrumentation({\n *   service: 'my-app',\n *   stream: true,            // opt in to the local SSE stream server\n * })\n * ```\n *\n * ```ts\n * // instrumentation.ts\n * import { defineNodeInstrumentation } from 'evlog/next/instrumentation'\n *\n * export const { register, onRequestError } = defineNodeInstrumentation(() =>\n *   import('./lib/evlog')\n * )\n * ```\n *\n * When enabled, the mini server boots on first `register()` call and prints\n * `[evlog] Stream → http://127.0.0.1:<port>`. Without `stream`, this is a\n * straight pass-through to `createInstrumentation()`.\n */\n\nimport { startStreamServer, type StreamServerOptions } from '../stream'\nimport type { DrainContext } from '../types'\nimport { createInstrumentation, type InstrumentationOptions } from './instrumentation'\n\nexport interface StreamedInstrumentationOptions extends InstrumentationOptions {\n  /**\n   * Live stream server.\n   *\n   * Strict opt-in — nothing starts unless this is set explicitly.\n   *\n   * - `true` — enable with defaults\n   * - `false` — off (same as omitting)\n   * - `StreamServerOptions` — full config (port, host, token, ...)\n   * - `undefined` (default) — off\n   */\n  stream?: boolean | StreamServerOptions\n}\n\ninterface InstrumentationResult {\n  register: () => Promise<void>\n  onRequestError: ReturnType<typeof createInstrumentation>['onRequestError']\n}\n\n/**\n * Drop-in replacement for `createInstrumentation` that adds the local\n * stream server lifecycle.\n */\nexport function defineStreamedInstrumentation(options: StreamedInstrumentationOptions = {}): InstrumentationResult {\n  const { stream: streamOpt, drain: userDrain, ...rest } = options\n\n  function shouldStartServer(): boolean {\n    if (streamOpt === true) return true\n    if (streamOpt && typeof streamOpt === 'object') return true\n    return false\n  }\n\n  const start: boolean = shouldStartServer()\n  let serverDrain: ((ctx: DrainContext) => void | Promise<void>) | null = null\n\n  async function register(): Promise<void> {\n    if (start) {\n      const cfg: StreamServerOptions = streamOpt && typeof streamOpt === 'object' ? streamOpt : {}\n      try {\n        const server = await startStreamServer(cfg)\n        serverDrain = ctx => server.drain(ctx)\n      } catch (err) {\n        console.error('[evlog/next] failed to start stream server:', err)\n      }\n    }\n\n    const composedDrain = composeDrains(userDrain, serverDrain)\n    const inner = createInstrumentation({ ...rest, drain: composedDrain })\n    inner.register()\n  }\n\n  // We intentionally instantiate a \"zero-time\" inner just for onRequestError —\n  // it wires `log.error` which doesn't depend on the drain.\n  const errorOnly = createInstrumentation({ ...rest })\n\n  return {\n    register,\n    onRequestError: errorOnly.onRequestError,\n  }\n}\n\nfunction composeDrains(\n  user: ((ctx: DrainContext) => void | Promise<void>) | undefined,\n  server: ((ctx: DrainContext) => void | Promise<void>) | null,\n): ((ctx: DrainContext) => void | Promise<void>) | undefined {\n  if (!user && !server) return undefined\n  if (!user) return server!\n  if (!server) return user\n  return async (ctx) => {\n    await Promise.all([\n      Promise.resolve(user(ctx)),\n      Promise.resolve(server(ctx)),\n    ])\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,8BAA8B,UAA0C,EAAE,EAAyB;CACjH,MAAM,EAAE,QAAQ,WAAW,OAAO,WAAW,GAAG,SAAS;CAEzD,SAAS,oBAA6B;AACpC,MAAI,cAAc,KAAM,QAAO;AAC/B,MAAI,aAAa,OAAO,cAAc,SAAU,QAAO;AACvD,SAAO;;CAGT,MAAM,QAAiB,mBAAmB;CAC1C,IAAI,cAAoE;CAExE,eAAe,WAA0B;AACvC,MAAI,OAAO;GACT,MAAM,MAA2B,aAAa,OAAO,cAAc,WAAW,YAAY,EAAE;AAC5F,OAAI;IACF,MAAM,SAAS,MAAM,kBAAkB,IAAI;AAC3C,mBAAc,QAAO,OAAO,MAAM,IAAI;YAC/B,KAAK;AACZ,YAAQ,MAAM,+CAA+C,IAAI;;;EAIrE,MAAM,gBAAgB,cAAc,WAAW,YAAY;AAC7C,wBAAsB;GAAE,GAAG;GAAM,OAAO;GAAe,CAChE,CAAC,UAAU;;AAOlB,QAAO;EACL;EACA,gBAJgB,sBAAsB,EAAE,GAAG,MAAM,CAIxB,CAAC;EAC3B;;AAGH,SAAS,cACP,MACA,QAC2D;AAC3D,KAAI,CAAC,QAAQ,CAAC,OAAQ,QAAO,KAAA;AAC7B,KAAI,CAAC,KAAM,QAAO;AAClB,KAAI,CAAC,OAAQ,QAAO;AACpB,QAAO,OAAO,QAAQ;AACpB,QAAM,QAAQ,IAAI,CAChB,QAAQ,QAAQ,KAAK,IAAI,CAAC,EAC1B,QAAQ,QAAQ,OAAO,IAAI,CAAC,CAC7B,CAAC"}

package/dist/nitro/errorHandler.mjs

@@ -1,5 +1,5 @@
 import { t as extractErrorStatus } from "../errors-BQgyQ9xe.mjs";
-import { n as serializeEvlogErrorResponse, t as resolveEvlogError } from "../nitro-DavLelNz.mjs";
+import { n as serializeEvlogErrorResponse, t as resolveEvlogError } from "../nitro-DErMq_Zj.mjs";
 import { getRequestURL, send, setResponseHeader, setResponseStatus } from "h3";
 import { defineNitroErrorHandler } from "nitropack/runtime/internal/error/utils";
 //#region src/nitro/errorHandler.ts

package/dist/nitro/module.d.mts

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

package/dist/nitro/plugin.mjs

@@ -1,8 +1,9 @@
 import { A as normalizeRedactConfig, b as initLogger, g as createRequestLogger, x as isEnabled, y as getGlobalPluginRunner } from "../audit-pV5aLGP0.mjs";
 import { filterSafeHeaders } from "../utils.mjs";
 import { t as extractErrorStatus } from "../errors-BQgyQ9xe.mjs";
-import { n as shouldLog, t as getServiceForPath } from "../routes-B48wm7Pb.mjs";
-import { n as resolveEvlogConfigForNitroPlugin } from "../nitroConfigBridge-aZ1e5upQ.mjs";
+import { n as shouldLog, t as getServiceForPath } from "../routes-CnIgYWf8.mjs";
+import { n as resolveEvlogConfigForNitroPlugin } from "../nitroConfigBridge-DKk7eOn-.mjs";
+import { startStreamServer } from "../stream.mjs";
 import { defineNitroPlugin } from "nitropack/runtime/internal/plugin";
 import { getHeaders } from "h3";
 //#region src/nitro/plugin.ts
@@ -83,6 +84,14 @@ var plugin_default = defineNitroPlugin(async (nitroApp) => {
 		redact,
 		_suppressDrainWarning: true
 	});
+	const streamSetting = evlogConfig?.stream;
+	if (streamSetting === true || streamSetting && typeof streamSetting === "object") startStreamServer(streamSetting === true ? {} : streamSetting).then((server) => {
+		nitroApp.hooks.hook("evlog:drain", (ctx) => {
+			if (ctx?.event) server.drain(ctx);
+		});
+	}).catch((err) => {
+		console.error("[evlog] failed to start stream server:", err);
+	});
 	if (!isEnabled()) {
 		nitroApp.hooks.hook("request", (event) => {
 			const e = event;