@oh-my-pi/pi-utils 18.0.10 → 18.1.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [18.1.0] - 2026-09-01
+
+### Added
+
+- Added `postmortem.fatal` for terminal-safe top-level failure reporting.
+
+### Fixed
+
+- Fixed sub-second duration formatting so it no longer exposes floating-point precision noise.
+- Managed Chrome-for-Testing downloads now reject unsupported Linux ARM64 hosts instead of installing an incompatible x86_64 browser.
+- Fixed Markdown reference-link labels that match built-in `Object.prototype` names, such as `constructor` and `__proto__`, so they are no longer misidentified as definitions or emitted with an undefined URL ([#10283](https://github.com/can1357/oh-my-pi/issues/10283)).
+
+## [18.0.11] - 2026-08-29
+
+### Fixed
+
+- Fixed runtime installation getting stuck for up to 60 seconds after an installer crash or forced termination, allowing subsequent installation attempts to proceed normally.
+
 ## [18.0.10] - 2026-08-28
 
 ### Added

package/dist/types/env.d.ts

@@ -16,6 +16,15 @@ export declare function isValidEnvName(name: string): boolean;
 export declare function isSafeEnvName(name: string): boolean;
 export declare function isSafeEnvValue(value: string): boolean;
 export declare function isMacosMallocStackLoggingEnvName(name: string): boolean;
+/**
+ * True when running inside a WSL (Windows Subsystem for Linux) distribution.
+ *
+ * WSL reports `linux` for `process.platform`, so the only reliable signal is
+ * the `WSL_DISTRO_NAME`/`WSL_INTEROP` variables the interop layer injects.
+ * Callers use this to translate Windows drive paths to their `/mnt/<drive>`
+ * mounts and to route clipboard access through `powershell.exe`.
+ */
+export declare function isWsl(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): boolean;
 export declare function filterProcessEnv(env: Record<string, string | undefined>): Record<string, string>;
 /** 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>;

package/dist/types/path.d.ts

@@ -1,2 +1,4 @@
+/** Maps an absolute Windows drive path to the drive's default WSL mount. */
+export declare function windowsPathToWslMount(filePath: string): string | undefined;
 /** Removes Win32 extended-length prefixes before passing paths to Bun APIs. */
 export declare function stripWindowsExtendedLengthPathPrefix(filePath: string, platform?: NodeJS.Platform): string;

package/dist/types/postmortem.d.ts

@@ -123,6 +123,10 @@ export declare function interceptUnhandledRejections(interceptor: (reason: unkno
  * through an uncaught exception or unhandled rejection.
  */
 export declare function registerFatalRecoveryHint(provider: FatalRecoveryHintProvider): () => void;
+/**
+ * Reports a caught top-level failure after terminal owners restore their display, then exits.
+ */
+export declare function fatal(error: unknown): Promise<never>;
 /** Controls when a registered cleanup callback participates in cleanup passes. */
 export interface CleanupRegistrationOptions {
     /**

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

@@ -73,6 +73,13 @@ export interface EnsureRuntimeInstalledOptions {
 export declare function writeRuntimeManifest(runtimeDir: string, install: RuntimeInstallSpec): Promise<void>;
 /**
  * Materialize a pinned dependency set into `runtimeDir` (idempotent,
- * cross-process safe via a lock directory). Returns `runtimeDir`.
+ * cross-process safe). Returns `runtimeDir`.
+ *
+ * Serialization uses the OS-backed {@link withFileLock} at
+ * `${runtimeDir}.install.lock`, which the kernel releases on process death, so
+ * a crashed installer cannot wedge later attempts (issue #10120). The path is
+ * deliberately distinct from the legacy `${runtimeDir}.lock` mkdir directory;
+ * {@link withLegacyInstallLock} atomically reserves that namespace during the
+ * new install so older processes cannot cross the migration boundary.
  */
 export declare function ensureRuntimeInstalled(options: EnsureRuntimeInstalledOptions): Promise<string>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-utils",
-	"version": "18.0.10",
+	"version": "18.1.0",
 	"description": "Shared utilities for pi packages",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -23,15 +23,15 @@
 	"main": "./src/index.ts",
 	"types": "./dist/types/index.d.ts",
 	"scripts": {
-		"check": "biome check . && bun run check:types",
+		"check": "oxlint . && oxfmt --check --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts' && bun run check:types",
 		"check:types": "tsgo -p tsconfig.json --noEmit",
-		"lint": "biome lint .",
+		"lint": "oxlint .",
 		"test": "bun test --parallel",
-		"fix": "biome check --write --unsafe .",
-		"fmt": "biome format --write ."
+		"fix": "oxlint --fix --fix-suggestions . && bun run fmt",
+		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "18.0.10"
+		"@oh-my-pi/pi-natives": "18.1.0"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/acp/connection.ts

@@ -67,13 +67,11 @@ export class AgentSideConnection {
 	#connection: RpcConnection;
 
 	constructor(toAgent: (connection: AgentSideConnection) => Agent, stream: Stream) {
-		let agent: Agent | undefined;
 		this.#connection = new RpcConnection(stream, async (method, params, notification) => {
-			const target = agent;
-			if (!target) throw RequestError.internalError(undefined, "Agent is not initialized");
-			return dispatchAgent(target, method, params, notification);
+			if (!agent) throw RequestError.internalError(undefined, "Agent is not initialized");
+			return dispatchAgent(agent, method, params, notification);
 		});
-		agent = toAgent(this);
+		const agent = toAgent(this);
 	}
 
 	/** Signal aborted when the transport closes. */
@@ -170,13 +168,11 @@ export class ClientSideConnection {
 	#connection: RpcConnection;
 
 	constructor(toClient: (connection: ClientSideConnection) => Client, stream: Stream) {
-		let client: Client | undefined;
 		this.#connection = new RpcConnection(stream, async (method, params, notification) => {
-			const target = client;
-			if (!target) throw RequestError.internalError(undefined, "Client is not initialized");
-			return dispatchClient(target, method, params, notification);
+			if (!client) throw RequestError.internalError(undefined, "Client is not initialized");
+			return dispatchClient(client, method, params, notification);
 		});
-		client = toClient(this);
+		const client = toClient(this);
 	}
 	/** Signal aborted when the transport closes. */
 	get signal(): AbortSignal {

package/src/ar/entries.ts

@@ -45,7 +45,7 @@ export function upsertArchiveEntry(
  */
 export function ensureParentDirectories(map: Map<string, ArchiveIndexEntry>, limits: ArchiveLimits): void {
 	assertEntryCount(map.size, limits);
-	for (const entry of [...map.values()]) {
+	for (const entry of Array.from(map.values())) {
 		const parts = entry.path.split("/");
 		const stop = parts.length - 1;
 		for (let index = 1; index <= stop; index++) {
@@ -73,7 +73,7 @@ export function resolveArchiveLinkPath(
 ): string {
 	let resolvedPath = archivePath;
 	const seen = new Set<string>();
-	for (let rewrites = 0; !seen.has(resolvedPath); ) {
+	for (let rewrites = 0; !seen.has(resolvedPath);) {
 		seen.add(resolvedPath);
 		let replacement: string | undefined;
 		for (let end = resolvedPath.length; end > 0; end = resolvedPath.lastIndexOf("/", end - 1)) {

package/src/ar/iso.ts

@@ -324,7 +324,7 @@ function decodeIdentifier(identifier: Uint8Array, joliet: boolean): string {
 
 function findSuspSkip(record: IsoRecord): number | undefined {
 	const bytes = record.systemUse;
-	for (let offset = 0; offset + 7 <= bytes.byteLength; ) {
+	for (let offset = 0; offset + 7 <= bytes.byteLength;) {
 		const length = bytes[offset + 2]!;
 		if (length < 4 || offset + length > bytes.byteLength) return undefined;
 		if (
@@ -359,7 +359,7 @@ async function parseSusp(
 	let relocation: SuspData["relocation"];
 	for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
 		const area = queue[queueIndex]!;
-		for (let offset = 0; offset + 4 <= area.byteLength; ) {
+		for (let offset = 0; offset + 4 <= area.byteLength;) {
 			const signature = String.fromCharCode(area[offset]!, area[offset + 1]!);
 			const length = area[offset + 2]!;
 			const version = area[offset + 3]!;
@@ -466,7 +466,7 @@ async function readDirectoryRecords(
 	const end = safeAdd(start, record.size, "directory extent range");
 	const bytes = await budget.read(source, start, end, "directory extent");
 	const records: IsoRecord[] = [];
-	for (let offset = 0; offset < bytes.byteLength; ) {
+	for (let offset = 0; offset < bytes.byteLength;) {
 		const sectorRemaining = blockSize - (offset % blockSize);
 		const length = bytes[offset]!;
 		if (length === 0) {
@@ -586,7 +586,7 @@ async function readIsoImpl(source: ByteSource, options: Parameters<FormatReader>
 		) {
 			suspSkip = findSuspSkip(records[0]!);
 		}
-		for (let index = 0; index < records.length; ) {
+		for (let index = 0; index < records.length;) {
 			const record = records[index]!;
 			if (record.identifier.byteLength === 1 && (record.identifier[0] === 0 || record.identifier[0] === 1)) {
 				index++;

package/src/ar/rar/rar4-decoder.ts

@@ -45,7 +45,7 @@ class Bits {
 	read(count: number): number {
 		if (count === 0) return 0;
 		let value = 0;
-		for (let left = count; left > 0; ) {
+		for (let left = count; left > 0;) {
 			if (this.pos >= this.bytes.byteLength - 4) corrupt("truncated compressed data");
 			const take = Math.min(left, 8 - this.bit);
 			value = value * 2 ** take + ((this.bytes[this.pos]! >>> (8 - this.bit - take)) & (2 ** take - 1));
@@ -340,7 +340,7 @@ class VmBits {
 
 	read(count: number): number {
 		let value = 0;
-		for (let left = count; left > 0; ) {
+		for (let left = count; left > 0;) {
 			const bytePosition = this.#position >>> 3;
 			if (bytePosition >= this.#bytes.byteLength) corrupt("truncated RarVM code");
 			const bitPosition = this.#position & 7;
@@ -393,7 +393,7 @@ function applyFilters(output: Uint8Array, filters: PendingFilter[]): void {
 			continue;
 		}
 		const compareOpcode = filter.type === 2 ? 0xe9 : 0xe8;
-		for (let position = 0; position + 4 < data.byteLength; ) {
+		for (let position = 0; position + 4 < data.byteLength;) {
 			const opcode = data[position++]!;
 			if (opcode !== 0xe8 && opcode !== compareOpcode) continue;
 			const offset = position + (filter.fileOffset >>> 0);
@@ -437,7 +437,7 @@ function readLengthTable(bits: Bits, previous: Uint8Array, size: number): Uint8A
 	const preTable = new Huffman(20);
 	preTable.build(preLengths, 0, 20);
 	const lengths = new Uint8Array(size);
-	for (let position = 0; position < size; ) {
+	for (let position = 0; position < size;) {
 		const symbol = preTable.decode(bits);
 		if (symbol < 16) {
 			lengths[position] = (symbol + previous[position]!) & 15;

package/src/ar/rar/rar5-decoder.ts

@@ -33,7 +33,7 @@ class Bits {
 		if (n === 0) return 0;
 		if (n < 0 || n > 31) fail("invalid bit count");
 		let value = 0;
-		for (let left = n; left > 0; ) {
+		for (let left = n; left > 0;) {
 			if (this.pos >= this.bytes.byteLength - 16) fail("truncated compressed data");
 			const take = Math.min(left, 8 - this.bit);
 			value = value * 2 ** take + ((this.bytes[this.pos]! >>> (8 - this.bit - take)) & (2 ** take - 1));
@@ -211,7 +211,7 @@ export class Rar5Decoder {
 			if ((flags & 0x80) === 0) return;
 
 			const levelLengths = new Uint8Array(20);
-			for (let i = 0; i < 20; ) {
+			for (let i = 0; i < 20;) {
 				const length = bits.read(4);
 				if (length === 15) {
 					const zeros = bits.read(4);
@@ -226,7 +226,7 @@ export class Rar5Decoder {
 			level.build(levelLengths);
 			const tableLength = version === 1 ? TABLE_SIZE : TABLE_SIZE - 16;
 			const lengthsCompact = new Uint8Array(tableLength);
-			for (let i = 0; i < tableLength; ) {
+			for (let i = 0; i < tableLength;) {
 				const symbol = level.decode(bits);
 				if (symbol < 16) {
 					lengthsCompact[i++] = symbol;
@@ -358,7 +358,7 @@ function applyFilters(output: Uint8Array, filters: Filter[]): void {
 			}
 		} else if (filter.type === 1 || filter.type === 2) {
 			const fileSize = 1 << 24;
-			for (let pos = 0; pos + 4 < data.byteLength; ) {
+			for (let pos = 0; pos + 4 < data.byteLength;) {
 				const opcode = data[pos++]!;
 				if (opcode !== 0xe8 && (filter.type === 1 || opcode !== 0xe9)) continue;
 				const offset = (filter.start + pos) & (fileSize - 1);

package/src/ar/sevenzip.ts

@@ -107,6 +107,7 @@ interface FileMetadata {
 }
 
 function readBoolVector(reader: HeaderReader, count: number): boolean[] {
+	// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 	const result = new Array<boolean>(count);
 	let byte = 0;
 	let mask = 0;
@@ -122,12 +123,16 @@ function readBoolVector(reader: HeaderReader, count: number): boolean[] {
 }
 
 function readDefinedVector(reader: HeaderReader, count: number): boolean[] {
-	if (reader.readByte() !== 0) return new Array<boolean>(count).fill(true);
+	if (reader.readByte() !== 0) {
+		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
+		return new Array<boolean>(count).fill(true);
+	}
 	return readBoolVector(reader, count);
 }
 
 function readDigests(reader: HeaderReader, count: number): Digests {
 	const defined = readDefinedVector(reader, count);
+	// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 	const values = new Array<number | undefined>(count);
 	for (let index = 0; index < count; index++) if (defined[index]) values[index] = reader.readUInt32();
 	return { defined, values };
@@ -229,7 +234,10 @@ function parsePackInfo(reader: HeaderReader, streams: SevenZipStreams, options:
 		} else reader.skipSizedProperty();
 	}
 	if (streams.packSizes.length !== count) throw new ArchiveError("Invalid 7z PackInfo without complete sizes");
-	if (streams.packCrcs.length === 0) streams.packCrcs = new Array(count).fill(undefined);
+	if (streams.packCrcs.length === 0) {
+		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
+		streams.packCrcs = new Array(count).fill(undefined);
+	}
 }
 
 function parseUnpackInfo(reader: HeaderReader, streams: SevenZipStreams, options: FormatReadOptions): void {
@@ -254,6 +262,7 @@ function parseUnpackInfo(reader: HeaderReader, streams: SevenZipStreams, options
 }
 
 function parseSubStreamsInfo(reader: HeaderReader, streams: SevenZipStreams): void {
+	// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 	const counts = new Array<number>(streams.folders.length).fill(1);
 	let sizes: number[] | undefined;
 	let rawDigests: Digests | undefined;
@@ -398,6 +407,7 @@ function parseNames(reader: HeaderReader, count: number, external: Uint8Array[],
 function parseTimes(reader: HeaderReader, count: number, external: Uint8Array[]): Array<number | undefined> {
 	const defined = readDefinedVector(reader, count);
 	const values = selectPropertyStream(reader, external);
+	// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 	const result = new Array<number | undefined>(count);
 	for (let index = 0; index < count; index++)
 		if (defined[index]) {
@@ -411,6 +421,7 @@ function parseTimes(reader: HeaderReader, count: number, external: Uint8Array[])
 function parseAttributes(reader: HeaderReader, count: number, external: Uint8Array[]): Array<number | undefined> {
 	const defined = readDefinedVector(reader, count);
 	const values = selectPropertyStream(reader, external);
+	// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 	const result = new Array<number | undefined>(count);
 	for (let index = 0; index < count; index++) if (defined[index]) result[index] = values.readUInt32();
 	return result;
@@ -420,11 +431,15 @@ function parseFilesInfo(reader: HeaderReader, external: Uint8Array[], options: F
 	const count = reader.readNumber("file count");
 	assertEntryCount(count, options.limits);
 	const metadata: FileMetadata = {
+		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 		names: new Array<string>(count).fill(""),
+		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 		emptyStreams: new Array<boolean>(count).fill(false),
 		emptyFiles: [],
 		antiFiles: [],
+		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 		mtimes: new Array<number | undefined>(count),
+		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 		attributes: new Array<number | undefined>(count),
 	};
 	for (;;) {

package/src/ar/unix-ar.ts

@@ -197,7 +197,7 @@ export function readUnixArEntriesFromBuffer(bytes: Uint8Array, options: FormatRe
 	const records: RawArMember[] = [];
 	let longNames: Uint8Array | undefined;
 	let metadataSize = 0;
-	for (let position = SIGNATURE.length; position < bytes.byteLength; ) {
+	for (let position = SIGNATURE.length; position < bytes.byteLength;) {
 		if (bytes.byteLength - position < HEADER_SIZE)
 			throw new ArchiveError("Invalid ar archive: truncated member header");
 		const header = parseHeader(readMemoryRange(bytes, position, position + HEADER_SIZE));
@@ -255,7 +255,7 @@ async function readUnixArImpl(source: ByteSource, options: FormatReadOptions): P
 	const records: RawArMember[] = [];
 	let longNames: Uint8Array | undefined;
 	let metadataSize = 0;
-	for (let position = SIGNATURE.length; position < source.size; ) {
+	for (let position = SIGNATURE.length; position < source.size;) {
 		const headerBytes = await readExact(source, position, position + HEADER_SIZE, "member header");
 		const header = parseHeader(headerBytes);
 		metadataSize += HEADER_SIZE;

package/src/browsers.ts

@@ -39,6 +39,13 @@ export enum BrowserPlatform {
 	WIN32 = "win32",
 	WIN64 = "win64",
 }
+type ChromeForTestingPlatform = Exclude<BrowserPlatform, BrowserPlatform.LINUX_ARM>;
+
+function requireChromeForTestingPlatform(platform: BrowserPlatform): ChromeForTestingPlatform {
+	if (platform === BrowserPlatform.LINUX_ARM)
+		throw new Error("Chrome for Testing does not provide linux/arm64 builds");
+	return platform;
+}
 
 const BROWSERS = [
 	Browser.CHROME,
@@ -163,13 +170,13 @@ export function getDownloadUrl(
 
 /** Compute the executable path in Puppeteer's cache layout. */
 export function computeExecutablePath(options: ComputeExecutablePathOptions): string {
-	const platform = options.platform ?? detectBrowserPlatform();
-	if (!platform) throw new Error("Cannot determine a browser platform for this host");
+	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);
 	switch (platform) {
 		case BrowserPlatform.LINUX:
-		case BrowserPlatform.LINUX_ARM:
 			return path.join(installDir, "chrome-linux64", "chrome");
 		case BrowserPlatform.MAC:
 			return path.join(
@@ -292,9 +299,8 @@ async function fetchMetadata<T>(filename: string): Promise<T> {
 }
 
 function chromeArchivePlatform(platform: BrowserPlatform): string {
-	switch (platform) {
+	switch (requireChromeForTestingPlatform(platform)) {
 		case BrowserPlatform.LINUX:
-		case BrowserPlatform.LINUX_ARM:
 			return "linux64";
 		case BrowserPlatform.MAC:
 			return "mac-x64";

package/src/dates.ts

@@ -100,7 +100,7 @@ export function format(value: Date | number, pattern: string): string {
 	const date = asDate(value);
 	let result = "";
 
-	for (let index = 0; index < pattern.length; ) {
+	for (let index = 0; index < pattern.length;) {
 		if (pattern[index] === "'") {
 			if (pattern[index + 1] === "'") {
 				result += "'";

package/src/docx/converter.ts

@@ -530,7 +530,7 @@ function renderList(
 
 function renderBlocks(blocks: readonly Block[]): string {
 	let html = "";
-	for (let index = 0; index < blocks.length; ) {
+	for (let index = 0; index < blocks.length;) {
 		const block = blocks[index];
 		if (block.kind === "html") {
 			html += block.html;
@@ -549,7 +549,7 @@ function renderBlocks(blocks: readonly Block[]): string {
 			listItems.push(candidate);
 			index++;
 		}
-		for (let itemIndex = 0; itemIndex < listItems.length; ) {
+		for (let itemIndex = 0; itemIndex < listItems.length;) {
 			const rendered = renderList(listItems, itemIndex, listItems[itemIndex].list?.level ?? 0);
 			html += rendered.html;
 			itemIndex = rendered.next;

package/src/dom/core.ts

@@ -105,7 +105,7 @@ export class EventTarget {
 	dispatchEvent(event: Event): boolean {
 		if (!event.target) event.target = this;
 		event.currentTarget = this;
-		for (const listener of [...(this.#listeners.get(event.type) ?? [])]) {
+		for (const listener of Array.from(this.#listeners.get(event.type) ?? [])) {
 			if (typeof listener === "function") listener.call(this, event);
 			else listener.handleEvent(event);
 			if (event.propagationStopped) break;
@@ -196,7 +196,7 @@ export class Node extends EventTarget {
 		const node: Node = child;
 		if (node === this || node.contains(this)) throw new Error("The new child is an ancestor of this node");
 		if (child instanceof DocumentFragment) {
-			for (const nested of [...child.childNodes]) this.appendChild(nested);
+			for (const nested of Array.from(child.childNodes)) this.appendChild(nested);
 			return child;
 		}
 		child.parentNode?.removeChild(child);
@@ -212,7 +212,7 @@ export class Node extends EventTarget {
 		const index = this.childNodes.indexOf(reference);
 		if (index < 0) throw new Error("The reference node is not a child of this node");
 		if (child instanceof DocumentFragment) {
-			for (const nested of [...child.childNodes]) this.insertBefore(nested, reference);
+			for (const nested of Array.from(child.childNodes)) this.insertBefore(nested, reference);
 			return child;
 		}
 		child.parentNode?.removeChild(child);
@@ -681,7 +681,7 @@ export class Element extends Node {
 		const parent = this.parentNode;
 		if (!parent) return;
 		const fragment = parseFragment(value, this.documentForCreation(), this.parentElement?.localName);
-		for (const child of [...fragment.childNodes]) parent.insertBefore(child, this);
+		for (const child of Array.from(fragment.childNodes)) parent.insertBefore(child, this);
 		parent.removeChild(this);
 	}
 

package/src/env.ts

@@ -36,6 +36,18 @@ export function isMacosMallocStackLoggingEnvName(name: string): boolean {
 	return name === "MallocStackLogging" || name === "MallocStackLoggingNoCompact";
 }
 
+/**
+ * True when running inside a WSL (Windows Subsystem for Linux) distribution.
+ *
+ * WSL reports `linux` for `process.platform`, so the only reliable signal is
+ * the `WSL_DISTRO_NAME`/`WSL_INTEROP` variables the interop layer injects.
+ * Callers use this to translate Windows drive paths to their `/mnt/<drive>`
+ * mounts and to route clipboard access through `powershell.exe`.
+ */
+export function isWsl(platform: NodeJS.Platform = process.platform, env: NodeJS.ProcessEnv = process.env): boolean {
+	return platform === "linux" && Boolean(env.WSL_DISTRO_NAME || env.WSL_INTEROP);
+}
+
 export function filterProcessEnv(env: Record<string, string | undefined>): Record<string, string> {
 	const result: Record<string, string> = {};
 	for (const key in env) {

package/src/format.ts

@@ -9,7 +9,7 @@ const DAY = 24 * HOUR;
  */
 export function formatDuration(ms: number): string {
 	if (!Number.isFinite(ms) || ms <= 0) return "0ms";
-	if (ms < SEC) return `${ms}ms`;
+	if (ms < SEC) return `${Math.floor(ms)}ms`;
 	if (ms < MIN) return `${(ms / SEC).toFixed(1)}s`;
 	if (ms < HOUR) {
 		const mins = Math.floor(ms / MIN);

package/src/frontmatter.ts

@@ -22,6 +22,7 @@ export function normalizeFrontmatterKeys<T>(obj: T): T {
 	if (obj === null || typeof obj !== "object") return obj;
 	if (Array.isArray(obj)) {
 		let changed = false;
+		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 		const out: unknown[] = new Array(obj.length);
 		for (let i = 0; i < obj.length; i++) {
 			const v = obj[i];

package/src/marked/core.ts

@@ -343,8 +343,15 @@ const DEFAULTS: MarkedOptions = {
 };
 const PUNCTUATION = /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/;
 
-function tokenList(links: Links = {}): TokensList {
+function tokenList(links: Links = Object.create(null)): TokensList {
 	const list = [] as unknown as TokensList;
+	// The reference-definition map is keyed by user-controlled labels. A plain
+	// `{}` inherits `Object.prototype`, so a reference-style link whose label is
+	// an inherited member (`[x][constructor]`, `[x][__proto__]`) resolves to a
+	// truthy non-definition and yields a link token with `href: undefined`
+	// (issue #10283). A null-prototype map makes such lookups miss, so the link
+	// correctly falls back to literal text, and label writes cannot pollute the
+	// prototype.
 	list.links = links;
 	return list;
 }

package/src/path.ts

@@ -1,3 +1,17 @@
+import * as path from "node:path";
+
+const WINDOWS_DRIVE_PATH = /^([A-Za-z]):[\\/](.*)$/;
+
+/** Maps an absolute Windows drive path to the drive's default WSL mount. */
+export function windowsPathToWslMount(filePath: string): string | undefined {
+	const normalized = path.win32.normalize(filePath.trim());
+	const match = WINDOWS_DRIVE_PATH.exec(normalized);
+	if (!match) return undefined;
+	const [, drive, rest] = match;
+	const segments = rest.split("\\").filter(Boolean);
+	return path.posix.join("/mnt", drive!.toLowerCase(), ...segments);
+}
+
 const WINDOWS_DRIVE_EXTENDED_PREFIX = /^\\\\[?]\\([A-Za-z]:[\\/].*)$/;
 const WINDOWS_UNC_EXTENDED_PREFIX = /^\\\\[?]\\UNC[\\/]([^\\/]+)[\\/](.+)$/i;
 const WINDOWS_DRIVE_EXTENDED_FORWARD_PREFIX = /^\/\/[?]\/([A-Za-z]:\/.*)$/;

package/src/postmortem.ts

@@ -222,7 +222,7 @@ export function isInternalSocketClosedError(err: unknown): boolean {
 	const internal = frames.every(frame => {
 		const trimmed = frame.trim();
 		if (trimmed === "" || trimmed === "at unknown" || trimmed === "at native") return true;
-		if (!/\(node:[^)]*\)$/.test(trimmed) && !/^at node:/.test(trimmed)) return false;
+		if (!/\(node:[^)]*\)$/.test(trimmed) && !trimmed.startsWith("at node:")) return false;
 		hasNetFrame ||= trimmed.includes("node:net:");
 		return true;
 	});
@@ -395,23 +395,40 @@ function formatFatalError(label: string, err: Error): string {
 	return `\n[${label}] ${name}: ${message}${formattedStack}\n`;
 }
 
-async function exitAfterFatal(label: string, logMessage: string, err: Error, reason: Reason): Promise<void> {
+async function exitAfterFatal(output: string, logMessage: string, err: Error, reason: Reason): Promise<never> {
 	const forcedExit = setTimeout(() => exitProcess(1), 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, `${formatFatalError(label, err)}${formatFatalRecoveryHints()}`);
+			fs.writeSync(2, output);
 		} catch {}
 		logger.error(logMessage, { err });
-		await runCleanup(reason);
+		await cleanup;
 	} finally {
 		clearTimeout(forcedExit);
 		exitProcess(1);
 	}
 }
 
+/**
+ * Reports a caught top-level failure after terminal owners restore their display, then exits.
+ */
+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) {
+		process.stderr.write(output);
+		process.exit(1);
+	}
+	return exitAfterFatal(output, "Fatal error", err, Reason.UNHANDLED_REJECTION);
+}
+
 if (isMainThread) {
 	process
 		.on("SIGINT", async () => {
@@ -461,7 +478,12 @@ if (isMainThread) {
 				});
 				return;
 			}
-			await exitAfterFatal("Uncaught Exception", "Uncaught exception", err, Reason.UNCAUGHT_EXCEPTION);
+			await exitAfterFatal(
+				`${formatFatalError("Uncaught Exception", err)}${formatFatalRecoveryHints()}`,
+				"Uncaught exception",
+				err,
+				Reason.UNCAUGHT_EXCEPTION,
+			);
 		})
 		.on("unhandledRejection", async reason => {
 			const err = reason instanceof Error ? reason : new Error(String(reason));
@@ -497,7 +519,12 @@ if (isMainThread) {
 					});
 				}
 			}
-			await exitAfterFatal("Unhandled Rejection", "Unhandled rejection", err, Reason.UNHANDLED_REJECTION);
+			await exitAfterFatal(
+				`${formatFatalError("Unhandled Rejection", err)}${formatFatalRecoveryHints()}`,
+				"Unhandled rejection",
+				err,
+				Reason.UNHANDLED_REJECTION,
+			);
 		})
 		.on("exit", async () => {
 			void runCleanup(Reason.EXIT); // fire and forget (exit imminent)

package/src/prompt.ts

@@ -196,6 +196,7 @@ export function format(content: string, options: PromptFormatOptions = {}): stri
 	} = options;
 	const isPreRender = renderPhase === "pre-render";
 	const lines = content.split("\n");
+	// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 	const result: string[] = new Array(lines.length);
 	let n = 0; // logical length of `result` (pops are n--)
 	let inCodeBlock = false;

package/src/ring.ts

@@ -15,6 +15,7 @@ export class RingBuffer<T> {
 	 * @param capacity - The maximum number of elements the buffer can hold. Must be positive.
 	 */
 	constructor(public readonly capacity: number) {
+		// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
 		this.#buf = new Array(capacity);
 	}
 

package/src/runtime-install.ts

@@ -2,6 +2,8 @@ import * as fs from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as Module from "node:module";
 import * as path from "node:path";
+import { withFileLock } from "./file-lock";
+import { isEexist, isEnoent } from "./fs-error";
 
 /**
  * On-demand runtime dependency support for native-heavy optional packages
@@ -303,25 +305,62 @@ export interface EnsureRuntimeInstalledOptions {
 	lockSleepMs?: number;
 }
 
-function isErrnoCode(error: unknown, code: string): boolean {
-	return typeof error === "object" && error !== null && "code" in error && error.code === code;
-}
+/** No runtime install plausibly runs this long, so older legacy lock directories are crash orphans. */
+const STALE_LEGACY_LOCK_MS = 10 * 60_000;
 
-async function acquireInstallLock(runtimeDir: string, attempts: number, sleepMs: number): Promise<() => Promise<void>> {
-	const lockDir = `${runtimeDir}.lock`;
-	await fsp.mkdir(path.dirname(lockDir), { recursive: true });
-	for (let attempt = 0; attempt < attempts; attempt++) {
+/**
+ * Run `fn` while reserving the pre-crash-safe `${runtimeDir}.lock` namespace.
+ *
+ * Versions through 18.0.10 serialized installs with a bare lock *directory*
+ * that only its creator removed; an installer killed outside that window
+ * (SIGKILL/OOM/Ctrl-C) left it unreleasable, wedging every later install for
+ * the full wait envelope (issue #10120). During an in-flight upgrade a legacy
+ * process may still legitimately own this directory, so poll until it is
+ * released and only force-reclaim once the directory is older than any
+ * plausible install ({@link STALE_LEGACY_LOCK_MS}) — never merely because a
+ * retry budget elapsed, which would delete a still-active legacy lock and let
+ * two installers race the same tree. Once the namespace is free, atomically
+ * create and retain a regular file through `fn`: an older process cannot
+ * acquire it between the handoff check and the new install. A file left by a
+ * crashed new installer can be reused immediately because the outer OS lock
+ * proves its owner is gone, unlike a legacy directory whose owner is unknown.
+ */
+async function withLegacyInstallLock<T>(runtimeDir: string, sleepMs: number, fn: () => Promise<T>): Promise<T> {
+	const legacy = `${runtimeDir}.lock`;
+	for (;;) {
 		try {
-			await fsp.mkdir(lockDir);
-			return async () => {
-				await fsp.rm(lockDir, { recursive: true, force: true });
-			};
+			const reservation = await fsp.open(legacy, "wx");
+			await reservation.close();
 		} catch (error) {
-			if (!isErrnoCode(error, "EEXIST")) throw error;
-			await Bun.sleep(sleepMs);
+			if (!isEexist(error)) throw error;
+			let stat: fs.Stats;
+			try {
+				stat = await fsp.stat(legacy);
+			} catch (statError) {
+				if (isEnoent(statError)) continue; // released between open and stat; retry
+				throw statError;
+			}
+			// A non-directory is a reservation left by a newer installer. The
+			// outer OS lock proves that installer is gone, so reuse it at once.
+			if (!stat.isDirectory()) break;
+			// A fresh directory may still belong to a live pre-18.x installer, so
+			// wait for it to finish; only a crash orphan (older than any plausible
+			// install) is force-reclaimed.
+			if (Date.now() - stat.mtimeMs > STALE_LEGACY_LOCK_MS) {
+				await fsp.rm(legacy, { recursive: true, force: true });
+			} else {
+				await Bun.sleep(sleepMs);
+			}
+			continue;
 		}
+		break;
+	}
+	// Retain the regular-file reservation across the install.
+	try {
+		return await fn();
+	} finally {
+		await fsp.rm(legacy, { force: true });
 	}
-	throw new Error(`Timed out waiting for runtime install lock: ${lockDir}`);
 }
 
 export async function writeRuntimeManifest(runtimeDir: string, install: RuntimeInstallSpec): Promise<void> {
@@ -363,7 +402,14 @@ async function runRuntimeInstall(runtimeDir: string): Promise<void> {
 
 /**
  * Materialize a pinned dependency set into `runtimeDir` (idempotent,
- * cross-process safe via a lock directory). Returns `runtimeDir`.
+ * cross-process safe). Returns `runtimeDir`.
+ *
+ * Serialization uses the OS-backed {@link withFileLock} at
+ * `${runtimeDir}.install.lock`, which the kernel releases on process death, so
+ * a crashed installer cannot wedge later attempts (issue #10120). The path is
+ * deliberately distinct from the legacy `${runtimeDir}.lock` mkdir directory;
+ * {@link withLegacyInstallLock} atomically reserves that namespace during the
+ * new install so older processes cannot cross the migration boundary.
  */
 export async function ensureRuntimeInstalled(options: EnsureRuntimeInstalledOptions): Promise<string> {
 	const { runtimeDir, install, onPhase, lockAttempts = 240, lockSleepMs = 250 } = options;
@@ -379,15 +425,20 @@ export async function ensureRuntimeInstalled(options: EnsureRuntimeInstalledOpti
 	if (await probeManifest.exists()) return runtimeDir;
 
 	onPhase?.("initiate");
-	const releaseLock = await acquireInstallLock(runtimeDir, lockAttempts, lockSleepMs);
-	try {
-		if (await probeManifest.exists()) return runtimeDir;
-		await writeRuntimeManifest(runtimeDir, install);
-		onPhase?.("download");
-		await runRuntimeInstall(runtimeDir);
-		onPhase?.("done");
-		return runtimeDir;
-	} finally {
-		await releaseLock();
-	}
+	// withFileLock does not create parent directories; the runtime cache dir may
+	// not exist yet on the very first install.
+	await fsp.mkdir(path.dirname(runtimeDir), { recursive: true });
+	return withFileLock(
+		`${runtimeDir}.install`,
+		() =>
+			withLegacyInstallLock(runtimeDir, lockSleepMs, async () => {
+				if (await probeManifest.exists()) return runtimeDir;
+				await writeRuntimeManifest(runtimeDir, install);
+				onPhase?.("download");
+				await runRuntimeInstall(runtimeDir);
+				onPhase?.("done");
+				return runtimeDir;
+			}),
+		{ retries: lockAttempts, retryDelayMs: lockSleepMs },
+	);
 }

package/src/template.ts

@@ -549,7 +549,7 @@ export function compile<T = unknown>(source: string, options: CompileOptions = {
 	const nodes = parseTemplate(stripStandalone(source));
 	return (context, runtime = {}) => {
 		const root = context ?? {};
-		const frame: Frame = { context: root, parents: [], root, data: { root, ...(runtime.data ?? {}) } };
+		const frame: Frame = { context: root, parents: [], root, data: { root, ...runtime.data } };
 		return renderNodes(nodes, frame, { helpers, partials, options, runtime });
 	};
 }
@@ -579,7 +579,7 @@ export class TemplateEngine {
 		const nodes = parseTemplate(stripStandalone(source));
 		return (context, runtime = {}) => {
 			const root = context ?? {};
-			const frame: Frame = { context: root, parents: [], root, data: { root, ...(runtime.data ?? {}) } };
+			const frame: Frame = { context: root, parents: [], root, data: { root, ...runtime.data } };
 			return renderNodes(nodes, frame, { helpers: this.#helpers, partials: this.#partials, options, runtime });
 		};
 	}

package/src/tls-fetch.ts

@@ -174,5 +174,5 @@ export function withExtraCaFetch<T extends { fetch?: FetchImpl } | undefined>(op
 	const fetchImpl = options?.fetch ?? (globalThis.fetch as FetchImpl);
 	const wrapped = wrapFetchForExtraCa(fetchImpl);
 	if (wrapped === fetchImpl && options?.fetch !== undefined) return options;
-	return { ...(options ?? {}), fetch: wrapped } as T;
+	return { ...options, fetch: wrapped } as T;
 }

package/src/turndown/html.ts

@@ -222,7 +222,7 @@ export function parseHtmlFragment(html: string): TurndownNode {
 	const stack: HtmlNode[] = [root];
 	for (const token of htmlTokens(html)) {
 		const parent = stack[stack.length - 1] ?? root;
-		if (token.startsWith("<!--") || /^<!/i.test(token)) continue;
+		if (token.startsWith("<!--") || token.startsWith("<!")) continue;
 		if (!token.startsWith("<")) {
 			parent.append(new HtmlText(decodeEntities(token)));
 			continue;