@sayknow-cli/utils 0.3.16 → 0.4.1

package/dist/types/env.d.ts

@@ -1,68 +0,0 @@
-export { filterProcessEnv, isSafeEnvName, isSafeEnvValue } from "./spawn-env";
-/**
- * Strict shell-identifier shape. Used for dotenv keys we accept into
- * `Bun.env` — those should be referenceable as `$NAME` from POSIX shells,
- * so we reject anything outside `[A-Za-z_][A-Za-z0-9_]*`.
- */
-export declare function isValidEnvName(name: string): boolean;
-/**
- * Parses simple POSIX shell environment assignments from files such as
- * ~/.zshrc without executing user shell code. Supports `export KEY=value` and
- * `KEY=value`, including single/double quoted literal values. Dynamic shell
- * expressions are intentionally ignored because evaluating startup files would
- * run arbitrary code during CLI startup.
- */
-export declare function parseShellEnvFile(filePath: string): Record<string, string>;
-/**
- * Parses a .env file synchronously and extracts key-value string pairs.
- * Ignores lines that are empty or start with '#'. Trims whitespace.
- * Allows values to be quoted with single or double quotes.
- * Returns an object of key-value pairs.
- */
-export declare function parseEnvFile(filePath: string): Record<string, string>;
-export declare function $inheritedEnv(name: string): string | undefined;
-/**
- * Intentional re-export of Bun.env.
- *
- * All users should import this env module (import { $env } from "@sayknow-cli/utils")
- * before using environment variables. This ensures that .env files have been loaded and
- * overrides (project, home) have been applied, so $env always reflects the correct values.
- *
- * Provider credential resolution must not use this merged view because it includes the
- * caller's cwd/.env. Use $credentialEnv/$pickCredentialEnv for model authentication.
- */
-export declare const $env: Record<string, string>;
-/**
- * Resolve the first environment variable value from the given keys.
- * @param keys - The keys to resolve.
- * @returns The first environment variable value, or undefined if no value is found.
- */
-export declare function $pickenv(...keys: string[]): string | undefined;
-/**
- * Resolve credential-bearing environment variables without consulting the caller's project .env.
- *
- * SKC loads cwd/.env into $env for project-aware tools, but model-provider authentication should
- * only use values explicitly inherited from the launching shell or SKC/user-owned config files.
- */
-export declare function $credentialEnv(name: string): string | undefined;
-/**
- * Resolve the first credential env value from the given keys, excluding cwd/.env overlays.
- */
-export declare function $pickCredentialEnv(...keys: string[]): string | undefined;
-/**
- * Parses a positive decimal integer from `$env[name]`.
- * Empty, invalid, NaN, zero, or negative values return `defaultValue`.
- */
-export declare function $envpos(name: string, defaultValue: number): number;
-/** True when `BUN_ENV` or `NODE_ENV` is the string `test`. */
-export declare function isBunTestRuntime(): boolean;
-/**
- * True when this code is running inside a `bun build --compile` standalone
- * binary. Detects via the embedded virtual-filesystem path markers
- * (`$bunfs`, `~BUN`, or its URL-encoded form `%7EBUN`) in `import.meta.url`,
- * which Bun rewrites for every module bundled into the executable. The
- * `PI_COMPILED` env var (set by the build script's `--define`) is checked
- * first for cheap fast-path detection.
- */
-export declare function isCompiledBinary(): boolean;
-export declare function $flag(name: string, def?: boolean): boolean;

package/dist/types/fetch-retry.d.ts

@@ -1,80 +0,0 @@
-/**
- * Server-suggested retry delay extraction. Merges the patterns historically used
- * by the OpenAI code provider and Google Gemini retry helpers.
- *
- * Header sources (checked in order):
- *  - `Retry-After` (numeric seconds, or HTTP date)
- *  - `x-ratelimit-reset` (Unix epoch seconds)
- *  - `x-ratelimit-reset-after` (seconds)
- *
- * Body patterns:
- *  - `Your quota will reset after 18h31m10s` / `10m15s` / `39s`
- *  - `Please retry in 250ms` / `Please retry in 12s`
- *  - `"retryDelay": "34.074824224s"` (JSON error detail field)
- *  - `try again in 250ms` / `try again in 12s` / `try again in 12sec`
- *
- * Returns `undefined` if no signal is found.
- */
-export declare function extractRetryHint(source: Response | Headers | null | undefined, body?: string): number | undefined;
-export interface FetchWithRetryOptions extends RequestInit {
-    /** Total fetch attempts (initial + retries). Default `5`. */
-    maxAttempts?: number;
-    /**
-     * Per-delay cap. Server-provided `Retry-After` hints exceeding this return
-     * the current response immediately — caller deals with the `!response.ok`.
-     * Default `60_000`.
-     */
-    maxDelayMs?: number;
-    /**
-     * Fallback delay schedule when no server hint is present. Number, array
-     * (indexed by attempt, clamped to last), or function. Default exponential
-     * `500ms * 2 ** attempt` capped at `maxDelayMs`.
-     */
-    defaultDelayMs?: number | readonly number[] | ((attempt: number) => number);
-    /**
-     * Optional per-attempt overlay merged into the base `RequestInit` each try.
-     * Headers from the overlay shallow-merge over the base. Useful for auth
-     * token refresh or user-agent rotation.
-     */
-    prepareInit?: (attempt: number) => RequestInit | Promise<RequestInit>;
-    /**
-     * Optional `fetch` implementation override. Defaults to `globalThis.fetch`.
-     * Useful for routing requests through a proxy, instrumented transport, or
-     * mock during tests.
-     */
-    fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-}
-/**
- * Fetch with bounded retries and sensible defaults. Retries on any
- * `isRetryableStatus` (5xx, 408, 429) and on transient network errors. Server
- * `Retry-After`/quota hints are honoured up to `maxDelayMs`; a hint that exceeds
- * the cap returns the current response so the caller can fail fast. Aborts on
- * `init.signal` propagate as `"Request was aborted"`.
- *
- * The caller is responsible for inspecting `!response.ok` once the call returns.
- */
-export declare function fetchWithRetry(url: string | URL | ((attempt: number) => string | URL), options?: FetchWithRetryOptions): Promise<Response>;
-/**
- * Inspect an arbitrary error value (or its `cause` chain, up to depth 2) for an
- * HTTP status code. Reads `status`, `statusCode`, and `response.status` fields,
- * coerces string values, and falls back to scanning the error message for
- * common patterns like `Error: 401`, `error (429)`, or `HTTP 503`.
- */
-export declare function extractHttpStatusFromError(error: unknown): number | undefined;
-/**
- * `true` if the given HTTP status code is one we treat as transient: 408
- * (Request Timeout), 429 (Too Many Requests), or any 5xx (server error).
- */
-export declare function isRetryableStatus(status: number): boolean;
-/**
- * `true` if the message describes an unexpected socket closure — Bun and some
- * proxies surface these for any HTTP/2 stream reset.
- */
-export declare function isUnexpectedSocketCloseMessage(message: string): boolean;
-/**
- * Identify errors that should be retried: aborts/timeouts in the error name or
- * message, retryable HTTP statuses (see `isRetryableStatus`), unexpected socket
- * closes, and the standard transient phrases. 4xx statuses other than 408/429
- * and validation-shaped messages short-circuit to `false`.
- */
-export declare function isRetryableError(error: unknown): boolean;

package/dist/types/format.d.ts

@@ -1,37 +0,0 @@
-/**
- * Format a duration in milliseconds to a short human-readable string.
- * Examples: "123ms", "1.5s", "30m15s", "2h30m", "3d2h"
- */
-export declare function formatDuration(ms: number): string;
-/**
- * Format a number with K/M/B suffix for compact display.
- * Uses 1 decimal for small leading digits when non-zero, rounded otherwise.
- * Examples: "999", "1K", "1.5K", "25K", "1M", "1.5M", "25M", "1.5B"
- */
-export declare function formatNumber(n: number): string;
-/**
- * Format a byte count to a human-readable string.
- * Examples: "512B", "1.5KB", "2.3MB", "1.2GB"
- */
-export declare function formatBytes(bytes: number): string;
-/**
- * Truncate a string to maxLen characters, appending an ellipsis if truncated.
- * For display-width-aware truncation (terminals), use truncateToWidth from @sayknow-cli/tui.
- */
-export declare function truncate(str: string, maxLen: number, ellipsis?: string): string;
-/**
- * Format count with pluralized label (e.g., "3 files", "1 error").
- */
-export declare function formatCount(label: string, count: number): string;
-/**
- * Format age from seconds to human-readable string.
- */
-export declare function formatAge(ageSeconds: number | null | undefined): string;
-/**
- * Pluralize a label based on the count.
- */
-export declare function pluralize(label: string, count: number): string;
-/**
- * Format a ratio as a percentage.
- */
-export declare function formatPercent(ratio: number): string;

package/dist/types/frontmatter.d.ts

@@ -1,25 +0,0 @@
-export declare class FrontmatterError extends Error {
-    readonly source?: unknown | undefined;
-    constructor(error: Error, source?: unknown | undefined);
-    toString(): string;
-}
-export interface FrontmatterOptions {
-    /** Source of the content (alias: source) */
-    location?: unknown;
-    /** Source of the content (alias for location) */
-    source?: unknown;
-    /** Fallback frontmatter values */
-    fallback?: Record<string, unknown>;
-    /** Normalize the content */
-    normalize?: boolean;
-    /** Level of error handling */
-    level?: "off" | "warn" | "fatal";
-}
-/**
- * Parse YAML frontmatter from markdown content
- * Returns { frontmatter, body } where body has frontmatter stripped
- */
-export declare function parseFrontmatter(content: string, options?: FrontmatterOptions): {
-    frontmatter: Record<string, unknown>;
-    body: string;
-};

package/dist/types/fs-error.d.ts

@@ -1,31 +0,0 @@
-/**
- * Type-safe filesystem error handling utilities.
- *
- * Use these to check error codes without string matching on messages:
- *
- * @example
- * ```ts
- * import { isEnoent, isFsError } from "@sayknow-cli/utils";
- *
- * try {
- *     return await Bun.file(path).text();
- * } catch (err) {
- *     if (isEnoent(err)) return null;
- *     throw err;
- * }
- * ```
- */
-export interface FsError extends Error {
-    code: string;
-    errno?: number;
-    syscall?: string;
-    path?: string;
-}
-export declare function isFsError(err: unknown): err is FsError;
-export declare function isEnoent(err: unknown): err is FsError;
-export declare function isEacces(err: unknown): err is FsError;
-export declare function isEisdir(err: unknown): err is FsError;
-export declare function isEnotdir(err: unknown): err is FsError;
-export declare function isEexist(err: unknown): err is FsError;
-export declare function isEnotempty(err: unknown): err is FsError;
-export declare function hasFsCode(err: unknown, code: string): err is FsError;

package/dist/types/glob.d.ts

@@ -1,28 +0,0 @@
-export interface GlobPathsOptions {
-    /** Base directory for glob patterns. Defaults to getProjectDir(). */
-    cwd?: string;
-    /** Glob exclusion patterns. */
-    exclude?: string[];
-    /** Abort signal to cancel the glob. */
-    signal?: AbortSignal;
-    /** Timeout in milliseconds for the glob operation. */
-    timeoutMs?: number;
-    /** Include dotfiles when true. */
-    dot?: boolean;
-    /** Only return files (skip directories). Default: true. */
-    onlyFiles?: boolean;
-    /** Respect .gitignore files when true. Walks up directory tree to find all applicable .gitignore files. */
-    gitignore?: boolean;
-}
-/**
- * Load .gitignore patterns from a directory and its parents.
- * Walks up the directory tree to find all applicable .gitignore files.
- * Returns glob-compatible exclude patterns.
- */
-export declare function loadGitignorePatterns(baseDir: string): Promise<string[]>;
-/**
- * Resolve filesystem paths matching glob patterns with optional exclude filters.
- * Returns paths relative to the provided cwd (or getProjectDir()).
- * Errors and abort/timeouts are surfaced to the caller.
- */
-export declare function globPaths(patterns: string | string[], options?: GlobPathsOptions): Promise<string[]>;

package/dist/types/hook-fetch.d.ts

@@ -1,16 +0,0 @@
-/**
- * Intercept `globalThis.fetch` with a middleware-style handler.
- *
- * Returns a `Disposable` so callers can use `using` for automatic cleanup:
- *
- * ```ts
- * using _hook = hookFetch((input, init, next) => {
- *   if (shouldIntercept(input)) {
- *     return new Response("mocked");
- *   }
- *   return next(input, init);
- * });
- * ```
- */
-export type FetchHandler = (input: string | URL | Request, init: RequestInit | undefined, next: typeof fetch) => Response | Promise<Response>;
-export declare function hookFetch(handler: FetchHandler): Disposable;

package/dist/types/index.d.ts

@@ -1,31 +0,0 @@
-export { createAbortableStream, once, untilAborted } from "./abortable";
-export * from "./async";
-export * from "./broken-pipe";
-export * from "./color";
-export * from "./dirs";
-export * from "./env";
-export * from "./fetch-retry";
-export * from "./format";
-export * from "./frontmatter";
-export * from "./fs-error";
-export * from "./glob";
-export * from "./hook-fetch";
-export * from "./json";
-export * as logger from "./logger";
-export * from "./mermaid-ascii";
-export * from "./mime";
-export * from "./peek-file";
-export * as postmortem from "./postmortem";
-export * as procmgr from "./procmgr";
-export * as prompt from "./prompt";
-export * as ptree from "./ptree";
-export { AbortError, ChildProcess, Exception, NonZeroExitError } from "./ptree";
-export * from "./safe-stderr";
-export * from "./sanitize-text";
-export * from "./snowflake";
-export * from "./stream";
-export * from "./tab-spacing";
-export * from "./temp";
-export * from "./type-guards";
-export * from "./which";
-export declare function structuredCloneJSON<T>(value: T): T;

package/dist/types/json.d.ts

@@ -1,4 +0,0 @@
-/**
- * Try to parse JSON, returning null on failure.
- */
-export declare function tryParseJson<T = unknown>(content: string): T | null;

package/dist/types/logger.d.ts

@@ -1,66 +0,0 @@
-/**
- * Replace the active log transports. Pass `console: true, file: false` for
- * long-running services (the auth broker, etc.) that want their structured
- * logs piped into a process supervisor instead of the rotating file.
- */
-export declare function setTransports(opts: {
-    console?: boolean;
-    file?: boolean | string;
-}): void;
-/**
- * Log an error message.
- * @param message - The message to log.
- * @param context - The context to log.
- */
-export declare function error(message: string, context?: Record<string, unknown>): void;
-/**
- * Log a warning message.
- * @param message - The message to log.
- * @param context - The context to log.
- */
-export declare function warn(message: string, context?: Record<string, unknown>): void;
-/**
- * Log an informational message.
- * @param message - The message to log.
- * @param context - The context to log.
- */
-export declare function info(message: string, context?: Record<string, unknown>): void;
-/**
- * Log a debug message.
- * @param message - The message to log.
- * @param context - The context to log.
- */
-export declare function debug(message: string, context?: Record<string, unknown>): void;
-/**
- * Print collected timings as an indented tree.
- * Each span shows wall duration; parents with children also show "(self)" for unattributed time.
- * Sibling spans are sorted by start time. Spans whose intervals overlap with siblings ran in parallel.
- */
-export declare function printTimings(): void;
-/**
- * Begin recording startup timings under a new root span.
- * Idempotent: a second call while already recording is a no-op so that side-effect
- * starters (see module-timer.ts) and explicit starters (main.ts) can coexist.
- */
-export declare function startTiming(): void;
-/**
- * Record an externally-measured span as a leaf child of the active span (or root
- * when no span is active). Used by the module-load timing plugin to splice load
- * events into the tree retroactively.
- */
-export declare function recordModuleLoadSpan(path: string, start: number, durationMs: number): void;
-/**
- * End timing window and clear buffers.
- */
-export declare function endTiming(): void;
-/**
- * Time a span. Three forms:
- *   time(op)                    — point event (zero-duration breadcrumb)
- *   time(op, fn, ...args)        — wrap fn in a span; returns fn's return value (sync or Promise)
- *
- * Spans nest hierarchically via AsyncLocalStorage: a child started inside another span's fn
- * (even across awaits) becomes that span's child. Parallel children are recorded as siblings
- * with overlapping intervals.
- */
-export declare function time(op: string): void;
-export declare function time<T, A extends unknown[]>(op: string, fn: (...args: A) => T, ...args: A): T;

package/dist/types/mermaid-ascii.d.ts

@@ -1,11 +0,0 @@
-import { type AsciiRenderOptions } from "beautiful-mermaid";
-export type { AsciiRenderOptions as MermaidAsciiRenderOptions };
-export declare function renderMermaidAscii(source: string, options?: AsciiRenderOptions): string;
-export declare function renderMermaidAsciiSafe(source: string, options?: AsciiRenderOptions): string | null;
-/**
- * Extract mermaid code blocks from markdown text.
- */
-export declare function extractMermaidBlocks(markdown: string): {
-    source: string;
-    hash: bigint | number;
-}[];

package/dist/types/mime.d.ts

@@ -1,29 +0,0 @@
-export declare const SUPPORTED_IMAGE_MIME_TYPES: Set<string>;
-export type ImageMetadata = {
-    mimeType: "image/png";
-    width?: number;
-    height?: number;
-    channels?: number;
-    hasAlpha?: boolean;
-} | {
-    mimeType: "image/jpeg";
-    width?: number;
-    height?: number;
-    channels?: number;
-    hasAlpha?: false;
-} | {
-    mimeType: "image/gif";
-    width?: number;
-    height?: number;
-    channels?: 3;
-    hasAlpha?: never;
-} | {
-    mimeType: "image/webp";
-    width?: number;
-    height?: number;
-    channels?: number;
-    hasAlpha?: boolean;
-};
-export declare function parseImageMetadata(header: Uint8Array): ImageMetadata | null;
-export declare function readImageMetadataSync(filePath: string, maxBytes?: number): ImageMetadata | null;
-export declare function readImageMetadata(filePath: string, maxBytes?: number): Promise<ImageMetadata | null>;

package/dist/types/peek-file.d.ts

@@ -1,9 +0,0 @@
-/**
- * Synchronously reads up to `maxBytes` from the start of `filePath` and returns `op(header)`.
- * If the file is shorter, `header` is only the bytes actually read.
- */
-export declare function peekFileSync<T>(filePath: string, maxBytes: number, op: (header: Uint8Array) => T): T;
-/**
- * Like {@link peekFileSync} but uses async I/O.
- */
-export declare function peekFile<T>(filePath: string, maxBytes: number, op: (header: Uint8Array) => T): Promise<T>;

package/dist/types/postmortem.d.ts

@@ -1,29 +0,0 @@
-export declare enum Reason {
-    PRE_EXIT = "pre_exit",// Pre-exit phase (not used by default)
-    EXIT = "exit",// Normal process exit
-    SIGINT = "sigint",// Ctrl-C or SIGINT
-    SIGTERM = "sigterm",// SIGTERM
-    SIGHUP = "sighup",// SIGHUP
-    UNCAUGHT_EXCEPTION = "uncaught_exception",// Fatal exception
-    UNHANDLED_REJECTION = "unhandled_rejection",// Unhandled promise rejection
-    MANUAL = "manual"
-}
-/**
- * Register a process cleanup callback, to be run on shutdown, signal, or fatal error.
- *
- * Returns a Callback instance that can be used to cancel (unregister) or manually clean up.
- * If register is called after cleanup already began, invokes callback on a microtask.
- */
-export declare function register(id: string, callback: (reason: Reason) => void | Promise<void>): () => void;
-/**
- * Runs all cleanup callbacks without exiting.
- * Use this in workers or when you need to clean up but continue execution.
- */
-export declare function cleanup(): Promise<void>;
-/**
- * Runs all cleanup callbacks and exits.
- *
- * In main thread: waits for stdout drain, then calls process.exit().
- * In workers: runs cleanup only (process.exit would kill entire process).
- */
-export declare function quit(code?: number): Promise<void>;

package/dist/types/procmgr.d.ts

@@ -1,35 +0,0 @@
-import type { Subprocess } from "bun";
-export interface ShellConfig {
-    shell: string;
-    args: string[];
-    env: Record<string, string>;
-    prefix: string | undefined;
-}
-/**
- * Strip disabled macOS malloc-stack-logging vars from `process.env` in place.
- *
- * macOS leaves `MallocStackLogging=0` (or similar) inherited by debug-attached
- * shells. Bun's libc init then prints `MallocStackLogging: can't turn off
- * malloc stack logging because it was not enabled.` to stderr for every
- * subprocess. Scrubbing once at startup means every child we spawn — bash,
- * bun subagents, plugin installs, ptree commands — inherits a clean env.
- */
-export declare function scrubProcessEnv(): void;
-/**
- * Resolve a basic shell (bash or sh) as fallback.
- */
-export declare function resolveBasicShell(): string | undefined;
-/**
- * Get shell configuration based on platform.
- * Resolution order:
- * 1. User-specified shellPath in settings.json
- * 2. On Windows: Git Bash in known locations, then bash on PATH
- * 3. On Unix: $SHELL if bash/zsh, then fallback paths
- * 4. Fallback: sh
- */
-export declare function getShellConfig(customShellPath?: string): ShellConfig;
-/**
- * Check if a process is running.
- */
-export declare function isPidRunning(pid: number | Subprocess): boolean;
-export declare function onProcessExit(proc: Subprocess | number, abortSignal?: AbortSignal): Promise<boolean>;

package/dist/types/prompt.d.ts

@@ -1,18 +0,0 @@
-import type { HelperDelegate, HelperOptions, Template, TemplateDelegate } from "handlebars";
-export type { HelperDelegate, HelperOptions, Template, TemplateDelegate };
-export type PromptRenderPhase = "pre-render" | "post-render";
-export interface PromptFormatOptions {
-    renderPhase?: PromptRenderPhase;
-    replaceAsciiSymbols?: boolean;
-    normalizeRfc2119?: boolean;
-}
-export declare function format(content: string, options?: PromptFormatOptions): string;
-export interface TemplateContext extends Record<string, unknown> {
-    args?: string[];
-    ARGUMENTS?: string;
-    arguments?: string;
-}
-export declare function registerHelper(name: string, fn: HelperDelegate): void;
-export declare function registerPartial(name: string, fn: Template): void;
-export declare function compile(template: string): (context: TemplateContext) => string;
-export declare function render(template: string, context?: TemplateContext): string;

package/dist/types/ptree.d.ts

@@ -1,108 +0,0 @@
-/**
- * Process tree management utilities for Bun subprocesses.
- *
- * - Track managed child processes for cleanup on shutdown (postmortem).
- * - Drain stdout/stderr to avoid subprocess pipe deadlocks.
- * - Cross-platform tree kill for process groups (Windows taskkill, Unix -pid).
- * - Convenience helpers: captureText / execText, AbortSignal, timeouts.
- */
-import type { Spawn, Subprocess } from "bun";
-type InMask = "pipe" | "ignore" | Buffer | Uint8Array | null;
-/** A Bun subprocess with stdout/stderr always piped (stdin may vary). */
-type PipedSubprocess<In extends InMask = InMask> = Subprocess<In, "pipe", "pipe">;
-/**
- * Base for all exceptions representing child process nonzero exit, killed, or
- * cancellation.
- */
-export declare abstract class Exception extends Error {
-    readonly exitCode: number;
-    readonly stderr: string;
-    constructor(message: string, exitCode: number, stderr: string);
-    abstract readonly aborted: boolean;
-}
-/** Exception for nonzero exit codes (not cancellation). */
-export declare class NonZeroExitError extends Exception {
-    static readonly MAX_TRACE: number;
-    constructor(exitCode: number, stderr: string);
-    get aborted(): boolean;
-}
-/** Exception for explicit process abortion (via signal). */
-export declare class AbortError extends Exception {
-    readonly reason: unknown;
-    constructor(reason: unknown, stderr: string);
-    get aborted(): boolean;
-}
-/** Exception for process timeout. */
-export declare class TimeoutError extends AbortError {
-    constructor(timeout: number, stderr: string);
-}
-/** Options for waiting for process exit and capturing output. */
-export interface WaitOptions {
-    allowNonZero?: boolean;
-    allowAbort?: boolean;
-    stderr?: "full" | "buffer";
-}
-/** Result from wait and exec. */
-export interface ExecResult {
-    stdout: string;
-    stderr: string;
-    exitCode: number | null;
-    ok: boolean;
-    exitError?: Exception;
-}
-/**
- * ChildProcess wraps a managed subprocess, capturing stderr tail, providing
- * cross-platform kill/detach logic plus AbortSignal integration.
- *
- * Stdout is exposed directly from the underlying Bun subprocess; consumers
- * must read it (via text(), wait(), etc.) to prevent pipe deadlock.
- * Stderr is eagerly drained into an internal buffer.
- */
-export declare class ChildProcess<In extends InMask = InMask> {
-    #private;
-    readonly proc: PipedSubprocess<In>;
-    readonly exposeStderr: boolean;
-    constructor(proc: PipedSubprocess<In>, exposeStderr: boolean);
-    get pid(): number;
-    get exited(): Promise<number>;
-    get exitCode(): number | null;
-    get exitReason(): Exception | undefined;
-    get killed(): boolean;
-    get stdin(): Bun.SpawnOptions.WritableToIO<In>;
-    /** Raw stdout stream. Must be consumed to prevent pipe deadlock. */
-    get stdout(): ReadableStream<Uint8Array<ArrayBuffer>>;
-    /** Optional stderr stream (only when requested in spawn options). */
-    get stderr(): ReadableStream<Uint8Array<ArrayBufferLike>> | undefined;
-    get exitedCleanly(): Promise<number>;
-    /** Returns the truncated stderr tail (last 32KB). */
-    peekStderr(): string;
-    nothrow(): this;
-    kill(reason?: Exception): void;
-    text(): Promise<string>;
-    blob(): Promise<Blob>;
-    json(): Promise<unknown>;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    bytes(): Promise<Uint8Array>;
-    wait(opts?: WaitOptions): Promise<ExecResult>;
-    attachSignal(signal: AbortSignal): void;
-    attachTimeout(ms: number): void;
-    [Symbol.dispose](): void;
-}
-/** Options for child spawn. Always pipes stdout/stderr. */
-type ChildSpawnOptions<In extends InMask = InMask> = Omit<Spawn.SpawnOptions<In, "pipe", "pipe">, "stdout" | "stderr" | "detached"> & {
-    signal?: AbortSignal;
-    detached?: boolean;
-    stderr?: "full" | null;
-};
-/** Spawn a child process with piped stdout/stderr. */
-export declare function spawn<In extends InMask = InMask>(cmd: string[], opts?: ChildSpawnOptions<In>): ChildProcess<In>;
-/** Options for exec. */
-export interface ExecOptions extends Omit<ChildSpawnOptions, "stderr" | "stdin">, WaitOptions {
-    input?: string | Buffer | Uint8Array;
-}
-/** Spawn, wait, and return captured output. */
-export declare function exec(cmd: string[], opts?: ExecOptions): Promise<ExecResult>;
-type SignalValue = AbortSignal | number | null | undefined;
-/** Combine AbortSignals and timeout values into a single signal. */
-export declare function combineSignals(...signals: SignalValue[]): AbortSignal | undefined;
-export {};