wasm-html-to-image 0.1.0

package/dist/workers-parent.js

@@ -0,0 +1,602 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __esmMin = (fn, res, err) => () => {
+	if (err) throw err[0];
+	try {
+		return fn && (res = fn(fn = 0)), res;
+	} catch (e) {
+		throw err = [e], e;
+	}
+};
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/loader.ts
+/**
+* Runtime-only load of a `node:` builtin (e.g. `importNode("fs/promises")`).
+* Uses `process.getBuiltinModule` (Node 22.3+/20.16+) so there is NO `import`
+* syntax at all: bundlers with static analysis (webpack/vite/rollup, and
+* Turbopack — the Next.js 16 default builder, which rejects both dynamic
+* `` `node:${name}` `` requests and literal `import("node:*")` inside Edge
+* graphs) have nothing to resolve or rewrite. Only the builtins actually
+* used by this package are supported. All call sites are guarded to run on
+* Node only; other runtimes never evaluate these branches. A `new Function`
+* indirect-import fallback keeps older Node working without adding any
+* statically analyzable import.
+*/
+function importNode(name) {
+	if (name !== "fs/promises" && name !== "path" && name !== "module") throw new Error(`wasm-html-to-image: unsupported node builtin "${name}"`);
+	const proc = globalThis.process;
+	try {
+		const mod = proc?.getBuiltinModule?.(`node:${name}`);
+		if (mod) return Promise.resolve(mod);
+	} catch {}
+	return new Function("s", "return import(s)")(`node:${name}`);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/worker-lib@2.2.1/node_modules/worker-lib/dist/esm/common.js
+var FUNCTION_PLACEHOLDER, isPlaceholder, isPlainObject, getTransferables, createRegistry;
+var init_common = __esmMin((() => {
+	FUNCTION_PLACEHOLDER = "__worker_lib_function__";
+	isPlaceholder = (v) => v && typeof v === "object" && "__worker_lib_function__" in v;
+	isPlainObject = (v) => {
+		return v && typeof v === "object" && Object.prototype.toString.call(v) === "[object Object]" && !(v instanceof Uint8Array) && !(v instanceof ArrayBuffer) && !ArrayBuffer.isView(v);
+	};
+	getTransferables = (v, result = []) => {
+		if (v instanceof ArrayBuffer) result.push(v);
+		else if (ArrayBuffer.isView(v)) result.push(v.buffer);
+		else if (Array.isArray(v)) for (const item of v) getTransferables(item, result);
+		else if (v && typeof v === "object") for (const key in v) getTransferables(v[key], result);
+		return result;
+	};
+	createRegistry = () => {
+		const callbacks = /* @__PURE__ */ new Map();
+		const callbackProxies = /* @__PURE__ */ new Map();
+		const registerCallback = (requestId, fn) => {
+			const id = `${requestId}:${Math.random().toString(36).slice(2)}`;
+			callbacks.set(id, fn);
+			return id;
+		};
+		const clearCallbacks = (requestId) => {
+			for (const key of callbacks.keys()) if (key.startsWith(`${requestId}:`)) callbacks.delete(key);
+			for (const key of callbackProxies.keys()) if (key.startsWith(`${requestId}:`)) callbackProxies.delete(key);
+		};
+		const transformArgs = (requestId, args) => {
+			if (typeof args === "function") return { [FUNCTION_PLACEHOLDER]: registerCallback(requestId, args) };
+			if (ArrayBuffer.isView(args) || args instanceof ArrayBuffer) return args;
+			if (Array.isArray(args)) return args.map((v) => transformArgs(requestId, v));
+			if (isPlainObject(args)) {
+				const result = {};
+				for (const key in args) result[key] = transformArgs(requestId, args[key]);
+				return result;
+			}
+			return args;
+		};
+		const resolveArgs = (requestId, args, createProxy) => {
+			if (isPlaceholder(args)) return createProxy(args[FUNCTION_PLACEHOLDER]);
+			if (Array.isArray(args)) return args.map((v) => resolveArgs(requestId, v, createProxy));
+			if (isPlainObject(args)) {
+				const result = {};
+				for (const key in args) result[key] = resolveArgs(requestId, args[key], createProxy);
+				return result;
+			}
+			return args;
+		};
+		return {
+			callbacks,
+			callbackProxies,
+			registerCallback,
+			clearCallbacks,
+			transformArgs,
+			resolveArgs
+		};
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/worker-lib@2.2.1/node_modules/worker-lib/dist/esm/pool.js
+var requestIdCounter, exec, createWorkerPool, initUniversalWorker;
+var init_pool = __esmMin((() => {
+	init_common();
+	requestIdCounter = 0;
+	exec = (worker, name, registry, ...args) => {
+		const requestId = requestIdCounter++;
+		const { callbacks, callbackProxies, clearCallbacks, transformArgs, resolveArgs } = registry;
+		return new Promise((resolve, reject) => {
+			const createProxy = (callbackId) => {
+				const key = `${requestId}:${callbackId}`;
+				if (callbackProxies.has(key)) return callbackProxies.get(key);
+				const proxy = (...proxyArgs) => {
+					const callId = Math.random().toString(36).slice(2);
+					return new Promise((res) => {
+						const handler = (data) => {
+							if (data.type === "callback_result" && data.payload.id === callId) {
+								worker.removeEventListener("message", handler);
+								res(resolveArgs(requestId, data.payload.result, createProxy));
+							}
+						};
+						worker.addEventListener("message", handler);
+						const transformedProxyArgs = transformArgs(requestId, proxyArgs);
+						worker.postMessage({
+							type: "callback_call",
+							payload: {
+								id: requestId,
+								callbackId,
+								args: transformedProxyArgs,
+								callId
+							}
+						}, getTransferables(transformedProxyArgs));
+					});
+				};
+				callbackProxies.set(key, proxy);
+				return proxy;
+			};
+			const messageHandler = async (data) => {
+				if (!data || typeof data !== "object") return;
+				const payload = data.payload;
+				if (payload?.id !== requestId) return;
+				if (data.type === "result") {
+					worker.removeEventListener("message", messageHandler);
+					const result = resolveArgs(requestId, payload.result, createProxy);
+					clearCallbacks(requestId);
+					resolve(result);
+				} else if (data.type === "error") {
+					worker.removeEventListener("message", messageHandler);
+					clearCallbacks(requestId);
+					reject(payload.error);
+				} else if (data.type === "callback_call") {
+					const { callbackId, args: callArgs, callId } = payload;
+					const fn = callbacks.get(callbackId);
+					if (fn) try {
+						const result = await fn(...resolveArgs(requestId, callArgs, createProxy));
+						const transformedResult = transformArgs(requestId, result);
+						worker.postMessage({
+							type: "callback_result",
+							payload: {
+								id: callId,
+								result: transformedResult
+							}
+						}, getTransferables(transformedResult));
+					} catch (e) {
+						console.error("[worker-lib] Callback execution failed:", e);
+					}
+				}
+			};
+			worker.addEventListener("message", messageHandler);
+			const transformedArgs = transformArgs(requestId, args);
+			worker.postMessage({
+				type: "function",
+				payload: {
+					id: requestId,
+					name,
+					args: transformedArgs
+				}
+			}, getTransferables(transformedArgs));
+		});
+	};
+	createWorkerPool = (builder, limit = 4) => {
+		let workers = Array(limit).fill(void 0).map(() => ({}));
+		const emptyWaits = [];
+		let isEmptyWait = false;
+		const registry = createRegistry();
+		const getResolver = async () => {
+			while (true) {
+				const target = workers.find(({ resultResolver }) => !resultResolver);
+				if (target) {
+					target.resultResolver = Promise.withResolvers();
+					if (!target.worker) target.worker = await builder();
+					return target;
+				}
+				await Promise.race(workers.map(({ resultResolver }) => resultResolver?.promise));
+			}
+		};
+		const execute = async (name, ...value) => {
+			const target = await getResolver();
+			const { resultResolver } = target;
+			if (!resultResolver) throw new Error("Unexpected error");
+			exec(target.worker, name, registry, ...value).then(resultResolver.resolve).catch(resultResolver.reject).finally(() => {
+				target.resultResolver = void 0;
+			});
+			return resultResolver.promise;
+		};
+		const launchWorker = async () => {
+			return Promise.all(workers.map(async (target) => {
+				if (!target.worker) target.worker = await builder();
+			}));
+		};
+		const waitAll = async () => {
+			while (workers.find(({ resultResolver }) => resultResolver)) await Promise.all(workers.flatMap(({ resultResolver }) => resultResolver ? [resultResolver.promise] : []));
+		};
+		const waitReady = async (retryTime = 1) => {
+			const p = Promise.withResolvers();
+			emptyWaits.push(p);
+			(async () => {
+				if (!isEmptyWait) {
+					isEmptyWait = true;
+					do {
+						const actives = workers.flatMap(({ resultResolver }) => resultResolver ? [resultResolver.promise] : []);
+						if (workers.length === actives.length) await Promise.race(actives);
+						emptyWaits.shift()?.resolve();
+						if (retryTime) await new Promise((r) => setTimeout(r, retryTime));
+						else await Promise.resolve();
+					} while (emptyWaits.length);
+					isEmptyWait = false;
+				}
+			})();
+			return p.promise;
+		};
+		const close = () => {
+			for (const target of workers) {
+				target.worker?.terminate();
+				target.worker = void 0;
+				target.resultResolver = void 0;
+			}
+		};
+		const setLimit = (newLimit) => {
+			workers.forEach((w) => w.worker?.terminate());
+			workers = Array(newLimit).fill(void 0).map(() => ({}));
+		};
+		return {
+			execute,
+			waitAll,
+			waitReady,
+			close,
+			setLimit,
+			launchWorker
+		};
+	};
+	initUniversalWorker = (worker, WorkerProc) => {
+		const { callbacks, callbackProxies, registerCallback, clearCallbacks, transformArgs, resolveArgs } = createRegistry();
+		const createProxy = (callbackId, requestId) => {
+			const key = `${requestId}:${callbackId}`;
+			if (callbackProxies.has(key)) return callbackProxies.get(key);
+			const proxy = (...proxyArgs) => {
+				const callId = Math.random().toString(36).slice(2);
+				return new Promise((res) => {
+					const handler = (data) => {
+						if (data.type === "callback_result" && data.payload.id === callId) {
+							worker.removeEventListener("message", handler);
+							res(resolveArgs(requestId, data.payload.result, (cbId) => createProxy(cbId, requestId)));
+						}
+					};
+					worker.addEventListener("message", handler);
+					const transformedArgs = transformArgs(requestId, proxyArgs);
+					worker.postMessage({
+						type: "callback_call",
+						payload: {
+							id: requestId,
+							callbackId,
+							args: transformedArgs,
+							callId
+						}
+					}, getTransferables(transformedArgs));
+				});
+			};
+			callbackProxies.set(key, proxy);
+			return proxy;
+		};
+		worker.addEventListener("message", async (data) => {
+			if (!data) return;
+			if (data.type === "function") {
+				const { id, name, args } = data.payload;
+				const proc = WorkerProc[name];
+				if (proc) try {
+					const result = await proc(...resolveArgs(id, args, (cbId) => createProxy(cbId, id)));
+					const transformedResult = transformArgs(id, result);
+					worker.postMessage({
+						type: "result",
+						payload: {
+							id,
+							result: transformedResult
+						}
+					}, getTransferables(transformedResult));
+					clearCallbacks(id);
+				} catch (error) {
+					worker.postMessage({
+						type: "error",
+						payload: {
+							id,
+							error: String(error)
+						}
+					});
+					clearCallbacks(id);
+				}
+			} else if (data.type === "callback_call") {
+				const { id, callbackId, args, callId } = data.payload;
+				const fn = callbacks.get(callbackId);
+				if (fn) try {
+					const result = await fn(...resolveArgs(id, args, (cbId) => createProxy(cbId, id)));
+					const transformedResult = transformArgs(id, result);
+					worker.postMessage({
+						type: "callback_result",
+						payload: {
+							id: callId,
+							result: transformedResult
+						}
+					}, getTransferables(transformedResult));
+				} catch (e) {
+					console.error("[worker-lib] Worker-side callback failed:", e);
+				}
+			}
+		});
+		worker.postMessage("ready");
+		return WorkerProc;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/worker-lib@2.2.1/node_modules/worker-lib/dist/esm/index.js
+var esm_exports = /* @__PURE__ */ __exportAll({
+	Worker: () => w,
+	createWorker: () => createWorker$1,
+	initWorker: () => initWorker
+});
+var w, wrapWorker, init, createWorker$1, initWorker;
+var init_esm = __esmMin((() => {
+	init_pool();
+	w = Worker;
+	wrapWorker = (worker) => ({
+		postMessage: (message, transfer) => worker.postMessage(message, transfer),
+		addEventListener: (type, listener) => {
+			const handler = (e) => {
+				if (e instanceof MessageEvent) listener(e.data);
+			};
+			listener._handler = handler;
+			worker.addEventListener(type, handler);
+		},
+		removeEventListener: (type, listener) => {
+			const handler = listener._handler;
+			worker.removeEventListener(type, handler);
+		},
+		terminate: () => worker.terminate()
+	});
+	init = (worker) => {
+		return new Promise((resolve) => {
+			const handler = (e) => {
+				if (e.data === "ready") {
+					worker.removeEventListener("message", handler);
+					resolve(worker);
+				}
+			};
+			worker.addEventListener("message", handler);
+		});
+	};
+	createWorker$1 = (builder, limit = 4) => {
+		return createWorkerPool(async () => {
+			const result = builder();
+			const worker = result instanceof Worker ? result : new Worker(result);
+			await init(worker);
+			return wrapWorker(worker);
+		}, limit);
+	};
+	initWorker = (WorkerProc) => {
+		const worker = self;
+		return initUniversalWorker({
+			postMessage: (message, transfer) => worker.postMessage(message, transfer),
+			addEventListener: (type, listener) => {
+				const handler = (e) => {
+					if (e instanceof MessageEvent) listener(e.data);
+				};
+				listener._handler = handler;
+				worker.addEventListener(type, handler);
+			},
+			removeEventListener: (type, listener) => {
+				const handler = listener._handler;
+				worker.removeEventListener(type, handler);
+			},
+			terminate: () => {}
+		}, WorkerProc);
+	};
+}));
+//#endregion
+//#region src/worker-lib-loader.ts
+let cached;
+/**
+* Load worker-lib, tolerating its broken native-ESM build: the published
+* `dist/esm/*.js` uses extensionless relative imports (`./pool`), which
+* throw `ERR_MODULE_NOT_FOUND` under plain Node (2.2.0/2.2.1; upstream
+* dodges this via bundler resolution). Plain Node falls back to the CJS
+* build via `createRequire`, which resolves fine.
+*
+* No `@vite-ignore` on the first import so bundlers still substitute the
+* browser build for browser targets.
+*/
+function loadWorkerLib() {
+	if (!cached) {
+		cached = (async () => {
+			try {
+				return await Promise.resolve().then(() => (init_esm(), esm_exports));
+			} catch {
+				return (await importNode("module")).createRequire(import.meta.url)("worker-lib");
+			}
+		})();
+		cached.catch(() => {
+			resetWorkerLib();
+		});
+	}
+	return cached;
+}
+/** Drop the cached load (e.g. after a failed load) so it can be retried. */
+function resetWorkerLib() {
+	cached = void 0;
+}
+//#endregion
+//#region src/diagnostics.ts
+/**
+* Playground-parity diagnostics (satoru-compatible shapes).
+*
+* `LogLevel` mirrors `satoru/log-level.ts` verbatim (numeric levels shared
+* with the WASM `set_log_level` binding). `RenderDiagnostics` mirrors
+* satoru's `RenderDiagnostics` so playground-style consumers can switch
+* imports without reshaping reports.
+*/
+/** Log severity, shared with the WASM `set_log_level` binding. */
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel[LogLevel["None"] = 0] = "None";
+	LogLevel[LogLevel["Error"] = 1] = "Error";
+	LogLevel[LogLevel["Warning"] = 2] = "Warning";
+	LogLevel[LogLevel["Info"] = 3] = "Info";
+	LogLevel[LogLevel["Debug"] = 4] = "Debug";
+	return LogLevel;
+}({});
+/** Machine-readable diagnostic codes (satoru parity). */
+const DIAGNOSTIC_CODES = {
+	LIMIT_TIMEOUT: "LIMIT_TIMEOUT",
+	LIMIT_RESOURCE_SIZE: "LIMIT_RESOURCE_SIZE",
+	LIMIT_TOTAL_SIZE: "LIMIT_TOTAL_SIZE",
+	LIMIT_RESOURCE_COUNT: "LIMIT_RESOURCE_COUNT",
+	LIMIT_PROTOCOL_BLOCKED: "LIMIT_PROTOCOL_BLOCKED",
+	LIMIT_HOST_BLOCKED: "LIMIT_HOST_BLOCKED",
+	/** Extension: a resource fetch (or resolveResource hook) failed. */
+	RESOURCE_FETCH_FAILED: "RESOURCE_FETCH_FAILED"
+};
+//#endregion
+//#region src/core.ts
+const EMOJI_URL = "https://cdn.jsdelivr.net/npm/@fontsource/noto-color-emoji/files/noto-color-emoji-emoji-400-normal.woff2";
+/**
+* Upstream default font strategy (verbatim from satoru `DEFAULT_FONT_MAP`):
+* generic families resolve to Google Fonts css2 URLs (fetched with a browser
+* UA so woff2 is served); fetched at render time, nothing bundled.
+*/
+const DEFAULT_FONT_MAP = {
+	"sans-serif": "https://fonts.googleapis.com/css2?family=Noto+Sans+JP",
+	serif: "https://fonts.googleapis.com/css2?family=Noto+Serif+JP",
+	monospace: "https://fonts.googleapis.com/css2?family=M+PLUS+1+Code",
+	cursive: "https://fonts.googleapis.com/css2?family=Yuji+Syuku",
+	fantasy: "https://fonts.googleapis.com/css2?family=Reggae+One",
+	"Noto Color Emoji": EMOJI_URL,
+	emoji: EMOJI_URL,
+	"Noto Emoji": EMOJI_URL,
+	notocoloremoji: EMOJI_URL,
+	notoemoji: EMOJI_URL
+};
+//#endregion
+//#region src/workers.ts
+const { createWorker, Worker: Worker$1 } = await loadWorkerLib();
+/**
+* Create a wasm-html-to-image worker pool using worker-lib.
+* The pooled action is the unified `render` (HTML and image inputs).
+* Each worker thread loads its own module instance via the loader
+* (modules cannot cross thread boundaries).
+*
+* @param params Initialization parameters
+* @param params.worker Optional: Path to the worker file, a URL, or a factory function.
+*                      Defaults to the pre-bundled browser worker
+*                      (`./web-workers.js`, SINGLE_FILE inlined) when
+*                      `window` exists, else the Node worker
+*                      (`./child-workers.js`) next to this file.
+* @param params.maxParallel Maximum number of parallel workers (default: 4)
+* @param params.timeoutMs Optional: Default timeout in milliseconds for each render job.
+*                         If a render job times out, the pool is reset to prevent hung workers.
+*/
+const createHtmlToImageWorker = (params) => {
+	const { worker, maxParallel = 4, timeoutMs } = params ?? {};
+	const factory = () => {
+		let w;
+		if (worker) w = typeof worker === "function" ? worker() : worker;
+		else {
+			const workerUrl = typeof window !== "undefined" ? new URL("./web-workers.js", import.meta.url) : new URL("./child-workers.js", import.meta.url);
+			if (typeof Worker$1 !== "undefined") w = new Worker$1(workerUrl, { type: "module" });
+		}
+		if (!w) throw new Error("Worker is not supported in this environment.");
+		return w;
+	};
+	const workerInstance = createWorker(factory, maxParallel);
+	let totalPendingJobs = 0;
+	let completedJobs = 0;
+	let failedJobs = 0;
+	let totalJobTimeMs = 0;
+	/**
+	* Retrieve operational stats of the worker pool.
+	*/
+	const getStats = () => ({
+		workerCount: maxParallel,
+		activeJobs: Math.min(totalPendingJobs, maxParallel),
+		queuedJobs: Math.max(0, totalPendingJobs - maxParallel),
+		completedJobs,
+		failedJobs,
+		avgJobTimeMs: completedJobs > 0 ? totalJobTimeMs / completedJobs : 0
+	});
+	/**
+	* Reset the worker pool by terminating all running workers and recreating them.
+	* Useful to clear hung workers or reset statistics.
+	*/
+	const reset = () => {
+		workerInstance.setLimit(0);
+		workerInstance.setLimit(maxParallel);
+		totalPendingJobs = 0;
+		completedJobs = 0;
+		failedJobs = 0;
+		totalJobTimeMs = 0;
+	};
+	return new Proxy(workerInstance, { get(target, prop, receiver) {
+		if (prop === "getStats") return getStats;
+		if (prop === "reset") return reset;
+		if (prop === "render") return async (options) => {
+			totalPendingJobs++;
+			const startTime = Date.now();
+			let timeoutId;
+			let timeoutPromise;
+			if (timeoutMs !== void 0 && timeoutMs > 0) timeoutPromise = new Promise((_, reject) => {
+				timeoutId = setTimeout(() => {
+					reset();
+					reject(/* @__PURE__ */ new Error(`Render timed out after ${timeoutMs}ms`));
+				}, timeoutMs);
+			});
+			let execOptions = options;
+			if (options && typeof options === "object") {
+				if (options.value instanceof Uint8Array) execOptions = {
+					...options,
+					value: options.value.slice()
+				};
+				else if (options.value instanceof ArrayBuffer) execOptions = {
+					...options,
+					value: options.value.slice(0)
+				};
+			}
+			try {
+				const executePromise = target.execute("render", execOptions);
+				const result = await (timeoutPromise ? Promise.race([executePromise, timeoutPromise]) : executePromise);
+				completedJobs++;
+				totalJobTimeMs += Date.now() - startTime;
+				return result;
+			} catch (e) {
+				failedJobs++;
+				throw e;
+			} finally {
+				if (timeoutId) clearTimeout(timeoutId);
+				totalPendingJobs--;
+			}
+		};
+		if (prop in target) return Reflect.get(target, prop, receiver);
+	} });
+};
+let defaultWorker;
+/** Lazily create the shared single-slot pool on first use (not at import). */
+function getDefaultWorker() {
+	if (!defaultWorker) defaultWorker = createHtmlToImageWorker({ maxParallel: 1 });
+	return defaultWorker;
+}
+const close = () => {
+	getDefaultWorker().close();
+};
+function render(options) {
+	return getDefaultWorker().render(options);
+}
+const launchWorker = () => getDefaultWorker().launchWorker();
+const setLimit = (limit) => {
+	getDefaultWorker().setLimit(limit);
+};
+const waitAll = () => getDefaultWorker().waitAll();
+const waitReady = (retryTime) => getDefaultWorker().waitReady(retryTime);
+const reset = () => {
+	getDefaultWorker().reset();
+};
+const getStats = () => getDefaultWorker().getStats();
+//#endregion
+export { DEFAULT_FONT_MAP, DIAGNOSTIC_CODES, LogLevel, close, createHtmlToImageWorker, getStats, launchWorker, render, reset, setLimit, waitAll, waitReady };

package/dist/workers.d.ts

@@ -0,0 +1,86 @@
+export type { HtmlToImageWorker } from "./child-workers.js";
+import { type HtmlToImageOptions, type RenderResult } from "./core.js";
+export type { HtmlToImageOptions, RenderResult } from "./core.js";
+export { DEFAULT_FONT_MAP, DIAGNOSTIC_CODES, LogLevel } from "./core.js";
+export type { DiagnosticMessage, FontDiagnostic, RenderDiagnostics, RenderLimits, ResolveResourceHook, ResourceDiagnostic, } from "./core.js";
+/** Operational stats of the worker pool. */
+export interface WorkerPoolStats {
+    /** Number of workers in the pool */
+    workerCount: number;
+    /** Jobs currently being executed */
+    activeJobs: number;
+    /** Jobs waiting for a free worker */
+    queuedJobs: number;
+    /** Total jobs completed successfully since start */
+    completedJobs: number;
+    /** Total jobs that failed since start */
+    failedJobs: number;
+    /** Average time per job in milliseconds */
+    avgJobTimeMs: number;
+}
+/**
+ * Create a wasm-html-to-image worker pool using worker-lib.
+ * The pooled action is the unified `render` (HTML and image inputs).
+ * Each worker thread loads its own module instance via the loader
+ * (modules cannot cross thread boundaries).
+ *
+ * @param params Initialization parameters
+ * @param params.worker Optional: Path to the worker file, a URL, or a factory function.
+ *                      Defaults to the pre-bundled browser worker
+ *                      (`./web-workers.js`, SINGLE_FILE inlined) when
+ *                      `window` exists, else the Node worker
+ *                      (`./child-workers.js`) next to this file.
+ * @param params.maxParallel Maximum number of parallel workers (default: 4)
+ * @param params.timeoutMs Optional: Default timeout in milliseconds for each render job.
+ *                         If a render job times out, the pool is reset to prevent hung workers.
+ */
+export declare const createHtmlToImageWorker: (params?: {
+    worker?: string | URL | (() => Worker | string | URL);
+    maxParallel?: number;
+    timeoutMs?: number;
+}) => Omit<{
+    execute: <K extends "render">(name: K, ...value: Parameters<{
+        render(options: HtmlToImageOptions): Promise<RenderResult<Uint8Array | string>>;
+    }[K]>) => Promise<Awaited<ReturnType<{
+        render(options: HtmlToImageOptions): Promise<RenderResult<Uint8Array | string>>;
+    }[K]>>>;
+    waitAll: () => Promise<void>;
+    waitReady: (retryTime?: number) => Promise<void>;
+    close: () => void;
+    setLimit: (newLimit: number) => void;
+    launchWorker: () => Promise<void[]>;
+}, "execute"> & {
+    render(options: HtmlToImageOptions): Promise<RenderResult<Uint8Array | string>>;
+} & {
+    /**
+     * Retrieve operational stats of the worker pool.
+     */
+    getStats: () => WorkerPoolStats;
+    /**
+     * Reset the worker pool by terminating all running workers and recreating them.
+     */
+    reset: () => void;
+    /**
+     * Close and terminate all workers in the pool immediately.
+     */
+    close: () => void;
+    /**
+     * Wait for all running tasks in the pool to complete.
+     */
+    waitAll: () => Promise<void>;
+    /**
+     * Wait until there is an available worker slot in the pool.
+     */
+    waitReady: (retryTime?: number) => Promise<void>;
+};
+export declare const close: () => void;
+export declare function render(options: HtmlToImageOptions & {
+    format: "svg";
+}): Promise<RenderResult<string>>;
+export declare function render(options: HtmlToImageOptions): Promise<RenderResult<Uint8Array | string>>;
+export declare const launchWorker: () => Promise<void[]>;
+export declare const setLimit: (limit: number) => void;
+export declare const waitAll: () => Promise<void>;
+export declare const waitReady: (retryTime?: number) => Promise<void>;
+export declare const reset: () => void;
+export declare const getStats: () => WorkerPoolStats;