@hasna/browser 0.0.9 → 0.1.0

package/dist/index.js

@@ -28,6 +28,79 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/types/index.ts
+var UseCase, BrowserError, SessionNotFoundError, EngineNotAvailableError, NavigationError, ElementNotFoundError, RecordingNotFoundError, AgentNotFoundError, ProjectNotFoundError;
+var init_types = __esm(() => {
+  ((UseCase2) => {
+    UseCase2["SCRAPE"] = "scrape";
+    UseCase2["EXTRACT_LINKS"] = "extract_links";
+    UseCase2["STATUS_CHECK"] = "status_check";
+    UseCase2["FORM_FILL"] = "form_fill";
+    UseCase2["SPA_NAVIGATE"] = "spa_navigate";
+    UseCase2["SCREENSHOT"] = "screenshot";
+    UseCase2["AUTH_FLOW"] = "auth_flow";
+    UseCase2["MULTI_TAB"] = "multi_tab";
+    UseCase2["NETWORK_MONITOR"] = "network_monitor";
+    UseCase2["HAR_CAPTURE"] = "har_capture";
+    UseCase2["PERF_PROFILE"] = "perf_profile";
+    UseCase2["SCRIPT_INJECT"] = "script_inject";
+    UseCase2["COVERAGE"] = "coverage";
+    UseCase2["RECORD_REPLAY"] = "record_replay";
+  })(UseCase ||= {});
+  BrowserError = class BrowserError extends Error {
+    code;
+    retryable;
+    constructor(message, code = "BROWSER_ERROR", retryable = false) {
+      super(message);
+      this.code = code;
+      this.retryable = retryable;
+      this.name = "BrowserError";
+    }
+  };
+  SessionNotFoundError = class SessionNotFoundError extends BrowserError {
+    constructor(id) {
+      super(`Session not found: ${id}`, "SESSION_NOT_FOUND", false);
+      this.name = "SessionNotFoundError";
+    }
+  };
+  EngineNotAvailableError = class EngineNotAvailableError extends BrowserError {
+    constructor(engine, reason) {
+      super(`Engine '${engine}' is not available${reason ? `: ${reason}` : ""}`, "ENGINE_NOT_AVAILABLE", false);
+      this.name = "EngineNotAvailableError";
+    }
+  };
+  NavigationError = class NavigationError extends BrowserError {
+    constructor(url, reason) {
+      super(`Navigation to '${url}' failed${reason ? `: ${reason}` : ""}`, "NAVIGATION_ERROR", true);
+      this.name = "NavigationError";
+    }
+  };
+  ElementNotFoundError = class ElementNotFoundError extends BrowserError {
+    constructor(selector) {
+      super(`Element not found: ${selector}`, "ELEMENT_NOT_FOUND", false);
+      this.name = "ElementNotFoundError";
+    }
+  };
+  RecordingNotFoundError = class RecordingNotFoundError extends BrowserError {
+    constructor(id) {
+      super(`Recording not found: ${id}`, "RECORDING_NOT_FOUND", false);
+      this.name = "RecordingNotFoundError";
+    }
+  };
+  AgentNotFoundError = class AgentNotFoundError extends BrowserError {
+    constructor(id) {
+      super(`Agent not found: ${id}`, "AGENT_NOT_FOUND", false);
+      this.name = "AgentNotFoundError";
+    }
+  };
+  ProjectNotFoundError = class ProjectNotFoundError extends BrowserError {
+    constructor(id) {
+      super(`Project not found: ${id}`, "PROJECT_NOT_FOUND", false);
+      this.name = "ProjectNotFoundError";
+    }
+  };
+});
+
 // src/db/schema.ts
 import { Database } from "bun:sqlite";
 import { join } from "path";
@@ -243,6 +316,23 @@ function runMigrations(db) {
         );
         CREATE INDEX IF NOT EXISTS idx_session_tags_tag ON session_tags(tag);
       `
+    },
+    {
+      version: 6,
+      sql: `
+        CREATE TABLE IF NOT EXISTS auth_flows (
+          id                 TEXT PRIMARY KEY,
+          name               TEXT NOT NULL UNIQUE,
+          domain             TEXT NOT NULL,
+          recording_id       TEXT REFERENCES recordings(id),
+          storage_state_path TEXT,
+          created_at         TEXT DEFAULT (datetime('now')),
+          last_used          TEXT
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_auth_flows_domain ON auth_flows(domain);
+        CREATE INDEX IF NOT EXISTS idx_auth_flows_name ON auth_flows(name);
+      `
     }
   ];
   for (const m of migrations) {
@@ -291,6 +381,188 @@ var init_console_log = __esm(() => {
   init_schema();
 });
 
+// src/engines/cdp.ts
+var exports_cdp = {};
+__export(exports_cdp, {
+  connectToExistingBrowser: () => connectToExistingBrowser,
+  CDPClient: () => CDPClient
+});
+async function connectToExistingBrowser(cdpUrl) {
+  const { chromium: chromium2 } = await import("playwright");
+  try {
+    return await chromium2.connectOverCDP(cdpUrl);
+  } catch (err) {
+    throw new BrowserError(`Failed to connect to browser at ${cdpUrl}: ${err instanceof Error ? err.message : String(err)}. Start Chrome with: google-chrome --remote-debugging-port=9222`, "CDP_CONNECT_FAILED", true);
+  }
+}
+
+class CDPClient {
+  session;
+  networkEnabled = false;
+  performanceEnabled = false;
+  constructor(session) {
+    this.session = session;
+  }
+  static async fromPage(page) {
+    try {
+      const session = await page.context().newCDPSession(page);
+      return new CDPClient(session);
+    } catch (err) {
+      throw new BrowserError(`Failed to create CDP session: ${err instanceof Error ? err.message : String(err)}`, "CDP_SESSION_FAILED");
+    }
+  }
+  async send(method, params) {
+    try {
+      return await this.session.send(method, params);
+    } catch (err) {
+      throw new BrowserError(`CDP command '${method}' failed: ${err instanceof Error ? err.message : String(err)}`, "CDP_COMMAND_FAILED");
+    }
+  }
+  on(event, handler) {
+    this.session.on(event, handler);
+  }
+  off(event, handler) {
+    this.session.off(event, handler);
+  }
+  async enableNetwork() {
+    if (!this.networkEnabled) {
+      await this.send("Network.enable");
+      this.networkEnabled = true;
+    }
+  }
+  async enablePerformance() {
+    if (!this.performanceEnabled) {
+      await this.send("Performance.enable");
+      this.performanceEnabled = true;
+    }
+  }
+  async getPerformanceMetrics() {
+    await this.enablePerformance();
+    const result = await this.send("Performance.getMetrics");
+    const m = {};
+    for (const metric of result.metrics) {
+      m[metric.name] = metric.value;
+    }
+    return {
+      js_heap_size_used: m["JSHeapUsedSize"],
+      js_heap_size_total: m["JSHeapTotalSize"],
+      dom_interactive: m["DOMInteractive"],
+      dom_complete: m["DOMComplete"],
+      load_event: m["LoadEventEnd"]
+    };
+  }
+  async startJSCoverage() {
+    await this.send("Profiler.enable");
+    await this.send("Debugger.enable");
+    await this.send("Profiler.startPreciseCoverage", {
+      callCount: false,
+      detailed: true
+    });
+  }
+  async stopJSCoverage() {
+    const result = await this.send("Profiler.takePreciseCoverage");
+    await this.send("Profiler.stopPreciseCoverage");
+    return result.result.filter((r) => r.url && !r.url.startsWith("v8-snapshot://")).map((r) => ({
+      url: r.url,
+      text: "",
+      ranges: r.functions.flatMap((f) => f.ranges.filter((rng) => rng.count > 0).map((rng) => ({ start: rng.startOffset, end: rng.endOffset })))
+    }));
+  }
+  async getCoverage() {
+    await this.startJSCoverage();
+    const js = await this.stopJSCoverage();
+    const totalBytes = js.reduce((acc, e) => acc + e.ranges.reduce((sum, r) => sum + (r.end - r.start), 0), 0);
+    return { js, css: [], totalBytes, usedBytes: totalBytes, unusedPercent: 0 };
+  }
+  async captureHAREntries(page, handler) {
+    await this.enableNetwork();
+    const requestTimings = new Map;
+    const onRequest = (params) => {
+      requestTimings.set(params.requestId, params.timestamp);
+    };
+    const onResponse = (params) => {
+      const start = requestTimings.get(params.requestId);
+      const duration = start != null ? (params.timestamp - start) * 1000 : 0;
+      handler({
+        method: "GET",
+        url: params.response.url,
+        status: params.response.status,
+        duration
+      });
+    };
+    this.on("Network.requestWillBeSent", onRequest);
+    this.on("Network.responseReceived", onResponse);
+    return () => {
+      this.off("Network.requestWillBeSent", onRequest);
+      this.off("Network.responseReceived", onResponse);
+    };
+  }
+  async detach() {
+    try {
+      await this.session.detach();
+    } catch {}
+  }
+}
+var init_cdp = __esm(() => {
+  init_types();
+});
+
+// src/lib/storage-state.ts
+var exports_storage_state = {};
+__export(exports_storage_state, {
+  saveStateFromPage: () => saveStateFromPage,
+  saveState: () => saveState,
+  loadStatePath: () => loadStatePath,
+  listStates: () => listStates,
+  deleteState: () => deleteState
+});
+import { mkdirSync as mkdirSync3, existsSync, readdirSync, unlinkSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+function ensureDir() {
+  mkdirSync3(STATES_DIR, { recursive: true });
+}
+function statePath(name) {
+  return join3(STATES_DIR, `${name}.json`);
+}
+async function saveState(context, name) {
+  ensureDir();
+  const path = statePath(name);
+  const state = await context.storageState({ path });
+  return path;
+}
+async function saveStateFromPage(page, name) {
+  return saveState(page.context(), name);
+}
+function loadStatePath(name) {
+  const path = statePath(name);
+  return existsSync(path) ? path : null;
+}
+function listStates() {
+  ensureDir();
+  return readdirSync(STATES_DIR).filter((f) => f.endsWith(".json")).map((f) => {
+    const path = join3(STATES_DIR, f);
+    const stat = Bun.file(path);
+    return {
+      name: f.replace(".json", ""),
+      path,
+      modified: new Date(stat.lastModified).toISOString()
+    };
+  }).sort((a, b) => b.modified.localeCompare(a.modified));
+}
+function deleteState(name) {
+  const path = statePath(name);
+  if (existsSync(path)) {
+    unlinkSync(path);
+    return true;
+  }
+  return false;
+}
+var STATES_DIR;
+var init_storage_state = __esm(() => {
+  STATES_DIR = join3(process.env["BROWSER_DATA_DIR"] ?? join3(homedir3(), ".browser"), "states");
+});
+
 // node_modules/sharp/lib/is.js
 var require_is = __commonJS((exports, module) => {
   /*!
@@ -6686,90 +6958,13 @@ var require_lib = __commonJS((exports, module) => {
   module.exports = Sharp;
 });
 
-// src/types/index.ts
-var UseCase;
-((UseCase2) => {
-  UseCase2["SCRAPE"] = "scrape";
-  UseCase2["EXTRACT_LINKS"] = "extract_links";
-  UseCase2["STATUS_CHECK"] = "status_check";
-  UseCase2["FORM_FILL"] = "form_fill";
-  UseCase2["SPA_NAVIGATE"] = "spa_navigate";
-  UseCase2["SCREENSHOT"] = "screenshot";
-  UseCase2["AUTH_FLOW"] = "auth_flow";
-  UseCase2["MULTI_TAB"] = "multi_tab";
-  UseCase2["NETWORK_MONITOR"] = "network_monitor";
-  UseCase2["HAR_CAPTURE"] = "har_capture";
-  UseCase2["PERF_PROFILE"] = "perf_profile";
-  UseCase2["SCRIPT_INJECT"] = "script_inject";
-  UseCase2["COVERAGE"] = "coverage";
-  UseCase2["RECORD_REPLAY"] = "record_replay";
-})(UseCase ||= {});
-
-class BrowserError extends Error {
-  code;
-  retryable;
-  constructor(message, code = "BROWSER_ERROR", retryable = false) {
-    super(message);
-    this.code = code;
-    this.retryable = retryable;
-    this.name = "BrowserError";
-  }
-}
-
-class SessionNotFoundError extends BrowserError {
-  constructor(id) {
-    super(`Session not found: ${id}`, "SESSION_NOT_FOUND", false);
-    this.name = "SessionNotFoundError";
-  }
-}
-
-class EngineNotAvailableError extends BrowserError {
-  constructor(engine, reason) {
-    super(`Engine '${engine}' is not available${reason ? `: ${reason}` : ""}`, "ENGINE_NOT_AVAILABLE", false);
-    this.name = "EngineNotAvailableError";
-  }
-}
-
-class NavigationError extends BrowserError {
-  constructor(url, reason) {
-    super(`Navigation to '${url}' failed${reason ? `: ${reason}` : ""}`, "NAVIGATION_ERROR", true);
-    this.name = "NavigationError";
-  }
-}
-
-class ElementNotFoundError extends BrowserError {
-  constructor(selector) {
-    super(`Element not found: ${selector}`, "ELEMENT_NOT_FOUND", false);
-    this.name = "ElementNotFoundError";
-  }
-}
-
-class RecordingNotFoundError extends BrowserError {
-  constructor(id) {
-    super(`Recording not found: ${id}`, "RECORDING_NOT_FOUND", false);
-    this.name = "RecordingNotFoundError";
-  }
-}
-
-class AgentNotFoundError extends BrowserError {
-  constructor(id) {
-    super(`Agent not found: ${id}`, "AGENT_NOT_FOUND", false);
-    this.name = "AgentNotFoundError";
-  }
-}
-
-class ProjectNotFoundError extends BrowserError {
-  constructor(id) {
-    super(`Project not found: ${id}`, "PROJECT_NOT_FOUND", false);
-    this.name = "ProjectNotFoundError";
-  }
-}
-
 // src/index.ts
 init_schema();
+init_types();
 
 // src/db/projects.ts
 init_schema();
+init_types();
 import { randomUUID } from "crypto";
 function createProject(data) {
   const db = getDatabase();
@@ -6827,6 +7022,7 @@ function deleteProject(id) {
 }
 // src/db/agents.ts
 init_schema();
+init_types();
 import { randomUUID as randomUUID2 } from "crypto";
 function registerAgent(name, opts = {}) {
   const db = getDatabase();
@@ -6907,6 +7103,7 @@ function cleanStaleAgents(thresholdMs) {
 }
 // src/db/sessions.ts
 init_schema();
+init_types();
 import { randomUUID as randomUUID3 } from "crypto";
 function createSession(data) {
   const db = getDatabase();
@@ -7039,6 +7236,7 @@ init_console_log();
 
 // src/db/recordings.ts
 init_schema();
+init_types();
 import { randomUUID as randomUUID7 } from "crypto";
 function deserialize(row) {
   return {
@@ -7153,6 +7351,7 @@ function cleanOldHeartbeats(olderThanMs) {
   return result.changes;
 }
 // src/engines/playwright.ts
+init_types();
 import { chromium } from "playwright";
 var DEFAULT_VIEWPORT = { width: 1280, height: 720 };
 async function launchPlaywright(options) {
@@ -7230,115 +7429,12 @@ class BrowserPool {
     return this.pool.filter((e) => !e.inUse).length;
   }
 }
-// src/engines/cdp.ts
-class CDPClient {
-  session;
-  networkEnabled = false;
-  performanceEnabled = false;
-  constructor(session) {
-    this.session = session;
-  }
-  static async fromPage(page) {
-    try {
-      const session = await page.context().newCDPSession(page);
-      return new CDPClient(session);
-    } catch (err) {
-      throw new BrowserError(`Failed to create CDP session: ${err instanceof Error ? err.message : String(err)}`, "CDP_SESSION_FAILED");
-    }
-  }
-  async send(method, params) {
-    try {
-      return await this.session.send(method, params);
-    } catch (err) {
-      throw new BrowserError(`CDP command '${method}' failed: ${err instanceof Error ? err.message : String(err)}`, "CDP_COMMAND_FAILED");
-    }
-  }
-  on(event, handler) {
-    this.session.on(event, handler);
-  }
-  off(event, handler) {
-    this.session.off(event, handler);
-  }
-  async enableNetwork() {
-    if (!this.networkEnabled) {
-      await this.send("Network.enable");
-      this.networkEnabled = true;
-    }
-  }
-  async enablePerformance() {
-    if (!this.performanceEnabled) {
-      await this.send("Performance.enable");
-      this.performanceEnabled = true;
-    }
-  }
-  async getPerformanceMetrics() {
-    await this.enablePerformance();
-    const result = await this.send("Performance.getMetrics");
-    const m = {};
-    for (const metric of result.metrics) {
-      m[metric.name] = metric.value;
-    }
-    return {
-      js_heap_size_used: m["JSHeapUsedSize"],
-      js_heap_size_total: m["JSHeapTotalSize"],
-      dom_interactive: m["DOMInteractive"],
-      dom_complete: m["DOMComplete"],
-      load_event: m["LoadEventEnd"]
-    };
-  }
-  async startJSCoverage() {
-    await this.send("Profiler.enable");
-    await this.send("Debugger.enable");
-    await this.send("Profiler.startPreciseCoverage", {
-      callCount: false,
-      detailed: true
-    });
-  }
-  async stopJSCoverage() {
-    const result = await this.send("Profiler.takePreciseCoverage");
-    await this.send("Profiler.stopPreciseCoverage");
-    return result.result.filter((r) => r.url && !r.url.startsWith("v8-snapshot://")).map((r) => ({
-      url: r.url,
-      text: "",
-      ranges: r.functions.flatMap((f) => f.ranges.filter((rng) => rng.count > 0).map((rng) => ({ start: rng.startOffset, end: rng.endOffset })))
-    }));
-  }
-  async getCoverage() {
-    await this.startJSCoverage();
-    const js = await this.stopJSCoverage();
-    const totalBytes = js.reduce((acc, e) => acc + e.ranges.reduce((sum, r) => sum + (r.end - r.start), 0), 0);
-    return { js, css: [], totalBytes, usedBytes: totalBytes, unusedPercent: 0 };
-  }
-  async captureHAREntries(page, handler) {
-    await this.enableNetwork();
-    const requestTimings = new Map;
-    const onRequest = (params) => {
-      requestTimings.set(params.requestId, params.timestamp);
-    };
-    const onResponse = (params) => {
-      const start = requestTimings.get(params.requestId);
-      const duration = start != null ? (params.timestamp - start) * 1000 : 0;
-      handler({
-        method: "GET",
-        url: params.response.url,
-        status: params.response.status,
-        duration
-      });
-    };
-    this.on("Network.requestWillBeSent", onRequest);
-    this.on("Network.responseReceived", onResponse);
-    return () => {
-      this.off("Network.requestWillBeSent", onRequest);
-      this.off("Network.responseReceived", onResponse);
-    };
-  }
-  async detach() {
-    try {
-      await this.session.detach();
-    } catch {}
-  }
-}
+
+// src/index.ts
+init_cdp();
+
 // src/engines/lightpanda.ts
+init_types();
 import { execSync, spawn } from "child_process";
 import { chromium as chromium2 } from "playwright";
 var DEFAULT_LIGHTPANDA_PORT = 9222;
@@ -7480,6 +7576,9 @@ class LightpandaPage {
     await this.page.context().close();
   }
 }
+// src/engines/selector.ts
+init_types();
+
 // src/engines/bun-webview.ts
 import { join as join2 } from "path";
 import { mkdirSync as mkdirSync2 } from "fs";
@@ -7953,6 +8052,10 @@ function inferUseCase(label) {
   };
   return map[label.toLowerCase()] ?? "spa_navigate" /* SPA_NAVIGATE */;
 }
+// src/lib/session.ts
+init_types();
+init_types();
+
 // src/lib/network.ts
 function enableNetworkLogging(page, sessionId) {
   const requestStart = new Map;
@@ -8229,6 +8332,37 @@ function createBunProxy(view) {
   return view;
 }
 async function createSession2(opts = {}) {
+  if (opts.cdpUrl) {
+    const { connectToExistingBrowser: connectToExistingBrowser2 } = await Promise.resolve().then(() => (init_cdp(), exports_cdp));
+    const cdpBrowser = await connectToExistingBrowser2(opts.cdpUrl);
+    const contexts = cdpBrowser.contexts();
+    const context = contexts.length > 0 ? contexts[0] : await cdpBrowser.newContext();
+    const pages = context.pages();
+    const page2 = pages.length > 0 ? pages[0] : await context.newPage();
+    const session2 = createSession({
+      engine: "cdp",
+      projectId: opts.projectId,
+      agentId: opts.agentId,
+      startUrl: page2.url(),
+      name: opts.name ?? "attached"
+    });
+    const cleanups2 = [];
+    if (opts.captureNetwork !== false) {
+      try {
+        cleanups2.push(enableNetworkLogging(page2, session2.id));
+      } catch {}
+    }
+    if (opts.captureConsole !== false) {
+      try {
+        cleanups2.push(enableConsoleCapture(page2, session2.id));
+      } catch {}
+    }
+    try {
+      cleanups2.push(setupDialogHandler(page2, session2.id));
+    } catch {}
+    handles.set(session2.id, { browser: cdpBrowser, bunView: null, page: page2, engine: "cdp", cleanups: cleanups2, tokenBudget: { total: 0, used: 0 }, lastActivity: Date.now(), autoGallery: opts.autoGallery ?? false });
+    return { session: session2, page: page2 };
+  }
   const engine = opts.engine === "auto" || !opts.engine ? selectEngine(opts.useCase ?? "spa_navigate" /* SPA_NAVIGATE */, opts.engine) : opts.engine;
   const resolvedEngine = engine === "auto" ? "playwright" : engine;
   let browser = null;
@@ -8254,7 +8388,22 @@ async function createSession2(opts = {}) {
     page = await context.newPage();
   } else {
     browser = await pool.acquire(opts.headless ?? true);
-    page = await getPage(browser, { viewport: opts.viewport, userAgent: opts.userAgent });
+    if (opts.storageState) {
+      const { loadStatePath: loadStatePath2 } = await Promise.resolve().then(() => (init_storage_state(), exports_storage_state));
+      const statePath2 = loadStatePath2(opts.storageState);
+      if (statePath2) {
+        const context = await browser.newContext({
+          viewport: opts.viewport ?? { width: 1280, height: 720 },
+          userAgent: opts.userAgent,
+          storageState: statePath2
+        });
+        page = await context.newPage();
+      } else {
+        page = await getPage(browser, { viewport: opts.viewport, userAgent: opts.userAgent });
+      }
+    } else {
+      page = await getPage(browser, { viewport: opts.viewport, userAgent: opts.userAgent });
+    }
   }
   const sessionName = opts.name ?? (opts.startUrl ? (() => {
     try {
@@ -8452,6 +8601,9 @@ function isAutoGallery(sessionId) {
 function countActiveSessions2() {
   return countActiveSessions();
 }
+// src/lib/actions.ts
+init_types();
+
 // src/lib/snapshot.ts
 var lastSnapshots = new Map;
 var sessionRefMaps = new Map;
@@ -8465,6 +8617,66 @@ function getRefLocator(page, sessionId, ref) {
   return page.getByRole(entry.role, { name: entry.name }).first();
 }
 
+// src/lib/self-heal.ts
+async function healSelector(page, selector, sessionId) {
+  const attempts = [];
+  attempts.push(`selector: ${selector}`);
+  try {
+    const loc = page.locator(selector).first();
+    if (await loc.count() > 0) {
+      return { found: true, locator: loc, method: "original", healed: false, attempts };
+    }
+  } catch {}
+  if (!selector.startsWith("#") && !selector.startsWith(".") && !selector.startsWith("[") && !selector.includes(">") && !selector.includes(" ")) {
+    attempts.push(`text: "${selector}"`);
+    try {
+      const loc = page.getByText(selector, { exact: false }).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "text", healed: true, attempts };
+      }
+    } catch {}
+  }
+  const roleMap = {
+    button: ["button", "submit", "reset"],
+    link: ["a"],
+    input: ["input", "textarea"],
+    heading: ["h1", "h2", "h3", "h4", "h5", "h6"]
+  };
+  const nameHint = selector.replace(/^[#.]/, "").replace(/[-_]/g, " ").toLowerCase();
+  for (const [role, tags] of Object.entries(roleMap)) {
+    attempts.push(`role: ${role} name~="${nameHint}"`);
+    try {
+      const loc = page.getByRole(role, { name: new RegExp(nameHint.split(" ")[0], "i") }).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "role", healed: true, attempts };
+      }
+    } catch {}
+  }
+  if (selector.startsWith("#")) {
+    const idPart = selector.slice(1).split("-").pop() ?? selector.slice(1);
+    const partialSel = `[id*="${idPart}"]`;
+    attempts.push(`partial_id: ${partialSel}`);
+    try {
+      const loc = page.locator(partialSel).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "partial_id", healed: true, attempts };
+      }
+    } catch {}
+  }
+  if (selector.startsWith(".")) {
+    const classPart = selector.slice(1).split("-").pop() ?? selector.slice(1);
+    const partialSel = `[class*="${classPart}"]`;
+    attempts.push(`partial_class: ${partialSel}`);
+    try {
+      const loc = page.locator(partialSel).first();
+      if (await loc.count() > 0) {
+        return { found: true, locator: loc, method: "partial_class", healed: true, attempts };
+      }
+    } catch {}
+  }
+  return { found: false, locator: null, method: "none", healed: false, attempts };
+}
+
 // src/lib/actions.ts
 async function click(page, selector, opts) {
   try {
@@ -8474,11 +8686,22 @@ async function click(page, selector, opts) {
       delay: opts?.delay,
       timeout: opts?.timeout ?? 1e4
     });
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("not found")) {
+    return {};
+  } catch (originalError) {
+    if (opts?.selfHeal !== false) {
+      const result = await healSelector(page, selector);
+      if (result.found && result.locator) {
+        await result.locator.click({
+          button: opts?.button ?? "left",
+          timeout: opts?.timeout ?? 1e4
+        });
+        return { healed: true, method: result.method, attempts: result.attempts };
+      }
+    }
+    if (originalError instanceof Error && originalError.message.includes("not found")) {
       throw new ElementNotFoundError(selector);
     }
-    throw new BrowserError(`Click failed on '${selector}': ${err instanceof Error ? err.message : String(err)}`, "CLICK_FAILED");
+    throw new BrowserError(`Click failed on '${selector}': ${originalError instanceof Error ? originalError.message : String(originalError)}`, "CLICK_FAILED");
   }
 }
 async function type(page, selector, text, opts) {
@@ -8487,17 +8710,35 @@ async function type(page, selector, text, opts) {
       await page.fill(selector, "", { timeout: opts?.timeout ?? 1e4 });
     }
     await page.type(selector, text, { delay: opts?.delay, timeout: opts?.timeout ?? 1e4 });
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("not found")) {
+    return {};
+  } catch (originalError) {
+    if (opts?.selfHeal !== false) {
+      const result = await healSelector(page, selector);
+      if (result.found && result.locator) {
+        if (opts?.clear)
+          await result.locator.fill("", { timeout: opts?.timeout ?? 1e4 });
+        await result.locator.pressSequentially(text, { delay: opts?.delay, timeout: opts?.timeout ?? 1e4 });
+        return { healed: true, method: result.method, attempts: result.attempts };
+      }
+    }
+    if (originalError instanceof Error && originalError.message.includes("not found")) {
       throw new ElementNotFoundError(selector);
     }
-    throw new BrowserError(`Type failed on '${selector}': ${err instanceof Error ? err.message : String(err)}`, "TYPE_FAILED");
+    throw new BrowserError(`Type failed on '${selector}': ${originalError instanceof Error ? originalError.message : String(originalError)}`, "TYPE_FAILED");
   }
 }
-async function fill(page, selector, value, timeout = 1e4) {
+async function fill(page, selector, value, timeout = 1e4, selfHeal = true) {
   try {
     await page.fill(selector, value, { timeout });
-  } catch (err) {
+    return {};
+  } catch (originalError) {
+    if (selfHeal) {
+      const result = await healSelector(page, selector);
+      if (result.found && result.locator) {
+        await result.locator.fill(value, { timeout });
+        return { healed: true, method: result.method, attempts: result.attempts };
+      }
+    }
     throw new ElementNotFoundError(selector);
   }
 }
@@ -8623,12 +8864,39 @@ async function clickText(page, text, opts) {
     }
   }, { retries: opts?.retries ?? 1 });
 }
-async function fillForm(page, fields, submitSelector) {
+async function fillForm(page, fields, submitSelector, selfHeal = true) {
   let filled = 0;
   const errors = [];
+  const healedFields = [];
   for (const [selector, value] of Object.entries(fields)) {
     try {
-      const el = await page.$(selector);
+      let el = await page.$(selector);
+      if (!el && selfHeal) {
+        const result = await healSelector(page, selector);
+        if (result.found && result.locator) {
+          const handle = await result.locator.elementHandle();
+          if (handle) {
+            el = handle;
+            healedFields.push(selector);
+            const tagName2 = await result.locator.evaluate((e) => e.tagName.toLowerCase());
+            const inputType2 = await result.locator.evaluate((e) => e.type?.toLowerCase() ?? "text");
+            if (tagName2 === "select") {
+              await result.locator.selectOption(String(value));
+            } else if (tagName2 === "input" && (inputType2 === "checkbox" || inputType2 === "radio")) {
+              if (Boolean(value))
+                await result.locator.check();
+              else
+                await result.locator.uncheck();
+            } else {
+              await result.locator.fill(String(value));
+            }
+            filled++;
+            continue;
+          }
+        }
+        errors.push(`${selector}: element not found`);
+        continue;
+      }
       if (!el) {
         errors.push(`${selector}: element not found`);
         continue;
@@ -8655,11 +8923,21 @@ async function fillForm(page, fields, submitSelector) {
   if (submitSelector) {
     try {
       await page.click(submitSelector);
-    } catch (err) {
-      errors.push(`submit(${submitSelector}): ${err instanceof Error ? err.message : String(err)}`);
+    } catch (submitErr) {
+      if (selfHeal) {
+        const result = await healSelector(page, submitSelector);
+        if (result.found && result.locator) {
+          await result.locator.click();
+          healedFields.push(submitSelector);
+        } else {
+          errors.push(`submit(${submitSelector}): ${submitErr instanceof Error ? submitErr.message : String(submitErr)}`);
+        }
+      } else {
+        errors.push(`submit(${submitSelector}): ${submitErr instanceof Error ? submitErr.message : String(submitErr)}`);
+      }
     }
   }
-  return { filled, errors, fields_attempted: Object.keys(fields).length };
+  return { filled, errors, fields_attempted: Object.keys(fields).length, ...healedFields.length > 0 ? { healed_fields: healedFields } : {} };
 }
 async function waitForText(page, text, opts) {
   const timeout = opts?.timeout ?? 1e4;
@@ -8939,6 +9217,7 @@ async function getPageInfo(page) {
   };
 }
 // src/lib/performance.ts
+init_cdp();
 async function getPerformanceMetrics(page) {
   const navTiming = await page.evaluate(() => {
     const t = performance.timing;
@@ -9026,10 +9305,11 @@ async function startCoverage(page) {
   };
 }
 // src/lib/screenshot.ts
+init_types();
 var import_sharp = __toESM(require_lib(), 1);
-import { join as join3 } from "path";
-import { mkdirSync as mkdirSync3 } from "fs";
-import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+import { mkdirSync as mkdirSync4 } from "fs";
+import { homedir as homedir4 } from "os";
 
 // src/db/gallery.ts
 init_schema();
@@ -9075,13 +9355,13 @@ function getEntry(id) {
 
 // src/lib/screenshot.ts
 function getDataDir2() {
-  return process.env["BROWSER_DATA_DIR"] ?? join3(homedir3(), ".browser");
+  return process.env["BROWSER_DATA_DIR"] ?? join4(homedir4(), ".browser");
 }
 function getScreenshotDir(projectId) {
-  const base = join3(getDataDir2(), "screenshots");
+  const base = join4(getDataDir2(), "screenshots");
   const date = new Date().toISOString().split("T")[0];
-  const dir = projectId ? join3(base, projectId, date) : join3(base, date);
-  mkdirSync3(dir, { recursive: true });
+  const dir = projectId ? join4(base, projectId, date) : join4(base, date);
+  mkdirSync4(dir, { recursive: true });
   return dir;
 }
 async function compressBuffer(raw, format, quality, maxWidth) {
@@ -9096,7 +9376,7 @@ async function compressBuffer(raw, format, quality, maxWidth) {
   }
 }
 async function generateThumbnail(raw, dir, stem) {
-  const thumbPath = join3(dir, `${stem}.thumb.webp`);
+  const thumbPath = join4(dir, `${stem}.thumb.webp`);
   const thumbBuffer = await import_sharp.default(raw).resize({ width: 200, withoutEnlargement: true }).webp({ quality: 70, effort: 3 }).toBuffer();
   await Bun.write(thumbPath, thumbBuffer);
   return { path: thumbPath, base64: thumbBuffer.toString("base64") };
@@ -9153,7 +9433,7 @@ async function takeScreenshot(page, opts) {
     const compressedSizeBytes = finalBuffer.length;
     const compressionRatio = originalSizeBytes > 0 ? compressedSizeBytes / originalSizeBytes : 1;
     const ext = format;
-    const screenshotPath = opts?.path ?? join3(dir, `${stem}.${ext}`);
+    const screenshotPath = opts?.path ?? join4(dir, `${stem}.${ext}`);
     await Bun.write(screenshotPath, finalBuffer);
     let thumbnailPath;
     let thumbnailBase64;
@@ -9213,12 +9493,12 @@ async function takeScreenshot(page, opts) {
 }
 async function generatePDF(page, opts) {
   try {
-    const base = join3(getDataDir2(), "pdfs");
+    const base = join4(getDataDir2(), "pdfs");
     const date = new Date().toISOString().split("T")[0];
-    const dir = opts?.projectId ? join3(base, opts.projectId, date) : join3(base, date);
-    mkdirSync3(dir, { recursive: true });
+    const dir = opts?.projectId ? join4(base, opts.projectId, date) : join4(base, date);
+    mkdirSync4(dir, { recursive: true });
     const timestamp = Date.now();
-    const pdfPath = opts?.path ?? join3(dir, `${timestamp}.pdf`);
+    const pdfPath = opts?.path ?? join4(dir, `${timestamp}.pdf`);
     const buffer = await page.pdf({
       path: pdfPath,
       format: opts?.format ?? "A4",
@@ -9308,6 +9588,7 @@ async function getIndexedDB(page, dbName, storeName) {
   }), [dbName, storeName]);
 }
 // src/lib/recorder.ts
+init_types();
 var activeRecordings = new Map;
 function startRecording(sessionId, name, startUrl) {
   const steps = [];
@@ -9466,6 +9747,7 @@ function exportRecording(recordingId, format = "json") {
 `);
 }
 // src/lib/crawler.ts
+init_types();
 async function crawl(startUrl, opts = {}) {
   const maxDepth = opts.maxDepth ?? 2;
   const maxPages = opts.maxPages ?? 50;
@@ -9678,6 +9960,7 @@ export {
   createCrawlResult,
   crawl,
   countActiveSessions2 as countActiveSessions,
+  connectToExistingBrowser,
   connectLightpanda,
   closeSession2 as closeSession,
   closePage,