@tryhamster/gerbil 1.0.0-rc.0

package/dist/chrome-backend-C5Un08O4.mjs

@@ -0,0 +1,771 @@
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "fs";
+import { createServer } from "http";
+import { homedir } from "os";
+import { join } from "path";
+import puppeteer from "puppeteer-core";
+
+//#region src/core/chrome-backend.ts
+/**
+* Chrome DevTools Protocol Backend for WebGPU Inference
+*
+* Uses headless Chrome as a WebGPU accelerator for Node.js environments.
+* Provides the same performance as browser inference (~100+ tok/s with q4f16).
+*/
+const GERBIL_CACHE_DIR = join(homedir(), ".gerbil", "chrome-cache");
+const WS_ENDPOINT_FILE = join(GERBIL_CACHE_DIR, "ws-endpoint.txt");
+const CACHED_MODELS_FILE = join(homedir(), ".gerbil", "cached-models.json");
+/** Get list of models cached in Chrome's IndexedDB */
+function getChromeCachedModels() {
+	try {
+		if (!existsSync(CACHED_MODELS_FILE)) return [];
+		return JSON.parse(readFileSync(CACHED_MODELS_FILE, "utf-8")).models || [];
+	} catch {
+		return [];
+	}
+}
+/** Fetch model size from HuggingFace API */
+async function fetchModelSize(modelId) {
+	try {
+		const treeRes = await fetch(`https://huggingface.co/api/models/${modelId}/tree/main/onnx`);
+		if (treeRes.ok) {
+			const files = await treeRes.json();
+			const q4f16 = files.find((f) => f.path.includes("q4f16") && f.path.endsWith(".onnx"));
+			const q4 = files.find((f) => f.path.includes("q4") && !f.path.includes("f16") && f.path.endsWith(".onnx"));
+			const fp16 = files.find((f) => f.path.includes("fp16") && f.path.endsWith(".onnx"));
+			const anyOnnx = files.find((f) => f.path.endsWith(".onnx"));
+			const bestFile = q4f16 || q4 || fp16 || anyOnnx;
+			if (bestFile?.size) return bestFile.size;
+		}
+		const res = await fetch(`https://huggingface.co/api/models/${modelId}`);
+		if (res.ok) return (await res.json()).usedStorage;
+	} catch {}
+}
+/** Track a model as cached */
+function trackCachedModel(modelId, sizeBytes) {
+	try {
+		const dir = join(homedir(), ".gerbil");
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const models = getChromeCachedModels();
+		const existing = models.find((m) => m.modelId === modelId);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		if (existing) {
+			existing.lastUsed = now;
+			if (sizeBytes) existing.sizeBytes = sizeBytes;
+		} else models.push({
+			modelId,
+			downloadedAt: now,
+			lastUsed: now,
+			sizeBytes
+		});
+		writeFileSync(CACHED_MODELS_FILE, JSON.stringify({ models }, null, 2));
+		if (!sizeBytes) fetchModelSize(modelId).then((size) => {
+			if (size) {
+				const updatedModels = getChromeCachedModels();
+				const model = updatedModels.find((m) => m.modelId === modelId);
+				if (model) {
+					model.sizeBytes = size;
+					writeFileSync(CACHED_MODELS_FILE, JSON.stringify({ models: updatedModels }, null, 2));
+				}
+			}
+		}).catch(() => {});
+	} catch {}
+}
+/** Refresh sizes for cached models that don't have them */
+async function refreshCachedModelSizes() {
+	try {
+		const models = getChromeCachedModels();
+		const needsSize = models.filter((m) => !m.sizeBytes);
+		if (needsSize.length === 0) return;
+		const batchSize = 3;
+		for (let i = 0; i < needsSize.length; i += batchSize) {
+			const batch = needsSize.slice(i, i + batchSize);
+			await Promise.all(batch.map(async (model) => {
+				const size = await fetchModelSize(model.modelId);
+				if (size) model.sizeBytes = size;
+			}));
+		}
+		writeFileSync(CACHED_MODELS_FILE, JSON.stringify({ models }, null, 2));
+	} catch {}
+}
+const GERBIL_LOCAL_PORT = 43724;
+let globalBrowser = null;
+let globalBrowserPromise = null;
+let globalServer = null;
+let globalServerPort = 0;
+let activePagesCount = 0;
+const MAX_CONCURRENT_PAGES = 5;
+const CHROME_PATHS = {
+	darwin: [
+		"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+		"/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+		"/Applications/Chromium.app/Contents/MacOS/Chromium",
+		"/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+		"/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+	],
+	linux: [
+		"google-chrome-stable",
+		"google-chrome",
+		"chromium-browser",
+		"chromium",
+		"microsoft-edge",
+		"brave-browser"
+	],
+	win32: [
+		"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+		"C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+		`${process.env.LOCALAPPDATA}\\Google\\Chrome\\Application\\chrome.exe`,
+		"C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+		"C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"
+	]
+};
+function findChrome() {
+	if (process.env.CHROME_PATH) return process.env.CHROME_PATH;
+	const platform = process.platform;
+	const paths = CHROME_PATHS[platform] || [];
+	for (const p of paths) try {
+		if (platform === "linux") {
+			execSync(`which ${p}`, { stdio: "ignore" });
+			return p;
+		}
+		if (existsSync(p)) return p;
+	} catch {}
+	throw new Error("Chrome not found. Install Chrome or set CHROME_PATH environment variable.");
+}
+function getChromeFlags(userDataDir, _debuggingPort) {
+	const flags = ["--no-sandbox", `--user-data-dir=${userDataDir}`];
+	if (process.platform === "linux") flags.push("--enable-unsafe-webgpu", "--enable-features=Vulkan", "--use-angle=vulkan", "--disable-vulkan-surface");
+	else if (process.platform === "darwin") {} else flags.push("--enable-unsafe-webgpu");
+	return flags;
+}
+function getWorkerPageHTML(modelPath) {
+	return `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Gerbil WebGPU Backend</title>
+  <script type="module">
+    import {
+      AutoTokenizer,
+      AutoModelForCausalLM,
+      TextStreamer,
+      InterruptableStoppingCriteria,
+    } from "https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.8.0";
+
+    class ModelPipeline {
+      static tokenizer = null;
+      static model = null;
+      static modelId = "${modelPath}";
+
+      static async getInstance(progressCallback) {
+        if (!this.tokenizer) {
+          this.tokenizer = await AutoTokenizer.from_pretrained(this.modelId, {
+            progress_callback: progressCallback,
+          });
+        }
+
+        if (!this.model) {
+          this.model = await AutoModelForCausalLM.from_pretrained(this.modelId, {
+            dtype: "q4f16",
+            device: "webgpu",
+            progress_callback: progressCallback,
+          });
+        }
+
+        return { tokenizer: this.tokenizer, model: this.model };
+      }
+    }
+
+    const stoppingCriteria = new InterruptableStoppingCriteria();
+    let pastKeyValuesCache = null;
+    let totalTokensInCache = 0;
+    
+    // Context length for auto-reset (Qwen3 default: 2048)
+    // Cache beyond this provides no benefit and wastes memory
+    const CONTEXT_LENGTH = 2048;
+
+    // Auto-load model on page init
+    (async function() {
+      console.log(JSON.stringify({ type: "progress", status: "Loading model..." }));
+      
+      try {
+        const { tokenizer, model } = await ModelPipeline.getInstance((progress) => {
+          if (progress.status === "progress" && progress.file) {
+            console.log(JSON.stringify({
+              type: "progress",
+              status: "progress",
+              file: progress.file,
+              progress: Math.round(progress.progress || 0),
+            }));
+          }
+        });
+
+        console.log(JSON.stringify({ type: "progress", status: "Compiling shaders..." }));
+        const warmupInputs = tokenizer("a");
+        await model.generate({ ...warmupInputs, max_new_tokens: 1 });
+
+        console.log(JSON.stringify({ type: "ready" }));
+      } catch (error) {
+        console.log(JSON.stringify({ type: "error", error: error.message || String(error) }));
+      }
+    })();
+
+    window.gerbilGenerate = async function(messages, options = {}) {
+      const { maxTokens = 256, temperature = 0.7, topP = 0.9, topK = 20, thinking = false } = options;
+      
+      // Auto-reset KV cache if it exceeds context length
+      // This prevents unbounded memory growth while preserving performance
+      if (totalTokensInCache > CONTEXT_LENGTH) {
+        console.log(JSON.stringify({ 
+          type: "cache_reset", 
+          reason: "context_exceeded",
+          tokensInCache: totalTokensInCache,
+          contextLength: CONTEXT_LENGTH
+        }));
+        pastKeyValuesCache = null;
+        totalTokensInCache = 0;
+      }
+
+      try {
+        const { tokenizer, model } = await ModelPipeline.getInstance();
+
+        const inputs = tokenizer.apply_chat_template(messages, {
+          add_generation_prompt: true,
+          return_dict: true,
+          enable_thinking: thinking,
+        });
+
+        let state = "answering";
+        let prevState = "answering";
+        const [START_THINKING_TOKEN_ID, END_THINKING_TOKEN_ID] = tokenizer.encode(
+          "<think></think>",
+          { add_special_tokens: false }
+        );
+
+        let startTime = null;
+        let numTokens = 0;
+
+        const tokenCallback = (tokens) => {
+          startTime ??= performance.now();
+          numTokens++;
+          
+          const tokenId = Number(tokens[0]);
+          if (tokenId === START_THINKING_TOKEN_ID) {
+            state = "thinking";
+          } else if (tokenId === END_THINKING_TOKEN_ID) {
+            state = "answering";
+          }
+        };
+
+        const streamCallback = (text) => {
+          const tps = startTime ? (numTokens / (performance.now() - startTime)) * 1000 : 0;
+          
+          // Inject <think> markers when state changes (since skip_special_tokens removes them)
+          let outputText = text;
+          if (thinking) {
+            if (state === "thinking" && prevState !== "thinking") {
+              outputText = "<think>" + text;
+            } else if (state === "answering" && prevState === "thinking") {
+              outputText = "</think>" + text;
+            }
+          }
+          prevState = state;
+          
+          console.log(JSON.stringify({ type: "token", text: outputText, state, numTokens, tps }));
+        };
+
+        const streamer = new TextStreamer(tokenizer, {
+          skip_prompt: true,
+          skip_special_tokens: true,
+          callback_function: streamCallback,
+          token_callback_function: tokenCallback,
+        });
+
+        console.log(JSON.stringify({ type: "start" }));
+
+        const { past_key_values, sequences } = await model.generate({
+          ...inputs,
+          past_key_values: pastKeyValuesCache,
+          do_sample: temperature > 0,
+          temperature: temperature > 0 ? temperature : undefined,
+          top_p: topP,
+          top_k: topK,
+          max_new_tokens: maxTokens,
+          streamer,
+          stopping_criteria: stoppingCriteria,
+          return_dict_in_generate: true,
+        });
+
+        pastKeyValuesCache = past_key_values;
+        
+        // Track total tokens in cache (input + generated)
+        const inputLength = inputs.input_ids.dims[1];
+        totalTokensInCache += inputLength + numTokens;
+
+        const endTime = performance.now();
+        const totalTime = startTime ? endTime - startTime : 0;
+        
+        // Extract only the generated tokens (exclude input prompt)
+        const generatedTokens = sequences.slice(null, [inputLength, null]);
+        const decoded = tokenizer.batch_decode(generatedTokens, { skip_special_tokens: true });
+
+        console.log(JSON.stringify({
+          type: "complete",
+          text: decoded[0] || "",
+          numTokens,
+          totalTime,
+          tps: totalTime > 0 ? (numTokens / totalTime) * 1000 : 0,
+          tokensInCache: totalTokensInCache,
+        }));
+
+        return decoded[0] || "";
+      } catch (error) {
+        console.log(JSON.stringify({ type: "error", error: error.message || String(error) }));
+        throw error;
+      }
+    };
+
+    window.gerbilInterrupt = function() {
+      stoppingCriteria.interrupt();
+    };
+
+    window.gerbilReset = function() {
+      pastKeyValuesCache = null;
+      totalTokensInCache = 0;
+      stoppingCriteria.reset();
+      console.log(JSON.stringify({ type: "cache_reset", reason: "manual" }));
+    };
+
+    // Signal that the page is ready for commands
+    console.log(JSON.stringify({ type: "init" }));
+  <\/script>
+</head>
+<body>
+  <h1>Gerbil WebGPU Backend</h1>
+  <p>This page provides WebGPU inference for the Gerbil CLI.</p>
+</body>
+</html>
+`;
+}
+var ChromeGPUBackend = class ChromeGPUBackend {
+	browser = null;
+	page = null;
+	cdp = null;
+	serverPort = 0;
+	userDataDir = GERBIL_CACHE_DIR;
+	modelId;
+	isReady = false;
+	messageHandlers = /* @__PURE__ */ new Map();
+	pendingRejects = [];
+	server = null;
+	constructor(modelId) {
+		this.modelId = modelId;
+	}
+	/**
+	* Create and initialize a Chrome GPU backend
+	*/
+	static async create(options = {}) {
+		const backend = new ChromeGPUBackend(options.modelId || "onnx-community/Qwen3-0.6B-ONNX");
+		await backend.launch(options);
+		return backend;
+	}
+	/**
+	* Get existing browser or launch a new one (singleton pattern)
+	* Multiple Gerbil instances share the same browser process
+	*/
+	async getOrCreateBrowser(chromePath, options) {
+		if (globalBrowser?.connected) {
+			options.onProgress?.({ status: "Reusing existing Chrome..." });
+			return globalBrowser;
+		}
+		if (globalBrowserPromise) {
+			options.onProgress?.({ status: "Waiting for Chrome startup..." });
+			return globalBrowserPromise;
+		}
+		if (existsSync(WS_ENDPOINT_FILE)) try {
+			const wsEndpoint = readFileSync(WS_ENDPOINT_FILE, "utf-8").trim();
+			options.onProgress?.({ status: "Connecting to existing Chrome..." });
+			globalBrowser = await puppeteer.connect({ browserWSEndpoint: wsEndpoint });
+			return globalBrowser;
+		} catch {
+			try {
+				unlinkSync(WS_ENDPOINT_FILE);
+			} catch {}
+		}
+		globalBrowserPromise = this.launchBrowser(chromePath, options);
+		try {
+			globalBrowser = await globalBrowserPromise;
+			return globalBrowser;
+		} finally {
+			globalBrowserPromise = null;
+		}
+	}
+	/**
+	* Launch a new Chrome browser instance
+	*/
+	async launchBrowser(chromePath, _options) {
+		const debuggingPort = 9222 + Math.floor(Math.random() * 1e3);
+		const lockFile = join(this.userDataDir, "SingletonLock");
+		if (existsSync(lockFile)) try {
+			unlinkSync(lockFile);
+			await new Promise((r) => setTimeout(r, 200));
+		} catch {}
+		const browser = await puppeteer.launch({
+			executablePath: chromePath,
+			headless: true,
+			args: [
+				...getChromeFlags(this.userDataDir, debuggingPort),
+				"--enable-gpu",
+				"--no-first-run",
+				"--no-default-browser-check",
+				"--disable-background-timer-throttling",
+				"--disable-renderer-backgrounding",
+				"--disable-dev-shm-usage"
+			],
+			handleSIGINT: false,
+			handleSIGTERM: false,
+			handleSIGHUP: false
+		});
+		writeFileSync(WS_ENDPOINT_FILE, browser.wsEndpoint());
+		browser.on("disconnected", () => {
+			globalBrowser = null;
+			try {
+				unlinkSync(WS_ENDPOINT_FILE);
+			} catch {}
+		});
+		return browser;
+	}
+	/**
+	* Launch Chrome and initialize the worker page
+	*/
+	async launch(options) {
+		if (activePagesCount >= MAX_CONCURRENT_PAGES) throw new Error(`Maximum concurrent pages (${MAX_CONCURRENT_PAGES}) reached. Call dispose() on old Gerbil instances to free resources. Currently active: ${activePagesCount}`);
+		const chromePath = options.chromePath || findChrome();
+		this.userDataDir = GERBIL_CACHE_DIR;
+		if (!existsSync(this.userDataDir)) mkdirSync(this.userDataDir, { recursive: true });
+		const html = getWorkerPageHTML(this.modelId);
+		await this.startServer(html);
+		options.onProgress?.({ status: "Starting Chrome..." });
+		this.browser = await this.getOrCreateBrowser(chromePath, options);
+		this.page = await this.browser.newPage();
+		this.cdp = await this.page.createCDPSession();
+		activePagesCount++;
+		options.onProgress?.({ status: `Active pages: ${activePagesCount}/${MAX_CONCURRENT_PAGES}` });
+		this.browser.on("disconnected", () => {
+			console.error("[Chrome] Browser disconnected unexpectedly");
+			this.isReady = false;
+			this.browser = null;
+			this.page = null;
+			this.cdp = null;
+			this.rejectPendingWaits(/* @__PURE__ */ new Error("CHROME_DISCONNECTED"));
+		});
+		await this.cdp.send("Runtime.enable");
+		await this.cdp.send("Runtime.setAsyncCallStackDepth", { maxDepth: 32 });
+		this.cdp.on("Runtime.consoleAPICalled", (event) => {
+			const text = event.args.map((a) => a.value || a.description || "").join(" ");
+			if (event.type === "log" && event.args[0]?.value) try {
+				const data = JSON.parse(event.args[0].value);
+				this.handleMessage(data, options);
+			} catch {
+				if (text.length < 500 && !text.includes("Float32Array") && !text.includes("past_key_values")) {}
+			}
+			else if (event.type === "error" || event.type === "warning") {
+				if (!(text.includes("onnxruntime") || text.includes("content-length") || text.includes("Float32Array") || text.includes("past_key_values")) && text.length < 1e3) console.error(`[Chrome ${event.type}]`, text);
+			}
+		});
+		this.cdp.on("Runtime.exceptionThrown", (event) => {
+			const errText = event.exceptionDetails?.text || event.exceptionDetails?.exception?.description || "";
+			if (errText.includes("Float32Array") || errText.includes("past_key_values") || errText.length > 1e3) return;
+			console.error("[Chrome Exception]", errText);
+		});
+		await this.page.goto(`http://127.0.0.1:${this.serverPort}/`, {
+			waitUntil: "domcontentloaded",
+			timeout: 3e4
+		});
+		await this.waitForMessage("ready", 3e5);
+		this.isReady = true;
+		options.onProgress?.({ status: "Ready (WebGPU)!" });
+		trackCachedModel(this.modelId);
+	}
+	/**
+	* Handle incoming messages from the page
+	*/
+	handleMessage(data, options) {
+		const { type, ...rest } = data;
+		const handler = this.messageHandlers.get(type);
+		if (handler) handler(rest);
+		if (type === "progress") options.onProgress?.(rest);
+		else if (type === "token") options.onToken?.(rest);
+	}
+	/**
+	* Wait for a specific message type
+	*/
+	waitForMessage(type, timeout = 3e4) {
+		return new Promise((resolve, reject) => {
+			this.pendingRejects.push(reject);
+			const cleanup = () => {
+				clearTimeout(timer);
+				this.messageHandlers.delete(type);
+				const idx = this.pendingRejects.indexOf(reject);
+				if (idx >= 0) this.pendingRejects.splice(idx, 1);
+			};
+			const timer = setTimeout(() => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error(`Timeout waiting for ${type} message`));
+			}, timeout);
+			this.messageHandlers.set(type, (data) => {
+				cleanup();
+				resolve(data);
+			});
+		});
+	}
+	/**
+	* Check if Chrome backend is still alive
+	*/
+	isAlive() {
+		return this.isReady && this.browser !== null && this.page !== null;
+	}
+	/**
+	* Get Chrome backend status information
+	*/
+	getStatus() {
+		let pid = null;
+		const browserProcess = this.browser?.process?.() || globalBrowser?.process?.();
+		if (browserProcess?.pid) pid = browserProcess.pid;
+		return {
+			pid,
+			port: this.serverPort || globalServerPort,
+			modelId: this.modelId,
+			startedAt: this.isReady ? /* @__PURE__ */ new Date() : null
+		};
+	}
+	/**
+	* Get Chrome memory usage via CDP Performance metrics
+	* Returns memory in bytes or null if unavailable
+	*/
+	async getMemoryUsage() {
+		if (!(this.cdp && this.isReady)) return null;
+		try {
+			await this.cdp.send("Performance.enable");
+			const { metrics } = await this.cdp.send("Performance.getMetrics");
+			return {
+				jsHeapUsed: metrics.find((m) => m.name === "JSHeapUsedSize")?.value ?? 0,
+				jsHeapTotal: metrics.find((m) => m.name === "JSHeapTotalSize")?.value ?? 0
+			};
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Check memory usage and auto-cleanup if threshold exceeded
+	* @param thresholdGB Memory threshold in GB (default: 8)
+	* @returns true if cleanup was performed
+	*/
+	async checkMemoryAndCleanup(thresholdGB = 8) {
+		const mem = await this.getMemoryUsage();
+		if (!mem) return false;
+		const usedGB = mem.jsHeapUsed / 1024 ** 3;
+		if (usedGB > thresholdGB) {
+			console.warn(`[Gerbil] Memory usage high (${usedGB.toFixed(1)}GB > ${thresholdGB}GB), clearing KV cache...`);
+			await this.reset();
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Get memory usage in a human-readable format
+	*/
+	async getMemoryStats() {
+		const mem = await this.getMemoryUsage();
+		if (!mem) return null;
+		return {
+			usedGB: mem.jsHeapUsed / 1024 ** 3,
+			totalGB: mem.jsHeapTotal / 1024 ** 3,
+			usedPercent: mem.jsHeapUsed / mem.jsHeapTotal * 100
+		};
+	}
+	/**
+	* Generate text with streaming
+	*/
+	async generate(prompt, options = {}) {
+		if (!this.isAlive()) throw new Error("CHROME_BACKEND_DEAD");
+		const messages = [{
+			role: "system",
+			content: options.system || "You are a helpful assistant."
+		}, {
+			role: "user",
+			content: prompt
+		}];
+		const genOptions = {
+			maxTokens: options.maxTokens ?? 256,
+			temperature: options.temperature ?? .7,
+			topP: options.topP ?? .9,
+			topK: options.topK ?? 20,
+			thinking: options.thinking ?? false
+		};
+		if (options.onToken) this.messageHandlers.set("token", options.onToken);
+		try {
+			const resultPromise = this.page.evaluate((msgs, opts) => window.gerbilGenerate(msgs, opts), messages, genOptions);
+			const completeData = await this.waitForMessage("complete", 6e5);
+			this.messageHandlers.delete("token");
+			await resultPromise;
+			return completeData.text || "";
+		} catch (err) {
+			if (!this.isAlive()) throw new Error("CHROME_BACKEND_DEAD");
+			throw err;
+		}
+	}
+	/**
+	* Interrupt current generation
+	*/
+	async interrupt() {
+		if (this.page) await this.page.evaluate("window.gerbilInterrupt()");
+	}
+	/**
+	* Reset conversation cache
+	*/
+	async reset() {
+		if (this.page) await this.page.evaluate("window.gerbilReset()");
+	}
+	/**
+	* Check if backend is ready
+	*/
+	ready() {
+		return this.isReady;
+	}
+	/**
+	* Start or reuse the global HTTP server
+	* Uses singleton pattern to prevent killing our own server
+	*/
+	async startServer(html) {
+		if (globalServer && globalServerPort) {
+			this.server = globalServer;
+			this.serverPort = globalServerPort;
+			return;
+		}
+		return new Promise((resolve, reject) => {
+			const server = createServer((_req, res) => {
+				res.writeHead(200, { "Content-Type": "text/html" });
+				res.end(html);
+			});
+			server.on("error", (err) => {
+				if (err.code === "EADDRINUSE") {
+					this.serverPort = GERBIL_LOCAL_PORT;
+					globalServerPort = GERBIL_LOCAL_PORT;
+					resolve();
+				} else reject(err);
+			});
+			server.listen(GERBIL_LOCAL_PORT, "127.0.0.1", () => {
+				this.server = server;
+				this.serverPort = GERBIL_LOCAL_PORT;
+				globalServer = server;
+				globalServerPort = GERBIL_LOCAL_PORT;
+				resolve();
+			});
+		});
+	}
+	/**
+	* Dispose of the backend and clean up
+	* Note: We keep the shared browser running for other backends
+	*/
+	async dispose() {
+		this.isReady = false;
+		this.pendingRejects = [];
+		this.messageHandlers.clear();
+		if (this.page) {
+			try {
+				await this.page.close();
+				activePagesCount = Math.max(0, activePagesCount - 1);
+			} catch {}
+			this.page = null;
+		}
+		this.cdp = null;
+		this.browser = null;
+		this.server = null;
+	}
+	/**
+	* Reject all pending waits (called on browser disconnect or dispose)
+	*/
+	rejectPendingWaits(error) {
+		for (const reject of this.pendingRejects) reject(error);
+		this.pendingRejects = [];
+		this.messageHandlers.clear();
+	}
+	/**
+	* Clear the model cache (forces re-download on next start)
+	*/
+	static clearCache() {
+		if (existsSync(GERBIL_CACHE_DIR)) rmSync(GERBIL_CACHE_DIR, {
+			recursive: true,
+			force: true
+		});
+	}
+	/**
+	* Get the number of active Chrome pages
+	*/
+	static getActivePageCount() {
+		return activePagesCount;
+	}
+	/**
+	* Get memory usage info for all active pages
+	*/
+	static getMemoryInfo() {
+		return {
+			activePagesCount,
+			maxPages: MAX_CONCURRENT_PAGES
+		};
+	}
+	/**
+	* Gracefully close the shared browser (call on process exit)
+	*/
+	static async closeSharedBrowser() {
+		if (globalBrowser) {
+			try {
+				await globalBrowser.close();
+			} catch {}
+			globalBrowser = null;
+			globalBrowserPromise = null;
+		}
+		if (globalServer) {
+			globalServer.close();
+			globalServer = null;
+			globalServerPort = 0;
+		}
+		activePagesCount = 0;
+		try {
+			unlinkSync(WS_ENDPOINT_FILE);
+		} catch {}
+	}
+};
+let cleanupRegistered = false;
+function registerCleanup() {
+	if (cleanupRegistered) return;
+	cleanupRegistered = true;
+	const cleanup = () => {
+		if (globalBrowser) {
+			try {
+				const browserProcess = globalBrowser.process();
+				if (browserProcess) browserProcess.kill("SIGTERM");
+			} catch {}
+			globalBrowser = null;
+		}
+		if (globalServer) {
+			globalServer.close();
+			globalServer = null;
+		}
+	};
+	process.on("exit", cleanup);
+	process.on("SIGINT", () => {
+		cleanup();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		cleanup();
+		process.exit(0);
+	});
+}
+registerCleanup();
+
+//#endregion
+export { trackCachedModel as i, getChromeCachedModels as n, refreshCachedModelSizes as r, ChromeGPUBackend as t };
+//# sourceMappingURL=chrome-backend-C5Un08O4.mjs.map