@oh-my-pi/pi-natives 8.12.9 → 8.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-natives",
-	"version": "8.12.9",
+	"version": "8.13.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": "8.12.9"
+		"@oh-my-pi/pi-utils": "8.13.0"
 	},
 	"devDependencies": {
 		"@types/node": "^25.0.10"

package/src/highlight/index.ts

@@ -0,0 +1,55 @@
+/**
+ * Syntax highlighting powered by WASM (syntect).
+ */
+
+import * as wasm from "../../wasm/pi_natives";
+
+type WasmHighlightExports = typeof wasm & {
+	highlight_code: (code: string, lang: string | null | undefined, colors: HighlightColors) => string;
+	supports_language: (lang: string) => boolean;
+	get_supported_languages: () => string[];
+};
+
+const wasmHighlight = wasm as WasmHighlightExports;
+
+/**
+ * Theme colors for syntax highlighting.
+ * Each color should be an ANSI escape sequence (e.g., "\x1b[38;2;255;0;0m").
+ */
+export interface HighlightColors {
+	comment: string;
+	keyword: string;
+	function: string;
+	variable: string;
+	string: string;
+	number: string;
+	type: string;
+	operator: string;
+	punctuation: string;
+}
+
+/**
+ * Highlight code with syntax coloring.
+ *
+ * @param code - The source code to highlight
+ * @param lang - Optional language identifier (e.g., "rust", "typescript", "python")
+ * @param colors - Theme colors as ANSI escape sequences
+ * @returns Highlighted code as a single string with ANSI color codes
+ */
+export function highlightCode(code: string, lang: string | undefined, colors: HighlightColors): string {
+	return wasmHighlight.highlight_code(code, lang, colors);
+}
+
+/**
+ * Check if a language is supported for highlighting.
+ */
+export function supportsLanguage(lang: string): boolean {
+	return wasmHighlight.supports_language(lang);
+}
+
+/**
+ * Get list of all supported languages.
+ */
+export function getSupportedLanguages(): string[] {
+	return wasmHighlight.get_supported_languages();
+}

package/src/html/index.ts

@@ -0,0 +1,47 @@
+/**
+ * HTML to Markdown conversion powered by WASM.
+ *
+ * Conversion happens in a worker thread to avoid blocking the main thread.
+ */
+
+import { type RequestOptions, WorkerPool } from "../pool";
+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,
+	maxWorkers: 2,
+	idleTimeoutMs: 30_000,
+});
+
+/**
+ * Convert HTML to Markdown.
+ *
+ * @param html - HTML content to convert
+ * @param options - Conversion options
+ * @returns Markdown text
+ */
+export async function htmlToMarkdown(
+	html: string,
+	options?: HtmlToMarkdownOptions,
+	req?: RequestOptions,
+): Promise<string> {
+	const response = await pool.request<Extract<HtmlResponse, { type: "converted" }>>(
+		{
+			type: "convert",
+			html,
+			options,
+		},
+		req,
+	);
+	return response.markdown;
+}
+
+/**
+ * Terminate the HTML worker pool.
+ * Call this when shutting down to clean up resources.
+ */
+export function terminate(): void {
+	pool.terminate();
+}

package/src/html/types.ts

@@ -0,0 +1,25 @@
+/**
+ * Types for HTML to Markdown worker communication.
+ */
+
+export interface HtmlToMarkdownOptions {
+	/** Remove navigation elements, forms, headers, footers */
+	cleanContent?: boolean;
+	/** 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/html/worker.ts

@@ -0,0 +1,40 @@
+/**
+ * Worker for HTML to Markdown conversion.
+ * Uses WASM for actual conversion.
+ */
+
+import { html_to_markdown } from "../../wasm/pi_natives";
+import type { HtmlRequest, HtmlResponse } from "./types";
+
+declare const self: Worker;
+
+function respond(msg: HtmlResponse): void {
+	self.postMessage(msg);
+}
+
+self.addEventListener("message", (e: MessageEvent<HtmlRequest>) => {
+	const msg = e.data;
+
+	switch (msg.type) {
+		case "init":
+			respond({ type: "ready", id: msg.id });
+			break;
+
+		case "destroy":
+			break;
+
+		case "convert": {
+			try {
+				const markdown = html_to_markdown(msg.html, msg.options);
+				respond({ type: "converted", id: msg.id, markdown });
+			} catch (err) {
+				respond({
+					type: "error",
+					id: msg.id,
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
+			break;
+		}
+	}
+});

package/src/image/index.ts

@@ -49,9 +49,12 @@ export class PhotonImage {
 	 * 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,
-		]);
+		const response = await pool.request<Extract<ImageResponse, { type: "loaded" }>>(
+			{ type: "load", bytes },
+			{
+				transfer: [bytes.buffer],
+			},
+		);
 		return new PhotonImage(response.handle, response.width, response.height);
 	}
 

package/src/index.ts

@@ -146,8 +146,29 @@ export {
 	visibleWidth,
 } from "./text/index";
 
+// =============================================================================
+// Syntax highlighting
+// =============================================================================
+
+export {
+	getSupportedLanguages,
+	type HighlightColors,
+	highlightCode,
+	supportsLanguage,
+} from "./highlight/index";
+
+// =============================================================================
+// HTML to Markdown
+// =============================================================================
+
+export {
+	type HtmlToMarkdownOptions,
+	htmlToMarkdown,
+	terminate as terminateHtmlWorker,
+} from "./html/index";
+
 // =============================================================================
 // Worker Pool (shared infrastructure)
 // =============================================================================
 
-export { type BaseRequest, type BaseResponse, WorkerPool, type WorkerPoolOptions } from "./pool";
+export { type BaseRequest, type BaseResponse, type RequestOptions, WorkerPool, type WorkerPoolOptions } from "./pool";

package/src/pool.ts

@@ -27,6 +27,17 @@ export interface WorkerPoolOptions {
 	idleTimeoutMs?: number;
 	/** Timeout for worker initialization in ms (default: 10000). */
 	initTimeoutMs?: number;
+	/** Grace period after request timeout before force-terminating stuck workers (default: 5000). */
+	stuckGracePeriodMs?: number;
+}
+
+export interface RequestOptions {
+	/** Timeout for this request in ms. After this, the promise rejects but worker gets a grace period. */
+	timeoutMs?: number;
+	/** Abort signal for this request. */
+	signal?: AbortSignal;
+	/** Transfer list for postMessage. */
+	transfer?: ArrayBufferLike[];
 }
 
 interface PooledWorker {
@@ -39,7 +50,8 @@ interface PooledWorker {
 interface PendingRequest<T> {
 	resolve: (result: T) => void;
 	reject: (error: Error) => void;
-	timeout?: ReturnType<typeof setTimeout>;
+	worker?: PooledWorker;
+	dispose?: () => void;
 }
 
 /**
@@ -62,26 +74,51 @@ export class WorkerPool<TReq extends BaseRequest, TRes extends BaseResponse> {
 			maxWorkers: options.maxWorkers ?? 4,
 			idleTimeoutMs: options.idleTimeoutMs ?? 30_000,
 			initTimeoutMs: options.initTimeoutMs ?? 10_000,
+			stuckGracePeriodMs: options.stuckGracePeriodMs ?? 5_000,
 		};
 	}
 
 	/**
 	 * Send a request to a worker and wait for the response.
 	 * Workers are acquired from the pool (or created if under limit).
+	 *
+	 * @param msg - Request message
+	 * @param options - Request options (timeout, transfer)
 	 */
 	async request<T extends TRes = TRes>(
 		msg: TReq | (Omit<TReq, "id"> & { id?: number }),
-		transfer?: ArrayBufferLike[],
+		options?: RequestOptions,
 	): Promise<T> {
+		const { timeoutMs, signal, transfer } = options ?? {};
+		signal?.throwIfAborted();
+
 		const worker = await this.#acquireWorker();
 		const id = msg.id ?? this.#nextRequestId++;
 		const fullMsg = { ...msg, id } as TReq;
 
 		const { promise, resolve, reject } = Promise.withResolvers<T>();
-		this.#pending.set(id, {
+		const pending: PendingRequest<T> = {
 			resolve: resolve as (result: TRes) => void,
 			reject,
-		});
+			worker,
+		};
+		this.#pending.set(id, pending as PendingRequest<TRes>);
+
+		const onAbort = () => {
+			this.#handleRequestAbort(id, worker);
+		};
+
+		if (timeoutMs && timeoutMs > 0 && signal) {
+			const combined = AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]);
+			combined.addEventListener("abort", onAbort, { once: true });
+			pending.dispose = () => combined.removeEventListener("abort", onAbort);
+		} else if (timeoutMs && timeoutMs > 0) {
+			const timer = setTimeout(onAbort, timeoutMs);
+			pending.dispose = () => clearTimeout(timer);
+		} else if (signal) {
+			signal.addEventListener("abort", onAbort, { once: true });
+			pending.dispose = () => signal.removeEventListener("abort", onAbort);
+		}
 
 		worker.currentRequestId = id;
 		if (transfer) {
@@ -109,7 +146,7 @@ export class WorkerPool<TReq extends BaseRequest, TRes extends BaseResponse> {
 
 		for (const pending of this.#pending.values()) {
 			pending.reject(new Error("Worker pool terminated"));
-			if (pending.timeout) clearTimeout(pending.timeout);
+			void pending.dispose?.();
 		}
 		this.#pending.clear();
 	}
@@ -144,7 +181,7 @@ export class WorkerPool<TReq extends BaseRequest, TRes extends BaseResponse> {
 		if (!pending) return;
 
 		this.#pending.delete(msg.id);
-		if (pending.timeout) clearTimeout(pending.timeout);
+		void pending.dispose?.();
 
 		if (msg.type === "error" && "error" in msg) {
 			pending.reject(new Error(msg.error ?? "Unknown error"));
@@ -163,11 +200,58 @@ export class WorkerPool<TReq extends BaseRequest, TRes extends BaseResponse> {
 		const pending = this.#pending.get(id);
 		if (pending) {
 			this.#pending.delete(id);
-			if (pending.timeout) clearTimeout(pending.timeout);
+			void pending.dispose?.();
 			pending.reject(error);
 		}
 	}
 
+	#handleRequestAbort(id: number, worker: PooledWorker): void {
+		const pending = this.#pending.get(id);
+		if (!pending) return;
+
+		pending.dispose = undefined;
+		pending.reject(new Error("Request timeout"));
+
+		if (this.#options.stuckGracePeriodMs > 0) {
+			const timer = setTimeout(() => {
+				this.#terminateStuckWorker(id, worker);
+			}, this.#options.stuckGracePeriodMs);
+
+			pending.dispose = () => {
+				clearTimeout(timer);
+			};
+		}
+	}
+
+	#terminateStuckWorker(id: number, worker: PooledWorker): void {
+		const pending = this.#pending.get(id);
+		if (pending) {
+			this.#pending.delete(id);
+			void pending.dispose?.();
+		}
+
+		if (worker.currentRequestId !== id) return;
+		if (!this.#pool.includes(worker)) return;
+
+		this.#removeWorker(worker);
+
+		if (this.#pool.length === 0 && this.#waiters.length > 0) {
+			this.#replenishPool();
+		}
+	}
+
+	async #replenishPool(): Promise<void> {
+		const worker = this.#createWorker();
+		worker.busy = true;
+		this.#pool.push(worker);
+		try {
+			await this.#initializeWorker(worker);
+			this.#releaseWorker(worker);
+		} catch {
+			this.#removeWorker(worker);
+		}
+	}
+
 	#removeWorker(pooledWorker: PooledWorker): void {
 		const idx = this.#pool.indexOf(pooledWorker);
 		if (idx !== -1) {
@@ -227,7 +311,7 @@ export class WorkerPool<TReq extends BaseRequest, TRes extends BaseResponse> {
 		this.#pending.set(id, {
 			resolve: () => resolve(),
 			reject,
-			timeout,
+			dispose: () => clearTimeout(timeout),
 		} as PendingRequest<TRes>);
 
 		pooledWorker.worker.postMessage({ type: "init", id } satisfies BaseRequest);

package/wasm/pi_natives.d.ts

@@ -77,11 +77,35 @@ export enum SamplingFilter {
  */
 export function extract_segments(line: string, before_end: number, after_start: number, after_len: number, strict_after: boolean): any;
 
+/**
+ * Get list of supported languages.
+ */
+export function get_supported_languages(): string[];
+
 /**
  * Quick check if content matches a pattern.
  */
 export function has_match(content: string, pattern: string, ignore_case: boolean, multiline: boolean): boolean;
 
+/**
+ * Highlight code and return ANSI-colored lines.
+ *
+ * # Arguments
+ * * `code` - The source code to highlight
+ * * `lang` - Language identifier (e.g., "rust", "typescript", "python")
+ * * `colors` - Theme colors as ANSI escape sequences
+ *
+ * # Returns
+ * Highlighted code with ANSI color codes, or the original code if highlighting
+ * fails.
+ */
+export function highlight_code(code: string, lang: string | null | undefined, colors: any): string;
+
+/**
+ * Convert HTML to Markdown.
+ */
+export function html_to_markdown(html: string, options: any): string;
+
 /**
  * Resize an image to the specified dimensions.
  */
@@ -98,6 +122,13 @@ export function search(content: string, options: any): any;
  */
 export function slice_with_width(line: string, start_col: number, length: number, strict: boolean): any;
 
+/**
+ * Check if a language is supported for highlighting.
+ * Returns true if the language has either direct support or a fallback
+ * mapping.
+ */
+export function supports_language(lang: string): boolean;
+
 /**
  * Truncate text to a visible width, preserving ANSI codes.
  */

package/wasm/pi_natives.js

@@ -226,6 +226,24 @@ export function extract_segments(line, before_end, after_start, after_len, stric
     return takeObject(ret);
 }
 
+/**
+ * Get list of supported languages.
+ * @returns {string[]}
+ */
+export function get_supported_languages() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.get_supported_languages(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export3(r0, r1 * 4, 4);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Quick check if content matches a pattern.
  * @param {string} content
@@ -254,6 +272,76 @@ export function has_match(content, pattern, ignore_case, multiline) {
     }
 }
 
+/**
+ * Highlight code and return ANSI-colored lines.
+ *
+ * # Arguments
+ * * `code` - The source code to highlight
+ * * `lang` - Language identifier (e.g., "rust", "typescript", "python")
+ * * `colors` - Theme colors as ANSI escape sequences
+ *
+ * # Returns
+ * Highlighted code with ANSI color codes, or the original code if highlighting
+ * fails.
+ * @param {string} code
+ * @param {string | null | undefined} lang
+ * @param {any} colors
+ * @returns {string}
+ */
+export function highlight_code(code, lang, colors) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(code, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(lang) ? 0 : passStringToWasm0(lang, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len1 = WASM_VECTOR_LEN;
+        wasm.highlight_code(retptr, ptr0, len0, ptr1, len1, addHeapObject(colors));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred3_0 = r0;
+        deferred3_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export3(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Convert HTML to Markdown.
+ * @param {string} html
+ * @param {any} options
+ * @returns {string}
+ */
+export function html_to_markdown(html, options) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(html, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.html_to_markdown(retptr, ptr0, len0, addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export3(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Resize an image to the specified dimensions.
  * @param {PhotonImage} image
@@ -297,6 +385,20 @@ export function slice_with_width(line, start_col, length, strict) {
     return takeObject(ret);
 }
 
+/**
+ * Check if a language is supported for highlighting.
+ * Returns true if the language has either direct support or a fallback
+ * mapping.
+ * @param {string} lang
+ * @returns {boolean}
+ */
+export function supports_language(lang) {
+    const ptr0 = passStringToWasm0(lang, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.supports_language(ptr0, len0);
+    return ret !== 0;
+}
+
 /**
  * Truncate text to a visible width, preserving ANSI codes.
  * @param {string} text
@@ -382,6 +484,10 @@ function __wbg_get_imports() {
             const ret = typeof(getObject(arg0)) === 'bigint';
             return ret;
         },
+        __wbg___wbindgen_is_null_ac34f5003991759a: function(arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        },
         __wbg___wbindgen_is_object_5ae8e5880f2c1fbd: function(arg0) {
             const val = getObject(arg0);
             const ret = typeof(val) === 'object' && val !== null;
@@ -629,6 +735,16 @@ function dropObject(idx) {
     heap_next = idx;
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);

package/wasm/pi_natives_bg.wasm.d.ts

@@ -7,7 +7,10 @@ export const compiledpattern_has_match: (a: number, b: number, c: number) => num
 export const compiledpattern_new: (a: number, b: number) => void;
 export const compiledpattern_search: (a: number, b: number, c: number, d: number, e: number) => number;
 export const extract_segments: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+export const get_supported_languages: (a: number) => void;
 export const has_match: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const highlight_code: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const html_to_markdown: (a: number, b: number, c: number, d: number) => void;
 export const photonimage_get_bytes: (a: number, b: number) => void;
 export const photonimage_get_bytes_jpeg: (a: number, b: number, c: number) => void;
 export const photonimage_get_height: (a: number) => number;
@@ -16,6 +19,7 @@ export const photonimage_new_from_byteslice: (a: number, b: number, c: number) =
 export const resize: (a: number, b: number, c: number, d: number) => number;
 export const search: (a: number, b: number, c: number) => number;
 export const slice_with_width: (a: number, b: number, c: number, d: number, e: number) => number;
+export const supports_language: (a: number, b: number) => number;
 export const truncate_to_width: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const visible_width: (a: number, b: number) => number;
 export const compiledpattern_has_match_bytes: (a: number, b: number, c: number) => number;