@hasna/browser 0.3.7 → 0.3.8

package/dist/server/index.js

@@ -3,6 +3,7 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
@@ -29,6 +30,23 @@ var __toESM = (mod, isNodeMode, target) => {
     cache.set(mod, to);
   return to;
 };
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -9487,6 +9505,12 @@ See https://www.postgresql.org/docs/current/libpq-ssl.html for libpq SSL mode de
 });
 
 // src/db/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  resetDatabase: () => resetDatabase,
+  getDatabase: () => getDatabase,
+  getDataDir: () => getDataDir2
+});
 import { join as join5 } from "path";
 import { mkdirSync as mkdirSync3, existsSync as existsSync4, readdirSync as readdirSync3, copyFileSync as copyFileSync2, statSync } from "fs";
 import { homedir as homedir6 } from "os";
@@ -9531,6 +9555,15 @@ function getDatabase(path) {
   runMigrations(_db);
   return _db;
 }
+function resetDatabase() {
+  if (_db) {
+    try {
+      _db.close();
+    } catch {}
+  }
+  _db = null;
+  _dbPath = null;
+}
 function runMigrations(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS schema_migrations (
@@ -9884,6 +9917,94 @@ var init_console_log = __esm(() => {
   init_schema();
 });
 
+// src/lib/dialogs.ts
+var exports_dialogs = {};
+__export(exports_dialogs, {
+  setupDialogHandler: () => setupDialogHandler,
+  handleDialog: () => handleDialog,
+  getDialogs: () => getDialogs,
+  clearDialogs: () => clearDialogs
+});
+function setupDialogHandler(page, sessionId) {
+  const onDialog = (dialog) => {
+    const info = {
+      type: dialog.type(),
+      message: dialog.message(),
+      default_value: dialog.defaultValue(),
+      timestamp: new Date().toISOString()
+    };
+    const autoTimer = setTimeout(() => {
+      try {
+        dialog.dismiss().catch(() => {});
+      } catch {}
+      const list = pendingDialogs.get(sessionId);
+      if (list) {
+        const idx = list.findIndex((p) => p.dialog === dialog);
+        if (idx >= 0)
+          list.splice(idx, 1);
+        if (list.length === 0)
+          pendingDialogs.delete(sessionId);
+      }
+    }, AUTO_DISMISS_MS);
+    const pending = { dialog, info, autoTimer };
+    if (!pendingDialogs.has(sessionId)) {
+      pendingDialogs.set(sessionId, []);
+    }
+    pendingDialogs.get(sessionId).push(pending);
+  };
+  page.on("dialog", onDialog);
+  return () => {
+    page.off("dialog", onDialog);
+    const list = pendingDialogs.get(sessionId);
+    if (list) {
+      for (const p of list)
+        clearTimeout(p.autoTimer);
+      pendingDialogs.delete(sessionId);
+    }
+  };
+}
+function getDialogs(sessionId) {
+  const list = pendingDialogs.get(sessionId);
+  if (!list)
+    return [];
+  return list.map((p) => p.info);
+}
+async function handleDialog(sessionId, action, promptText) {
+  const list = pendingDialogs.get(sessionId);
+  if (!list || list.length === 0) {
+    return { handled: false };
+  }
+  const pending = list.shift();
+  clearTimeout(pending.autoTimer);
+  if (list.length === 0) {
+    pendingDialogs.delete(sessionId);
+  }
+  try {
+    if (action === "accept") {
+      await pending.dialog.accept(promptText);
+    } else {
+      await pending.dialog.dismiss();
+    }
+  } catch {}
+  return { handled: true, dialog: pending.info };
+}
+function clearDialogs(sessionId) {
+  const list = pendingDialogs.get(sessionId);
+  if (list) {
+    for (const p of list) {
+      clearTimeout(p.autoTimer);
+      try {
+        p.dialog.dismiss().catch(() => {});
+      } catch {}
+    }
+    pendingDialogs.delete(sessionId);
+  }
+}
+var pendingDialogs, AUTO_DISMISS_MS = 5000;
+var init_dialogs = __esm(() => {
+  pendingDialogs = new Map;
+});
+
 // src/engines/cdp.ts
 var exports_cdp = {};
 __export(exports_cdp, {
@@ -10066,150 +10187,904 @@ var init_storage_state = __esm(() => {
   STATES_DIR = join8(getDataDir2(), "states");
 });
 
-// node_modules/sharp/lib/is.js
-var require_is = __commonJS((exports, module) => {
-  /*!
-    Copyright 2013 Lovell Fuller and others.
-    SPDX-License-Identifier: Apache-2.0
-  */
-  var defined = (val) => typeof val !== "undefined" && val !== null;
-  var object = (val) => typeof val === "object";
-  var plainObject = (val) => Object.prototype.toString.call(val) === "[object Object]";
-  var fn = (val) => typeof val === "function";
-  var bool = (val) => typeof val === "boolean";
-  var buffer = (val) => val instanceof Buffer;
-  var typedArray = (val) => {
-    if (defined(val)) {
-      switch (val.constructor) {
-        case Uint8Array:
-        case Uint8ClampedArray:
-        case Int8Array:
-        case Uint16Array:
-        case Int16Array:
-        case Uint32Array:
-        case Int32Array:
-        case Float32Array:
-        case Float64Array:
-          return true;
-      }
-    }
-    return false;
-  };
-  var arrayBuffer = (val) => val instanceof ArrayBuffer;
-  var string = (val) => typeof val === "string" && val.length > 0;
-  var number = (val) => typeof val === "number" && !Number.isNaN(val);
-  var integer = (val) => Number.isInteger(val);
-  var inRange = (val, min, max) => val >= min && val <= max;
-  var inArray = (val, list) => list.includes(val);
-  var invalidParameterError = (name, expected, actual) => new Error(`Expected ${expected} for ${name} but received ${actual} of type ${typeof actual}`);
-  var nativeError = (native, context) => {
-    context.message = native.message;
-    return context;
-  };
-  module.exports = {
-    defined,
-    object,
-    plainObject,
-    fn,
-    bool,
-    buffer,
-    typedArray,
-    arrayBuffer,
-    string,
-    number,
-    integer,
-    inRange,
-    inArray,
-    invalidParameterError,
-    nativeError
-  };
+// src/lib/snapshot.ts
+var exports_snapshot = {};
+__export(exports_snapshot, {
+  takeSnapshot: () => takeSnapshot,
+  takeBunSnapshot: () => takeBunSnapshot,
+  setLastSnapshot: () => setLastSnapshot,
+  hasRefs: () => hasRefs,
+  getSessionRefs: () => getSessionRefs,
+  getRefLocator: () => getRefLocator,
+  getRefInfo: () => getRefInfo,
+  getLastSnapshot: () => getLastSnapshot,
+  diffSnapshots: () => diffSnapshots,
+  clearSessionRefs: () => clearSessionRefs,
+  clearLastSnapshot: () => clearLastSnapshot
 });
-
-// node_modules/detect-libc/lib/process.js
-var require_process = __commonJS((exports, module) => {
-  var isLinux = () => process.platform === "linux";
-  var report = null;
-  var getReport = () => {
-    if (!report) {
-      if (isLinux() && process.report) {
-        const orig = process.report.excludeNetwork;
-        process.report.excludeNetwork = true;
-        report = process.report.getReport();
-        process.report.excludeNetwork = orig;
-      } else {
-        report = {};
+function getLastSnapshot(sessionId) {
+  return lastSnapshots.get(sessionId) ?? null;
+}
+function setLastSnapshot(sessionId, snapshot) {
+  lastSnapshots.set(sessionId, snapshot);
+}
+function clearLastSnapshot(sessionId) {
+  lastSnapshots.delete(sessionId);
+}
+async function takeSnapshot(page, sessionId) {
+  const isBunView = typeof page.getNativeView === "function" || typeof page.bunView !== "undefined";
+  if (isBunView) {
+    return takeBunSnapshot(page, sessionId);
+  }
+  let ariaTree;
+  try {
+    ariaTree = await page.locator("body").ariaSnapshot();
+  } catch {
+    ariaTree = "";
+  }
+  const refs = {};
+  const refMap = new Map;
+  let refCounter = 0;
+  for (const role of INTERACTIVE_ROLES) {
+    const locators = page.getByRole(role);
+    const count = await locators.count();
+    for (let i = 0;i < count; i++) {
+      const el = locators.nth(i);
+      let name = "";
+      let visible = false;
+      let enabled = true;
+      let value;
+      let checked;
+      try {
+        visible = await el.isVisible();
+        if (!visible)
+          continue;
+      } catch {
+        continue;
+      }
+      try {
+        name = await el.evaluate((e) => {
+          const el2 = e;
+          return el2.getAttribute("aria-label") ?? el2.textContent?.trim().slice(0, 80) ?? el2.getAttribute("title") ?? el2.getAttribute("placeholder") ?? "";
+        });
+      } catch {
+        continue;
       }
+      if (!name)
+        continue;
+      try {
+        enabled = await el.isEnabled();
+      } catch {}
+      try {
+        if (role === "checkbox" || role === "radio" || role === "switch") {
+          checked = await el.isChecked();
+        }
+      } catch {}
+      try {
+        if (role === "textbox" || role === "searchbox" || role === "spinbutton" || role === "combobox") {
+          value = await el.inputValue();
+        }
+      } catch {}
+      const ref = `@e${refCounter}`;
+      refCounter++;
+      refs[ref] = { role, name, visible, enabled, value, checked };
+      const escapedName = name.replace(/"/g, "\\\"");
+      refMap.set(ref, { role, name, locatorSelector: `role=${role}[name="${escapedName}"]` });
+    }
+  }
+  let annotatedTree = ariaTree;
+  for (const [ref, info] of Object.entries(refs)) {
+    const escapedName = info.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`(${info.role}\\s+"${escapedName.slice(0, 40)}[^"]*")`, "m");
+    const match = annotatedTree.match(pattern);
+    if (match) {
+      annotatedTree = annotatedTree.replace(match[0], `${match[0]} [${ref}]`);
     }
-    return report;
-  };
-  module.exports = { isLinux, getReport };
-});
+  }
+  const unmatchedRefs = Object.entries(refs).filter(([ref]) => !annotatedTree.includes(`[${ref}]`));
+  if (unmatchedRefs.length > 0) {
+    annotatedTree += `
 
-// node_modules/detect-libc/lib/filesystem.js
-var require_filesystem = __commonJS((exports, module) => {
-  var fs = __require("fs");
-  var LDD_PATH = "/usr/bin/ldd";
-  var SELF_PATH = "/proc/self/exe";
-  var MAX_LENGTH = 2048;
-  var readFileSync2 = (path) => {
-    const fd = fs.openSync(path, "r");
-    const buffer = Buffer.alloc(MAX_LENGTH);
-    const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-    fs.close(fd, () => {});
-    return buffer.subarray(0, bytesRead);
+--- Interactive elements ---`;
+    for (const [ref, info] of unmatchedRefs) {
+      const extras = [];
+      if (info.checked !== undefined)
+        extras.push(`checked=${info.checked}`);
+      if (!info.enabled)
+        extras.push("disabled");
+      if (info.value)
+        extras.push(`value="${info.value}"`);
+      const extrasStr = extras.length ? ` (${extras.join(", ")})` : "";
+      annotatedTree += `
+${info.role} "${info.name}" [${ref}]${extrasStr}`;
+    }
+  }
+  if (sessionId) {
+    sessionRefMaps.set(sessionId, refMap);
+  }
+  return {
+    tree: annotatedTree,
+    refs,
+    interactive_count: refCounter
   };
-  var readFile = (path) => new Promise((resolve, reject) => {
-    fs.open(path, "r", (err, fd) => {
-      if (err) {
-        reject(err);
-      } else {
-        const buffer = Buffer.alloc(MAX_LENGTH);
-        fs.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
-          resolve(buffer.subarray(0, bytesRead));
-          fs.close(fd, () => {});
-        });
+}
+function getRefLocator(page, sessionId, ref) {
+  const refMap = sessionRefMaps.get(sessionId);
+  if (!refMap)
+    throw new Error(`No snapshot taken for session ${sessionId}. Call browser_snapshot first.`);
+  const entry = refMap.get(ref);
+  if (!entry)
+    throw new Error(`Ref ${ref} not found. Available refs: ${[...refMap.keys()].slice(0, 20).join(", ")}`);
+  return page.getByRole(entry.role, { name: entry.name }).first();
+}
+function getRefInfo(sessionId, ref) {
+  const refMap = sessionRefMaps.get(sessionId);
+  if (!refMap)
+    return null;
+  return refMap.get(ref) ?? null;
+}
+function getSessionRefs(sessionId) {
+  return sessionRefMaps.get(sessionId) ?? null;
+}
+function clearSessionRefs(sessionId) {
+  sessionRefMaps.delete(sessionId);
+}
+function hasRefs(sessionId) {
+  return sessionRefMaps.has(sessionId) && (sessionRefMaps.get(sessionId)?.size ?? 0) > 0;
+}
+function refKey(info) {
+  return `${info.role}::${info.name}`;
+}
+function diffSnapshots(before, after) {
+  const beforeMap = new Map;
+  for (const [ref, info] of Object.entries(before.refs)) {
+    beforeMap.set(refKey(info), { ref, info });
+  }
+  const afterMap = new Map;
+  for (const [ref, info] of Object.entries(after.refs)) {
+    afterMap.set(refKey(info), { ref, info });
+  }
+  const added = [];
+  const removed = [];
+  const modified = [];
+  for (const [key, afterEntry] of afterMap) {
+    const beforeEntry = beforeMap.get(key);
+    if (!beforeEntry) {
+      added.push({ ref: afterEntry.ref, info: afterEntry.info });
+    } else {
+      const b = beforeEntry.info;
+      const a = afterEntry.info;
+      if (b.visible !== a.visible || b.enabled !== a.enabled || b.value !== a.value || b.checked !== a.checked || b.description !== a.description) {
+        modified.push({ ref: afterEntry.ref, before: b, after: a });
       }
-    });
-  });
-  module.exports = {
-    LDD_PATH,
-    SELF_PATH,
-    readFileSync: readFileSync2,
-    readFile
-  };
-});
-
-// node_modules/detect-libc/lib/elf.js
-var require_elf = __commonJS((exports, module) => {
-  var interpreterPath = (elf) => {
-    if (elf.length < 64) {
-      return null;
-    }
-    if (elf.readUInt32BE(0) !== 2135247942) {
-      return null;
-    }
-    if (elf.readUInt8(4) !== 2) {
-      return null;
     }
-    if (elf.readUInt8(5) !== 1) {
-      return null;
+  }
+  for (const [key, beforeEntry] of beforeMap) {
+    if (!afterMap.has(key)) {
+      removed.push({ ref: beforeEntry.ref, info: beforeEntry.info });
     }
-    const offset = elf.readUInt32LE(32);
-    const size = elf.readUInt16LE(54);
-    const count = elf.readUInt16LE(56);
-    for (let i = 0;i < count; i++) {
-      const headerOffset = offset + i * size;
-      const type2 = elf.readUInt32LE(headerOffset);
-      if (type2 === 3) {
-        const fileOffset = elf.readUInt32LE(headerOffset + 8);
-        const fileSize = elf.readUInt32LE(headerOffset + 32);
-        return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, "");
-      }
+  }
+  const url_changed = before.tree.split(`
+`)[0] !== after.tree.split(`
+`)[0];
+  const title_changed = before.tree !== after.tree && (added.length > 0 || removed.length > 0 || modified.length > 0);
+  return { added, removed, modified, url_changed, title_changed };
+}
+async function takeBunSnapshot(page, sessionId) {
+  const refs = {};
+  const refMap = new Map;
+  let refCounter = 0;
+  const lines = [];
+  try {
+    const elements = await page.evaluate(`
+      (() => {
+        const SELECTOR = 'a[href], button, input:not([type=hidden]), select, textarea, [role=button], [role=link], [role=checkbox], [role=combobox], [role=menuitem], [role=tab], [role=option]';
+        const els = Array.from(document.querySelectorAll(SELECTOR));
+        return els.slice(0, 100).map(el => {
+          const tag = el.tagName.toLowerCase();
+          const inputType = el.getAttribute('type') ?? '';
+          let role = el.getAttribute('role') || (['a'].includes(tag) ? 'link' : ['button'].includes(tag) ? 'button' : ['input'].includes(tag) ? (inputType === 'checkbox' ? 'checkbox' : inputType === 'radio' ? 'radio' : 'textbox') : ['select'].includes(tag) ? 'combobox' : ['textarea'].includes(tag) ? 'textbox' : tag);
+          const name = (el.getAttribute('aria-label') || el.textContent?.trim() || el.getAttribute('placeholder') || el.getAttribute('title') || el.getAttribute('value') || el.id || '').slice(0, 80);
+          const enabled = !el.disabled && !el.getAttribute('disabled');
+          const style = window.getComputedStyle(el);
+          const visible = style.display !== 'none' && style.visibility !== 'hidden' && el.offsetWidth > 0;
+          const checked = el.type === 'checkbox' || el.type === 'radio' ? el.checked : undefined;
+          const value = ['input', 'select', 'textarea'].includes(tag) && el.type !== 'checkbox' && el.type !== 'radio' ? el.value : undefined;
+          const selector = el.id ? '#' + el.id : (el.getAttribute('aria-label') ? '[aria-label="' + el.getAttribute('aria-label') + '"]' : tag);
+          return { role, name, enabled, visible, checked, value, selector };
+        }).filter(e => e.visible && e.name);
+      })()
+    `);
+    const pageTitle = await page.evaluate("document.title");
+    const pageUrl = typeof page.url === "function" ? page.url() : "";
+    lines.push(`# ${pageTitle || "Page"} (${pageUrl})`);
+    for (const el of elements) {
+      if (!el.name)
+        continue;
+      const ref = `@e${refCounter}`;
+      refCounter++;
+      refs[ref] = {
+        role: el.role,
+        name: el.name,
+        visible: el.visible,
+        enabled: el.enabled,
+        value: el.value,
+        checked: el.checked
+      };
+      refMap.set(ref, { role: el.role, name: el.name, locatorSelector: el.selector });
+      const extras = [];
+      if (el.checked !== undefined)
+        extras.push(`checked=${el.checked}`);
+      if (!el.enabled)
+        extras.push("disabled");
+      if (el.value && el.value !== el.name)
+        extras.push(`value="${el.value.slice(0, 30)}"`);
+      const extrasStr = extras.length ? ` (${extras.join(", ")})` : "";
+      lines.push(`${el.role} "${el.name}" [${ref}]${extrasStr}`);
     }
-    return null;
-  };
-  module.exports = {
-    interpreterPath
+  } catch (err) {
+    lines.push(`# (snapshot error: ${err instanceof Error ? err.message : String(err)})`);
+  }
+  if (sessionId) {
+    sessionRefMaps.set(sessionId, refMap);
+  }
+  return {
+    tree: lines.join(`
+`),
+    refs,
+    interactive_count: refCounter
+  };
+}
+var lastSnapshots, sessionRefMaps, INTERACTIVE_ROLES;
+var init_snapshot = __esm(() => {
+  lastSnapshots = new Map;
+  sessionRefMaps = new Map;
+  INTERACTIVE_ROLES = [
+    "button",
+    "link",
+    "textbox",
+    "checkbox",
+    "radio",
+    "combobox",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "searchbox",
+    "slider",
+    "spinbutton",
+    "switch",
+    "tab",
+    "treeitem",
+    "listbox",
+    "menu"
+  ];
+});
+
+// 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
+var exports_actions = {};
+__export(exports_actions, {
+  withRetry: () => withRetry,
+  watchPage: () => watchPage,
+  waitForText: () => waitForText,
+  waitForSelector: () => waitForSelector,
+  waitForNavigation: () => waitForNavigation,
+  uploadFile: () => uploadFile,
+  typeRef: () => typeRef,
+  type: () => type,
+  stopWatch: () => stopWatch,
+  stopAllWatchesForSession: () => stopAllWatchesForSession,
+  selectRef: () => selectRef,
+  selectOption: () => selectOption,
+  scrollTo: () => scrollTo,
+  scroll: () => scroll,
+  reload: () => reload,
+  pressKey: () => pressKey,
+  navigate: () => navigate,
+  hoverRef: () => hoverRef,
+  hover: () => hover,
+  goForward: () => goForward,
+  goBack: () => goBack,
+  getWatchChanges: () => getWatchChanges,
+  fillRef: () => fillRef,
+  fillForm: () => fillForm,
+  fill: () => fill,
+  clickText: () => clickText,
+  clickRef: () => clickRef,
+  click: () => click,
+  checkRef: () => checkRef,
+  checkBox: () => checkBox
+});
+async function click(page, selector, opts) {
+  try {
+    await page.click(selector, {
+      button: opts?.button ?? "left",
+      clickCount: opts?.clickCount ?? 1,
+      delay: opts?.delay,
+      timeout: opts?.timeout ?? 1e4
+    });
+    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}': ${originalError instanceof Error ? originalError.message : String(originalError)}`, "CLICK_FAILED");
+  }
+}
+async function type(page, selector, text, opts) {
+  try {
+    if (opts?.clear) {
+      await page.fill(selector, "", { timeout: opts?.timeout ?? 1e4 });
+    }
+    await page.type(selector, text, { delay: opts?.delay, timeout: opts?.timeout ?? 1e4 });
+    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}': ${originalError instanceof Error ? originalError.message : String(originalError)}`, "TYPE_FAILED");
+  }
+}
+async function fill(page, selector, value, timeout = 1e4, selfHeal = true) {
+  try {
+    await page.fill(selector, value, { timeout });
+    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);
+  }
+}
+async function scroll(page, direction = "down", amount = 300) {
+  const x = direction === "left" ? -amount : direction === "right" ? amount : 0;
+  const y = direction === "up" ? -amount : direction === "down" ? amount : 0;
+  await page.evaluate(({ x: x2, y: y2 }) => window.scrollBy(x2, y2), { x, y });
+}
+async function scrollTo(page, selector) {
+  try {
+    await page.locator(selector).scrollIntoViewIfNeeded();
+  } catch (err) {
+    throw new ElementNotFoundError(selector);
+  }
+}
+async function hover(page, selector, timeout = 1e4) {
+  try {
+    await page.hover(selector, { timeout });
+  } catch (err) {
+    throw new ElementNotFoundError(selector);
+  }
+}
+async function selectOption(page, selector, value, timeout = 1e4) {
+  try {
+    return await page.selectOption(selector, value, { timeout });
+  } catch (err) {
+    throw new ElementNotFoundError(selector);
+  }
+}
+async function checkBox(page, selector, checked, timeout = 1e4) {
+  try {
+    if (checked) {
+      await page.check(selector, { timeout });
+    } else {
+      await page.uncheck(selector, { timeout });
+    }
+  } catch (err) {
+    throw new ElementNotFoundError(selector);
+  }
+}
+async function uploadFile(page, selector, filePaths, timeout = 1e4) {
+  try {
+    await page.setInputFiles(selector, filePaths, { timeout });
+  } catch (err) {
+    throw new ElementNotFoundError(selector);
+  }
+}
+async function goBack(page, timeout = 1e4) {
+  try {
+    await page.goBack({ timeout, waitUntil: "domcontentloaded" });
+  } catch (err) {
+    throw new NavigationError("back", err instanceof Error ? err.message : String(err));
+  }
+}
+async function goForward(page, timeout = 1e4) {
+  try {
+    await page.goForward({ timeout, waitUntil: "domcontentloaded" });
+  } catch (err) {
+    throw new NavigationError("forward", err instanceof Error ? err.message : String(err));
+  }
+}
+async function reload(page, timeout = 1e4) {
+  try {
+    await page.reload({ timeout, waitUntil: "domcontentloaded" });
+  } catch (err) {
+    throw new NavigationError("reload", err instanceof Error ? err.message : String(err));
+  }
+}
+async function navigate(page, url, timeout = 30000) {
+  try {
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout });
+  } catch (err) {
+    throw new NavigationError(url, err instanceof Error ? err.message : String(err));
+  }
+}
+async function waitForSelector(page, selector, opts) {
+  try {
+    await page.waitForSelector(selector, {
+      state: opts?.state ?? "visible",
+      timeout: opts?.timeout ?? 1e4
+    });
+  } catch (err) {
+    throw new ElementNotFoundError(selector);
+  }
+}
+async function waitForNavigation(page, timeout = 30000) {
+  try {
+    await page.waitForLoadState("domcontentloaded", { timeout });
+  } catch (err) {
+    throw new NavigationError("navigation", err instanceof Error ? err.message : String(err));
+  }
+}
+async function pressKey(page, key) {
+  await page.keyboard.press(key);
+}
+async function withRetry(fn, opts) {
+  const retries = opts?.retries ?? 2;
+  const delay = opts?.delay ?? 300;
+  const retryOn = opts?.retryOn ?? RETRYABLE_ERRORS;
+  let lastErr;
+  for (let attempt = 0;attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      const msg = err instanceof Error ? err.message : String(err);
+      const shouldRetry = retryOn.some((pattern) => msg.includes(pattern));
+      if (!shouldRetry || err instanceof ElementNotFoundError)
+        throw err;
+      if (attempt < retries)
+        await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastErr;
+}
+async function clickText(page, text, opts) {
+  await withRetry(async () => {
+    try {
+      await page.getByText(text, { exact: opts?.exact ?? false }).first().click({ timeout: opts?.timeout ?? 1e4 });
+    } catch (err) {
+      throw new BrowserError(`clickText: could not find or click text "${text}": ${err instanceof Error ? err.message : String(err)}`, "CLICK_TEXT_FAILED");
+    }
+  }, { retries: opts?.retries ?? 1 });
+}
+async function fillForm(page, fields, submitSelector, selfHeal = true) {
+  let filled = 0;
+  const errors = [];
+  const healedFields = [];
+  for (const [selector, value] of Object.entries(fields)) {
+    try {
+      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;
+      }
+      const tagName = await el.evaluate((e) => e.tagName.toLowerCase());
+      const inputType = await el.evaluate((e) => e.type?.toLowerCase() ?? "text");
+      if (tagName === "select") {
+        await page.selectOption(selector, String(value));
+      } else if (tagName === "input" && (inputType === "checkbox" || inputType === "radio")) {
+        const checked = Boolean(value);
+        if (checked) {
+          await page.check(selector);
+        } else {
+          await page.uncheck(selector);
+        }
+      } else {
+        await page.fill(selector, String(value));
+      }
+      filled++;
+    } catch (err) {
+      errors.push(`${selector}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (submitSelector) {
+    try {
+      await page.click(submitSelector);
+    } 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, ...healedFields.length > 0 ? { healed_fields: healedFields } : {} };
+}
+async function waitForText(page, text, opts) {
+  const timeout = opts?.timeout ?? 1e4;
+  try {
+    await page.getByText(text, { exact: opts?.exact ?? false }).first().waitFor({ state: "visible", timeout });
+  } catch (err) {
+    throw new ElementNotFoundError(`text:"${text}"`);
+  }
+}
+function watchPage(page, opts) {
+  const id = `watch-${Date.now()}`;
+  const changes = [];
+  const intervalMs = opts?.intervalMs ?? 500;
+  const maxChanges = opts?.maxChanges ?? 50;
+  const interval = setInterval(async () => {
+    if (changes.length >= maxChanges)
+      return;
+    try {
+      const change = await page.evaluate((sel) => {
+        const el = sel ? document.querySelector(sel) : document.body;
+        return el ? `${new Date().toISOString()}:${el.textContent?.slice(0, 100)}` : null;
+      }, opts?.selector ?? null);
+      if (change && (changes.length === 0 || changes[changes.length - 1] !== change)) {
+        changes.push(change);
+      }
+    } catch {}
+  }, intervalMs);
+  activeWatches.set(id, { interval, changes });
+  return {
+    id,
+    stop: () => {
+      clearInterval(interval);
+      activeWatches.delete(id);
+    }
+  };
+}
+function getWatchChanges(watchId) {
+  return activeWatches.get(watchId)?.changes ?? [];
+}
+function stopWatch(watchId) {
+  const w = activeWatches.get(watchId);
+  if (w) {
+    clearInterval(w.interval);
+    activeWatches.delete(watchId);
+  }
+}
+function stopAllWatchesForSession(_sessionId) {
+  for (const [id, w] of activeWatches) {
+    clearInterval(w.interval);
+    activeWatches.delete(id);
+  }
+}
+async function clickRef(page, sessionId, ref, opts) {
+  try {
+    const locator = getRefLocator(page, sessionId, ref);
+    await locator.click({ timeout: opts?.timeout ?? 1e4 });
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Ref "))
+      throw new ElementNotFoundError(ref);
+    if (err instanceof Error && err.message.includes("No snapshot"))
+      throw new BrowserError(err.message, "NO_SNAPSHOT");
+    throw new BrowserError(`clickRef ${ref} failed: ${err instanceof Error ? err.message : String(err)}`, "CLICK_REF_FAILED");
+  }
+}
+async function typeRef(page, sessionId, ref, text, opts) {
+  try {
+    const locator = getRefLocator(page, sessionId, ref);
+    if (opts?.clear)
+      await locator.fill("", { timeout: opts.timeout ?? 1e4 });
+    await locator.pressSequentially(text, { delay: opts?.delay, timeout: opts?.timeout ?? 1e4 });
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Ref "))
+      throw new ElementNotFoundError(ref);
+    throw new BrowserError(`typeRef ${ref} failed: ${err instanceof Error ? err.message : String(err)}`, "TYPE_REF_FAILED");
+  }
+}
+async function fillRef(page, sessionId, ref, value, timeout = 1e4) {
+  try {
+    const locator = getRefLocator(page, sessionId, ref);
+    await locator.fill(value, { timeout });
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Ref "))
+      throw new ElementNotFoundError(ref);
+    throw new BrowserError(`fillRef ${ref} failed: ${err instanceof Error ? err.message : String(err)}`, "FILL_REF_FAILED");
+  }
+}
+async function selectRef(page, sessionId, ref, value, timeout = 1e4) {
+  try {
+    const locator = getRefLocator(page, sessionId, ref);
+    return await locator.selectOption(value, { timeout });
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Ref "))
+      throw new ElementNotFoundError(ref);
+    throw new BrowserError(`selectRef ${ref} failed: ${err instanceof Error ? err.message : String(err)}`, "SELECT_REF_FAILED");
+  }
+}
+async function checkRef(page, sessionId, ref, checked, timeout = 1e4) {
+  try {
+    const locator = getRefLocator(page, sessionId, ref);
+    if (checked)
+      await locator.check({ timeout });
+    else
+      await locator.uncheck({ timeout });
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Ref "))
+      throw new ElementNotFoundError(ref);
+    throw new BrowserError(`checkRef ${ref} failed: ${err instanceof Error ? err.message : String(err)}`, "CHECK_REF_FAILED");
+  }
+}
+async function hoverRef(page, sessionId, ref, timeout = 1e4) {
+  try {
+    const locator = getRefLocator(page, sessionId, ref);
+    await locator.hover({ timeout });
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Ref "))
+      throw new ElementNotFoundError(ref);
+    throw new BrowserError(`hoverRef ${ref} failed: ${err instanceof Error ? err.message : String(err)}`, "HOVER_REF_FAILED");
+  }
+}
+var RETRYABLE_ERRORS, activeWatches;
+var init_actions = __esm(() => {
+  init_types();
+  init_snapshot();
+  RETRYABLE_ERRORS = ["Timeout", "timeout", "navigation", "net::ERR", "Target closed"];
+  activeWatches = new Map;
+});
+
+// node_modules/sharp/lib/is.js
+var require_is = __commonJS((exports, module) => {
+  /*!
+    Copyright 2013 Lovell Fuller and others.
+    SPDX-License-Identifier: Apache-2.0
+  */
+  var defined = (val) => typeof val !== "undefined" && val !== null;
+  var object = (val) => typeof val === "object";
+  var plainObject = (val) => Object.prototype.toString.call(val) === "[object Object]";
+  var fn = (val) => typeof val === "function";
+  var bool = (val) => typeof val === "boolean";
+  var buffer = (val) => val instanceof Buffer;
+  var typedArray = (val) => {
+    if (defined(val)) {
+      switch (val.constructor) {
+        case Uint8Array:
+        case Uint8ClampedArray:
+        case Int8Array:
+        case Uint16Array:
+        case Int16Array:
+        case Uint32Array:
+        case Int32Array:
+        case Float32Array:
+        case Float64Array:
+          return true;
+      }
+    }
+    return false;
+  };
+  var arrayBuffer = (val) => val instanceof ArrayBuffer;
+  var string = (val) => typeof val === "string" && val.length > 0;
+  var number = (val) => typeof val === "number" && !Number.isNaN(val);
+  var integer = (val) => Number.isInteger(val);
+  var inRange = (val, min, max) => val >= min && val <= max;
+  var inArray = (val, list) => list.includes(val);
+  var invalidParameterError = (name, expected, actual) => new Error(`Expected ${expected} for ${name} but received ${actual} of type ${typeof actual}`);
+  var nativeError = (native, context) => {
+    context.message = native.message;
+    return context;
+  };
+  module.exports = {
+    defined,
+    object,
+    plainObject,
+    fn,
+    bool,
+    buffer,
+    typedArray,
+    arrayBuffer,
+    string,
+    number,
+    integer,
+    inRange,
+    inArray,
+    invalidParameterError,
+    nativeError
+  };
+});
+
+// node_modules/detect-libc/lib/process.js
+var require_process = __commonJS((exports, module) => {
+  var isLinux = () => process.platform === "linux";
+  var report = null;
+  var getReport = () => {
+    if (!report) {
+      if (isLinux() && process.report) {
+        const orig = process.report.excludeNetwork;
+        process.report.excludeNetwork = true;
+        report = process.report.getReport();
+        process.report.excludeNetwork = orig;
+      } else {
+        report = {};
+      }
+    }
+    return report;
+  };
+  module.exports = { isLinux, getReport };
+});
+
+// node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var LDD_PATH = "/usr/bin/ldd";
+  var SELF_PATH = "/proc/self/exe";
+  var MAX_LENGTH = 2048;
+  var readFileSync2 = (path) => {
+    const fd = fs.openSync(path, "r");
+    const buffer = Buffer.alloc(MAX_LENGTH);
+    const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+    fs.close(fd, () => {});
+    return buffer.subarray(0, bytesRead);
+  };
+  var readFile = (path) => new Promise((resolve, reject) => {
+    fs.open(path, "r", (err, fd) => {
+      if (err) {
+        reject(err);
+      } else {
+        const buffer = Buffer.alloc(MAX_LENGTH);
+        fs.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          resolve(buffer.subarray(0, bytesRead));
+          fs.close(fd, () => {});
+        });
+      }
+    });
+  });
+  module.exports = {
+    LDD_PATH,
+    SELF_PATH,
+    readFileSync: readFileSync2,
+    readFile
+  };
+});
+
+// node_modules/detect-libc/lib/elf.js
+var require_elf = __commonJS((exports, module) => {
+  var interpreterPath = (elf) => {
+    if (elf.length < 64) {
+      return null;
+    }
+    if (elf.readUInt32BE(0) !== 2135247942) {
+      return null;
+    }
+    if (elf.readUInt8(4) !== 2) {
+      return null;
+    }
+    if (elf.readUInt8(5) !== 1) {
+      return null;
+    }
+    const offset = elf.readUInt32LE(32);
+    const size = elf.readUInt16LE(54);
+    const count = elf.readUInt16LE(56);
+    for (let i = 0;i < count; i++) {
+      const headerOffset = offset + i * size;
+      const type2 = elf.readUInt32LE(headerOffset);
+      if (type2 === 3) {
+        const fileOffset = elf.readUInt32LE(headerOffset + 8);
+        const fileSize = elf.readUInt32LE(headerOffset + 32);
+        return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, "");
+      }
+    }
+    return null;
+  };
+  module.exports = {
+    interpreterPath
   };
 });
 
@@ -13725,7 +14600,7 @@ var require_operation = __commonJS((exports, module) => {
 // node_modules/@img/colour/color.cjs
 var require_color = __commonJS((exports, module) => {
   var __defProp3 = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames3 = Object.getOwnPropertyNames;
   var __hasOwnProp3 = Object.prototype.hasOwnProperty;
   var __export3 = (target, all) => {
@@ -13736,16 +14611,16 @@ var require_color = __commonJS((exports, module) => {
     if (from && typeof from === "object" || typeof from === "function") {
       for (let key of __getOwnPropNames3(from))
         if (!__hasOwnProp3.call(to, key) && key !== except)
-          __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+          __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
     }
     return to;
   };
-  var __toCommonJS = (mod) => __copyProps(__defProp3({}, "__esModule", { value: true }), mod);
+  var __toCommonJS2 = (mod) => __copyProps(__defProp3({}, "__esModule", { value: true }), mod);
   var index_exports = {};
   __export3(index_exports, {
     default: () => index_default
   });
-  module.exports = __toCommonJS(index_exports);
+  module.exports = __toCommonJS2(index_exports);
   var colors = {
     aliceblue: [240, 248, 255],
     antiquewhite: [250, 235, 215],
@@ -17389,6 +18264,7 @@ function enableNetworkLogging(page, sessionId) {
     requestStart.clear();
   };
 }
+var HAR_MAX_ENTRIES = 5000;
 function startHAR(page) {
   const entries = [];
   const requestStart = new Map;
@@ -17427,7 +18303,8 @@ function startHAR(page) {
       },
       timings: { send: 0, wait: duration, receive: 0 }
     };
-    entries.push(entry);
+    if (entries.length < HAR_MAX_ENTRIES)
+      entries.push(entry);
   };
   const onRequestFailed = (req) => {
     requestStart.delete(req.url() + req.method());
@@ -17545,49 +18422,8 @@ async function applyStealthPatches(page) {
   });
 }
 
-// src/lib/dialogs.ts
-var pendingDialogs = new Map;
-var AUTO_DISMISS_MS = 5000;
-function setupDialogHandler(page, sessionId) {
-  const onDialog = (dialog) => {
-    const info = {
-      type: dialog.type(),
-      message: dialog.message(),
-      default_value: dialog.defaultValue(),
-      timestamp: new Date().toISOString()
-    };
-    const autoTimer = setTimeout(() => {
-      try {
-        dialog.dismiss().catch(() => {});
-      } catch {}
-      const list = pendingDialogs.get(sessionId);
-      if (list) {
-        const idx = list.findIndex((p) => p.dialog === dialog);
-        if (idx >= 0)
-          list.splice(idx, 1);
-        if (list.length === 0)
-          pendingDialogs.delete(sessionId);
-      }
-    }, AUTO_DISMISS_MS);
-    const pending = { dialog, info, autoTimer };
-    if (!pendingDialogs.has(sessionId)) {
-      pendingDialogs.set(sessionId, []);
-    }
-    pendingDialogs.get(sessionId).push(pending);
-  };
-  page.on("dialog", onDialog);
-  return () => {
-    page.off("dialog", onDialog);
-    const list = pendingDialogs.get(sessionId);
-    if (list) {
-      for (const p of list)
-        clearTimeout(p.autoTimer);
-      pendingDialogs.delete(sessionId);
-    }
-  };
-}
-
 // src/lib/session.ts
+init_dialogs();
 var handles = new Map;
 var pool = new BrowserPool(5);
 var SESSION_TTL_MS = parseInt(process.env["SESSION_TTL_MINUTES"] ?? "10", 10) * 60000;
@@ -17603,6 +18439,20 @@ var ttlInterval = setInterval(async () => {
 }, 60000);
 if (ttlInterval.unref)
   ttlInterval.unref();
+var DB_PRUNE_INTERVAL_MS = 30 * 60000;
+var DB_RETENTION_HOURS = 24;
+var dbPruneInterval = setInterval(() => {
+  try {
+    const { getDatabase: getDatabase2 } = (init_schema(), __toCommonJS(exports_schema));
+    const db = getDatabase2();
+    const cutoff = new Date(Date.now() - DB_RETENTION_HOURS * 3600000).toISOString();
+    db.prepare("DELETE FROM network_log WHERE session_id IN (SELECT id FROM sessions WHERE status != 'active') AND timestamp < ?").run(cutoff);
+    db.prepare("DELETE FROM console_log WHERE session_id IN (SELECT id FROM sessions WHERE status != 'active') AND timestamp < ?").run(cutoff);
+    db.prepare("DELETE FROM snapshots WHERE session_id IN (SELECT id FROM sessions WHERE status != 'active') AND timestamp < ?").run(cutoff);
+  } catch {}
+}, DB_PRUNE_INTERVAL_MS);
+if (dbPruneInterval.unref)
+  dbPruneInterval.unref();
 function createBunProxy(view) {
   return view;
 }
@@ -17781,142 +18631,27 @@ async function closeSession2(sessionId) {
     }
     handles.delete(sessionId);
   }
-  return closeSession(sessionId);
-}
-function listSessions2(filter) {
-  return listSessions(filter);
-}
-
-// src/lib/actions.ts
-init_types();
-
-// src/lib/snapshot.ts
-var lastSnapshots = new Map;
-var sessionRefMaps = new Map;
-
-// 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 };
-    }
+    const { clearLastSnapshot: clearLastSnapshot2, clearSessionRefs: clearSessionRefs2 } = await Promise.resolve().then(() => (init_snapshot(), exports_snapshot));
+    clearLastSnapshot2(sessionId);
+    clearSessionRefs2(sessionId);
   } 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 {
-    await page.click(selector, {
-      button: opts?.button ?? "left",
-      clickCount: opts?.clickCount ?? 1,
-      delay: opts?.delay,
-      timeout: opts?.timeout ?? 1e4
-    });
-    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}': ${originalError instanceof Error ? originalError.message : String(originalError)}`, "CLICK_FAILED");
-  }
-}
-async function type(page, selector, text, opts) {
+    const { stopAllWatchesForSession: stopAllWatchesForSession2 } = await Promise.resolve().then(() => (init_actions(), exports_actions));
+    stopAllWatchesForSession2(sessionId);
+  } catch {}
   try {
-    if (opts?.clear) {
-      await page.fill(selector, "", { timeout: opts?.timeout ?? 1e4 });
-    }
-    await page.type(selector, text, { delay: opts?.delay, timeout: opts?.timeout ?? 1e4 });
-    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}': ${originalError instanceof Error ? originalError.message : String(originalError)}`, "TYPE_FAILED");
-  }
-}
-async function scroll(page, direction = "down", amount = 300) {
-  const x = direction === "left" ? -amount : direction === "right" ? amount : 0;
-  const y = direction === "up" ? -amount : direction === "down" ? amount : 0;
-  await page.evaluate(({ x: x2, y: y2 }) => window.scrollBy(x2, y2), { x, y });
+    const { clearDialogs: clearDialogs2 } = await Promise.resolve().then(() => (init_dialogs(), exports_dialogs));
+    clearDialogs2(sessionId);
+  } catch {}
+  return closeSession(sessionId);
 }
-async function navigate(page, url, timeout = 30000) {
-  try {
-    await page.goto(url, { waitUntil: "domcontentloaded", timeout });
-  } catch (err) {
-    throw new NavigationError(url, err instanceof Error ? err.message : String(err));
-  }
+function listSessions2(filter) {
+  return listSessions(filter);
 }
-var activeWatches = new Map;
+
+// src/server/index.ts
+init_actions();
 
 // src/lib/extractor.ts
 async function getText(page, selector) {
@@ -18398,6 +19133,7 @@ async function crawl(startUrl, opts = {}) {
 
 // src/lib/recorder.ts
 init_recordings();
+init_actions();
 init_types();
 var activeRecordings = new Map;
 async function replayRecording(recordingId, page) {