@linxiraos/pi-utils 1.4.4 → 1.4.6

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [1.4.6] - 2026-10-28
+
+- Released as part of Zeta 1.4.6; no package-specific user-visible changes.
+
+## [1.4.5] - 2026-10-28
+
+- Synced with upstream OMP v18.13.2 (shared utilities and runtime fixes); user-visible changes are in UPDATE-LOG.md under 1.4.5.
+
 ## [1.4.4] - 2026-10-26
 
 - Released as part of Zeta 1.4.4; no package-specific user-visible changes.

package/dist/types/acp/protocol.d.ts

@@ -93,6 +93,7 @@ export interface ToolCallLocation extends Meta {
 export interface ToolCall extends Meta {
     toolCallId: ToolCallId;
     title: string;
+    name?: string | null;
     kind?: ToolKind | null;
     status?: ToolCallStatus | null;
     content?: ToolCallContent[] | null;

package/dist/types/ar/tar.d.ts

@@ -6,7 +6,7 @@ export declare function readTarEntriesFromBuffer(buffer: Uint8Array, options: Fo
  * pass over `open()` walks the headers, and member reads open it again.
  */
 export declare function readTarEntriesFromStream(open: () => AsyncIterable<Uint8Array>, options: FormatReadOptions): Promise<ArchiveIndexEntry[]>;
-/** Read and index a tar source after one bounded whole-stream read. */
+/** Index a plain tar by ranging over headers and retaining lazy member offsets. */
 export declare const readTar: FormatReader;
 /** Detect a tar header, including legacy pre-ustar archives, by its checksum. */
 export declare function sniffTar(bytes: Uint8Array): boolean;

package/dist/types/ar/types.d.ts

@@ -8,7 +8,7 @@ export type WritableArchiveFormat = "zip" | "tar" | "tar.gz" | "tar.zst" | "asar
  * Where to read an archive from: an extension-inferred filesystem path, a
  * format-tagged filesystem path, in-memory bytes, or any caller-provided
  * {@link ByteSource} (e.g. `httpByteSource` for ranged remote reads).
- * File- and source-backed ZIP/ASAR/RAR/7z/ISO are read lazily.
+ * File- and source-backed TAR/ZIP/ASAR/RAR/7z/ISO are read lazily.
  */
 export type ArchiveSource = string | {
     bytes: Uint8Array;

package/dist/types/format.d.ts

@@ -6,9 +6,10 @@ export declare function formatDuration(ms: number): string;
 /**
  * Format a number with K/M/B suffix for compact display.
  * Uses 1 decimal for small leading digits when non-zero, rounded otherwise.
+ * Values below 1,000 print as-is unless `maxFractionDigits` caps their decimals.
  * Examples: "999", "1K", "1.5K", "25K", "1M", "1.5M", "25M", "1.5B"
  */
-export declare function formatNumber(n: number): string;
+export declare function formatNumber(n: number, maxFractionDigits?: number): string;
 /**
  * Format a byte count to a human-readable string.
  * Examples: "512B", "1.5KB", "2.3MB", "1.2GB"

package/dist/types/json.d.ts

@@ -2,6 +2,13 @@
  * Try to parse JSON, returning null on failure.
  */
 export declare function tryParseJson<T = unknown>(content: string): T | null;
+/**
+ * Index just past the JSON object or array that opens at `text[start]`, or -1
+ * when it does not close within `text`. String literals are skipped, honoring
+ * escapes, so brackets inside values do not count. Malformed input yields some
+ * end that a parser then rejects.
+ */
+export declare function jsonContainerEnd(text: string, start: number): number;
 /**
  * Serialize JSON while preserving bigint precision as decimal strings.
  *

package/dist/types/marked/inline-closers.d.ts

@@ -45,15 +45,23 @@ declare class EmphasisDelimiters {
 }
 /**
  * The runs of backticks in the root source, for the code span rule. A span opened by `width` backticks closes at the
- * first `width` backticks after its opening run that no backslash escapes: the start of a later run of at least
- * `width`, or, in a run whose first backtick a backslash escapes, the backticks from its `width`th on, since the
- * search for a closer goes on `width` past an escaped one.
+ * next run of exactly `width` backticks: a run of any other length is no closer, and the one that closes is the first
+ * run of that width at or after the opener. Backslash escapes do not apply inside a code span, so a backslash just
+ * before that closing backtick is content and still closes the span.
  */
 declare class CodeRuns {
     #private;
     constructor(src: string);
     /** Where the run of backticks holding the backtick at `at` ends. */
     endOf(at: number): number;
+    /**
+     * Whether a backtick string starts at `at` for a scan that walked to `at`: a string is a whole run, so it starts at
+     * the run's first backtick and nowhere else. A retry deeper inside a run is not a string, which keeps a run whose
+     * opener found no closer from opening a narrower span one backtick later. A position a tokenizer's raw resumed at,
+     * or the suffix an escape token left behind, is not a walked position — `codeOpenerWidth` admits those on its own,
+     * because it is told the scan resumed there rather than inferring it from the source text.
+     */
+    startsStringAt(at: number): boolean;
     /** Where the closer of a code span opened by `width` backticks that end at `from` starts, or -1. */
     closerAfter(from: number, width: number): number;
 }
@@ -102,8 +110,13 @@ export declare class InlineClosers {
     escapeWithin(rest: string, from: number, to: number): boolean;
     /** Where the emphasis opened by the `width` markers at the start of `rest` closes, or -1. */
     closeEmphasis(rest: string, marker: string, width: number): number;
-    /** How many backticks start `rest`, which starts with one. */
-    codeOpenerWidth(rest: string): number;
+    /**
+     * How many backticks start `rest`, which starts with one, or 0 where no code span opens because no backtick string
+     * starts there: the opener is a whole string, so the rest of a run whose opener found no closer is text, while the
+     * backticks left after a backslash escaped the run's first one do open a span. `resumed` says the scan resumed at
+     * `rest` after a tokenizer consumed a raw that ended here, where the backticks are a string wherever they sit.
+     */
+    codeOpenerWidth(rest: string, resumed?: boolean): number;
     /** Where the code span opened by the `width` backticks at the start of `rest` closes, or -1. */
     closeCode(rest: string, width: number): number;
     /**

package/dist/types/mime.d.ts

@@ -26,6 +26,13 @@ export type ImageMetadata = {
     hasAlpha?: boolean;
 };
 export declare function parseImageMetadata(header: Uint8Array): ImageMetadata | null;
+/** Still images in a HEIF (ISO BMFF) container, which the image pipeline cannot decode itself. */
+export type HeifImageMimeType = "image/heic" | "image/heif" | "image/avif";
+/**
+ * MIME type of a HEIC, AVIF or other HEIF image from the brands of its leading `ftyp` box:
+ * the major brand, then the compatible brands, with the generic `mif1`/`msf1` brands last.
+ */
+export declare function parseHeifImageMimeType(header: Uint8Array): HeifImageMimeType | null;
 /** Why base64 image data is unusable; `undefined` when it is canonical and non-empty. */
 export type Base64ImageDataFailure = "invalid base64 image data" | "empty image data";
 /**

package/dist/types/postmortem.d.ts

@@ -52,7 +52,7 @@ export declare const NATIVE_PROCESS_EXIT: unique symbol;
  * signal and fatal exit.
  */
 export declare function exitProcess(code: number): never;
-/** User-facing command printed before fatal cleanup so interrupted work can be resumed. */
+/** User-facing command printed after fatal or SIGTERM cleanup so interrupted work can be resumed. */
 export interface FatalRecoveryHint {
     /** Stable label identifying the recoverable session or process. */
     label: string;
@@ -168,7 +168,10 @@ export declare function isExpectedCleanupError(reason: unknown): boolean;
 export declare function interceptUnhandledRejections(interceptor: (reason: unknown) => boolean): () => void;
 /**
  * Register a synchronous recovery command to print when the process exits
- * through an uncaught exception or unhandled rejection.
+ * through an uncaught exception, an unhandled rejection, or SIGTERM.
+ *
+ * Providers are read once cleanup finishes (or hits its deadline), so they
+ * report what teardown left behind: a session it saved or one it dropped.
  */
 export declare function registerFatalRecoveryHint(provider: FatalRecoveryHintProvider): () => void;
 /**
@@ -182,6 +185,20 @@ export interface CleanupRegistrationOptions {
      * The registration remains armed when a keep-alive pass skips it.
      */
     exitOnly?: boolean;
+    /**
+     * How long a pass waits for this callback, when that is longer than the
+     * default 10 s cleanup deadline. It extends the pass only while the callback
+     * is still pending: one that settles early ends its hold at once.
+     */
+    deadlineMs?: number;
+    /**
+     * With `deadlineMs`: a line printed to stderr, with the remaining wait
+     * appended, if exit is still waiting on this callback once every other
+     * callback has finished (a terminal owner has then released the screen), or
+     * at the default 10 s deadline when another callback is still running.
+     * Nothing is printed when the callback finishes first.
+     */
+    waitMessage?: string;
 }
 /**
  * Registers a cleanup callback for shutdown, signals, fatal errors, and

package/dist/types/process-name.d.ts

@@ -1,5 +1,6 @@
 /**
- * Set both the JS `process.title` and — on Linux — the kernel `comm` name.
+ * Set the JS `process.title` (except on Windows, see above) and — on Linux —
+ * the kernel `comm` name.
  *
  * Never throws: `bun:ffi` unavailability or a failed syscall degrades silently
  * to the `process.title`-only behavior, so it is safe to call at startup.

package/dist/types/which.d.ts

@@ -42,4 +42,17 @@ export declare const whichFresh: typeof darwinWhich;
  * @returns Filesystem path if found, else null
  */
 export declare function $which(command: string, options?: WhichOptions): string | null;
+/**
+ * Locate every match for `command` on PATH, in PATH order, uncached.
+ *
+ * Callers that probe candidates (e.g. the Python eval backend) use this so a broken
+ * first hit — a version-manager shim with no version selected, a Windows Store alias —
+ * does not hide a working binary further down PATH. On macOS the Xcode/CLT toolchain
+ * match is appended last, mirroring {@link $which}'s fallback.
+ *
+ * @param command - Binary name to resolve
+ * @param options - `PATH` (defaults to `process.env.PATH`) and `cwd` for relative entries
+ * @returns Distinct filesystem paths; empty when nothing matches
+ */
+export declare function $whichAll(command: string, options?: Bun.WhichOptions): string[];
 export {};

package/package.json

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

package/src/acp/protocol.ts

@@ -102,6 +102,7 @@ export interface ToolCallLocation extends Meta {
 export interface ToolCall extends Meta {
 	toolCallId: ToolCallId;
 	title: string;
+	name?: string | null;
 	kind?: ToolKind | null;
 	status?: ToolCallStatus | null;
 	content?: ToolCallContent[] | null;

package/src/ar/tar.ts

@@ -16,7 +16,7 @@ import {
 	normalizeArchiveEntryPath,
 	normalizeArchiveLookupPath,
 } from "./paths";
-import { readAllBytes } from "./source";
+import type { ByteSource } from "./source";
 import type { ArchiveIndexEntry, FormatReader, FormatReadOptions, MemberSource } from "./types";
 
 const BLOCK_SIZE = 512;
@@ -53,8 +53,44 @@ interface PendingTarLink {
 	targetPath: string;
 }
 
+interface TarCursor {
+	readonly position: number;
+	read(length: number): Promise<Uint8Array>;
+	skip(length: number): Promise<boolean>;
+}
+
+/** Seek over plain tar payloads without fetching their bytes. */
+class TarSourceCursor implements TarCursor {
+	readonly #source: ByteSource;
+	#position = 0;
+
+	constructor(source: ByteSource) {
+		this.#source = source;
+	}
+
+	get position(): number {
+		return this.#position;
+	}
+
+	async read(length: number): Promise<Uint8Array> {
+		const size = Math.min(length, this.#source.size - this.#position);
+		if (size === 0) return new Uint8Array(0);
+		const end = this.#position + size;
+		const bytes = await this.#source.read(this.#position, end);
+		if (bytes.byteLength !== size) throw new ArchiveError("Invalid archive: truncated data");
+		this.#position = end;
+		return bytes;
+	}
+
+	async skip(length: number): Promise<boolean> {
+		if (length > this.#source.size - this.#position) return false;
+		this.#position += length;
+		return true;
+	}
+}
+
 /** Forward-only reader over tar bytes that arrive in chunks: one buffer, or a decompressing stream. */
-class TarByteStream {
+class TarByteStream implements TarCursor {
 	readonly #chunks: AsyncIterator<Uint8Array> | Iterator<Uint8Array>;
 	#chunk: Uint8Array = new Uint8Array(0);
 	#position = 0;
@@ -119,6 +155,27 @@ interface TarPayload {
 	read(offset: number, size: number, memberPath: string): Promise<Uint8Array>;
 }
 
+class TarSourcePayload implements TarPayload {
+	readonly #source: ByteSource;
+
+	constructor(source: ByteSource) {
+		this.#source = source;
+	}
+
+	async read(offset: number, size: number, memberPath: string): Promise<Uint8Array> {
+		try {
+			const bytes = await this.#source.read(offset, offset + size);
+			if (bytes.byteLength !== size) {
+				throw new ArchiveError(`Archive member '${formatArchivePathForError(memberPath)}' is truncated`);
+			}
+			return bytes;
+		} catch (error) {
+			if (error instanceof ArchiveError) throw error;
+			throw new ArchiveError(error instanceof Error ? error.message : "Failed to read tar member");
+		}
+	}
+}
+
 class TarBufferPayload implements TarPayload {
 	readonly #buffer: Uint8Array;
 
@@ -533,7 +590,7 @@ function resolvePendingLinks(
 
 /** Read one metadata record's payload, bounded by `maxIndexSize`, and step over its padding. */
 async function readTarMetadata(
-	stream: TarByteStream,
+	stream: TarCursor,
 	size: number,
 	limits: ArchiveLimits,
 	what: string,
@@ -551,7 +608,7 @@ async function readTarMetadata(
  * stepped over, never held: entries point into `payload` by stream offset.
  */
 async function readTarEntries(
-	stream: TarByteStream,
+	stream: TarCursor,
 	payload: TarPayload,
 	options: FormatReadOptions,
 ): Promise<ArchiveIndexEntry[]> {
@@ -737,18 +794,17 @@ export async function readTarEntriesFromStream(
 	}
 }
 
-/** Read and index a tar source after one bounded whole-stream read. */
+/** Index a plain tar by ranging over headers and retaining lazy member offsets. */
 export const readTar: FormatReader = async (source, options) => {
-	assertInMemorySize(source.size, options.limits);
-	let bytes: Uint8Array;
+	if (!Number.isSafeInteger(source.size) || source.size < 0) {
+		throw new ArchiveError("Archive is too large to read safely");
+	}
 	try {
-		bytes = await readAllBytes(source);
+		return await readTarEntries(new TarSourceCursor(source), new TarSourcePayload(source), options);
 	} catch (error) {
 		if (error instanceof ArchiveError) throw error;
 		throw new ArchiveError(error instanceof Error ? error.message : "Failed to read tar archive");
 	}
-	if (bytes.byteLength !== source.size) throw new ArchiveError("Invalid archive: truncated data");
-	return readTarEntriesFromBuffer(bytes, options);
 };
 
 /** Detect a tar header, including legacy pre-ustar archives, by its checksum. */

package/src/ar/types.ts

@@ -37,7 +37,7 @@ export type WritableArchiveFormat = "zip" | "tar" | "tar.gz" | "tar.zst" | "asar
  * Where to read an archive from: an extension-inferred filesystem path, a
  * format-tagged filesystem path, in-memory bytes, or any caller-provided
  * {@link ByteSource} (e.g. `httpByteSource` for ranged remote reads).
- * File- and source-backed ZIP/ASAR/RAR/7z/ISO are read lazily.
+ * File- and source-backed TAR/ZIP/ASAR/RAR/7z/ISO are read lazily.
  */
 export type ArchiveSource =
 	| string

package/src/dirs.ts

@@ -333,7 +333,21 @@ export function getSafeProjectCwd(): string {
 
 /** Get the config directory name relative to home (e.g. ".zeta" or ZETA_CONFIG_DIR override). */
 export function getConfigDirName(): string {
-	return process.env.ZETA_CONFIG_DIR || CONFIG_DIR_NAME;
+	const configured = process.env.ZETA_CONFIG_DIR;
+	if (!configured) return CONFIG_DIR_NAME;
+	// This value is a directory *name* under the user's home, never a path to
+	// adopt directly. Absolute paths would be re-joined to home by every
+	// consumer (`getBaseConfigRoot`, project discovery, plugin roots) and
+	// produce inconsistent trees; `..` would escape home entirely. Reject
+	// both at the boundary instead of scattering files.
+	if (path.isAbsolute(configured) || path.parse(configured).root !== "") {
+		throw new Error("ZETA_CONFIG_DIR must be a relative directory name under the home directory");
+	}
+	const normalized = path.normalize(configured);
+	if (normalized === "." || normalized === ".." || normalized.startsWith(`..${path.sep}`)) {
+		throw new Error("ZETA_CONFIG_DIR must stay within the home directory");
+	}
+	return normalized;
 }
 
 /** Get the config agent directory name relative to home (e.g. ".zeta/agent" or PI_CONFIG_DIR + "/agent"). */

package/src/format.ts

@@ -33,10 +33,14 @@ export function formatDuration(ms: number): string {
 /**
  * Format a number with K/M/B suffix for compact display.
  * Uses 1 decimal for small leading digits when non-zero, rounded otherwise.
+ * Values below 1,000 print as-is unless `maxFractionDigits` caps their decimals.
  * Examples: "999", "1K", "1.5K", "25K", "1M", "1.5M", "25M", "1.5B"
  */
-export function formatNumber(n: number): string {
-	if (n < 1_000) return n.toString();
+export function formatNumber(n: number, maxFractionDigits?: number): string {
+	if (n < 1_000) {
+		if (maxFractionDigits === undefined || Number.isInteger(n)) return n.toString();
+		return Number(n.toFixed(maxFractionDigits)).toString();
+	}
 	if (n < 10_000) return `${trim1(n / 1_000)}K`;
 	if (n < 1_000_000) return `${Math.round(n / 1_000)}K`;
 	if (n < 10_000_000) return `${trim1(n / 1_000_000)}M`;

package/src/json.ts

@@ -9,6 +9,31 @@ export function tryParseJson<T = unknown>(content: string): T | null {
 	}
 }
 
+/**
+ * Index just past the JSON object or array that opens at `text[start]`, or -1
+ * when it does not close within `text`. String literals are skipped, honoring
+ * escapes, so brackets inside values do not count. Malformed input yields some
+ * end that a parser then rejects.
+ */
+export function jsonContainerEnd(text: string, start: number): number {
+	let depth = 0;
+	for (let index = start; index < text.length; index++) {
+		const code = text.charCodeAt(index);
+		if (code === 0x22) {
+			for (index++; index < text.length; index++) {
+				const inner = text.charCodeAt(index);
+				if (inner === 0x5c) index++;
+				else if (inner === 0x22) break;
+			}
+		} else if (code === 0x7b || code === 0x5b) {
+			depth++;
+		} else if ((code === 0x7d || code === 0x5d) && --depth === 0) {
+			return index + 1;
+		}
+	}
+	return -1;
+}
+
 /**
  * Serialize JSON while preserving bigint precision as decimal strings.
  *

package/src/marked/core.ts

@@ -655,39 +655,48 @@ function lexToNested(lex: InlineLex): NestedMatch | undefined {
 	// The context is shared with the sources nested in this one, which move its end while they are lexed.
 	context.end = closers.end;
 	let rest = lex.rest;
+	// A token the lexer consumed ends the walk, so the backticks left where the next token starts are a string of their
+	// own even when the run they belong to began earlier: an extension, an override or an escape token may leave the
+	// scan inside a run, and a code span opens there. Only the text step's own advance leaves the scan inside a run
+	// without consuming a token, and no span opens at such a position.
+	let resumed = false;
+	/** Pushes `token` and moves past its raw, which is where the next token starts. */
+	const consumeToken = (token: Token): void => {
+		output.push(token);
+		rest = rest.slice(token.raw.length);
+		resumed = true;
+	};
 	while (rest !== "") {
+		const resumedHere = resumed;
+		resumed = false;
 		let custom: Tokens.Generic | undefined;
 		for (const extension of lexer.extensions.inline) {
 			custom = extension.tokenizer.call(context, rest, output);
 			if (custom?.raw) break;
 		}
 		if (custom?.raw) {
-			output.push(custom);
-			rest = rest.slice(custom.raw.length);
+			consumeToken(custom);
 			continue;
 		}
 
 		const escaped = /^\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/.exec(rest);
 		if (escaped) {
-			output.push({ type: "escape", raw: escaped[0], text: escaped[1]! });
-			rest = rest.slice(2);
+			consumeToken({ type: "escape", raw: escaped[0], text: escaped[1]! });
 			continue;
 		}
 		const br = lexer.options.breaks ? /^(?: {2,}|\\)?\n/.exec(rest) : /^(?: {2,}|\\)\n/.exec(rest);
 		if (br) {
-			output.push({ type: "br", raw: br[0] });
-			rest = rest.slice(br[0].length);
+			consumeToken({ type: "br", raw: br[0] });
 			continue;
 		}
 		if (rest[0] === "`") {
-			const width = closers.codeOpenerWidth(rest);
+			const width = closers.codeOpenerWidth(rest, resumedHere);
 			const end = closers.closeCode(rest, width);
 			if (end !== -1) {
 				const raw = rest.slice(0, end + width);
 				let text = rest.slice(width, end).replace(/\n/g, " ");
 				if (/^ .* $/.test(text) && text.trim() !== "") text = text.slice(1, -1);
-				output.push({ type: "codespan", raw, text });
-				rest = rest.slice(raw.length);
+				consumeToken({ type: "codespan", raw, text });
 				continue;
 			}
 		}
@@ -695,14 +704,12 @@ function lexToNested(lex: InlineLex): NestedMatch | undefined {
 		if (auto) {
 			const text = auto.slice(1, -1);
 			const href = text.includes("@") && !/^[a-z][a-z+.-]*:\/\//i.test(text) ? `mailto:${text}` : text;
-			output.push({ type: "link", raw: auto, text, href, tokens: [{ type: "text", raw: text, text }] });
-			rest = rest.slice(auto.length);
+			consumeToken({ type: "link", raw: auto, text, href, tokens: [{ type: "text", raw: text, text }] });
 			continue;
 		}
 		const html = inlineHtmlPrefix(rest, closers);
 		if (html) {
-			output.push({ type: "html", raw: html, inLink: false, inRawBlock: false, block: false, text: html });
-			rest = rest.slice(html.length);
+			consumeToken({ type: "html", raw: html, inLink: false, inRawBlock: false, block: false, text: html });
 			continue;
 		}
 		const nested = matchLink(rest, lexer, closers) ?? matchEmphasis(rest, output, closers);
@@ -716,8 +723,7 @@ function lexToNested(lex: InlineLex): NestedMatch | undefined {
 			if (override) del = override.call(lexer.tokenizer, rest, rest);
 			if (del === false || !override) del = lexer.tokenizer.del(rest);
 			if (del) {
-				output.push(del);
-				rest = rest.slice(del.raw.length);
+				consumeToken(del);
 				continue;
 			}
 		}
@@ -744,8 +750,7 @@ function lexToNested(lex: InlineLex): NestedMatch | undefined {
 			}
 		}
 		if (url) {
-			output.push(url);
-			rest = rest.slice(url.raw.length);
+			consumeToken(url);
 			continue;
 		}
 

package/src/marked/inline-closers.ts

@@ -170,38 +170,30 @@ class EmphasisDelimiters {
 
 /**
  * The runs of backticks in the root source, for the code span rule. A span opened by `width` backticks closes at the
- * first `width` backticks after its opening run that no backslash escapes: the start of a later run of at least
- * `width`, or, in a run whose first backtick a backslash escapes, the backticks from its `width`th on, since the
- * search for a closer goes on `width` past an escaped one.
+ * next run of exactly `width` backticks: a run of any other length is no closer, and the one that closes is the first
+ * run of that width at or after the opener. Backslash escapes do not apply inside a code span, so a backslash just
+ * before that closing backtick is content and still closes the span.
  */
 class CodeRuns {
-	// Per run, in order: where it starts and ends, and whether a backslash escapes it.
+	// Per run, in order: where it starts and ends; the starts are the binary search `endOf` and `startsStringAt` need.
 	readonly #starts: number[] = [];
 	readonly #ends: number[] = [];
-	readonly #escaped: boolean[] = [];
-	// A segment tree over the runs of the widest closer each run holds: its length, or half of it when escaped.
-	readonly #widest: Int32Array;
-	readonly #leaves: number;
+	// Run starts by width, each list ascending: a closer must have the opener's exact width, so finding one is a
+	// binary search in the list for that width and no scan of the runs between.
+	readonly #byWidth = new Map<number, number[]>();
 
 	constructor(src: string) {
-		const widths: number[] = [];
 		for (let at = src.indexOf("`"); at !== -1;) {
 			let end = at + 1;
 			while (src.charCodeAt(end) === 0x60 /* ` */) end++;
-			const escaped = escapedAt(src, at);
 			this.#starts.push(at);
 			this.#ends.push(end);
-			this.#escaped.push(escaped);
-			widths.push(escaped ? (end - at) >> 1 : end - at);
+			const width = end - at;
+			const starts = this.#byWidth.get(width);
+			if (starts === undefined) this.#byWidth.set(width, [at]);
+			else starts.push(at);
 			at = src.indexOf("`", end);
 		}
-		let leaves = 1;
-		while (leaves < widths.length) leaves <<= 1;
-		const widest = new Int32Array(2 * leaves);
-		for (let run = 0; run < widths.length; run++) widest[leaves + run] = widths[run]!;
-		for (let node = leaves - 1; node >= 1; node--) widest[node] = Math.max(widest[2 * node]!, widest[2 * node + 1]!);
-		this.#widest = widest;
-		this.#leaves = leaves;
 	}
 
 	/** Where the run of backticks holding the backtick at `at` ends. */
@@ -209,28 +201,24 @@ class CodeRuns {
 		return this.#ends[lowerBound(this.#starts, at + 1) - 1]!;
 	}
 
+	/**
+	 * Whether a backtick string starts at `at` for a scan that walked to `at`: a string is a whole run, so it starts at
+	 * the run's first backtick and nowhere else. A retry deeper inside a run is not a string, which keeps a run whose
+	 * opener found no closer from opening a narrower span one backtick later. A position a tokenizer's raw resumed at,
+	 * or the suffix an escape token left behind, is not a walked position — `codeOpenerWidth` admits those on its own,
+	 * because it is told the scan resumed there rather than inferring it from the source text.
+	 */
+	startsStringAt(at: number): boolean {
+		const run = lowerBound(this.#starts, at + 1) - 1;
+		return this.#starts[run] === at;
+	}
+
 	/** Where the closer of a code span opened by `width` backticks that end at `from` starts, or -1. */
 	closerAfter(from: number, width: number): number {
-		const run = this.#firstHolding(lowerBound(this.#starts, from), width);
-		return run === -1 ? -1 : this.#starts[run]! + (this.#escaped[run] ? width : 0);
-	}
-
-	/** The first run at or after `first` that holds a closer of `width` backticks, or -1. */
-	#firstHolding(first: number, width: number): number {
-		if (first >= this.#starts.length) return -1;
-		const widest = this.#widest;
-		const leaves = this.#leaves;
-		let node = leaves + first;
-		if (widest[node]! >= width) return first;
-		// Up to the nearest subtree on the right that holds one, then down to its first run that does.
-		for (;;) {
-			if (node === 1) return -1;
-			if ((node & 1) === 0 && widest[node + 1]! >= width) break;
-			node >>= 1;
-		}
-		node++;
-		while (node < leaves) node = widest[2 * node]! >= width ? 2 * node : 2 * node + 1;
-		return node - leaves;
+		const starts = this.#byWidth.get(width);
+		if (starts === undefined) return -1;
+		const run = lowerBound(starts, from);
+		return run < starts.length ? starts[run]! : -1;
 	}
 }
 
@@ -388,10 +376,17 @@ export class InlineClosers {
 		return close === -1 ? -1 : close - pos;
 	}
 
-	/** How many backticks start `rest`, which starts with one. */
-	codeOpenerWidth(rest: string): number {
+	/**
+	 * How many backticks start `rest`, which starts with one, or 0 where no code span opens because no backtick string
+	 * starts there: the opener is a whole string, so the rest of a run whose opener found no closer is text, while the
+	 * backticks left after a backslash escaped the run's first one do open a span. `resumed` says the scan resumed at
+	 * `rest` after a tokenizer consumed a raw that ended here, where the backticks are a string wherever they sit.
+	 */
+	codeOpenerWidth(rest: string, resumed = false): number {
 		const pos = this.end - rest.length;
-		return Math.min(this.#indexes.codeRuns.endOf(pos), this.end) - pos;
+		const runs = this.#indexes.codeRuns;
+		if (!resumed && !runs.startsStringAt(pos)) return 0;
+		return Math.min(runs.endOf(pos), this.end) - pos;
 	}
 
 	/** Where the code span opened by the `width` backticks at the start of `rest` closes, or -1. */

package/src/mime.ts

@@ -11,6 +11,7 @@ const GIF89A = Buffer.from("GIF89a");
 const WEBP_VP8X = Buffer.from("VP8X");
 const WEBP_VP8L = Buffer.from("VP8L");
 const WEBP_VP8 = Buffer.from("VP8 ");
+const FTYP = Buffer.from("ftyp");
 
 export const SUPPORTED_IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
 
@@ -143,6 +144,40 @@ export function parseImageMetadata(header: Uint8Array): ImageMetadata | null {
 	);
 }
 
+/** Still images in a HEIF (ISO BMFF) container, which the image pipeline cannot decode itself. */
+export type HeifImageMimeType = "image/heic" | "image/heif" | "image/avif";
+
+const HEIF_BRAND_MIME_TYPES: Readonly<Record<string, HeifImageMimeType>> = {
+	heic: "image/heic",
+	heix: "image/heic",
+	heim: "image/heic",
+	heis: "image/heic",
+	hevc: "image/heic",
+	hevx: "image/heic",
+	avif: "image/avif",
+	avis: "image/avif",
+	mif1: "image/heif",
+	msf1: "image/heif",
+};
+
+/**
+ * MIME type of a HEIC, AVIF or other HEIF image from the brands of its leading `ftyp` box:
+ * the major brand, then the compatible brands, with the generic `mif1`/`msf1` brands last.
+ */
+export function parseHeifImageMimeType(header: Uint8Array): HeifImageMimeType | null {
+	if (!magicEquals(header, 4, FTYP)) return null;
+	const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+	const boxEnd = Math.min(view.getUint32(0, false), header.length);
+	let generic: HeifImageMimeType | null = null;
+	// The major brand sits at 8 and the compatible brands start at 16, after the minor version.
+	for (let offset = 8; offset + 4 <= boxEnd; offset += offset === 8 ? 8 : 4) {
+		const mimeType = HEIF_BRAND_MIME_TYPES[String.fromCharCode(...header.subarray(offset, offset + 4))];
+		if (mimeType === "image/heif") generic ??= mimeType;
+		else if (mimeType) return mimeType;
+	}
+	return generic;
+}
+
 /** Why base64 image data is unusable; `undefined` when it is canonical and non-empty. */
 export type Base64ImageDataFailure = "invalid base64 image data" | "empty image data";
 

package/src/postmortem.ts

@@ -27,10 +27,26 @@ interface CleanupRegistration {
 	id: string;
 	callback: (reason: Reason) => Promise<void> | void;
 	exitOnly: boolean;
+	/** How long a pass waits for this callback, when longer than {@link CLEANUP_DEADLINE_MS}. */
+	deadlineMs: number | undefined;
+	/** Printed to stderr when exit waits on this callback alone; see {@link CleanupRegistrationOptions.waitMessage}. */
+	waitMessage: string | undefined;
 	cancelled: boolean;
 	lastPass: number;
 }
 
+/** The deadline of one cleanup pass, which callbacks with their own `deadlineMs` hold open. */
+interface CleanupPassDeadline {
+	/**
+	 * Keep the pass open until `pending` settles, for at most `deadlineMs`. A
+	 * `waitMessage` is printed to stderr if the pass is still waiting on it once
+	 * every other callback has finished.
+	 */
+	extend(pending: Promise<unknown>, deadlineMs: number, waitMessage?: string): void;
+	/** Whether a callback with its own deadline still holds the pass open. */
+	extended(): boolean;
+}
+
 // Active cleanup callbacks in registration order. Registrations survive
 // keep-alive passes; `lastPass` enforces at-most-once invocation per pass.
 const callbackList: CleanupRegistration[] = [];
@@ -42,6 +58,8 @@ let activeCleanupKeepAlive = false;
 // Promises of callbacks invoked late (registered while a pass runs), joined by
 // the active pass before it settles so `cleanup()`/signal exits await them.
 let activeLatePromises: Promise<void>[] | undefined;
+// Deadline of the running pass, so callbacks invoked late can extend it too.
+let activePassDeadline: CleanupPassDeadline | undefined;
 const CLEANUP_DEADLINE_MS = 10_000;
 /**
  * Symbol stamped by the extension-load guard onto the throwing replacement it
@@ -122,7 +140,7 @@ export function exitProcess(code: number): never {
 let cleanupPromise: Promise<void> | undefined;
 let stdioDisconnectRegistrations = 0;
 
-/** User-facing command printed before fatal cleanup so interrupted work can be resumed. */
+/** User-facing command printed after fatal or SIGTERM cleanup so interrupted work can be resumed. */
 export interface FatalRecoveryHint {
 	/** Stable label identifying the recoverable session or process. */
 	label: string;
@@ -184,10 +202,75 @@ function runCleanup(reason: Reason, keepAlive = false): Promise<void> {
 		}
 	};
 
+	// The pass ends once every callback settles, or at the deadline: CLEANUP_DEADLINE_MS,
+	// held open while a callback with a longer `deadlineMs` is still pending.
+	const deadline = Promise.withResolvers<void>();
+	const deadlineTimers: NodeJS.Timeout[] = [];
+	let baseDeadlineElapsed = false;
+	let openExtensions = 0;
+	let passDone = false;
+	const expireIfDue = (): void => {
+		if (passDone || !baseDeadlineElapsed || openExtensions > 0) return;
+		passDone = true;
+		logger.error("Cleanup deadline exceeded; proceeding with exit", { reason });
+		settle();
+		deadline.resolve();
+	};
+	// Holds that still keep the pass open and have a message for the user. The
+	// message is printed once the pass waits on nothing else, so a terminal owner
+	// has already released the screen and the user sees why exit is slow.
+	const announced: { message: string; until: number; open: () => boolean }[] = [];
+	let othersSettled = false;
+	const announce = (): void => {
+		if (passDone || !othersSettled) return;
+		for (const hold of announced.splice(0)) {
+			if (!hold.open()) continue;
+			const seconds = Math.max(1, Math.ceil((hold.until - Date.now()) / 1000));
+			try {
+				fs.writeSync(2, `${hold.message} (up to ${seconds} s)…\n`);
+			} catch {}
+		}
+	};
+	const passDeadline: CleanupPassDeadline = {
+		extend(pending, deadlineMs, waitMessage) {
+			if (passDone || deadlineMs <= 0) return;
+			openExtensions++;
+			let open = true;
+			const close = (): void => {
+				if (!open) return;
+				open = false;
+				openExtensions--;
+				// Check on a later macrotask: when this was the last pending callback, the
+				// pass completes first and no deadline is reported.
+				deadlineTimers.push(setTimeout(expireIfDue, 0));
+			};
+			deadlineTimers.push(setTimeout(close, deadlineMs));
+			pending.then(close, close);
+			if (waitMessage !== undefined) {
+				announced.push({ message: waitMessage, until: Date.now() + deadlineMs, open: () => open });
+				// On a later macrotask, so a callback that is already done closes first.
+				if (othersSettled) deadlineTimers.push(setTimeout(announce, 0));
+			}
+		},
+		extended: () => !passDone && openExtensions > 0,
+	};
+	activePassDeadline = passDeadline;
+
 	// Snapshot the pass. Registrations added while a keep-alive cleanup runs are
 	// invoked by register() when appropriate and remain active for later passes.
-	const promises = callbackList.toReversed().map(registration => {
-		return Promise.try(() => invokeCleanup(registration, reason, keepAlive, pass));
+	const snapshot = callbackList.toReversed();
+	const promises = snapshot.map(registration => {
+		return Promise.try(() => {
+			const pending = invokeCleanup(registration, reason, keepAlive, pass);
+			if (pending && registration.deadlineMs !== undefined) {
+				passDeadline.extend(pending, registration.deadlineMs, registration.waitMessage);
+			}
+			return pending;
+		});
+	});
+	void Promise.allSettled(promises.filter((_, index) => snapshot[index]?.deadlineMs === undefined)).then(() => {
+		othersSettled = true;
+		deadlineTimers.push(setTimeout(announce, 0));
 	});
 
 	const cleanupSettled = Promise.allSettled(promises).then(async results => {
@@ -202,14 +285,20 @@ function runCleanup(reason: Reason, keepAlive = false): Promise<void> {
 		while (late.length > 0) await Promise.allSettled(late.splice(0));
 		settle();
 	});
-	const deadline = Promise.withResolvers<void>();
-	const deadlineTimer = setTimeout(() => {
-		logger.error("Cleanup deadline exceeded; proceeding with exit", { reason });
-		settle();
-		deadline.resolve();
-	}, CLEANUP_DEADLINE_MS);
+	deadlineTimers.push(
+		setTimeout(() => {
+			baseDeadlineElapsed = true;
+			// The pass no longer waits on the other callbacks, so a hold still open is
+			// what exit waits on; terminal owners released the screen synchronously.
+			othersSettled = true;
+			announce();
+			expireIfDue();
+		}, CLEANUP_DEADLINE_MS),
+	);
 	const passPromise = Promise.race([cleanupSettled, deadline.promise]).finally(() => {
-		clearTimeout(deadlineTimer);
+		passDone = true;
+		for (const timer of deadlineTimers) clearTimeout(timer);
+		if (activePassDeadline === passDeadline) activePassDeadline = undefined;
 		// A re-armed pass must drop only its own settled promise; an older
 		// deadline-limited pass may finish after a newer one has already started.
 		if (keepAlive && cleanupPass === pass && cleanupPromise === passPromise) cleanupPromise = undefined;
@@ -480,7 +569,10 @@ export function interceptUnhandledRejections(interceptor: (reason: unknown) => b
 
 /**
  * Register a synchronous recovery command to print when the process exits
- * through an uncaught exception or unhandled rejection.
+ * through an uncaught exception, an unhandled rejection, or SIGTERM.
+ *
+ * Providers are read once cleanup finishes (or hits its deadline), so they
+ * report what teardown left behind: a session it saved or one it dropped.
  */
 export function registerFatalRecoveryHint(provider: FatalRecoveryHintProvider): () => void {
 	fatalRecoveryHintProviders.add(provider);
@@ -494,10 +586,10 @@ function escapeFatalHintText(value: string): string {
 	});
 }
 
-function formatFatalRecoveryHints(): string {
+function formatFatalRecoveryHints(providers: Iterable<FatalRecoveryHintProvider>): string {
 	const lines: string[] = [];
 	const seenCommands = new Set<string>();
-	for (const provider of fatalRecoveryHintProviders) {
+	for (const provider of providers) {
 		try {
 			const hint = provider();
 			if (!hint?.command || seenCommands.has(hint.command)) continue;
@@ -519,21 +611,54 @@ function formatFatalError(label: string, err: Error): string {
 	return `\n[${label}] ${name}: ${message}${formattedStack}\n`;
 }
 
+/** Write a final report to stderr once terminal owners have handed the terminal back. */
+function writeTerminalReport(output: string): void {
+	restoreTerminalStderr();
+	// A revoked terminal can make stream writes raise another fatal error. Use
+	// the descriptor directly so failure stays synchronous and contained.
+	try {
+		fs.writeSync(2, output);
+	} catch {}
+}
+
+let recoveryHintsWritten = false;
+
+/**
+ * Print the recovery commands at most once per process. Callers snapshot the
+ * providers before cleanup, because a session's own cleanup unregisters its
+ * provider, and call this after cleanup, because teardown can still save the
+ * session (an unsent draft, an aborted first reply) or drop an empty one.
+ */
+function writeRecoveryHints(providers: readonly FatalRecoveryHintProvider[], heading = ""): void {
+	if (recoveryHintsWritten) return;
+	const hints = formatFatalRecoveryHints(providers);
+	if (!hints) return;
+	recoveryHintsWritten = true;
+	writeTerminalReport(`${heading}${hints}`);
+}
+
 async function exitAfterFatal(output: string, logMessage: string, err: Error, reason: Reason): Promise<never> {
-	const forcedExit = setTimeout(() => exitProcess(1), CLEANUP_DEADLINE_MS);
+	const hintProviders = [...fatalRecoveryHintProviders];
+	// The forced exit backs up the pass deadline, so it waits while a callback with
+	// its own `deadlineMs` holds the pass open; that pass still ends at its deadline.
+	const forceExit = (): void => {
+		if (activePassDeadline?.extended()) {
+			forcedExit = setTimeout(forceExit, CLEANUP_DEADLINE_MS);
+			return;
+		}
+		writeRecoveryHints(hintProviders);
+		exitProcess(1);
+	};
+	let forcedExit = setTimeout(forceExit, CLEANUP_DEADLINE_MS);
 	try {
 		// Cleanup callbacks are invoked synchronously before runCleanup returns its
 		// completion promise. TUI owners therefore hand the cursor back before the
 		// fatal report is written, while slower resource cleanup continues afterward.
 		const cleanup = runCleanup(reason);
-		restoreTerminalStderr();
-		// A revoked terminal can make stream writes raise another fatal error. Use
-		// the descriptor directly so failure stays synchronous and contained.
-		try {
-			fs.writeSync(2, output);
-		} catch {}
+		writeTerminalReport(output);
 		logger.error(logMessage, { err });
 		await cleanup;
+		writeRecoveryHints(hintProviders);
 	} finally {
 		clearTimeout(forcedExit);
 		exitProcess(1);
@@ -552,12 +677,12 @@ function handleWorkerSendEpipe(err: Error): boolean {
  */
 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()}`;
+	const report = `${Bun.inspect(error, { colors: process.stderr.isTTY === true })}\n`;
 	if (!Bun.isMainThread) {
-		process.stderr.write(output);
+		process.stderr.write(`${report}${formatFatalRecoveryHints(fatalRecoveryHintProviders)}`);
 		process.exit(1);
 	}
-	return exitAfterFatal(output, "Fatal error", err, Reason.UNHANDLED_REJECTION);
+	return exitAfterFatal(report, "Fatal error", err, Reason.UNHANDLED_REJECTION);
 }
 
 if (Bun.isMainThread) {
@@ -607,7 +732,7 @@ if (Bun.isMainThread) {
 				return;
 			}
 			await exitAfterFatal(
-				`${formatFatalError("Uncaught Exception", err)}${formatFatalRecoveryHints()}`,
+				formatFatalError("Uncaught Exception", err),
 				"Uncaught exception",
 				err,
 				Reason.UNCAUGHT_EXCEPTION,
@@ -630,7 +755,7 @@ if (Bun.isMainThread) {
 				}
 			}
 			await exitAfterFatal(
-				`${formatFatalError("Unhandled Rejection", err)}${formatFatalRecoveryHints()}`,
+				formatFatalError("Unhandled Rejection", err),
 				"Unhandled rejection",
 				err,
 				Reason.UNHANDLED_REJECTION,
@@ -640,7 +765,12 @@ if (Bun.isMainThread) {
 			void runCleanup(Reason.EXIT); // fire and forget (exit imminent)
 		})
 		.on("SIGTERM", async () => {
+			// A stopped session otherwise leaves its last frame above the shell prompt,
+			// which reads as a crash. A repeated SIGTERM joins the same cleanup and the
+			// hints still print once.
+			const hintProviders = [...fatalRecoveryHintProviders];
 			await runCleanup(Reason.SIGTERM);
+			writeRecoveryHints(hintProviders, "\n[Stopped by SIGTERM]");
 			exitProcess(143); // 128 + SIGTERM (15)
 		})
 		.on("SIGHUP", async () => {
@@ -664,6 +794,20 @@ export interface CleanupRegistrationOptions {
 	 * The registration remains armed when a keep-alive pass skips it.
 	 */
 	exitOnly?: boolean;
+	/**
+	 * How long a pass waits for this callback, when that is longer than the
+	 * default 10 s cleanup deadline. It extends the pass only while the callback
+	 * is still pending: one that settles early ends its hold at once.
+	 */
+	deadlineMs?: number;
+	/**
+	 * With `deadlineMs`: a line printed to stderr, with the remaining wait
+	 * appended, if exit is still waiting on this callback once every other
+	 * callback has finished (a terminal owner has then released the screen), or
+	 * at the default 10 s deadline when another callback is still running.
+	 * Nothing is printed when the callback finishes first.
+	 */
+	waitMessage?: string;
 }
 
 /**
@@ -690,6 +834,8 @@ export function register(
 		id,
 		callback,
 		exitOnly: options.exitOnly ?? false,
+		deadlineMs: options.deadlineMs,
+		waitMessage: options.waitMessage,
 		cancelled: false,
 		lastPass: 0,
 	};
@@ -709,6 +855,9 @@ export function register(
 			// Join the active pass so cleanup()/signal exits await it; after a
 			// completed exit pass there is nothing left to join.
 			activeLatePromises?.push(tracked);
+			if (registration.deadlineMs !== undefined) {
+				activePassDeadline?.extend(tracked, registration.deadlineMs, registration.waitMessage);
+			}
 		} catch (error) {
 			const err = error instanceof Error ? error : new Error(String(error));
 			logger.error("Cleanup callback failed", { err, id, stack: err.stack });

package/src/process-name.ts

@@ -10,9 +10,11 @@
  * setter) and additionally drive `prctl` via `bun:ffi` on Linux, mirroring the
  * libc-FFI pattern in `ttyid.ts` / `stderr-guard.ts`.
  *
- * macOS has no clean userspace equivalent for the shebang-run path, and on
- * Windows / compiled binaries the kernel derives the name from the exec'd file,
- * so those paths already report correctly; there we only set `process.title`.
+ * macOS has no clean userspace equivalent for the shebang-run path, so there
+ * we only set `process.title`. Windows derives the name from the exec'd file,
+ * and there Bun's `process.title` setter is libuv's `SetConsoleTitleW`: every
+ * omp child attached to a pane's console (workers, `browser-relay`, servers)
+ * would overwrite that pane's tab title, so Windows skips it entirely.
  */
 import { dlopen, FFIType, ptr } from "bun:ffi";
 import * as os from "node:os";
@@ -21,17 +23,20 @@ import * as os from "node:os";
 const PR_SET_NAME = 15;
 
 /**
- * Set both the JS `process.title` and — on Linux — the kernel `comm` name.
+ * Set the JS `process.title` (except on Windows, see above) and — on Linux —
+ * the kernel `comm` name.
  *
  * Never throws: `bun:ffi` unavailability or a failed syscall degrades silently
  * to the `process.title`-only behavior, so it is safe to call at startup.
  */
 export function setProcessName(name: string): void {
+	const platform = os.platform();
+	if (platform === "win32") return;
 	try {
 		process.title = name;
 	} catch {}
 
-	if (os.platform() !== "linux") return;
+	if (platform !== "linux") return;
 
 	// glibc first, then the generic soname for musl-style layouts (see stderr-guard.ts).
 	for (const soname of ["libc.so.6", "libc.so"]) {

package/src/stream.ts

@@ -2,6 +2,7 @@ const trailingEvents = new WeakSet<ServerSentEvent>();
 
 import { abortableSource } from "./abortable";
 import { parseStreamingJson } from "./json-parse";
+import { isWhitespace } from "./json-lexer";
 
 const LF = 0x0a;
 const CR = 0x0d;
@@ -613,9 +614,11 @@ export async function* readSseEvents(
  */
 export function parseJsonlLenient<T>(buffer: string, options: { onMalformedRecord?: () => void } = {}): T[] {
 	let entries: T[] | undefined;
+	let cursor = 0;
+	const len = buffer.length;
 
-	while (buffer.length > 0) {
-		const { values, error, read, done } = Bun.JSONL.parseChunk(buffer);
+	while (cursor < len) {
+		const { values, error, read, done } = Bun.JSONL.parseChunk(buffer, cursor);
 		if (values.length > 0) {
 			const ext = values as T[];
 			if (!entries) {
@@ -625,18 +628,22 @@ export function parseJsonlLenient<T>(buffer: string, options: { onMalformedRecor
 			}
 		}
 		if (error) {
-			const nextNewline = buffer.indexOf("\n", read);
-			const malformedEnd = nextNewline === -1 ? buffer.length : nextNewline;
-			if (buffer.substring(read, malformedEnd).trim().length > 0) options.onMalformedRecord?.();
+			let malformedStart = read;
+			while (malformedStart < len && isWhitespace(buffer.charCodeAt(malformedStart))) {
+				malformedStart++;
+			}
+			const nextNewline = buffer.indexOf("\n", malformedStart);
+			const malformedEnd = nextNewline === -1 ? len : nextNewline;
+			if (buffer.substring(malformedStart, malformedEnd).trim().length > 0) options.onMalformedRecord?.();
 			if (nextNewline === -1) break;
-			buffer = buffer.substring(nextNewline + 1);
+			cursor = nextNewline + 1;
 			continue;
 		}
-		if (read === 0) {
-			if (buffer.trim().length > 0) options.onMalformedRecord?.();
+		if (read === cursor) {
+			if (buffer.substring(cursor).trim().length > 0) options.onMalformedRecord?.();
 			break;
 		}
-		buffer = buffer.substring(read);
+		cursor = read;
 		if (done) break;
 	}
 	return entries ?? [];

package/src/which.ts

@@ -261,3 +261,30 @@ export function $which(command: string, options?: WhichOptions): string | null {
 	}
 	return result;
 }
+
+/**
+ * Locate every match for `command` on PATH, in PATH order, uncached.
+ *
+ * Callers that probe candidates (e.g. the Python eval backend) use this so a broken
+ * first hit — a version-manager shim with no version selected, a Windows Store alias —
+ * does not hide a working binary further down PATH. On macOS the Xcode/CLT toolchain
+ * match is appended last, mirroring {@link $which}'s fallback.
+ *
+ * @param command - Binary name to resolve
+ * @param options - `PATH` (defaults to `process.env.PATH`) and `cwd` for relative entries
+ * @returns Distinct filesystem paths; empty when nothing matches
+ */
+export function $whichAll(command: string, options?: Bun.WhichOptions): string[] {
+	const searchPath = options?.PATH ?? process.env.PATH ?? "";
+	const matches: string[] = [];
+	for (const dir of searchPath.split(path.delimiter)) {
+		if (!dir) continue;
+		const match = Bun.which(command, { cwd: options?.cwd, PATH: dir });
+		if (match && !matches.includes(match)) matches.push(match);
+	}
+	if (os.platform() === "darwin" && isXcodeBin(command)) {
+		const toolchainMatch = getMacosToolPaths().get(command);
+		if (toolchainMatch && !matches.includes(toolchainMatch)) matches.push(toolchainMatch);
+	}
+	return matches;
+}