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

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-Ke44zirU.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DeNLii5l.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-ByY2ZuYG.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * A 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 };

package/dist/middleware/hono.js

@@ -1,33 +1 @@
-import { a as extractSafeHeaders, c as createMiddlewareLogger } from '../packem_shared/headers-BxHWM6KI.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 };
+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

@@ -1,36 +1,103 @@
-import type { PailMiddlewareOptions } from "../shared/create-middleware-logger.d.ts";
+import { P as PailMiddlewareOptions } from "../../packem_shared/create-middleware-logger.d-DeNLii5l.js";
+import { W as WideEvent } from "../../packem_shared/wide-event.d-Ke44zirU.js";
+import 'node:async_hooks';
+import "../../packem_shared/types.d-ByY2ZuYG.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 });
- * });
- * ```
- */
-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";
+* 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

@@ -1,53 +1 @@
-import { a as extractSafeHeaders, c as createMiddlewareLogger } from '../../packem_shared/headers-BxHWM6KI.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 };
+var g=Object.defineProperty;var h=(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 S=Object.defineProperty,U=h((a,r)=>S(a,"name",{value:r,configurable:!0}),"c");const N=U(a=>r=>async(...o)=>{const[n]=o,l=n instanceof Request;let i="UNKNOWN",c="/",d=crypto.randomUUID(),u={};if(l){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:f,skipped:m}=x(a,{headers:u,method:i,path:c,requestId:d});if(m)return r(...o);try{const e=await y.run(f,()=>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}),f.setStatus(s),e}},"createWithPail");export{N as createWithPail,E as pailMiddleware,W as useLogger};

package/dist/middleware/sveltekit.d.ts

@@ -1,123 +1,125 @@
-import type { WideEvent } from "../wide-event.d.ts";
-import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+import { W as WideEvent } from "../packem_shared/wide-event.d-Ke44zirU.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DeNLii5l.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-ByY2ZuYG.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * A 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 } });
- * };
- * ```
- */
+* 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;
+  [key: string]: unknown;
+  locals: Record<string, unknown> & {
+    log?: WideEvent;
+  };
+  request: Request;
+  url: URL;
 }
 /**
- * Options passed to SvelteKit's resolve function.
- */
+* Options passed to SvelteKit's resolve function.
+*/
 interface PailSvelteKitResolveOptions {
-    filterSerializedResponseHeaders?: (name: string) => boolean;
-    preload?: (input: {
-        type: string;
-    }) => boolean;
-    transformPageChunk?: (input: {
-        html: string;
-    }) => string;
+  filterSerializedResponseHeaders?: (name: string) => boolean;
+  preload?: (input: {
+    type: string;
+  }) => boolean;
+  transformPageChunk?: (input: {
+    html: string;
+  }) => string;
 }
 /**
- * SvelteKit resolve function type.
- */
+* SvelteKit resolve function type.
+*/
 type PailSvelteKitResolve = (event: PailSvelteKitEvent, options?: PailSvelteKitResolveOptions) => Promise<Response>;
 /**
- * Input for the SvelteKit handle hook.
- */
+* Input for the SvelteKit handle hook.
+*/
 interface PailSvelteKitHandleInput {
-    event: PailSvelteKitEvent;
-    resolve: PailSvelteKitResolve;
+  event: PailSvelteKitEvent;
+  resolve: PailSvelteKitResolve;
 }
 /**
- * SvelteKit handle hook function type returned by `pailHandle()`.
- */
+* SvelteKit handle hook function type returned by `pailHandle()`.
+*/
 type PailSvelteKitHandle = (input: PailSvelteKitHandleInput) => Promise<Response>;
 /**
- * Input for the SvelteKit handleError hook.
- */
+* Input for the SvelteKit handleError hook.
+*/
 interface PailSvelteKitHandleErrorInput {
-    error: unknown;
-    event: PailSvelteKitEvent;
-    message: string;
-    status: number;
+  error: unknown;
+  event: PailSvelteKitEvent;
+  message: string;
+  status: number;
 }
 /**
- * SvelteKit handleError hook function type returned by `pailHandleError()`.
- */
+* 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
- */
+* 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();
- * ```
- */
-export declare const pailHandle: <T extends string = string>(options: SvelteKitHandleOptions<T>) => PailSvelteKitHandle;
+* 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
- */
-export declare const pailHandleError: () => PailSvelteKitHandleError;
+* 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 };
- * ```
- */
-export declare const createPailHooks: <T extends string = string>(options: SvelteKitHandleOptions<T>) => {
-    handle: PailSvelteKitHandle;
-    handleError: 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 { useLogger };
-export type { PailSvelteKitEvent, PailSvelteKitHandle, PailSvelteKitHandleError, PailSvelteKitHandleErrorInput, PailSvelteKitHandleInput, PailSvelteKitResolve, PailSvelteKitResolveOptions, SvelteKitHandleOptions, };
-export type { WideEvent } from "../wide-event.d.ts";
+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

@@ -1,43 +1 @@
-import { a as extractSafeHeaders, c as createMiddlewareLogger } from '../packem_shared/headers-BxHWM6KI.js';
-import { c as createLoggerStorage } from '../packem_shared/storage-D0vqz8OX.js';
-
-const loggerStorage = createLoggerStorage("SvelteKit handle hook context. Make sure pailHandle is added to your hooks.server.ts.");
-const useLogger = () => loggerStorage.useLogger();
-const pailHandle = (options) => async ({ event, resolve }) => {
-  const requestId = event.request.headers.get("x-request-id") ?? crypto.randomUUID();
-  const safeHeaders = extractSafeHeaders(event.request.headers);
-  const { finish, logger, skipped } = createMiddlewareLogger(options, {
-    headers: safeHeaders,
-    method: event.request.method,
-    path: event.url.pathname,
-    requestId
-  });
-  if (skipped) {
-    return resolve(event);
-  }
-  event.locals.log = logger;
-  return loggerStorage.storage.run(logger, async () => {
-    try {
-      const response = await resolve(event);
-      finish({ status: response.status });
-      return response;
-    } catch (error) {
-      finish({ error: error instanceof Error ? error : new Error(String(error)) });
-      throw error;
-    }
-  });
-};
-const pailHandleError = () => ({ error, event }) => {
-  const logger = event.locals.log;
-  if (logger && error instanceof Error) {
-    logger.error(error.message, error);
-  }
-};
-const createPailHooks = (options) => {
-  return {
-    handle: pailHandle(options),
-    handleError: pailHandleError()
-  };
-};
-
-export { createPailHooks, pailHandle, pailHandleError, useLogger };
+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};