@visulima/pail 4.0.0-alpha.10 → 4.0.0-alpha.12

package/dist/wide-event.d.ts

@@ -1,300 +1,5 @@
-import type { PailBrowserImpl } from "./pail.d.ts";
-import type { DefaultLogTypes, LoggerFunction } from "./types.d.ts";
-/**
- * A pail instance with dynamically generated log methods.
- * This is the minimal interface WideEvent needs from a pail logger.
- */
-type PailLike<T extends string = string> = PailBrowserImpl<T> & Record<DefaultLogTypes | T, LoggerFunction>;
-/**
- * Makes all properties in T optional recursively.
- */
-type DeepPartial<T> = {
-    [K in keyof T]?: T[K] extends Record<string, unknown> ? DeepPartial<T[K]> : T[K];
-};
-/**
- * Severity levels for wide events.
- */
-export type WideEventLevel = "debug" | "error" | "info" | "warn";
-/**
- * An entry in the request lifecycle log.
- */
-export interface RequestLogEntry {
-    /**
-     * Additional structured context for this log entry.
-     */
-    context?: Record<string, unknown>;
-    /**
-     * Severity level of this entry.
-     */
-    level: WideEventLevel;
-    /**
-     * Human-readable message describing what happened.
-     */
-    message: string;
-    /**
-     * ISO 8601 timestamp of when this entry was recorded.
-     */
-    timestamp: string;
-}
-/**
- * Serialized error information included in the emitted wide event.
- */
-export interface SerializedError {
-    cause?: SerializedError;
-    data?: unknown;
-    message: string;
-    name: string;
-    stack?: string;
-    status?: number;
-}
-/**
- * Options for finishing a wide event with HTTP context.
- */
-export interface WideEventFinishOptions {
-    /**
-     * An error that occurred during the operation.
-     * Will be serialized and included in the emitted event.
-     */
-    error?: Error;
-    /**
-     * HTTP response status code.
-     */
-    status?: number;
-}
-/**
- * Options for creating a WideEvent instance.
- * @template T - Custom logger type names
- */
-export interface WideEventOptions<T extends string = string> {
-    /**
-     * Auto-emit the event when disposed via `Symbol.dispose`.
-     * Works with TC39 Explicit Resource Management (`using`).
-     * @default true
-     */
-    autoEmit?: boolean;
-    /**
-     * Event name identifying this wide event, e.g. "api.checkout", "worker.send-email".
-     */
-    name: string;
-    /**
-     * The pail logger instance to use for emission.
-     */
-    pail: PailLike<T>;
-    /**
-     * Service name for this event. Overrides any service name from pail's scope.
-     */
-    service?: string;
-    /**
-     * Base log type to use when emitting. Defaults to "info".
-     * The actual type may be escalated based on logged warnings/errors.
-     */
-    type?: DefaultLogTypes | T;
-}
-/**
- * A wide event logger that accumulates context incrementally and emits
- * a single comprehensive log event through pail.
- *
- * Instead of scattering multiple log calls throughout an operation,
- * use `set()` to build up context as information becomes available,
- * then emit once at the end. Lifecycle methods (`info()`, `warn()`, `error()`,
- * `debug()`) record timestamped entries in a `requestLogs` array and
- * automatically escalate the event's severity level.
- *
- * Implements `Disposable` for use with TC39 Explicit Resource Management.
- * @template TData - Shape of the accumulated event data
- * @template T - Custom logger type names from the pail instance
- * @example
- * ```typescript
- * // Manual finish
- * const ev = createWideEvent({ pail: logger, name: "api.checkout" });
- * ev.set({ user: { id: 1 } });
- * ev.info("Validated cart");
- * ev.set({ cart: { items: 3, total: 9999 } });
- * ev.finish({ status: 200 });
- *
- * // Auto-emit with Explicit Resource Management
- * using ev = createWideEvent({ pail: logger, name: "api.checkout" });
- * ev.set({ user: { id: 1 } });
- * // emits automatically when scope exits
- *
- * // Typed data shape
- * 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
- * ```
- */
-export declare class WideEvent<TData extends Record<string, unknown> = Record<string, unknown>, T extends string = string> implements Disposable {
-    [Symbol.dispose]: () => void;
-    readonly name: string;
-    private readonly autoEmit;
-    private data;
-    private emitted;
-    private attachedError?;
-    private level;
-    private readonly pail;
-    private readonly requestLogs;
-    private readonly service;
-    private readonly startTime;
-    private status;
-    private readonly timestamp;
-    private readonly type;
-    constructor(options: WideEventOptions<T>);
-    /**
-     * Record a debug-level lifecycle log entry.
-     * Does not escalate the event level.
-     * @param message Description of what happened
-     * @param context Optional structured context
-     * @returns `this` for chaining
-     */
-    debug(message: string, context?: Record<string, unknown>): this;
-    /**
-     * Emit the wide event through the pail logger. Can only be called once;
-     * subsequent calls are no-ops.
-     *
-     * Automatically calculates duration, determines the log type based on
-     * the highest severity level reached, and serializes any attached error.
-     *
-     * Prefer `finish()` for HTTP request contexts where you have a status code.
-     * @param typeOverride Override the log type for this emission
-     */
-    emit(typeOverride?: DefaultLogTypes | T): void;
-    /**
-     * Record an error-level lifecycle log entry and attach the error.
-     * Escalates the event level to "error".
-     * @param message Description of what went wrong
-     * @param error The error that occurred
-     * @param context Optional structured context
-     * @returns `this` for chaining
-     */
-    error(message: string, error?: Error, context?: Record<string, unknown>): this;
-    /**
-     * Finish and emit the wide event with HTTP context.
-     * Sets the response status and optional error before emitting.
-     * @example
-     * ```typescript
-     * ev.finish({ status: 200 });
-     * ev.finish({ status: 500, error: new Error("DB timeout") });
-     * ```
-     * @param options Status code and/or error
-     */
-    finish(options?: WideEventFinishOptions): void;
-    /**
-     * Get a read-only snapshot of the accumulated data.
-     */
-    getData(): Readonly<TData>;
-    /**
-     * Get the current severity level of the event.
-     * The level auto-escalates as `warn()` or `error()` entries are added.
-     */
-    getLevel(): WideEventLevel;
-    /**
-     * Get a read-only copy of the request lifecycle log entries.
-     */
-    getRequestLogs(): ReadonlyArray<RequestLogEntry>;
-    /**
-     * Record an info-level lifecycle log entry.
-     * Does not escalate the event level.
-     * @param message Description of what happened
-     * @param context Optional structured context
-     * @returns `this` for chaining
-     */
-    info(message: string, context?: Record<string, unknown>): this;
-    /**
-     * Accumulate context into the wide event via deep merge.
-     * Call as many times as needed throughout the operation.
-     * @example
-     * ```typescript
-     * ev.set({ user: { id: 1 } });
-     * ev.set({ user: { plan: "pro" } });
-     * // data = { user: { id: 1, plan: "pro" } }
-     * ```
-     * @param data Partial data to merge into the event
-     * @returns `this` for chaining
-     */
-    set(data: DeepPartial<TData>): this;
-    /**
-     * Attach an error to the event. Automatically escalates the event
-     * level to "error".
-     * @param error The error to attach
-     * @returns `this` for chaining
-     */
-    setError(error: Error): this;
-    /**
-     * Set the HTTP response status code.
-     * @param status HTTP status code
-     * @returns `this` for chaining
-     */
-    setStatus(status: number): this;
-    /**
-     * Record a warn-level lifecycle log entry.
-     * Escalates the event level to "warn" (unless already "error").
-     * @param message Description of the warning
-     * @param context Optional structured context
-     * @returns `this` for chaining
-     */
-    warn(message: string, context?: Record<string, unknown>): this;
-    /**
-     * Disposable implementation. Auto-emits the event if `autoEmit` is true
-     * and the event hasn't been manually emitted yet.
-     *
-     * Enables usage with TC39 Explicit Resource Management:
-     * ```typescript
-     * using ev = createWideEvent({ pail: logger, name: "api.checkout" });
-     * ev.set({ user: { id: 1 } });
-     * // auto-emits here when scope exits
-     * ```
-     */
-    [Symbol.dispose](): void;
-    /**
-     * Add an entry to the request lifecycle log and escalate level if needed.
-     */
-    private addLogEntry;
-    /**
-     * Escalate the event level if the new level has higher severity.
-     */
-    private escalateLevel;
-}
-/**
- * Create a wide event logger that accumulates context and emits a single
- * comprehensive log event through pail.
- * @template TData - Shape of the accumulated event data
- * @template T - Custom logger type names from the pail instance
- * @param options Configuration options
- * @returns A new WideEvent instance
- * @example
- * ```typescript
- * import { createPail } from "@visulima/pail";
- * import { createWideEvent } from "@visulima/pail/wide-event";
- *
- * const logger = createPail();
- *
- * // In a request handler:
- * 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: "2025-01-24T10: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", timestamp: "...", context: { itemCount: 3 } },
- * //     { level: "info", message: "Payment processed", timestamp: "..." }
- * //   ]
- * // }
- * ```
- */
-export declare const createWideEvent: <TData extends Record<string, unknown> = Record<string, unknown>, T extends string = string>(options: WideEventOptions<T>) => WideEvent<TData, T>;
-export {};
+export { R as RequestLogEntry, S as SerializedError, W as WideEvent, a as WideEventFinishOptions, b as WideEventLevel, c as WideEventOptions, d as createWideEvent } from "./packem_shared/wide-event.d-B-t8ZnhI.js";
+import "./packem_shared/types.d-BeLumqgD.js";
+import 'safe-stable-stringify';
+import '@visulima/colorize';
+import '@visulima/interactive-manager';

package/dist/wide-event.js

@@ -66,7 +66,8 @@ class WideEvent {
   startTime;
   status;
   timestamp;
-  type;
+  // @ts-expect-error TS6133 -- preserved for future use (richer event categorization)
+  _type;
   constructor(options) {
     this.name = options.name;
     this.pail = options.pail;
@@ -75,7 +76,7 @@ class WideEvent {
     this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
     this.emitted = false;
     this.autoEmit = options.autoEmit ?? true;
-    this.type = options.type ?? "info";
+    this._type = options.type ?? "info";
     this.level = "info";
     this.requestLogs = [];
     this.service = options.service;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@visulima/pail",
-  "version": "4.0.0-alpha.10",
+  "version": "4.0.0-alpha.12",
   "description": "Highly configurable Logger for Node.js, Edge and Browser.",
   "keywords": [
-    "ansi",
     "anolilab",
+    "ansi",
     "browser",
     "browser-logger",
     "callsite",
@@ -27,8 +27,8 @@
     "json",
     "json-logger",
     "json-logging",
-    "log level",
     "log",
+    "log level",
     "log-cleaner",
     "log-rotation",
     "log4j",
@@ -37,11 +37,10 @@
     "logger",
     "logging",
     "node",
-    "stream",
-    "pretty",
     "node-logger",
     "pail",
     "pino",
+    "pretty",
     "pretty-error",
     "pretty-log",
     "print",
@@ -49,6 +48,7 @@
     "redact",
     "rotating-log",
     "show error",
+    "stream",
     "timer",
     "universal",
     "visulima",
@@ -190,18 +190,6 @@
         "default": "./dist/reporter/http/http-reporter.js"
       }
     },
-    "./progress-bar": {
-      "types": "./dist/progress-bar.d.ts",
-      "default": "./dist/progress-bar.js"
-    },
-    "./spinner": {
-      "types": "./dist/spinner.d.ts",
-      "default": "./dist/spinner.js"
-    },
-    "./interactive": {
-      "types": "./dist/interactive/index.d.ts",
-      "default": "./dist/interactive/index.js"
-    },
     "./object-tree": {
       "types": "./dist/object-tree.d.ts",
       "default": "./dist/object-tree.js"
@@ -243,13 +231,13 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@visulima/colorize": "2.0.0-alpha.8",
-    "type-fest": "5.5.0"
+    "@visulima/colorize": "2.0.0-alpha.10",
+    "@visulima/interactive-manager": "1.0.0-alpha.2"
   },
   "peerDependencies": {
     "@opentelemetry/api": "1.9.1",
     "@sveltejs/kit": ">=2.0",
-    "@visulima/redact": "3.0.0-alpha.8",
+    "@visulima/redact": "3.0.0-alpha.10",
     "elysia": ">=1.0",
     "express": ">=4.0",
     "fastify": ">=4.0",
@@ -287,7 +275,7 @@
     }
   },
   "engines": {
-    "node": ">=22.13 <=25.x"
+    "node": "^22.14.0 || >=24.10.0"
   },
   "os": [
     "darwin",

package/dist/constants.d.ts

@@ -1,37 +0,0 @@
-import type { DefaultLoggerTypes } from "./types.d.ts";
-/**
- * Extended RFC 5424 Log Levels
- *
- * The log levels pail uses are those defined in the syslog protocol.
- * Each level is assigned a numeric priority where lower numbers indicate higher priority.
- * @see https://datatracker.ietf.org/doc/html/rfc5424#page-36
- * @example
- * ```typescript
- * import { EXTENDED_RFC_5424_LOG_LEVELS } from "@visulima/pail";
- *
- * console.log(EXTENDED_RFC_5424_LOG_LEVELS.error); // 5
- * ```
- */
-export declare const EXTENDED_RFC_5424_LOG_LEVELS: Record<string, number>;
-/**
- * Default Logger Types Configuration
- *
- * Predefined logger types with their associated colors, labels, and log levels.
- * These types provide semantic meaning to different kinds of log messages.
- * @example
- * ```typescript
- * import { LOG_TYPES } from "@visulima/pail";
- *
- * console.log(LOG_TYPES.error.color); // "red"
- * console.log(LOG_TYPES.success.label); // "success"
- * ```
- */
-export declare const LOG_TYPES: DefaultLoggerTypes;
-/**
- * Empty Symbol
- *
- * A unique symbol used internally to represent empty or undefined message values.
- * This helps distinguish between intentional empty messages and undefined values.
- * @internal
- */
-export declare const EMPTY_SYMBOL: symbol;

package/dist/interactive/index.d.ts

@@ -1,2 +0,0 @@
-export { default as InteractiveManager } from "./interactive-manager.d.ts";
-export { default as InteractiveStreamHook } from "./interactive-stream-hook.d.ts";

package/dist/interactive/index.js

@@ -1,2 +0,0 @@
-export { default as InteractiveManager } from '../packem_shared/InteractiveManager-CowYA3Hx.js';
-export { default as InteractiveStreamHook } from '../packem_shared/InteractiveStreamHook-BypRlYTX.js';

package/dist/interactive/interactive-manager.d.ts

@@ -1,108 +0,0 @@
-import type InteractiveStreamHook from "./interactive-stream-hook.d.ts";
-/** Supported stream types for interactive output */
-type StreamType = "stderr" | "stdout";
-/**
- * Interactive Manager.
- *
- * Manages interactive terminal output by coordinating stdout and stderr streams.
- * Enables features like progress bars, spinners, and dynamic updates by temporarily
- * capturing and controlling terminal output. Supports suspending and resuming
- * interactive mode for external output.
- * @example
- * ```typescript
- * const manager = new InteractiveManager(stdoutHook, stderrHook);
- *
- * // Start interactive mode
- * manager.hook();
- *
- * // Update output dynamically
- * manager.update("stdout", ["Processing...", "50% complete"]);
- *
- * // Temporarily suspend for external output
- * manager.suspend("stdout");
- * console.log("External message");
- * manager.resume("stdout");
- *
- * // End interactive mode and show final output
- * manager.unhook();
- * ```
- */
-declare class InteractiveManager {
-    #private;
-    /**
-     * Creates a new InteractiveManager with the given stream hooks.
-     * @param stdout Hook for stdout stream
-     * @param stderr Hook for stderr stream
-     */
-    constructor(stdout: InteractiveStreamHook, stderr: InteractiveStreamHook);
-    /**
-     * Last printed rows count.
-     *
-     * Tracks the number of rows that were last written to the terminal.
-     * Used internally for managing cursor positioning and output updates.
-     */
-    get lastLength(): number;
-    /**
-     * Rows count outside editable area.
-     *
-     * Tracks the number of rows that extend beyond the current terminal height.
-     * Used for managing scrolling and ensuring all output remains visible.
-     */
-    get outside(): number;
-    /**
-     * Hook activity status.
-     *
-     * Indicates whether the interactive hooks are currently active.
-     * When true, streams are being intercepted for interactive output.
-     */
-    get isHooked(): boolean;
-    /**
-     * Suspend status for active hooks.
-     *
-     * Indicates whether interactive mode is temporarily suspended.
-     * When suspended, external output can be written without interference.
-     */
-    get isSuspended(): boolean;
-    /**
-     * Removes lines from the terminal output.
-     *
-     * Erases the specified number of lines from the bottom of the output,
-     * moving the cursor up and clearing the lines. Useful for removing
-     * previous interactive output before displaying new content.
-     * @param stream The stream to erase lines from ("stdout" or "stderr")
-     * @param count Number of lines to remove (defaults to lastLength)
-     * @throws {TypeError} If the specified stream is not available
-     */
-    erase(stream: StreamType, count?: number): void;
-    /**
-     * Hook stdout and stderr streams.
-     * @returns Success status
-     */
-    hook(): boolean;
-    /**
-     * Resume suspend hooks.
-     * @param stream Stream to resume
-     * @param eraseRowCount erase output rows count
-     */
-    resume(stream: StreamType, eraseRowCount?: number): void;
-    /**
-     * Suspend active hooks for external output.
-     * @param stream Stream to suspend
-     * @param erase erase output
-     */
-    suspend(stream: StreamType, erase?: boolean): void;
-    /**
-     * Unhooks both stdout and stderr streams and print their story of logs.
-     * @param separateHistory If `true`, will add an empty line to the history output for individual recorded lines and console logs
-     * @returns Success status
-     */
-    unhook(separateHistory?: boolean): boolean;
-    /**
-     * Update output.
-     * @param stream Stream to write to
-     * @param rows Text lines to write to standard output
-     * @param from Index of the line starting from which the contents of the terminal are being overwritten
-     */
-    update(stream: StreamType, rows: string[], from?: number): void;
-}
-export default InteractiveManager;

package/dist/interactive/interactive-stream-hook.d.ts

@@ -1,68 +0,0 @@
-/**
- * Interactive Stream Hook.
- *
- * A utility class that hooks into Node.js WriteStreams to capture output
- * for interactive terminal applications. It allows temporarily intercepting
- * stream writes to enable features like progress bars and dynamic updates.
- * @example
- * ```typescript
- * const hook = new InteractiveStreamHook(process.stdout);
- * hook.active(); // Start capturing output
- *
- * // Output will be stored in history instead of being written to stdout
- * console.log("This won't appear immediately");
- *
- * hook.inactive(); // Stop capturing and replay stored output
- * ```
- */
-declare class InteractiveStreamHook {
-    #private;
-    /** Constant indicating the stream write operation was successful */
-    static readonly DRAIN = true;
-    /**
-     * Creates a new InteractiveStreamHook for the given stream.
-     * @param stream The Node.js WriteStream to hook into (usually stdout or stderr)
-     */
-    constructor(stream: NodeJS.WriteStream);
-    /**
-     * Activates the stream hook.
-     *
-     * When active, all writes to the stream are captured in history instead of
-     * being written immediately. This allows for interactive features like
-     * progress bars that can update dynamically.
-     */
-    active(): void;
-    /**
-     * Erases the specified number of lines from the terminal.
-     *
-     * Uses ANSI escape sequences to remove lines from the current cursor position
-     * upwards, which is useful for clearing previous output in interactive applications.
-     * @param count Number of lines to erase (including the current line)
-     */
-    erase(count: number): void;
-    /**
-     * Deactivates the stream hook and replays captured output.
-     *
-     * Restores normal stream operation and outputs all captured history.
-     * Optionally adds a newline separator before replaying the history.
-     * @param separateHistory Whether to add a newline before replaying history
-     */
-    inactive(separateHistory?: boolean): void;
-    /**
-     * Renews the stream hook state.
-     *
-     * Restores the original stream write method and shows the cursor.
-     * This is typically called when temporarily suspending interactive mode.
-     */
-    renew(): void;
-    /**
-     * Writes a message directly to the underlying stream.
-     *
-     * Bypasses the hook mechanism and writes directly using the original
-     * stream write method. Useful for writing control sequences or
-     * messages that should not be captured in history.
-     * @param message The message to write to the stream
-     */
-    write(message: string): void;
-}
-export default InteractiveStreamHook;

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

@@ -1,59 +0,0 @@
-/**
- * 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.d.ts";
- * @param options Middleware configuration
- * @returns A middleware function
- * @example
- * ```typescript
- * // middleware.ts
- * import { NextResponse } from "next/server.d.ts";
- * import { pailMiddleware } from "@visulima/pail/middleware/next";
- *
- * const middleware = pailMiddleware(NextResponse, {
- *   exclude: ["/_next/**", "/favicon.ico"],
- * });
- *
- * export default middleware;
- * ```
- */
-export declare const pailMiddleware: (NextResponseClass: NextResponseConstructor, options?: PailNextMiddlewareOptions) => (request: NextRequest) => NextResponse;
-export type { PailNextMiddlewareOptions };