@prometheus-ai/utils 0.5.4 → 0.5.8

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.5.8] - 2026-06-14
+
+### Fixed
+
+- Fixed runtime module resolution so bare imports made by runtime-cache parents
+  stay inside the runtime cache before falling back to bundled or host modules.
+
+## [0.5.0] - 2026-06-11
+
+- Establish Prometheus public baseline for the package.

package/README.md

@@ -0,0 +1,36 @@
+# @prometheus-ai/utils
+
+Shared utilities for Prometheus packages. Bun-first, small, and used across the agent runtime.
+
+## Notable modules
+
+| Module | Purpose |
+| --- | --- |
+| `logger` | Centralized logger writing to `~/.prometheus/logs/` with rotation and TUI-safe output |
+| `prompt` | Handlebars-based prompt templating and formatting helpers |
+| `dirs` | Path helpers for Prometheus config directories (`~/.prometheus`, XDG-aware on Linux) |
+| `stream` | `readStream` and `readLines` helpers over `ReadableStream` |
+| `ptree` / `procmgr` | Process trees, `ChildProcess` wrapper, and process lifecycle management |
+| `postmortem` | Cleanup callbacks on exit, signals, and fatal exceptions |
+| `which` | `$which()` binary lookup with caching |
+| `fetch-retry` | `fetch` with retry/backoff policies |
+| `fs-error` | Errno guards such as `isEnoent` |
+| `env` | Environment plumbing and worker-host entry contract (`workerHostEntry`) |
+| `abortable` / `async` | AbortSignal-aware stream and promise helpers |
+| `peek-file` | Read the first N bytes of a file with pooled buffers |
+| `frontmatter`, `glob`, `mime`, `temp`, `format`, `color`, `snowflake`, `tab-spacing`, `path-tree`, `sanitize-text` | Smaller single-purpose helpers |
+
+Import from the root barrel or per-module subpaths (`@prometheus-ai/utils/<module>`).
+
+## Install
+
+```sh
+bun add @prometheus-ai/utils
+```
+
+Ships TypeScript source directly and requires Bun 1.3.14 or newer.
+
+## References
+
+- [Prometheus README](https://github.com/uttamtrivedi/Prometheus#readme)
+- [CHANGELOG](./CHANGELOG.md)

package/dist/types/abortable.d.ts

@@ -4,6 +4,11 @@ export declare class AbortError extends Error {
 /**
  * Creates an abortable stream from a given stream and signal.
  *
+ * Unlike `stream.pipeThrough(..., { signal })`, this explicitly cancels the
+ * source reader when the signal aborts. That propagates HTTP-client disconnects
+ * and stream watchdog timeouts all the way to the backend request instead of
+ * only stopping the local consumer.
+ *
  * @param stream - The stream to make abortable
  * @param signal - The signal to abort the stream
  * @returns The abortable stream

package/dist/types/dirs.d.ts

@@ -105,6 +105,8 @@ export declare function getGithubCacheDbPath(): string;
 export declare function getAuthBrokerSnapshotCachePath(): string;
 /** Get the local FastEmbed model cache directory (~/.prometheus/cache/fastembed). */
 export declare function getFastembedCacheDir(): string;
+/** Get the on-demand FastEmbed runtime install root (~/.prometheus/cache/fastembed-runtime). */
+export declare function getFastembedRuntimeDir(): string;
 /** Get the natives directory (~/.prometheus/natives). */
 export declare function getNativesDir(): string;
 /** Get the stats database path (~/.prometheus/stats.db). */
@@ -119,6 +121,8 @@ export declare function getAutoresearchDbPath(encodedProject: string): string;
 export declare function getAutoresearchRunDir(encodedProject: string, runId: number): string;
 /** Get the path to agent.db (SQLite database for settings and auth storage). */
 export declare function getAgentDbPath(agentDir?: string): string;
+/** Get the last-seen-changelog-version marker file (~/.prometheus/agent/last-changelog-version). */
+export declare function getLastChangelogVersionPath(agentDir?: string): string;
 /** Get the path to history.db (SQLite database for session history). */
 export declare function getHistoryDbPath(agentDir?: string): string;
 /** Get the path to models.db (model cache database). */

package/dist/types/env.d.ts

@@ -52,4 +52,8 @@ export declare function isBunTestRuntime(): boolean;
  * first for cheap fast-path detection.
  */
 export declare function isCompiledBinary(): boolean;
+/** Called by CLI entrypoints whose main module dispatches worker argv selectors. */
+export declare function declareWorkerHostEntry(): void;
+/** Main-module path of the self-dispatching CLI host, or null outside it. */
+export declare function workerHostEntry(): string | null;
 export declare function $flag(name: string, def?: boolean): boolean;

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

@@ -43,6 +43,14 @@ export interface FetchWithRetryOptions extends RequestInit {
      * mock during tests.
      */
     fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+    /**
+     * Bun extension forwarded verbatim to the underlying `fetch` call. `false`
+     * disables Bun's native ~300s pre-response timeout (callers that own a
+     * configurable first-event/idle watchdog or an external `AbortSignal`
+     * supply this so the runtime ceiling cannot pre-empt them); a positive
+     * number sets a custom ceiling in ms. Bare browser/Node fetch ignores it.
+     */
+    timeout?: number | false;
 }
 /**
  * Fetch with bounded retries and sensible defaults. Retries on any

package/dist/types/index.d.ts

@@ -11,14 +11,17 @@ export * from "./glob";
 export * from "./hook-fetch";
 export * from "./json";
 export * as logger from "./logger";
+export * from "./loop-phase";
 export * from "./mermaid-ascii";
 export * from "./mime";
+export * from "./path-tree";
 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 "./runtime-install";
 export * from "./sanitize-text";
 export * from "./snowflake";
 export * from "./stream";

package/dist/types/logger.d.ts

@@ -31,6 +31,17 @@ export declare function info(message: string, context?: Record<string, unknown>)
  * @param context - The context to log.
  */
 export declare function debug(message: string, context?: Record<string, unknown>): void;
+/**
+ * Streaming startup markers, enabled by `PROMETHEUS_DEBUG_STARTUP`. Unlike the
+ * PROMETHEUS_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.
@@ -39,20 +50,26 @@ export declare function debug(message: string, context?: Record<string, unknown>
 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.
+ * 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 the module-load timing plugin to splice load
- * events into the tree retroactively.
+ * 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): void;
+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)

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/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/procmgr.d.ts

@@ -5,6 +5,10 @@ export interface ShellConfig {
     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.
  */

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/tab-spacing.d.ts

@@ -7,3 +7,19 @@ export declare function setDefaultTabWidth(width: number): void;
  * Visible tab width in columns for `file` (from `.editorconfig` + default), or the default when `file` is omitted.
  */
 export declare function getIndentation(file?: string | null, projectDir?: string | null): number;
+/**
+ * `.editorconfig`-derived formatting options for an LSP `textDocument/formatting` request.
+ *
+ * Both fields are absent when the resolved `.editorconfig` chain does not pin them, so callers
+ * can layer their own fallbacks underneath.
+ */
+export interface EditorConfigFormatting {
+    /** Effective indent width in columns, from `indent_size` or `tab_width`. */
+    tabSize?: number;
+    /** `true` for `indent_style = space`, `false` for `indent_style = tab` or `indent_size = tab`. */
+    insertSpaces?: boolean;
+}
+/**
+ * Resolve `.editorconfig` formatting hints for `file` without falling back to any default.
+ */
+export declare function getEditorConfigFormatting(file?: string | null, projectDir?: string | null): EditorConfigFormatting;

package/dist/types/timing-buffer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared contract between the {@link module-timer} preload and {@link logger}'s
+ * timing tree. Kept in its own dependency-free module so the preload can import
+ * it without pulling in winston (via logger) and the logger can drain the buffer
+ * without importing the Bun-plugin preload.
+ */
+export interface ModuleLoadEvent {
+    /** Absolute or Bun-resolved module path. */
+    path: string;
+    /** `performance.now()` timestamp captured at Bun `onLoad` entry. */
+    start: number;
+    /** Inclusive module window: `onLoad` entry → appended final marker. */
+    durationMs: number;
+    /** Own top-level body / TLA time: prepended body marker → appended final marker. */
+    bodyMs?: number;
+    /** Resolved static children imported by this module. */
+    imports: string[];
+}
+/** The append-only buffer the preload pushes into (created on first access). */
+export declare function moduleLoadBuffer(): ModuleLoadEvent[];
+/** Drain and return all buffered events, leaving the buffer empty. */
+export declare function drainModuleLoadEvents(): ModuleLoadEvent[];

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@prometheus-ai/utils",
-	"version": "0.5.4",
+	"version": "0.5.8",
 	"description": "Shared utilities for Prometheus packages",
 	"homepage": "https://prometheus.trivlab.com",
 	"author": "Uttam Trivedi",
@@ -31,7 +31,7 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@prometheus-ai/natives": "0.5.4",
+		"@prometheus-ai/natives": "0.5.8",
 		"beautiful-mermaid": "^1.1.3",
 		"handlebars": "^4.7.9",
 		"winston": "^3.19.0",
@@ -45,6 +45,8 @@
 	},
 	"files": [
 		"src",
+		"README.md",
+		"CHANGELOG.md",
 		"dist/types"
 	],
 	"exports": {

package/src/abortable.ts

@@ -10,16 +10,101 @@ export class AbortError extends Error {
 	}
 }
 
+type AbortableStreamReadResult<T> = { done: true; value?: T } | { done: false; value: T };
+
+interface AbortableStreamReader<T> {
+	read(): Promise<AbortableStreamReadResult<T>>;
+	cancel(reason?: unknown): Promise<void>;
+	releaseLock(): void;
+}
+
 /**
  * Creates an abortable stream from a given stream and signal.
  *
+ * Unlike `stream.pipeThrough(..., { signal })`, this explicitly cancels the
+ * source reader when the signal aborts. That propagates HTTP-client disconnects
+ * and stream watchdog timeouts all the way to the backend request instead of
+ * only stopping the local consumer.
+ *
  * @param stream - The stream to make abortable
  * @param signal - The signal to abort the stream
  * @returns The abortable stream
  */
 export function createAbortableStream<T>(stream: ReadableStream<T>, signal?: AbortSignal): ReadableStream<T> {
 	if (!signal) return stream;
-	return stream.pipeThrough(new TransformStream<T, T>(), { signal });
+	let reader: AbortableStreamReader<T> | undefined;
+	let closed = false;
+	let onAbort: (() => void) | undefined;
+
+	const cleanup = () => {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+		onAbort = undefined;
+		const currentReader = reader;
+		reader = undefined;
+		try {
+			currentReader?.releaseLock();
+		} catch {}
+	};
+
+	const cancelReader = (reason: unknown): Promise<void> => {
+		if (closed) return Promise.resolve();
+		closed = true;
+		const currentReader = reader;
+		reader = undefined;
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+		onAbort = undefined;
+		if (!currentReader) return Promise.resolve();
+		return currentReader
+			.cancel(reason)
+			.catch(() => {})
+			.finally(() => {
+				try {
+					currentReader.releaseLock();
+				} catch {}
+			});
+	};
+
+	return new ReadableStream<T>({
+		start(controller) {
+			reader = stream.getReader();
+			onAbort = () => {
+				void cancelReader(signal.reason);
+				try {
+					controller.error(new AbortError(signal));
+				} catch {}
+			};
+			if (signal.aborted) {
+				onAbort();
+				return;
+			}
+			signal.addEventListener("abort", onAbort, { once: true });
+			void (async () => {
+				try {
+					for (;;) {
+						const currentReader = reader;
+						if (!currentReader) return;
+						const { value, done } = await currentReader.read();
+						if (closed) return;
+						if (done) {
+							closed = true;
+							cleanup();
+							controller.close();
+							return;
+						}
+						controller.enqueue(value);
+					}
+				} catch (error) {
+					if (closed) return;
+					closed = true;
+					cleanup();
+					controller.error(signal.aborted ? new AbortError(signal) : error);
+				}
+			})();
+		},
+		cancel(reason) {
+			return cancelReader(reason);
+		},
+	});
 }
 
 /**

package/src/dirs.ts

@@ -362,6 +362,11 @@ export function getFastembedCacheDir(): string {
 	return dirs.rootSubdir(path.join("cache", "fastembed"), "cache");
 }
 
+/** Get the on-demand FastEmbed runtime install root (~/.prometheus/cache/fastembed-runtime). */
+export function getFastembedRuntimeDir(): string {
+	return dirs.rootSubdir(path.join("cache", "fastembed-runtime"), "cache");
+}
+
 /** Get the natives directory (~/.prometheus/natives). */
 export function getNativesDir(): string {
 	return dirs.rootSubdir("natives", "cache");
@@ -401,6 +406,11 @@ export function getAgentDbPath(agentDir?: string): string {
 	return dirs.agentSubdir(agentDir, "agent.db", "data");
 }
 
+/** Get the last-seen-changelog-version marker file (~/.prometheus/agent/last-changelog-version). */
+export function getLastChangelogVersionPath(agentDir?: string): string {
+	return dirs.agentSubdir(agentDir, "last-changelog-version", "state");
+}
+
 /** Get the path to history.db (SQLite database for session history). */
 export function getHistoryDbPath(agentDir?: string): string {
 	return dirs.agentSubdir(agentDir, "history.db", "data");

package/src/env.ts

@@ -154,6 +154,23 @@ export function isCompiledBinary(): boolean {
 	return url.includes("$bunfs") || url.includes("~BUN") || url.includes("%7EBUN");
 }
 
+/**
+ * Main-module path declared by self-dispatching CLI entrypoints. Worker spawn
+ * sites re-enter this module via `new Worker(entry, { argv })`, so source,
+ * npm bundle, and compiled binary installs all share one host entrypoint.
+ */
+let workerHostMain: string | null = null;
+
+/** Called by CLI entrypoints whose main module dispatches worker argv selectors. */
+export function declareWorkerHostEntry(): void {
+	workerHostMain = Bun.main;
+}
+
+/** Main-module path of the self-dispatching CLI host, or null outside it. */
+export function workerHostEntry(): string | null {
+	return workerHostMain;
+}
+
 const TRUTHY: Dict<boolean> = {
 	"1": true,
 	Y: true,

package/src/fetch-retry.ts

@@ -129,6 +129,14 @@ export interface FetchWithRetryOptions extends RequestInit {
 	 * mock during tests.
 	 */
 	fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+	/**
+	 * Bun extension forwarded verbatim to the underlying `fetch` call. `false`
+	 * disables Bun's native ~300s pre-response timeout (callers that own a
+	 * configurable first-event/idle watchdog or an external `AbortSignal`
+	 * supply this so the runtime ceiling cannot pre-empt them); a positive
+	 * number sets a custom ceiling in ms. Bare browser/Node fetch ignores it.
+	 */
+	timeout?: number | false;
 }
 
 const DEFAULT_MAX_DELAY_MS = 60_000;

package/src/index.ts

@@ -11,14 +11,17 @@ export * from "./glob";
 export * from "./hook-fetch";
 export * from "./json";
 export * as logger from "./logger";
+export * from "./loop-phase";
 export * from "./mermaid-ascii";
 export * from "./mime";
+export * from "./path-tree";
 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 "./runtime-install";
 export * from "./sanitize-text";
 export * from "./snowflake";
 export * from "./stream";