@visulima/pail 3.2.0 → 3.2.2

package/CHANGELOG.md

@@ -1,3 +1,44 @@
+## @visulima/pail [3.2.2](https://github.com/visulima/visulima/compare/@visulima/pail@3.2.1...@visulima/pail@3.2.2) (2025-11-13)
+
+### Bug Fixes
+
+* bump packem, to fix minified version of the code ([2a36ceb](https://github.com/visulima/visulima/commit/2a36ceb09251b0ca1178701a26547a871ed717a7))
+
+
+### Dependencies
+
+* **@visulima/colorize:** upgraded to 1.4.29
+* **@visulima/error:** upgraded to 5.0.6
+* **@visulima/fmt:** upgraded to 1.1.21
+* **@visulima/inspector:** upgraded to 1.0.30
+* **@visulima/redact:** upgraded to 2.0.5
+* **@visulima/string:** upgraded to 2.0.6
+
+## @visulima/pail [3.2.1](https://github.com/visulima/visulima/compare/@visulima/pail@3.2.0...@visulima/pail@3.2.1) (2025-11-12)
+
+### Bug Fixes
+
+* **deps:** update type-fest dependency across multiple packages ([93e13be](https://github.com/visulima/visulima/commit/93e13be5248207968a96303710db2a0604d16b9b))
+* update package configurations and TypeScript definitions ([b59aa59](https://github.com/visulima/visulima/commit/b59aa59dac1508216b944f4b917fb4a7ab1f70a4))
+
+### Miscellaneous Chores
+
+* Add jsr file to all packages for release ([#565](https://github.com/visulima/visulima/issues/565)) ([ec91652](https://github.com/visulima/visulima/commit/ec91652b4e4112adf14ba152c1239a7703ba425a))
+* **pail:** add rslog logging to benchmarks ([c5675c8](https://github.com/visulima/visulima/commit/c5675c880a81a979a713771d6c82f6d2682daaaa))
+* **pail:** integrate roarr logging into benchmarks ([563bb52](https://github.com/visulima/visulima/commit/563bb52b7311ad9a3bfc4de6a2ff0593b2cfcc44))
+* **pail:** update benchmark results and add rslog performance metrics ([123e2b5](https://github.com/visulima/visulima/commit/123e2b533dc3a75e6bab45055a4055897824630b))
+* update license files and clean up TypeScript definitions ([fe668cc](https://github.com/visulima/visulima/commit/fe668cc26de23591d4df54a0954455ebbe31b22d))
+
+
+### Dependencies
+
+* **@visulima/colorize:** upgraded to 1.4.28
+* **@visulima/error:** upgraded to 5.0.5
+* **@visulima/fmt:** upgraded to 1.1.20
+* **@visulima/inspector:** upgraded to 1.0.29
+* **@visulima/redact:** upgraded to 2.0.4
+* **@visulima/string:** upgraded to 2.0.5
+
 ## @visulima/pail [3.2.0](https://github.com/visulima/visulima/compare/@visulima/pail@3.1.0...@visulima/pail@3.2.0) (2025-11-07)
 
 ### Features

package/LICENSE.md

@@ -623,11 +623,14 @@ Repository: sindresorhus/terminal-size
 <!-- TYPE_DEPENDENCIES -->
 
 # Licenses of bundled types
+
 The published @visulima/pail artifact additionally contains code with the following licenses:
 MIT
 
 # Bundled types:
+
 ## safe-stable-stringify
+
 License: MIT
 By: Ruben Bridgewater
 Repository: git+https://github.com/BridgeAR/safe-stable-stringify.git

package/dist/constants.d.ts

@@ -0,0 +1,37 @@
+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/index.browser.d.ts

@@ -1,12 +1,47 @@
-import { P as PailBrowserType } from './packem_shared/pail.browser-By9KjOH7.js';
-import { C as ConstructorOptions } from './packem_shared/types-D3ycu8-x.js';
-export { a as DefaultLogTypes, D as DefaultLoggerTypes, E as ExtendedRfc5424LogLevels, L as LoggerConfiguration, b as LoggerFunction, c as LoggerTypesAwareReporter, d as LoggerTypesConfig, P as Processor, R as Reporter, S as StreamAwareReporter } from './packem_shared/types-D3ycu8-x.js';
-import './packem_shared/index.d-oxZvg_y7.js';
-import 'type-fest';
-import '@visulima/colorize';
-import './interactive/index.js';
-
-declare const createPail: <T extends string = string, L extends string = string>(options?: ConstructorOptions<T, L>) => PailBrowserType<T, L>;
-declare const pail: PailBrowserType<string, string>;
-
-export { ConstructorOptions, PailBrowserType as Pail, createPail, pail };
+import type { PailBrowserType } from "./pail.d.ts";
+import type { ConstructorOptions } from "./types.d.ts";
+/**
+ * Creates a new Pail logger instance configured for browser environments.
+ *
+ * This factory function creates a browser-compatible logger with default processors
+ * and reporters suitable for client-side logging.
+ * @template T - Custom logger types
+ * @template L - Log level types
+ * @param options Configuration options for the logger
+ * @returns A new PailBrowser instance
+ * @example
+ * ```typescript
+ * import { createPail } from "@visulima/pail";
+ *
+ * const logger = createPail({
+ *   logLevel: "debug",
+ *   types: {
+ *     custom: {
+ *       color: "blue",
+ *       label: "CUSTOM",
+ *       logLevel: "info"
+ *     }
+ *   }
+ * });
+ *
+ * logger.info("Hello world!");
+ * logger.custom("Custom message");
+ * ```
+ */
+export declare const createPail: <T extends string = string, L extends string = string>(options?: ConstructorOptions<T, L>) => PailBrowserType<T, L>;
+/**
+ * Default Pail logger instance for browser environments.
+ *
+ * A pre-configured logger instance ready for immediate use in browser environments.
+ * Uses default configuration with JSON reporter and message formatter processor.
+ * @example
+ * ```typescript
+ * import { pail } from "@visulima/pail";
+ *
+ * pail.info("Application started");
+ * pail.error("Something went wrong", new Error("Test error"));
+ * ```
+ */
+export declare const pail: PailBrowserType<string, string>;
+export type { PailBrowserType as Pail } from "./pail.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,4 +1,4 @@
-import { P as PailBrowser } from './packem_shared/pail.browser-CPDOE_d1.js';
+import { P as PailBrowser } from './packem_shared/pail.browser-CPjQrsyy.js';
 import MessageFormatterProcessor from './processor/message-formatter-processor.js';
 import JsonReporter from './packem_shared/JsonReporter-DcM2LBX9.js';
 

package/dist/index.server.d.ts

@@ -1,43 +1,65 @@
-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';
-import 'type-fest';
-import '@visulima/colorize';
-
-declare class PailServerImpl<T extends string = string, L extends string = string> extends PailBrowserImpl<T, L> {
-    #private;
-    readonly options: ServerConstructorOptions<T, L>;
-    protected readonly stdout: NodeJS.WriteStream;
-    protected readonly stderr: NodeJS.WriteStream;
-    protected interactiveManager: InteractiveManager | undefined;
-    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;
-    wrapAll(): void;
-    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> = 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?: ServerConstructorOptions<T, L>) => PailServerType<T, L>;
-declare const pail: PailServerType<string, string>;
-
-export { ConstructorOptions, DefaultLogTypes, LoggerFunction, MultiBarOptions, MultiProgressBar, MultiSpinner, ProgressBar, Reporter, SingleBarOptions, Spinner, SpinnerOptions, createPail, pail };
-export type { PailServerType as Pail };
+import type { PailServerType } from "./pail.d.ts";
+import type { ServerConstructorOptions } from "./types.d.ts";
+/**
+ * Creates a new Pail logger instance configured for server environments.
+ *
+ * This factory function creates a server-compatible logger with default processors
+ * and reporters suitable for Node.js environments. It automatically configures
+ * log levels based on environment variables and sets up pretty printing.
+ * @template T - Custom logger types
+ * @template L - Log level types
+ * @param options Configuration options for the logger
+ * @returns A new PailServer instance
+ * @example
+ * ```typescript
+ * import { createPail } from "@visulima/pail";
+ *
+ * const logger = createPail({
+ *   logLevel: "debug",
+ *   types: {
+ *     http: {
+ *       color: "blue",
+ *       label: "HTTP",
+ *       logLevel: "info"
+ *     }
+ *   }
+ * });
+ *
+ * logger.info("Server started on port 3000");
+ * logger.http("GET /api/users 200");
+ * ```
+ * @example
+ * ```bash
+ * # Control log level via environment variable
+ * PAIL_LOG_LEVEL=debug node app.js
+ * ```
+ */
+export declare const createPail: <T extends string = string, L extends string = string>(options?: ServerConstructorOptions<T, L>) => PailServerType<T, L>;
+/**
+ * Default Pail logger instance for server environments.
+ *
+ * A pre-configured logger instance ready for immediate use in Node.js environments.
+ * Uses default configuration with pretty reporter, message formatter processor,
+ * and automatic log level detection based on environment variables.
+ * @example
+ * ```typescript
+ * import { pail } from "@visulima/pail";
+ *
+ * pail.info("Server listening on port 3000");
+ * pail.error("Database connection failed", error);
+ * pail.success("Migration completed successfully");
+ * ```
+ * @example
+ * ```bash
+ * # Set log level via environment
+ * NODE_ENV=production node app.js
+ * PAIL_LOG_LEVEL=debug node app.js
+ * ```
+ */
+export declare const pail: PailServerType<string, string>;
+export type { PailServerType as Pail } from "./pail.d.ts";
+export type { MultiBarOptions, ProgressBarOptions, ProgressBarPayload, ProgressBarStyle, SingleBarOptions } from "./progress-bar.d.ts";
+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 { ConstructorOptions, DefaultLoggerTypes, DefaultLogTypes, ExtendedRfc5424LogLevels, LoggerConfiguration, LoggerFunction, LoggerTypesAwareReporter, LoggerTypesConfig, Processor, Reporter, StreamAwareReporter, } from "./types.d.ts";

package/dist/index.server.js

@@ -11,7 +11,7 @@ const {
 } = __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 { a as PailBrowserImpl, m as mergeTypes, b as arrayify } from './packem_shared/pail.browser-CPjQrsyy.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';
@@ -33,11 +33,9 @@ class RawReporter {
     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_;
   }

package/dist/interactive/index.d.ts

@@ -1,28 +1,2 @@
-declare class InteractiveStreamHook {
-    #private;
-    static readonly DRAIN = true;
-    constructor(stream: NodeJS.WriteStream);
-    active(): void;
-    erase(count: number): void;
-    inactive(separateHistory?: boolean): void;
-    renew(): void;
-    write(message: string): void;
-}
-
-type StreamType = "stderr" | "stdout";
-declare class InteractiveManager {
-    #private;
-    constructor(stdout: InteractiveStreamHook, stderr: InteractiveStreamHook);
-    get lastLength(): number;
-    get outside(): number;
-    get isHooked(): boolean;
-    get isSuspended(): boolean;
-    erase(stream: StreamType, count?: number): void;
-    hook(): boolean;
-    resume(stream: StreamType, eraseRowCount?: number): void;
-    suspend(stream: StreamType, erase?: boolean): void;
-    unhook(separateHistory?: boolean): boolean;
-    update(stream: StreamType, rows: string[], from?: number): void;
-}
-
-export { InteractiveManager, InteractiveStreamHook };
+export { default as InteractiveManager } from "./interactive-manager.d.ts";
+export { default as InteractiveStreamHook } from "./interactive-stream-hook.d.ts";

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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,68 @@
+/**
+ * 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/object-tree.d.ts

@@ -1,17 +1,75 @@
-type TreeRenderFunction = (node: unknown) => string | undefined;
-type TreeSortFunction = (a: string, b: string) => number;
-interface ObjectTreeOptions {
+/**
+ * Function to render a node value for display
+ * @param node The node to render
+ * @returns A string representation or undefined if should not render
+ */
+export type TreeRenderFunction = (node: unknown) => string | undefined;
+/**
+ * Function to sort keys during tree traversal
+ * @param a First key for comparison
+ * @param b Second key for comparison
+ * @returns Negative if a < b, positive if a > b, 0 if equal
+ */
+export type TreeSortFunction = (a: string, b: string) => number;
+/**
+ * Configuration options for object tree rendering
+ */
+export interface ObjectTreeOptions {
+    /** Text to display for circular references (default: " (circular ref.)") */
     breakCircularWith?: string | null | undefined;
+    /** Whether to return as single string or array of lines (default: true) */
     joined?: boolean;
+    /** Connector for neighbor keys (default: "├─ ") */
     keyNeighbour?: string;
+    /** Connector for non-neighbor keys (default: "└─ ") */
     keyNoNeighbour?: string;
+    /** Function to render node values (default: renders primitives) */
     renderFn?: TreeRenderFunction;
+    /** Separator between key and value (default: ": ") */
     separator?: string;
+    /** Function to sort object keys (default: natural order) */
     sortFn?: TreeSortFunction | undefined;
+    /** Spacer for neighbor branches (default: "│  ") */
     spacerNeighbour?: string;
+    /** Spacer for non-neighbor branches (default: "   ") */
     spacerNoNeighbour?: string;
 }
-declare const renderObjectTree: (tree: Record<string, unknown> | unknown[], options?: ObjectTreeOptions) => string | string[];
-
-export { renderObjectTree as default, renderObjectTree };
-export type { ObjectTreeOptions, TreeRenderFunction, TreeSortFunction };
+/**
+ * Renders an object as an ASCII tree structure.
+ * @param tree The object to render as a tree
+ * @param options Configuration options for tree rendering
+ * @returns Formatted tree as string or array of lines
+ * @example
+ * ```typescript
+ * const obj = {
+ *   name: "John",
+ *   age: 30,
+ *   address: {
+ *     street: "Main St",
+ *     city: "New York"
+ *   }
+ * };
+ *
+ * // Default output as string
+ * console.log(renderObjectTree(obj));
+ *
+ * // Custom rendering
+ * console.log(renderObjectTree(obj, {
+ *   sortFn: (a, b) => a.localeCompare(b),
+ *   renderFn: (node) => {
+ *     if (typeof node === 'string') return node.toUpperCase();
+ *     return ['boolean', 'string', 'number'].includes(typeof node)
+ *       ? String(node)
+ *       : undefined;
+ *   }
+ * }));
+ *
+ * // Get as array of lines
+ * const lines = renderObjectTree(obj, { joined: false });
+ * ```
+ */
+export declare const renderObjectTree: (tree: Record<string, unknown> | unknown[], options?: ObjectTreeOptions) => string | string[];
+/**
+ * Default export for CommonJS compatibility
+ */
+export default renderObjectTree;

package/dist/packem_shared/{JsonReporter-BqWsVkHP.js → JsonReporter-C0AXk99i.js}

@@ -29,7 +29,6 @@ class JsonReporter extends AbstractJsonReporter {
    * Sets the stdout stream for the reporter.
    * @param stdout_ The writable stream to use for stdout output
    */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   setStdout(stdout_) {
     this.#stdout = stdout_;
   }
@@ -37,7 +36,6 @@ class JsonReporter extends AbstractJsonReporter {
    * Sets the stderr stream for the reporter.
    * @param stderr_ The writable stream to use for stderr output
    */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   setStderr(stderr_) {
     this.#stderr = stderr_;
   }

package/dist/packem_shared/{pail.browser-CPDOE_d1.js → pail.browser-CPjQrsyy.js}

@@ -13,14 +13,14 @@ var hasRequiredSafeStableStringify;
 function requireSafeStableStringify () {
 	if (hasRequiredSafeStableStringify) return safeStableStringify.exports;
 	hasRequiredSafeStableStringify = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 		const { hasOwnProperty } = Object.prototype;
 		const stringify = configure();
 		stringify.configure = configure;
 		stringify.stringify = stringify;
 		stringify.default = stringify;
-		exports.stringify = stringify;
-		exports.configure = configure;
+		exports$1.stringify = stringify;
+		exports$1.configure = configure;
 		module.exports = stringify;
 		const strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
 		function strEscape(str) {