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

package/dist/middleware/elysia.d.ts

@@ -0,0 +1,73 @@
+import { W as WideEvent } from "../packem_shared/wide-event.d-gb2-ks5w.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-CR3o6VDh.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+.
+*/
+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 @@
+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

@@ -0,0 +1,88 @@
+import { W as WideEvent } from "../packem_shared/wide-event.d-gb2-ks5w.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-CR3o6VDh.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 } });
+* });
+* ```
+*/
+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 @@
+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

@@ -0,0 +1,83 @@
+import { W as WideEvent } from "../packem_shared/wide-event.d-gb2-ks5w.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-CR3o6VDh.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 } });
+* });
+* ```
+*/
+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 @@
+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};

package/dist/middleware/hono.d.ts

@@ -0,0 +1,87 @@
+import { W as WideEvent } from "../packem_shared/wide-event.d-gb2-ks5w.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-CR3o6VDh.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 } });
+* });
+* ```
+*/
+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 @@
+var c=Object.defineProperty;var s=(r,e)=>c(r,"name",{value:e,configurable:!0});import{a as u,c as p}from"../packem_shared/headers-S8WyX-2m.js";var h=Object.defineProperty,d=s((r,e)=>h(r,"name",{value:e,configurable:!0}),"o");const m=d(r=>{const e=r.get("log");if(!e)throw new Error("[pail] useLogger() called but pail middleware is not registered.");return e},"useLogger"),q=d(r=>async(e,t)=>{const i=e.req.header("x-request-id")??crypto.randomUUID(),n=u(e.req.raw.headers),{finish:o,logger:g,skipped:l}=p(r,{headers:n,method:e.req.method,path:e.req.path,requestId:i});if(l){await t();return}e.set("log",g);try{await t(),o({status:e.res.status})}catch(a){throw o({error:a instanceof Error?a:new Error(String(a))}),a}},"pailMiddleware");export{q as pailMiddleware,m as useLogger};

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

@@ -0,0 +1,103 @@
+import { P as PailMiddlewareOptions } from "../../packem_shared/create-middleware-logger.d-CR3o6VDh.js";
+import { W as WideEvent } from "../../packem_shared/wide-event.d-gb2-ks5w.js";
+import 'node:async_hooks';
+import "../../packem_shared/types.d-BeLumqgD.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 @@
+var g=Object.defineProperty;var f=(a,r)=>g(a,"name",{value:r,configurable:!0});import{a as w,c as x}from"../../packem_shared/headers-S8WyX-2m.js";import{pailStorage as y}from"../../packem_shared/useLogger-qyZrjy4D.js";import{useLogger as W}from"../../packem_shared/useLogger-qyZrjy4D.js";import{pailMiddleware as E}from"../../packem_shared/pailMiddleware-CWOJRmJq.js";var U=Object.defineProperty,q=f((a,r)=>U(a,"name",{value:r,configurable:!0}),"l");const P=q(a=>r=>async(...o)=>{const[n]=o,h=n instanceof Request;let i="UNKNOWN",c="/",d=crypto.randomUUID(),u={};if(h){const e=n,t=new URL(e.url);i=e.method,c=t.pathname,u=w(e.headers);const s=e.headers.get("x-request-id");s&&(d=s)}const{finish:p,logger:l,skipped:m}=x(a,{headers:u,method:i,path:c,requestId:d});if(m)return r(...o);try{const e=await y.run(l,()=>r(...o)),t=e instanceof Response?e.status:200;return p({status:t}),e}catch(e){const t=e instanceof Error?e:new Error(String(e)),s=t.status??t.statusCode??500;throw p({error:t,status:s}),e}},"createWithPail");export{P as createWithPail,E as pailMiddleware,W as useLogger};

package/dist/middleware/sveltekit.d.ts

@@ -0,0 +1,125 @@
+import { W as WideEvent } from "../packem_shared/wide-event.d-gb2-ks5w.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-CR3o6VDh.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-BeLumqgD.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 @@
+var u=Object.defineProperty;var l=(r,e)=>u(r,"name",{value:e,configurable:!0});import{a as h,c as p}from"../packem_shared/headers-S8WyX-2m.js";import{c as m}from"../packem_shared/storage-DHM1EP2P.js";var v=Object.defineProperty,t=l((r,e)=>v(r,"name",{value:e,configurable:!0}),"n");const d=m("SvelteKit handle hook context. Make sure pailHandle is added to your hooks.server.ts."),q=t(()=>d.useLogger(),"useLogger"),f=t(r=>async({event:e,resolve:o})=>{const c=e.request.headers.get("x-request-id")??crypto.randomUUID(),i=h(e.request.headers),{finish:s,logger:n,skipped:g}=p(r,{headers:i,method:e.request.method,path:e.url.pathname,requestId:c});return g?o(e):(e.locals.log=n,d.storage.run(n,async()=>{try{const a=await o(e);return s({status:a.status}),a}catch(a){throw s({error:a instanceof Error?a:new Error(String(a))}),a}}))},"pailHandle"),H=t(()=>({error:r,event:e})=>{const o=e.locals.log;o&&r instanceof Error&&o.error(r.message,r)},"pailHandleError"),L=t(r=>({handle:f(r),handleError:H()}),"createPailHooks");export{L as createPailHooks,f as pailHandle,H as pailHandleError,q as useLogger};