@oh-my-pi/pi-natives 9.3.1 → 9.6.0

package/src/html/types.ts

@@ -1,5 +1,5 @@
 /**
- * Types for HTML to Markdown worker communication.
+ * Types for HTML to Markdown conversion.
  */
 
 export interface HtmlToMarkdownOptions {
@@ -8,18 +8,3 @@ export interface HtmlToMarkdownOptions {
 	/** Skip images during conversion */
 	skipImages?: boolean;
 }
-
-export type HtmlRequest =
-	| { type: "init"; id: number }
-	| { type: "destroy" }
-	| {
-			type: "convert";
-			id: number;
-			html: string;
-			options?: HtmlToMarkdownOptions;
-	  };
-
-export type HtmlResponse =
-	| { type: "ready"; id: number }
-	| { type: "error"; id: number; error: string }
-	| { type: "converted"; id: number; markdown: string };

package/src/image/index.ts

@@ -1,48 +1,55 @@
 /**
- * Async image processing via worker.
- *
- * All heavy lifting happens in a worker thread to avoid blocking the main thread.
- * Uses transferable ArrayBuffers to avoid copying image data.
+ * Image processing via native bindings.
  */
 
-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>({
-	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)
-});
+import { type NativePhotonImage, native } from "../native";
+
+const images = new Map<number, NativePhotonImage>();
+let nextHandle = 1;
+
+function registerImage(image: NativePhotonImage): number {
+	const handle = nextHandle++;
+	images.set(handle, image);
+	return handle;
+}
+
+function getImage(handle: number): NativePhotonImage {
+	const image = images.get(handle);
+	if (!image) {
+		throw new Error("Image already freed");
+	}
+	return image;
+}
+
+export const SamplingFilter = native.SamplingFilter;
+export type SamplingFilter = (typeof SamplingFilter)[keyof typeof SamplingFilter];
 
 /**
  * Image handle for async operations.
- * Must call free() when done to release WASM memory.
  */
 export class PhotonImage {
 	#handle: number;
-	#width: number;
-	#height: number;
 	#freed = false;
 
-	private constructor(handle: number, width: number, height: number) {
+	private constructor(handle: number) {
 		this.#handle = handle;
-		this.#width = width;
-		this.#height = height;
 	}
 
 	/** @internal */
-	static _create(handle: number, width: number, height: number): PhotonImage {
-		return new PhotonImage(handle, width, height);
+	static _create(handle: number): PhotonImage {
+		if (!images.has(handle)) {
+			throw new Error("Invalid image handle");
+		}
+		return new PhotonImage(handle);
+	}
+
+	/**
+	 * Load an image from encoded bytes (PNG, JPEG, WebP, GIF).
+	 */
+	static async new_from_byteslice(bytes: Uint8Array): Promise<PhotonImage> {
+		const image = await native.PhotonImage.newFromByteslice(bytes);
+		const handle = registerImage(image);
+		return new PhotonImage(handle);
 	}
 
 	/** @internal */
@@ -51,56 +58,36 @@ export class PhotonImage {
 		return this.#handle;
 	}
 
-	/**
-	 * Load an image from encoded bytes (PNG, JPEG, WebP, GIF).
-	 * The bytes are transferred to the worker (zero-copy).
-	 */
-	static async new_from_byteslice(bytes: Uint8Array): Promise<PhotonImage> {
-		const response = await pool.request<Extract<ImageResponse, { type: "loaded" }>>(
-			{ type: "load", bytes },
-			{
-				transfer: [bytes.buffer],
-			},
-		);
-		return new PhotonImage(response.handle, response.width, response.height);
+	#native(): NativePhotonImage {
+		if (this.#freed) throw new Error("Image already freed");
+		return getImage(this.#handle);
 	}
 
 	/** Get image width in pixels. */
 	get_width(): number {
-		return this.#width;
+		return this.#native().getWidth();
 	}
 
 	/** Get image height in pixels. */
 	get_height(): number {
-		return this.#height;
+		return this.#native().getHeight();
 	}
 
 	/** Export as PNG bytes. */
 	async get_bytes(): Promise<Uint8Array> {
-		if (this.#freed) throw new Error("Image already freed");
-		const response = await pool.request<Extract<ImageResponse, { type: "bytes" }>>({
-			type: "get_png",
-			handle: this.#handle,
-		});
-		return response.bytes;
+		return this.#native().getBytes();
 	}
 
 	/** Export as JPEG bytes with specified quality (0-100). */
 	async get_bytes_jpeg(quality: number): Promise<Uint8Array> {
-		if (this.#freed) throw new Error("Image already freed");
-		const response = await pool.request<Extract<ImageResponse, { type: "bytes" }>>({
-			type: "get_jpeg",
-			handle: this.#handle,
-			quality,
-		});
-		return response.bytes;
+		return this.#native().getBytesJpeg(quality);
 	}
 
-	/** Release WASM memory. Must be called when done with the image. */
+	/** Release native resources. */
 	free() {
 		if (this.#freed) return;
 		this.#freed = true;
-		pool.request({ type: "free", handle: this.#handle }).catch(() => {});
+		images.delete(this.#handle);
 	}
 
 	/** Alias for free() to support using-declarations. */
@@ -114,21 +101,13 @@ export class PhotonImage {
  * Returns a new PhotonImage (original is not modified).
  */
 export async function resize(image: PhotonImage, width: number, height: number, filter: number): Promise<PhotonImage> {
-	const handle = image._getHandle();
-	const response = await pool.request<Extract<ImageResponse, { type: "resized" }>>({
-		type: "resize",
-		handle,
-		width,
-		height,
-		filter,
-	});
-	return PhotonImage._create(response.handle, response.width, response.height);
+	const nativeImage = getImage(image._getHandle());
+	const resized = await nativeImage.resize(width, height, filter);
+	const handle = registerImage(resized);
+	return PhotonImage._create(handle);
 }
 
 /**
- * Terminate the image worker.
- * Call this when shutting down to clean up resources.
+ * Terminate image resources (no-op for native bindings).
  */
-export function terminate(): void {
-	pool.terminate();
-}
+export function terminate(): void {}

package/src/index.ts

@@ -1,10 +1,10 @@
 /**
- * Native utilities powered by WASM.
+ * Native utilities powered by N-API.
  */
 
-import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { globPaths } from "@oh-my-pi/pi-utils";
+import type { FindMatch, FindOptions, FindResult } from "./find/types";
+import { native } from "./native";
 
 // =============================================================================
 // Grep (ripgrep-based regex search)
@@ -12,52 +12,24 @@ import { globPaths } from "@oh-my-pi/pi-utils";
 
 export {
 	type ContextLine,
+	type FuzzyFindMatch,
+	type FuzzyFindOptions,
+	type FuzzyFindResult,
+	fuzzyFind,
 	type GrepMatch,
 	type GrepOptions,
 	type GrepResult,
 	type GrepSummary,
 	grep,
-	grepDirect,
-	grepPool,
 	hasMatch,
 	searchContent,
-	terminate,
 } from "./grep/index";
 
-// =============================================================================
-// WASI implementation
-// =============================================================================
-
-export { WASI1, WASIError, WASIExitError, type WASIOptions } from "./wasix";
-
 // =============================================================================
 // Find (file discovery)
 // =============================================================================
 
-export interface FindOptions {
-	/** Glob pattern to match (e.g., `*.ts`) */
-	pattern: string;
-	/** Directory to search */
-	path: string;
-	/** Filter by file type: "file", "dir", or "symlink" */
-	fileType?: "file" | "dir" | "symlink";
-	/** Include hidden files (default: false) */
-	hidden?: boolean;
-	/** Maximum number of results */
-	maxResults?: number;
-	/** Respect .gitignore files (default: true) */
-	gitignore?: boolean;
-}
-
-export interface FindMatch {
-	path: string;
-	fileType: "file" | "dir" | "symlink";
-}
-
-export interface FindResult {
-	matches: FindMatch[];
-	totalMatches: number;
-}
+export type { FindMatch, FindOptions, FindResult } from "./find/types";
 
 /**
  * Find files matching a glob pattern.
@@ -70,59 +42,19 @@ export async function find(options: FindOptions, onMatch?: (match: FindMatch) =>
 	// Convert simple patterns to recursive globs if needed
 	const globPattern = pattern.includes("/") || pattern.startsWith("**") ? pattern : `**/${pattern}`;
 
-	const paths = await globPaths(globPattern, {
-		cwd: searchPath,
-		dot: options.hidden ?? false,
-		onlyFiles: options.fileType === "file",
-		gitignore: options.gitignore ?? true,
-	});
-
-	const matches: FindMatch[] = [];
-	const maxResults = options.maxResults ?? Number.MAX_SAFE_INTEGER;
-
-	for (const p of paths) {
-		if (matches.length >= maxResults) {
-			break;
-		}
-
-		const normalizedPath = p.replace(/\\/g, "/");
-		if (!normalizedPath) {
-			continue;
-		}
-
-		let stats: Awaited<ReturnType<typeof fs.lstat>>;
-		try {
-			stats = await fs.lstat(path.join(searchPath, normalizedPath));
-		} catch {
-			continue;
-		}
-
-		const fileType: "file" | "dir" | "symlink" = stats.isSymbolicLink()
-			? "symlink"
-			: stats.isDirectory()
-				? "dir"
-				: "file";
-
-		if (options.fileType && options.fileType !== fileType) {
-			continue;
-		}
-
-		const match: FindMatch = {
-			path: normalizedPath,
-			fileType,
-		};
-
-		matches.push(match);
-		onMatch?.(match);
-	}
-
-	return {
-		matches,
-		totalMatches: matches.length,
-	};
+	return native.find(
+		{
+			...options,
+			path: searchPath,
+			pattern: globPattern,
+			hidden: options.hidden ?? false,
+			gitignore: options.gitignore ?? true,
+		},
+		onMatch,
+	);
 }
 
-// =============================================================================
+// =====================================================	========================
 // Image processing (photon-compatible API)
 // =============================================================================
 
@@ -164,11 +96,6 @@ export {
 export {
 	type HtmlToMarkdownOptions,
 	htmlToMarkdown,
-	terminate as terminateHtmlWorker,
 } from "./html/index";
 
-// =============================================================================
-// Worker Pool (shared infrastructure)
-// =============================================================================
-
-export { type BaseRequest, type BaseResponse, type RequestOptions, WorkerPool, type WorkerPoolOptions } from "./pool";
+export type { RequestOptions } from "./request-options";

package/src/native.ts

@@ -0,0 +1,159 @@
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import type { FindMatch, FindOptions, FindResult } from "./find/types";
+import type {
+	FuzzyFindOptions,
+	FuzzyFindResult,
+	GrepOptions,
+	GrepResult,
+	SearchOptions,
+	SearchResult,
+} from "./grep/types";
+import type { HighlightColors } from "./highlight/index";
+import type { HtmlToMarkdownOptions } from "./html/types";
+import type { ExtractSegmentsResult, SliceWithWidthResult, TextInput } from "./text/index";
+
+export interface NativePhotonImage {
+	getWidth(): number;
+	getHeight(): number;
+	getBytes(): Promise<Uint8Array>;
+	getBytesJpeg(quality: number): Promise<Uint8Array>;
+	getBytesWebp(): Promise<Uint8Array>;
+	getBytesGif(): Promise<Uint8Array>;
+	resize(width: number, height: number, filter: number): Promise<NativePhotonImage>;
+}
+
+export interface NativePhotonImageConstructor {
+	newFromByteslice(bytes: Uint8Array): Promise<NativePhotonImage>;
+	prototype: NativePhotonImage;
+}
+
+export interface NativeSamplingFilter {
+	Nearest: 1;
+	Triangle: 2;
+	CatmullRom: 3;
+	Gaussian: 4;
+	Lanczos3: 5;
+}
+
+import type { GrepMatch } from "./grep/types";
+
+export interface NativeBindings {
+	find(options: FindOptions, onMatch?: (match: FindMatch) => void): Promise<FindResult>;
+	fuzzyFind(options: FuzzyFindOptions): Promise<FuzzyFindResult>;
+	grep(options: GrepOptions, onMatch?: (match: GrepMatch) => void): Promise<GrepResult>;
+	search(content: string | Uint8Array, options: SearchOptions): SearchResult;
+	hasMatch(
+		content: string | Uint8Array,
+		pattern: string | Uint8Array,
+		ignoreCase: boolean,
+		multiline: boolean,
+	): boolean;
+	htmlToMarkdown(html: string, options?: HtmlToMarkdownOptions | null): Promise<string>;
+	highlightCode(code: string, lang: string | null | undefined, colors: HighlightColors): string;
+	supportsLanguage(lang: string): boolean;
+	getSupportedLanguages(): string[];
+	SamplingFilter: NativeSamplingFilter;
+	PhotonImage: NativePhotonImageConstructor;
+	visibleWidth(text: TextInput): number;
+	truncateToWidth(text: TextInput, maxWidth: number, ellipsis: TextInput, pad: boolean): string;
+	sliceWithWidth(line: TextInput, startCol: number, length: number, strict: boolean): SliceWithWidthResult;
+	extractSegments(
+		line: TextInput,
+		beforeEnd: number,
+		afterStart: number,
+		afterLen: number,
+		strictAfter: boolean,
+	): ExtractSegmentsResult;
+}
+
+const require = createRequire(import.meta.url);
+const platformTag = `${process.platform}-${process.arch}`;
+const nativeDir = path.join(import.meta.dir, "..", "native");
+const repoRoot = path.join(import.meta.dir, "..", "..", "..");
+const execDir = path.dirname(process.execPath);
+
+const SUPPORTED_PLATFORMS = ["linux-x64", "linux-arm64", "darwin-x64", "darwin-arm64", "win32-x64"];
+
+const candidates = [
+	path.join(nativeDir, `pi_natives.${platformTag}.node`),
+	path.join(nativeDir, "pi_natives.node"),
+	path.join(execDir, `pi_natives.${platformTag}.node`),
+	path.join(execDir, "pi_natives.node"),
+	path.join(repoRoot, "target", "release", "pi_natives.node"),
+	path.join(repoRoot, "crates", "pi-natives", "target", "release", "pi_natives.node"),
+];
+
+function loadNative(): NativeBindings {
+	const errors: string[] = [];
+
+	for (const candidate of candidates) {
+		try {
+			const bindings = require(candidate) as NativeBindings;
+			validateNative(bindings, candidate);
+			return bindings;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			errors.push(`${candidate}: ${message}`);
+		}
+	}
+
+	// Check if this is an unsupported platform
+	if (!SUPPORTED_PLATFORMS.includes(platformTag)) {
+		throw new Error(
+			`Unsupported platform: ${platformTag}\n` +
+				`Supported platforms: ${SUPPORTED_PLATFORMS.join(", ")}\n` +
+				"If you need support for this platform, please open an issue.",
+		);
+	}
+
+	const details = errors.map(error => `- ${error}`).join("\n");
+	throw new Error(
+		`Failed to load pi_natives native addon for ${platformTag}.\n\n` +
+			`Tried:\n${details}\n\n` +
+			"If installed via npm/bun, try reinstalling: bun install @oh-my-pi/pi-natives\n" +
+			"If developing locally, build with: bun --cwd=packages/natives run build:native",
+	);
+}
+
+function validateNative(bindings: NativeBindings, source: string): void {
+	const missing: string[] = [];
+	const checkFn = (name: keyof NativeBindings) => {
+		if (typeof bindings[name] !== "function") {
+			missing.push(name);
+		}
+	};
+
+	checkFn("find");
+	checkFn("fuzzyFind");
+	checkFn("grep");
+	checkFn("search");
+	checkFn("hasMatch");
+	checkFn("htmlToMarkdown");
+	checkFn("highlightCode");
+	checkFn("supportsLanguage");
+	checkFn("getSupportedLanguages");
+	checkFn("visibleWidth");
+	checkFn("truncateToWidth");
+	checkFn("sliceWithWidth");
+	checkFn("extractSegments");
+
+	if (!bindings.PhotonImage?.newFromByteslice) {
+		missing.push("PhotonImage.newFromByteslice");
+	}
+	if (!bindings.PhotonImage?.prototype?.resize) {
+		missing.push("PhotonImage.resize");
+	}
+	if (!bindings.SamplingFilter || typeof bindings.SamplingFilter.Lanczos3 !== "number") {
+		missing.push("SamplingFilter");
+	}
+
+	if (missing.length) {
+		throw new Error(
+			`Native addon missing exports (${source}). Missing: ${missing.join(", ")}. ` +
+				"Rebuild with `bun --cwd=packages/natives run build:native`.",
+		);
+	}
+}
+
+export const native = loadNative();

package/src/request-options.ts

@@ -0,0 +1,94 @@
+export interface RequestOptions {
+	timeoutMs?: number;
+	signal?: AbortSignal;
+}
+
+function abortReason(signal?: AbortSignal): Error {
+	if (!signal || !signal.reason) return new Error("Request aborted");
+	if (signal.reason instanceof Error) return signal.reason;
+	return new Error("Request aborted", { cause: signal.reason });
+}
+export async function wrapRequestOptions<T>(fn: () => Promise<T>, options?: RequestOptions): Promise<T> {
+	const timeoutMs = options?.timeoutMs ?? 0;
+	const signal = options?.signal;
+
+	// Fast path: no timeout + no signal
+	if (!signal && timeoutMs <= 0) return fn();
+
+	// If already aborted, fail immediately
+	if (signal?.aborted) throw abortReason(signal);
+
+	// If we only have an abort signal and no timeout, keep it simple.
+	if (signal && timeoutMs <= 0) {
+		return withAbortSignal(fn, signal);
+	}
+
+	return withTimeoutAndOptionalAbort(fn, timeoutMs, signal);
+}
+
+function withAbortSignal<T>(fn: () => Promise<T>, signal: AbortSignal): Promise<T> {
+	return new Promise<T>((resolve, reject) => {
+		const onAbort = () => {
+			signal.removeEventListener("abort", onAbort);
+			reject(abortReason(signal));
+		};
+
+		signal.addEventListener("abort", onAbort, { once: true });
+
+		// If it races and aborts right after addEventListener, `once` handles it,
+		// but we still want to short-circuit.
+		if (signal.aborted) return onAbort();
+
+		fn().then(
+			v => {
+				signal.removeEventListener("abort", onAbort);
+				resolve(v);
+			},
+			err => {
+				signal.removeEventListener("abort", onAbort);
+				reject(err);
+			},
+		);
+	});
+}
+
+function withTimeoutAndOptionalAbort<T>(fn: () => Promise<T>, timeoutMs: number, signal?: AbortSignal): Promise<T> {
+	return new Promise<T>((resolve, reject) => {
+		let settled = false;
+
+		let timeoutId: ReturnType<typeof setTimeout> | undefined;
+		const cleanup = () => {
+			if (timeoutId) {
+				clearTimeout(timeoutId);
+				timeoutId = undefined;
+			}
+			if (signal) signal.removeEventListener("abort", onAbort);
+		};
+
+		const settle = (ok: boolean, value: any) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			ok ? resolve(value as T) : reject(value);
+		};
+
+		const onAbort = () => settle(false, abortReason(signal!));
+
+		// timeout
+		timeoutId = setTimeout(() => {
+			settle(false, new Error(`Request timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+
+		// abort (optional)
+		if (signal) {
+			signal.addEventListener("abort", onAbort, { once: true });
+			if (signal.aborted) return onAbort();
+		}
+
+		// run
+		fn().then(
+			v => settle(true, v),
+			err => settle(false, err),
+		);
+	});
+}

package/src/text/index.ts

@@ -1,8 +1,8 @@
 /**
- * ANSI-aware text utilities powered by WASM.
+ * ANSI-aware text utilities powered by native bindings.
  */
 
-import * as wasm from "../../wasm/pi_natives";
+import { native } from "../native";
 
 export interface SliceWithWidthResult {
 	text: string;
@@ -16,49 +16,41 @@ export interface ExtractSegmentsResult {
 	afterWidth: number;
 }
 
-type WasmTextExports = typeof wasm & {
-	visible_width: (text: string) => number;
-	truncate_to_width: (text: string, maxWidth: number, ellipsis: string, pad: boolean) => string;
-	slice_with_width: (line: string, startCol: number, length: number, strict: boolean) => SliceWithWidthResult;
-	extract_segments: (
-		line: string,
-		beforeEnd: number,
-		afterStart: number,
-		afterLen: number,
-		strictAfter: boolean,
-	) => ExtractSegmentsResult;
-};
-
-const wasmText = wasm as WasmTextExports;
+export type TextInput = string | Uint8Array;
 
 /** Compute the visible width of a string, ignoring ANSI codes. */
-export function visibleWidth(text: string): number {
-	return wasmText.visible_width(text);
+export function visibleWidth(text: TextInput): number {
+	return native.visibleWidth(text);
 }
 
 /**
  * Truncate a string to a visible width, preserving ANSI codes.
  */
-export function truncateToWidth(text: string, maxWidth: number, ellipsis = "…", pad = false): string {
-	return wasmText.truncate_to_width(text, maxWidth, ellipsis, pad);
+export function truncateToWidth(text: TextInput, maxWidth: number, ellipsis: TextInput = "…", pad = false): string {
+	return native.truncateToWidth(text, maxWidth, ellipsis, pad);
 }
 
 /**
  * Slice a range of visible columns from a line.
  */
-export function sliceWithWidth(line: string, startCol: number, length: number, strict = false): SliceWithWidthResult {
-	return wasmText.slice_with_width(line, startCol, length, strict);
+export function sliceWithWidth(
+	line: TextInput,
+	startCol: number,
+	length: number,
+	strict = false,
+): SliceWithWidthResult {
+	return native.sliceWithWidth(line, startCol, length, strict);
 }
 
 /**
  * Extract before/after segments around an overlay region.
  */
 export function extractSegments(
-	line: string,
+	line: TextInput,
 	beforeEnd: number,
 	afterStart: number,
 	afterLen: number,
 	strictAfter = false,
 ): ExtractSegmentsResult {
-	return wasmText.extract_segments(line, beforeEnd, afterStart, afterLen, strictAfter);
+	return native.extractSegments(line, beforeEnd, afterStart, afterLen, strictAfter);
 }