@visulima/pail 4.0.0-alpha.11 → 4.0.0-alpha.13

package/dist/middleware/elysia.d.ts

@@ -1,71 +1,73 @@
-import type { WideEvent } from "../wide-event.d.ts";
-import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+import { W as WideEvent } from "../packem_shared/wide-event.d-Ke44zirU.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DeNLii5l.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-ByY2ZuYG.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * An Elysia-like instance that supports the derive/hook registration API.
- * Compatible with Elysia v1+.
- */
+* An Elysia-like instance that supports the derive/hook registration API.
+* Compatible with Elysia v1+.
+*/
 interface PailElysiaInstance {
-    derive: (options: {
-        as: string;
-    }, handler: (context: {
-        request: Request;
-    }) => Record<string, unknown>) => PailElysiaInstance;
-    onAfterHandle: (options: {
-        as: string;
-    }, handler: (context: {
-        request: Request;
-        set: {
-            status?: number;
-        };
-    }) => Promise<void>) => PailElysiaInstance;
-    onError: (options: {
-        as: string;
-    }, handler: (context: {
-        error: Error;
-        request: Request;
-    }) => Promise<void>) => PailElysiaInstance;
+  derive: (options: {
+    as: string;
+  }, handler: (context: {
+    request: Request;
+  }) => Record<string, unknown>) => PailElysiaInstance;
+  onAfterHandle: (options: {
+    as: string;
+  }, handler: (context: {
+    request: Request;
+    set: {
+      status?: number;
+    };
+  }) => Promise<void>) => PailElysiaInstance;
+  onError: (options: {
+    as: string;
+  }, handler: (context: {
+    error: Error;
+    request: Request;
+  }) => Promise<void>) => PailElysiaInstance;
 }
 /**
- * Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
- * Must be called within a request handler where pail middleware is active.
- * @returns The request-scoped WideEvent logger
- * @throws Error if called outside of the middleware context
- */
+* Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
+* Must be called within a request handler where pail middleware is active.
+* @returns The request-scoped WideEvent logger
+* @throws Error if called outside of the middleware context
+*/
 declare const useLogger: () => WideEvent;
 /**
- * Configuration options for the Elysia pail plugin.
- * @template T - Custom logger type names from the pail instance
- */
+* Configuration options for the Elysia pail plugin.
+* @template T - Custom logger type names from the pail instance
+*/
 type ElysiaPluginOptions<T extends string = string> = PailMiddlewareOptions<T>;
 /**
- * Register pail wide event logging as an Elysia plugin.
- *
- * Injects a `log` property into handler context via `derive`, accessible via:
- * - `context.log` in route handlers (auto-injected)
- * - `useLogger()` from anywhere in the async call stack
- *
- * The wide event is automatically emitted on response or error.
- * @param app The Elysia instance
- * @param options Plugin configuration
- * @returns The Elysia instance (for chaining)
- * @example
- * ```typescript
- * import { Elysia } from "elysia";
- * import { createPail } from "@visulima/pail";
- * import { pailPlugin, useLogger } from "@visulima/pail/middleware/elysia";
- *
- * const logger = createPail();
- * const app = new Elysia();
- *
- * pailPlugin(app, { pail: logger });
- *
- * app.get("/api/users", ({ log }) => {
- *   log.set({ user: { id: 1 } });
- *   return { ok: true };
- * });
- * ```
- */
-export declare const pailPlugin: <T extends string = string>(app: PailElysiaInstance, options: ElysiaPluginOptions<T>) => PailElysiaInstance;
-export { useLogger };
-export type { ElysiaPluginOptions, PailElysiaInstance };
-export type { WideEvent } from "../wide-event.d.ts";
+* Register pail wide event logging as an Elysia plugin.
+*
+* Injects a `log` property into handler context via `derive`, accessible via:
+* - `context.log` in route handlers (auto-injected)
+* - `useLogger()` from anywhere in the async call stack
+*
+* The wide event is automatically emitted on response or error.
+* @param app The Elysia instance
+* @param options Plugin configuration
+* @returns The Elysia instance (for chaining)
+* @example
+* ```typescript
+* import { Elysia } from "elysia";
+* import { createPail } from "@visulima/pail";
+* import { pailPlugin, useLogger } from "@visulima/pail/middleware/elysia";
+*
+* const logger = createPail();
+* const app = new Elysia();
+*
+* pailPlugin(app, { pail: logger });
+*
+* app.get("/api/users", ({ log }) => {
+*   log.set({ user: { id: 1 } });
+*   return { ok: true };
+* });
+* ```
+*/
+declare const pailPlugin: <T extends string = string>(app: PailElysiaInstance, options: ElysiaPluginOptions<T>) => PailElysiaInstance;
+export { type ElysiaPluginOptions, type PailElysiaInstance, type WideEvent, pailPlugin, useLogger };

package/dist/middleware/elysia.js

@@ -1,70 +1 @@
-import { createRequire as __cjs_createRequire } from "node:module";
-
-const __cjs_require = __cjs_createRequire(import.meta.url);
-
-const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
-
-const __cjs_getBuiltinModule = (module) => {
-    // Check if we're in Node.js and version supports getBuiltinModule
-    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
-        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
-        // Node.js 20.16.0+ and 22.3.0+
-        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
-            return __cjs_getProcess.getBuiltinModule(module);
-        }
-    }
-    // Fallback to createRequire
-    return __cjs_require(module);
-};
-
-const {
-  AsyncLocalStorage
-} = __cjs_getBuiltinModule("node:async_hooks");
-import { a as extractSafeHeaders, c as createMiddlewareLogger } from '../packem_shared/headers-BxHWM6KI.js';
-
-const storage = new AsyncLocalStorage();
-const activeLoggers = /* @__PURE__ */ new WeakSet();
-const useLogger = () => {
-  const logger = storage.getStore();
-  if (!logger || !activeLoggers.has(logger)) {
-    throw new Error("[pail] useLogger() called outside of Elysia pail plugin context.");
-  }
-  return logger;
-};
-const pailPlugin = (app, options) => {
-  const requestState = /* @__PURE__ */ new WeakMap();
-  const emitted = /* @__PURE__ */ new WeakSet();
-  return app.derive({ as: "global" }, ({ request }) => {
-    const url = new URL(request.url);
-    const requestId = request.headers.get("x-request-id") ?? crypto.randomUUID();
-    const safeHeaders = extractSafeHeaders(request.headers);
-    const result = createMiddlewareLogger(options, {
-      headers: safeHeaders,
-      method: request.method,
-      path: url.pathname,
-      requestId
-    });
-    requestState.set(request, result);
-    if (!result.skipped) {
-      activeLoggers.add(result.logger);
-      storage.enterWith(result.logger);
-    }
-    return { log: result.logger };
-  }).onAfterHandle({ as: "global" }, async ({ request, set }) => {
-    const state = requestState.get(request);
-    if (!state?.skipped && state && !emitted.has(request)) {
-      emitted.add(request);
-      state.finish({ status: set.status ?? 200 });
-      activeLoggers.delete(state.logger);
-    }
-  }).onError({ as: "global" }, async ({ error, request }) => {
-    const state = requestState.get(request);
-    if (!state?.skipped && state && !emitted.has(request)) {
-      emitted.add(request);
-      state.finish({ error });
-      activeLoggers.delete(state.logger);
-    }
-  });
-};
-
-export { pailPlugin, useLogger };
+var f=Object.defineProperty;var g=(e,t)=>f(e,"name",{value:t,configurable:!0});import{createRequire as h}from"node:module";import{a as b,c as q}from"../packem_shared/headers-S8WyX-2m.js";const m=h(import.meta.url),i=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,_=g(e=>{if(typeof i<"u"&&i.versions&&i.versions.node){const[t,a]=i.versions.node.split(".").map(Number);if(t>22||t===22&&a>=3||t===20&&a>=16)return i.getBuiltinModule(e)}return m(e)},"__cjs_getBuiltinModule"),{AsyncLocalStorage:y}=_("node:async_hooks");var w=Object.defineProperty,c=g((e,t)=>w(e,"name",{value:t,configurable:!0}),"d");const u=new y,d=new WeakSet,L=c(()=>{const e=u.getStore();if(!e||!d.has(e))throw new Error("[pail] useLogger() called outside of Elysia pail plugin context.");return e},"useLogger"),S=c((e,t)=>{const a=new WeakMap,l=new WeakSet;return e.derive({as:"global"},({request:r})=>{const o=new URL(r.url),s=r.headers.get("x-request-id")??crypto.randomUUID(),p=b(r.headers),n=q(t,{headers:p,method:r.method,path:o.pathname,requestId:s});return a.set(r,n),n.skipped||(d.add(n.logger),u.enterWith(n.logger)),{log:n.logger}}).onAfterHandle({as:"global"},async({request:r,set:o})=>{const s=a.get(r);!s?.skipped&&s&&!l.has(r)&&(l.add(r),s.finish({status:o.status??200}),d.delete(s.logger))}).onError({as:"global"},async({error:r,request:o})=>{const s=a.get(o);!s?.skipped&&s&&!l.has(o)&&(l.add(o),s.finish({error:r}),d.delete(s.logger))})},"pailPlugin");export{S as pailPlugin,L as useLogger};

package/dist/middleware/express.d.ts

@@ -1,86 +1,88 @@
-import type { WideEvent } from "../wide-event.d.ts";
-import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+import { W as WideEvent } from "../packem_shared/wide-event.d-Ke44zirU.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DeNLii5l.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-ByY2ZuYG.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * An Express-like request object with the pail logger attached.
- * Use this to type your route handlers when accessing `req.log`.
- * @example
- * ```typescript
- * import type { PailRequest } from "@visulima/pail/middleware/express";
- *
- * app.get("/api/users", (req: PailRequest, res) => {
- *   req.log?.set({ user: { id: 1 } });
- * });
- * ```
- */
+* An Express-like request object with the pail logger attached.
+* Use this to type your route handlers when accessing `req.log`.
+* @example
+* ```typescript
+* import type { PailRequest } from "@visulima/pail/middleware/express";
+*
+* app.get("/api/users", (req: PailRequest, res) => {
+*   req.log?.set({ user: { id: 1 } });
+* });
+* ```
+*/
 interface PailRequest {
-    [key: string]: unknown;
-    headers: Record<string, string | string[] | undefined>;
-    /**
-     * The request-scoped WideEvent logger, attached by pail middleware.
-     * Only present for non-excluded routes.
-     */
-    log?: WideEvent;
-    method: string;
-    originalUrl?: string;
-    path: string;
+  [key: string]: unknown;
+  headers: Record<string, string | string[] | undefined>;
+  /**
+  * The request-scoped WideEvent logger, attached by pail middleware.
+  * Only present for non-excluded routes.
+  */
+  log?: WideEvent;
+  method: string;
+  originalUrl?: string;
+  path: string;
 }
 /**
- * An Express-like response object.
- */
+* An Express-like response object.
+*/
 interface PailResponse {
-    [key: string]: unknown;
-    on: (event: string, listener: () => void) => void;
-    statusCode: number;
+  [key: string]: unknown;
+  on: (event: string, listener: () => void) => void;
+  statusCode: number;
 }
 /**
- * Express-compatible next function.
- */
+* Express-compatible next function.
+*/
 type PailNextFunction = (error?: unknown) => void;
 /**
- * The Express middleware function signature returned by `pailMiddleware()`.
- */
+* The Express middleware function signature returned by `pailMiddleware()`.
+*/
 type PailExpressMiddleware = (request: PailRequest, response: PailResponse, next: PailNextFunction) => void;
 /**
- * Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
- * Must be called within a request handled by the pail Express middleware.
- * @returns The request-scoped WideEvent logger
- * @throws Error if called outside of the middleware context
- */
+* Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
+* Must be called within a request handled by the pail Express middleware.
+* @returns The request-scoped WideEvent logger
+* @throws Error if called outside of the middleware context
+*/
 declare const useLogger: () => WideEvent;
 /**
- * Configuration options for the Express pail middleware.
- * @template T - Custom logger type names from the pail instance
- */
+* Configuration options for the Express pail middleware.
+* @template T - Custom logger type names from the pail instance
+*/
 type ExpressMiddlewareOptions<T extends string = string> = PailMiddlewareOptions<T>;
 /**
- * Create Express middleware that attaches a WideEvent logger to each request.
- *
- * The logger is available via:
- * - `req.log` on the request object
- * - `useLogger()` from anywhere in the async call stack
- *
- * The wide event is automatically emitted when the response finishes.
- * @param options Middleware configuration
- * @returns Express middleware function
- * @example
- * ```typescript
- * import express from "express";
- * import { createPail } from "@visulima/pail";
- * import { pailMiddleware, useLogger } from "@visulima/pail/middleware/express";
- *
- * const app = express();
- * const logger = createPail();
- *
- * app.use(pailMiddleware({ pail: logger }));
- *
- * app.get("/api/users", (req, res) => {
- *   req.log.set({ user: { id: 1 } });
- *   // or: useLogger().set({ user: { id: 1 } });
- *   res.json({ ok: true });
- * });
- * ```
- */
-export declare const pailMiddleware: <T extends string = string>(options: ExpressMiddlewareOptions<T>) => PailExpressMiddleware;
-export { useLogger };
-export type { ExpressMiddlewareOptions, PailExpressMiddleware, PailNextFunction, PailRequest, PailResponse };
-export type { WideEvent } from "../wide-event.d.ts";
+* Create Express middleware that attaches a WideEvent logger to each request.
+*
+* The logger is available via:
+* - `req.log` on the request object
+* - `useLogger()` from anywhere in the async call stack
+*
+* The wide event is automatically emitted when the response finishes.
+* @param options Middleware configuration
+* @returns Express middleware function
+* @example
+* ```typescript
+* import express from "express";
+* import { createPail } from "@visulima/pail";
+* import { pailMiddleware, useLogger } from "@visulima/pail/middleware/express";
+*
+* const app = express();
+* const logger = createPail();
+*
+* app.use(pailMiddleware({ pail: logger }));
+*
+* app.get("/api/users", (req, res) => {
+*   req.log.set({ user: { id: 1 } });
+*   // or: useLogger().set({ user: { id: 1 } });
+*   res.json({ ok: true });
+* });
+* ```
+*/
+declare const pailMiddleware: <T extends string = string>(options: ExpressMiddlewareOptions<T>) => PailExpressMiddleware;
+export { type ExpressMiddlewareOptions, type PailExpressMiddleware, type PailNextFunction, type PailRequest, type PailResponse, type WideEvent, pailMiddleware, useLogger };

package/dist/middleware/express.js

@@ -1,29 +1 @@
-import { e as extractSafeNodeHeaders, c as createMiddlewareLogger } from '../packem_shared/headers-BxHWM6KI.js';
-import { c as createLoggerStorage } from '../packem_shared/storage-D0vqz8OX.js';
-
-const loggerStorage = createLoggerStorage("Express middleware context. Make sure pail middleware is registered before your route handlers.");
-const useLogger = () => loggerStorage.useLogger();
-const pailMiddleware = (options) => (request, response, next) => {
-  const requestId = request.headers["x-request-id"] ?? crypto.randomUUID();
-  const path = request.originalUrl ?? request.url ?? "/";
-  const safeHeaders = extractSafeNodeHeaders(request.headers);
-  const { finish, logger, skipped } = createMiddlewareLogger(options, {
-    headers: safeHeaders,
-    method: request.method,
-    path,
-    requestId
-  });
-  if (skipped) {
-    next();
-    return;
-  }
-  request.log = logger;
-  response.on("finish", () => {
-    finish({ status: response.statusCode });
-  });
-  loggerStorage.storage.run(logger, () => {
-    next();
-  });
-};
-
-export { pailMiddleware, useLogger };
+var c=Object.defineProperty;var t=(r,e)=>c(r,"name",{value:e,configurable:!0});import{e as m,c as f}from"../packem_shared/headers-S8WyX-2m.js";import{c as h}from"../packem_shared/storage-DHM1EP2P.js";var w=Object.defineProperty,d=t((r,e)=>w(r,"name",{value:e,configurable:!0}),"i");const i=h("Express middleware context. Make sure pail middleware is registered before your route handlers."),b=d(()=>i.useLogger(),"useLogger"),v=d(r=>(e,a,o)=>{const g=e.headers["x-request-id"]??crypto.randomUUID(),l=e.originalUrl??e.url??"/",u=m(e.headers),{finish:n,logger:s,skipped:p}=f(r,{headers:u,method:e.method,path:l,requestId:g});if(p){o();return}e.log=s,a.on("finish",()=>{n({status:a.statusCode})}),i.storage.run(s,()=>{o()})},"pailMiddleware");export{v as pailMiddleware,b as useLogger};

package/dist/middleware/fastify.d.ts

@@ -1,81 +1,83 @@
-import type { WideEvent } from "../wide-event.d.ts";
-import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+import { W as WideEvent } from "../packem_shared/wide-event.d-Ke44zirU.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DeNLii5l.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-ByY2ZuYG.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * A Fastify-like request object with the pail logger attached.
- * Use this to type your route handlers when accessing `request.log`.
- * @example
- * ```typescript
- * import type { PailFastifyRequest } from "@visulima/pail/middleware/fastify";
- *
- * app.get("/api/users", async (request: PailFastifyRequest, reply) => {
- *   request.log?.set({ user: { id: 1 } });
- * });
- * ```
- */
+* A Fastify-like request object with the pail logger attached.
+* Use this to type your route handlers when accessing `request.log`.
+* @example
+* ```typescript
+* import type { PailFastifyRequest } from "@visulima/pail/middleware/fastify";
+*
+* app.get("/api/users", async (request: PailFastifyRequest, reply) => {
+*   request.log?.set({ user: { id: 1 } });
+* });
+* ```
+*/
 interface PailFastifyRequest {
-    [key: string]: unknown;
-    headers: Record<string, string | string[] | undefined>;
-    /**
-     * The request-scoped WideEvent logger, attached by pail plugin.
-     * Only present for non-excluded routes.
-     */
-    log?: WideEvent;
-    method: string;
-    url: string;
+  [key: string]: unknown;
+  headers: Record<string, string | string[] | undefined>;
+  /**
+  * The request-scoped WideEvent logger, attached by pail plugin.
+  * Only present for non-excluded routes.
+  */
+  log?: WideEvent;
+  method: string;
+  url: string;
 }
 /**
- * A Fastify-like reply object.
- */
+* A Fastify-like reply object.
+*/
 interface PailFastifyReply {
-    [key: string]: unknown;
-    statusCode: number;
+  [key: string]: unknown;
+  statusCode: number;
 }
 /**
- * A Fastify-like instance that supports the hook registration API.
- */
+* A Fastify-like instance that supports the hook registration API.
+*/
 interface PailFastifyInstance {
-    addHook: ((name: "onError", hook: (request: PailFastifyRequest, reply: PailFastifyReply, error: Error) => Promise<void>) => void) & ((name: "onRequest", hook: (request: PailFastifyRequest, reply: PailFastifyReply, done: () => void) => void) => void) & ((name: "onResponse", hook: (request: PailFastifyRequest, reply: PailFastifyReply) => Promise<void>) => void);
+  addHook: ((name: "onError", hook: (request: PailFastifyRequest, reply: PailFastifyReply, error: Error) => Promise<void>) => void) & ((name: "onRequest", hook: (request: PailFastifyRequest, reply: PailFastifyReply, done: () => void) => void) => void) & ((name: "onResponse", hook: (request: PailFastifyRequest, reply: PailFastifyReply) => Promise<void>) => void);
 }
 /**
- * Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
- * Must be called within a request handled by the pail Fastify plugin.
- * @returns The request-scoped WideEvent logger
- * @throws Error if called outside of the plugin context
- */
+* Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
+* Must be called within a request handled by the pail Fastify plugin.
+* @returns The request-scoped WideEvent logger
+* @throws Error if called outside of the plugin context
+*/
 declare const useLogger: () => WideEvent;
 /**
- * Configuration options for the Fastify pail plugin.
- * @template T - Custom logger type names from the pail instance
- */
+* Configuration options for the Fastify pail plugin.
+* @template T - Custom logger type names from the pail instance
+*/
 type FastifyPluginOptions<T extends string = string> = PailMiddlewareOptions<T>;
 /**
- * Register pail wide event logging as a Fastify plugin.
- *
- * Attaches a WideEvent logger to each request, accessible via:
- * - `request.log` on the Fastify request object
- * - `useLogger()` from anywhere in the async call stack
- *
- * The wide event is automatically emitted on response or error.
- * @param fastify The Fastify instance
- * @param options Plugin configuration
- * @example
- * ```typescript
- * import Fastify from "fastify";
- * import { createPail } from "@visulima/pail";
- * import { pailPlugin, useLogger } from "@visulima/pail/middleware/fastify";
- *
- * const app = Fastify();
- * const logger = createPail();
- *
- * pailPlugin(app, { pail: logger });
- *
- * app.get("/api/users", async (request, reply) => {
- *   request.log.set({ user: { id: 1 } });
- *   return { ok: true };
- * });
- * ```
- */
-export declare const pailPlugin: <T extends string = string>(fastify: PailFastifyInstance, options: FastifyPluginOptions<T>) => void;
-export { useLogger };
-export type { FastifyPluginOptions, PailFastifyInstance, PailFastifyReply, PailFastifyRequest };
-export type { WideEvent } from "../wide-event.d.ts";
+* Register pail wide event logging as a Fastify plugin.
+*
+* Attaches a WideEvent logger to each request, accessible via:
+* - `request.log` on the Fastify request object
+* - `useLogger()` from anywhere in the async call stack
+*
+* The wide event is automatically emitted on response or error.
+* @param fastify The Fastify instance
+* @param options Plugin configuration
+* @example
+* ```typescript
+* import Fastify from "fastify";
+* import { createPail } from "@visulima/pail";
+* import { pailPlugin, useLogger } from "@visulima/pail/middleware/fastify";
+*
+* const app = Fastify();
+* const logger = createPail();
+*
+* pailPlugin(app, { pail: logger });
+*
+* app.get("/api/users", async (request, reply) => {
+*   request.log.set({ user: { id: 1 } });
+*   return { ok: true };
+* });
+* ```
+*/
+declare const pailPlugin: <T extends string = string>(fastify: PailFastifyInstance, options: FastifyPluginOptions<T>) => void;
+export { type FastifyPluginOptions, type PailFastifyInstance, type PailFastifyReply, type PailFastifyRequest, type WideEvent, pailPlugin, useLogger };

package/dist/middleware/fastify.js

@@ -1,46 +1 @@
-import { e as extractSafeNodeHeaders, c as createMiddlewareLogger } from '../packem_shared/headers-BxHWM6KI.js';
-import { c as createLoggerStorage } from '../packem_shared/storage-D0vqz8OX.js';
-
-const loggerStorage = createLoggerStorage("Fastify middleware context. Make sure pail plugin is registered before your route handlers.");
-const useLogger = () => loggerStorage.useLogger();
-const pailPlugin = (fastify, options) => {
-  const requestState = /* @__PURE__ */ new WeakMap();
-  const emitted = /* @__PURE__ */ new WeakSet();
-  fastify.addHook("onRequest", (request, _reply, done) => {
-    const requestId = request.headers["x-request-id"] ?? crypto.randomUUID();
-    const safeHeaders = extractSafeNodeHeaders(request.headers);
-    const { finish, logger, skipped } = createMiddlewareLogger(options, {
-      headers: safeHeaders,
-      method: request.method,
-      path: request.url,
-      requestId
-    });
-    if (skipped) {
-      done();
-      return;
-    }
-    request.log = logger;
-    requestState.set(request, { finish });
-    loggerStorage.storage.run(logger, () => {
-      done();
-    });
-  });
-  fastify.addHook("onResponse", async (request, reply) => {
-    const state = requestState.get(request);
-    if (!state || emitted.has(request)) {
-      return;
-    }
-    emitted.add(request);
-    state.finish({ status: reply.statusCode });
-  });
-  fastify.addHook("onError", async (request, _reply, error) => {
-    const state = requestState.get(request);
-    if (!state || emitted.has(request)) {
-      return;
-    }
-    emitted.add(request);
-    state.finish({ error });
-  });
-};
-
-export { pailPlugin, useLogger };
+var h=Object.defineProperty;var g=(r,a)=>h(r,"name",{value:a,configurable:!0});import{e as m,c as k}from"../packem_shared/headers-S8WyX-2m.js";import{c as y}from"../packem_shared/storage-DHM1EP2P.js";var L=Object.defineProperty,u=g((r,a)=>L(r,"name",{value:a,configurable:!0}),"d");const c=y("Fastify middleware context. Make sure pail plugin is registered before your route handlers."),b=u(()=>c.useLogger(),"useLogger"),q=u((r,a)=>{const n=new WeakMap,s=new WeakSet;r.addHook("onRequest",(e,d,o)=>{const t=e.headers["x-request-id"]??crypto.randomUUID(),l=m(e.headers),{finish:p,logger:i,skipped:f}=k(a,{headers:l,method:e.method,path:e.url,requestId:t});if(f){o();return}e.log=i,n.set(e,{finish:p}),c.storage.run(i,()=>{o()})}),r.addHook("onResponse",async(e,d)=>{const o=n.get(e);!o||s.has(e)||(s.add(e),o.finish({status:d.statusCode}))}),r.addHook("onError",async(e,d,o)=>{const t=n.get(e);!t||s.has(e)||(s.add(e),t.finish({error:o}))})},"pailPlugin");export{q as pailPlugin,b as useLogger};