@oh-my-pi/pi-natives 8.12.4

package/src/grep/worker.ts

@@ -0,0 +1,205 @@
+/**
+ * Worker script for running wasm-bindgen grep.
+ * Each worker loads its own WASM instance and processes requests.
+ */
+
+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 { buildGlobPattern, matchesTypeFilter, resolveTypeFilter } from "./filters";
+import type { GrepMatch, GrepOptions, GrepResult, WasmSearchResult, WorkerRequest, WorkerResponse } from "./types";
+
+function filterUndefined<T extends Record<string, unknown>>(obj: T): T {
+	const result = {} as T;
+	for (const [key, value] of Object.entries(obj)) {
+		if (value !== undefined) {
+			(result as Record<string, unknown>)[key] = value;
+		}
+	}
+	return result;
+}
+
+async function runGrep(request: GrepOptions): Promise<GrepResult> {
+	const searchPath = path.resolve(request.path);
+	const stat = await fs.stat(searchPath);
+	const isFile = stat.isFile();
+
+	using compiledPattern = new CompiledPattern(
+		filterUndefined({
+			pattern: request.pattern,
+			ignoreCase: request.ignoreCase,
+			multiline: request.multiline,
+			context: request.context,
+			maxColumns: request.maxColumns,
+			mode: request.mode === "content" || !request.mode ? "content" : "count",
+		}),
+	);
+
+	const matches: GrepMatch[] = [];
+	let totalMatches = 0;
+	let filesWithMatches = 0;
+	let filesSearched = 0;
+	let limitReached = false;
+	const maxCount = request.maxCount;
+	const globalOffset = request.offset ?? 0;
+	const typeFilter = resolveTypeFilter(request.type);
+	const globPattern = buildGlobPattern(request.glob);
+
+	if (isFile) {
+		if (typeFilter && !matchesTypeFilter(searchPath, typeFilter)) {
+			return {
+				matches,
+				totalMatches,
+				filesWithMatches,
+				filesSearched,
+				limitReached: limitReached || undefined,
+			};
+		}
+
+		const content = Bun.mmap(searchPath);
+		filesSearched = 1;
+
+		const result = compiledPattern.search_bytes(
+			content,
+			maxCount,
+			globalOffset > 0 ? globalOffset : undefined,
+		) as WasmSearchResult;
+
+		if (!result.error && result.matchCount > 0) {
+			filesWithMatches = 1;
+			totalMatches = result.matchCount;
+
+			if (request.mode === "content" || !request.mode) {
+				for (const m of result.matches) {
+					matches.push({
+						path: searchPath,
+						lineNumber: m.lineNumber,
+						line: m.line,
+						contextBefore: m.contextBefore?.length ? m.contextBefore : undefined,
+						contextAfter: m.contextAfter?.length ? m.contextAfter : undefined,
+						truncated: m.truncated || undefined,
+					});
+				}
+			} else {
+				matches.push({
+					path: searchPath,
+					lineNumber: 0,
+					line: "",
+					matchCount: result.matchCount,
+				});
+			}
+
+			limitReached = result.limitReached || (maxCount !== undefined && totalMatches >= maxCount);
+		}
+	} else {
+		const paths = await globPaths(globPattern, {
+			cwd: searchPath,
+			dot: request.hidden ?? true,
+			onlyFiles: true,
+			gitignore: true,
+		});
+
+		for (const relativePath of paths) {
+			if (limitReached) break;
+			if (typeFilter && !matchesTypeFilter(relativePath, typeFilter)) {
+				continue;
+			}
+
+			const normalizedPath = relativePath.replace(/\\/g, "/");
+			const fullPath = path.join(searchPath, normalizedPath);
+
+			let content: Uint8Array;
+			try {
+				content = Bun.mmap(fullPath);
+			} catch {
+				continue;
+			}
+
+			filesSearched++;
+
+			if (!compiledPattern.has_match_bytes(content)) {
+				continue;
+			}
+
+			const fileOffset = globalOffset > 0 ? Math.max(globalOffset - totalMatches, 0) : 0;
+			const remaining = maxCount !== undefined ? Math.max(maxCount - totalMatches, 0) : undefined;
+			if (remaining === 0) {
+				limitReached = true;
+				break;
+			}
+			const result = compiledPattern.search_bytes(
+				content,
+				remaining,
+				fileOffset > 0 ? fileOffset : undefined,
+			) as WasmSearchResult;
+
+			if (result.error) continue;
+
+			if (result.matchCount > 0) {
+				filesWithMatches++;
+				totalMatches += result.matchCount;
+
+				if (request.mode === "content" || !request.mode) {
+					for (const m of result.matches) {
+						matches.push({
+							path: normalizedPath,
+							lineNumber: m.lineNumber,
+							line: m.line,
+							contextBefore: m.contextBefore?.length ? m.contextBefore : undefined,
+							contextAfter: m.contextAfter?.length ? m.contextAfter : undefined,
+							truncated: m.truncated || undefined,
+						});
+					}
+				} else {
+					matches.push({
+						path: normalizedPath,
+						lineNumber: 0,
+						line: "",
+						matchCount: result.matchCount,
+					});
+				}
+
+				if (result.limitReached || (maxCount !== undefined && totalMatches >= maxCount)) {
+					limitReached = true;
+				}
+			}
+		}
+	}
+
+	return {
+		matches,
+		totalMatches,
+		filesWithMatches,
+		filesSearched,
+		limitReached: limitReached || undefined,
+	};
+}
+
+declare const self: Worker;
+
+self.addEventListener("message", async (e: MessageEvent<WorkerRequest>) => {
+	const msg = e.data;
+
+	switch (msg.type) {
+		case "init":
+			self.postMessage({ type: "ready", id: msg.id } satisfies WorkerResponse);
+			break;
+
+		case "grep":
+			try {
+				const result = await runGrep(msg.request);
+				self.postMessage({ type: "result", id: msg.id, result } satisfies WorkerResponse);
+			} catch (err) {
+				self.postMessage({
+					type: "error",
+					id: msg.id,
+					error: err instanceof Error ? err.message : String(err),
+				} satisfies WorkerResponse);
+			}
+			break;
+
+		case "destroy":
+			break;
+	}
+});

package/src/image/index.ts

@@ -0,0 +1,124 @@
+/**
+ * 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.
+ */
+
+import { WorkerPool } from "../pool";
+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,
+	maxWorkers: 1,
+	idleTimeoutMs: 0, // Keep alive - stateful (image handles)
+});
+
+/**
+ * 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) {
+		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);
+	}
+
+	/** @internal */
+	_getHandle(): number {
+		if (this.#freed) throw new Error("Image already freed");
+		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 }, [
+			bytes.buffer,
+		]);
+		return new PhotonImage(response.handle, response.width, response.height);
+	}
+
+	/** Get image width in pixels. */
+	get_width(): number {
+		return this.#width;
+	}
+
+	/** Get image height in pixels. */
+	get_height(): number {
+		return this.#height;
+	}
+
+	/** 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;
+	}
+
+	/** 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;
+	}
+
+	/** Release WASM memory. Must be called when done with the image. */
+	free() {
+		if (this.#freed) return;
+		this.#freed = true;
+		pool.request({ type: "free", handle: this.#handle }).catch(() => {});
+	}
+
+	/** Alias for free() to support using-declarations. */
+	[Symbol.dispose](): void {
+		this.free();
+	}
+}
+
+/**
+ * Resize an image to the specified dimensions.
+ * 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);
+}
+
+/**
+ * Terminate the image worker.
+ * Call this when shutting down to clean up resources.
+ */
+export function terminate(): void {
+	pool.terminate();
+}

package/src/image/types.ts

@@ -0,0 +1,52 @@
+/**
+ * Types for image worker communication.
+ */
+
+export type ImageRequest =
+	| { type: "init"; id: number }
+	| { type: "destroy" }
+	| {
+			type: "load";
+			id: number;
+			/** Image bytes (transferred, not copied) */
+			bytes: Uint8Array;
+	  }
+	| {
+			type: "resize";
+			id: number;
+			/** Handle returned from load */
+			handle: number;
+			width: number;
+			height: number;
+			filter: number;
+	  }
+	| {
+			type: "get_dimensions";
+			id: number;
+			handle: number;
+	  }
+	| {
+			type: "get_png";
+			id: number;
+			handle: number;
+	  }
+	| {
+			type: "get_jpeg";
+			id: number;
+			handle: number;
+			quality: number;
+	  }
+	| {
+			type: "free";
+			id: number;
+			handle: number;
+	  };
+
+export type ImageResponse =
+	| { type: "ready"; id: number }
+	| { type: "error"; id: number; error: string }
+	| { type: "loaded"; id: number; handle: number; width: number; height: number }
+	| { type: "resized"; id: number; handle: number; width: number; height: number }
+	| { type: "dimensions"; id: number; width: number; height: number }
+	| { type: "bytes"; id: number; bytes: Uint8Array }
+	| { type: "freed"; id: number };

package/src/image/worker.ts

@@ -0,0 +1,152 @@
+/**
+ * Worker for image processing operations.
+ * Uses WASM for actual processing, communicates via transferable buffers.
+ */
+
+import { PhotonImage, type SamplingFilter, resize as wasmResize } from "../../wasm/pi_natives";
+import type { ImageRequest, ImageResponse } from "./types";
+
+declare const self: Worker;
+
+/** Map of handle -> PhotonImage */
+const images = new Map<number, PhotonImage>();
+let nextHandle = 1;
+
+function respond(msg: ImageResponse, transfer?: ArrayBufferLike[]): void {
+	if (transfer) {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		self.postMessage(msg, transfer as any);
+	} else {
+		self.postMessage(msg);
+	}
+}
+
+self.addEventListener("message", (e: MessageEvent<ImageRequest>) => {
+	const msg = e.data;
+
+	switch (msg.type) {
+		case "init":
+			respond({ type: "ready", id: msg.id });
+			break;
+
+		case "destroy":
+			for (const img of images.values()) {
+				img.free();
+			}
+			images.clear();
+			break;
+
+		case "load": {
+			try {
+				const img = PhotonImage.new_from_byteslice(msg.bytes);
+				const handle = nextHandle++;
+				images.set(handle, img);
+				respond({
+					type: "loaded",
+					id: msg.id,
+					handle,
+					width: img.get_width(),
+					height: img.get_height(),
+				});
+			} catch (err) {
+				respond({
+					type: "error",
+					id: msg.id,
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
+			break;
+		}
+
+		case "resize": {
+			const img = images.get(msg.handle);
+			if (!img) {
+				respond({ type: "error", id: msg.id, error: "Invalid image handle" });
+				break;
+			}
+			try {
+				const filter = msg.filter as SamplingFilter;
+				const resized = wasmResize(img, msg.width, msg.height, filter);
+				const handle = nextHandle++;
+				images.set(handle, resized);
+				respond({
+					type: "resized",
+					id: msg.id,
+					handle,
+					width: resized.get_width(),
+					height: resized.get_height(),
+				});
+			} catch (err) {
+				respond({
+					type: "error",
+					id: msg.id,
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
+			break;
+		}
+
+		case "get_dimensions": {
+			const img = images.get(msg.handle);
+			if (!img) {
+				respond({ type: "error", id: msg.id, error: "Invalid image handle" });
+				break;
+			}
+			respond({
+				type: "dimensions",
+				id: msg.id,
+				width: img.get_width(),
+				height: img.get_height(),
+			});
+			break;
+		}
+
+		case "get_png": {
+			const img = images.get(msg.handle);
+			if (!img) {
+				respond({ type: "error", id: msg.id, error: "Invalid image handle" });
+				break;
+			}
+			try {
+				const bytes = img.get_bytes();
+				respond({ type: "bytes", id: msg.id, bytes }, [bytes.buffer]);
+			} catch (err) {
+				respond({
+					type: "error",
+					id: msg.id,
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
+			break;
+		}
+
+		case "get_jpeg": {
+			const img = images.get(msg.handle);
+			if (!img) {
+				respond({ type: "error", id: msg.id, error: "Invalid image handle" });
+				break;
+			}
+			try {
+				const bytes = img.get_bytes_jpeg(msg.quality);
+				respond({ type: "bytes", id: msg.id, bytes }, [bytes.buffer]);
+			} catch (err) {
+				respond({
+					type: "error",
+					id: msg.id,
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
+			break;
+		}
+
+		case "free": {
+			const img = images.get(msg.handle);
+			if (img) {
+				img.free();
+				images.delete(msg.handle);
+			}
+			respond({ type: "freed", id: msg.id });
+			break;
+		}
+	}
+});

package/src/index.ts

@@ -0,0 +1,140 @@
+/**
+ * Native utilities powered by WASM.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { globPaths } from "@oh-my-pi/pi-utils";
+
+// =============================================================================
+// Grep (ripgrep-based regex search)
+// =============================================================================
+
+export {
+	type ContextLine,
+	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;
+}
+
+/**
+ * Find files matching a glob pattern.
+ * Respects .gitignore by default.
+ */
+export async function find(options: FindOptions, onMatch?: (match: FindMatch) => void): Promise<FindResult> {
+	const searchPath = path.resolve(options.path);
+	const pattern = options.pattern || "*";
+
+	// 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,
+	};
+}
+
+// =============================================================================
+// Image processing (photon-compatible API)
+// =============================================================================
+
+export {
+	PhotonImage,
+	resize,
+	SamplingFilter,
+	terminate as terminateImageWorker,
+} from "./image/index";
+
+// =============================================================================
+// Worker Pool (shared infrastructure)
+// =============================================================================
+
+export { type BaseRequest, type BaseResponse, WorkerPool, type WorkerPoolOptions } from "./pool";