evlog 2.14.0 → 2.15.0

package/dist/{audit-mUutdf6A.d.mts → audit-CJl-wZ10.d.mts}

@@ -1,3 +1,110 @@
+//#region src/shared/plugin.d.ts
+/** Context passed to {@link EvlogPlugin.setup} when the plugin is registered. */
+interface PluginSetupContext {
+  env: EnvironmentContext;
+}
+/** Per-request context for `onRequestStart` / `onRequestFinish`. */
+interface RequestLifecycleContext {
+  logger: RequestLogger;
+  request: {
+    method: string;
+    path: string;
+    requestId?: string;
+  };
+  /** Pre-filtered safe request headers (sensitive headers stripped). */
+  headers?: Record<string, string>;
+}
+interface RequestFinishContext extends RequestLifecycleContext {
+  /** `null` when the event was sampled out or disabled. */
+  event: WideEvent | null;
+  status?: number;
+  durationMs: number;
+  error?: Error;
+}
+/** Context passed to {@link EvlogPlugin.onClientLog} for client-submitted events. */
+interface ClientLogContext {
+  /** Raw client payload, before normalization. */
+  payload: Record<string, unknown>;
+  request?: {
+    method?: string;
+    path?: string;
+  };
+  headers?: Record<string, string>;
+}
+/**
+ * Canonical extension point for evlog. A plugin can opt into any subset of
+ * hooks; drains and enrichers are special cases (see {@link drainPlugin} and
+ * {@link enricherPlugin}).
+ *
+ * @example
+ * ```ts
+ * export const tenantPlugin = definePlugin({
+ *   name: 'tenant',
+ *   onRequestStart({ logger, headers }) {
+ *     const tenantId = headers?.['x-tenant-id']
+ *     if (tenantId) logger.set({ tenant: { id: tenantId } })
+ *   },
+ *   enrich({ event }) {
+ *     event.region = process.env.REGION
+ *   },
+ * })
+ * ```
+ */
+interface EvlogPlugin {
+  /** Stable identifier. Used for de-duplication and error messages. */
+  name: string;
+  /** Run-once when the plugin is registered. */
+  setup?: (ctx: PluginSetupContext) => void | Promise<void>;
+  /** Runs before drain. */
+  enrich?: (ctx: EnrichContext) => void | Promise<void>;
+  /** Called for every emitted event. */
+  drain?: (ctx: DrainContext) => void | Promise<void>;
+  /** Tail sampling hook. Set `ctx.shouldKeep = true` to force-keep. */
+  keep?: (ctx: TailSamplingContext) => void | Promise<void>;
+  onRequestStart?: (ctx: RequestLifecycleContext) => void;
+  onRequestFinish?: (ctx: RequestFinishContext) => void;
+  /** Observe events submitted from browser/edge clients. */
+  onClientLog?: (ctx: ClientLogContext) => void;
+  /**
+   * Decorate per-request loggers with extra methods. Augment `RequestLogger`
+   * in a `.d.ts` to expose them on `useLogger()`.
+   */
+  extendLogger?: (logger: RequestLogger) => void;
+}
+/** Identity helper preserving plugin type inference. */
+declare function definePlugin(plugin: EvlogPlugin): EvlogPlugin;
+/** Wrap a standalone drain callback as an {@link EvlogPlugin}. */
+declare function drainPlugin(name: string, drain: NonNullable<EvlogPlugin['drain']>): EvlogPlugin;
+/** Wrap a standalone enricher callback as an {@link EvlogPlugin}. */
+declare function enricherPlugin(name: string, enrich: NonNullable<EvlogPlugin['enrich']>): EvlogPlugin;
+/**
+ * Compiled view of a plugin set. Errors from individual hooks are caught and
+ * logged to `console.error` with the plugin name — they never break the request.
+ */
+interface PluginRunner {
+  readonly plugins: readonly EvlogPlugin[];
+  /** `true` when at least one plugin implements the matching hook. */
+  readonly hasEnrich: boolean;
+  readonly hasDrain: boolean;
+  readonly hasKeep: boolean;
+  readonly hasRequestLifecycle: boolean;
+  readonly hasClientLog: boolean;
+  readonly hasExtendLogger: boolean;
+  applyExtendLogger: (logger: RequestLogger) => void;
+  runOnRequestStart: (ctx: RequestLifecycleContext) => void;
+  runOnRequestFinish: (ctx: RequestFinishContext) => void;
+  runEnrich: (ctx: EnrichContext) => Promise<void>;
+  /** Drains run concurrently (`Promise.allSettled`). */
+  runDrain: (ctx: DrainContext) => Promise<void>;
+  runKeep: (ctx: TailSamplingContext) => Promise<void>;
+  runOnClientLog: (ctx: ClientLogContext) => void;
+  runSetup: (ctx: PluginSetupContext) => Promise<void>;
+}
+/** De-duplicates by `name` — last registration wins. */
+declare function createPluginRunner(plugins?: EvlogPlugin[]): PluginRunner;
+/** Shared no-op runner used when no plugins are registered. */
+declare function getEmptyPluginRunner(): PluginRunner;
+//#endregion
 //#region src/types.d.ts
 declare module 'nitropack/types' {
   interface NitroRuntimeHooks {
@@ -359,6 +466,31 @@ interface LoggerConfig {
    * ```
    */
   drain?: (ctx: DrainContext) => void | Promise<void>;
+  /**
+   * Plugins registered globally with the logger.
+   *
+   * Plugins are the canonical extension contract for evlog: they can opt into
+   * `enrich`, `drain`, `keep`, lifecycle hooks (`onRequestStart`, `onRequestFinish`),
+   * client-log observation, and per-request logger decoration. See
+   * {@link import('./shared/plugin').EvlogPlugin} for the full surface.
+   *
+   * Plugin drains run alongside the standalone `drain` callback (composed with
+   * `Promise.allSettled`), so you can mix one-off drains and plugin-shaped
+   * extensions safely.
+   *
+   * @example
+   * ```ts
+   * import { initLogger, definePlugin } from 'evlog'
+   * import { createAxiomDrain } from 'evlog/axiom'
+   *
+   * initLogger({
+   *   plugins: [
+   *     definePlugin({ name: 'axiom', drain: createAxiomDrain() }),
+   *   ],
+   * })
+   * ```
+   */
+  plugins?: Array<EvlogPlugin>;
   /** @internal Suppress the "silent without drain" warning (used by hook-based frameworks like Nitro/Nuxt) */
   _suppressDrainWarning?: boolean;
 }
@@ -700,6 +832,16 @@ interface RequestLoggerOptions {
   method?: string;
   path?: string;
   requestId?: string;
+  /**
+   * Registers async drain work with the host runtime so it can finish after the
+   * HTTP response is returned. Required on **Cloudflare Workers** (and similar
+   * edge runtimes): without this, `initLogger({ drain })` + `log.emit()` may
+   * never complete outbound HTTP to observability backends.
+   *
+   * Pass the same function you would pass to `ExecutionContext#waitUntil`, e.g.
+   * `context.waitUntil.bind(context)` from a Workers `fetch` handler.
+   */
+  waitUntil?: (promise: Promise<unknown>) => void;
 }
 /**
  * H3 event context with evlog logger attached
@@ -1126,5 +1268,5 @@ declare function signed(drain: DrainFn, options: SignedOptions): DrainFn;
  */
 declare const auditRedactPreset: RedactConfig;
 //#endregion
-export { SamplingRates as $, AuditFields as A, H3EventContext as B, buildAuditFields as C, withAudit as D, signed as E, DrainContext as F, LoggerConfig as G, InternalFields as H, EnrichContext as I, RequestLogEntry as J, ParsedError as K, EnvironmentContext as L, AuditTarget as M, BaseWideEvent as N, withAuditMethods as O, DeepPartial as P, SamplingConfig as Q, ErrorOptions as R, auditRedactPreset as S, mockAudit as T, Log as U, IngestPayload as V, LogLevel as W, RequestLoggerOptions as X, RequestLogger as Y, RouteConfig as Z, WithAuditOptions as _, AuditInput as a, auditEnricher as b, AuditOnlyOptions as c, DefinedAuditAction as d, ServerEvent as et, DrainFn as f, WithAuditContext as g, SignedOptions as h, AuditEnricherOptions as i, WideEvent as it, AuditLoggerMethod as j, AuditActor as k, AuditPatchOp as l, SignedChainState as m, AuditDeniedError as n, TailSamplingContext as nt, AuditMatcher as o, MockAudit as p, RedactConfig as q, AuditDiffOptions as r, TransportConfig as rt, AuditMethod as s, AUDIT_SCHEMA_VERSION as t, TailSamplingCondition as tt, AuditableLogger as u, audit as v, defineAuditAction as w, auditOnly as x, auditDiff as y, FieldContext as z };
-//# sourceMappingURL=audit-mUutdf6A.d.mts.map
+export { SamplingRates as $, AuditFields as A, H3EventContext as B, buildAuditFields as C, withAudit as D, signed as E, DrainContext as F, LoggerConfig as G, InternalFields as H, EnrichContext as I, RequestLogEntry as J, ParsedError as K, EnvironmentContext as L, AuditTarget as M, BaseWideEvent as N, withAuditMethods as O, DeepPartial as P, SamplingConfig as Q, ErrorOptions as R, auditRedactPreset as S, mockAudit as T, Log as U, IngestPayload as V, LogLevel as W, RequestLoggerOptions as X, RequestLogger as Y, RouteConfig as Z, WithAuditOptions as _, AuditInput as a, ClientLogContext as at, auditEnricher as b, AuditOnlyOptions as c, PluginSetupContext as ct, DefinedAuditAction as d, createPluginRunner as dt, ServerEvent as et, DrainFn as f, definePlugin as ft, WithAuditContext as g, SignedOptions as h, getEmptyPluginRunner as ht, AuditEnricherOptions as i, WideEvent as it, AuditLoggerMethod as j, AuditActor as k, AuditPatchOp as l, RequestFinishContext as lt, SignedChainState as m, enricherPlugin as mt, AuditDeniedError as n, TailSamplingContext as nt, AuditMatcher as o, EvlogPlugin as ot, MockAudit as p, drainPlugin as pt, RedactConfig as q, AuditDiffOptions as r, TransportConfig as rt, AuditMethod as s, PluginRunner as st, AUDIT_SCHEMA_VERSION as t, TailSamplingCondition as tt, AuditableLogger as u, RequestLifecycleContext as ut, audit as v, defineAuditAction as w, auditOnly as x, auditDiff as y, FieldContext as z };
+//# sourceMappingURL=audit-CJl-wZ10.d.mts.map

package/dist/audit-CJl-wZ10.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-CJl-wZ10.d.mts","names":[],"sources":["../src/shared/plugin.ts","../src/types.ts","../src/audit.ts"],"mappings":";AAGA;AAAA,UAAiB,kBAAA;EACf,GAAA,EAAK,kBAAA;AAAA;;UAIU,uBAAA;EACf,MAAA,EAAQ,aAAA;EACR,OAAA;IACE,MAAA;IACA,IAAA;IACA,SAAA;EAAA;EAFA;EAKF,OAAA,GAAU,MAAA;AAAA;AAAA,UAGK,oBAAA,SAA6B,uBAAA;EAHlC;EAKV,KAAA,EAAO,SAAA;EACP,MAAA;EACA,UAAA;EACA,KAAA,GAAQ,KAAA;AAAA;;UAIO,gBAAA;EAT6B;EAW5C,OAAA,EAAS,MAAA;EACT,OAAA;IACE,MAAA;IACA,IAAA;EAAA;EAEF,OAAA,GAAU,MAAA;AAAA;;;;;AAPZ;;;;;;;;;;;;;AA6BA;;UAAiB,WAAA;EAID;EAFd,IAAA;EAIe;EAFf,KAAA,IAAS,GAAA,EAAK,kBAAA,YAA8B,OAAA;EAI9B;EAFd,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EAI3B;EAFb,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAGf;EADvB,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;EAC5C,cAAA,IAAkB,GAAA,EAAK,uBAAA;EACvB,eAAA,IAAmB,GAAA,EAAK,oBAAA;EAOa;EALrC,WAAA,IAAe,GAAA,EAAK,gBAAA;EAZpB;;;;EAiBA,YAAA,IAAgB,MAAA,EAAQ,aAAA;AAAA;;iBAIV,YAAA,CAAa,MAAA,EAAQ,WAAA,GAAc,WAAA;;iBAKnC,WAAA,CAAY,IAAA,UAAc,KAAA,EAAO,WAAA,CAAY,WAAA,aAAwB,WAAA;;iBAKrE,cAAA,CAAe,IAAA,UAAc,MAAA,EAAQ,WAAA,CAAY,WAAA,cAAyB,WAAA;;;;;UAQzE,YAAA;EAAA,SACN,OAAA,WAAkB,WAAA;EA/BJ;EAAA,SAiCd,SAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,mBAAA;EAAA,SACA,YAAA;EAAA,SACA,eAAA;EACT,iBAAA,GAAoB,MAAA,EAAQ,aAAA;EAC5B,iBAAA,GAAoB,GAAA,EAAK,uBAAA;EACzB,kBAAA,GAAqB,GAAA,EAAK,oBAAA;EAC1B,SAAA,GAAY,GAAA,EAAK,aAAA,KAAkB,OAAA;EAlCE;EAoCrC,QAAA,GAAW,GAAA,EAAK,YAAA,KAAiB,OAAA;EACjC,OAAA,GAAU,GAAA,EAAK,mBAAA,KAAwB,OAAA;EACvC,cAAA,GAAiB,GAAA,EAAK,gBAAA;EACtB,QAAA,GAAW,GAAA,EAAK,kBAAA,KAAuB,OAAA;AAAA;;iBAQzB,kBAAA,CAAmB,OAAA,GAAS,WAAA,KAAqB,YAAA;;iBAiHjD,oBAAA,CAAA,GAAwB,YAAA;;;;YCzO5B,iBAAA;IDAuB;;;;AAKnC;;;;;;;;;ICSI,iBAAA,GAAoB,GAAA,EAAK,mBAAA,YAA+B,OAAA;IDD1D;;;;AAGF;;;;;;;ICWI,cAAA,GAAiB,GAAA,EAAK,aAAA,YAAyB,OAAA;IDXL;;;;;;;;;AAS9C;;;;;;;ICoBI,aAAA,GAAgB,GAAA,EAAK,YAAA,YAAwB,OAAA;EAAA;AAAA;AAAA;EAAA,UAKrC,iBAAA;IACR,iBAAA,GAAoB,GAAA,EAAK,mBAAA,YAA+B,OAAA;IACxD,cAAA,GAAiB,GAAA,EAAK,aAAA,YAAyB,OAAA;IAC/C,aAAA,GAAgB,GAAA,EAAK,YAAA,YAAwB,OAAA;EAAA;AAAA;;;;UAOhC,eAAA;EDEuB;;;;ECGtC,OAAA;EDGoB;;;;ECGpB,QAAA;EDbA;;;;ECmBA,WAAA,GAAc,kBAAA;AAAA;;;;UAMC,aAAA;EACf,SAAA;EACA,KAAA;EAAA,CACC,GAAA;AAAA;;;;;;;;UAUc,YAAA;ED5Bf;EC8BA,KAAA;ED9Be;ECgCf,QAAA,GAAW,MAAA;ED3Ba;;;;AAI1B;;;;ECgCE,QAAA,WAAmB,KAAA;EDhCQ;;;;AAK7B;ECiCE,WAAA;;EAEA,QAAA,GAAW,KAAA,EAAO,MAAA,GAAS,KAAA;AAAA;;;;UAMZ,aAAA;EDzCgC;EC2C/C,IAAA;ED3CwC;EC6CxC,IAAA;ED7C8F;EC+C9F,KAAA;ED1Cc;EC4Cd,KAAA;AAAA;;;;;UAOe,qBAAA;EDnDc;ECqD7B,MAAA;EDrD+D;ECuD/D,QAAA;EDvDwF;ECyDxF,IAAA;AAAA;ADjDF;;;;AAAA,UCwDiB,mBAAA;ED9CU;ECgDzB,MAAA;ED9CiB;ECgDjB,QAAA;ED9CgB;ECgDhB,IAAA;ED/Ce;ECiDf,MAAA;EDhDsB;ECkDtB,OAAA,EAAS,MAAA;EDjD8B;;;;ECsDvC,UAAA;AAAA;;;;;UAOe,aAAA;EDrEf;ECuEA,KAAA,EAAO,SAAA;EDvEa;ECyEpB,OAAA;IACE,MAAA;IACA,IAAA;IACA,SAAA;EAAA;ED1EmB;EC6ErB,OAAA,GAAU,MAAA;ED5EO;EC8EjB,QAAA;IACE,MAAA;IACA,OAAA,GAAU,MAAA;EAAA;AAAA;;;;;UAQG,YAAA;EDpFf;ECsFA,KAAA,EAAO,SAAA;EDtFU;ECwFjB,OAAA;IACE,MAAA;IACA,IAAA;IACA,SAAA;EAAA;ED1F4C;EC6F9C,OAAA,GAAU,MAAA;AAAA;;;;UAMK,cAAA;ED3FgD;;;AAiHjE;;;;;;;;ACqc0B;;;;;;;EAxcxB,KAAA,GAAQ,aAAA;EAzLuC;;;;;;;;;;;;;;;;;EA4M/C,IAAA,GAAO,qBAAA;AAAA;AA5M+C;;;AAAA,UAkNvC,WAAA;EA5M2C;EA8M1D,OAAA;AAAA;;;;UAMe,kBAAA;EArNL;EAuNV,OAAA;EAtN2B;EAwN3B,WAAA;EAxN0D;EA0N1D,OAAA;EAzNwB;EA2NxB,UAAA;EA3NiD;EA6NjD,MAAA;AAAA;;;;UAMe,YAAA;EAlOuC;AAOxD;;;;EAiOE,OAAA;EAtNA;EAwNA,GAAA,GAAM,OAAA,CAAQ,kBAAA;EAlNA;EAoNd,MAAA;EApNgC;EAsNhC,QAAA,GAAW,cAAA;EAhNiB;;;;;;EAuN5B,QAAA,GAAW,QAAA;EApNC;AAUd;;;;EAgNE,SAAA;EA3LkB;;;;;;;EAmMlB,MAAA;EA3MmB;;;;;;;;AAcrB;;;;;;;;;;AAeA;;;;;;;;;AAaA;;;;EAiME,MAAA,aAAmB,YAAA;EA7LnB;;;;;;;;AAkBF;;;;;;;;;;;;;;;;;;;;;;AAsBA;EAqLE,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;;;;;;;;;;;;;AArKxC;;;;;;;;;;AA4CA;;EAkJE,OAAA,GAAU,KAAA,CAzBmC,WAAA;EAvH7C;EAkJA,qBAAA;AAAA;;;;;;;;;UAWe,UAAA;EACf,IAAA;EACA,EAAA;EACA,WAAA;EACA,KAAA;EACA,KAAA;EACA,KAAA;EACA,MAAA;EACA,QAAA;AAAA;;;;;;;;UAUe,WAAA;EACf,IAAA;EACA,EAAA;EAAA,CACC,GAAA;AAAA;;;;;;;;;;;;;;;;;;AArBH;;;UA4CiB,WAAA;EA3Cf;EA6CA,MAAA;EACA,KAAA,EAAO,UAAA;EACP,MAAA,GAAS,WAAA;EACT,OAAA;EA3CA;EA6CA,MAAA;EA3CA;EA6CA,OAAA;IAAY,MAAA;IAAkB,KAAA;EAAA;;EAE9B,WAAA;EApCA;EAsCA,aAAA;EApCC;EAsCD,OAAA;EAtCY;EAwCZ,cAAA;EAjB0B;EAmB1B,OAAA;IACE,SAAA;IACA,OAAA;IACA,EAAA;IACA,SAAA;IACA,QAAA;IAAA,CACC,GAAA;EAAA;EAlBH;EAqBA,SAAA;EAnBY;EAqBZ,QAAA;EAnBA;EAqBA,IAAA;AAAA;;;;;;;UASe,aAAA;EACf,SAAA;EACA,KAAA;EACA,OAAA;EACA,WAAA;EACA,OAAA;EACA,UAAA;EACA,MAAA;EACA,KAAA,GAAQ,WAAA;AAAA;;;;KAME,SAAA,GAAY,aAAA,GAAgB,MAAA;;;;;KAM5B,WAAA,MAAiB,CAAA,SAAU,KAAA,YACnC,CAAA,GACA,CAAA,gCACgB,CAAA,IAAK,WAAA,CAAY,CAAA,CAAE,CAAA,OACjC,CAAA;;AAVN;;;UAgBiB,cAAA;EACf,MAAA;EACA,OAAA;EACA,WAAA,GAAc,eAAA;EAbO;EAerB,SAAA;EAfqC;EAiBrC,gBAAA;AAAA;;;;UAMe,eAAA;EACf,KAAA;EACA,OAAA;EACA,SAAA;AAAA;;;;;;;KASU,YAAA,oBAAgC,MAAA,qBAC1C,WAAA,CAAY,IAAA,CAAK,CAAA,QAAS,cAAA,KAAmB,cAAA;;;;;;AA1B/C;;;;;;;;;;;;AAaA;;;;;;;;;AAYA;;;;;;;;;UAsCiB,aAAA,oBAAiC,MAAA;EArCW;;;;;;;;EA8C3D,GAAA,GAAM,OAAA,EAAS,YAAA,CAAa,CAAA;EA9C+B;AAqC7D;;;;EAgBE,KAAA,GAAQ,KAAA,EAAO,KAAA,WAAgB,OAAA,GAAU,YAAA,CAAa,CAAA;EAPvC;;;;;EAcf,IAAA,GAAO,OAAA,UAAiB,OAAA,GAAU,YAAA,CAAa,CAAA;EAOA;;;;;EAA/C,IAAA,GAAO,OAAA,UAAiB,OAAA,GAAU,YAAA,CAAa,CAAA;EAc7B;;;;;;;EALlB,IAAA,GAAO,SAAA,GAAY,YAAA,CAAa,CAAA;IAAO,UAAA;EAAA,MAA2B,SAAA;EA9BtC;;;EAmC5B,UAAA,QAAkB,YAAA,CAAa,CAAA,IAAK,MAAA;EA5B5B;;;;;;;;;;;;;;;;;;;EAiDR,IAAA,IAAQ,KAAA,UAAe,EAAA,eAAiB,OAAA;EArBxC;;;;;;;;;;;;AAiDF;;;;;;;;;;EAJE,KAAA,GAAQ,iBAAA;AAAA;;UAIO,iBAAA;EAAA,CACd,KAAA,EAD+B,UAAA;EAEhC,IAAA,GAAO,MAAA,UAAgB,KAAA,EAAO,IAAA,CADM,UAAA;AAAA;AAOtC;;;AAAA,KAAY,QAAA;;AAWZ;;;;;;;;UAAiB,GAAA;EAMf;;;;;EAAA,IAAA,CAAK,GAAA,UAAa,OAAA;EAClB,IAAA,CAAK,KAAA,EAAO,MAAA;EAON;;;;;EAAN,KAAA,CAAM,GAAA,UAAa,OAAA;EACnB,KAAA,CAAM,KAAA,EAAO,MAAA;EAOK;;;;;EAAlB,IAAA,CAAK,GAAA,UAAa,OAAA;EAClB,IAAA,CAAK,KAAA,EAAO,MAAA;EAQZ;;;;;EADA,KAAA,CAAM,GAAA,UAAa,OAAA;EACnB,KAAA,CAAM,KAAA,EAAO,MAAA;AAAA;;;;UAME,YAAA;EAQf;EANA,OAAA;EAUA;EARA,MAAA;EAaA;EAXA,GAAA;EAWiB;EATjB,GAAA;EAee;EAbf,IAAA;;EAEA,KAAA,GAAQ,KAAA;EAYR;;;;EAPA,QAAA,GAAW,MAAA;AAAA;;;AAyBb;UAnBiB,oBAAA;EACf,MAAA;EACA,IAAA;EACA,SAAA;EAiBM;;;;;;;;;EAPN,SAAA,IAAa,OAAA,EAAS,OAAA;AAAA;;;;UAMP,cAAA;EACf,GAAA,GAAM,aAAA;EACN,SAAA;EACA,MAAA;EAcA;EAZA,eAAA;EAcA;EAZA,aAAA;EAcE;EAZF,gBAAA;EAAA,CACC,GAAA;AAAA;;;;UAMc,WAAA;EACf,MAAA;EACA,IAAA;EACA,OAAA,EAAS,cAAA;IAWT,yEATE,UAAA;MACE,OAAA;QACE,SAAA,GAAY,OAAA,EAAS,OAAA;MAAA;IAAA,GAaD;IATxB,SAAA,IAAa,OAAA,EAAS,OAAA;EAAA;EAExB,IAAA;IAAS,GAAA;MAAQ,UAAA;IAAA;EAAA;EACjB,QAAA,GAAW,QAAA;AAAA;;;;UAMI,WAAA;EACf,OAAA;EACA,MAAA;EACA,GAAA;EACA,GAAA;EACA,IAAA;EACA,GAAA;AAAA;;;ADzzBF;;;;AAAA,cEKa,oBAAA;AFAb;;;;;;;AAAA,UESiB,UAAA;EACf,MAAA;EACA,KAAA,EAAO,UAAA;EACP,MAAA,GAAS,WAAA;EACT,OAAA,GAAU,WAAA;EACV,MAAA;EACA,OAAA,GAAU,WAAA;EACV,WAAA;EACA,aAAA;EACA,OAAA;AAAA;;;;;;;;;iBAgEc,gBAAA,CAAiB,KAAA,EAAO,UAAA,GAAa,WAAA;;;;;AF9DrD;;;;;;;;;;;;;AA6BA;iBE6EgB,gBAAA,oBAAoC,MAAA,kBAAA,CAAyB,MAAA,EAAQ,aAAA,CAAc,CAAA,IAAK,eAAA,CAAgB,CAAA;;;;KA+B5G,eAAA,oBAAmC,MAAA,qBAA2B,aAAA,CAAc,CAAA;EAAO,KAAA,EAAO,WAAA,CAAY,CAAA;AAAA;;UAGjG,WAAA,oBAA+B,MAAA;EAAA,CAC7C,KAAA,EAAO,UAAA;EFrGe;;;;;EE2GvB,IAAA,GAAO,MAAA,UAAgB,KAAA,EAAO,IAAA,CAAK,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;iBAsBrB,KAAA,CAAM,KAAA,EAAO,UAAA,GAAa,SAAA;;;;;;;;;;;AFrH1C;;;;;;;;;AAKA;;;;;iBEgJgB,SAAA,iBAAA,CACd,OAAA,EAAS,gBAAA,CAAiB,MAAA,GAC1B,EAAA,GAAK,KAAA,EAAO,MAAA,EAAQ,GAAA,EAAK,gBAAA,KAAqB,OAAA,CAAQ,OAAA,IAAW,OAAA,IAC/D,KAAA,EAAO,MAAA,EAAQ,GAAA,EAAK,gBAAA,KAAqB,OAAA,CAAQ,OAAA;;;;;;cAqCxC,gBAAA,SAAyB,KAAA;cAExB,MAAA;AAAA;;UAQG,gBAAA;EACf,MAAA;EACA,MAAA,GAAS,WAAA,KAAgB,KAAA,EAAO,MAAA,KAAW,WAAA;AAAA;;;;;UAO5B,gBAAA;EACf,KAAA,EAAO,UAAA;EACP,WAAA;EACA,aAAA;AAAA;;;AFjMF;;;;;;;;;;;;;;;;;iBEuNgB,SAAA,CACd,MAAA,WACA,KAAA,WACA,OAAA,GAAS,gBAAA;EACN,MAAA;EAAkB,KAAA;EAAiB,KAAA,EAAO,YAAA;AAAA;;UAkE9B,YAAA;EACf,EAAA;EACA,IAAA;EACA,KAAA;AAAA;;UAIe,gBAAA;EF1RU;EE4RzB,WAAA;EF3RA;EE6RA,WAAA;EF7RqB;EE+RrB,aAAA;EF9RiB;EEgSjB,YAAA;AAAA;;;;;;;;;;;;;;;;;;AFnRF;iBEwSgB,iBAAA,oDAAA,CACd,MAAA,UACA,OAAA;EAAY,MAAA,GAAS,WAAA;AAAA,IACpB,kBAAA,CAAmB,WAAA;;;;;KAkBV,kBAAA,4CACV,KAAA,EAAO,WAAA,kBACH,IAAA,CAAK,UAAA;EAAqC,MAAA,GAAS,IAAA,CAAK,WAAA;IAAyB,IAAA,GAAO,WAAA;EAAA;AAAA,IACxF,IAAA,CAAK,UAAA,gBACN,UAAA;;;;;ADqPqB;;;;;;;;;;;;;;;;;;;iBC5NV,SAAA,CAAA,GAAa,SAAA;;UAmBZ,SAAA;EACf,MAAA,EAAQ,WAAA;EACR,OAAA;EACA,gBAAA,GAAmB,OAAA,EAAS,YAAA;AAAA;;UAIb,YAAA;EACf,MAAA,YAAkB,MAAA;EAClB,OAAA,GAAU,WAAA;EACV,KAAA,GAAQ,OAAA,CAAQ,UAAA;EAChB,MAAA,GAAS,OAAA,CAAQ,WAAA;AAAA;;UAqDF,6BAAA;EDhfb;ECkfF,UAAA,GAAa,GAAA,EAAK,aAAA,KAAkB,OAAA,CAAQ,UAAA,uBAAiC,UAAA;AAAA;;UAI9D,oBAAA;EDtfuC;;AAOxD;;ECofE,QAAA,IAAY,GAAA,EAAK,aAAA;EDnee;;;;ECwehC,MAAA,GAAS,6BAAA;EDxeuB;EC0ehC,SAAA;AAAA;;;;;;;;;ADvdF;;;;;;;iBCyegB,aAAA,CAAc,OAAA,GAAS,oBAAA,IAA6B,GAAA,EAAK,aAAA,YAAyB,OAAA;;UAwCjF,gBAAA;ED7gBf;;;;;ECmhBA,KAAA;AAAA;;KAIU,OAAA,IAAW,GAAA,EAAK,YAAA,YAAwB,OAAA;;;ADhgBpD;;;;;;;;;;AAeA;;;;;;;;;AAaA;;;iBC8fgB,SAAA,CAAU,KAAA,EAAO,OAAA,EAAS,OAAA,GAAS,gBAAA,GAAwB,OAAA;;UAY1D,gBAAA;EDpgBf;ECsgBA,IAAA,QAAY,OAAA;EDlgBZ;ECogBA,IAAA,GAAO,IAAA,aAAiB,OAAA;AAAA;;KAId,aAAA;EACN,QAAA;EAAkB,MAAA;EAAgB,SAAA;AAAA;EAClC,QAAA;EAAwB,KAAA,GAAQ,gBAAA;EAAkB,SAAA;AAAA;;;;;;;;;;;;;;;ADxexD;;;;;;;;;;;;iBCogBgB,MAAA,CAAO,KAAA,EAAO,OAAA,EAAS,OAAA,EAAS,aAAA,GAAgB,OAAA;;ADpfhE;;;;;;;;;;AA4CA;;;;;cCgkBa,iBAAA,EAAmB,YAAA"}

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

@@ -1,4 +1,4 @@
-import { Y as RequestLogger } from "../audit-mUutdf6A.mjs";
+import { Y as RequestLogger } from "../audit-CJl-wZ10.mjs";
 
 //#region src/better-auth/index.d.ts
 /**

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

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

package/dist/browser.d.mts

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

package/dist/define-D6OJdSUH.mjs

@@ -0,0 +1,63 @@
+//#region src/shared/define.ts
+/**
+* Identity helper for authoring an evlog configuration once and sharing it
+* across `initLogger` and framework middleware.
+*
+* @example
+* ```ts
+* export const config = defineEvlog({
+*   service: 'checkout',
+*   redact: true,
+*   sampling: { rates: { info: 25 } },
+*   enrich: createDefaultEnrichers(),
+*   plugins: [drainPlugin('axiom', createAxiomDrain())],
+* })
+*
+* initLogger(toLoggerConfig(config))
+* app.use(evlogMiddleware(config))
+* ```
+*/
+function defineEvlog(config) {
+	return config;
+}
+/**
+* Project an {@link EvlogConfig} onto the surface accepted by `initLogger`.
+* Strips middleware-only fields (`include`, `exclude`, `routes`, `enrich`,
+* `keep`); drains and plugins are preserved.
+*/
+function toLoggerConfig(config) {
+	const env = config.env ? { ...config.env } : config.service || config.environment ? {} : void 0;
+	if (env) {
+		if (config.service) env.service = config.service;
+		if (config.environment) env.environment = config.environment;
+	}
+	const out = {};
+	if (env) out.env = env;
+	if (config.enabled !== void 0) out.enabled = config.enabled;
+	if (config.pretty !== void 0) out.pretty = config.pretty;
+	if (config.sampling !== void 0) out.sampling = config.sampling;
+	if (config.minLevel !== void 0) out.minLevel = config.minLevel;
+	if (config.stringify !== void 0) out.stringify = config.stringify;
+	if (config.silent !== void 0) out.silent = config.silent;
+	if (config.redact !== void 0) out.redact = config.redact;
+	if (config.drain) out.drain = config.drain;
+	if (config.plugins) out.plugins = config.plugins;
+	return out;
+}
+/** Project an {@link EvlogConfig} onto the surface accepted by framework middleware. */
+function toMiddlewareOptions(config) {
+	const out = {};
+	if (config.include) out.include = config.include;
+	if (config.exclude) out.exclude = config.exclude;
+	if (config.routes) out.routes = config.routes;
+	if (config.drain) out.drain = config.drain;
+	if (config.enrich) out.enrich = config.enrich;
+	if (config.keep) out.keep = config.keep;
+	if (config.redact !== void 0) out.redact = config.redact;
+	if (config.plugins) out.plugins = config.plugins;
+	return out;
+}
+//#endregion
+export { toLoggerConfig as n, toMiddlewareOptions as r, defineEvlog as t };
+
+//# sourceMappingURL=define-D6OJdSUH.mjs.map

package/dist/define-D6OJdSUH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-D6OJdSUH.mjs","names":[],"sources":["../src/shared/define.ts"],"sourcesContent":["import type { DrainContext, EnrichContext, EnvironmentContext, LoggerConfig, RedactConfig, SamplingConfig, TailSamplingContext } from '../types'\nimport type { BaseEvlogOptions } from './middleware'\nimport type { EvlogPlugin } from './plugin'\n\n/**\n * Single-config shape accepted everywhere evlog is bootstrapped: at\n * `initLogger`, in framework middleware, and in the Nuxt module. Authored\n * with {@link defineEvlog} and split via {@link toLoggerConfig} /\n * {@link toMiddlewareOptions}.\n */\nexport interface EvlogConfig extends BaseEvlogOptions {\n  service?: string\n  environment?: string\n  /** Full environment context override (advanced). */\n  env?: Partial<EnvironmentContext>\n  /** Enable or disable all logging globally. */\n  enabled?: boolean\n  /** Auto-detected from `NODE_ENV` when omitted. */\n  pretty?: boolean\n  sampling?: SamplingConfig\n  /** Suppress built-in console output (useful when drains own the channel). */\n  silent?: boolean\n  /** Emit JSON strings (default) or raw objects in non-pretty mode. */\n  stringify?: boolean\n  /** Minimum severity for the global `log` API. */\n  minLevel?: LoggerConfig['minLevel']\n}\n\n/**\n * Identity helper for authoring an evlog configuration once and sharing it\n * across `initLogger` and framework middleware.\n *\n * @example\n * ```ts\n * export const config = defineEvlog({\n *   service: 'checkout',\n *   redact: true,\n *   sampling: { rates: { info: 25 } },\n *   enrich: createDefaultEnrichers(),\n *   plugins: [drainPlugin('axiom', createAxiomDrain())],\n * })\n *\n * initLogger(toLoggerConfig(config))\n * app.use(evlogMiddleware(config))\n * ```\n */\nexport function defineEvlog<T extends EvlogConfig>(config: T): T {\n  return config\n}\n\n/**\n * Project an {@link EvlogConfig} onto the surface accepted by `initLogger`.\n * Strips middleware-only fields (`include`, `exclude`, `routes`, `enrich`,\n * `keep`); drains and plugins are preserved.\n */\nexport function toLoggerConfig(config: EvlogConfig): LoggerConfig {\n  const env: Partial<EnvironmentContext> | undefined = config.env\n    ? { ...config.env }\n    : config.service || config.environment\n      ? {}\n      : undefined\n  if (env) {\n    if (config.service) env.service = config.service\n    if (config.environment) env.environment = config.environment\n  }\n  const out: LoggerConfig = {}\n  if (env) out.env = env\n  if (config.enabled !== undefined) out.enabled = config.enabled\n  if (config.pretty !== undefined) out.pretty = config.pretty\n  if (config.sampling !== undefined) out.sampling = config.sampling\n  if (config.minLevel !== undefined) out.minLevel = config.minLevel\n  if (config.stringify !== undefined) out.stringify = config.stringify\n  if (config.silent !== undefined) out.silent = config.silent\n  if (config.redact !== undefined) out.redact = config.redact as boolean | RedactConfig | undefined\n  if (config.drain) out.drain = config.drain\n  if (config.plugins) out.plugins = config.plugins\n  return out\n}\n\n/** Project an {@link EvlogConfig} onto the surface accepted by framework middleware. */\nexport function toMiddlewareOptions<T extends BaseEvlogOptions>(config: EvlogConfig): T {\n  const out: BaseEvlogOptions = {}\n  if (config.include) out.include = config.include\n  if (config.exclude) out.exclude = config.exclude\n  if (config.routes) out.routes = config.routes\n  if (config.drain) out.drain = config.drain as (ctx: DrainContext) => void | Promise<void>\n  if (config.enrich) out.enrich = config.enrich as (ctx: EnrichContext) => void | Promise<void>\n  if (config.keep) out.keep = config.keep as (ctx: TailSamplingContext) => void | Promise<void>\n  if (config.redact !== undefined) out.redact = config.redact as boolean | RedactConfig | undefined\n  if (config.plugins) out.plugins = config.plugins as EvlogPlugin[]\n  return out as T\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,YAAmC,QAAc;AAC/D,QAAO;;;;;;;AAQT,SAAgB,eAAe,QAAmC;CAChE,MAAM,MAA+C,OAAO,MACxD,EAAE,GAAG,OAAO,KAAK,GACjB,OAAO,WAAW,OAAO,cACvB,EAAE,GACF,KAAA;AACN,KAAI,KAAK;AACP,MAAI,OAAO,QAAS,KAAI,UAAU,OAAO;AACzC,MAAI,OAAO,YAAa,KAAI,cAAc,OAAO;;CAEnD,MAAM,MAAoB,EAAE;AAC5B,KAAI,IAAK,KAAI,MAAM;AACnB,KAAI,OAAO,YAAY,KAAA,EAAW,KAAI,UAAU,OAAO;AACvD,KAAI,OAAO,WAAW,KAAA,EAAW,KAAI,SAAS,OAAO;AACrD,KAAI,OAAO,aAAa,KAAA,EAAW,KAAI,WAAW,OAAO;AACzD,KAAI,OAAO,aAAa,KAAA,EAAW,KAAI,WAAW,OAAO;AACzD,KAAI,OAAO,cAAc,KAAA,EAAW,KAAI,YAAY,OAAO;AAC3D,KAAI,OAAO,WAAW,KAAA,EAAW,KAAI,SAAS,OAAO;AACrD,KAAI,OAAO,WAAW,KAAA,EAAW,KAAI,SAAS,OAAO;AACrD,KAAI,OAAO,MAAO,KAAI,QAAQ,OAAO;AACrC,KAAI,OAAO,QAAS,KAAI,UAAU,OAAO;AACzC,QAAO;;;AAIT,SAAgB,oBAAgD,QAAwB;CACtF,MAAM,MAAwB,EAAE;AAChC,KAAI,OAAO,QAAS,KAAI,UAAU,OAAO;AACzC,KAAI,OAAO,QAAS,KAAI,UAAU,OAAO;AACzC,KAAI,OAAO,OAAQ,KAAI,SAAS,OAAO;AACvC,KAAI,OAAO,MAAO,KAAI,QAAQ,OAAO;AACrC,KAAI,OAAO,OAAQ,KAAI,SAAS,OAAO;AACvC,KAAI,OAAO,KAAM,KAAI,OAAO,OAAO;AACnC,KAAI,OAAO,WAAW,KAAA,EAAW,KAAI,SAAS,OAAO;AACrD,KAAI,OAAO,QAAS,KAAI,UAAU,OAAO;AACzC,QAAO"}

package/dist/define-Fp8TrdEB.d.mts

@@ -0,0 +1,57 @@
+import { G as LoggerConfig, L as EnvironmentContext, Q as SamplingConfig } from "./audit-CJl-wZ10.mjs";
+import { t as BaseEvlogOptions } from "./middleware-CGM-bOvE.mjs";
+
+//#region src/shared/define.d.ts
+/**
+ * Single-config shape accepted everywhere evlog is bootstrapped: at
+ * `initLogger`, in framework middleware, and in the Nuxt module. Authored
+ * with {@link defineEvlog} and split via {@link toLoggerConfig} /
+ * {@link toMiddlewareOptions}.
+ */
+interface EvlogConfig extends BaseEvlogOptions {
+  service?: string;
+  environment?: string;
+  /** Full environment context override (advanced). */
+  env?: Partial<EnvironmentContext>;
+  /** Enable or disable all logging globally. */
+  enabled?: boolean;
+  /** Auto-detected from `NODE_ENV` when omitted. */
+  pretty?: boolean;
+  sampling?: SamplingConfig;
+  /** Suppress built-in console output (useful when drains own the channel). */
+  silent?: boolean;
+  /** Emit JSON strings (default) or raw objects in non-pretty mode. */
+  stringify?: boolean;
+  /** Minimum severity for the global `log` API. */
+  minLevel?: LoggerConfig['minLevel'];
+}
+/**
+ * Identity helper for authoring an evlog configuration once and sharing it
+ * across `initLogger` and framework middleware.
+ *
+ * @example
+ * ```ts
+ * export const config = defineEvlog({
+ *   service: 'checkout',
+ *   redact: true,
+ *   sampling: { rates: { info: 25 } },
+ *   enrich: createDefaultEnrichers(),
+ *   plugins: [drainPlugin('axiom', createAxiomDrain())],
+ * })
+ *
+ * initLogger(toLoggerConfig(config))
+ * app.use(evlogMiddleware(config))
+ * ```
+ */
+declare function defineEvlog<T extends EvlogConfig>(config: T): T;
+/**
+ * Project an {@link EvlogConfig} onto the surface accepted by `initLogger`.
+ * Strips middleware-only fields (`include`, `exclude`, `routes`, `enrich`,
+ * `keep`); drains and plugins are preserved.
+ */
+declare function toLoggerConfig(config: EvlogConfig): LoggerConfig;
+/** Project an {@link EvlogConfig} onto the surface accepted by framework middleware. */
+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-Fp8TrdEB.d.mts.map

package/dist/define-Fp8TrdEB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-Fp8TrdEB.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;EACA,QAAA,GAAW,cAAA;EALL;EAON,MAAA;EALA;EAOA,SAAA;EAJA;EAMA,QAAA,GAAW,YAAA;AAAA;;;;;;AAqBb;;;;;;;;;;;;;iBAAgB,WAAA,WAAsB,WAAA,CAAA,CAAa,MAAA,EAAQ,CAAA,GAAI,CAAA;;AAS/D;;;;iBAAgB,cAAA,CAAe,MAAA,EAAQ,WAAA,GAAc,YAAA;;iBAyBrC,mBAAA,WAA8B,gBAAA,CAAA,CAAkB,MAAA,EAAQ,WAAA,GAAc,CAAA"}

package/dist/{dist-Do8P4zWd.mjs → dist-BIlS38vi.mjs}

@@ -48,4 +48,4 @@ function parsePath(input = "") {
 //#endregion
 export { parseURL as t };
 
-//# sourceMappingURL=dist-Do8P4zWd.mjs.map
+//# sourceMappingURL=dist-BIlS38vi.mjs.map

package/dist/dist-BIlS38vi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dist-BIlS38vi.mjs","names":[],"sources":["../../../node_modules/.pnpm/ufo@1.6.4/node_modules/ufo/dist/index.mjs"],"sourcesContent":["const n = /[^\\0-\\x7E]/;\nconst t = /[\\x2E\\u3002\\uFF0E\\uFF61]/g;\nconst o = {\n  overflow: \"Overflow Error\",\n  \"not-basic\": \"Illegal Input\",\n  \"invalid-input\": \"Invalid Input\"\n};\nconst e = Math.floor;\nconst r = String.fromCharCode;\nfunction s(n2) {\n  throw new RangeError(o[n2]);\n}\nconst c = function(n2, t2) {\n  return n2 + 22 + 75 * (n2 < 26) - ((t2 != 0) << 5);\n};\nconst u = function(n2, t2, o2) {\n  let r2 = 0;\n  for (n2 = o2 ? e(n2 / 700) : n2 >> 1, n2 += e(n2 / t2); n2 > 455; r2 += 36) {\n    n2 = e(n2 / 35);\n  }\n  return e(r2 + 36 * n2 / (n2 + 38));\n};\nfunction toASCII(o2) {\n  return (function(n2, o3) {\n    const e2 = n2.split(\"@\");\n    let r2 = \"\";\n    e2.length > 1 && (r2 = e2[0] + \"@\", n2 = e2[1]);\n    const s2 = (function(n3, t2) {\n      const o4 = [];\n      let e3 = n3.length;\n      for (; e3--; ) {\n        o4[e3] = t2(n3[e3]);\n      }\n      return o4;\n    })((n2 = n2.replace(t, \".\")).split(\".\"), o3).join(\".\");\n    return r2 + s2;\n  })(o2, function(t2) {\n    return n.test(t2) ? \"xn--\" + (function(n2) {\n      const t3 = [];\n      const o3 = (n2 = (function(n3) {\n        const t4 = [];\n        let o4 = 0;\n        const e2 = n3.length;\n        for (; o4 < e2; ) {\n          const r2 = n3.charCodeAt(o4++);\n          if (r2 >= 55296 && r2 <= 56319 && o4 < e2) {\n            const e3 = n3.charCodeAt(o4++);\n            (64512 & e3) == 56320 ? t4.push(((1023 & r2) << 10) + (1023 & e3) + 65536) : (t4.push(r2), o4--);\n          } else {\n            t4.push(r2);\n          }\n        }\n        return t4;\n      })(n2)).length;\n      let f = 128;\n      let i = 0;\n      let l = 72;\n      for (const o4 of n2) {\n        o4 < 128 && t3.push(r(o4));\n      }\n      const h = t3.length;\n      let p = h;\n      for (h && t3.push(\"-\"); p < o3; ) {\n        let o4 = 2147483647;\n        for (const t4 of n2) {\n          t4 >= f && t4 < o4 && (o4 = t4);\n        }\n        const a = p + 1;\n        o4 - f > e((2147483647 - i) / a) && s(\"overflow\"), i += (o4 - f) * a, f = o4;\n        for (const o5 of n2) {\n          if (o5 < f && ++i > 2147483647 && s(\"overflow\"), o5 == f) {\n            let n3 = i;\n            for (let o6 = 36; ; o6 += 36) {\n              const s2 = o6 <= l ? 1 : o6 >= l + 26 ? 26 : o6 - l;\n              if (n3 < s2) {\n                break;\n              }\n              const u2 = n3 - s2;\n              const f2 = 36 - s2;\n              t3.push(r(c(s2 + u2 % f2, 0))), n3 = e(u2 / f2);\n            }\n            t3.push(r(c(n3, 0))), l = u(i, a, p == h), i = 0, ++p;\n          }\n        }\n        ++i, ++f;\n      }\n      return t3.join(\"\");\n    })(t2) : t2;\n  });\n}\n\nconst HASH_RE = /#/g;\nconst AMPERSAND_RE = /&/g;\nconst SLASH_RE = /\\//g;\nconst EQUAL_RE = /=/g;\nconst IM_RE = /\\?/g;\nconst PLUS_RE = /\\+/g;\nconst ENC_CARET_RE = /%5e/gi;\nconst ENC_BACKTICK_RE = /%60/gi;\nconst ENC_CURLY_OPEN_RE = /%7b/gi;\nconst ENC_PIPE_RE = /%7c/gi;\nconst ENC_CURLY_CLOSE_RE = /%7d/gi;\nconst ENC_SPACE_RE = /%20/gi;\nconst ENC_SLASH_RE = /%2f/gi;\nconst ENC_ENC_SLASH_RE = /%252f/gi;\nfunction encode(text) {\n  return encodeURI(\"\" + text).replace(ENC_PIPE_RE, \"|\");\n}\nfunction encodeHash(text) {\n  return encode(text).replace(ENC_CURLY_OPEN_RE, \"{\").replace(ENC_CURLY_CLOSE_RE, \"}\").replace(ENC_CARET_RE, \"^\");\n}\nfunction encodeQueryValue(input) {\n  return encode(typeof input === \"string\" ? input : JSON.stringify(input)).replace(PLUS_RE, \"%2B\").replace(ENC_SPACE_RE, \"+\").replace(HASH_RE, \"%23\").replace(AMPERSAND_RE, \"%26\").replace(ENC_BACKTICK_RE, \"`\").replace(ENC_CARET_RE, \"^\").replace(SLASH_RE, \"%2F\");\n}\nfunction encodeQueryKey(text) {\n  return encodeQueryValue(text).replace(EQUAL_RE, \"%3D\");\n}\nfunction encodePath(text) {\n  return encode(text).replace(HASH_RE, \"%23\").replace(IM_RE, \"%3F\").replace(ENC_ENC_SLASH_RE, \"%2F\").replace(AMPERSAND_RE, \"%26\").replace(PLUS_RE, \"%2B\");\n}\nfunction encodeParam(text) {\n  return encodePath(text).replace(SLASH_RE, \"%2F\");\n}\nfunction decode(text = \"\") {\n  try {\n    return decodeURIComponent(\"\" + text);\n  } catch {\n    return \"\" + text;\n  }\n}\nfunction decodePath(text) {\n  return decode(text.replace(ENC_SLASH_RE, \"%252F\"));\n}\nfunction decodeQueryKey(text) {\n  return decode(text.replace(PLUS_RE, \" \"));\n}\nfunction decodeQueryValue(text) {\n  return decode(text.replace(PLUS_RE, \" \"));\n}\nfunction encodeHost(name = \"\") {\n  return toASCII(name);\n}\n\nfunction parseQuery(parametersString = \"\") {\n  const object = /* @__PURE__ */ Object.create(null);\n  if (parametersString[0] === \"?\") {\n    parametersString = parametersString.slice(1);\n  }\n  for (const parameter of parametersString.split(\"&\")) {\n    const s = parameter.match(/([^=]+)=?(.*)/) || [];\n    if (s.length < 2) {\n      continue;\n    }\n    const key = decodeQueryKey(s[1]);\n    if (key === \"__proto__\" || key === \"constructor\") {\n      continue;\n    }\n    const value = decodeQueryValue(s[2] || \"\");\n    if (object[key] === void 0) {\n      object[key] = value;\n    } else if (Array.isArray(object[key])) {\n      object[key].push(value);\n    } else {\n      object[key] = [object[key], value];\n    }\n  }\n  return object;\n}\nfunction encodeQueryItem(key, value) {\n  if (typeof value === \"number\" || typeof value === \"boolean\") {\n    value = String(value);\n  }\n  if (!value) {\n    return encodeQueryKey(key);\n  }\n  if (Array.isArray(value)) {\n    return value.map(\n      (_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`\n    ).join(\"&\");\n  }\n  return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;\n}\nfunction stringifyQuery(query) {\n  return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join(\"&\");\n}\n\nconst PROTOCOL_STRICT_REGEX = /^[\\s\\w\\0+.-]{2,}:([/\\\\]{1,2})/;\nconst PROTOCOL_REGEX = /^[\\s\\w\\0+.-]{2,}:([/\\\\]{2})?/;\nconst PROTOCOL_RELATIVE_REGEX = /^([/\\\\]\\s*){2,}[^/\\\\]/;\nconst PROTOCOL_SCRIPT_RE = /^[\\s\\0]*(blob|data|javascript|vbscript):$/i;\nconst TRAILING_SLASH_RE = /\\/$|\\/\\?|\\/#/;\nconst JOIN_LEADING_SLASH_RE = /^\\.?\\//;\nfunction isRelative(inputString) {\n  return [\"./\", \"../\"].some((string_) => inputString.startsWith(string_));\n}\nfunction hasProtocol(inputString, opts = {}) {\n  if (typeof opts === \"boolean\") {\n    opts = { acceptRelative: opts };\n  }\n  if (opts.strict) {\n    return PROTOCOL_STRICT_REGEX.test(inputString);\n  }\n  return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);\n}\nfunction isScriptProtocol(protocol) {\n  return !!protocol && PROTOCOL_SCRIPT_RE.test(protocol);\n}\nfunction hasTrailingSlash(input = \"\", respectQueryAndFragment) {\n  if (!respectQueryAndFragment) {\n    return input.endsWith(\"/\");\n  }\n  return TRAILING_SLASH_RE.test(input);\n}\nfunction withoutTrailingSlash(input = \"\", respectQueryAndFragment) {\n  if (!respectQueryAndFragment) {\n    return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || \"/\";\n  }\n  if (!hasTrailingSlash(input, true)) {\n    return input || \"/\";\n  }\n  let path = input;\n  let fragment = \"\";\n  const fragmentIndex = input.indexOf(\"#\");\n  if (fragmentIndex !== -1) {\n    path = input.slice(0, fragmentIndex);\n    fragment = input.slice(fragmentIndex);\n  }\n  const [s0, ...s] = path.split(\"?\");\n  const cleanPath = s0.endsWith(\"/\") ? s0.slice(0, -1) : s0;\n  return (cleanPath || \"/\") + (s.length > 0 ? `?${s.join(\"?\")}` : \"\") + fragment;\n}\nfunction withTrailingSlash(input = \"\", respectQueryAndFragment) {\n  if (!respectQueryAndFragment) {\n    return input.endsWith(\"/\") ? input : input + \"/\";\n  }\n  if (hasTrailingSlash(input, true)) {\n    return input || \"/\";\n  }\n  let path = input;\n  let fragment = \"\";\n  const fragmentIndex = input.indexOf(\"#\");\n  if (fragmentIndex !== -1) {\n    path = input.slice(0, fragmentIndex);\n    fragment = input.slice(fragmentIndex);\n    if (!path) {\n      return fragment;\n    }\n  }\n  const [s0, ...s] = path.split(\"?\");\n  return s0 + \"/\" + (s.length > 0 ? `?${s.join(\"?\")}` : \"\") + fragment;\n}\nfunction hasLeadingSlash(input = \"\") {\n  return input.startsWith(\"/\");\n}\nfunction withoutLeadingSlash(input = \"\") {\n  return (hasLeadingSlash(input) ? input.slice(1) : input) || \"/\";\n}\nfunction withLeadingSlash(input = \"\") {\n  return hasLeadingSlash(input) ? input : \"/\" + input;\n}\nfunction cleanDoubleSlashes(input = \"\") {\n  return input.split(\"://\").map((string_) => string_.replace(/\\/{2,}/g, \"/\")).join(\"://\");\n}\nfunction withBase(input, base) {\n  if (isEmptyURL(base) || hasProtocol(input)) {\n    return input;\n  }\n  const _base = withoutTrailingSlash(base);\n  if (input.startsWith(_base)) {\n    const nextChar = input[_base.length];\n    if (!nextChar || nextChar === \"/\" || nextChar === \"?\") {\n      return input;\n    }\n  }\n  return joinURL(_base, input);\n}\nfunction withoutBase(input, base) {\n  if (isEmptyURL(base)) {\n    return input;\n  }\n  const _base = withoutTrailingSlash(base);\n  if (!input.startsWith(_base)) {\n    return input;\n  }\n  const nextChar = input[_base.length];\n  if (nextChar && nextChar !== \"/\" && nextChar !== \"?\") {\n    return input;\n  }\n  const trimmed = input.slice(_base.length).replace(/^\\/+/, \"\");\n  return \"/\" + trimmed;\n}\nfunction withQuery(input, query) {\n  const parsed = parseURL(input);\n  const mergedQuery = { ...parseQuery(parsed.search), ...query };\n  parsed.search = stringifyQuery(mergedQuery);\n  return stringifyParsedURL(parsed);\n}\nfunction filterQuery(input, predicate) {\n  if (!input.includes(\"?\")) {\n    return input;\n  }\n  const parsed = parseURL(input);\n  const query = parseQuery(parsed.search);\n  const filteredQuery = Object.fromEntries(\n    Object.entries(query).filter(([key, value]) => predicate(key, value))\n  );\n  parsed.search = stringifyQuery(filteredQuery);\n  return stringifyParsedURL(parsed);\n}\nfunction getQuery(input) {\n  return parseQuery(parseURL(input).search);\n}\nfunction isEmptyURL(url) {\n  return !url || url === \"/\";\n}\nfunction isNonEmptyURL(url) {\n  return url && url !== \"/\";\n}\nfunction joinURL(base, ...input) {\n  let url = base || \"\";\n  for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {\n    if (url) {\n      const _segment = segment.replace(JOIN_LEADING_SLASH_RE, \"\");\n      url = withTrailingSlash(url) + _segment;\n    } else {\n      url = segment;\n    }\n  }\n  return url;\n}\nfunction joinRelativeURL(..._input) {\n  const JOIN_SEGMENT_SPLIT_RE = /\\/(?!\\/)/;\n  const input = _input.filter(Boolean);\n  const segments = [];\n  let segmentsDepth = 0;\n  for (const i of input) {\n    if (!i || i === \"/\") {\n      continue;\n    }\n    for (const [sindex, s] of i.split(JOIN_SEGMENT_SPLIT_RE).entries()) {\n      if (!s || s === \".\") {\n        continue;\n      }\n      if (s === \"..\") {\n        if (segments.length === 1 && hasProtocol(segments[0])) {\n          continue;\n        }\n        segments.pop();\n        segmentsDepth--;\n        continue;\n      }\n      if (sindex === 1 && segments[segments.length - 1]?.endsWith(\":/\")) {\n        segments[segments.length - 1] += \"/\" + s;\n        continue;\n      }\n      segments.push(s);\n      segmentsDepth++;\n    }\n  }\n  let url = segments.join(\"/\");\n  if (segmentsDepth >= 0) {\n    if (input[0]?.startsWith(\"/\") && !url.startsWith(\"/\")) {\n      url = \"/\" + url;\n    } else if (input[0]?.startsWith(\"./\") && !url.startsWith(\"./\")) {\n      url = \"./\" + url;\n    }\n  } else {\n    url = \"../\".repeat(-1 * segmentsDepth) + url;\n  }\n  if (input[input.length - 1]?.endsWith(\"/\") && !url.endsWith(\"/\")) {\n    url += \"/\";\n  }\n  return url;\n}\nfunction withHttp(input) {\n  return withProtocol(input, \"http://\");\n}\nfunction withHttps(input) {\n  return withProtocol(input, \"https://\");\n}\nfunction withoutProtocol(input) {\n  return withProtocol(input, \"\");\n}\nfunction withProtocol(input, protocol) {\n  let match = input.match(PROTOCOL_REGEX);\n  if (!match) {\n    match = input.match(/^\\/{2,}/);\n  }\n  if (!match) {\n    return protocol + input;\n  }\n  return protocol + input.slice(match[0].length);\n}\nfunction normalizeURL(input) {\n  const parsed = parseURL(input);\n  parsed.pathname = encodePath(decodePath(parsed.pathname));\n  parsed.hash = encodeHash(decode(parsed.hash));\n  parsed.host = encodeHost(decode(parsed.host));\n  parsed.search = stringifyQuery(parseQuery(parsed.search));\n  return stringifyParsedURL(parsed);\n}\nfunction resolveURL(base = \"\", ...inputs) {\n  if (typeof base !== \"string\") {\n    throw new TypeError(\n      `URL input should be string received ${typeof base} (${base})`\n    );\n  }\n  const filteredInputs = inputs.filter((input) => isNonEmptyURL(input));\n  if (filteredInputs.length === 0) {\n    return base;\n  }\n  const url = parseURL(base);\n  for (const inputSegment of filteredInputs) {\n    const urlSegment = parseURL(inputSegment);\n    if (urlSegment.pathname) {\n      url.pathname = withTrailingSlash(url.pathname) + withoutLeadingSlash(urlSegment.pathname);\n    }\n    if (urlSegment.hash && urlSegment.hash !== \"#\") {\n      url.hash = urlSegment.hash;\n    }\n    if (urlSegment.search && urlSegment.search !== \"?\") {\n      if (url.search && url.search !== \"?\") {\n        const queryString = stringifyQuery({\n          ...parseQuery(url.search),\n          ...parseQuery(urlSegment.search)\n        });\n        url.search = queryString.length > 0 ? \"?\" + queryString : \"\";\n      } else {\n        url.search = urlSegment.search;\n      }\n    }\n  }\n  return stringifyParsedURL(url);\n}\nfunction isSamePath(p1, p2) {\n  return decode(withoutTrailingSlash(p1)) === decode(withoutTrailingSlash(p2));\n}\nfunction isEqual(a, b, options = {}) {\n  if (!options.trailingSlash) {\n    a = withTrailingSlash(a);\n    b = withTrailingSlash(b);\n  }\n  if (!options.leadingSlash) {\n    a = withLeadingSlash(a);\n    b = withLeadingSlash(b);\n  }\n  if (!options.encoding) {\n    a = decode(a);\n    b = decode(b);\n  }\n  return a === b;\n}\nfunction withFragment(input, hash) {\n  if (!hash || hash === \"#\") {\n    return input;\n  }\n  const parsed = parseURL(input);\n  parsed.hash = hash === \"\" ? \"\" : \"#\" + encodeHash(hash);\n  return stringifyParsedURL(parsed);\n}\nfunction withoutFragment(input) {\n  return stringifyParsedURL({ ...parseURL(input), hash: \"\" });\n}\nfunction withoutHost(input) {\n  const parsed = parseURL(input);\n  return (parsed.pathname || \"/\") + parsed.search + parsed.hash;\n}\n\nconst protocolRelative = Symbol.for(\"ufo:protocolRelative\");\nfunction parseURL(input = \"\", defaultProto) {\n  const _specialProtoMatch = input.match(\n    /^[\\s\\0]*(blob:|data:|javascript:|vbscript:)(.*)/i\n  );\n  if (_specialProtoMatch) {\n    const [, _proto, _pathname = \"\"] = _specialProtoMatch;\n    return {\n      protocol: _proto.toLowerCase(),\n      pathname: _pathname,\n      href: _proto + _pathname,\n      auth: \"\",\n      host: \"\",\n      search: \"\",\n      hash: \"\"\n    };\n  }\n  if (!hasProtocol(input, { acceptRelative: true })) {\n    return defaultProto ? parseURL(defaultProto + input) : parsePath(input);\n  }\n  const [, protocol = \"\", auth, hostAndPath = \"\"] = input.replace(/\\\\/g, \"/\").match(/^[\\s\\0]*([\\w+.-]{2,}:)?\\/\\/([^/@]+@)?(.*)/) || [];\n  let [, host = \"\", path = \"\"] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];\n  if (protocol === \"file:\") {\n    path = path.replace(/\\/(?=[A-Za-z]:)/, \"\");\n  }\n  const { pathname, search, hash } = parsePath(path);\n  return {\n    protocol: protocol.toLowerCase(),\n    auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : \"\",\n    host,\n    pathname,\n    search,\n    hash,\n    [protocolRelative]: !protocol\n  };\n}\nfunction parsePath(input = \"\") {\n  const [pathname = \"\", search = \"\", hash = \"\"] = (input.match(/([^#?]*)(\\?[^#]*)?(#.*)?/) || []).splice(1);\n  return {\n    pathname,\n    search,\n    hash\n  };\n}\nfunction parseAuth(input = \"\") {\n  const [username, password] = input.split(\":\");\n  return {\n    username: decode(username),\n    password: decode(password)\n  };\n}\nfunction parseHost(input = \"\") {\n  const [hostname, port] = (input.match(/([^/:]*):?(\\d+)?/) || []).splice(1);\n  return {\n    hostname: decode(hostname),\n    port\n  };\n}\nfunction stringifyParsedURL(parsed) {\n  const pathname = parsed.pathname || \"\";\n  const search = parsed.search ? (parsed.search.startsWith(\"?\") ? \"\" : \"?\") + parsed.search : \"\";\n  const hash = parsed.hash || \"\";\n  const auth = parsed.auth ? parsed.auth + \"@\" : \"\";\n  const host = parsed.host || \"\";\n  const proto = parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || \"\") + \"//\" : \"\";\n  return proto + auth + host + pathname + search + hash;\n}\nconst FILENAME_STRICT_REGEX = /\\/([^/]+\\.[^/]+)$/;\nconst FILENAME_REGEX = /\\/([^/]+)$/;\nfunction parseFilename(input = \"\", opts) {\n  const { pathname } = parseURL(input);\n  const matches = opts?.strict ? pathname.match(FILENAME_STRICT_REGEX) : pathname.match(FILENAME_REGEX);\n  return matches ? matches[1] : void 0;\n}\n\nclass $URL {\n  protocol;\n  host;\n  auth;\n  pathname;\n  query = {};\n  hash;\n  constructor(input = \"\") {\n    if (typeof input !== \"string\") {\n      throw new TypeError(\n        `URL input should be string received ${typeof input} (${input})`\n      );\n    }\n    const parsed = parseURL(input);\n    this.protocol = decode(parsed.protocol);\n    this.host = decode(parsed.host);\n    this.auth = decode(parsed.auth);\n    this.pathname = decodePath(parsed.pathname);\n    this.query = parseQuery(parsed.search);\n    this.hash = decode(parsed.hash);\n  }\n  get hostname() {\n    return parseHost(this.host).hostname;\n  }\n  get port() {\n    return parseHost(this.host).port || \"\";\n  }\n  get username() {\n    return parseAuth(this.auth).username;\n  }\n  get password() {\n    return parseAuth(this.auth).password || \"\";\n  }\n  get hasProtocol() {\n    return this.protocol.length;\n  }\n  get isAbsolute() {\n    return this.hasProtocol || this.pathname[0] === \"/\";\n  }\n  get search() {\n    const q = stringifyQuery(this.query);\n    return q.length > 0 ? \"?\" + q : \"\";\n  }\n  get searchParams() {\n    const p = new URLSearchParams();\n    for (const name in this.query) {\n      const value = this.query[name];\n      if (Array.isArray(value)) {\n        for (const v of value) {\n          p.append(name, v);\n        }\n      } else {\n        p.append(\n          name,\n          typeof value === \"string\" ? value : JSON.stringify(value)\n        );\n      }\n    }\n    return p;\n  }\n  get origin() {\n    return (this.protocol ? this.protocol + \"//\" : \"\") + encodeHost(this.host);\n  }\n  get fullpath() {\n    return encodePath(this.pathname) + this.search + encodeHash(this.hash);\n  }\n  get encodedAuth() {\n    if (!this.auth) {\n      return \"\";\n    }\n    const { username, password } = parseAuth(this.auth);\n    return encodeURIComponent(username) + (password ? \":\" + encodeURIComponent(password) : \"\");\n  }\n  get href() {\n    const auth = this.encodedAuth;\n    const originWithAuth = (this.protocol ? this.protocol + \"//\" : \"\") + (auth ? auth + \"@\" : \"\") + encodeHost(this.host);\n    return this.hasProtocol && this.isAbsolute ? originWithAuth + this.fullpath : this.fullpath;\n  }\n  append(url) {\n    if (url.hasProtocol) {\n      throw new Error(\"Cannot append a URL with protocol\");\n    }\n    Object.assign(this.query, url.query);\n    if (url.pathname) {\n      this.pathname = withTrailingSlash(this.pathname) + withoutLeadingSlash(url.pathname);\n    }\n    if (url.hash) {\n      this.hash = url.hash;\n    }\n  }\n  toJSON() {\n    return this.href;\n  }\n  toString() {\n    return this.href;\n  }\n}\nfunction createURL(input) {\n  return new $URL(input);\n}\n\nexport { $URL, cleanDoubleSlashes, createURL, decode, decodePath, decodeQueryKey, decodeQueryValue, encode, encodeHash, encodeHost, encodeParam, encodePath, encodeQueryItem, encodeQueryKey, encodeQueryValue, filterQuery, getQuery, hasLeadingSlash, hasProtocol, hasTrailingSlash, isEmptyURL, isEqual, isNonEmptyURL, isRelative, isSamePath, isScriptProtocol, joinRelativeURL, joinURL, normalizeURL, parseAuth, parseFilename, parseHost, parsePath, parseQuery, parseURL, resolveURL, stringifyParsedURL, stringifyQuery, withBase, withFragment, withHttp, withHttps, withLeadingSlash, withProtocol, withQuery, withTrailingSlash, withoutBase, withoutFragment, withoutHost, withoutLeadingSlash, withoutProtocol, withoutTrailingSlash };\n"],"x_google_ignoreList":[0],"mappings":"AAQU,OAAO;AAkLjB,MAAM,wBAAwB;AAC9B,MAAM,iBAAiB;AACvB,MAAM,0BAA0B;AAOhC,SAAS,YAAY,aAAa,OAAO,EAAE,EAAE;AAC3C,KAAI,OAAO,SAAS,UAClB,QAAO,EAAE,gBAAgB,MAAM;AAEjC,KAAI,KAAK,OACP,QAAO,sBAAsB,KAAK,YAAY;AAEhD,QAAO,eAAe,KAAK,YAAY,KAAK,KAAK,iBAAiB,wBAAwB,KAAK,YAAY,GAAG;;AA0QhH,MAAM,mBAAmB,OAAO,IAAI,uBAAuB;AAC3D,SAAS,SAAS,QAAQ,IAAI,cAAc;CAC1C,MAAM,qBAAqB,MAAM,MAC/B,mDACD;AACD,KAAI,oBAAoB;EACtB,MAAM,GAAG,QAAQ,YAAY,MAAM;AACnC,SAAO;GACL,UAAU,OAAO,aAAa;GAC9B,UAAU;GACV,MAAM,SAAS;GACf,MAAM;GACN,MAAM;GACN,QAAQ;GACR,MAAM;GACP;;AAEH,KAAI,CAAC,YAAY,OAAO,EAAE,gBAAgB,MAAM,CAAC,CAC/C,QAAO,eAAe,SAAS,eAAe,MAAM,GAAG,UAAU,MAAM;CAEzE,MAAM,GAAG,WAAW,IAAI,MAAM,cAAc,MAAM,MAAM,QAAQ,OAAO,IAAI,CAAC,MAAM,4CAA4C,IAAI,EAAE;CACpI,IAAI,GAAG,OAAO,IAAI,OAAO,MAAM,YAAY,MAAM,iBAAiB,IAAI,EAAE;AACxE,KAAI,aAAa,QACf,QAAO,KAAK,QAAQ,mBAAmB,GAAG;CAE5C,MAAM,EAAE,UAAU,QAAQ,SAAS,UAAU,KAAK;AAClD,QAAO;EACL,UAAU,SAAS,aAAa;EAChC,MAAM,OAAO,KAAK,MAAM,GAAG,KAAK,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC,GAAG;EAC3D;EACA;EACA;EACA;GACC,mBAAmB,CAAC;EACtB;;AAEH,SAAS,UAAU,QAAQ,IAAI;CAC7B,MAAM,CAAC,WAAW,IAAI,SAAS,IAAI,OAAO,OAAO,MAAM,MAAM,2BAA2B,IAAI,EAAE,EAAE,OAAO,EAAE;AACzG,QAAO;EACL;EACA;EACA;EACD"}

package/dist/drain-ByWUeOQC.mjs

@@ -0,0 +1,160 @@
+import { t as getNitroRuntimeConfigRecord } from "./nitroConfigBridge-aZ1e5upQ.mjs";
+//#region src/shared/config.ts
+/** Read the full Nitro `useRuntimeConfig()` record (or `undefined` outside Nitro). */
+function getRuntimeConfig() {
+	return getNitroRuntimeConfigRecord();
+}
+/**
+* Resolve adapter configuration with the standard priority chain:
+*
+* 1. `overrides` passed to the drain factory
+* 2. `runtimeConfig.evlog.{namespace}.{key}` (Nitro)
+* 3. `runtimeConfig.{namespace}.{key}` (Nitro)
+* 4. `process.env[envKey]` for each env in `field.env`
+*/
+async function resolveAdapterConfig(namespace, fields, overrides) {
+	const runtimeConfig = shouldProbeRuntimeConfig(fields, overrides) ? await getRuntimeConfig() : void 0;
+	const evlogNs = runtimeConfig?.evlog?.[namespace];
+	const rootNs = runtimeConfig?.[namespace];
+	const config = {};
+	for (const { key, env } of fields) config[key] = overrides?.[key] ?? evlogNs?.[key] ?? rootNs?.[key] ?? resolveEnv(env);
+	return config;
+}
+function shouldProbeRuntimeConfig(fields, overrides) {
+	return fields.some(({ key, env }) => {
+		if (overrides?.[key] !== void 0) return false;
+		if (!env) return false;
+		return resolveEnv(env) === void 0;
+	});
+}
+function resolveEnv(envKeys) {
+	if (!envKeys) return void 0;
+	for (const key of envKeys) {
+		const val = process.env[key];
+		if (val) return val;
+	}
+}
+//#endregion
+//#region src/shared/http.ts
+function isRetryable(error) {
+	if (error instanceof DOMException && error.name === "AbortError") return true;
+	if (error instanceof TypeError) return true;
+	if (error instanceof Error) {
+		const match = error.message.match(/API error: (\d+)/);
+		if (match) return Number.parseInt(match[1]) >= 500;
+	}
+	return false;
+}
+/**
+* POST a body with timeout + retry. Throws label-prefixed errors with a
+* truncated response body. Safe to call from any drain `send()`.
+*/
+async function httpPost({ url, headers, body, timeout, label, retries = 2 }) {
+	const normalizedRetries = Number.isFinite(retries) && retries >= 0 ? Math.floor(retries) : 2;
+	let lastError;
+	for (let attempt = 0; attempt <= normalizedRetries; attempt++) {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), timeout);
+		try {
+			const response = await fetch(url, {
+				method: "POST",
+				headers,
+				body,
+				signal: controller.signal
+			});
+			if (!response.ok) {
+				const text = await response.text().catch(() => "Unknown error");
+				const safeText = text.length > 200 ? `${text.slice(0, 200)}...[truncated]` : text;
+				throw new Error(`${label} API error: ${response.status} ${response.statusText} - ${safeText}`);
+			}
+			clearTimeout(timeoutId);
+			return;
+		} catch (error) {
+			clearTimeout(timeoutId);
+			if (error instanceof DOMException && error.name === "AbortError") lastError = /* @__PURE__ */ new Error(`${label} request timed out after ${timeout}ms`);
+			else lastError = error;
+			if (!isRetryable(error) || attempt === normalizedRetries) throw lastError;
+			await new Promise((r) => setTimeout(r, 200 * 2 ** attempt));
+		}
+	}
+	throw lastError;
+}
+//#endregion
+//#region src/shared/drain.ts
+/**
+* Build a drain callback. Errors raised by `send` are logged with the drain
+* name and swallowed, so a failing drain never breaks the request pipeline.
+*
+* @example
+* ```ts
+* export function createMyDrain(overrides?: Partial<MyConfig>) {
+*   return defineDrain<MyConfig>({
+*     name: 'my-drain',
+*     resolve: () => ({ url: process.env.MY_URL ?? null }),
+*     send: async (events, config) => { ... },
+*   })
+* }
+* ```
+*/
+function defineDrain(options) {
+	return async (ctx) => {
+		const contexts = Array.isArray(ctx) ? ctx : [ctx];
+		if (contexts.length === 0) return;
+		const config = await options.resolve();
+		if (!config) return;
+		try {
+			await options.send(contexts.map((c) => c.event), config);
+		} catch (error) {
+			console.error(`[evlog/${options.name}] Failed to send events:`, error);
+		}
+	};
+}
+const DEFAULT_HTTP_TIMEOUT = 5e3;
+/**
+* Build an HTTP drain. Timeouts/retries are resolved from the config (with
+* overrides via `resolveTimeout` / `resolveRetries`) and forwarded to
+* {@link httpPost}.
+*
+* @example
+* ```ts
+* export function createMyDrain(overrides?: Partial<MyConfig>) {
+*   return defineHttpDrain<MyConfig>({
+*     name: 'my',
+*     resolve: async () => {
+*       const cfg = await resolveAdapterConfig<MyConfig>('my', FIELDS, overrides)
+*       return cfg.apiKey ? cfg as MyConfig : null
+*     },
+*     encode: (events, config) => ({
+*       url: `${config.endpoint ?? 'https://api.my.com'}/ingest`,
+*       headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${config.apiKey}` },
+*       body: JSON.stringify(events),
+*     }),
+*   })
+* }
+* ```
+*/
+function defineHttpDrain(options) {
+	return defineDrain({
+		name: options.name,
+		resolve: options.resolve,
+		send: async (events, config) => {
+			if (events.length === 0) return;
+			const request = options.encode(events, config);
+			if (!request) return;
+			const timeout = options.resolveTimeout?.(config) ?? config.timeout ?? options.timeout ?? DEFAULT_HTTP_TIMEOUT;
+			const retries = options.resolveRetries?.(config) ?? config.retries ?? options.retries;
+			await httpPost({
+				url: request.url,
+				headers: request.headers,
+				body: request.body,
+				timeout,
+				retries,
+				label: options.name
+			});
+		}
+	});
+}
+//#endregion
+export { resolveAdapterConfig as a, getRuntimeConfig as i, defineHttpDrain as n, httpPost as r, defineDrain as t };
+
+//# sourceMappingURL=drain-ByWUeOQC.mjs.map