@oh-my-pi/pi-natives 9.1.1 → 9.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-natives",
-	"version": "9.1.1",
+	"version": "9.2.0",
 	"description": "Native Rust functionality compiled to WebAssembly via wasm-bindgen",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,7 +30,7 @@
 		"directory": "packages/natives"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-utils": "9.1.1"
+		"@oh-my-pi/pi-utils": "9.2.0"
 	},
 	"devDependencies": {
 		"@types/node": "^25.0.10"

package/src/grep/file-reader.ts

@@ -0,0 +1,51 @@
+/**
+ * Cross-platform file reader for grep.
+ *
+ * Uses mmap for files <= 4MB on platforms that support it,
+ * falls back to reading into a reusable buffer otherwise.
+ */
+import * as fs from "node:fs/promises";
+
+const MAX_MMAP_SIZE = 4 * 1024 * 1024; // 4MB
+export class FileReader {
+	#buffer: Buffer | null = null;
+	constructor(private readonly maxSize: number = MAX_MMAP_SIZE) {}
+	#getBuffer(size: number): Buffer {
+		if (!this.#buffer) {
+			this.#buffer = Buffer.allocUnsafe(this.maxSize);
+		}
+		return this.#buffer.subarray(0, size);
+	}
+
+	async read(filePath: string): Promise<Uint8Array | null> {
+		let fileSize: number;
+		try {
+			const stat = await fs.stat(filePath);
+			fileSize = stat.size;
+		} catch {
+			return null;
+		}
+
+		// Skip files larger than buffer size (only search first 4MB worth)
+		const readSize = Math.min(fileSize, this.maxSize);
+
+		// Try mmap for small files (fast path on Linux/macOS)
+		if (fileSize <= this.maxSize) {
+			try {
+				return Bun.mmap(filePath);
+			} catch {
+				// mmap not supported (Windows) or failed, fall through to read
+			}
+		}
+
+		// Fall back to reading into buffer
+		try {
+			await using handle = await fs.open(filePath, "r");
+			const buffer = this.#getBuffer(readSize);
+			const { bytesRead } = await handle.read(buffer, 0, readSize, 0);
+			return buffer.subarray(0, bytesRead);
+		} catch {
+			return null;
+		}
+	}
+}

package/src/grep/index.ts

@@ -14,6 +14,8 @@ import {
 	search as wasmSearch,
 } from "../../wasm/pi_natives";
 import { WorkerPool } from "../pool";
+import { resolveWorkerSpecifier } from "../worker-resolver";
+import { FileReader } from "./file-reader";
 import { buildGlobPattern, matchesTypeFilter, resolveTypeFilter } from "./filters";
 import type {
 	ContextLine,
@@ -97,7 +99,17 @@ async function grepDirect(options: GrepOptions, onMatch?: (match: GrepMatch) =>
 			};
 		}
 
-		const content = Bun.mmap(searchPath);
+		const fileReader = new FileReader();
+		const content = await fileReader.read(searchPath);
+		if (!content) {
+			return {
+				matches,
+				totalMatches,
+				filesWithMatches,
+				filesSearched,
+				limitReached: limitReached || undefined,
+			};
+		}
 		filesSearched = 1;
 
 		const result = compiledPattern.search_bytes(
@@ -148,6 +160,7 @@ async function grepDirect(options: GrepOptions, onMatch?: (match: GrepMatch) =>
 			gitignore: true,
 		});
 
+		const fileReader = new FileReader();
 		for (const relativePath of paths) {
 			if (limitReached) break;
 			if (typeFilter && !matchesTypeFilter(relativePath, typeFilter)) {
@@ -157,12 +170,8 @@ async function grepDirect(options: GrepOptions, onMatch?: (match: GrepMatch) =>
 			const normalizedPath = relativePath.replace(/\\/g, "/");
 			const fullPath = path.join(searchPath, normalizedPath);
 
-			let content: Uint8Array;
-			try {
-				content = Bun.mmap(fullPath);
-			} catch {
-				continue;
-			}
+			const content = await fileReader.read(fullPath);
+			if (!content) continue;
 
 			filesSearched++;
 
@@ -293,7 +302,13 @@ export async function grepPool(options: GrepOptions): Promise<GrepResult> {
 // =============================================================================
 
 const pool = new WorkerPool<WorkerRequest, WorkerResponse>({
-	workerUrl: new URL("./worker.ts", import.meta.url).href,
+	createWorker: () =>
+		new Worker(
+			resolveWorkerSpecifier({
+				compiled: "./packages/natives/src/grep/worker.ts",
+				dev: new URL("./worker.ts", import.meta.url),
+			}),
+		),
 	maxWorkers: 4,
 	idleTimeoutMs: 30_000,
 });

package/src/grep/worker.ts

@@ -7,6 +7,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { globPaths } from "@oh-my-pi/pi-utils";
 import { CompiledPattern } from "../../wasm/pi_natives";
+import { FileReader } from "./file-reader";
 import { buildGlobPattern, matchesTypeFilter, resolveTypeFilter } from "./filters";
 import type { GrepMatch, GrepOptions, GrepResult, WasmSearchResult, WorkerRequest, WorkerResponse } from "./types";
 
@@ -46,6 +47,7 @@ async function runGrep(request: GrepOptions): Promise<GrepResult> {
 	const typeFilter = resolveTypeFilter(request.type);
 	const globPattern = buildGlobPattern(request.glob);
 
+	const fileReader = new FileReader();
 	if (isFile) {
 		if (typeFilter && !matchesTypeFilter(searchPath, typeFilter)) {
 			return {
@@ -57,7 +59,16 @@ async function runGrep(request: GrepOptions): Promise<GrepResult> {
 			};
 		}
 
-		const content = Bun.mmap(searchPath);
+		const content = await fileReader.read(searchPath);
+		if (!content) {
+			return {
+				matches,
+				totalMatches,
+				filesWithMatches,
+				filesSearched,
+				limitReached: limitReached || undefined,
+			};
+		}
 		filesSearched = 1;
 
 		const result = compiledPattern.search_bytes(
@@ -109,12 +120,8 @@ async function runGrep(request: GrepOptions): Promise<GrepResult> {
 			const normalizedPath = relativePath.replace(/\\/g, "/");
 			const fullPath = path.join(searchPath, normalizedPath);
 
-			let content: Uint8Array;
-			try {
-				content = Bun.mmap(fullPath);
-			} catch {
-				continue;
-			}
+			const content = await fileReader.read(fullPath);
+			if (!content) continue;
 
 			filesSearched++;
 

package/src/highlight/index.ts

@@ -26,6 +26,10 @@ export interface HighlightColors {
 	type: string;
 	operator: string;
 	punctuation: string;
+	/** Color for diff inserted lines (+). Optional, defaults to no coloring. */
+	inserted?: string;
+	/** Color for diff deleted lines (-). Optional, defaults to no coloring. */
+	deleted?: string;
 }
 
 /**

package/src/html/index.ts

@@ -5,12 +5,19 @@
  */
 
 import { type RequestOptions, WorkerPool } from "../pool";
+import { resolveWorkerSpecifier } from "../worker-resolver";
 import type { HtmlRequest, HtmlResponse, HtmlToMarkdownOptions } from "./types";
 
 export type { HtmlToMarkdownOptions } from "./types";
 
 const pool = new WorkerPool<HtmlRequest, HtmlResponse>({
-	workerUrl: new URL("./worker.ts", import.meta.url).href,
+	createWorker: () =>
+		new Worker(
+			resolveWorkerSpecifier({
+				compiled: "./packages/natives/src/html/worker.ts",
+				dev: new URL("./worker.ts", import.meta.url),
+			}),
+		),
 	maxWorkers: 2,
 	idleTimeoutMs: 30_000,
 });

package/src/image/index.ts

@@ -6,13 +6,20 @@
  */
 
 import { WorkerPool } from "../pool";
+import { resolveWorkerSpecifier } from "../worker-resolver";
 import type { ImageRequest, ImageResponse } from "./types";
 
 // Re-export the enum for filter selection
 export { SamplingFilter } from "../../wasm/pi_natives";
 
 const pool = new WorkerPool<ImageRequest, ImageResponse>({
-	workerUrl: new URL("./worker.ts", import.meta.url).href,
+	createWorker: () =>
+		new Worker(
+			resolveWorkerSpecifier({
+				compiled: "./packages/natives/src/image/worker.ts",
+				dev: new URL("./worker.ts", import.meta.url),
+			}),
+		),
 	maxWorkers: 1,
 	idleTimeoutMs: 0, // Keep alive - stateful (image handles)
 });

package/src/pool.ts

@@ -19,8 +19,10 @@ export interface BaseResponse {
 }
 
 export interface WorkerPoolOptions {
-	/** URL to the worker script. */
-	workerUrl: string | URL;
+	/** URL to the worker script (deprecated: use createWorker for compiled binaries). */
+	workerUrl?: string | URL;
+	/** Factory function to create workers. Required for compiled binaries where Bun needs static analysis. */
+	createWorker?: () => Worker;
 	/** Maximum number of workers (default: 4). */
 	maxWorkers?: number;
 	/** Idle timeout in ms before terminating unused workers (0 = never, default: 30000). */
@@ -61,7 +63,14 @@ interface PendingRequest<T> {
  * @typeParam TRes - Response message type (must extend BaseResponse)
  */
 export class WorkerPool<TReq extends BaseRequest, TRes extends BaseResponse> {
-	readonly #options: Required<WorkerPoolOptions>;
+	readonly #options: {
+		workerUrl?: string | URL;
+		createWorker?: () => Worker;
+		maxWorkers: number;
+		idleTimeoutMs: number;
+		initTimeoutMs: number;
+		stuckGracePeriodMs: number;
+	};
 	readonly #pool: PooledWorker[] = [];
 	readonly #waiters: Array<(worker: PooledWorker) => void> = [];
 	readonly #pending = new Map<number, PendingRequest<TRes>>();
@@ -69,8 +78,12 @@ export class WorkerPool<TReq extends BaseRequest, TRes extends BaseResponse> {
 	#idleCheckInterval: ReturnType<typeof setInterval> | null = null;
 
 	constructor(options: WorkerPoolOptions) {
+		if (!options.workerUrl && !options.createWorker) {
+			throw new Error("WorkerPool requires either workerUrl or createWorker");
+		}
 		this.#options = {
 			workerUrl: options.workerUrl,
+			createWorker: options.createWorker,
 			maxWorkers: options.maxWorkers ?? 4,
 			idleTimeoutMs: options.idleTimeoutMs ?? 30_000,
 			initTimeoutMs: options.initTimeoutMs ?? 10_000,
@@ -152,7 +165,7 @@ export class WorkerPool<TReq extends BaseRequest, TRes extends BaseResponse> {
 	}
 
 	#createWorker(): PooledWorker {
-		const worker = new Worker(this.#options.workerUrl);
+		const worker = this.#options.createWorker ? this.#options.createWorker() : new Worker(this.#options.workerUrl!);
 
 		const pooledWorker: PooledWorker = {
 			worker,
@@ -314,6 +327,7 @@ export class WorkerPool<TReq extends BaseRequest, TRes extends BaseResponse> {
 			dispose: () => clearTimeout(timeout),
 		} as PendingRequest<TRes>);
 
+		pooledWorker.currentRequestId = id;
 		pooledWorker.worker.postMessage({ type: "init", id } satisfies BaseRequest);
 		return promise;
 	}

package/src/worker-resolver.ts

@@ -0,0 +1,9 @@
+declare const OMP_COMPILED: boolean | undefined;
+
+export function resolveWorkerSpecifier(options: { compiled: string; dev: URL }): string | URL {
+	if (typeof OMP_COMPILED !== "undefined" && OMP_COMPILED) {
+		return options.compiled;
+	}
+
+	return options.dev;
+}