@oh-my-pi-zen/pi-utils 16.3.6-zen.1

package/dist/types/logger.d.ts

@@ -0,0 +1,83 @@
+/**
+ * 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;
+/**
+ * Streaming startup markers, enabled by `PI_DEBUG_STARTUP`. Unlike the
+ * PI_TIMING tree (printed only after startup completes), these write one
+ * synchronous stderr line as each phase begins/ends, so a hard hang still
+ * shows the last phase that started. `fs.writeSync(2)` is used deliberately:
+ * it cannot be reordered or buffered past a synchronous block of the event
+ * loop (dlopen, sync fs on a dead mount, spawnSync).
+ */
+export declare function startupMarker(text: string): void;
+export declare function timingModeIncludes(option: "full" | "x"): boolean;
+export declare function shouldExitAfterTimings(): boolean;
+/**
+ * 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 an explicit
+ * starter (main.ts) and any future early starter 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 {@link spliceModuleLoadBuffer} to fold
+ * preload-captured module windows into the tree.
+ */
+export declare function recordModuleLoadSpan(path: string, start: number, durationMs: number, bodyMs?: number, imports?: string[]): void;
+/**
+ * End timing window and clear buffers.
+ */
+export declare function endTiming(): void;
+/**
+ * Ops of the currently-open span chain (root → deepest), following the most
+ * recently started unfinished child at each level. Lets a startup watchdog
+ * name the phase a stalled startup is stuck in.
+ */
+export declare function openSpanPath(): string[];
+/**
+ * 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/loop-phase.d.ts

@@ -0,0 +1,10 @@
+export declare function pushLoopPhase(label: string): void;
+export declare function popLoopPhase(): void;
+export declare function currentLoopPhase(): string | undefined;
+/**
+ * Phase to blame for a just-detected loop block: the live top phase if one is
+ * still held, else the most recent phase pushed since the last call. Clears the
+ * recent slot so a block in a later, phase-less interval is not misattributed
+ * to a phase that already finished.
+ */
+export declare function takeRecentLoopPhase(): string | undefined;

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

@@ -0,0 +1,11 @@
+import { type AsciiRenderOptions } from "./vendor/mermaid-ascii";
+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

@@ -0,0 +1,29 @@
+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/module-timer.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/path-tree.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Multi-level path tree shared by grouped file listings (find / grep / ast tools)
+ * and compaction file-operation lists.
+ *
+ * Flat path lists used to group by the *immediate* parent directory and print the
+ * full directory path in every header. For results spread across a deep tree — or
+ * rooted outside cwd, where paths stay absolute — that repeated the shared prefix
+ * on every line. The tree below folds single-child directory chains (so the common
+ * prefix collapses into one header) and nests the rest, charging the model one
+ * token per path segment instead of one per file.
+ */
+/** True for `scheme://…` entries that have no meaningful directory structure. */
+export declare function isUrlLikePath(filePath: string): boolean;
+export interface PathTreeNode {
+    /** Direct file leaves, in first-seen order. */
+    files: Array<{
+        name: string;
+        key: string;
+    }>;
+    /** Dedup set for `files` (a glob can surface the same path twice on retry). */
+    fileNames: Set<string>;
+    /** Child directories, in first-seen order. */
+    subdirs: Array<{
+        name: string;
+        node: PathTreeNode;
+    }>;
+    /** Dedup index for `subdirs`. */
+    dirIndex: Map<string, PathTreeNode>;
+}
+export interface PathTreeInput {
+    /** Path string; absolute, cwd-relative, or url-like. Backslashes are normalized. */
+    path: string;
+    /** Whether the leaf itself is a directory (trailing-slash match from find). */
+    isDir: boolean;
+    /** Opaque key carried onto file events for section lookup. Defaults to `path`. */
+    key?: string;
+}
+/** One node emitted while walking the tree: a folded directory or a file leaf. */
+export interface GroupedTreeEvent {
+    kind: "dir" | "file";
+    /** 0-based nesting depth (root children are depth 0). */
+    depth: number;
+    /** Folded chain for dirs (e.g. `a/b/c`, no trailing slash); basename for files. */
+    name: string;
+    /** File key for `kind === "file"`; empty string for directories. */
+    key: string;
+}
+/**
+ * Build a directory tree from a flat list of paths. URL-like entries are kept
+ * whole as root-level file leaves (they have no meaningful directory structure).
+ * Absolute paths carry a leading empty segment so they share a common `/` root
+ * and fold like any other prefix.
+ */
+export declare function buildPathTree(entries: Iterable<PathTreeInput>): PathTreeNode;
+/**
+ * Depth-first walk yielding directory and file events. Directories collapse their
+ * single-child chains (`a` → `a/b` → `a/b/c`) so a shared prefix becomes one
+ * header. Each node's direct files are emitted before its subdirectories, keeping
+ * a file unambiguously attached to the header above it.
+ */
+export declare function walkPathTree(node: PathTreeNode, depth?: number): Generator<GroupedTreeEvent>;
+/**
+ * Render a flat path list as a grouped, prefix-folded directory tree without
+ * per-file bodies (find-tool output shape, also used by compaction `<files>`
+ * lists). Single-child directory chains fold into one header (`# a/b/c/`),
+ * each level adds one `#`, and files are listed bare under the deepest
+ * directory header that owns them. Trailing-slash entries are directory
+ * leaves and keep their slash in the header.
+ *
+ * `annotate` receives each file's full original path and its return value is
+ * appended verbatim to the file line (e.g. ` (RW)`).
+ *
+ * Order follows the input: a directory appears when its first member is
+ * emitted, and a node's own files precede its subdirectories.
+ */
+export declare function formatGroupedPaths(paths: readonly string[], annotate?: (path: string) => string): string;

package/dist/types/path.d.ts

@@ -0,0 +1,2 @@
+/** Removes Win32 extended-length prefixes before passing paths to Bun APIs. */
+export declare function stripWindowsExtendedLengthPathPrefix(filePath: string, platform?: NodeJS.Platform): string;

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

@@ -0,0 +1,29 @@
+/**
+ * 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>;
+/**
+ * Read up to the last `maxBytes` of `filePath` and pass that slice to `op`.
+ *
+ * The tail mirror of {@link peekFile}: same pooled-buffer strategy (no per-call
+ * allocation for small reads), but the read is positioned at `size - len` so the
+ * window ends at EOF. When the file is shorter than `maxBytes`, the whole file is
+ * returned. A multi-byte codepoint straddling the leading cut decodes to a
+ * replacement char — callers that parse line-oriented tails drop the partial
+ * leading line anyway.
+ */
+export declare function peekFileTail<T>(filePath: string, maxBytes: number, op: (tail: Uint8Array) => T): Promise<T>;
+/**
+ * Read up to the first `prefixBytes` and last `suffixBytes` of `filePath`, then
+ * pass both slices to `op`.
+ *
+ * Uses a single open/stat sequence. When the whole file fits in the head window,
+ * the tail is sliced from the already-read head bytes instead of issuing a
+ * second read.
+ */
+export declare function peekFileEnds<T>(filePath: string, prefixBytes: number, suffixBytes: number, op: (head: Uint8Array, tail: Uint8Array) => T): Promise<T>;

package/dist/types/postmortem.d.ts

@@ -0,0 +1,37 @@
+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"
+}
+/**
+ * Detect an EPIPE rejection that originated from an IPC `send()` to a worker
+ * subprocess (`syscall: "send"`), as opposed to a stdin/stdout pipe write
+ * (`syscall: "write"`). Only the IPC-send path can break an optional worker
+ * subsystem without affecting the main process, so only this shape is safe to
+ * swallow at the global `unhandledRejection` level. See issue #2997.
+ */
+export declare function isIpcSendEpipe(err: Error): boolean;
+/**
+ * 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

@@ -0,0 +1,29 @@
+import type { Subprocess } from "bun";
+export interface ShellConfig {
+    shell: string;
+    args: string[];
+    env: Record<string, string>;
+    prefix: string | undefined;
+}
+/**
+ * Check if a shell binary is executable.
+ */
+export declare function isExecutable(path: string): boolean;
+/**
+ * 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

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

@@ -0,0 +1,108 @@
+/**
+ * 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 {};

package/dist/types/ring.d.ts

@@ -0,0 +1,93 @@
+/**
+ * A fixed-capacity circular buffer that supports efficient push/pop/shift/unshift operations.
+ * When the buffer is full, adding new items overwrites the oldest items (FIFO behavior).
+ *
+ * @template T The type of elements stored in the buffer.
+ */
+export declare class RingBuffer<T> {
+    #private;
+    readonly capacity: number;
+    /**
+     * Creates a new ring buffer with the specified capacity.
+     *
+     * @param capacity - The maximum number of elements the buffer can hold. Must be positive.
+     */
+    constructor(capacity: number);
+    /**
+     * The number of elements currently in the buffer.
+     */
+    get length(): number;
+    /**
+     * Whether the buffer is at full capacity.
+     */
+    get isFull(): boolean;
+    /**
+     * Whether the buffer is empty (contains no elements).
+     */
+    get isEmpty(): boolean;
+    /**
+     * Adds an item to the end of the buffer.
+     * If the buffer is full, the oldest item is overwritten and returned.
+     *
+     * @param item - The item to add.
+     * @returns The overwritten item if the buffer was full, otherwise `undefined`.
+     */
+    push(item: T): T | undefined;
+    /**
+     * Removes and returns the first (oldest) item from the buffer.
+     *
+     * @returns The removed item, or `undefined` if the buffer is empty.
+     */
+    shift(): T | undefined;
+    /**
+     * Removes and returns the last (newest) item from the buffer.
+     *
+     * @returns The removed item, or `undefined` if the buffer is empty.
+     */
+    pop(): T | undefined;
+    /**
+     * Adds an item to the beginning of the buffer.
+     * If the buffer is full, the newest item is overwritten and returned.
+     *
+     * @param item - The item to add.
+     * @returns The overwritten item if the buffer was full, otherwise `undefined`.
+     */
+    unshift(item: T): T | undefined;
+    /**
+     * Returns the element at the specified index without removing it.
+     * Supports negative indices (e.g., `-1` for the last element).
+     *
+     * @param index - The zero-based index, or negative index from the end.
+     * @returns The element at the index, or `undefined` if the index is out of bounds.
+     */
+    at(index: number): T | undefined;
+    /**
+     * Returns the first (oldest) element without removing it.
+     *
+     * @returns The first element, or `undefined` if the buffer is empty.
+     */
+    peek(): T | undefined;
+    /**
+     * Returns the last (newest) element without removing it.
+     *
+     * @returns The last element, or `undefined` if the buffer is empty.
+     */
+    peekBack(): T | undefined;
+    /**
+     * Removes all elements from the buffer, resetting it to an empty state.
+     */
+    clear(): void;
+    /**
+     * Returns an iterator that yields elements in logical order (oldest to newest).
+     * Allows the buffer to be used with `for...of` loops and spread syntax.
+     *
+     * @yields Elements in FIFO order.
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Creates a new array containing all elements in logical order (oldest to newest).
+     *
+     * @returns A new array with all buffer elements.
+     */
+    toArray(): T[];
+}

package/dist/types/runtime-install.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Walk a conditional `exports` target (string, array of fallbacks, or a
+ * condition object) and return the first relative path that matches a runtime
+ * condition in declaration order. Returns `null` when nothing applies (e.g.
+ * an `import`-only entry).
+ */
+export declare function selectConditionalTarget(target: unknown): string | null;
+/**
+ * Split a bare specifier into its package name and optional subpath, handling
+ * scoped packages (`@scope/name/sub` → `@scope/name` + `sub`).
+ */
+export declare function splitBareSpecifier(specifier: string): {
+    packageName: string;
+    subpath: string | undefined;
+};
+/**
+ * Resolve a bare specifier against an installed `node_modules` directory,
+ * honoring `exports` (CommonJS conditions), then `main`, then `index.js`.
+ * Returns an absolute file path, or `null` when the package/entry is absent.
+ */
+export declare function resolveRuntimeModule(runtimeNodeModules: string, specifier: string): string | null;
+export interface RuntimeResolverOptions {
+    /** Absolute path to the runtime cache's `node_modules`. */
+    runtimeNodeModules: string;
+    /** Bare specifier → absolute file path overrides (e.g. `sharp` → no-op stub). */
+    stubs?: Record<string, string>;
+}
+/**
+ * Patch `node:module`'s resolver (idempotently) so bare specifiers that the
+ * stock compiled-binary resolver cannot find fall back to the registered
+ * runtime caches. Stock resolution is tried first and kept for anything
+ * outside the registered roots (bundled imports, node builtins, host or
+ * extension trees). Multiple runtime roots may register; they are consulted
+ * in registration order.
+ *
+ * One stock "success" is distrusted: the compiled-binary resolver ignores
+ * `main`/`exports` for real-FS packages (Bun #1763), so a package shipping
+ * its TS source next to `dist/` (e.g. `@huggingface/hub`'s root `index.ts`)
+ * resolves to the wrong file. When the stock hit lands inside a registered
+ * runtime root, the manifest-aware resolution wins.
+ */
+export declare function installRuntimeModuleResolver({ runtimeNodeModules, stubs }: RuntimeResolverOptions): void;
+/** Pinned dependency set materialized into a runtime cache directory. */
+export interface RuntimeInstallSpec {
+    dependencies: Record<string, string>;
+    /** Version pins forced across the whole runtime tree (bun `overrides`), e.g. dislodging a transitive dep. */
+    overrides?: Record<string, string>;
+    /** Packages whose lifecycle scripts bun may run during the install. */
+    trustedDependencies?: string[];
+}
+export type RuntimeInstallPhase = "initiate" | "download" | "done";
+export interface EnsureRuntimeInstalledOptions {
+    /** Directory owning the runtime `package.json` + `node_modules`. */
+    runtimeDir: string;
+    install: RuntimeInstallSpec;
+    /** Package whose installed manifest marks the runtime complete; defaults to the first dependency. */
+    probePackage?: string;
+    /** Phase notifications (progress UI); not emitted when already installed. */
+    onPhase?: (phase: RuntimeInstallPhase) => void;
+    lockAttempts?: number;
+    lockSleepMs?: number;
+}
+export declare function writeRuntimeManifest(runtimeDir: string, install: RuntimeInstallSpec): Promise<void>;
+/**
+ * Materialize a pinned dependency set into `runtimeDir` (idempotent,
+ * cross-process safe via a lock directory). Returns `runtimeDir`.
+ */
+export declare function ensureRuntimeInstalled(options: EnsureRuntimeInstalledOptions): Promise<string>;

package/dist/types/sanitize-text.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Strip ANSI escape sequences, remove control characters / lone surrogates,
+ * and normalize line endings.
+ *
+ * Bun-native implementation of the former native `sanitizeText` (see
+ * `crates/pi-natives/src/text.rs::sanitize_text`). JavaScript strings are
+ * already UTF-16 code-unit arrays. `toWellFormed()` handles the uncommon
+ * malformed path; when it changes the input, replacement characters are
+ * dropped and the normalized result goes through the well-formed sanitizer.
+ *
+ * Fast path: well-formed input with no controls or ANSI returns the original
+ * string after the control probe.
+ */
+export declare function sanitizeText(text: string): string;
+/**
+ * Escape the three XML-significant characters (`&`, `<`, `>`) in text destined
+ * for an XML/markup element body. Allocation-conscious: returns the input
+ * unchanged (same reference) when nothing needs escaping. Quotes are left as-is
+ * — use it for element text, not attribute values.
+ */
+export declare function escapeXmlText(input: string): string;
+/**
+ * Escape XML-significant characters for an attribute VALUE: the three body
+ * characters (`&`, `<`, `>`) plus the double quote (`"` → `&quot;`) that would
+ * otherwise close the attribute. Allocation-conscious: returns the input
+ * unchanged (same reference) when nothing needs escaping. Use it for attribute
+ * values; {@link escapeXmlText} is for element bodies and leaves `"` intact.
+ */
+export declare function escapeXmlAttribute(input: string): string;

package/dist/types/snowflake.d.ts

@@ -0,0 +1,25 @@
+type Snowflake = string & {
+    readonly __brand: unique symbol;
+};
+declare namespace Snowflake {
+    const PATTERN: RegExp;
+    const EPOCH_TIMESTAMP = 1420070400000;
+    const MAX_SEQUENCE = 4194303;
+    function formatParts(dt: number, seq: number): Snowflake;
+    class Source {
+        #private;
+        constructor(sequence?: number);
+        get sequence(): number;
+        set sequence(v: number);
+        reset(): void;
+        generate(timestamp: number): Snowflake;
+    }
+    function next(timestamp?: number): Snowflake;
+    function valid(value: string): value is Snowflake;
+    function lowerbound(timelike: Date | number | Snowflake): Snowflake;
+    function upperbound(timelike: Date | number | Snowflake): Snowflake;
+    function getSequence(value: Snowflake): number;
+    function getTimestamp(value: Snowflake): number;
+    function getDate(value: Snowflake): Date;
+}
+export { Snowflake };