@uipath/common 0.2.0 → 0.9.0

package/dist/jsonpath.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Evaluate a JSONPath expression against arbitrary data.
+ *
+ * Returns a newline-separated string of matched values.
+ * Objects/arrays are serialized to compact JSON.
+ * Returns an empty string when nothing matches or the expression is unrecognised.
+ */
+export declare function evaluateJsonPath(data: unknown, expression: string): string;
+export declare class JsonPathError extends Error {
+    constructor(message: string);
+}

package/dist/logger.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Shared logger for packages that don't have access to CliContext.
+ * Writes through the OutputSink abstraction so output is correctly
+ * routed in CLI, MCP, and browser contexts.
+ *
+ * By default, all messages are written to stderr via the sink.
+ * When a log file is configured (via --log-file), messages are
+ * appended to that file instead.
+ *
+ * Routing (default / stderr mode):
+ *   all levels → writeErr (stderr), respecting the level threshold
+ *
+ * Routing (file mode, enabled via --log-file):
+ *   all levels → file, respecting the level threshold
+ */
+import type { OutputSink } from "./output-sink";
+export declare function setGlobalLogFilePath(path: string): void;
+export declare function getGlobalLogFilePath(): string;
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+export declare const DEFAULT_LOG_LEVEL = LogLevel.ERROR;
+export interface LoggerConfig {
+    /** Log level threshold. Messages below this level are suppressed. */
+    level?: LogLevel;
+    /** Output sink to set as the process-wide default. */
+    sink?: OutputSink;
+    /** Set to false to disable file logging. Defaults to false. */
+    fileLogging?: boolean;
+    /** Path to a log file. When set, enables file logging to this path. */
+    logFile?: string;
+}
+declare class SimpleLogger {
+    /** Brand marker for cross-bundle duck-type detection. */
+    readonly __brand: "SimpleLogger";
+    private level;
+    private logFilePath;
+    private fileLoggingEnabled;
+    private pendingWrites;
+    private pendingInit;
+    constructor();
+    static getInstance(): SimpleLogger;
+    /** Reset the singleton — intended for testing only. */
+    static resetInstance(): void;
+    private static readonly isNode;
+    private static resolveLevel;
+    private static parseLevel;
+    private format;
+    /** Check if file logging is active (local or cross-bundle via globalThis). */
+    private isFileLoggingActive;
+    private writeToFile;
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    /**
+     * Get the current log level.
+     */
+    getLevel(): LogLevel;
+    /**
+     * Set the log level dynamically
+     */
+    setLevel(level: LogLevel): void;
+    /**
+     * Enable or disable file logging.
+     */
+    setFileLogging(enabled: boolean): void;
+    /**
+     * Set a log file path and enable file logging.
+     */
+    setLogFile(path: string): void;
+    /** Drain pending async file I/O. For tests that read synchronously after logging. */
+    flushFile(): Promise<void>;
+    /**
+     * Get the path to the current log file (empty string if no --log-file was provided).
+     */
+    getLogFilePath(): string;
+    /**
+     * Log handler compatible with the SDK's LogHandler type.
+     * Accepts a LogMessage-shaped object and routes it through SimpleLogger.
+     *
+     * Usage: pass `logger.handleLog` as the `logHandler` option to
+     * `createNodeSolutionPackager` or `createNodeProjectPackager`.
+     */
+    handleLog: (logMessage: {
+        message: string;
+        logLevel: string;
+        source?: string;
+        sourceTarget?: string;
+    }) => void;
+}
+export declare const logger: SimpleLogger;
+/** Reset the logger singleton — intended for testing only. */
+export declare function resetLoggerInstance(): void;
+/**
+ * Get the path to the current log file.
+ */
+export declare function getLogFilePath(): string;
+/**
+ * Configure the logger and output sink in one call.
+ *
+ * @example
+ * // CLI entry point
+ * configureLogger({ sink: new TerminalSink() });
+ *
+ * // Browser entry point
+ * configureLogger({ sink: new BrowserSink() });
+ *
+ * // MCP — errors still surface via writeErr
+ * configureLogger({ level: LogLevel.ERROR, sink: new BufferSink() });
+ */
+export declare function configureLogger(config: LoggerConfig): void;
+export {};

package/dist/option-validators.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared commander option-value validators.
+ *
+ * Use these as the third argument to `.option()` to coerce + validate
+ * raw string input before it reaches command handlers. Throws
+ * `commander.InvalidArgumentError` so commander emits a structured
+ * ValidationError result instead of letting bad input propagate.
+ *
+ * Example:
+ *   .option("-l, --limit <number>", "Maximum results", parseLimit)
+ */
+/**
+ * Parse and validate a positive-integer `--limit` value.
+ * Accepts: integers in [1, max] (default max: 10000)
+ * Rejects: non-numeric, negative, zero, fractional, > max
+ */
+export declare function parseLimit(raw: string, _previous?: number): number;
+/**
+ * Parse and validate a non-negative-integer `--offset` value.
+ * Accepts: integers in [0, max] (default max: 1_000_000)
+ * Rejects: non-numeric, negative, fractional, > max
+ */
+export declare function parseOffset(raw: string, _previous?: number): number;
+/**
+ * Generic bounded-integer parser used by parseLimit/parseOffset.
+ * Accepts integers in [bounds.min, bounds.max] (inclusive).
+ * Use `min: 0` for non-negative, `min: 1` for strictly positive.
+ * Exposed so other commands can build custom-bounded validators.
+ */
+export declare function parseBoundedInt(raw: string, optionName: string, bounds: {
+    min: number;
+    max: number;
+}): number;

package/dist/output-context.d.ts

@@ -0,0 +1,28 @@
+import type { OutputSink, SinkCapabilities } from "./output-sink";
+/**
+ * Run a function with a specific OutputSink bound to the current async context.
+ * All code executed within `fn` (including async continuations) will see this sink
+ * via `getOutputSink()`.
+ *
+ * This is concurrency-safe: multiple simultaneous `runWithSink` scopes
+ * (e.g. concurrent MCP tool calls) each see their own sink.
+ */
+export declare function runWithSink<T>(sink: OutputSink, fn: () => T): T;
+/**
+ * Get the OutputSink for the current execution context.
+ *
+ * Resolution order:
+ *   1. AsyncLocalStorage context (set by runWithSink)
+ *   2. Global fallback sink (set at process startup)
+ *   3. CONSOLE_FALLBACK (writes to process.stdout/stderr — last resort)
+ */
+export declare function getOutputSink(): OutputSink;
+/**
+ * Set the process-wide default sink. Called once at CLI startup.
+ * This is NOT per-request — it is the global fallback when no
+ * AsyncLocalStorage context is active.
+ *
+ * Stored on globalThis so all bundled copies of @uipath/common share it.
+ */
+export declare function setGlobalSink(sink: OutputSink): void;
+export type { OutputSink, SinkCapabilities };

package/dist/output-format-context.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Process-wide output format & filter context.
+ *
+ * Stores the current OutputFormat and JMESPath filter expression so that
+ * OutputFormatter functions can apply them automatically without every
+ * command having to thread these values through.
+ */
+import type { OutputFormat } from "./formatter";
+/**
+ * Set the process-wide output format.
+ * Called once at CLI startup (from extractFormatFromArgs for early use via --output)
+ * and updated by the preAction hook with the Commander-resolved value.
+ */
+export declare function setOutputFormat(format: OutputFormat): void;
+/**
+ * Get the current output format, defaulting to "json" if not set.
+ */
+export declare function getOutputFormat(): OutputFormat;
+/**
+ * Set the process-wide output filter expression.
+ * Called once at CLI startup after parsing the global --output-filter option.
+ */
+export declare function setOutputFilter(filter: string | undefined): void;
+/**
+ * Get the current output filter expression, if any.
+ */
+export declare function getOutputFilter(): string | undefined;

package/dist/output-sink.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The fundamental write target for all CLI output.
+ * Every output path (OutputFormatter, logger) writes through this.
+ */
+export interface OutputSink {
+    /** Write user-facing structured output (stdout equivalent) */
+    writeOut(str: string): void;
+    /** Write error output (stderr equivalent) */
+    writeErr(str: string): void;
+    /** Write diagnostic log messages (logger.info, logger.warn, logger.debug).
+     *  Sinks decide the destination: stdout for CLI, no-op for MCP. */
+    writeLog(str: string): void;
+    /** Capabilities query — allows callers to adapt behavior */
+    readonly capabilities: SinkCapabilities;
+}
+export interface SinkCapabilities {
+    /** True when a human is reading (TTY). False for piped, MCP, browser. */
+    isInteractive: boolean;
+    /** True when ANSI escape codes are supported. */
+    supportsColor: boolean;
+    /** Terminal width, or a sensible default (80/120). */
+    outputWidth: number;
+}

package/dist/polling/abort-controller.d.ts

@@ -0,0 +1 @@
+export declare function createPollAbortController(): AbortController;

package/dist/polling/format-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Convert milliseconds to a human-readable HH:MM:SS duration string.
+ *
+ * Returns `"00:00:00"` for invalid input (negative, NaN, Infinity).
+ *
+ * @example
+ * ```ts
+ * msToDuration(5_023_000); // "01:23:43"
+ * msToDuration(45_000);    // "00:00:45"
+ * msToDuration(0);         // "00:00:00"
+ * ```
+ */
+export declare function msToDuration(ms: number): string;

package/dist/polling/index.d.ts

@@ -0,0 +1,6 @@
+export { createPollAbortController } from "./abort-controller";
+export { msToDuration } from "./format-utils";
+export { pollUntil } from "./poll-until";
+export { isFailureStatus, isSuccessStatus, isTerminalStatus, } from "./terminal-statuses";
+export type { BackoffConfig, OnErrorCallback, PollContext, PollUntilOptions, PollUntilResult, } from "./types";
+export { BACKOFF_DEFAULTS, ErrorDecision, MIN_INTERVAL_MS, POLL_DEFAULTS, PollOutcome, } from "./types";

package/dist/polling/poll-until.d.ts

@@ -0,0 +1,60 @@
+import type { PollUntilOptions, PollUntilResult } from "./types";
+/**
+ * Generic polling utility. Repeatedly calls `fn()` until `until(result)`
+ * returns `true`, a timeout is reached, a signal interrupts, or a consumer
+ * callback aborts.
+ *
+ * All lifecycle hooks are optional. The utility handles timing, retries,
+ * status tracking, backoff, progress logging, and cancellation. Consumers
+ * bring their domain logic via callbacks.
+ *
+ * @example Simple status polling
+ * ```ts
+ * const result = await pollUntil({
+ *     fn: () => api.getJobStatus({ jobId }),
+ *     until: (job) => TERMINAL.has(job.state),
+ *     getStatus: (job) => job.state,
+ *     label: `job ${jobId}`,
+ *     intervalMs: 5000,
+ *     timeoutMs: 360_000,
+ * });
+ * if (result.outcome === PollOutcome.Completed) { ... }
+ * ```
+ *
+ * @example Error-resilient polling with retry
+ * ```ts
+ * const result = await pollUntil({
+ *     fn: () => api.getStatus({ id }),
+ *     until: (r) => r.done,
+ *     maxConsecutiveErrors: 3,
+ *     intervalMs: 60_000,
+ * });
+ * ```
+ *
+ * @example Selective error handling (404 transient, 403 fatal)
+ * ```ts
+ * const result = await pollUntil({
+ *     fn: () => getTraces(id),
+ *     until: (spans) => hasTerminalSpan(spans),
+ *     maxConsecutiveErrors: 0,
+ *     onError: (error) => {
+ *         if (error.message.includes("404")) return;
+ *         return ErrorDecision.Abort;
+ *     },
+ * });
+ * ```
+ *
+ * @example Exponential backoff on errors (normal polls use intervalMs)
+ * ```ts
+ * const result = await pollUntil({
+ *     fn: () => api.getStatus({ id }),
+ *     until: (r) => r.done,
+ *     intervalMs: 5000,        // 5s between successful polls
+ *     backoff: true,           // errors: 1s → 2s → 4s → ... → 30s cap
+ *     maxConsecutiveErrors: 0, // never auto-abort
+ * });
+ * ```
+ *
+ * @see PollUntilOptions for full configuration and callback documentation.
+ */
+export declare function pollUntil<T>(options: PollUntilOptions<T>): Promise<PollUntilResult<T>>;

package/dist/polling/terminal-statuses.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Shared terminal status definitions across all UiPath async operations.
+ *
+ * These cover the superset of known statuses from Orchestrator, Flow,
+ * Test Manager, and Solution deployments. Comparison is case-insensitive.
+ *
+ * Individual tools can extend with domain-specific statuses if needed,
+ * but the common set eliminates each tool defining its own.
+ */
+/**
+ * Check if a status string represents a terminal state (case-insensitive).
+ *
+ * Covers the known superset across Orchestrator jobs, Flow executions,
+ * Test Manager executions, and Solution deployments.
+ *
+ * @example
+ * ```ts
+ * isTerminalStatus("Completed")  // true
+ * isTerminalStatus("Running")    // false
+ * isTerminalStatus("FAULTED")    // true
+ * ```
+ */
+export declare function isTerminalStatus(status: string): boolean;
+/**
+ * Check if a status string represents a failure state (case-insensitive).
+ *
+ * A subset of terminal statuses — excludes success states like
+ * "Completed", "Successful", "Finished".
+ *
+ * @example
+ * ```ts
+ * isFailureStatus("Faulted")    // true
+ * isFailureStatus("Completed")  // false
+ * isFailureStatus("Cancelled")  // true
+ * ```
+ */
+export declare function isFailureStatus(status: string): boolean;
+/**
+ * Check if a status string represents a successful terminal state (case-insensitive).
+ *
+ * Equivalent to `isTerminalStatus(s) && !isFailureStatus(s)`.
+ *
+ * @example
+ * ```ts
+ * isSuccessStatus("Completed")  // true
+ * isSuccessStatus("Faulted")    // false
+ * isSuccessStatus("Running")    // false
+ * ```
+ */
+export declare function isSuccessStatus(status: string): boolean;

package/dist/polling/types.d.ts

@@ -0,0 +1,247 @@
+/**
+ * Shared polling utility types.
+ *
+ * These interfaces define the contract for `pollUntil` — a generic,
+ * callback-driven polling utility that any tool can consume. The design
+ * is driven by the union of all consumer requirements across the codebase.
+ *
+ * Callback ordering contract (per successful poll iteration):
+ *   beforePoll → fn() → onPoll → getStatus/onStatusChange → until → onComplete (if terminal)
+ */
+/**
+ * Context passed to dynamic functions (`intervalMs`, `beforePoll`).
+ * Gives consumers full visibility into the polling state so they can
+ * make informed decisions (e.g., token refresh after N minutes,
+ * adaptive interval based on last status).
+ */
+export interface PollContext<T> {
+    /** Number of completed successful polls (0 before first poll). */
+    pollCount: number;
+    /** Time elapsed since polling started, in ms. */
+    elapsedMs: number;
+    /** Result of the last successful poll. `undefined` before first success. */
+    lastResult?: T;
+    /** Status string from the last poll. `undefined` if `getStatus` is not provided or before the first poll. */
+    lastStatus?: string;
+}
+/**
+ * Backoff configuration for exponential backoff.
+ * When `backoff` is set on `PollUntilOptions`, it overrides `intervalMs`.
+ */
+export interface BackoffConfig {
+    /** Initial interval in ms. (default: 1000) */
+    initialMs?: number;
+    /** Multiplier applied per poll. (default: 2) */
+    multiplier?: number;
+    /** Maximum interval cap in ms. (default: 30000) */
+    maxMs?: number;
+    /**
+     * Jitter factor in [0, 1]. Randomizes the interval to avoid thundering herd.
+     * 0 = no jitter, 1 = full jitter (uniform in [0, computed]).
+     * (default: 0.5 — equal jitter)
+     */
+    jitter?: number;
+}
+/**
+ * Callback type for `onError`. Return `ErrorDecision.Abort` to stop polling,
+ * or return nothing to continue with retry logic. Async-capable.
+ */
+export type OnErrorCallback = (error: Error, consecutiveCount: number) => void | ErrorDecision | Promise<void | ErrorDecision>;
+/** Resolved backoff config with all defaults filled in. */
+export interface ResolvedBackoffConfig {
+    initialMs: number;
+    multiplier: number;
+    maxMs: number;
+    jitter: number;
+}
+export interface PollUntilOptions<T> {
+    /** Async function that fetches current state. */
+    fn: () => Promise<T>;
+    /** Predicate — return `true` when polling should stop. */
+    until: (result: T) => boolean;
+    /** Extract a status string from the poll result for change detection and logging. */
+    getStatus?: (result: T) => string;
+    /**
+     * Polling interval in ms for **successful** polls. Static number or dynamic function.
+     *
+     * Dynamic function receives `PollContext` and returns the interval for the
+     * upcoming sleep. Use for custom scheduling, e.g.:
+     * ```ts
+     * intervalMs: (ctx) => ctx.lastStatus === "Running" ? 2000 : 5000
+     * ```
+     *
+     * (default: 5000)
+     */
+    intervalMs?: number | ((ctx: PollContext<T>) => number);
+    /**
+     * Max time to poll in ms. `0` means no limit — poll indefinitely until
+     * a terminal state, abort, or interrupt.
+     *
+     * (default: 1_800_000 — 30 minutes)
+     */
+    timeoutMs?: number;
+    /**
+     * Exponential backoff for **error retries only**. Does not affect
+     * the interval between successful polls (that's `intervalMs`).
+     *
+     * - `true` — use defaults: `{ initialMs: 1000, multiplier: 2, maxMs: 30000 }`
+     * - `BackoffConfig` object — customize any or all fields; unset fields use defaults.
+     * - `false` / `undefined` — disabled, errors retry with `intervalMs` instead.
+     *
+     * The backoff counter resets when a poll succeeds.
+     */
+    backoff?: boolean | BackoffConfig;
+    /**
+     * `AbortSignal` for external cancellation (from parent operation, tests, etc.).
+     *
+     * When the signal fires, the current sleep is interrupted immediately and
+     * `pollUntil` returns with `outcome: "interrupted"`.
+     *
+     * For SIGINT/SIGTERM support, use `createPollAbortController()` at the CLI
+     * entry point and pass its signal here.
+     */
+    signal?: AbortSignal;
+    /**
+     * Max consecutive poll errors before aborting (throwing).
+     *
+     * - `> 0` — throw after this many consecutive failures.
+     * - `0` — never auto-abort on errors. Only timeout, `onError` returning
+     *   `"abort"`, or signal interruption stops polling. Used by consumers
+     *   that expect transient errors (e.g., integration-service OAuth,
+     *   trace streaming with 404s during startup).
+     *
+     * (default: 3)
+     */
+    maxConsecutiveErrors?: number;
+    /**
+     * Label for log messages (e.g., `"job abc123"`, `"deployment xyz"`).
+     *
+     * When provided, `pollUntil` emits structured log lines via `logger.info`
+     * for start, progress, status changes, errors, and completion.
+     *
+     * Omit for silent mode — zero log output from the utility. Consumers
+     * can still use callbacks (`onPoll`, etc.) for custom logging.
+     */
+    label?: string;
+    /**
+     * Prefix for log messages. Appears as `[prefix]` before each log line.
+     * (default: `"wait"`)
+     *
+     * Override to match your command name, e.g. `"deploy"`, `"activate"`.
+     */
+    logPrefix?: string;
+    /**
+     * Interval between progress log lines in ms.
+     *
+     * Progress lines are only emitted when `label` is provided.
+     *
+     * (default: 30_000)
+     */
+    logIntervalMs?: number;
+    /**
+     * Called BEFORE each poll. Async-capable.
+     *
+     * Use for token refresh, rate-limit checks, or any pre-flight logic.
+     * If this throws, the error is treated as a poll error (increments
+     * `consecutiveErrors`, fires `onError`, follows retry logic).
+     */
+    beforePoll?: (ctx: PollContext<T>) => void | Promise<void>;
+    /**
+     * Called after each successful `fn()` call.
+     *
+     * Fires on EVERY successful poll, including the terminal one (before
+     * `onComplete`). Consumers that need to emit incremental data (e.g.,
+     * trace streaming with span deduplication) use this callback.
+     */
+    onPoll?: (result: T, elapsedMs: number) => void;
+    /**
+     * Called when `getStatus()` detects a status transition.
+     *
+     * Only fires when the extracted status string differs from the previous
+     * poll's status. `getStatus` must be provided for this to work.
+     */
+    onStatusChange?: (newStatus: string, oldStatus: string, result: T) => void;
+    /**
+     * Called on each poll error (including `beforePoll` errors).
+     *
+     * Return `"abort"` to stop polling immediately — `pollUntil` will return
+     * with `outcome: "aborted"`. Return `void` (or nothing) to continue
+     * with the retry/timeout logic.
+     *
+     * Async-capable: the return value is awaited if a Promise is returned.
+     *
+     * Use for selective error handling, e.g.:
+     * ```ts
+     * onError: (error) => {
+     *     if (error.message.includes("404")) return; // transient, continue
+     *     return "abort"; // fatal, stop
+     * }
+     * ```
+     */
+    onError?: OnErrorCallback;
+    /**
+     * Called when polling completes (terminal state reached via `until`).
+     */
+    onComplete?: (result: T, elapsedMs: number) => void;
+    /**
+     * Called when the timeout deadline is reached without a terminal state.
+     * `lastResult` may be `undefined` if no poll succeeded.
+     */
+    onTimeout?: (lastResult: T | undefined, elapsedMs: number) => void;
+    /**
+     * Called when polling is interrupted via `AbortSignal`.
+     * `lastResult` may be `undefined` if no poll succeeded.
+     */
+    onInterrupt?: (lastResult: T | undefined, elapsedMs: number) => void;
+}
+/**
+ * Result returned by `pollUntil`.
+ *
+ * - `"completed"` — `until(result)` returned `true`. `data` is guaranteed to be `T`.
+ * - `"timeout"` — deadline reached. `data` is the last successful poll result, or `undefined`.
+ * - `"interrupted"` — `AbortSignal` fired. `data` is the last successful poll result, or `undefined`.
+ * - `"aborted"` — consumer's `onError` returned `"abort"`. `data` is the last successful poll result, or `undefined`.
+ * - `"failed"` — `maxConsecutiveErrors` exceeded. `error` contains the last poll error.
+ */
+export interface PollUntilResult<T> {
+    /** The final polled value. Guaranteed `T` when `outcome` is `"completed"`. `T | undefined` otherwise. */
+    data: T | undefined;
+    /** How the poll ended. Compare with `PollOutcome` constants. */
+    outcome: PollOutcome;
+    /** Total elapsed time in ms. */
+    elapsedMs: number;
+    /** The error associated with a non-successful outcome. Set when `outcome` is `"aborted"` or `"failed"`; `undefined` otherwise. */
+    error?: Error;
+}
+/** Possible outcomes of a `pollUntil` call. Use instead of string literals. */
+export declare const PollOutcome: {
+    /** `until(result)` returned `true`. `data` is guaranteed to be `T`. */
+    readonly Completed: "completed";
+    /** Deadline reached without terminal state. */
+    readonly Timeout: "timeout";
+    /** `AbortSignal` fired. */
+    readonly Interrupted: "interrupted";
+    /** Consumer's `onError` returned `ErrorDecision.Abort`. */
+    readonly Aborted: "aborted";
+    /** `maxConsecutiveErrors` exceeded. `error` field has the last poll error. */
+    readonly Failed: "failed";
+};
+export type PollOutcome = (typeof PollOutcome)[keyof typeof PollOutcome];
+/** Return values from `onError` callback. Use instead of string literals. */
+export declare const ErrorDecision: {
+    /** Stop polling immediately. */
+    readonly Abort: "abort";
+};
+export type ErrorDecision = (typeof ErrorDecision)[keyof typeof ErrorDecision];
+/** Default values for `PollUntilOptions`. */
+export declare const POLL_DEFAULTS: {
+    readonly intervalMs: 5000;
+    readonly timeoutMs: 1800000;
+    readonly maxConsecutiveErrors: 3;
+    readonly logIntervalMs: 30000;
+    readonly logPrefix: "wait";
+};
+/** Default values for `BackoffConfig`. */
+export declare const BACKOFF_DEFAULTS: ResolvedBackoffConfig;
+/** Minimum allowed polling interval in ms. Prevents CPU spin on bad dynamic values. */
+export declare const MIN_INTERVAL_MS = 100;

package/dist/registry.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Read a value from the Windows registry.
+ * reg utility always exist.
+ * Returns an empty string on non-Windows platforms or when the key/value is missing.
+ */
+export declare function readRegistryValue(keyPath: string, valueName: string): string;

package/dist/screen-logger.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Standalone screen-output helper.
+ * Methods here write human-visible messages to the screen,
+ * bypassing log-level filtering and file-logging redirection.
+ */
+export declare namespace ScreenLogger {
+    /** Write a progress message to the screen. */
+    function progress(message: string): void;
+}