@visulima/pail 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/middleware/elysia.d.ts

@@ -0,0 +1,71 @@
+import type { WideEvent } from "../wide-event.d.ts";
+import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+/**
+ * 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;
+}
+/**
+ * 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
+ */
+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";

package/dist/middleware/elysia.js

@@ -0,0 +1,70 @@
+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-Cp4uLtr4.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 };

package/dist/middleware/express.d.ts

@@ -0,0 +1,86 @@
+import type { WideEvent } from "../wide-event.d.ts";
+import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+/**
+ * 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;
+}
+/**
+ * An Express-like response object.
+ */
+interface PailResponse {
+    [key: string]: unknown;
+    on: (event: string, listener: () => void) => void;
+    statusCode: number;
+}
+/**
+ * Express-compatible next function.
+ */
+type PailNextFunction = (error?: unknown) => void;
+/**
+ * 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
+ */
+declare const useLogger: () => WideEvent;
+/**
+ * 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";

package/dist/middleware/express.js

@@ -0,0 +1,29 @@
+import { e as extractSafeNodeHeaders, c as createMiddlewareLogger } from '../packem_shared/headers-Cp4uLtr4.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.path;
+  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 };

package/dist/middleware/fastify.d.ts

@@ -0,0 +1,81 @@
+import type { WideEvent } from "../wide-event.d.ts";
+import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+/**
+ * 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;
+}
+/**
+ * A Fastify-like reply object.
+ */
+interface PailFastifyReply {
+    [key: string]: unknown;
+    statusCode: number;
+}
+/**
+ * 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);
+}
+/**
+ * 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
+ */
+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";

package/dist/middleware/fastify.js

@@ -0,0 +1,46 @@
+import { e as extractSafeNodeHeaders, c as createMiddlewareLogger } from '../packem_shared/headers-Cp4uLtr4.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 };

package/dist/middleware/hono.d.ts

@@ -0,0 +1,85 @@
+import type { WideEvent } from "../wide-event.d.ts";
+import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+/**
+ * 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;
+        };
+    };
+    res: {
+        status: number;
+    };
+    set: (key: string, value: unknown) => void;
+}
+/**
+ * Hono-compatible next function.
+ */
+type PailHonoNext = () => Promise<void>;
+/**
+ * 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
+ */
+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
+ */
+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";

package/dist/middleware/hono.js

@@ -0,0 +1,33 @@
+import { a as extractSafeHeaders, c as createMiddlewareLogger } from '../packem_shared/headers-Cp4uLtr4.js';
+
+const useLogger = (c) => {
+  const logger = c.get("log");
+  if (!logger) {
+    throw new Error("[pail] useLogger() called but pail middleware is not registered.");
+  }
+  return logger;
+};
+const pailMiddleware = (options) => async (c, next) => {
+  const requestId = c.req.header("x-request-id") ?? crypto.randomUUID();
+  const safeHeaders = extractSafeHeaders(c.req.raw.headers);
+  const { finish, logger, skipped } = createMiddlewareLogger(options, {
+    headers: safeHeaders,
+    method: c.req.method,
+    path: c.req.path,
+    requestId
+  });
+  if (skipped) {
+    await next();
+    return;
+  }
+  c.set("log", logger);
+  try {
+    await next();
+    finish({ status: c.res.status });
+  } catch (error) {
+    finish({ error: error instanceof Error ? error : new Error(String(error)) });
+    throw error;
+  }
+};
+
+export { pailMiddleware, useLogger };

package/dist/middleware/next/handler.d.ts

@@ -0,0 +1,36 @@
+import type { PailMiddlewareOptions } from "../shared/create-middleware-logger.d.ts";
+type NextPailOptions<T extends string = string> = PailMiddlewareOptions<T>;
+/**
+ * Create a `withPail` wrapper function for Next.js route handlers and server actions.
+ *
+ * Wraps handler execution in AsyncLocalStorage so that `useLogger()` works
+ * anywhere in the async call stack. The wide event is automatically emitted
+ * when the handler completes or throws.
+ * @param options Configuration options
+ * @returns A `withPail` wrapper function
+ * @example
+ * ```typescript
+ * // lib/pail.ts
+ * import { createPail } from "@visulima/pail";
+ * import { createWithPail } from "@visulima/pail/middleware/next";
+ *
+ * const logger = createPail();
+ * export const withPail = createWithPail({ pail: logger });
+ *
+ * // app/api/users/route.ts
+ * import { withPail } from "@/lib/pail";
+ * import { useLogger } from "@visulima/pail/middleware/next";
+ *
+ * export const GET = withPail(async (request: Request) => {
+ *   const log = useLogger();
+ *   log.set({ user: { id: 1 } });
+ *   return Response.json({ ok: true });
+ * });
+ * ```
+ */
+export declare const createWithPail: <T extends string = string>(options: NextPailOptions<T>) => <TArgs extends unknown[], TReturn>(handler: (...args: TArgs) => Promise<TReturn> | TReturn) => (...args: TArgs) => Promise<TReturn>;
+export type { NextPailOptions };
+export type { WideEvent } from "../../wide-event.d.ts";
+export type { PailNextMiddlewareOptions } from "./middleware/next/middleware.d.ts";
+export { pailMiddleware } from "./middleware/next/middleware.d.ts";
+export { useLogger } from "./storage.d.ts";

package/dist/middleware/next/handler.js

@@ -0,0 +1,53 @@
+import { a as extractSafeHeaders, c as createMiddlewareLogger } from '../../packem_shared/headers-Cp4uLtr4.js';
+import { pailStorage } from '../../packem_shared/useLogger-D0rU3lcX.js';
+export { useLogger } from '../../packem_shared/useLogger-D0rU3lcX.js';
+export { pailMiddleware } from '../../packem_shared/pailMiddleware-Ci88geIF.js';
+
+const createWithPail = (options) => (
+  /**
+   * Wrap a Next.js route handler or server action with wide event logging.
+   * @returns A wrapped handler that creates and emits a WideEvent
+   */
+  (handler) => async (...args) => {
+    const [firstArgument] = args;
+    const isRequest = firstArgument instanceof Request;
+    let method = "UNKNOWN";
+    let path = "/";
+    let requestId = crypto.randomUUID();
+    let headers = {};
+    if (isRequest) {
+      const request = firstArgument;
+      const url = new URL(request.url);
+      method = request.method;
+      path = url.pathname;
+      headers = extractSafeHeaders(request.headers);
+      const middlewareRequestId = request.headers.get("x-request-id");
+      if (middlewareRequestId) {
+        requestId = middlewareRequestId;
+      }
+    }
+    const { finish, logger, skipped } = createMiddlewareLogger(options, {
+      headers,
+      method,
+      path,
+      requestId
+    });
+    if (skipped) {
+      return handler(...args);
+    }
+    try {
+      const result = await pailStorage.run(logger, () => handler(...args));
+      const status = result instanceof Response ? result.status : 200;
+      finish({ status });
+      return result;
+    } catch (error) {
+      const errorInstance = error instanceof Error ? error : new Error(String(error));
+      const errorStatus = errorInstance.status ?? errorInstance.statusCode ?? 500;
+      finish({ error: errorInstance });
+      logger.setStatus(errorStatus);
+      throw error;
+    }
+  }
+);
+
+export { createWithPail };

package/dist/middleware/next/middleware.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Minimal type definitions to avoid requiring next as a dependency.
+ */
+interface NextRequest {
+    headers: Headers;
+    nextUrl: {
+        pathname: string;
+    };
+}
+interface NextResponse {
+    headers: Headers;
+}
+interface NextResponseConstructor {
+    next: (options?: {
+        request?: {
+            headers?: Headers;
+        };
+    }) => NextResponse;
+}
+/**
+ * Options for the Next.js pail middleware.
+ */
+interface PailNextMiddlewareOptions {
+    /**
+     * Glob patterns for paths to exclude from logging.
+     * Excluded paths won't get request IDs or timing headers.
+     * @example ["/_next/**", "/favicon.ico"]
+     */
+    exclude?: string[];
+    /**
+     * Glob patterns for paths to include in logging.
+     * If not set, all non-excluded paths are included.
+     */
+    include?: string[];
+}
+/**
+ * Create a Next.js edge middleware that sets `x-request-id` and `x-pail-start`
+ * headers on the request for downstream use by `withPail()`.
+ *
+ * This middleware runs at the edge and prepares request metadata.
+ * The actual wide event logging happens in `withPail()`.
+ * @param NextResponseClass The NextResponse class from "next/server.d.ts";
+ * @param options Middleware configuration
+ * @returns A middleware function
+ * @example
+ * ```typescript
+ * // middleware.ts
+ * import { NextResponse } from "next/server.d.ts";
+ * import { pailMiddleware } from "@visulima/pail/middleware/next";
+ *
+ * const middleware = pailMiddleware(NextResponse, {
+ *   exclude: ["/_next/**", "/favicon.ico"],
+ * });
+ *
+ * export default middleware;
+ * ```
+ */
+export declare const pailMiddleware: (NextResponseClass: NextResponseConstructor, options?: PailNextMiddlewareOptions) => (request: NextRequest) => NextResponse;
+export type { PailNextMiddlewareOptions };

package/dist/middleware/next/storage.d.ts

@@ -0,0 +1,14 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { WideEvent } from "../../wide-event.d.ts";
+/**
+ * AsyncLocalStorage instance used to propagate the WideEvent logger
+ * through Next.js server actions, route handlers, and server components.
+ */
+export declare const pailStorage: AsyncLocalStorage<WideEvent>;
+/**
+ * Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
+ * Must be called within a `withPail()` wrapped handler or server action.
+ * @returns The request-scoped WideEvent logger
+ * @throws Error if called outside of a withPail context
+ */
+export declare const useLogger: () => WideEvent;