@visulima/pail 4.0.0-alpha.6 → 4.0.0-alpha.8

package/CHANGELOG.md

@@ -1,3 +1,38 @@
+## @visulima/pail [4.0.0-alpha.8](https://github.com/visulima/visulima/compare/@visulima/pail@4.0.0-alpha.7...@visulima/pail@4.0.0-alpha.8) (2026-03-26)
+
+### Bug Fixes
+
+* **pail:** use workspace:* for internal [@visulima](https://github.com/visulima) deps ([8423dd7](https://github.com/visulima/visulima/commit/8423dd779fbea0acff8f090e548a423e46d761fd))
+* **web:** improve build setup with incremental stats caching and prod install ([fe33e75](https://github.com/visulima/visulima/commit/fe33e75827586779b4b3a0c6d57b39f889ee6207))
+
+### Miscellaneous Chores
+
+* **pail:** migrate deps to pnpm catalogs ([b2acd86](https://github.com/visulima/visulima/commit/b2acd864a40d0b2cc8eaf4e531cb2dedfd54181a))
+* update license ([b2d306c](https://github.com/visulima/visulima/commit/b2d306cfeb1eabfd9e24880cb9198f6360724d82))
+
+
+### Dependencies
+
+* **@visulima/colorize:** upgraded to 2.0.0-alpha.6
+* **@visulima/error:** upgraded to 6.0.0-alpha.6
+* **@visulima/fmt:** upgraded to 2.0.0-alpha.6
+* **@visulima/inspector:** upgraded to 2.0.0-alpha.5
+* **@visulima/redact:** upgraded to 3.0.0-alpha.6
+* **@visulima/string:** upgraded to 3.0.0-alpha.7
+
+## @visulima/pail [4.0.0-alpha.7](https://github.com/visulima/visulima/compare/@visulima/pail@4.0.0-alpha.6...@visulima/pail@4.0.0-alpha.7) (2026-03-16)
+
+### Features
+
+* **pail:** add self-documenting errors, sampling processor, and environment processor ([3ec79de](https://github.com/visulima/visulima/commit/3ec79de3034cee4d1514dc93e78da2d05df4f9a7))
+* **pail:** add wide events, framework middleware, tests, and docs ([6d1a4f3](https://github.com/visulima/visulima/commit/6d1a4f3ef4455da78371b8754cdbca9c939bc8b4))
+
+### Miscellaneous Chores
+
+* **pail:** update dependencies ([72b9561](https://github.com/visulima/visulima/commit/72b9561a3416a121198ea47cdcbe0202c0d8cbef))
+* remove exit 0 ([b6d2408](https://github.com/visulima/visulima/commit/b6d2408fab8b5299a5ae902021b229909c84f184))
+* visulima website ([#591](https://github.com/visulima/visulima/issues/591)) ([59ab2e2](https://github.com/visulima/visulima/commit/59ab2e2befb03e51cd2088956f83d9b87de6d033))
+
 ## @visulima/pail [4.0.0-alpha.6](https://github.com/visulima/visulima/compare/@visulima/pail@4.0.0-alpha.5...@visulima/pail@4.0.0-alpha.6) (2026-03-06)
 
 ### Bug Fixes

package/LICENSE.md

@@ -34,7 +34,7 @@ Repository: git+https://github.com/visulima/visulima.git
 
 > MIT License
 >
-> Copyright (c) 2025 visulima
+> Copyright (c) 2026 visulima
 >
 > Permission is hereby granted, free of charge, to any person obtaining a copy
 > of this software and associated documentation files (the "Software"), to deal
@@ -68,7 +68,7 @@ Repository: git+https://github.com/visulima/visulima.git
 >
 > > MIT License
 > >
-> > Copyright (c) 2025 visulima
+> > Copyright (c) 2026 visulima
 > >
 > > Permission is hereby granted, free of charge, to any person obtaining a copy
 > > of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -63,6 +63,8 @@ If you're upgrading from an earlier version of pail, check out our [Migration Gu
 - ESM‑only with tree‑shaking support (Node.js ≥ 20.19)
 - Supports circular structures
 - Fast and powerful, see the [benchmarks](__bench__/README.md)
+- [Wide events](#wide-events) — accumulate context across an operation and emit once
+- [Framework middleware](#framework-middleware) for Express, Fastify, Hono, Elysia, SvelteKit, and Next.js
 
 ## Install
 
@@ -1064,6 +1066,327 @@ When a log entry exceeds `maxLogSize`, a `LogSizeError` is thrown. When a batch
 | `onDebugRequestResponse` | `(reqRes: {...}) => void`                  | `undefined`          | Debug callback for HTTP requests/responses    |
 | `payloadTemplate`        | `(data: {...}) => string`                  | `undefined`          | Custom payload formatter                      |
 
+## Wide Events
+
+Wide events let you accumulate structured context throughout an operation and emit a single, comprehensive log event at the end — instead of scattering multiple log calls.
+
+Inspired by [Charity Majors' wide events](https://charity.wtf/2019/02/05/logs-vs-structured-events/) pattern.
+
+### Basic Usage
+
+```typescript
+import { createPail } from "@visulima/pail";
+import { createWideEvent } from "@visulima/pail/wide-event";
+
+const logger = createPail();
+
+const ev = createWideEvent({ pail: logger, name: "api.checkout" });
+
+ev.set({ user: { id: 1, plan: "pro" } });
+ev.info("Validated cart", { itemCount: 3 });
+ev.set({ cart: { id: 42, items: 3, total: 9999 } });
+ev.info("Payment processed");
+ev.finish({ status: 200 });
+
+// Emits a single structured log:
+// {
+//   event: "api.checkout",
+//   timestamp: "2026-03-14T10:23:45.612Z",
+//   duration: "127ms",
+//   duration_ms: 127,
+//   status: 200,
+//   user: { id: 1, plan: "pro" },
+//   cart: { id: 42, items: 3, total: 9999 },
+//   requestLogs: [
+//     { level: "info", message: "Validated cart", context: { itemCount: 3 }, timestamp: "..." },
+//     { level: "info", message: "Payment processed", timestamp: "..." }
+//   ]
+// }
+```
+
+### Auto-Emit with Explicit Resource Management
+
+Wide events implement `Disposable` for use with TC39 Explicit Resource Management (`using`):
+
+```typescript
+{
+    using ev = createWideEvent({ pail: logger, name: "api.checkout" });
+    ev.set({ user: { id: 1 } });
+    // auto-emits when scope exits
+}
+```
+
+### Typed Data Shape
+
+```typescript
+interface CheckoutData {
+    user: { id: number; plan: string };
+    cart: { items: number; total: number };
+}
+
+const ev = createWideEvent<CheckoutData>({ pail: logger, name: "api.checkout" });
+ev.set({ user: { id: 1, plan: "pro" } }); // fully typed
+```
+
+### Level Escalation
+
+The event level auto-escalates based on lifecycle log entries. If you call `warn()` or `error()`, the final emission uses the highest severity:
+
+```typescript
+const ev = createWideEvent({ pail: logger, name: "api.checkout" });
+
+ev.info("Cart validated"); // level stays "info"
+ev.warn("Rate limit approaching"); // level escalates to "warn"
+ev.info("Payment processed"); // level stays "warn" (no de-escalation)
+ev.finish({ status: 200 }); // emits at "warn" level
+```
+
+### Error Handling
+
+```typescript
+const ev = createWideEvent({ pail: logger, name: "api.checkout" });
+
+try {
+    await processPayment();
+} catch (error) {
+    ev.error("Payment failed", error);
+    ev.finish({ status: 500, error });
+    // Emits with serialized error (name, message, stack, status, cause chain)
+}
+```
+
+### Options
+
+| Option     | Type          | Default  | Description                       |
+| ---------- | ------------- | -------- | --------------------------------- |
+| `name`     | `string`      | required | Event name, e.g. `"api.checkout"` |
+| `pail`     | Pail instance | required | The pail logger to emit through   |
+| `service`  | `string`      | —        | Service name override             |
+| `type`     | `string`      | `"info"` | Base log type (may be escalated)  |
+| `autoEmit` | `boolean`     | `true`   | Auto-emit on `Symbol.dispose`     |
+
+### Methods
+
+| Method                   | Description                                   |
+| ------------------------ | --------------------------------------------- |
+| `set(data)`              | Deep-merge partial data into the event        |
+| `info(msg, ctx?)`        | Record an info-level lifecycle entry          |
+| `warn(msg, ctx?)`        | Record a warn-level entry (escalates level)   |
+| `error(msg, err?, ctx?)` | Record an error-level entry (escalates level) |
+| `debug(msg, ctx?)`       | Record a debug-level entry                    |
+| `setError(error)`        | Attach an error (escalates to "error")        |
+| `setStatus(code)`        | Set HTTP status code                          |
+| `finish(opts?)`          | Set status/error and emit                     |
+| `emit(typeOverride?)`    | Emit the event (only fires once)              |
+| `getData()`              | Get read-only snapshot of accumulated data    |
+| `getLevel()`             | Get current severity level                    |
+| `getRequestLogs()`       | Get read-only lifecycle log entries           |
+
+## Framework Middleware
+
+Pail provides first-class middleware/plugin adapters for popular web frameworks. Each adapter creates a request-scoped [Wide Event](#wide-events) that:
+
+- Accumulates context throughout the request lifecycle
+- Auto-emits a single structured log when the response completes or an error occurs
+- Is accessible via `req.log` / `request.log` / `context.log` and `useLogger()`
+- Supports route inclusion/exclusion via glob patterns
+- Supports per-route service name overrides
+
+### Shared Options
+
+All middleware adapters accept these options:
+
+| Option    | Type                           | Description                         |
+| --------- | ------------------------------ | ----------------------------------- |
+| `pail`    | Pail instance                  | The pail logger (required)          |
+| `service` | `string`                       | Default service name                |
+| `include` | `string[]`                     | Glob patterns for paths to include  |
+| `exclude` | `string[]`                     | Glob patterns for paths to exclude  |
+| `routes`  | `Record<string, { service? }>` | Per-route config (first match wins) |
+
+### Express
+
+```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 } });
+    req.log.info("Fetched user list");
+    // or from anywhere in the async call stack:
+    // useLogger().set({ user: { id: 1 } });
+    res.json({ ok: true });
+});
+```
+
+**Exports:** `pailMiddleware`, `useLogger`, `PailRequest`, `PailResponse`, `PailNextFunction`, `PailExpressMiddleware`, `WideEvent`
+
+### Fastify
+
+```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 };
+});
+```
+
+**Exports:** `pailPlugin`, `useLogger`, `PailFastifyRequest`, `PailFastifyReply`, `PailFastifyInstance`, `WideEvent`
+
+### Hono
+
+```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 });
+});
+```
+
+> **Note:** Hono's `useLogger()` takes the context `c` as an argument (the logger is stored on the context, not in AsyncLocalStorage).
+
+**Exports:** `pailMiddleware`, `useLogger`, `PailHonoContext`, `PailHonoNext`, `PailHonoMiddleware`, `WideEvent`
+
+### Elysia
+
+```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 };
+});
+```
+
+**Exports:** `pailPlugin`, `useLogger`, `PailElysiaInstance`, `WideEvent`
+
+### SvelteKit
+
+```typescript
+// src/hooks.server.ts
+import { createPail } from "@visulima/pail";
+import { createPailHooks, useLogger } from "@visulima/pail/middleware/sveltekit";
+
+const logger = createPail();
+const { handle, handleError } = createPailHooks({ pail: logger });
+
+export { handle, handleError };
+```
+
+```typescript
+// In a load function or action:
+import { useLogger } from "@visulima/pail/middleware/sveltekit";
+
+export const load = async (event) => {
+    event.locals.log.set({ user: { id: 1 } });
+    // or from anywhere in the async call stack:
+    // useLogger().set({ user: { id: 1 } });
+};
+```
+
+**Exports:** `pailHandle`, `pailHandleError`, `createPailHooks`, `useLogger`, `PailSvelteKitEvent`, `PailSvelteKitHandle`, `PailSvelteKitHandleError`, `WideEvent`
+
+### Next.js
+
+Next.js integration uses two parts: an edge middleware for request ID injection and a handler wrapper for wide event logging.
+
+```typescript
+// middleware.ts
+import { NextResponse } from "next/server";
+import { pailMiddleware } from "@visulima/pail/middleware/next";
+
+export default pailMiddleware(NextResponse, {
+    exclude: ["/_next/**", "/favicon.ico"],
+});
+```
+
+```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 });
+```
+
+```typescript
+// 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 });
+});
+```
+
+**Exports:** `pailMiddleware`, `createWithPail`, `useLogger`, `WideEvent`
+
+### Route Configuration
+
+All adapters support glob-based route configuration:
+
+```typescript
+pailMiddleware({
+    pail: logger,
+    service: "api-gateway",
+    exclude: ["/health", "/metrics", "/_next/**"],
+    include: ["/api/**"],
+    routes: {
+        "/api/auth/**": { service: "auth-service" },
+        "/api/payments/**": { service: "payments-service" },
+    },
+});
+```
+
+- **Exclusions take precedence** over inclusions
+- **Glob patterns** support `*` (any non-`/`), `**` (any including `/`), and `?` (single char)
+- **Route service overrides** apply to the first matching pattern
+
+### Sensitive Header Filtering
+
+All adapters automatically filter sensitive headers before logging:
+
+| Filtered Headers      |
+| --------------------- |
+| `authorization`       |
+| `cookie`              |
+| `set-cookie`          |
+| `x-api-key`           |
+| `x-auth-token`        |
+| `proxy-authorization` |
+
 ## Integrations
 
 ### Use with @visulima/boxen

package/dist/error.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Options for creating a PailError.
+ *
+ * Extends standard error properties with self-documenting fields
+ * that provide actionable context for debugging, particularly useful
+ * for AI-assisted log analysis.
+ */
+interface PailErrorOptions {
+    /** The root cause of this error */
+    cause?: unknown;
+    /** A suggested resolution or steps to fix the issue */
+    fix?: string;
+    /** A link to relevant documentation or issue tracker */
+    link?: string;
+    /** The error message */
+    message: string;
+    /** HTTP status code associated with this error */
+    status?: number;
+    /** An explanation of what caused the failure */
+    why?: string;
+}
+/**
+ * Self-documenting error class for structured logging.
+ *
+ * Inspired by evlog's structured error approach, PailError extends the native
+ * Error class with additional fields that make log entries immediately actionable:
+ * - `why`: Explains what caused the failure
+ * - `fix`: Suggests how to resolve the issue
+ * - `link`: Points to relevant documentation
+ * - `status`: HTTP status code for request-related errors
+ *
+ * These fields are preserved through the logging pipeline and displayed by reporters,
+ * making it easier for both humans and AI agents to understand and resolve issues.
+ * @example
+ * ```typescript
+ * import { PailError, createPailError } from "@visulima/pail/error";
+ *
+ * // Using the class directly
+ * throw new PailError({
+ *   message: "Payment processing failed",
+ *   status: 402,
+ *   why: "The customer's card was declined by the payment provider",
+ *   fix: "Retry with a different payment method or contact the card issuer",
+ *   link: "https://docs.example.com/payments/declined",
+ * });
+ *
+ * // Using the factory function
+ * throw createPailError("Connection timeout");
+ *
+ * // With full options
+ * throw createPailError({
+ *   message: "Database connection failed",
+ *   why: "Connection pool exhausted after 30s timeout",
+ *   fix: "Increase pool size or check for connection leaks",
+ * });
+ * ```
+ */
+declare class PailError extends Error {
+    /** HTTP status code (defaults to 500) */
+    readonly status: number;
+    /** Explanation of what caused the failure */
+    readonly why: string | undefined;
+    /** Suggested resolution steps */
+    readonly fix: string | undefined;
+    /** Link to relevant documentation */
+    readonly link: string | undefined;
+    constructor(options: PailErrorOptions | string);
+    /**
+     * Converts the error to a JSON-serializable object.
+     *
+     * Includes all self-documenting fields in the output for structured logging.
+     * @returns A plain object representation of the error
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Returns a formatted string representation including self-documenting fields.
+     * @returns Formatted error string with why/fix/link context
+     */
+    toString(): string;
+}
+/**
+ * Factory function for creating PailError instances.
+ *
+ * A convenient shorthand for creating PailError objects. Accepts either
+ * a string message or a full PailErrorOptions object.
+ * @param options Error message string or PailErrorOptions object
+ * @returns A new PailError instance
+ * @example
+ * ```typescript
+ * import { createPailError } from "@visulima/pail/error";
+ *
+ * throw createPailError("Something went wrong");
+ *
+ * throw createPailError({
+ *   message: "Auth failed",
+ *   status: 401,
+ *   why: "Token expired",
+ *   fix: "Refresh the authentication token",
+ * });
+ * ```
+ */
+declare const createPailError: (options: PailErrorOptions | string) => PailError;
+export { createPailError, PailError };
+export type { PailErrorOptions };

package/dist/error.js

@@ -0,0 +1,76 @@
+class PailError extends Error {
+  /** HTTP status code (defaults to 500) */
+  status;
+  /** Explanation of what caused the failure */
+  why;
+  /** Suggested resolution steps */
+  fix;
+  /** Link to relevant documentation */
+  link;
+  constructor(options) {
+    const resolvedOptions = typeof options === "string" ? { message: options } : options;
+    super(resolvedOptions.message, resolvedOptions.cause === void 0 ? void 0 : { cause: resolvedOptions.cause });
+    this.name = "PailError";
+    this.status = resolvedOptions.status ?? 500;
+    this.why = resolvedOptions.why;
+    this.fix = resolvedOptions.fix;
+    this.link = resolvedOptions.link;
+  }
+  /**
+   * Converts the error to a JSON-serializable object.
+   *
+   * Includes all self-documenting fields in the output for structured logging.
+   * @returns A plain object representation of the error
+   */
+  toJSON() {
+    const json = {
+      message: this.message,
+      name: this.name,
+      status: this.status
+    };
+    if (this.why) {
+      json.why = this.why;
+    }
+    if (this.fix) {
+      json.fix = this.fix;
+    }
+    if (this.link) {
+      json.link = this.link;
+    }
+    if (this.stack) {
+      json.stack = this.stack;
+    }
+    if (this.cause !== void 0) {
+      json.cause = this.cause instanceof Error ? { message: this.cause.message, name: this.cause.name, stack: this.cause.stack } : this.cause;
+    }
+    return json;
+  }
+  /**
+   * Returns a formatted string representation including self-documenting fields.
+   * @returns Formatted error string with why/fix/link context
+   */
+  toString() {
+    let output = `${this.name} [${this.status}]: ${this.message}`;
+    if (this.why) {
+      output += `
+  Why: ${this.why}`;
+    }
+    if (this.fix) {
+      output += `
+  Fix: ${this.fix}`;
+    }
+    if (this.link) {
+      output += `
+  Link: ${this.link}`;
+    }
+    if (this.cause !== void 0) {
+      const causeMessage = this.cause instanceof Error ? this.cause.message : String(this.cause);
+      output += `
+  Cause: ${causeMessage}`;
+    }
+    return output;
+  }
+}
+const createPailError = (options) => new PailError(options);
+
+export { PailError, createPailError };

package/dist/index.browser.d.ts

@@ -44,4 +44,6 @@ export declare const createPail: <T extends string = string, L extends string =
  */
 export declare const pail: PailBrowserType<string, string>;
 export type { PailBrowserType as Pail } from "./pail.d.ts";
+export type { PailErrorOptions } from "./error.d.ts";
+export { createPailError, PailError } from "./error.d.ts";
 export type { ConstructorOptions, DefaultLoggerTypes, DefaultLogTypes, ExtendedRfc5424LogLevels, LoggerConfiguration, LoggerFunction, LoggerTypesAwareReporter, LoggerTypesConfig, Processor, Reporter, StreamAwareReporter, } from "./types.d.ts";

package/dist/index.browser.js

@@ -1,10 +1,11 @@
 import { a as EXTENDED_RFC_5424_LOG_LEVELS, E as EMPTY_SYMBOL, L as LOG_TYPES } from './packem_shared/constants-omsTHUWB.js';
 import { w as writeConsoleLogBasedOnLevel } from './packem_shared/write-console-log-based-on-level-DBmRYXpj.js';
 import { g as getLongestLabel, b as build } from './packem_shared/index-DnkF86LQ.js';
-import JsonReporter from './packem_shared/JsonReporter-BRw4skd5.js';
+import JsonReporter from './packem_shared/JsonReporter-p_BXg6Sj.js';
+export { PailError, createPailError } from './packem_shared/createPailError-B11aRfrT.js';
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 
 var safeStableStringify = {exports: {}};

package/dist/index.server.d.ts

@@ -62,4 +62,6 @@ export type { MultiBarOptions, ProgressBarOptions, ProgressBarPayload, ProgressB
 export { getBarChar, MultiProgressBar, ProgressBar } from "./progress-bar.d.ts";
 export type { SpinnerIcons, SpinnerOptions, SpinnerStartOptions, SpinnerStyle } from "./spinner.d.ts";
 export { MultiSpinner, Spinner } from "./spinner.d.ts";
+export type { PailErrorOptions } from "./error.d.ts";
+export { createPailError, PailError } from "./error.d.ts";
 export type { ConstructorOptions, DefaultLoggerTypes, DefaultLogTypes, ExtendedRfc5424LogLevels, LoggerConfiguration, LoggerFunction, LoggerTypesAwareReporter, LoggerTypesConfig, Processor, Reporter, StreamAwareReporter, } from "./types.d.ts";

package/dist/index.server.js

@@ -30,6 +30,7 @@ import { ProgressBar, applyStyleToOptions, MultiProgressBar } from './packem_sha
 export { getBarChar } from './packem_shared/getBarChar-BWj1UrH3.js';
 import { Spinner, MultiSpinner } from './packem_shared/Spinner-DIdVcfWq.js';
 import colorize, { red, greenBright, cyan, green, grey, bgGrey, underline, white } from '@visulima/colorize';
+export { PailError, createPailError } from './packem_shared/createPailError-B11aRfrT.js';
 
 class InteractiveManager {
   #stream;
@@ -317,8 +318,8 @@ class InteractiveStreamHook {
   }
 }
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 
 var safeStableStringify = {exports: {}};
@@ -2946,7 +2947,8 @@ class MessageFormatterProcessor {
   }
 }
 
-const pailFileFilter = (line) => !/[\\/]pail[\\/]dist/.test(line);
+const PAIL_DIST_REGEX = /[\\/]pail[\\/]dist/;
+const pailFileFilter = (line) => !PAIL_DIST_REGEX.test(line);
 class PrettyReporter extends AbstractPrettyReporter {
   #stdout;
   #stderr;