@visulima/pail 4.0.0-alpha.2 → 4.0.0-alpha.21

package/dist/middleware/elysia.d.ts

@@ -0,0 +1,73 @@
+import { W as WideEvent } from "../packem_shared/wide-event.d-DkYD7YVK.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-MK7moe4r.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-Ck_RSjLg.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+/**
+* 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 };
+* });
+* ```
+*/
+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

@@ -0,0 +1 @@
+import{createRequire as u}from"node:module";import{a as m,c as _}from"../packem_shared/headers-D-K_EnkH.js";const p=u(import.meta.url),i=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,h=s=>{if(typeof i<"u"&&i.versions&&i.versions.node){const[a,o]=i.versions.node.split(".").map(Number);if(a>22||a===22&&o>=3||a===20&&o>=16)return i.getBuiltinModule(s)}return p(s)},{AsyncLocalStorage:f}=h("node:async_hooks"),g=new f,d=new WeakSet,w=()=>{const s=g.getStore();if(!s||!d.has(s))throw new Error("[pail] useLogger() called outside of Elysia pail plugin context.");return s},b=(s,a)=>{const o=new WeakMap,l=new WeakSet;return s.derive({as:"global"},({request:e})=>{const t=new URL(e.url),r=e.headers.get("x-request-id")??crypto.randomUUID(),c=m(e.headers),n=_(a,{headers:c,method:e.method,path:t.pathname,requestId:r});return o.set(e,n),n.skipped||(d.add(n.logger),g.enterWith(n.logger)),{log:n.logger}}).onAfterHandle({as:"global"},async({request:e,set:t})=>{const r=o.get(e);!r?.skipped&&r&&!l.has(e)&&(l.add(e),r.finish({status:t.status??200}),d.delete(r.logger))}).onError({as:"global"},async({error:e,request:t})=>{const r=o.get(t);!r?.skipped&&r&&!l.has(t)&&(l.add(t),r.finish({error:e}),d.delete(r.logger))})};export{b as pailPlugin,w as useLogger};

package/dist/middleware/express.d.ts

@@ -0,0 +1,88 @@
+import { W as WideEvent } from "../packem_shared/wide-event.d-DkYD7YVK.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-MK7moe4r.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-Ck_RSjLg.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 } });
+* });
+* ```
+*/
+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 });
+* });
+* ```
+*/
+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

@@ -0,0 +1 @@
+import{e as u,c as p}from"../packem_shared/headers-D-K_EnkH.js";import{c}from"../packem_shared/storage-DaXAlpiO.js";const a=c("Express middleware context. Make sure pail middleware is registered before your route handlers."),f=()=>a.useLogger(),x=t=>(e,r,s)=>{const d=e.headers["x-request-id"]??crypto.randomUUID(),i=e.originalUrl??e.url??"/",g=u(e.headers),{finish:l,logger:o,skipped:n}=p(t,{headers:g,method:e.method,path:i,requestId:d});if(n){s();return}e.log=o,r.on("finish",()=>{l({status:r.statusCode})}),a.storage.run(o,()=>{s()})};export{x as pailMiddleware,f as useLogger};

package/dist/middleware/fastify.d.ts

@@ -0,0 +1,83 @@
+import { W as WideEvent } from "../packem_shared/wide-event.d-DkYD7YVK.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-MK7moe4r.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-Ck_RSjLg.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 } });
+* });
+* ```
+*/
+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 };
+* });
+* ```
+*/
+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

@@ -0,0 +1 @@
+import{e as p,c as f}from"../packem_shared/headers-D-K_EnkH.js";import{c as l}from"../packem_shared/storage-DaXAlpiO.js";const i=l("Fastify middleware context. Make sure pail plugin is registered before your route handlers."),y=()=>i.useLogger(),w=(a,g)=>{const t=new WeakMap,s=new WeakSet;a.addHook("onRequest",(e,d,r)=>{const o=e.headers["x-request-id"]??crypto.randomUUID(),c=p(e.headers),{finish:u,logger:n,skipped:h}=f(g,{headers:c,method:e.method,path:e.url,requestId:o});if(h){r();return}e.log=n,t.set(e,{finish:u}),i.storage.run(n,()=>{r()})}),a.addHook("onResponse",async(e,d)=>{const r=t.get(e);!r||s.has(e)||(s.add(e),r.finish({status:d.statusCode}))}),a.addHook("onError",async(e,d,r)=>{const o=t.get(e);!o||s.has(e)||(s.add(e),o.finish({error:r}))})};export{w as pailPlugin,y as useLogger};

package/dist/middleware/hono.d.ts

@@ -0,0 +1,87 @@
+import { W as WideEvent } from "../packem_shared/wide-event.d-DkYD7YVK.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-MK7moe4r.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-Ck_RSjLg.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 } });
+* });
+* ```
+*/
+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 });
+* });
+* ```
+*/
+declare const pailMiddleware: <T extends string = string>(options: HonoMiddlewareOptions<T>) => PailHonoMiddleware;
+export { type HonoMiddlewareOptions, type PailHonoContext, type PailHonoMiddleware, type PailHonoNext, type WideEvent, pailMiddleware, useLogger };

package/dist/middleware/hono.js

@@ -0,0 +1 @@
+import{a as c,c as g}from"../packem_shared/headers-D-K_EnkH.js";const l=t=>{const r=t.get("log");if(!r)throw new Error("[pail] useLogger() called but pail middleware is not registered.");return r},p=t=>async(r,a)=>{const o=r.req.header("x-request-id")??crypto.randomUUID(),i=c(r.req.raw.headers),{finish:s,logger:d,skipped:n}=g(t,{headers:i,method:r.req.method,path:r.req.path,requestId:o});if(n){await a();return}r.set("log",d);try{await a(),s({status:r.res.status})}catch(e){throw s({error:e instanceof Error?e:new Error(String(e))}),e}};export{p as pailMiddleware,l as useLogger};

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

@@ -0,0 +1,103 @@
+import { P as PailMiddlewareOptions } from "../../packem_shared/create-middleware-logger.d-MK7moe4r.js";
+import { W as WideEvent } from "../../packem_shared/wide-event.d-DkYD7YVK.js";
+import 'node:async_hooks';
+import "../../packem_shared/types.d-Ck_RSjLg.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+import 'safe-stable-stringify';
+/**
+* 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.js"
+* @param options Middleware configuration
+* @returns A middleware function
+* @example
+* ```typescript
+* // middleware.ts
+* import { NextResponse } from "next/server.js";
+* import { pailMiddleware } from "@visulima/pail/middleware/next";
+*
+* const middleware = pailMiddleware(NextResponse, {
+*   exclude: ["/_next/**", "/favicon.ico"],
+* });
+*
+* export default middleware;
+* ```
+*/
+declare const pailMiddleware: (NextResponseClass: NextResponseConstructor, options?: PailNextMiddlewareOptions) => (request: NextRequest) => NextResponse;
+/**
+* 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
+*/
+declare const useLogger: () => WideEvent;
+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 });
+* });
+* ```
+*/
+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, type PailNextMiddlewareOptions, type WideEvent, createWithPail, pailMiddleware, useLogger };

package/dist/middleware/next/handler.js

@@ -0,0 +1 @@
+import{a as m,c as l}from"../../packem_shared/headers-D-K_EnkH.js";import{pailStorage as w}from"../../packem_shared/useLogger-DB34CuU5.js";import{useLogger as N}from"../../packem_shared/useLogger-DB34CuU5.js";import{pailMiddleware as S}from"../../packem_shared/pailMiddleware-B5DJoBYl.js";const q=u=>s=>async(...a)=>{const[o]=a,f=o instanceof Request;let n="UNKNOWN",i="/",c=crypto.randomUUID(),d={};if(f){const e=o,t=new URL(e.url);n=e.method,i=t.pathname,d=m(e.headers);const r=e.headers.get("x-request-id");r&&(c=r)}const{finish:p,logger:h,skipped:g}=l(u,{headers:d,method:n,path:i,requestId:c});if(g)return s(...a);try{const e=await w.run(h,()=>s(...a)),t=e instanceof Response?e.status:200;return p({status:t}),e}catch(e){const t=e instanceof Error?e:new Error(String(e)),r=t.status??t.statusCode??500;throw p({error:t,status:r}),e}};export{q as createWithPail,S as pailMiddleware,N as useLogger};

package/dist/middleware/sveltekit.d.ts

@@ -0,0 +1,125 @@
+import { W as WideEvent } from "../packem_shared/wide-event.d-DkYD7YVK.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-MK7moe4r.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-Ck_RSjLg.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+/**
+* A SvelteKit-like event object with access to the pail logger via `locals.log`.
+* @example
+* ```typescript
+* // In a SvelteKit load function or action:
+* import type { PailSvelteKitEvent } from "@visulima/pail/middleware/sveltekit";
+*
+* export const load = async (event: PailSvelteKitEvent) => {
+*   event.locals.log?.set({ user: { id: 1 } });
+* };
+* ```
+*/
+interface PailSvelteKitEvent {
+  [key: string]: unknown;
+  locals: Record<string, unknown> & {
+    log?: WideEvent;
+  };
+  request: Request;
+  url: URL;
+}
+/**
+* Options passed to SvelteKit's resolve function.
+*/
+interface PailSvelteKitResolveOptions {
+  filterSerializedResponseHeaders?: (name: string) => boolean;
+  preload?: (input: {
+    type: string;
+  }) => boolean;
+  transformPageChunk?: (input: {
+    html: string;
+  }) => string;
+}
+/**
+* SvelteKit resolve function type.
+*/
+type PailSvelteKitResolve = (event: PailSvelteKitEvent, options?: PailSvelteKitResolveOptions) => Promise<Response>;
+/**
+* Input for the SvelteKit handle hook.
+*/
+interface PailSvelteKitHandleInput {
+  event: PailSvelteKitEvent;
+  resolve: PailSvelteKitResolve;
+}
+/**
+* SvelteKit handle hook function type returned by `pailHandle()`.
+*/
+type PailSvelteKitHandle = (input: PailSvelteKitHandleInput) => Promise<Response>;
+/**
+* Input for the SvelteKit handleError hook.
+*/
+interface PailSvelteKitHandleErrorInput {
+  error: unknown;
+  event: PailSvelteKitEvent;
+  message: string;
+  status: number;
+}
+/**
+* SvelteKit handleError hook function type returned by `pailHandleError()`.
+*/
+type PailSvelteKitHandleError = (input: PailSvelteKitHandleErrorInput) => void;
+/**
+* Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
+* Must be called within a request handled by the pail SvelteKit handle hook.
+* @returns The request-scoped WideEvent logger
+* @throws Error if called outside of the hook context
+*/
+declare const useLogger: () => WideEvent;
+type SvelteKitHandleOptions<T extends string = string> = PailMiddlewareOptions<T>;
+/**
+* Create a SvelteKit `handle` hook that attaches a WideEvent logger to each request.
+*
+* The logger is available via:
+* - `event.locals.log` in server load functions and actions
+* - `useLogger()` from anywhere in the async call stack
+*
+* The wide event is automatically emitted when the response is sent or an error occurs.
+* @param options Hook configuration
+* @returns SvelteKit handle hook function
+* @example
+* ```typescript
+* // src/hooks.server.ts
+* import { createPail } from "@visulima/pail";
+* import { pailHandle, pailHandleError } from "@visulima/pail/middleware/sveltekit";
+*
+* const logger = createPail();
+*
+* export const handle = pailHandle({ pail: logger });
+* export const handleError = pailHandleError();
+* ```
+*/
+declare const pailHandle: <T extends string = string>(options: SvelteKitHandleOptions<T>) => PailSvelteKitHandle;
+/**
+* Create a SvelteKit `handleError` hook that captures errors into the WideEvent logger.
+*
+* Should be used alongside `pailHandle` to ensure errors are recorded in the wide event.
+* @returns SvelteKit handleError hook function
+*/
+declare const pailHandleError: () => PailSvelteKitHandleError;
+/**
+* Convenience function that returns both handle and handleError hooks.
+* @param options Hook configuration
+* @returns Object with `handle` and `handleError` hooks
+* @example
+* ```typescript
+* // src/hooks.server.ts
+* import { createPail } from "@visulima/pail";
+* import { createPailHooks } from "@visulima/pail/middleware/sveltekit";
+*
+* const logger = createPail();
+* const { handle, handleError } = createPailHooks({ pail: logger });
+*
+* export { handle, handleError };
+* ```
+*/
+declare const createPailHooks: <T extends string = string>(options: SvelteKitHandleOptions<T>) => {
+  handle: PailSvelteKitHandle;
+  handleError: PailSvelteKitHandleError;
+};
+export { type PailSvelteKitEvent, type PailSvelteKitHandle, type PailSvelteKitHandleError, type PailSvelteKitHandleErrorInput, type PailSvelteKitHandleInput, type PailSvelteKitResolve, type PailSvelteKitResolveOptions, type SvelteKitHandleOptions, type WideEvent, createPailHooks, pailHandle, pailHandleError, useLogger };

package/dist/middleware/sveltekit.js

@@ -0,0 +1 @@
+import{a as g,c as i}from"../packem_shared/headers-D-K_EnkH.js";import{c as u}from"../packem_shared/storage-DaXAlpiO.js";const n=u("SvelteKit handle hook context. Make sure pailHandle is added to your hooks.server.ts."),k=()=>n.useLogger(),h=e=>async({event:r,resolve:a})=>{const d=r.request.headers.get("x-request-id")??crypto.randomUUID(),l=g(r.request.headers),{finish:t,logger:s,skipped:c}=i(e,{headers:l,method:r.request.method,path:r.url.pathname,requestId:d});return c?a(r):(r.locals.log=s,n.storage.run(s,async()=>{try{const o=await a(r);return t({status:o.status}),o}catch(o){throw t({error:o instanceof Error?o:new Error(String(o))}),o}}))},p=()=>({error:e,event:r})=>{const a=r.locals.log;a&&e instanceof Error&&a.error(e.message,e)},q=e=>({handle:h(e),handleError:p()});export{q as createPailHooks,h as pailHandle,p as pailHandleError,k as useLogger};