@tryhamster/gerbil 1.0.0-rc.9 → 1.0.1

package/dist/chrome-backend-CORwaIyC.mjs

@@ -1,1212 +0,0 @@
-import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import { createServer } from "node:http";
-import { homedir } from "node:os";
-import { join } from "node: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 context length from HuggingFace (config.json preferred for actual limit) */
-async function fetchContextLength(modelId) {
-	try {
-		const res = await fetch(`https://huggingface.co/${modelId}/raw/main/config.json`);
-		if (res.ok) {
-			const config = await res.json();
-			const textConfig = config.text_config || {};
-			const ctxLen = config.max_position_embeddings || textConfig.max_position_embeddings || config.sliding_window || textConfig.sliding_window || config.max_seq_len || config.max_sequence_length || config.n_ctx || config.n_positions;
-			if (ctxLen) return ctxLen;
-		}
-	} catch {}
-	try {
-		const tokRes = await fetch(`https://huggingface.co/${modelId}/raw/main/tokenizer_config.json`);
-		if (tokRes.ok) {
-			const tokConfig = await tokRes.json();
-			if (tokConfig.model_max_length && tokConfig.model_max_length < 1e6) return tokConfig.model_max_length;
-		}
-	} catch {}
-}
-/** Get file size from HuggingFace tree entry (handles both regular and LFS files) */
-function getFileSize(file) {
-	return file.lfs?.size || file.size || 0;
-}
-/** 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) {
-				const baseName = bestFile.path.replace(".onnx", "");
-				const totalSize = files.filter((f) => f.path === bestFile.path || f.path.startsWith(`${baseName}.onnx_data`)).reduce((sum, f) => sum + getFileSize(f), 0);
-				if (totalSize > 0) return totalSize;
-			}
-		}
-		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, contextLength) {
-	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;
-			if (contextLength) existing.contextLength = contextLength;
-		} else models.push({
-			modelId,
-			downloadedAt: now,
-			lastUsed: now,
-			sizeBytes,
-			contextLength
-		});
-		writeFileSync(CACHED_MODELS_FILE, JSON.stringify({ models }, null, 2));
-		const needsSize = !(sizeBytes || existing?.sizeBytes);
-		const needsContext = !(contextLength || existing?.contextLength);
-		if (needsSize || needsContext) Promise.all([needsSize ? fetchModelSize(modelId) : Promise.resolve(void 0), needsContext ? fetchContextLength(modelId) : Promise.resolve(void 0)]).then(([size, context]) => {
-			const updatedModels = getChromeCachedModels();
-			const model = updatedModels.find((m) => m.modelId === modelId);
-			if (model) {
-				if (size) model.sizeBytes = size;
-				if (context) model.contextLength = context;
-				writeFileSync(CACHED_MODELS_FILE, JSON.stringify({ models: updatedModels }, null, 2));
-			}
-		}).catch(() => {});
-	} catch {}
-}
-/** Refresh metadata (size, context length) for cached models that need it */
-async function refreshCachedModelSizes() {
-	try {
-		const models = getChromeCachedModels();
-		const MIN_EXPECTED_SIZE = 1e6;
-		const needsRefresh = models.filter((m) => !m.sizeBytes || m.sizeBytes < MIN_EXPECTED_SIZE || !m.contextLength);
-		if (needsRefresh.length === 0) return;
-		const batchSize = 3;
-		for (let i = 0; i < needsRefresh.length; i += batchSize) {
-			const batch = needsRefresh.slice(i, i + batchSize);
-			await Promise.all(batch.map(async (model) => {
-				const [size, context] = await Promise.all([!model.sizeBytes || model.sizeBytes < MIN_EXPECTED_SIZE ? fetchModelSize(model.modelId) : Promise.resolve(void 0), model.contextLength ? Promise.resolve(void 0) : fetchContextLength(model.modelId)]);
-				if (size) model.sizeBytes = size;
-				if (context) model.contextLength = context;
-			}));
-		}
-		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 globalServerHtml = "";
-let activePagesCount = 0;
-const MAX_CONCURRENT_PAGES = 5;
-const activeBackends = /* @__PURE__ */ new Set();
-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, contextLength = 32768, isVision = false) {
-	return `
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Gerbil WebGPU Backend</title>
-  <script type="module">
-    import {
-      AutoTokenizer,
-      AutoModelForCausalLM,
-      AutoProcessor,
-      AutoModelForImageTextToText,
-      RawImage,
-      TextStreamer,
-      InterruptableStoppingCriteria,
-      env,
-    } from "https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.8.1";
-
-    // Enable IndexedDB caching (prevents re-downloading models)
-    env.useBrowserCache = true;
-    env.allowLocalModels = false;
-
-    const IS_VISION = ${isVision};
-    
-    class ModelPipeline {
-      static tokenizer = null;
-      static processor = null;
-      static model = null;
-      static modelId = "${modelPath}";
-      static isVision = IS_VISION;
-
-      static async getInstance(progressCallback) {
-        if (this.isVision) {
-          // Vision model: use AutoProcessor + AutoModelForImageTextToText
-          if (!this.processor) {
-            this.processor = await AutoProcessor.from_pretrained(this.modelId, {
-              progress_callback: progressCallback,
-            });
-          }
-          if (!this.model) {
-            this.model = await AutoModelForImageTextToText.from_pretrained(this.modelId, {
-              device: "webgpu",
-              progress_callback: progressCallback,
-            });
-          }
-          return { 
-            processor: this.processor, 
-            tokenizer: this.processor.tokenizer, 
-            model: this.model,
-            isVision: true 
-          };
-        } else {
-          // Text model: use AutoTokenizer + AutoModelForCausalLM
-          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,
-            isVision: false 
-          };
-        }
-      }
-    }
-
-    const stoppingCriteria = new InterruptableStoppingCriteria();
-    let pastKeyValuesCache = null;
-    let totalTokensInCache = 0;
-    
-    // Context length for auto-reset (passed from model config)
-    const CONTEXT_LENGTH = ${contextLength};
-
-    // Auto-load model on page init
-    (async function() {
-      console.log(JSON.stringify({ type: "progress", status: IS_VISION ? "Loading vision model..." : "Loading model..." }));
-      
-      try {
-        const result = 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..." }));
-        
-        // Warmup generation to compile shaders and initialize model
-        // Always do text warmup first
-        const textWarmupInputs = result.tokenizer("hello");
-        await result.model.generate({ ...textWarmupInputs, max_new_tokens: 1 });
-        
-        // Vision models also need vision warmup
-        if (result.isVision) {
-          console.log(JSON.stringify({ type: "progress", status: "Warming up vision encoder..." }));
-          try {
-            // Create a tiny 8x8 red test image
-            const canvas = new OffscreenCanvas(8, 8);
-            const ctx = canvas.getContext('2d');
-            ctx.fillStyle = 'red';
-            ctx.fillRect(0, 0, 8, 8);
-            const blob = await canvas.convertToBlob({ type: 'image/png' });
-            const warmupImage = await RawImage.fromBlob(blob);
-            
-            // Process with vision pipeline
-            const warmupContent = [{ type: "image" }, { type: "text", text: "hi" }];
-            const warmupMessages = [{ role: "user", content: warmupContent }];
-            const warmupPrompt = result.processor.apply_chat_template(warmupMessages);
-            const warmupInputs = await result.processor(warmupImage, warmupPrompt, { add_special_tokens: false });
-            
-            // Run vision warmup generation
-            await result.model.generate({
-              ...warmupInputs,
-              max_new_tokens: 1,
-              do_sample: false,
-            });
-          } catch {
-            // Vision warmup failed, text warmup was done so continue
-          }
-        }
-        
-        // Set page title to model ID for cross-process identification
-        document.title = "Gerbil: " + ModelPipeline.modelId;
-        
-        console.log(JSON.stringify({ type: "ready", isVision: result.isVision }));
-      } catch (error) {
-        console.log(JSON.stringify({ type: "error", error: error.message || String(error) }));
-      }
-    })();
-
-    // Text generation (for non-vision models or vision without images)
-    window.gerbilGenerate = async function(messages, options = {}) {
-      const { maxTokens = 256, temperature = 0.7, topP = 0.9, topK = 20, thinking = false, images = [] } = options;
-      
-      const result = await ModelPipeline.getInstance();
-      
-      // Route to vision generation if we have images and this is a vision model
-      if (images.length > 0 && result.isVision) {
-        return window.gerbilGenerateVision(messages, images, options);
-      }
-      
-      // Auto-reset KV cache if it exceeds context length
-      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 } = result;
-
-        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 += 1;
-          
-          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;
-          
-          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;
-        
-        const inputLength = inputs.input_ids.dims[1];
-        totalTokensInCache += inputLength + numTokens;
-
-        const endTime = performance.now();
-        const totalTime = startTime ? endTime - startTime : 0;
-        
-        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;
-      }
-    };
-
-    // Vision generation (for vision models with images)
-    window.gerbilGenerateVision = async function(messages, imageUrls, options = {}) {
-      const { maxTokens = 2048, temperature = 0.7, topP = 0.9, topK = 20 } = options;
-
-      try {
-        const { processor, tokenizer, model } = await ModelPipeline.getInstance();
-
-        // Build message content with image placeholders for the user prompt
-        const lastMessage = messages[messages.length - 1];
-        const content = [];
-        for (let i = 0; i < imageUrls.length; i += 1) {
-          content.push({ type: "image" });
-        }
-        content.push({ type: "text", text: lastMessage.content });
-
-        // For vision models, include a brief system instruction for concise responses
-        const visionMessages = [
-          { role: "system", content: "You are a helpful assistant. Be concise and direct in your responses." },
-          { role: "user", content }
-        ];
-
-        // Apply chat template with generation prompt
-        const chatPrompt = processor.apply_chat_template(visionMessages, { 
-          add_generation_prompt: true 
-        });
-
-        // Load images
-        console.log(JSON.stringify({ type: "progress", status: "Loading images..." }));
-        const loadedImages = await Promise.all(
-          imageUrls.map(url => RawImage.fromURL(url))
-        );
-
-        // Process inputs
-        const inputs = await processor(
-          loadedImages.length === 1 ? loadedImages[0] : loadedImages,
-          chatPrompt,
-          { add_special_tokens: false }
-        );
-
-        let startTime = null;
-        let numTokens = 0;
-
-        const streamCallback = (text) => {
-          startTime ??= performance.now();
-          numTokens += 1;
-          const tps = (numTokens / (performance.now() - startTime)) * 1000;
-          console.log(JSON.stringify({ type: "token", text, state: "answering", numTokens, tps }));
-        };
-
-        const streamer = new TextStreamer(tokenizer, {
-          skip_prompt: true,
-          skip_special_tokens: true,
-          callback_function: streamCallback,
-        });
-
-        console.log(JSON.stringify({ type: "start" }));
-
-        const outputs = await model.generate({
-          ...inputs,
-          max_new_tokens: maxTokens,
-          do_sample: temperature > 0,
-          temperature: temperature > 0 ? temperature : undefined,
-          top_p: topP,
-          top_k: topK,
-          streamer,
-          stopping_criteria: stoppingCriteria,
-        });
-
-        // Decode output (skip prompt)
-        const inputLength = inputs.input_ids.dims?.at(-1) || 0;
-        const decoded = processor.batch_decode(
-          outputs.slice(null, [inputLength, null]),
-          { skip_special_tokens: true }
-        );
-
-        const endTime = performance.now();
-        const totalTime = startTime ? endTime - startTime : 0;
-
-        console.log(JSON.stringify({
-          type: "complete",
-          text: decoded[0] || "",
-          numTokens,
-          totalTime,
-          tps: totalTime > 0 ? (numTokens / totalTime) * 1000 : 0,
-        }));
-
-        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;
-	server = null;
-	serverPort = 0;
-	userDataDir = GERBIL_CACHE_DIR;
-	modelId;
-	isReady = false;
-	isVisionModel = false;
-	messageHandlers = /* @__PURE__ */ new Map();
-	pendingRejects = [];
-	constructor(modelId, isVision = false) {
-		this.modelId = modelId;
-		this.isVisionModel = isVision;
-	}
-	/**
-	* Create and initialize a Chrome GPU backend
-	*/
-	static async create(options = {}) {
-		const modelId = options.modelId || "onnx-community/Qwen3-0.6B-ONNX";
-		const backend = new ChromeGPUBackend(modelId, options.isVision ?? ChromeGPUBackend.detectVisionModel(modelId));
-		await backend.launch(options);
-		return backend;
-	}
-	/**
-	* Detect if a model is a vision model based on its ID
-	*/
-	static detectVisionModel(modelId) {
-		return [
-			/ministral/i,
-			/pixtral/i,
-			/llava/i,
-			/vision/i,
-			/vl/i,
-			/image-text/i,
-			/multimodal/i
-		].some((pattern) => pattern.test(modelId));
-	}
-	/**
-	* Check if this backend is for a vision model
-	*/
-	isVision() {
-		return this.isVisionModel;
-	}
-	/**
-	* Clean up orphan Gerbil pages from previous sessions
-	* These are pages that were left behind when process exited without proper cleanup
-	*/
-	async cleanupOrphanPages(browser, options) {
-		try {
-			const gerbilPages = (await browser.pages()).filter((p) => {
-				const url = p.url();
-				return /127\.0\.0\.1:4\d{4}/.test(url);
-			});
-			const orphanCount = gerbilPages.length - activeBackends.size;
-			if (orphanCount > 0) {
-				options.onProgress?.({ status: `Cleaning up ${orphanCount} orphan page(s)...` });
-				for (const page of gerbilPages) {
-					let isOwned = false;
-					for (const backend of activeBackends) if (backend.page === page) {
-						isOwned = true;
-						break;
-					}
-					if (!isOwned) try {
-						await page.close();
-					} catch {}
-				}
-			}
-			return orphanCount;
-		} catch {
-			return 0;
-		}
-	}
-	/**
-	* 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..." });
-			await this.cleanupOrphanPages(globalBrowser, options);
-			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 });
-			await this.cleanupOrphanPages(globalBrowser, options);
-			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 contextLength = options.contextLength || 32768;
-		const html = getWorkerPageHTML(this.modelId, contextLength, this.isVisionModel);
-		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 += 1;
-		activeBackends.add(this);
-		options.onProgress?.({ status: `Active pages: ${activePagesCount}/${MAX_CONCURRENT_PAGES}` });
-		this.browser.on("disconnected", () => {
-			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) {}
-			}
-		});
-		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;
-		});
-		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;
-		if (mem.jsHeapUsed / 1024 ** 3 > thresholdGB) {
-			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 ?? (this.isVisionModel ? 2048 : 256),
-			temperature: options.temperature ?? .7,
-			topP: options.topP ?? .9,
-			topK: options.topK ?? 20,
-			thinking: options.thinking ?? false,
-			images: options.images ?? []
-		};
-		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
-	* Updates HTML content for new model loads
-	*/
-	async startServer(html) {
-		globalServerHtml = 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(globalServerHtml);
-			});
-			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
-	* @param disconnect If true, also disconnect from shared browser (for clean script exit)
-	*/
-	async dispose(disconnect = false) {
-		this.isReady = false;
-		this.pendingRejects = [];
-		this.messageHandlers.clear();
-		if (this.cdp) {
-			try {
-				await this.cdp.detach();
-			} catch {}
-			this.cdp = null;
-		}
-		if (this.page) {
-			try {
-				await this.page.goto("about:blank").catch(() => {});
-				await new Promise((r) => setTimeout(r, 50));
-				await this.page.close({ runBeforeUnload: false });
-				activePagesCount = Math.max(0, activePagesCount - 1);
-			} catch {}
-			this.page = null;
-		}
-		activeBackends.delete(this);
-		this.browser = null;
-		this.server = null;
-		if (disconnect) await new Promise((r) => setTimeout(r, 100));
-		if (disconnect && activeBackends.size === 0 && globalBrowser) try {
-			globalBrowser.disconnect();
-			globalBrowser = null;
-			globalBrowserPromise = null;
-		} catch {}
-	}
-	/**
-	* 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
-		};
-	}
-	/**
-	* Get global browser status (even if no active backends)
-	*/
-	static getGlobalBrowserStatus() {
-		let pid = null;
-		let wsEndpoint = null;
-		if (globalBrowser?.connected) {
-			const browserProcess = globalBrowser.process?.();
-			if (browserProcess?.pid) pid = browserProcess.pid;
-			wsEndpoint = globalBrowser.wsEndpoint();
-		}
-		return {
-			running: globalBrowser?.connected ?? false,
-			pid,
-			port: globalServerPort,
-			activePagesCount,
-			maxPages: MAX_CONCURRENT_PAGES,
-			wsEndpoint
-		};
-	}
-	/**
-	* Get total page count from Chrome (all processes)
-	*/
-	static async getTotalPageCount() {
-		if (!globalBrowser?.connected) return 0;
-		try {
-			return (await globalBrowser.pages()).filter((p) => {
-				return p.url().includes(`127.0.0.1:${globalServerPort}`);
-			}).length;
-		} catch {
-			return 0;
-		}
-	}
-	/**
-	* Get all active backends with their memory usage (this process only)
-	*/
-	static async getAllBackendsInfo() {
-		const results = [];
-		for (const backend of activeBackends) {
-			const mem = await backend.getMemoryStats();
-			results.push({
-				modelId: backend.modelId,
-				isVision: backend.isVisionModel,
-				isReady: backend.isReady,
-				memory: mem
-			});
-		}
-		return results;
-	}
-	/**
-	* Get ALL pages in Chrome browser (cross-process visibility)
-	* This shows pages from ALL Gerbil processes sharing the browser
-	*/
-	static async getAllChromePages() {
-		if (!globalBrowser?.connected) return [];
-		try {
-			const pages = await globalBrowser.pages();
-			const results = [];
-			for (const page of pages) {
-				const url = page.url();
-				const title = await page.title().catch(() => "");
-				if (url === "about:blank" || !url.includes(`127.0.0.1:${globalServerPort}`)) continue;
-				let modelId = null;
-				let isOurs = false;
-				let memory = null;
-				for (const backend of activeBackends) if (backend.page === page) {
-					isOurs = true;
-					modelId = backend.modelId;
-					const mem = await backend.getMemoryStats();
-					if (mem) memory = {
-						usedGB: mem.usedGB,
-						totalGB: mem.totalGB
-					};
-					break;
-				}
-				if (!isOurs) {
-					if (title.startsWith("Gerbil: ")) modelId = title.replace("Gerbil: ", "");
-					try {
-						const cdp = await page.createCDPSession();
-						await cdp.send("Performance.enable");
-						const { metrics } = await cdp.send("Performance.getMetrics");
-						const jsHeapUsed = metrics.find((m) => m.name === "JSHeapUsedSize")?.value ?? 0;
-						const jsHeapTotal = metrics.find((m) => m.name === "JSHeapTotalSize")?.value ?? 0;
-						memory = {
-							usedGB: jsHeapUsed / 1024 ** 3,
-							totalGB: jsHeapTotal / 1024 ** 3
-						};
-						await cdp.detach();
-					} catch {}
-				}
-				results.push({
-					url,
-					title: title || "Gerbil WebGPU Backend",
-					isOurs,
-					modelId,
-					memory
-				});
-			}
-			return results;
-		} catch {
-			return [];
-		}
-	}
-	/**
-	* Kill a Chrome page by index (works cross-process)
-	*/
-	static async killPageByIndex(index) {
-		if (!globalBrowser?.connected) return false;
-		try {
-			const gerbilPages = (await globalBrowser.pages()).filter((p) => {
-				return p.url().includes(`127.0.0.1:${globalServerPort}`);
-			});
-			if (index < 0 || index >= gerbilPages.length) return false;
-			const page = gerbilPages[index];
-			for (const backend of activeBackends) if (backend.page === page) {
-				await backend.dispose();
-				return true;
-			}
-			await page.close();
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Kill a specific backend by index (this process only)
-	*/
-	static async killBackendByIndex(index) {
-		const backends = [...activeBackends];
-		if (index < 0 || index >= backends.length) return false;
-		const backend = backends[index];
-		try {
-			await backend.dispose();
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Force kill all backends (for zombie cleanup)
-	*/
-	static async killAllBackends() {
-		const count = activeBackends.size;
-		for (const backend of [...activeBackends]) try {
-			await backend.dispose();
-		} catch {}
-		activeBackends.clear();
-		let browserKilled = false;
-		if (globalBrowser) {
-			try {
-				await globalBrowser.close();
-				browserKilled = true;
-			} catch {}
-			globalBrowser = null;
-			globalBrowserPromise = null;
-		}
-		if (globalServer) {
-			globalServer.close();
-			globalServer = null;
-			globalServerPort = 0;
-		}
-		activePagesCount = 0;
-		try {
-			unlinkSync(WS_ENDPOINT_FILE);
-		} catch {}
-		return {
-			pagesKilled: count,
-			browserKilled
-		};
-	}
-	/**
-	* 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-CORwaIyC.mjs.map