@visulima/pail 3.0.3 → 3.2.0

package/dist/index.server.d.ts

@@ -1,74 +1,14 @@
-import { I as InteractiveManager, e as ServerConstructorOptions, R as Reporter, a as DefaultLogTypes, b as LoggerFunction, C as ConstructorOptions } from './packem_shared/types-RidvA4RN.js';
-export { D as DefaultLoggerTypes, E as ExtendedRfc5424LogLevels, L as LoggerConfiguration, c as LoggerTypesAwareReporter, d as LoggerTypesConfig, P as Processor, S as StreamAwareReporter } from './packem_shared/types-RidvA4RN.js';
-import { a as PailBrowserImpl } from './packem_shared/pail.browser-Bs2ng_Qj.js';
-import '@visulima/colorize';
-import 'type-fest';
+import { InteractiveManager } from './interactive/index.js';
+import { a as PailBrowserImpl } from './packem_shared/pail.browser-By9KjOH7.js';
+import { SingleBarOptions, ProgressBar, MultiBarOptions, MultiProgressBar } from './progress-bar.js';
+export { ProgressBarOptions, ProgressBarPayload, ProgressBarStyle, getBarChar } from './progress-bar.js';
+import { SpinnerOptions, Spinner, MultiSpinner } from './spinner.js';
+export { SpinnerIcons, SpinnerStartOptions, SpinnerStyle } from './spinner.js';
+import { g as ServerConstructorOptions, C as ConstructorOptions, R as Reporter, a as DefaultLogTypes, b as LoggerFunction } from './packem_shared/types-D3ycu8-x.js';
+export { D as DefaultLoggerTypes, E as ExtendedRfc5424LogLevels, L as LoggerConfiguration, c as LoggerTypesAwareReporter, d as LoggerTypesConfig, P as Processor, S as StreamAwareReporter } from './packem_shared/types-D3ycu8-x.js';
 import './packem_shared/index.d-oxZvg_y7.js';
-
-type ProgressBarStyle = "shades_classic" | "shades_grey" | "rect" | "filled" | "solid" | "ascii" | "custom";
-interface ProgressBarOptions {
-    barCompleteChar?: string;
-    barGlue?: string;
-    barIncompleteChar?: string;
-    barsize?: number;
-    clear?: boolean;
-    current?: number;
-    etaBuffer?: number;
-    format?: string;
-    fps?: number;
-    hideCursor?: boolean;
-    lineWrap?: boolean;
-    position?: "left" | "right" | "center";
-    stream?: NodeJS.WriteStream;
-    style?: ProgressBarStyle;
-    total: number;
-    width?: number;
-}
-interface SingleBarOptions extends ProgressBarOptions {
-    format?: string;
-}
-interface MultiBarOptions {
-    barCompleteChar?: string;
-    barGlue?: string;
-    barIncompleteChar?: string;
-    clearOnComplete?: boolean;
-    format?: string;
-    fps?: number;
-    hideCursor?: boolean;
-    stream?: NodeJS.WriteStream;
-    style?: ProgressBarStyle;
-}
-interface ProgressBarPayload {
-    [key: string]: string | number | boolean;
-}
-declare const getBarChar: (char: string | undefined, style: ProgressBarStyle, complete?: boolean) => string;
-declare class ProgressBar {
-    private options;
-    private current;
-    private startTime;
-    private interactiveManager?;
-    private isActive;
-    private payload?;
-    constructor(options: ProgressBarOptions, interactiveManager?: InteractiveManager, payload?: ProgressBarPayload);
-    update(current: number, payload?: ProgressBarPayload): void;
-    increment(step?: number, payload?: ProgressBarPayload): void;
-    render(): string;
-    start(total?: number, startValue?: number, payload?: ProgressBarPayload): void;
-    stop(): void;
-    private calculateETA;
-}
-declare class MultiProgressBar {
-    private bars;
-    private options;
-    private interactiveManager?;
-    private isActive;
-    private nextBarId;
-    constructor(options?: MultiBarOptions, interactiveManager?: InteractiveManager);
-    create(total: number, startValue?: number, payload?: ProgressBarPayload): ProgressBar;
-    remove(bar: ProgressBar): boolean;
-    renderAll(): void;
-    stop(): void;
-}
+import 'type-fest';
+import '@visulima/colorize';
 
 declare class PailServerImpl<T extends string = string, L extends string = string> extends PailBrowserImpl<T, L> {
     #private;
@@ -79,6 +19,7 @@ declare class PailServerImpl<T extends string = string, L extends string = strin
     protected readonly interactive: boolean;
     constructor(options: ServerConstructorOptions<T, L>);
     scope<N extends string = T>(...name: string[]): PailServerType<N, L>;
+    child<N extends string = T, LC extends string = L>(options?: Partial<ConstructorOptions<N, LC>> & Partial<Pick<ServerConstructorOptions<N, LC>, "interactive" | "stderr" | "stdout">>): PailServerType<N, LC>;
     getInteractiveManager(): InteractiveManager | undefined;
     wrapStd(): void;
     restoreStd(): void;
@@ -86,13 +27,17 @@ declare class PailServerImpl<T extends string = string, L extends string = strin
     restoreAll(): void;
     createProgressBar(options: SingleBarOptions): ProgressBar;
     createMultiProgressBar(options?: MultiBarOptions): MultiProgressBar;
+    createSpinner(options?: SpinnerOptions): Spinner;
+    createMultiSpinner(options?: SpinnerOptions): MultiSpinner;
     clear(): void;
     protected extendReporter(reporter: Reporter<L>): Reporter<L>;
 }
-type PailServerType<T extends string = string, L extends string = string> = (new <TC extends string = string, LC extends string = string>(options?: ServerConstructorOptions<TC, LC>) => PailServerType<TC, LC>) & PailServerImpl<T, L> & Record<DefaultLogTypes, LoggerFunction> & Record<T, LoggerFunction>;
+type PailServerType<T extends string = string, L extends string = string> = Console & (new <TC extends string = string, LC extends string = string>(options?: ServerConstructorOptions<TC, LC>) => PailServerType<TC, LC>) & PailServerImpl<T, L> & Record<DefaultLogTypes, LoggerFunction> & Record<T, LoggerFunction> & {
+    force: Record<DefaultLogTypes, LoggerFunction> & Record<T, LoggerFunction>;
+};
 
-declare const createPail: <T extends string = string, L extends string = string>(options?: ConstructorOptions<T, L>) => PailServerType<T, L>;
+declare const createPail: <T extends string = string, L extends string = string>(options?: ServerConstructorOptions<T, L>) => PailServerType<T, L>;
 declare const pail: PailServerType<string, string>;
 
-export { ConstructorOptions, DefaultLogTypes, LoggerFunction, MultiProgressBar, ProgressBar, Reporter, createPail, getBarChar, pail };
-export type { MultiBarOptions, PailServerType as Pail, ProgressBarOptions, ProgressBarPayload, ProgressBarStyle, SingleBarOptions };
+export { ConstructorOptions, DefaultLogTypes, LoggerFunction, MultiBarOptions, MultiProgressBar, MultiSpinner, ProgressBar, Reporter, SingleBarOptions, Spinner, SpinnerOptions, createPail, pail };
+export type { PailServerType as Pail };

package/dist/index.server.js

@@ -1,5 +1,535 @@
-var j=Object.defineProperty;var o=(r,t)=>j(r,"name",{value:t,configurable:!0});import{createRequire as I}from"node:module";import{O as x,i as $,B as O,a as f}from"./packem_shared/format-label-DqvZRRR6.js";import{a as R}from"./packem_shared/pail.browser-BmHoDvEA.js";import{applyStyleToOptions as g,ProgressBar as A,MultiProgressBar as N}from"./packem_shared/getBarChar-mKDZW32R.js";import{getBarChar as bt}from"./packem_shared/getBarChar-mKDZW32R.js";import{E as D}from"./packem_shared/constants-DKfCaSUR.js";import{n as H}from"./packem_shared/write-stream-CD8XFv1L.js";import k from"./processor/message-formatter-processor.js";import{PrettyReporter as C}from"./packem_shared/PrettyReporter-APmxUrnh.js";const P=I(import.meta.url),l=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,E=o(r=>{if(typeof l<"u"&&l.versions&&l.versions.node){const[t,e]=l.versions.node.split(".").map(Number);if(t>22||t===22&&e>=3||t===20&&e>=16)return l.getBuiltinModule(r)}return P(r)},"__cjs_getBuiltinModule"),{stdout:y,stderr:_,env:d}=l,{StringDecoder:T}=E("node:string_decoder");var G=Object.defineProperty,V=o((r,t)=>G(r,"name",{value:t,configurable:!0}),"l");class q{static{o(this,"g")}static{V(this,"InteractiveManager")}#t;#e=!1;#r=!1;#s=0;#i=0;constructor(t,e){this.#t={stderr:e,stdout:t}}get lastLength(){return this.#s}get outside(){return this.#i}get isHooked(){return this.#e}get isSuspended(){return this.#r}erase(t,e=this.#s){if(this.#t[t]===void 0)throw new TypeError(`Stream "${t}" is not available`);this.#t[t].erase(e)}hook(){return this.#e||(Object.values(this.#t).forEach(t=>t.active()),this.#o(!0)),this.#e}resume(t,e){this.#r&&(this.#r=!1,e&&this.erase(t,e),this.#s=0,Object.values(this.#t).forEach(s=>s.active()))}suspend(t,e=!0){this.#r||(this.#r=!0,e&&this.erase(t),Object.values(this.#t).forEach(s=>s.renew()))}unhook(t=!0){return this.#e&&(Object.values(this.#t).forEach(e=>e.inactive(t)),this.#o()),!this.#e}update(t,e,s=0){if(e.length>0){if(this.#t[t]===void 0)throw new TypeError(`Stream "${t}" is not available`);const a=this.#t[t],{columns:p,rows:i}=x(),h=s>i?i-1:Math.max(0,Math.min(i-1,s)),c=this.lastLength-h,u=Math.max(c-i,this.outside);let n=e.reduce((L,M)=>[...L,$(M,{trim:!1,width:p,wrapMode:O.STRICT_WIDTH})],[]);i<=c?(a.erase(i),h<u&&(n=n.slice(u-h+1))):c&&a.erase(c),a.write(`${n.join(`
-`)}
-`),this.#s=u?u+n.length+1:n.length,this.#i=Math.max(this.lastLength-i,this.outside)}}#o(t=!1){this.#e=t,this.#s=0,this.#i=0}}var Y=Object.defineProperty,b=o((r,t)=>Y(r,"name",{value:t,configurable:!0}),"t$2");const v="\x1B[2J",J="\x1B[2K",U=b((r=1)=>`${"\x1B["+r}A`,"cursorUp"),w=process.platform==="win32"?`${v}\x1B[0f`:`${v}\x1B[3J\x1B[H`,K="\x1B[?25l",W="\x1B[?25h",z=b(r=>{let t="";for(let e=0;e<r;e++)t+=J+(e<r-1?U():"");return r&&(t+="\x1B[G"),t},"eraseLines");var F=Object.defineProperty,Q=o((r,t)=>F(r,"name",{value:t,configurable:!0}),"s$1");let m=class S{static{o(this,"t")}static{Q(this,"InteractiveStreamHook")}static DRAIN=!0;#t=new T;#e=[];#r;#s;constructor(t){this.#r=t.write,this.#s=t}active(){this.write(K),this.#s.write=(t,...e)=>{const s=e.at(-1);return this.#e.push(this.#t.write(typeof t=="string"?Buffer.from(t,typeof e[0]=="string"?e[0]:void 0):Buffer.from(t))),typeof s=="function"&&s(),S.DRAIN}}erase(t){t>0&&this.write(z(t+1))}inactive(t=!1){this.#e.length>0&&(t&&this.write(`
-`),this.#e.forEach(e=>{this.write(e)}),this.#e=[]),this.renew()}renew(){this.#s.write=this.#r,this.write(W)}write(t){this.#r.apply(this.#s,[t])}};var X=Object.defineProperty,Z=o((r,t)=>X(r,"name",{value:t,configurable:!0}),"c");class tt{static{o(this,"v")}static{Z(this,"RawReporter")}#t;#e;#r;#s=!1;#i;constructor(t={}){this.#t=y,this.#e=_,this.#i=t}setStdout(t){this.#t=t}setStderr(t){this.#e=t}setInteractiveManager(t){this.#r=t}setIsInteractive(t){this.#s=t}log(t){const{context:e,groups:s,message:a,type:p}=t,i=[];if(a!==D){const n=typeof a=="string"?a:f(a,this.#i);i.push(n)}e&&i.push(...e.map(n=>typeof n=="object"?` ${f(n,this.#i)}`:` ${n}`));const h=["error","trace","warn"].includes(p.level)?"stderr":"stdout",c=h==="stderr"?this.#e:this.#t,u=s.map(()=>"    ").join("");this.#s&&this.#r!==void 0&&c.isTTY?this.#r.update(h,(u+i.join("")).split(`
-`),0):H(u+i.join(""),c)}}var et=Object.defineProperty,rt=o((r,t)=>et(r,"name",{value:t,configurable:!0}),"o");let st=class extends R{static{o(this,"L")}constructor(t){const{interactive:e,rawReporter:s,reporters:a,stderr:p,stdout:i,...h}=t;super(h),this.options=t,this.interactive=e??!1,this.stdout=i,this.stderr=p,this.interactive&&(this.interactiveManager=new q(new m(this.stdout),new m(this.stderr))),Array.isArray(a)&&this.registerReporters(a),this.rawReporter=this.extendReporter(t.rawReporter??new tt)}static{rt(this,"PailServerImpl")}stdout;stderr;interactiveManager;interactive;scope(...t){if(t.length===0)throw new Error("No scope name was defined.");return this.scopeName=t.flat(),this}getInteractiveManager(){return this.interactiveManager}wrapStd(){this.#t(this.stdout,"log"),this.#t(this.stderr,"log")}restoreStd(){this.#e(this.stdout),this.#e(this.stderr)}wrapAll(){this.wrapConsole(),this.wrapStd()}restoreAll(){this.restoreConsole(),this.restoreStd()}createProgressBar(t){const e=g(t);return new A(e,this.interactiveManager)}createMultiProgressBar(t={}){const e=g(t);return new N(e,this.interactiveManager)}clear(){this.stdout.write(w),this.stderr.write(w)}extendReporter(t){return typeof t.setStdout=="function"&&t.setStdout(this.stdout),typeof t.setStderr=="function"&&t.setStderr(this.stderr),typeof t.setLoggerTypes=="function"&&t.setLoggerTypes(this.types),typeof t.setStringify=="function"&&t.setStringify(this.stringify),typeof t.setIsInteractive=="function"&&t.setIsInteractive(this.interactive),this.interactive&&typeof t.setInteractiveManager=="function"&&t.setInteractiveManager(this.interactiveManager),t}#t(t,e){t&&(t.__write||(t.__write=t.write),t.write=s=>{this[e](String(s).trim())})}#e(t){t&&t.__write&&(t.write=t.__write,delete t.__write)}};const it=st;var ot=Object.defineProperty,B=o((r,t)=>ot(r,"name",{value:t,configurable:!0}),"t");const at=B(()=>d.NODE_ENV==="debug"||d.DEBUG!==void 0?"debug":d.NODE_ENV==="test"?"warning":"informational","getDefaultLogLevel"),nt=B(r=>{let t=at();return d.PAIL_LOG_LEVEL!==void 0&&(t=d.PAIL_LOG_LEVEL),new it({logLevel:t,processors:[new k],reporters:[new C],stderr:_,stdout:y,...r})},"createPail"),mt=nt();export{N as MultiProgressBar,A as ProgressBar,nt as createPail,bt as getBarChar,mt as pail};
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const {
+  stdout,
+  stderr,
+  env
+} = __cjs_getProcess;
+import InteractiveManager from './packem_shared/InteractiveManager-CZ85hGNW.js';
+import { I as InteractiveStreamHook, c as clearTerminal } from './packem_shared/interactive-stream-hook-DG4BtN12.js';
+import { a as PailBrowserImpl, m as mergeTypes, b as arrayify } from './packem_shared/pail.browser-CPDOE_d1.js';
+import { ProgressBar, applyStyleToOptions, MultiProgressBar } from './progress-bar.js';
+export { getBarChar } from './progress-bar.js';
+import { i as inspect } from './packem_shared/format-label-Btft2KGP.js';
+import { E as EMPTY_SYMBOL } from './packem_shared/constants-DfDr4MHC.js';
+import { w as writeStream } from './packem_shared/write-stream-BG8fhcs3.js';
+import { Spinner, MultiSpinner } from './spinner.js';
+import { g as getLongestLabel } from './packem_shared/get-longest-label-C9PWeyKq.js';
+import MessageFormatterProcessor from './processor/message-formatter-processor.js';
+import { PrettyReporter } from './packem_shared/PrettyReporter-BFWaYP_J.js';
+
+class RawReporter {
+  #stdout;
+  #stderr;
+  #interactiveManager;
+  #interactive = false;
+  #inspectOptions;
+  constructor(inspectOptions = {}) {
+    this.#stdout = stdout;
+    this.#stderr = stderr;
+    this.#inspectOptions = inspectOptions;
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  setStdout(stdout_) {
+    this.#stdout = stdout_;
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  setStderr(stderr_) {
+    this.#stderr = stderr_;
+  }
+  setInteractiveManager(manager) {
+    this.#interactiveManager = manager;
+  }
+  setIsInteractive(interactive) {
+    this.#interactive = interactive;
+  }
+  log(meta) {
+    const { context, groups, message, type } = meta;
+    const items = [];
+    if (message !== EMPTY_SYMBOL) {
+      const formattedMessage = typeof message === "string" ? message : inspect(message, this.#inspectOptions);
+      items.push(formattedMessage);
+    }
+    if (context) {
+      items.push(
+        ...context.map((value) => {
+          if (typeof value === "object") {
+            return ` ${inspect(value, this.#inspectOptions)}`;
+          }
+          return ` ${value}`;
+        })
+      );
+    }
+    const streamType = ["error", "trace", "warn"].includes(type.level) ? "stderr" : "stdout";
+    const stream = streamType === "stderr" ? this.#stderr : this.#stdout;
+    const groupSpaces = groups.map(() => "    ").join("");
+    if (this.#interactive && this.#interactiveManager !== void 0 && stream.isTTY) {
+      this.#interactiveManager.update(streamType, (groupSpaces + items.join("")).split("\n"), 0);
+    } else {
+      writeStream(groupSpaces + items.join(""), stream);
+    }
+  }
+}
+
+class PailServerImpl extends PailBrowserImpl {
+  /**
+   * Creates a new Pail server logger instance.
+   *
+   * Initializes the server-compatible logger with streams, interactive support,
+   * and server-specific configuration options.
+   * @param options Server-specific configuration options
+   */
+  constructor(options) {
+    const parentStderr = options.parentStderr;
+    const parentStdout = options.parentStdout;
+    const { interactive, processors, rawReporter, reporters, stderr: optionsStderr, stdout: optionsStdout } = options;
+    const stderr = parentStderr ?? optionsStderr;
+    const stdout = parentStdout ?? optionsStdout;
+    const parentLongestLabel = options.parentLongestLabel;
+    const parentTypes = options.parentTypes;
+    const { parentLogLevels, parentMessages, parentStringify } = options;
+    const parentOptions = {
+      disabled: options.disabled,
+      logLevel: options.logLevel,
+      logLevels: options.logLevels,
+      messages: options.messages,
+      processors: [],
+      rawReporter: options.rawReporter,
+      reporters: [],
+      scope: options.scope,
+      throttle: options.throttle,
+      throttleMin: options.throttleMin
+    };
+    const hasTypesProperty = "types" in options;
+    if (parentTypes && parentLongestLabel && !hasTypesProperty) {
+      parentOptions.parentTypes = parentTypes;
+      parentOptions.parentLongestLabel = parentLongestLabel;
+    } else if (hasTypesProperty && options.types !== void 0) {
+      parentOptions.types = options.types;
+    }
+    if (parentStringify) {
+      parentOptions.parentStringify = parentStringify;
+    }
+    if (parentLogLevels && !options.logLevels) {
+      parentOptions.parentLogLevels = parentLogLevels;
+    }
+    if (parentMessages && !options.messages) {
+      parentOptions.parentMessages = parentMessages;
+    }
+    super(parentOptions);
+    this.options = options;
+    this.interactive = interactive ?? false;
+    this.stdout = stdout;
+    this.stderr = stderr;
+    if (this.interactive) {
+      this.interactiveManager = new InteractiveManager(new InteractiveStreamHook(this.stdout), new InteractiveStreamHook(this.stderr));
+    }
+    if (Array.isArray(reporters)) {
+      this.registerReporters(reporters);
+    }
+    this.rawReporter = this.extendReporter(rawReporter ?? new RawReporter());
+    if (Array.isArray(processors)) {
+      this.registerProcessors(processors);
+    }
+  }
+  stdout;
+  stderr;
+  interactiveManager;
+  interactive;
+  // @ts-expect-error - this returns a different type
+  scope(...name) {
+    if (name.length === 0) {
+      throw new Error("No scope name was defined.");
+    }
+    this.scopeName = name.flat();
+    return this;
+  }
+  /**
+   * Creates a child logger that inherits settings from the parent.
+   *
+   * Returns a new logger instance that inherits all configuration from the parent
+   * (reporters, processors, types, log levels, throttle settings, etc.) while allowing
+   * you to override only what you need. Child loggers are independent instances with
+   * their own state (timers, counters, etc.).
+   * @template N - The new custom logger type names
+   * @template LC - The new log level types
+   * @param options Configuration options to override or extend parent settings
+   * @returns A new child logger instance
+   * @example
+   * ```typescript
+   * const parent = createPail({
+   *   logLevel: "info",
+   *   types: { http: { label: "HTTP", logLevel: "info" } },
+   *   reporters: [new PrettyReporter()],
+   * });
+   *
+   * // Child inherits parent settings but overrides log level
+   * const child = parent.child({ logLevel: "debug" });
+   * child.info("This will be logged"); // Uses debug level from child
+   * child.http("GET /api 200"); // Inherits http type from parent
+   *
+   * // Child can add new types
+   * const childWithNewType = parent.child({
+   *   types: { db: { label: "DB", logLevel: "info" } },
+   * });
+   * childWithNewType.db("Query executed"); // New type available
+   * ```
+   */
+  // @ts-expect-error - override signature differs due to server-specific options
+  child(options) {
+    const typesChanged = options?.types !== void 0 && options.types !== null;
+    const mergedTypes = typesChanged ? mergeTypes(this.types, options.types) : this.types;
+    const childReporters = options?.reporters ?? [];
+    const allReporters = childReporters.length > 0 ? [...this.reporters, ...childReporters] : [...this.reporters];
+    const childProcessors = options?.processors ?? [];
+    const allProcessors = childProcessors.length > 0 ? [...this.processors, ...childProcessors] : [...this.processors];
+    const mergedLogLevels = options?.logLevels ? { ...this.logLevels, ...options.logLevels } : this.logLevels;
+    let mergedScope;
+    if (options?.scope) {
+      const childScope = arrayify(options.scope).filter(Boolean);
+      mergedScope = this.scopeName.length > 0 ? [...this.scopeName, ...childScope] : childScope;
+    } else {
+      mergedScope = this.scopeName.length > 0 ? this.scopeName : [];
+    }
+    const mergedMessages = options?.messages ? {
+      timerEnd: this.endTimerMessage,
+      timerStart: this.startTimerMessage,
+      ...options.messages
+    } : {
+      timerEnd: this.endTimerMessage,
+      timerStart: this.startTimerMessage
+    };
+    const childOptions = {
+      disabled: options?.disabled ?? this.disabled,
+      interactive: options?.interactive ?? this.interactive,
+      logLevel: options?.logLevel ?? this.generalLogLevel,
+      logLevels: mergedLogLevels,
+      messages: mergedMessages,
+      processors: allProcessors,
+      rawReporter: options?.rawReporter ?? this.rawReporter,
+      reporters: allReporters,
+      scope: mergedScope,
+      stderr: options?.stderr ?? this.stderr,
+      stdout: options?.stdout ?? this.stdout,
+      throttle: options?.throttle ?? this.throttle,
+      throttleMin: options?.throttleMin ?? this.throttleMin
+    };
+    this.#assignParentValues(childOptions, options, typesChanged, mergedTypes);
+    return new PailServerImpl(childOptions);
+  }
+  /**
+   * Assigns parent values to child options for optimization.
+   *
+   * Reuses parent values when they haven't changed to avoid unnecessary recalculations.
+   */
+  /* eslint-disable no-param-reassign */
+  #assignParentValues(childOptions, options, typesChanged, mergedTypes) {
+    if (typesChanged) {
+      childOptions.parentTypes = mergedTypes;
+      childOptions.parentLongestLabel = getLongestLabel(mergedTypes);
+    } else {
+      childOptions.parentTypes = this.types;
+      childOptions.parentLongestLabel = this.longestLabel;
+    }
+    if (!options?.logLevels) {
+      childOptions.parentLogLevels = this.logLevels;
+    }
+    if (!options?.messages) {
+      childOptions.parentMessages = {
+        timerEnd: this.endTimerMessage,
+        timerStart: this.startTimerMessage
+      };
+    }
+    childOptions.parentStringify = this.stringify;
+    if (!options?.stdout) {
+      childOptions.parentStdout = this.stdout;
+    }
+    if (!options?.stderr) {
+      childOptions.parentStderr = this.stderr;
+    }
+  }
+  /* eslint-enable no-param-reassign */
+  /**
+   * Gets the interactive manager instance if interactive mode is enabled.
+   *
+   * Returns the InteractiveManager instance that handles interactive terminal
+   * features like progress bars and dynamic updates. Only available when
+   * interactive mode is enabled in the constructor options.
+   * @returns The interactive manager instance, or undefined if not in interactive mode
+   * @example
+   * ```typescript
+   * const logger = createPail({ interactive: true });
+   * const manager = logger.getInteractiveManager();
+   * if (manager) {
+   *   manager.hook();
+   *   // Use interactive features
+   *   manager.unhook();
+   * }
+   * ```
+   */
+  getInteractiveManager() {
+    return this.interactiveManager;
+  }
+  /**
+   * Wraps stdout and stderr streams to redirect them through the logger.
+   *
+   * Intercepts writes to process.stdout and process.stderr, redirecting them
+   * through the logger instead of writing directly to the streams. This allows
+   * all output to be processed by the logging pipeline.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.wrapStd();
+   *
+   * console.log("This goes through logger");
+   * process.stdout.write("This too");
+   *
+   * logger.restoreStd(); // Restore original streams
+   * ```
+   */
+  wrapStd() {
+    this.#wrapStream(this.stdout, "log");
+    this.#wrapStream(this.stderr, "log");
+  }
+  /**
+   * Restores the original stdout and stderr streams.
+   *
+   * Removes the stream wrapping that was applied by wrapStd(),
+   * restoring the original stream write methods.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.wrapStd();
+   * // Streams are wrapped
+   * logger.restoreStd();
+   * // Streams are restored to original behavior
+   * ```
+   */
+  restoreStd() {
+    this.#restoreStream(this.stdout);
+    this.#restoreStream(this.stderr);
+  }
+  /**
+   * Wraps all output sources (console and streams).
+   *
+   * Convenience method that calls both wrapConsole() and wrapStd()
+   * to redirect all output through the logger.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.wrapAll(); // Wraps console and streams
+   *
+   * // All output now goes through logger
+   * console.log("Console output");
+   * process.stdout.write("Stream output");
+   *
+   * logger.restoreAll(); // Restore everything
+   * ```
+   */
+  wrapAll() {
+    this.wrapConsole();
+    this.wrapStd();
+  }
+  /**
+   * Restores all wrapped output sources.
+   *
+   * Convenience method that calls both restoreConsole() and restoreStd()
+   * to restore all original output behavior.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.wrapAll();
+   * // All output is wrapped
+   * logger.restoreAll();
+   * // All output sources are restored
+   * ```
+   */
+  restoreAll() {
+    this.restoreConsole();
+    this.restoreStd();
+  }
+  /**
+   * Creates a single progress bar.
+   * @param options Configuration options for the progress bar
+   * @returns A new ProgressBar instance
+   * @example
+   * ```typescript
+   * const logger = createPail({ interactive: true });
+   * const bar = logger.createProgressBar({
+   *   total: 100,
+   *   format: 'Downloading [{bar}] {percentage}% | ETA: {eta}s | {value}/{total}'
+   * });
+   *
+   * bar.start();
+   * // ... do work and update progress
+   * bar.update(50);
+   * bar.stop();
+   * ```
+   */
+  createProgressBar(options) {
+    if (!this.interactiveManager) {
+      throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use progress bars.");
+    }
+    const styledOptions = applyStyleToOptions(options);
+    return new ProgressBar(styledOptions, this.interactiveManager);
+  }
+  /**
+   * Creates a multi-bar progress manager for displaying multiple progress bars.
+   * @param options Configuration options for the multi-bar manager
+   * @returns A new MultiProgressBar instance
+   * @example
+   * ```typescript
+   * const logger = createPail({ interactive: true });
+   * const multiBar = logger.createMultiProgressBar();
+   *
+   * const bar1 = multiBar.create(100);
+   * const bar2 = multiBar.create(200);
+   *
+   * bar1.start();
+   * bar2.start();
+   * // ... update bars as needed
+   * multiBar.stop();
+   * ```
+   */
+  createMultiProgressBar(options = {}) {
+    if (!this.interactiveManager) {
+      throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use progress bars.");
+    }
+    const styledOptions = applyStyleToOptions(options);
+    return new MultiProgressBar(styledOptions, this.interactiveManager);
+  }
+  /**
+   * Creates a single spinner.
+   * @param options Configuration options for the spinner
+   * @returns A new Spinner instance
+   * @example
+   * ```typescript
+   * const logger = createPail({ interactive: true });
+   * const spinner = logger.createSpinner({ name: 'dots' });
+   * spinner.start('Loading...');
+   * // ... do work
+   * spinner.succeed('Done');
+   * ```
+   */
+  createSpinner(options = {}) {
+    if (!this.interactiveManager) {
+      throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use spinners.");
+    }
+    return new Spinner(options, this.interactiveManager);
+  }
+  /**
+   * Creates a multi-spinner manager for displaying multiple spinners.
+   * @param options Configuration options for the multi-spinner manager
+   * @returns A new MultiSpinner instance
+   * @example
+   * ```typescript
+   * const logger = createPail({ interactive: true });
+   * const multiSpinner = logger.createMultiSpinner();
+   *
+   * const spinner1 = multiSpinner.create('Loading 1');
+   * const spinner2 = multiSpinner.create('Loading 2');
+   *
+   * spinner1.start();
+   * spinner2.start();
+   * // ... update spinners as needed
+   * multiSpinner.stop();
+   * ```
+   */
+  createMultiSpinner(options = {}) {
+    if (!this.interactiveManager) {
+      throw new Error("Interactive mode is not enabled. Create Pail with { interactive: true } to use spinners.");
+    }
+    return new MultiSpinner(options, this.interactiveManager);
+  }
+  /**
+   * Clears the terminal screen.
+   *
+   * Sends ANSI escape sequences to clear the terminal screen and move
+   * the cursor to the top-left position. This overrides the browser
+   * implementation to work with terminal streams.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.info("Some output");
+   * logger.clear(); // Clears the terminal screen
+   * ```
+   */
+  clear() {
+    this.stdout.write(clearTerminal);
+    this.stderr.write(clearTerminal);
+  }
+  extendReporter(reporter) {
+    if (typeof reporter.setStdout === "function") {
+      reporter.setStdout(this.stdout);
+    }
+    if (typeof reporter.setStderr === "function") {
+      reporter.setStderr(this.stderr);
+    }
+    if (typeof reporter.setLoggerTypes === "function") {
+      reporter.setLoggerTypes(this.types);
+    }
+    if (typeof reporter.setStringify === "function") {
+      reporter.setStringify(this.stringify);
+    }
+    if (typeof reporter.setIsInteractive === "function") {
+      reporter.setIsInteractive(this.interactive);
+    }
+    if (this.interactive && typeof reporter.setInteractiveManager === "function") {
+      reporter.setInteractiveManager(this.interactiveManager);
+    }
+    return reporter;
+  }
+  #wrapStream(stream, type) {
+    if (!stream) {
+      return;
+    }
+    if (!stream.__write) {
+      stream.__write = stream.write;
+    }
+    stream.write = (data) => {
+      this[type](String(data).trim());
+    };
+  }
+  // eslint-disable-next-line class-methods-use-this
+  #restoreStream(stream) {
+    if (!stream) {
+      return;
+    }
+    if (stream.__write) {
+      stream.write = stream.__write;
+      delete stream.__write;
+    }
+  }
+}
+const PailServer = PailServerImpl;
+
+const getDefaultLogLevel = () => {
+  if (env.NODE_ENV === "debug" || env.DEBUG !== void 0) {
+    return "debug";
+  }
+  if (env.NODE_ENV === "test") {
+    return "warning";
+  }
+  return "informational";
+};
+const createPail = (options) => {
+  let logLevel = getDefaultLogLevel();
+  if (env.PAIL_LOG_LEVEL !== void 0) {
+    logLevel = env.PAIL_LOG_LEVEL;
+  }
+  return new PailServer({
+    logLevel,
+    processors: [new MessageFormatterProcessor()],
+    reporters: [new PrettyReporter()],
+    stderr,
+    stdout,
+    ...options
+  });
+};
+const pail = createPail();
+
+export { MultiProgressBar, MultiSpinner, ProgressBar, Spinner, createPail, pail };