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

package/dist/index.server.js

@@ -10,8 +10,8 @@ const {
   env
 } = __cjs_getProcess;
 import { InteractiveManager, InteractiveStreamHook } from '@visulima/interactive-manager';
-import { g as getLongestLabel, E as EXTENDED_RFC_5424_LOG_LEVELS, a as EMPTY_SYMBOL, L as LOG_TYPES, i as inspect, w as writeStream, A as AbstractPrettyReporter, d as defaultInspectorConfig, t as terminalSize, b as getLongestBadge, c as getStringWidth, f as formatLabel, e as wordWrap, r as renderError, W as WrapMode } from './packem_shared/abstract-pretty-reporter-CXAKYCb8.js';
-import colorize, { red, greenBright, cyan, green, grey, bgGrey, underline, white } from '@visulima/colorize';
+import { g as getLongestLabel, E as EXTENDED_RFC_5424_LOG_LEVELS, a as EMPTY_SYMBOL, L as LOG_TYPES, i as inspect, w as writeStream, A as AbstractPrettyReporter, d as defaultInspectorConfig, t as terminalSize, b as getLongestBadge, c as getStringWidth, f as formatLabel, e as wordWrap, r as renderError, W as WrapMode } from './packem_shared/abstract-pretty-reporter-CkqCt5hg.js';
+import colorize from '@visulima/colorize';
 export { PailError, createPailError } from './packem_shared/createPailError-B_sgL0nF.js';
 
 const ESC = "\x1B";
@@ -2183,7 +2183,7 @@ const parseCss = (cssString) => {
   }
   return css;
 };
-const cssToAnsi = (css, previousCss = null) => {
+const cssToAnsi = (css, previousCss) => {
   previousCss = previousCss ?? getDefaultCss();
   let ansi = "";
   if (!colorEquals(css.backgroundColor, previousCss.backgroundColor)) {
@@ -2360,7 +2360,7 @@ const format = (fmt, arguments_ = [], options = {}) => {
   let a = 1 - offset;
   let lastPosition = -1;
   let usedStyle = false;
-  let previousCss = null;
+  let previousCss;
   for (let index = 0; index < fmt.length; ) {
     if (fmt.codePointAt(index) === CHAR_PERCENT && index + 1 < fmt.length) {
       lastPosition = lastPosition > -1 ? lastPosition : 0;
@@ -2573,6 +2573,7 @@ class MessageFormatterProcessor {
   }
 }
 
+const { bgGrey, cyan, green, greenBright, grey, red, underline, white } = colorize;
 const PAIL_DIST_REGEX = /[\\/]pail[\\/]dist/;
 const pailFileFilter = (line) => !PAIL_DIST_REGEX.test(line);
 class PrettyReporter extends AbstractPrettyReporter {

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-B-t8ZnhI.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DheMh8q4.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-BeLumqgD.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/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-B-t8ZnhI.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DheMh8q4.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-BeLumqgD.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/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-B-t8ZnhI.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DheMh8q4.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-BeLumqgD.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/hono.d.ts

@@ -1,85 +1,87 @@
-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-B-t8ZnhI.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DheMh8q4.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * A Hono-like context object with access to the pail logger.
- *
- * Use `c.get("log")` or `useLogger(c)` to access the WideEvent logger.
- * @example
- * ```typescript
- * import type { PailHonoContext } from "@visulima/pail/middleware/hono";
- *
- * app.get("/api/users", (c: PailHonoContext) => {
- *   const log = c.get("log");
- *   log.set({ user: { id: 1 } });
- * });
- * ```
- */
+* A Hono-like context object with access to the pail logger.
+*
+* Use `c.get("log")` or `useLogger(c)` to access the WideEvent logger.
+* @example
+* ```typescript
+* import type { PailHonoContext } from "@visulima/pail/middleware/hono";
+*
+* app.get("/api/users", (c: PailHonoContext) => {
+*   const log = c.get("log");
+*   log.set({ user: { id: 1 } });
+* });
+* ```
+*/
 interface PailHonoContext {
-    [key: string]: unknown;
-    get: (key: string) => unknown;
-    req: {
-        header: (name: string) => string | undefined;
-        method: string;
-        path: string;
-        raw: {
-            headers: Headers;
-        };
+  [key: string]: unknown;
+  get: (key: string) => unknown;
+  req: {
+    header: (name: string) => string | undefined;
+    method: string;
+    path: string;
+    raw: {
+      headers: Headers;
     };
-    res: {
-        status: number;
-    };
-    set: (key: string, value: unknown) => void;
+  };
+  res: {
+    status: number;
+  };
+  set: (key: string, value: unknown) => void;
 }
 /**
- * Hono-compatible next function.
- */
+* Hono-compatible next function.
+*/
 type PailHonoNext = () => Promise<void>;
 /**
- * The Hono middleware function signature returned by `pailMiddleware()`.
- */
+* The Hono middleware function signature returned by `pailMiddleware()`.
+*/
 type PailHonoMiddleware = (c: PailHonoContext, next: PailHonoNext) => Promise<void>;
 /**
- * Configuration options for the Hono pail middleware.
- * @template T - Custom logger type names from the pail instance
- */
+* Configuration options for the Hono pail middleware.
+* @template T - Custom logger type names from the pail instance
+*/
 type HonoMiddlewareOptions<T extends string = string> = PailMiddlewareOptions<T>;
 /**
- * Retrieve the WideEvent logger from Hono context.
- * Must be called within a request handler where pail middleware is active.
- * @param c The Hono context object
- * @returns The request-scoped WideEvent logger
- * @throws Error if the middleware is not registered
- */
+* Retrieve the WideEvent logger from Hono context.
+* Must be called within a request handler where pail middleware is active.
+* @param c The Hono context object
+* @returns The request-scoped WideEvent logger
+* @throws Error if the middleware is not registered
+*/
 declare const useLogger: (c: PailHonoContext) => WideEvent;
 /**
- * Create Hono middleware that attaches a WideEvent logger to each request.
- *
- * The logger is available via:
- * - `c.get("log")` on the Hono context
- * - `useLogger(c)` helper function
- *
- * The wide event is automatically emitted when the handler completes or throws.
- * @param options Middleware configuration
- * @returns Hono middleware function
- * @example
- * ```typescript
- * import { Hono } from "hono";
- * import { createPail } from "@visulima/pail";
- * import { pailMiddleware, useLogger } from "@visulima/pail/middleware/hono";
- *
- * const app = new Hono();
- * const logger = createPail();
- *
- * app.use("*", pailMiddleware({ pail: logger }));
- *
- * app.get("/api/users", (c) => {
- *   const log = useLogger(c);
- *   log.set({ user: { id: 1 } });
- *   return c.json({ ok: true });
- * });
- * ```
- */
-export declare const pailMiddleware: <T extends string = string>(options: HonoMiddlewareOptions<T>) => PailHonoMiddleware;
-export { useLogger };
-export type { HonoMiddlewareOptions, PailHonoContext, PailHonoMiddleware, PailHonoNext };
-export type { WideEvent } from "../wide-event.d.ts";
+* Create Hono middleware that attaches a WideEvent logger to each request.
+*
+* The logger is available via:
+* - `c.get("log")` on the Hono context
+* - `useLogger(c)` helper function
+*
+* The wide event is automatically emitted when the handler completes or throws.
+* @param options Middleware configuration
+* @returns Hono middleware function
+* @example
+* ```typescript
+* import { Hono } from "hono";
+* import { createPail } from "@visulima/pail";
+* import { pailMiddleware, useLogger } from "@visulima/pail/middleware/hono";
+*
+* const app = new Hono();
+* const logger = createPail();
+*
+* app.use("*", pailMiddleware({ pail: logger }));
+*
+* app.get("/api/users", (c) => {
+*   const log = useLogger(c);
+*   log.set({ user: { id: 1 } });
+*   return c.json({ ok: true });
+* });
+* ```
+*/
+declare const pailMiddleware: <T extends string = string>(options: HonoMiddlewareOptions<T>) => PailHonoMiddleware;
+export { type HonoMiddlewareOptions, type PailHonoContext, type PailHonoMiddleware, type PailHonoNext, type WideEvent, pailMiddleware, useLogger };