@visulima/pail 4.0.0-alpha.8 → 4.0.0

package/dist/middleware/hono.d.ts

@@ -1,85 +1,88 @@
-import type { WideEvent } from "../wide-event.d.ts";
-import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+import { W as WideEvent } from "../packem_shared/wide-event.d-D3ATYpoK.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-B-JmQ1Sl.js";
+import "../packem_shared/index.d-T71KjNAr.js";
+import 'type-fest';
+import "../packem_shared/types.d-bWnqHJKL.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-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 };
+import{e as c,c as g}from"../packem_shared/headers-DH0H2s8W.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

@@ -1,36 +1,104 @@
-import type { PailMiddlewareOptions } from "../shared/create-middleware-logger.d.ts";
+import { P as PailMiddlewareOptions } from "../../packem_shared/create-middleware-logger.d-B-JmQ1Sl.js";
+import { W as WideEvent } from "../../packem_shared/wide-event.d-D3ATYpoK.js";
+import 'node:async_hooks';
+import "../../packem_shared/types.d-bWnqHJKL.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+import 'type-fest';
+import "../../packem_shared/index.d-T71KjNAr.js";
+/**
+* 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-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 };
+import{e as m,c as l}from"../../packem_shared/headers-DH0H2s8W.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

@@ -1,123 +1,126 @@
-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-D3ATYpoK.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-B-JmQ1Sl.js";
+import "../packem_shared/index.d-T71KjNAr.js";
+import 'type-fest';
+import "../packem_shared/types.d-bWnqHJKL.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-Cp4uLtr4.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 };
+import{e as g,c as i}from"../packem_shared/headers-DH0H2s8W.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=r=>async({event:e,resolve:a})=>{const d=e.request.headers.get("x-request-id")??crypto.randomUUID(),l=g(e.request.headers),{finish:t,logger:s,skipped:c}=i(r,{headers:l,method:e.request.method,path:e.url.pathname,requestId:d});return c?a(e):(e.locals.log=s,n.storage.run(s,async()=>{try{const o=await a(e);return t({status:o.status}),o}catch(o){throw t({error:o instanceof Error?o:new Error(String(o))}),o}}))},p=()=>({error:r,event:e})=>{const a=e.locals.log;a&&r instanceof Error&&a.error(r.message,r)},q=r=>({handle:h(r),handleError:p()});export{q as createPailHooks,h as pailHandle,p as pailHandleError,k as useLogger};