@oh-my-pi/pi-utils 18.1.22 → 18.2.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [18.2.0] - 2026-09-15
+
+### Breaking Changes
+
+- Removed the unused `globPaths`, `loadGitignorePatterns`, and `GlobPathsOptions` exports.
+- Browser helpers now manage Chrome only: removed `Browser`, `BrowserTag`, `resolveBuildId()`, `getInstalledBrowsers()`, and `browser` options/metadata; `getDownloadUrl()` now takes `(platform, buildId, baseUrl?)`.
+
+### Added
+
+- Added `relativePathWithinNormalizedRoot()` for reusing canonical paths across containment checks.
+- Added `sleepLong()` and `MAX_TIMER_DELAY_MS`: an abortable sleep that chunks delays past the signed 32-bit timer ceiling so day-scale provider waits elapse instead of overflowing the timer.
+
+### Changed
+
+- Log-retention cleanup now runs after logger construction without keeping short-lived commands alive.
+- Debugger support now loads only when SIGUSR1 requests it.
+
+### Fixed
+
+- Fixed `extractRetryHint` dropping OpenCode Go's `Resets in …` quota window (`45min`, `2hr 15min`, `3 days`): the `reset in` pattern now accepts `Resets` phrasing, `hr`/`day` units, and compound `2hr 15min` remainders, so exhausted Go credentials block for the server-stated window instead of the 60s heuristic guess. ([#12091](https://github.com/can1357/oh-my-pi/pull/12091) by [@H4vC](https://github.com/H4vC))
+- Async file-peek callbacks now receive stable `Uint8Array` windows with copying `slice()` semantics.
+- Dotenv loading now handles multiline values and escapes consistently with Bun, preventing project values from leaking into child-shell environments.
+- SSE readers now support lone-CR line endings and CRLF split across chunks without merging or delaying events.
+
 ## [18.1.22] - 2026-09-14
 
 ### Fixed

package/THIRD-PARTY-NOTICES.txt

@@ -10843,7 +10843,7 @@ RUST RUNTIME DEPENDENCY LICENSES
 
 Generated from Cargo.lock by cargo-about 0.8.2 in locked, offline, workspace, all-feature, all-target mode, then restricted using cargo metadata to normal and build edges reachable from the workspace (development-only edges are excluded). cargo-deny independently evaluates the complete all-target graph.
 
-Native Opus (audiopus/audiopus_sys) and PCRE2 (pcre2/pcre2-sys) are covered by the exact crate license payloads below. inferno 0.12.8 is package-scoped as CDDL-1.0: its CDDL-covered source remains available in the locked crates.io source archive at https://crates.io/crates/inferno/0.12.8 and https://github.com/jonhoo/inferno. The full locked license text follows below.
+Native Opus (opus/opusic-sys) and PCRE2 (pcre2/pcre2-sys) are covered by the exact crate license payloads below. inferno 0.12.8 is package-scoped as CDDL-1.0: its CDDL-covered source remains available in the locked crates.io source archive at https://crates.io/crates/inferno/0.12.8 and https://github.com/jonhoo/inferno. The full locked license text follows below.
 
 -------------------------------------------------------------------------------
 License: Apache License 2.0 (Apache-2.0)
@@ -12509,6 +12509,58 @@ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+-------------------------------------------------------------------------------
+License: BSD 3-Clause "New" or "Revised" License (BSD-3-Clause)
+Used by:
+- opusic-sys 0.7.5 (https://github.com/DoumanAsh/opusic-sys)
+
+Full license text:
+
+Copyright 2001-2023 Xiph.Org, Skype Limited, Octasic,
+                    Jean-Marc Valin, Timothy B. Terriberry,
+                    CSIRO, Gregory Maxwell, Mark Borgerding,
+                    Erik de Castro Lopo, Mozilla, Amazon
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of Internet Society, IETF or IETF Trust, nor the
+names of specific contributors, may be used to endorse or promote
+products derived from this software without specific prior written
+permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Opus is subject to the royalty-free patent licenses which are
+specified at:
+
+Xiph.Org Foundation:
+https://datatracker.ietf.org/ipr/1524/
+
+Microsoft Corporation:
+https://datatracker.ietf.org/ipr/1914/
+
+Broadcom Corporation:
+https://datatracker.ietf.org/ipr/1526/
+
 -------------------------------------------------------------------------------
 License: BSD 3-Clause "New" or "Revised" License (BSD-3-Clause)
 Used by:
@@ -13290,29 +13342,6 @@ jurisdiction of the Federal Courts of the Northern District of
 California and the state courts of the State of California, with
 venue lying in Santa Clara County, California.
 
--------------------------------------------------------------------------------
-License: ISC License (ISC)
-Used by:
-- audiopus_sys 0.2.2 (https://github.com/lakelezz/audiopus_sys.git)
-
-Full license text:
-
-ISC License
-
-Copyright (c) 2019, Lakelezz
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
 -------------------------------------------------------------------------------
 License: ISC License (ISC)
 Used by:
@@ -18734,7 +18763,7 @@ DEALINGS IN THE SOFTWARE.
 -------------------------------------------------------------------------------
 License: MIT License (MIT)
 Used by:
-- opus 0.3.1 (https://github.com/SpaceManiac/opus-rs)
+- opus 0.4.0 (https://github.com/SpaceManiac/opus-rs)
 
 Full license text:
 

package/dist/types/async.d.ts

@@ -1,3 +1,28 @@
+/**
+ * Largest delay `setTimeout` (and `timers/promises` `scheduler.wait`)
+ * accepts without 32-bit signed overflow: larger values wrap and fire
+ * almost immediately instead of sleeping. Chunk day-scale provider waits
+ * (e.g. a monthly quota reset parsed from an error hint) so the full
+ * duration elapses instead of overflowing the timer.
+ */
+export declare const MAX_TIMER_DELAY_MS = 2147483647;
+/**
+ * Abortable sleep for arbitrarily long delays. Waits longer than
+ * {@link MAX_TIMER_DELAY_MS} chunk the sleep into back-to-back timer waits
+ * so no single timer overflows; an abort during any chunk rejects like
+ * `scheduler.wait`.
+ *
+ * The remainder is deliberately consumed by chunk, not recomputed from a
+ * monotonic deadline: deadline tracking never terminates under the repo's
+ * instant `scheduler.wait` mocks (retry-cap suites spy it to resolve
+ * immediately, so `deadline - performance.now()` never reaches zero and the
+ * loop spins forever). A premature native wake (Bun `uv_async_send`, see
+ * `sleepAtLeast` in `packages/agent/src/utils/yield.ts`) can therefore
+ * under-wait by the unelapsed chunk time — but that self-corrects downstream:
+ * credential blocks carry the true deadline independently of this sleep, so
+ * an early retry re-hits 429 and re-sleeps on a fresh server hint.
+ */
+export declare function sleepLong(delayMs: number, signal?: AbortSignal): Promise<void>;
 /**
  * Wrap a promise with a timeout and optional abort signal.
  * Rejects with the given error or a new error containing the given message if

package/dist/types/browsers.d.ts

@@ -1,12 +1,3 @@
-/** Behavior-compatible reimplementation of @puppeteer/browsers' used surface. */
-/** Supported browser products. */
-export declare enum Browser {
-    CHROME = "chrome",
-    CHROMEHEADLESSSHELL = "chrome-headless-shell",
-    CHROMIUM = "chromium",
-    FIREFOX = "firefox",
-    CHROMEDRIVER = "chromedriver"
-}
 /** Browser download platform identifiers. */
 export declare enum BrowserPlatform {
     LINUX = "linux",
@@ -16,17 +7,6 @@ export declare enum BrowserPlatform {
     WIN32 = "win32",
     WIN64 = "win64"
 }
-/** Chrome-for-Testing release channel tags accepted by {@link resolveBuildId}. */
-export declare enum BrowserTag {
-    CANARY = "canary",
-    NIGHTLY = "nightly",
-    BETA = "beta",
-    DEV = "dev",
-    DEVEDITION = "devedition",
-    STABLE = "stable",
-    ESR = "esr",
-    LATEST = "latest"
-}
 /** Download progress reported while a browser archive is streamed to disk. */
 export interface BrowserDownloadProgress {
     downloadedBytes: number;
@@ -34,7 +14,6 @@ export interface BrowserDownloadProgress {
 }
 /** Inputs used to locate an installed browser executable. */
 export interface ComputeExecutablePathOptions {
-    browser: Browser;
     buildId: string;
     cacheDir: string;
     platform?: BrowserPlatform;
@@ -44,9 +23,8 @@ export interface InstallOptions extends ComputeExecutablePathOptions {
     baseUrl?: string;
     downloadProgressCallback?: (progress: BrowserDownloadProgress) => void;
 }
-/** Metadata for one browser installation found in a Puppeteer cache. */
+/** Metadata for a managed Chrome installation in Puppeteer's cache layout. */
 export interface InstalledBrowser {
-    browser: Browser;
     buildId: string;
     platform: BrowserPlatform;
     path: string;
@@ -54,15 +32,9 @@ export interface InstalledBrowser {
 }
 /** Detect the current host's Puppeteer browser platform. */
 export declare function detectBrowserPlatform(): BrowserPlatform | undefined;
-/** Resolve a Chrome-for-Testing channel, milestone, or build prefix to a full build ID. */
-export declare function resolveBuildId(browser: Browser, _platform: BrowserPlatform, tag: string | BrowserTag): Promise<string>;
 /** Return the Chrome-for-Testing archive URL for a browser build. */
-export declare function getDownloadUrl(browser: Browser, platform: BrowserPlatform, buildId: string, baseUrl?: string): URL;
+export declare function getDownloadUrl(platform: BrowserPlatform, buildId: string, baseUrl?: string): URL;
 /** Compute the executable path in Puppeteer's cache layout. */
 export declare function computeExecutablePath(options: ComputeExecutablePathOptions): string;
-/** Scan a Puppeteer cache for browser installation directories. */
-export declare function getInstalledBrowsers(options: {
-    cacheDir: string;
-}): Promise<InstalledBrowser[]>;
 /** Download and unpack Chrome into Puppeteer's existing cache layout. */
 export declare function install(options: InstallOptions): Promise<InstalledBrowser>;

package/dist/types/dirs.d.ts

@@ -44,6 +44,16 @@ export declare function resolveProfileEnv(omp: string | undefined, pi: string |
 export declare function getBaseConfigRoot(): string;
 export declare function resolveEquivalentPath(inputPath: string): string;
 export declare function normalizePathForComparison(inputPath: string): string;
+/**
+ * Compare paths already normalized by {@link normalizePathForComparison}.
+ *
+ * Returns the relative path (an empty string when the paths are equal), or
+ * `null` when the candidate is outside the root. Callers classifying one
+ * candidate against several static roots can normalize each side once and
+ * reuse the public helpers' containment semantics without repeating realpath
+ * work.
+ */
+export declare function relativePathWithinNormalizedRoot(normalizedRoot: string, normalizedCandidate: string): string | null;
 export declare function pathIsWithin(root: string, candidate: string): boolean;
 export declare function relativePathWithinRoot(root: string, candidate: string): string | null;
 /** Get the project directory. */

package/dist/types/env.d.ts

@@ -29,8 +29,8 @@ export declare function filterProcessEnv(env: Record<string, string | undefined>
 /** Filters process env for child shells without launch-cwd dotenv values. */
 export declare function filterChildShellEnv(env: Record<string, string | undefined>, cwd?: string): Record<string, string>;
 /**
- * Parses a .env file synchronously into key-value string pairs using
- * {@link parseEnvLine} for Bun-compatible line semantics, then mirrors valid
+ * Parses a complete .env file with the runtime's dotenv grammar, then retains
+ * only shell-identifier names and spawn-safe values before mirroring valid
  * `OMP_` variables to their `PI_` aliases.
  */
 export declare function parseEnvFile(filePath: string): Record<string, string>;

package/dist/types/index.d.ts

@@ -9,7 +9,6 @@ export * from "./file-lock.js";
 export * from "./format.js";
 export * from "./frontmatter.js";
 export * from "./fs-error.js";
-export * from "./glob.js";
 export * from "./incoming-json.js";
 export * from "./json.js";
 export * from "./json-parse.js";

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

@@ -10,9 +10,8 @@ export declare function peekFile<T>(filePath: string, maxBytes: number, op: (hea
 /**
  * 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
+ * The tail mirror of {@link peekFile}: 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.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-utils",
-	"version": "18.1.22",
+	"version": "18.2.0",
 	"description": "Shared utilities for pi packages",
 	"keywords": [
 		"cli",
@@ -54,7 +54,7 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "18.1.22"
+		"@oh-my-pi/pi-natives": "18.2.0"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/async.ts

@@ -1,3 +1,40 @@
+import { scheduler } from "node:timers/promises";
+
+/**
+ * Largest delay `setTimeout` (and `timers/promises` `scheduler.wait`)
+ * accepts without 32-bit signed overflow: larger values wrap and fire
+ * almost immediately instead of sleeping. Chunk day-scale provider waits
+ * (e.g. a monthly quota reset parsed from an error hint) so the full
+ * duration elapses instead of overflowing the timer.
+ */
+export const MAX_TIMER_DELAY_MS = 2_147_483_647;
+
+/**
+ * Abortable sleep for arbitrarily long delays. Waits longer than
+ * {@link MAX_TIMER_DELAY_MS} chunk the sleep into back-to-back timer waits
+ * so no single timer overflows; an abort during any chunk rejects like
+ * `scheduler.wait`.
+ *
+ * The remainder is deliberately consumed by chunk, not recomputed from a
+ * monotonic deadline: deadline tracking never terminates under the repo's
+ * instant `scheduler.wait` mocks (retry-cap suites spy it to resolve
+ * immediately, so `deadline - performance.now()` never reaches zero and the
+ * loop spins forever). A premature native wake (Bun `uv_async_send`, see
+ * `sleepAtLeast` in `packages/agent/src/utils/yield.ts`) can therefore
+ * under-wait by the unelapsed chunk time — but that self-corrects downstream:
+ * credential blocks carry the true deadline independently of this sleep, so
+ * an early retry re-hits 429 and re-sleeps on a fresh server hint.
+ */
+export async function sleepLong(delayMs: number, signal?: AbortSignal): Promise<void> {
+	signal?.throwIfAborted();
+	let remaining = delayMs;
+	while (remaining > 0) {
+		await scheduler.wait(Math.min(remaining, MAX_TIMER_DELAY_MS), { signal });
+		remaining -= MAX_TIMER_DELAY_MS;
+		signal?.throwIfAborted();
+	}
+}
+
 /**
  * Wrap a promise with a timeout and optional abort signal.
  * Rejects with the given error or a new error containing the given message if

package/src/browsers.ts

@@ -1,6 +1,4 @@
-/** Behavior-compatible reimplementation of @puppeteer/browsers' used surface. */
-
-import type * as fs from "node:fs";
+/** Managed Chrome-for-Testing installation with bounded downloads and atomic publication. */
 import * as fsp from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -8,7 +6,6 @@ import { type ArchiveLimits, extractArchive } from "./ar";
 import { withFileLock } from "./file-lock";
 
 const CHROME_FOR_TESTING_BASE_URL = "https://storage.googleapis.com/chrome-for-testing-public";
-const CHROME_METADATA_BASE_URL = "https://googlechromelabs.github.io/chrome-for-testing";
 // Installation is outside browser/Eval operation deadlines, but a stalled CDN
 // must still release the cached install promise and permit a later attempt.
 const DOWNLOAD_TIMEOUT_MS = 5 * 60_000;
@@ -25,15 +22,6 @@ const BROWSER_ARCHIVE_LIMITS: Partial<ArchiveLimits> = {
 	maxInMemorySize: 1024 * 1024 * 1024,
 };
 
-/** Supported browser products. */
-export enum Browser {
-	CHROME = "chrome",
-	CHROMEHEADLESSSHELL = "chrome-headless-shell",
-	CHROMIUM = "chromium",
-	FIREFOX = "firefox",
-	CHROMEDRIVER = "chromedriver",
-}
-
 /** Browser download platform identifiers. */
 export enum BrowserPlatform {
 	LINUX = "linux",
@@ -51,34 +39,6 @@ function requireChromeForTestingPlatform(platform: BrowserPlatform): ChromeForTe
 	return platform;
 }
 
-const BROWSERS = [
-	Browser.CHROME,
-	Browser.CHROMEHEADLESSSHELL,
-	Browser.CHROMIUM,
-	Browser.FIREFOX,
-	Browser.CHROMEDRIVER,
-] as const;
-const BROWSER_PLATFORMS = [
-	BrowserPlatform.LINUX,
-	BrowserPlatform.LINUX_ARM,
-	BrowserPlatform.MAC,
-	BrowserPlatform.MAC_ARM,
-	BrowserPlatform.WIN32,
-	BrowserPlatform.WIN64,
-] as const;
-
-/** Chrome-for-Testing release channel tags accepted by {@link resolveBuildId}. */
-export enum BrowserTag {
-	CANARY = "canary",
-	NIGHTLY = "nightly",
-	BETA = "beta",
-	DEV = "dev",
-	DEVEDITION = "devedition",
-	STABLE = "stable",
-	ESR = "esr",
-	LATEST = "latest",
-}
-
 /** Download progress reported while a browser archive is streamed to disk. */
 export interface BrowserDownloadProgress {
 	downloadedBytes: number;
@@ -87,7 +47,6 @@ export interface BrowserDownloadProgress {
 
 /** Inputs used to locate an installed browser executable. */
 export interface ComputeExecutablePathOptions {
-	browser: Browser;
 	buildId: string;
 	cacheDir: string;
 	platform?: BrowserPlatform;
@@ -99,27 +58,14 @@ export interface InstallOptions extends ComputeExecutablePathOptions {
 	downloadProgressCallback?: (progress: BrowserDownloadProgress) => void;
 }
 
-/** Metadata for one browser installation found in a Puppeteer cache. */
+/** Metadata for a managed Chrome installation in Puppeteer's cache layout. */
 export interface InstalledBrowser {
-	browser: Browser;
 	buildId: string;
 	platform: BrowserPlatform;
 	path: string;
 	executablePath: string;
 }
 
-interface LastKnownGoodVersions {
-	channels: Record<string, { version: string }>;
-}
-
-interface MilestoneVersions {
-	milestones: Record<string, { version: string }>;
-}
-
-interface PatchVersions {
-	builds: Record<string, { version: string }>;
-}
-
 /** Detect the current host's Puppeteer browser platform. */
 export function detectBrowserPlatform(): BrowserPlatform | undefined {
 	const platform = os.platform();
@@ -130,43 +76,8 @@ export function detectBrowserPlatform(): BrowserPlatform | undefined {
 	return undefined;
 }
 
-/** Resolve a Chrome-for-Testing channel, milestone, or build prefix to a full build ID. */
-export async function resolveBuildId(
-	browser: Browser,
-	_platform: BrowserPlatform,
-	tag: string | BrowserTag,
-): Promise<string> {
-	if (browser !== Browser.CHROME && browser !== Browser.CHROMEHEADLESSSHELL && browser !== Browser.CHROMEDRIVER) {
-		return tag;
-	}
-	if (/^\d+\.\d+\.\d+\.\d+$/.test(tag)) return tag;
-
-	const channel = tag === BrowserTag.LATEST ? "Canary" : chromeChannelName(tag);
-	if (channel) {
-		const metadata = await fetchMetadata<LastKnownGoodVersions>("last-known-good-versions.json");
-		const version = metadata.channels[channel]?.version;
-		if (!version) throw new Error(`Chrome channel ${tag} was not found in Chrome-for-Testing metadata`);
-		return version;
-	}
-	if (/^\d+$/.test(tag)) {
-		const metadata = await fetchMetadata<MilestoneVersions>("latest-versions-per-milestone.json");
-		return metadata.milestones[tag]?.version ?? tag;
-	}
-	if (/^\d+\.\d+\.\d+$/.test(tag)) {
-		const metadata = await fetchMetadata<PatchVersions>("latest-patch-versions-per-build.json");
-		return metadata.builds[tag]?.version ?? tag;
-	}
-	return tag;
-}
-
 /** Return the Chrome-for-Testing archive URL for a browser build. */
-export function getDownloadUrl(
-	browser: Browser,
-	platform: BrowserPlatform,
-	buildId: string,
-	baseUrl = CHROME_FOR_TESTING_BASE_URL,
-): URL {
-	if (browser !== Browser.CHROME) throw new Error(`Unsupported browser download: ${browser}`);
+export function getDownloadUrl(platform: BrowserPlatform, buildId: string, baseUrl = CHROME_FOR_TESTING_BASE_URL): URL {
 	const archivePlatform = chromeArchivePlatform(platform);
 	const root = baseUrl.replace(/\/$/, "");
 	return new URL(`${root}/${buildId}/${archivePlatform}/chrome-${archivePlatform}.zip`);
@@ -176,9 +87,8 @@ export function getDownloadUrl(
 export function computeExecutablePath(options: ComputeExecutablePathOptions): string {
 	const detectedPlatform = options.platform ?? detectBrowserPlatform();
 	if (!detectedPlatform) throw new Error("Cannot determine a browser platform for this host");
-	if (options.browser !== Browser.CHROME) throw new Error(`Unsupported browser executable: ${options.browser}`);
 	const platform = requireChromeForTestingPlatform(detectedPlatform);
-	const installDir = installationDir(options.cacheDir, options.browser, platform, options.buildId);
+	const installDir = installationDir(options.cacheDir, platform, options.buildId);
 	switch (platform) {
 		case BrowserPlatform.LINUX:
 			return path.join(installDir, "chrome-linux64", "chrome");
@@ -207,52 +117,14 @@ export function computeExecutablePath(options: ComputeExecutablePathOptions): st
 	}
 }
 
-/** Scan a Puppeteer cache for browser installation directories. */
-export async function getInstalledBrowsers(options: { cacheDir: string }): Promise<InstalledBrowser[]> {
-	const installed: InstalledBrowser[] = [];
-	for (const browser of BROWSERS) {
-		const browserDir = path.join(options.cacheDir, browser);
-		let entries: fs.Dirent[];
-		try {
-			entries = await fsp.readdir(browserDir, { withFileTypes: true });
-		} catch (error) {
-			if (isMissingPath(error)) continue;
-			throw error;
-		}
-		for (const entry of entries) {
-			if (!entry.isDirectory()) continue;
-			const parsed = parseInstallationName(entry.name);
-			if (!parsed) continue;
-			const installPath = path.join(browserDir, entry.name);
-			try {
-				installed.push({
-					browser,
-					buildId: parsed.buildId,
-					platform: parsed.platform,
-					path: installPath,
-					executablePath: computeExecutablePath({
-						browser,
-						buildId: parsed.buildId,
-						cacheDir: options.cacheDir,
-						platform: parsed.platform,
-					}),
-				});
-			} catch {
-				// Other browser products are not part of the surface used by OMP.
-			}
-		}
-	}
-	return installed;
-}
-
 /** Download and unpack Chrome into Puppeteer's existing cache layout. */
 export async function install(options: InstallOptions): Promise<InstalledBrowser> {
 	const platform = options.platform ?? detectBrowserPlatform();
 	if (!platform) throw new Error("Cannot determine a browser platform for this host");
 	const executablePath = computeExecutablePath({ ...options, platform });
-	const installPath = installationDir(options.cacheDir, options.browser, platform, options.buildId);
+	const installPath = installationDir(options.cacheDir, platform, options.buildId);
 	if (await pathExists(executablePath)) {
-		return { browser: options.browser, buildId: options.buildId, platform, path: installPath, executablePath };
+		return { buildId: options.buildId, platform, path: installPath, executablePath };
 	}
 
 	await fsp.mkdir(path.dirname(installPath), { recursive: true });
@@ -267,7 +139,7 @@ export async function install(options: InstallOptions): Promise<InstalledBrowser
 				const stagingPath = path.join(options.cacheDir, `.browser-${nonce}`);
 				try {
 					await downloadArchive(
-						getDownloadUrl(options.browser, platform, options.buildId, options.baseUrl),
+						getDownloadUrl(platform, options.buildId, options.baseUrl),
 						archivePath,
 						options.downloadProgressCallback,
 					);
@@ -284,34 +156,12 @@ export async function install(options: InstallOptions): Promise<InstalledBrowser
 					]);
 				}
 			}
-			return { browser: options.browser, buildId: options.buildId, platform, path: installPath, executablePath };
+			return { buildId: options.buildId, platform, path: installPath, executablePath };
 		},
 		{ retries: Math.ceil(DOWNLOAD_TIMEOUT_MS / 100) + 1, retryDelayMs: 100 },
 	);
 }
 
-function chromeChannelName(tag: string): string | undefined {
-	switch (tag) {
-		case BrowserTag.STABLE:
-			return "Stable";
-		case BrowserTag.BETA:
-			return "Beta";
-		case BrowserTag.DEV:
-			return "Dev";
-		case BrowserTag.CANARY:
-			return "Canary";
-		default:
-			return undefined;
-	}
-}
-
-async function fetchMetadata<T>(filename: string): Promise<T> {
-	const response = await fetch(`${CHROME_METADATA_BASE_URL}/${filename}`, { signal: AbortSignal.timeout(30_000) });
-	if (!response.ok)
-		throw new Error(`Failed to fetch Chrome-for-Testing metadata (${response.status} ${response.statusText})`);
-	return (await response.json()) as T;
-}
-
 function chromeArchivePlatform(platform: BrowserPlatform): string {
 	switch (requireChromeForTestingPlatform(platform)) {
 		case BrowserPlatform.LINUX:
@@ -327,17 +177,8 @@ function chromeArchivePlatform(platform: BrowserPlatform): string {
 	}
 }
 
-function installationDir(cacheDir: string, browser: Browser, platform: BrowserPlatform, buildId: string): string {
-	return path.join(cacheDir, browser, `${platform}-${buildId}`);
-}
-
-function parseInstallationName(name: string): { platform: BrowserPlatform; buildId: string } | undefined {
-	for (const platform of BROWSER_PLATFORMS) {
-		const prefix = `${platform}-`;
-		if (name.startsWith(prefix) && name.length > prefix.length)
-			return { platform, buildId: name.slice(prefix.length) };
-	}
-	return undefined;
+function installationDir(cacheDir: string, platform: BrowserPlatform, buildId: string): string {
+	return path.join(cacheDir, "chrome", `${platform}-${buildId}`);
 }
 
 function isMissingPath(error: unknown): boolean {

package/src/dirs.ts

@@ -165,19 +165,31 @@ export function normalizePathForComparison(inputPath: string): string {
 	return process.platform === "win32" ? resolvedPath.toLowerCase() : resolvedPath;
 }
 
+/**
+ * Compare paths already normalized by {@link normalizePathForComparison}.
+ *
+ * Returns the relative path (an empty string when the paths are equal), or
+ * `null` when the candidate is outside the root. Callers classifying one
+ * candidate against several static roots can normalize each side once and
+ * reuse the public helpers' containment semantics without repeating realpath
+ * work.
+ */
+export function relativePathWithinNormalizedRoot(normalizedRoot: string, normalizedCandidate: string): string | null {
+	const relative = path.relative(normalizedRoot, normalizedCandidate);
+	if (relative !== "" && (relative.startsWith("..") || path.isAbsolute(relative))) return null;
+	return relative;
+}
+
 export function pathIsWithin(root: string, candidate: string): boolean {
 	const normalizedRoot = normalizePathForComparison(root);
 	const normalizedCandidate = normalizePathForComparison(candidate);
-	const relative = path.relative(normalizedRoot, normalizedCandidate);
-	return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+	return relativePathWithinNormalizedRoot(normalizedRoot, normalizedCandidate) !== null;
 }
 
 export function relativePathWithinRoot(root: string, candidate: string): string | null {
-	if (!pathIsWithin(root, candidate)) return null;
 	const normalizedRoot = normalizePathForComparison(root);
 	const normalizedCandidate = normalizePathForComparison(candidate);
-	const relative = path.relative(normalizedRoot, normalizedCandidate);
-	return relative || null;
+	return relativePathWithinNormalizedRoot(normalizedRoot, normalizedCandidate) || null;
 }
 
 let projectDir: string | undefined;

package/src/env.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { parseEnv } from "node:util";
 import { getAgentDir, getConfigRootDir, getProjectDir, refreshDirsFromEnv } from "./dirs";
 
 export * from "./worker-host";
@@ -184,44 +185,17 @@ export function filterChildShellEnv(
 }
 
 /**
- * Parse one dotenv line with Bun-compatible semantics: an optional `export`
- * prefix, full-line `#` comments, inline `#` comments after whitespace on
- * unquoted values, and single/double/backtick quoting (a `#` inside quotes
- * stays literal). Returns undefined for blank lines, comments, and malformed
- * names.
- */
-function parseEnvLine(line: string): { key: string; value: string } | undefined {
-	const trimmed = line.trim();
-	if (!trimmed || trimmed.startsWith("#")) return undefined;
-	const eqIndex = trimmed.indexOf("=");
-	if (eqIndex === -1) return undefined;
-	let key = trimmed.slice(0, eqIndex).trim();
-	const exported = key.match(/^export[ \t]+(.*)$/);
-	if (exported) key = exported[1].trim();
-	if (!isValidEnvName(key)) return undefined;
-	const raw = trimmed.slice(eqIndex + 1).replace(/^[ \t]+/, "");
-	const quote = raw[0];
-	if (quote === '"' || quote === "'" || quote === "`") {
-		let close = raw.indexOf(quote, 1);
-		while (close !== -1 && raw[close - 1] === "\\") close = raw.indexOf(quote, close + 1);
-		return { key, value: close === -1 ? raw.slice(1) : raw.slice(1, close) };
-	}
-	const commentIndex = raw.search(/[ \t]#/);
-	return { key, value: (commentIndex === -1 ? raw : raw.slice(0, commentIndex)).trimEnd() };
-}
-
-/**
- * Parses a .env file synchronously into key-value string pairs using
- * {@link parseEnvLine} for Bun-compatible line semantics, then mirrors valid
+ * Parses a complete .env file with the runtime's dotenv grammar, then retains
+ * only shell-identifier names and spawn-safe values before mirroring valid
  * `OMP_` variables to their `PI_` aliases.
  */
 export function parseEnvFile(filePath: string): Record<string, string> {
 	const result: Record<string, string> = {};
 	try {
-		const content = fs.readFileSync(filePath, "utf-8");
-		for (const line of content.split("\n")) {
-			const parsed = parseEnvLine(line);
-			if (parsed && isSafeEnvValue(parsed.value)) result[parsed.key] = parsed.value;
+		const parsed = parseEnv(fs.readFileSync(filePath, "utf-8"));
+		for (const key in parsed) {
+			const value = parsed[key];
+			if (value !== undefined && isValidEnvName(key) && isSafeEnvValue(value)) result[key] = value;
 		}
 	} catch {
 		// File doesn't exist or can't be read - return empty result

package/src/fetch-retry.ts

@@ -11,7 +11,12 @@ const RETRY_DELAY_FIELD_PATTERN = /"retryDelay":\s*"([0-9.]+)(ms|s)"/i;
 // "try again in 90 minutes" / "try again in 1 hour"
 const TRY_AGAIN_PATTERN = /try again in\s+~?\s*([0-9.]+)\s*(ms|sec|s|minutes?|mins?|m|hours?|hrs?|h)\b/i;
 // "Your limit will reset in 13 minutes" / "reset in 13 minutes" / "will reset in 2h"
-const WILL_RESET_IN_PATTERN = /(?:will\s+)?reset in\s+~?\s*([0-9.]+)\s*(ms|sec|s|minutes?|mins?|m|hours?|hrs?|h)\b/i;
+// OpenCode Go quota errors use "Resets in …" with day units and compound
+// remainders ("Resets in 3 days", "Resets in 2hr 15min", "Resets in 45min").
+const WILL_RESET_IN_PATTERN =
+	/(?:will\s+)?resets?\s+in\s+~?\s*([0-9.]+)\s*(ms|sec|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b/i;
+// OpenCode Go compound remainder: "Resets in 2hr 15min".
+const RESET_IN_HR_MIN_PATTERN = /resets?\s+in\s+~?\s*(\d+(?:\.\d+)?)\s*hr\s*(\d+(?:\.\d+)?)\s*min\b/i;
 // "Your limit will reset at 2026-09-01 09:44:51" / "reset at 2026-09-01T09:44:51Z"
 const WILL_RESET_AT_PATTERN =
 	/(?:will\s+)?reset at\s+([0-9]{4}-[0-9]{2}-[0-9]{2}[ T][0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?(?:Z|[+-][0-9]{2}:?[0-9]{2})?)/i;
@@ -158,6 +163,16 @@ export function extractRetryHint(source: Response | Headers | null | undefined,
 			}
 		}
 	}
+	// OpenCode Go compound remainder ("Resets in 2hr 15min"): the generic
+	// pattern only captures the leading "2hr", so add the trailing minutes.
+	const compoundResetMatch = RESET_IN_HR_MIN_PATTERN.exec(body);
+	if (compoundResetMatch?.[1] && compoundResetMatch[2]) {
+		const hours = Number.parseFloat(compoundResetMatch[1]);
+		const minutes = Number.parseFloat(compoundResetMatch[2]);
+		if (Number.isFinite(hours) && Number.isFinite(minutes) && hours >= 0 && minutes > 0) {
+			consider(hours * 60 * 60_000 + minutes * 60_000);
+		}
+	}
 	const accountResetMatch = WILL_RESET_IN_PATTERN.exec(body);
 	if (accountResetMatch?.[1]) {
 		const value = Number.parseFloat(accountResetMatch[1]);
@@ -241,6 +256,10 @@ function unitToMs(unit: string): number | undefined {
 		case "hour":
 		case "hours":
 			return 60 * 60_000;
+		case "d":
+		case "day":
+		case "days":
+			return 24 * 60 * 60_000;
 		default:
 			return undefined;
 	}

package/src/index.ts

@@ -9,7 +9,6 @@ export * from "./file-lock";
 export * from "./format";
 export * from "./frontmatter";
 export * from "./fs-error";
-export * from "./glob";
 export * from "./incoming-json";
 export * from "./json";
 export * from "./json-parse";

package/src/logger.ts

@@ -152,6 +152,19 @@ function pruneStaleProcessLogs(dir: string): void {
 	}
 }
 
+const scheduledPruneDirs = new Set<string>();
+
+/** Run shared retention only after logger construction has returned to the event loop. */
+function schedulePruneStaleProcessLogs(dir: string): void {
+	if (scheduledPruneDirs.has(dir)) return;
+	scheduledPruneDirs.add(dir);
+	const immediate = setImmediate(() => {
+		scheduledPruneDirs.delete(dir);
+		pruneStaleProcessLogs(dir);
+	});
+	immediate.unref();
+}
+
 /** Ensure a logs directory exists; return the resolved path. */
 function ensureDir(dir: string): string {
 	if (!fs.existsSync(dir)) {
@@ -237,7 +250,7 @@ function formatLogInfo(info: NormalizedLogInfo): string {
 /** Build a rotating file sink with process-local rotation and shared retention. */
 function makeFileTransport(dir?: string): RotatingFileSink {
 	const logsDir = ensureDir(dir ?? getLogsDir());
-	pruneStaleProcessLogs(logsDir);
+	schedulePruneStaleProcessLogs(logsDir);
 	return new RotatingFileSink({
 		directory: logsDir,
 		filenamePrefix: "omp",

package/src/peek-file.ts

@@ -1,67 +1,20 @@
 /**
  * Read the first `maxBytes` of a file (offset 0) and pass that slice to `op`.
  *
- * Buffers are reused to avoid allocating on every peek: sync uses one growable
- * `Uint8Array`; async uses a small fixed pool of `Buffer`s with a bounded wait
- * queue, falling back to a fresh allocation when the pool and queue are saturated
- * or when `maxBytes` exceeds the pool slot size.
+ * Synchronous peeks reuse one growable `Uint8Array`; asynchronous peeks allocate
+ * their result window so callback-retained slices cannot be changed by a later read.
  */
 import * as fs from "node:fs";
 
-/** Async pool slot size; larger peeks allocate ad hoc. */
-const POOLED_BUFFER_SIZE = 512;
-const ASYNC_POOL_SIZE = 10;
-/** Cap waiter queue so heavy concurrency does not queue unbounded; overflow uses alloc. */
-const MAX_ASYNC_WAITERS = 4;
 const INITIAL_SYNC_BUFFER_SIZE = 1024;
-const EMPTY_BUFFER = Buffer.alloc(0);
+const EMPTY_BUFFER = new Uint8Array(0);
 
-const asyncPool = Array.from({ length: ASYNC_POOL_SIZE }, () => Buffer.allocUnsafe(POOLED_BUFFER_SIZE));
-const availableAsyncPoolIndexes = Array.from({ length: ASYNC_POOL_SIZE }, (_, index) => index);
-const asyncPoolWaiters: Array<(index: number) => void> = [];
 let syncPool = new Uint8Array(INITIAL_SYNC_BUFFER_SIZE);
 
-/** Returns a pool slot index, or `-1` when the caller should use a standalone buffer. */
-function acquireAsyncPoolIndex(): Promise<number> | number {
-	const index = availableAsyncPoolIndexes.pop();
-	if (index !== undefined) {
-		return index;
-	}
-	if (asyncPoolWaiters.length >= MAX_ASYNC_WAITERS) {
-		return -1;
-	}
-	const { promise, resolve } = Promise.withResolvers<number>();
-	asyncPoolWaiters.push(resolve);
-	return promise;
-}
-
-function releaseAsyncPoolIndex(index: number): void {
-	if (index < 0) {
-		return;
-	}
-	const waiter = asyncPoolWaiters.shift();
-	if (waiter) {
-		waiter(index);
-		return;
-	}
-	availableAsyncPoolIndexes.push(index);
-}
-
-async function withAsyncPoolBuffer<T>(maxBytes: number, op: (buffer: Buffer) => Promise<T>): Promise<T> {
-	if (maxBytes <= 0) {
-		return op(EMPTY_BUFFER);
-	}
-	if (maxBytes > POOLED_BUFFER_SIZE) {
-		return op(Buffer.allocUnsafe(maxBytes));
-	}
-
-	const poolIndex = await acquireAsyncPoolIndex();
-	const buffer = poolIndex >= 0 ? asyncPool[poolIndex] : Buffer.allocUnsafe(maxBytes);
-	try {
-		return await op(buffer.subarray(0, maxBytes));
-	} finally {
-		releaseAsyncPoolIndex(poolIndex);
-	}
+function allocateWindow(length: number): Uint8Array {
+	const buffer = Buffer.allocUnsafe(length);
+	// A plain view preserves Uint8Array.slice semantics without zeroing bytes the read replaces.
+	return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
 }
 
 function withSyncPoolBuffer<T>(maxBytes: number, op: (buffer: Uint8Array) => T): T {
@@ -104,10 +57,9 @@ export async function peekFile<T>(filePath: string, maxBytes: number, op: (heade
 
 	const fileHandle = await fs.promises.open(filePath, "r");
 	try {
-		return await withAsyncPoolBuffer(maxBytes, async buffer => {
-			const { bytesRead } = await fileHandle.read(buffer, 0, buffer.byteLength, 0);
-			return op(buffer.subarray(0, bytesRead));
-		});
+		const buffer = allocateWindow(maxBytes);
+		const { bytesRead } = await fileHandle.read(buffer, 0, buffer.byteLength, 0);
+		return op(buffer.subarray(0, bytesRead));
 	} finally {
 		await fileHandle.close();
 	}
@@ -116,9 +68,8 @@ export async function peekFile<T>(filePath: string, maxBytes: number, op: (heade
 /**
  * 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
+ * The tail mirror of {@link peekFile}: 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.
@@ -135,10 +86,9 @@ export async function peekFileTail<T>(filePath: string, maxBytes: number, op: (t
 		if (len <= 0) {
 			return op(EMPTY_BUFFER);
 		}
-		return await withAsyncPoolBuffer(len, async buffer => {
-			const { bytesRead } = await fileHandle.read(buffer, 0, buffer.byteLength, size - len);
-			return op(buffer.subarray(0, bytesRead));
-		});
+		const buffer = allocateWindow(len);
+		const { bytesRead } = await fileHandle.read(buffer, 0, buffer.byteLength, size - len);
+		return op(buffer.subarray(0, bytesRead));
 	} finally {
 		await fileHandle.close();
 	}
@@ -168,7 +118,7 @@ export async function peekFileEnds<T>(
 		const headLen = prefixBytes > 0 ? Math.min(prefixBytes, size) : 0;
 		const tailLen = suffixBytes > 0 ? Math.min(suffixBytes, size) : 0;
 
-		const head = headLen > 0 ? Buffer.allocUnsafe(headLen) : EMPTY_BUFFER;
+		const head = headLen > 0 ? allocateWindow(headLen) : EMPTY_BUFFER;
 		const headBytesRead = headLen > 0 ? (await fileHandle.read(head, 0, head.byteLength, 0)).bytesRead : 0;
 		const headSlice = head.subarray(0, headBytesRead);
 
@@ -179,7 +129,7 @@ export async function peekFileEnds<T>(
 			return op(headSlice, headSlice.subarray(Math.max(0, headBytesRead - tailLen)));
 		}
 
-		const tail = Buffer.allocUnsafe(tailLen);
+		const tail = allocateWindow(tailLen);
 		const { bytesRead: tailBytesRead } = await fileHandle.read(tail, 0, tail.byteLength, size - tailLen);
 		return op(headSlice, tail.subarray(0, tailBytesRead));
 	} finally {

package/src/postmortem.ts

@@ -7,8 +7,6 @@
  */
 
 import * as fs from "node:fs";
-import inspector from "node:inspector";
-import { isMainThread } from "node:worker_threads";
 import * as logger from "./logger";
 import { restoreTerminalStderr } from "./stderr-guard";
 
@@ -422,22 +420,24 @@ async function exitAfterFatal(output: string, logMessage: string, err: Error, re
 export async function fatal(error: unknown): Promise<never> {
 	const err = error instanceof Error ? error : new Error(String(error));
 	const output = `${Bun.inspect(error, { colors: process.stderr.isTTY === true })}\n${formatFatalRecoveryHints()}`;
-	if (!isMainThread) {
+	if (!Bun.isMainThread) {
 		process.stderr.write(output);
 		process.exit(1);
 	}
 	return exitAfterFatal(output, "Fatal error", err, Reason.UNHANDLED_REJECTION);
 }
 
-if (isMainThread) {
+if (Bun.isMainThread) {
 	process
 		.on("SIGINT", async () => {
 			await runCleanup(Reason.SIGINT);
 			exitProcess(130); // 128 + SIGINT (2)
 		})
-		.on("SIGUSR1", () => {
+		.on("SIGUSR1", async () => {
 			if (inspectorOpened) return;
 			inspectorOpened = true;
+			// Signal-only boundary: successful startup never constructs inspector.
+			const { default: inspector } = await import("node:inspector");
 			inspector.open(undefined, undefined, false);
 			const url = inspector.url();
 			process.stderr.write(`Inspector opened: ${url}\n`);
@@ -656,7 +656,7 @@ export async function drainStdout(): Promise<void> {
 async function runQuit(code: number, exitMode: "guarded" | "native", options: QuitOptions = {}): Promise<void> {
 	await runCleanup(Reason.MANUAL);
 
-	if (!isMainThread) {
+	if (!Bun.isMainThread) {
 		return; // Workers: cleanup done, let worker exit naturally
 	}
 

package/src/stream.ts

@@ -4,6 +4,7 @@ import { abortableSource } from "./abortable";
 import { parseStreamingJson } from "./json-parse";
 
 const LF = 0x0a;
+const CR = 0x0d;
 
 export async function* readLines(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<Uint8Array> {
 	const buffer = new ConcatSink();
@@ -63,6 +64,7 @@ export async function* readJsonl<T>(stream: ReadableStream<Uint8Array>, signal?:
 class ConcatSink {
 	#space?: Buffer;
 	#length = 0;
+	#skipLeadingLf = false;
 
 	#ensureCapacity(size: number): Buffer {
 		const space = this.#space;
@@ -133,19 +135,27 @@ class ConcatSink {
 	}
 
 	appendAndFlushText(chunk: Uint8Array, decoder: TextDecoder): string | undefined {
-		const lastNewline = chunk.lastIndexOf(LF);
-		if (lastNewline === -1) {
-			this.append(chunk);
+		let start = 0;
+		if (this.#skipLeadingLf) {
+			if (chunk.length === 0) return undefined;
+			this.#skipLeadingLf = false;
+			if (chunk[0] === LF) start = 1;
+		}
+
+		const lastLineEnd = Math.max(chunk.lastIndexOf(LF), chunk.lastIndexOf(CR));
+		if (lastLineEnd < start) {
+			if (start < chunk.length) this.append(chunk.subarray(start));
 			return undefined;
 		}
 
-		const completeEnd = lastNewline + 1;
+		const completeEnd = lastLineEnd + 1;
+		this.#skipLeadingLf = chunk[lastLineEnd] === CR && completeEnd === chunk.length;
 		let text: string;
 		if (this.isEmpty) {
-			const complete = completeEnd === chunk.length ? chunk : chunk.subarray(0, completeEnd);
+			const complete = start === 0 && completeEnd === chunk.length ? chunk : chunk.subarray(start, completeEnd);
 			text = decoder.decode(complete);
 		} else {
-			this.append(completeEnd === chunk.length ? chunk : chunk.subarray(0, completeEnd));
+			this.append(chunk.subarray(start, completeEnd));
 			text = decoder.decode(this.flush());
 			this.clear();
 		}
@@ -294,7 +304,7 @@ interface SseEventState {
 }
 
 // Complete lines are decoded in one batch per source chunk. Each batch ends on
-// LF, which cannot split a multi-byte UTF-8 sequence.
+// an ASCII line-ending byte, which cannot split a multi-byte UTF-8 sequence.
 const SSE_DECODER = new TextDecoder("utf-8");
 
 function flushSseEvent(state: SseEventState): ServerSentEvent | null {
@@ -318,11 +328,6 @@ function flushSseEvent(state: SseEventState): ServerSentEvent | null {
 }
 
 function pushSseLine(line: string, state: SseEventState): ServerSentEvent | null {
-	// Complete-line batches split on LF only; strip a trailing CR so CRLF sources
-	// don't leak `\r` into field values.
-	if (line.charCodeAt(line.length - 1) === 0x0d /* '\r' */) {
-		line = line.slice(0, -1);
-	}
 	if (line.length === 0) return flushSseEvent(state);
 
 	// Comment line: keep in `raw` for diagnostic context, skip parsing.
@@ -398,13 +403,21 @@ export async function* readSseEvents(
 			if (text === undefined) continue;
 			let start = 0;
 			while (start < text.length) {
-				const newline = text.indexOf("\n", start);
-				const event = pushSseLine(text.slice(start, newline), state);
+				let lineEnd = start;
+				while (lineEnd < text.length) {
+					const code = text.charCodeAt(lineEnd);
+					if (code === LF || code === CR) break;
+					lineEnd++;
+				}
+				const event = pushSseLine(text.slice(start, lineEnd), state);
 				if (event) yield event;
-				start = newline + 1;
+				if (text.charCodeAt(lineEnd) === CR && text.charCodeAt(lineEnd + 1) === LF) {
+					lineEnd++;
+				}
+				start = lineEnd + 1;
 			}
 		}
-		// Treat any trailing partial line (no terminating LF) as a complete line.
+		// Treat any trailing partial line (no terminating line ending) as complete.
 		if (!lineBuffer.isEmpty) {
 			const tail = lineBuffer.flush();
 			if (tail) {

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/src/glob.ts

@@ -1,189 +0,0 @@
-import * as path from "node:path";
-import { Glob } from "bun";
-import { getProjectDir } from "./dirs";
-
-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;
-}
-
-/** Patterns always excluded (.git is never useful in glob results). */
-const ALWAYS_IGNORED = ["**/.git", "**/.git/**"];
-
-/** node_modules exclusion patterns (skipped if pattern explicitly references node_modules). */
-const NODE_MODULES_IGNORED = ["**/node_modules", "**/node_modules/**"];
-
-/**
- * Parse a single .gitignore file and return glob-compatible exclude patterns.
- * @param content - Raw content of the .gitignore file
- * @param gitignoreDir - Absolute path to the directory containing the .gitignore
- * @param baseDir - Absolute path to the glob's cwd (for relativizing rooted patterns)
- */
-function parseGitignorePatterns(content: string, gitignoreDir: string, baseDir: string): string[] {
-	const patterns: string[] = [];
-
-	for (const rawLine of content.split("\n")) {
-		const line = rawLine.trim();
-		// Skip empty lines and comments
-		if (!line || line.startsWith("#")) {
-			continue;
-		}
-		// Skip negation patterns (unsupported for simple exclude)
-		if (line.startsWith("!")) {
-			continue;
-		}
-
-		let pattern = line;
-
-		// Handle trailing slash (directory-only match)
-		// For glob exclude, we treat it as matching the dir and its contents
-		const isDirectoryOnly = pattern.endsWith("/");
-		if (isDirectoryOnly) {
-			pattern = pattern.slice(0, -1);
-		}
-
-		// Handle rooted patterns (start with /)
-		if (pattern.startsWith("/")) {
-			// Rooted pattern: relative to the .gitignore location
-			const absolutePattern = path.join(gitignoreDir, pattern.slice(1));
-			const relativeToBase = path.relative(baseDir, absolutePattern);
-			if (relativeToBase.startsWith("..")) {
-				// Pattern is outside the search directory, skip
-				continue;
-			}
-			pattern = relativeToBase.replace(/\\/g, "/");
-			if (isDirectoryOnly) {
-				patterns.push(pattern);
-				patterns.push(`${pattern}/**`);
-			} else {
-				patterns.push(pattern);
-			}
-		} else {
-			// Unrooted pattern: match anywhere in the tree
-			if (pattern.includes("/")) {
-				// Contains slash: match from any directory level
-				patterns.push(`**/${pattern}`);
-				if (isDirectoryOnly) {
-					patterns.push(`**/${pattern}/**`);
-				}
-			} else {
-				// No slash: match file/dir name anywhere
-				patterns.push(`**/${pattern}`);
-				if (isDirectoryOnly) {
-					patterns.push(`**/${pattern}/**`);
-				}
-			}
-		}
-	}
-
-	return patterns;
-}
-
-/**
- * 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 async function loadGitignorePatterns(baseDir: string): Promise<string[]> {
-	const patterns: string[] = [];
-	const absoluteBase = path.resolve(baseDir);
-
-	let current = absoluteBase;
-	const maxDepth = 50; // Prevent infinite loops
-
-	for (let i = 0; i < maxDepth; i++) {
-		const gitignorePath = path.join(current, ".gitignore");
-
-		try {
-			const content = await Bun.file(gitignorePath).text();
-			const filePatterns = parseGitignorePatterns(content, current, absoluteBase);
-			patterns.push(...filePatterns);
-		} catch {
-			// .gitignore doesn't exist or can't be read, continue
-		}
-
-		const parent = path.dirname(current);
-		if (parent === current) {
-			// Reached filesystem root
-			break;
-		}
-		current = parent;
-	}
-
-	return patterns;
-}
-
-/**
- * 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 async function globPaths(patterns: string | string[], options: GlobPathsOptions = {}): Promise<string[]> {
-	const { cwd, exclude, signal, timeoutMs, dot, onlyFiles = true, gitignore } = options;
-
-	// Build exclude list: always exclude .git, exclude node_modules unless pattern references it
-	const patternArray = Array.isArray(patterns) ? patterns : [patterns];
-	const mentionsNodeModules = patternArray.some(p => p.includes("node_modules"));
-
-	const baseExclude = mentionsNodeModules ? [...ALWAYS_IGNORED] : [...ALWAYS_IGNORED, ...NODE_MODULES_IGNORED];
-	let effectiveExclude = exclude ? [...baseExclude, ...exclude] : baseExclude;
-
-	if (gitignore) {
-		const gitignorePatterns = await loadGitignorePatterns(cwd ?? getProjectDir());
-		effectiveExclude = [...effectiveExclude, ...gitignorePatterns];
-	}
-
-	const base = cwd ?? getProjectDir();
-	const allResults: string[] = [];
-
-	// Combine timeout and abort signals
-	const timeoutSignal = timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined;
-	const combinedSignal =
-		signal && timeoutSignal ? AbortSignal.any([signal, timeoutSignal]) : (signal ?? timeoutSignal);
-
-	for (const pattern of patternArray) {
-		const glob = new Glob(pattern);
-		const scanOptions = {
-			cwd: base,
-			dot,
-			onlyFiles,
-			throwErrorOnBrokenSymlink: false,
-		};
-
-		for await (const entry of glob.scan(scanOptions)) {
-			if (combinedSignal?.aborted) {
-				const reason = combinedSignal.reason;
-				if (reason instanceof Error) throw reason;
-				throw new DOMException("Aborted", "AbortError");
-			}
-
-			// Check exclusion patterns
-			const normalized = entry.replace(/\\/g, "/");
-			let excluded = false;
-			for (const excludePattern of effectiveExclude) {
-				const excludeGlob = new Glob(excludePattern);
-				if (excludeGlob.match(normalized)) {
-					excluded = true;
-					break;
-				}
-			}
-			if (!excluded) {
-				allResults.push(normalized);
-			}
-		}
-	}
-
-	return allResults;
-}