@hasna/browser 0.0.1

package/dist/index.js

@@ -0,0 +1,2080 @@
+// @bun
+// 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/db/schema.ts
+import { Database } from "bun:sqlite";
+import { join } from "path";
+import { mkdirSync } from "fs";
+import { homedir } from "os";
+function getDataDir() {
+  return process.env["BROWSER_DATA_DIR"] ?? join(homedir(), ".browser");
+}
+var _db = null;
+var _dbPath = null;
+function getDatabase(path) {
+  const resolvedPath = path ?? process.env["BROWSER_DB_PATH"] ?? join(getDataDir(), "browser.db");
+  if (_db && _dbPath === resolvedPath)
+    return _db;
+  if (_db) {
+    try {
+      _db.close();
+    } catch {}
+    _db = null;
+  }
+  mkdirSync(join(resolvedPath, ".."), { recursive: true });
+  _db = new Database(resolvedPath);
+  _dbPath = resolvedPath;
+  _db.exec("PRAGMA journal_mode=WAL;");
+  _db.exec("PRAGMA foreign_keys=ON;");
+  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 (
+      version   INTEGER PRIMARY KEY,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  const applied = new Set(db.query("SELECT version FROM schema_migrations").all().map((r) => r.version));
+  const migrations = [
+    {
+      version: 1,
+      sql: `
+        CREATE TABLE IF NOT EXISTS projects (
+          id          TEXT PRIMARY KEY,
+          name        TEXT NOT NULL UNIQUE,
+          path        TEXT NOT NULL,
+          description TEXT,
+          created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS agents (
+          id          TEXT PRIMARY KEY,
+          name        TEXT NOT NULL,
+          description TEXT,
+          session_id  TEXT,
+          project_id  TEXT REFERENCES projects(id) ON DELETE SET NULL,
+          working_dir TEXT,
+          last_seen   TEXT NOT NULL DEFAULT (datetime('now')),
+          created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS heartbeats (
+          id         TEXT PRIMARY KEY,
+          agent_id   TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+          session_id TEXT,
+          timestamp  TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS sessions (
+          id         TEXT PRIMARY KEY,
+          engine     TEXT NOT NULL,
+          project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+          agent_id   TEXT REFERENCES agents(id) ON DELETE SET NULL,
+          start_url  TEXT,
+          status     TEXT NOT NULL DEFAULT 'active',
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          closed_at  TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS snapshots (
+          id              TEXT PRIMARY KEY,
+          session_id      TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          url             TEXT NOT NULL,
+          title           TEXT,
+          html            TEXT,
+          screenshot_path TEXT,
+          timestamp       TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS network_log (
+          id               TEXT PRIMARY KEY,
+          session_id       TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          method           TEXT NOT NULL,
+          url              TEXT NOT NULL,
+          status_code      INTEGER,
+          request_headers  TEXT,
+          response_headers TEXT,
+          request_body     TEXT,
+          body_size        INTEGER,
+          duration_ms      INTEGER,
+          resource_type    TEXT,
+          timestamp        TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS console_log (
+          id          TEXT PRIMARY KEY,
+          session_id  TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          level       TEXT NOT NULL DEFAULT 'log',
+          message     TEXT NOT NULL,
+          source      TEXT,
+          line_number INTEGER,
+          timestamp   TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS recordings (
+          id         TEXT PRIMARY KEY,
+          name       TEXT NOT NULL,
+          project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+          start_url  TEXT,
+          steps      TEXT NOT NULL DEFAULT '[]',
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS crawl_results (
+          id         TEXT PRIMARY KEY,
+          project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+          start_url  TEXT NOT NULL,
+          depth      INTEGER NOT NULL DEFAULT 1,
+          pages      TEXT NOT NULL DEFAULT '[]',
+          links      TEXT NOT NULL DEFAULT '[]',
+          errors     TEXT NOT NULL DEFAULT '[]',
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+        CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+        CREATE INDEX IF NOT EXISTS idx_snapshots_session ON snapshots(session_id);
+        CREATE INDEX IF NOT EXISTS idx_network_log_session ON network_log(session_id);
+        CREATE INDEX IF NOT EXISTS idx_console_log_session ON console_log(session_id);
+        CREATE INDEX IF NOT EXISTS idx_agents_project ON agents(project_id);
+        CREATE INDEX IF NOT EXISTS idx_heartbeats_agent ON heartbeats(agent_id);
+        CREATE INDEX IF NOT EXISTS idx_recordings_project ON recordings(project_id);
+        CREATE INDEX IF NOT EXISTS idx_crawl_results_project ON crawl_results(project_id);
+      `
+    }
+  ];
+  for (const m of migrations) {
+    if (!applied.has(m.version)) {
+      db.transaction(() => {
+        db.exec(m.sql);
+        db.prepare("INSERT INTO schema_migrations (version) VALUES (?)").run(m.version);
+      })();
+    }
+  }
+}
+// src/db/projects.ts
+import { randomUUID } from "crypto";
+function createProject(data) {
+  const db = getDatabase();
+  const id = randomUUID();
+  db.prepare("INSERT INTO projects (id, name, path, description) VALUES (?, ?, ?, ?)").run(id, data.name, data.path, data.description ?? null);
+  return getProject(id);
+}
+function ensureProject(name, path, description) {
+  const db = getDatabase();
+  const existing = db.query("SELECT * FROM projects WHERE name = ?").get(name);
+  if (existing)
+    return existing;
+  return createProject({ name, path, description });
+}
+function getProject(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM projects WHERE id = ?").get(id);
+  if (!row)
+    throw new ProjectNotFoundError(id);
+  return row;
+}
+function getProjectByName(name) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM projects WHERE name = ?").get(name) ?? null;
+}
+function listProjects() {
+  const db = getDatabase();
+  return db.query("SELECT * FROM projects ORDER BY created_at DESC").all();
+}
+function updateProject(id, data) {
+  const db = getDatabase();
+  const fields = [];
+  const values = [];
+  if (data.name !== undefined) {
+    fields.push("name = ?");
+    values.push(data.name);
+  }
+  if (data.path !== undefined) {
+    fields.push("path = ?");
+    values.push(data.path);
+  }
+  if (data.description !== undefined) {
+    fields.push("description = ?");
+    values.push(data.description ?? null);
+  }
+  if (fields.length === 0)
+    return getProject(id);
+  values.push(id);
+  db.prepare(`UPDATE projects SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+  return getProject(id);
+}
+function deleteProject(id) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM projects WHERE id = ?").run(id);
+}
+// src/db/agents.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function registerAgent(name, opts = {}) {
+  const db = getDatabase();
+  const existing = db.query("SELECT * FROM agents WHERE name = ?").get(name);
+  if (existing) {
+    db.prepare("UPDATE agents SET last_seen = datetime('now'), session_id = ?, project_id = ?, working_dir = ? WHERE name = ?").run(opts.sessionId ?? existing.session_id ?? null, opts.projectId ?? existing.project_id ?? null, opts.workingDir ?? existing.working_dir ?? null, name);
+    return getAgentByName(name);
+  }
+  const id = randomUUID2();
+  db.prepare("INSERT INTO agents (id, name, description, session_id, project_id, working_dir) VALUES (?, ?, ?, ?, ?, ?)").run(id, name, opts.description ?? null, opts.sessionId ?? null, opts.projectId ?? null, opts.workingDir ?? null);
+  return getAgent(id);
+}
+function heartbeat(agentId) {
+  const db = getDatabase();
+  const agent = db.query("SELECT * FROM agents WHERE id = ?").get(agentId);
+  if (!agent)
+    throw new AgentNotFoundError(agentId);
+  db.prepare("UPDATE agents SET last_seen = datetime('now') WHERE id = ?").run(agentId);
+  db.prepare("INSERT INTO heartbeats (id, agent_id, session_id) VALUES (?, ?, ?)").run(randomUUID2(), agentId, agent.session_id ?? null);
+}
+function getAgent(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM agents WHERE id = ?").get(id);
+  if (!row)
+    throw new AgentNotFoundError(id);
+  return row;
+}
+function getAgentByName(name) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM agents WHERE name = ?").get(name) ?? null;
+}
+function listAgents(projectId) {
+  const db = getDatabase();
+  if (projectId) {
+    return db.query("SELECT * FROM agents WHERE project_id = ? ORDER BY last_seen DESC").all(projectId);
+  }
+  return db.query("SELECT * FROM agents ORDER BY last_seen DESC").all();
+}
+function updateAgent(id, data) {
+  const db = getDatabase();
+  const fields = [];
+  const values = [];
+  if (data.name !== undefined) {
+    fields.push("name = ?");
+    values.push(data.name ?? null);
+  }
+  if (data.description !== undefined) {
+    fields.push("description = ?");
+    values.push(data.description ?? null);
+  }
+  if (data.session_id !== undefined) {
+    fields.push("session_id = ?");
+    values.push(data.session_id ?? null);
+  }
+  if (data.project_id !== undefined) {
+    fields.push("project_id = ?");
+    values.push(data.project_id ?? null);
+  }
+  if (data.working_dir !== undefined) {
+    fields.push("working_dir = ?");
+    values.push(data.working_dir ?? null);
+  }
+  if (fields.length === 0)
+    return getAgent(id);
+  values.push(id);
+  db.prepare(`UPDATE agents SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+  return getAgent(id);
+}
+function deleteAgent(id) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM agents WHERE id = ?").run(id);
+}
+function cleanStaleAgents(thresholdMs) {
+  const db = getDatabase();
+  const cutoff = new Date(Date.now() - thresholdMs).toISOString().replace("T", " ").split(".")[0];
+  const result = db.prepare("DELETE FROM agents WHERE last_seen < ?").run(cutoff);
+  return result.changes;
+}
+// src/db/sessions.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function createSession(data) {
+  const db = getDatabase();
+  const id = randomUUID3();
+  db.prepare("INSERT INTO sessions (id, engine, project_id, agent_id, start_url) VALUES (?, ?, ?, ?, ?)").run(id, data.engine, data.projectId ?? null, data.agentId ?? null, data.startUrl ?? null);
+  return getSession(id);
+}
+function getSession(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM sessions WHERE id = ?").get(id);
+  if (!row)
+    throw new SessionNotFoundError(id);
+  return row;
+}
+function listSessions(filter) {
+  const db = getDatabase();
+  const conditions = [];
+  const values = [];
+  if (filter?.status) {
+    conditions.push("status = ?");
+    values.push(filter.status);
+  }
+  if (filter?.projectId) {
+    conditions.push("project_id = ?");
+    values.push(filter.projectId);
+  }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  return db.query(`SELECT * FROM sessions ${where} ORDER BY created_at DESC`).all(...values);
+}
+function updateSessionStatus(id, status) {
+  const db = getDatabase();
+  const closedAt = status === "closed" || status === "error" ? "datetime('now')" : "NULL";
+  db.prepare(`UPDATE sessions SET status = ?, closed_at = ${closedAt === "NULL" ? "NULL" : "(datetime('now'))"} WHERE id = ?`).run(status, id);
+  return getSession(id);
+}
+function closeSession(id) {
+  return updateSessionStatus(id, "closed");
+}
+function deleteSession(id) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
+}
+// src/db/snapshots.ts
+import { randomUUID as randomUUID4 } from "crypto";
+function createSnapshot(data) {
+  const db = getDatabase();
+  const id = randomUUID4();
+  db.prepare("INSERT INTO snapshots (id, session_id, url, title, html, screenshot_path) VALUES (?, ?, ?, ?, ?, ?)").run(id, data.session_id, data.url, data.title ?? null, data.html ?? null, data.screenshot_path ?? null);
+  return getSnapshot(id);
+}
+function getSnapshot(id) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM snapshots WHERE id = ?").get(id) ?? null;
+}
+function listSnapshots(sessionId) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM snapshots WHERE session_id = ? ORDER BY timestamp DESC").all(sessionId);
+}
+function deleteSnapshot(id) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM snapshots WHERE id = ?").run(id);
+}
+function deleteSnapshotsBySession(sessionId) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM snapshots WHERE session_id = ?").run(sessionId);
+}
+// src/db/network-log.ts
+import { randomUUID as randomUUID5 } from "crypto";
+function logRequest(data) {
+  const db = getDatabase();
+  const id = randomUUID5();
+  db.prepare(`INSERT INTO network_log (id, session_id, method, url, status_code, request_headers,
+     response_headers, request_body, body_size, duration_ms, resource_type)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, data.session_id, data.method, data.url, data.status_code ?? null, data.request_headers ?? null, data.response_headers ?? null, data.request_body ?? null, data.body_size ?? null, data.duration_ms ?? null, data.resource_type ?? null);
+  return getNetworkRequest(id);
+}
+function getNetworkRequest(id) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM network_log WHERE id = ?").get(id) ?? null;
+}
+function getNetworkLog(sessionId) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM network_log WHERE session_id = ? ORDER BY timestamp ASC").all(sessionId);
+}
+function clearNetworkLog(sessionId) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM network_log WHERE session_id = ?").run(sessionId);
+}
+function deleteNetworkRequest(id) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM network_log WHERE id = ?").run(id);
+}
+// src/db/console-log.ts
+import { randomUUID as randomUUID6 } from "crypto";
+function logConsoleMessage(data) {
+  const db = getDatabase();
+  const id = randomUUID6();
+  db.prepare("INSERT INTO console_log (id, session_id, level, message, source, line_number) VALUES (?, ?, ?, ?, ?, ?)").run(id, data.session_id, data.level, data.message, data.source ?? null, data.line_number ?? null);
+  return getConsoleMessage(id);
+}
+function getConsoleMessage(id) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM console_log WHERE id = ?").get(id) ?? null;
+}
+function getConsoleLog(sessionId, level) {
+  const db = getDatabase();
+  if (level) {
+    return db.query("SELECT * FROM console_log WHERE session_id = ? AND level = ? ORDER BY timestamp ASC").all(sessionId, level);
+  }
+  return db.query("SELECT * FROM console_log WHERE session_id = ? ORDER BY timestamp ASC").all(sessionId);
+}
+function clearConsoleLog(sessionId) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM console_log WHERE session_id = ?").run(sessionId);
+}
+// src/db/recordings.ts
+import { randomUUID as randomUUID7 } from "crypto";
+function deserialize(row) {
+  return {
+    ...row,
+    project_id: row.project_id ?? undefined,
+    start_url: row.start_url ?? undefined,
+    steps: JSON.parse(row.steps)
+  };
+}
+function createRecording(data) {
+  const db = getDatabase();
+  const id = randomUUID7();
+  db.prepare("INSERT INTO recordings (id, name, project_id, start_url, steps) VALUES (?, ?, ?, ?, ?)").run(id, data.name, data.project_id ?? null, data.start_url ?? null, JSON.stringify(data.steps ?? []));
+  return getRecording(id);
+}
+function getRecording(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM recordings WHERE id = ?").get(id);
+  if (!row)
+    throw new RecordingNotFoundError(id);
+  return deserialize(row);
+}
+function listRecordings(projectId) {
+  const db = getDatabase();
+  const rows = projectId ? db.query("SELECT * FROM recordings WHERE project_id = ? ORDER BY created_at DESC").all(projectId) : db.query("SELECT * FROM recordings ORDER BY created_at DESC").all();
+  return rows.map(deserialize);
+}
+function updateRecording(id, data) {
+  const db = getDatabase();
+  const fields = [];
+  const values = [];
+  if (data.name !== undefined) {
+    fields.push("name = ?");
+    values.push(data.name);
+  }
+  if (data.steps !== undefined) {
+    fields.push("steps = ?");
+    values.push(JSON.stringify(data.steps));
+  }
+  if (data.start_url !== undefined) {
+    fields.push("start_url = ?");
+    values.push(data.start_url ?? null);
+  }
+  if (fields.length === 0)
+    return getRecording(id);
+  values.push(id);
+  db.prepare(`UPDATE recordings SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+  return getRecording(id);
+}
+function deleteRecording(id) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM recordings WHERE id = ?").run(id);
+}
+// src/db/crawl-results.ts
+import { randomUUID as randomUUID8 } from "crypto";
+function deserialize2(row) {
+  const pages = JSON.parse(row.pages);
+  return {
+    id: row.id,
+    project_id: row.project_id ?? undefined,
+    start_url: row.start_url,
+    depth: row.depth,
+    pages,
+    total_links: pages.reduce((acc, p) => acc + p.links.length, 0),
+    errors: JSON.parse(row.errors),
+    created_at: row.created_at
+  };
+}
+function createCrawlResult(data) {
+  const db = getDatabase();
+  const id = randomUUID8();
+  db.prepare("INSERT INTO crawl_results (id, project_id, start_url, depth, pages, links, errors) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, data.project_id ?? null, data.start_url, data.depth, JSON.stringify(data.pages), JSON.stringify(data.pages.flatMap((p) => p.links)), JSON.stringify(data.errors));
+  return getCrawlResult(id);
+}
+function getCrawlResult(id) {
+  const db = getDatabase();
+  const row = db.query("SELECT * FROM crawl_results WHERE id = ?").get(id);
+  return row ? deserialize2(row) : null;
+}
+function listCrawlResults(projectId) {
+  const db = getDatabase();
+  const rows = projectId ? db.query("SELECT * FROM crawl_results WHERE project_id = ? ORDER BY created_at DESC").all(projectId) : db.query("SELECT * FROM crawl_results ORDER BY created_at DESC").all();
+  return rows.map(deserialize2);
+}
+function deleteCrawlResult(id) {
+  const db = getDatabase();
+  db.prepare("DELETE FROM crawl_results WHERE id = ?").run(id);
+}
+// src/db/heartbeats.ts
+import { randomUUID as randomUUID9 } from "crypto";
+function recordHeartbeat(agentId, sessionId) {
+  const db = getDatabase();
+  const id = randomUUID9();
+  db.prepare("INSERT INTO heartbeats (id, agent_id, session_id) VALUES (?, ?, ?)").run(id, agentId, sessionId ?? null);
+  db.prepare("UPDATE agents SET last_seen = datetime('now') WHERE id = ?").run(agentId);
+  return getLastHeartbeat(agentId);
+}
+function getLastHeartbeat(agentId) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM heartbeats WHERE agent_id = ? ORDER BY timestamp DESC LIMIT 1").get(agentId) ?? null;
+}
+function listHeartbeats(agentId, limit = 50) {
+  const db = getDatabase();
+  return db.query("SELECT * FROM heartbeats WHERE agent_id = ? ORDER BY timestamp DESC LIMIT ?").all(agentId, limit);
+}
+function cleanOldHeartbeats(olderThanMs) {
+  const db = getDatabase();
+  const cutoff = new Date(Date.now() - olderThanMs).toISOString().replace("T", " ").split(".")[0];
+  const result = db.prepare("DELETE FROM heartbeats WHERE timestamp < ?").run(cutoff);
+  return result.changes;
+}
+// src/engines/playwright.ts
+import { chromium } from "playwright";
+var DEFAULT_VIEWPORT = { width: 1280, height: 720 };
+async function launchPlaywright(options) {
+  try {
+    return await chromium.launch({
+      headless: options?.headless ?? true,
+      executablePath: options?.executablePath
+    });
+  } catch (err) {
+    throw new BrowserError(`Failed to launch Playwright browser: ${err instanceof Error ? err.message : String(err)}`, "PLAYWRIGHT_LAUNCH_FAILED", true);
+  }
+}
+async function getPage(browser, options) {
+  const context = await browser.newContext({
+    viewport: options?.viewport ?? DEFAULT_VIEWPORT,
+    userAgent: options?.userAgent,
+    locale: options?.locale
+  });
+  return context.newPage();
+}
+async function closeBrowser(browser) {
+  try {
+    await browser.close();
+  } catch {}
+}
+async function closePage(page) {
+  try {
+    await page.context().close();
+  } catch {}
+}
+
+class BrowserPool {
+  pool = [];
+  maxSize;
+  options;
+  constructor(maxSize = 3, options) {
+    this.maxSize = maxSize;
+    this.options = options;
+  }
+  async acquire() {
+    const available = this.pool.find((e) => !e.inUse);
+    if (available) {
+      available.inUse = true;
+      return available.browser;
+    }
+    if (this.pool.length < this.maxSize) {
+      const browser = await launchPlaywright(this.options);
+      this.pool.push({ browser, inUse: true, createdAt: Date.now() });
+      return browser;
+    }
+    return new Promise((resolve) => {
+      const interval = setInterval(() => {
+        const free = this.pool.find((e) => !e.inUse);
+        if (free) {
+          clearInterval(interval);
+          free.inUse = true;
+          resolve(free.browser);
+        }
+      }, 100);
+    });
+  }
+  release(browser) {
+    const entry = this.pool.find((e) => e.browser === browser);
+    if (entry)
+      entry.inUse = false;
+  }
+  async destroyAll() {
+    await Promise.all(this.pool.map((e) => e.browser.close().catch(() => {})));
+    this.pool = [];
+  }
+  get size() {
+    return this.pool.length;
+  }
+  get available() {
+    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/engines/lightpanda.ts
+import { execSync, spawn } from "child_process";
+import { chromium as chromium2 } from "playwright";
+var DEFAULT_LIGHTPANDA_PORT = 9222;
+var LIGHTPANDA_BINARY = process.env["LIGHTPANDA_BINARY"] ?? "lightpanda";
+function isLightpandaAvailable() {
+  try {
+    execSync(`which ${LIGHTPANDA_BINARY}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    const paths = [
+      "/usr/local/bin/lightpanda",
+      "/usr/bin/lightpanda",
+      `${process.env["HOME"]}/.browser/bin/lightpanda`
+    ];
+    return paths.some((p) => {
+      try {
+        execSync(`test -x ${p}`, { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    });
+  }
+}
+function getLightpandaBinaryPath() {
+  if (process.env["LIGHTPANDA_BINARY"])
+    return process.env["LIGHTPANDA_BINARY"];
+  const paths = [
+    "lightpanda",
+    "/usr/local/bin/lightpanda",
+    "/usr/bin/lightpanda",
+    `${process.env["HOME"]}/.browser/bin/lightpanda`
+  ];
+  for (const p of paths) {
+    try {
+      execSync(`which ${p}`, { stdio: "ignore" });
+      return p;
+    } catch {
+      try {
+        execSync(`test -x ${p}`, { stdio: "ignore" });
+        return p;
+      } catch {
+        continue;
+      }
+    }
+  }
+  throw new EngineNotAvailableError("lightpanda", "binary not found. Run: browser install-browser --engine lightpanda");
+}
+var _lpProcess = null;
+async function launchLightpanda(port) {
+  if (_lpProcess)
+    return _lpProcess;
+  if (!isLightpandaAvailable()) {
+    throw new EngineNotAvailableError("lightpanda", "binary not found. Run: browser install-browser --engine lightpanda");
+  }
+  const usePort = port ?? DEFAULT_LIGHTPANDA_PORT;
+  const binary = getLightpandaBinaryPath();
+  const proc = spawn(binary, ["--cdp-host", "127.0.0.1", "--cdp-port", String(usePort)], {
+    stdio: "ignore",
+    detached: false
+  });
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new BrowserError("Lightpanda startup timeout", "LIGHTPANDA_TIMEOUT")), 5000);
+    const check = setInterval(async () => {
+      try {
+        const resp = await fetch(`http://127.0.0.1:${usePort}/json/version`);
+        if (resp.ok) {
+          clearInterval(check);
+          clearTimeout(timeout);
+          resolve();
+        }
+      } catch {}
+    }, 100);
+    proc.on("error", (err) => {
+      clearInterval(check);
+      clearTimeout(timeout);
+      reject(new BrowserError(`Lightpanda failed to start: ${err.message}`, "LIGHTPANDA_ERROR"));
+    });
+  });
+  _lpProcess = {
+    process: proc,
+    port: usePort,
+    wsUrl: `ws://127.0.0.1:${usePort}`
+  };
+  return _lpProcess;
+}
+async function connectLightpanda(port) {
+  const lp = await launchLightpanda(port);
+  try {
+    const resp = await fetch(`http://127.0.0.1:${lp.port}/json/version`);
+    const info = await resp.json();
+    const wsUrl = info.webSocketDebuggerUrl ?? `ws://127.0.0.1:${lp.port}`;
+    return await chromium2.connectOverCDP(wsUrl);
+  } catch (err) {
+    throw new BrowserError(`Failed to connect to Lightpanda: ${err instanceof Error ? err.message : String(err)}`, "LIGHTPANDA_CONNECT_FAILED");
+  }
+}
+function stopLightpanda() {
+  if (_lpProcess) {
+    _lpProcess.process.kill();
+    _lpProcess = null;
+  }
+}
+
+class LightpandaPage {
+  page;
+  constructor(page) {
+    this.page = page;
+  }
+  static async create(port) {
+    const browser = await connectLightpanda(port);
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    return new LightpandaPage(page);
+  }
+  async navigate(url) {
+    await this.page.goto(url, { waitUntil: "domcontentloaded" });
+  }
+  async getContent() {
+    return this.page.content();
+  }
+  async getTitle() {
+    return this.page.title();
+  }
+  async getLinks() {
+    return this.page.evaluate(() => Array.from(document.querySelectorAll("a[href]")).map((a) => a.href).filter((h) => h.startsWith("http")));
+  }
+  async getText(selector) {
+    if (selector) {
+      const el = await this.page.$(selector);
+      return el ? await el.textContent() ?? "" : "";
+    }
+    return this.page.evaluate(() => document.body.innerText ?? "");
+  }
+  get rawPage() {
+    return this.page;
+  }
+  async close() {
+    await this.page.context().close();
+  }
+}
+// src/engines/selector.ts
+var ENGINE_MAP = {
+  ["scrape" /* SCRAPE */]: "lightpanda",
+  ["extract_links" /* EXTRACT_LINKS */]: "lightpanda",
+  ["status_check" /* STATUS_CHECK */]: "lightpanda",
+  ["form_fill" /* FORM_FILL */]: "playwright",
+  ["spa_navigate" /* SPA_NAVIGATE */]: "playwright",
+  ["screenshot" /* SCREENSHOT */]: "playwright",
+  ["auth_flow" /* AUTH_FLOW */]: "playwright",
+  ["multi_tab" /* MULTI_TAB */]: "playwright",
+  ["record_replay" /* RECORD_REPLAY */]: "playwright",
+  ["network_monitor" /* NETWORK_MONITOR */]: "cdp",
+  ["har_capture" /* HAR_CAPTURE */]: "cdp",
+  ["perf_profile" /* PERF_PROFILE */]: "cdp",
+  ["script_inject" /* SCRIPT_INJECT */]: "cdp",
+  ["coverage" /* COVERAGE */]: "cdp"
+};
+function selectEngine(useCase, explicit) {
+  if (explicit && explicit !== "auto")
+    return explicit;
+  const preferred = ENGINE_MAP[useCase];
+  if (preferred === "lightpanda" && !isLightpandaAvailable()) {
+    return "playwright";
+  }
+  return preferred;
+}
+function isEngineAvailable(engine) {
+  if (engine === "auto")
+    return true;
+  if (engine === "playwright")
+    return true;
+  if (engine === "cdp")
+    return true;
+  if (engine === "lightpanda")
+    return isLightpandaAvailable();
+  return false;
+}
+function inferUseCase(label) {
+  const map = {
+    scrape: "scrape" /* SCRAPE */,
+    extract: "extract_links" /* EXTRACT_LINKS */,
+    links: "extract_links" /* EXTRACT_LINKS */,
+    status: "status_check" /* STATUS_CHECK */,
+    check: "status_check" /* STATUS_CHECK */,
+    form: "form_fill" /* FORM_FILL */,
+    fill: "form_fill" /* FORM_FILL */,
+    spa: "spa_navigate" /* SPA_NAVIGATE */,
+    navigate: "spa_navigate" /* SPA_NAVIGATE */,
+    screenshot: "screenshot" /* SCREENSHOT */,
+    auth: "auth_flow" /* AUTH_FLOW */,
+    login: "auth_flow" /* AUTH_FLOW */,
+    "multi-tab": "multi_tab" /* MULTI_TAB */,
+    tabs: "multi_tab" /* MULTI_TAB */,
+    network: "network_monitor" /* NETWORK_MONITOR */,
+    har: "har_capture" /* HAR_CAPTURE */,
+    perf: "perf_profile" /* PERF_PROFILE */,
+    performance: "perf_profile" /* PERF_PROFILE */,
+    inject: "script_inject" /* SCRIPT_INJECT */,
+    coverage: "coverage" /* COVERAGE */,
+    record: "record_replay" /* RECORD_REPLAY */,
+    replay: "record_replay" /* RECORD_REPLAY */
+  };
+  return map[label.toLowerCase()] ?? "spa_navigate" /* SPA_NAVIGATE */;
+}
+// src/lib/session.ts
+var handles = new Map;
+async function createSession2(opts = {}) {
+  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;
+  let page;
+  if (resolvedEngine === "lightpanda") {
+    browser = await connectLightpanda();
+    const context = await browser.newContext({ viewport: opts.viewport ?? { width: 1280, height: 720 } });
+    page = await context.newPage();
+  } else {
+    browser = await launchPlaywright({
+      headless: opts.headless ?? true,
+      viewport: opts.viewport,
+      userAgent: opts.userAgent
+    });
+    page = await getPage(browser, {
+      viewport: opts.viewport,
+      userAgent: opts.userAgent
+    });
+  }
+  const session = createSession({
+    engine: resolvedEngine,
+    projectId: opts.projectId,
+    agentId: opts.agentId,
+    startUrl: opts.startUrl
+  });
+  handles.set(session.id, { browser, page, engine: resolvedEngine });
+  if (opts.startUrl) {
+    try {
+      await page.goto(opts.startUrl, { waitUntil: "domcontentloaded" });
+    } catch (err) {}
+  }
+  return { session, page };
+}
+function getSessionPage(sessionId) {
+  const handle = handles.get(sessionId);
+  if (!handle)
+    throw new SessionNotFoundError(sessionId);
+  return handle.page;
+}
+function getSessionBrowser(sessionId) {
+  const handle = handles.get(sessionId);
+  if (!handle)
+    throw new SessionNotFoundError(sessionId);
+  return handle.browser;
+}
+function getSessionEngine(sessionId) {
+  const handle = handles.get(sessionId);
+  if (!handle)
+    throw new SessionNotFoundError(sessionId);
+  return handle.engine;
+}
+function hasActiveHandle(sessionId) {
+  return handles.has(sessionId);
+}
+async function closeSession2(sessionId) {
+  const handle = handles.get(sessionId);
+  if (handle) {
+    try {
+      await handle.page.context().close();
+    } catch {}
+    try {
+      await closeBrowser(handle.browser);
+    } catch {}
+    handles.delete(sessionId);
+  }
+  return closeSession(sessionId);
+}
+function listSessions2(filter) {
+  return listSessions(filter);
+}
+function getActiveSessions() {
+  return listSessions({ status: "active" });
+}
+async function closeAllSessions() {
+  for (const [id] of handles) {
+    await closeSession2(id).catch(() => {});
+  }
+}
+// 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
+    });
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("not found")) {
+      throw new ElementNotFoundError(selector);
+    }
+    throw new BrowserError(`Click failed on '${selector}': ${err instanceof Error ? err.message : String(err)}`, "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 });
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("not found")) {
+      throw new ElementNotFoundError(selector);
+    }
+    throw new BrowserError(`Type failed on '${selector}': ${err instanceof Error ? err.message : String(err)}`, "TYPE_FAILED");
+  }
+}
+async function fill(page, selector, value, timeout = 1e4) {
+  try {
+    await page.fill(selector, value, { timeout });
+  } catch (err) {
+    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);
+}
+// src/lib/extractor.ts
+async function getText(page, selector) {
+  if (selector) {
+    const el = await page.$(selector);
+    if (!el)
+      return "";
+    return await el.textContent() ?? "";
+  }
+  return page.evaluate(() => document.body.innerText ?? "");
+}
+async function getHTML(page, selector) {
+  if (selector) {
+    const el = await page.$(selector);
+    if (!el)
+      return "";
+    return await el.innerHTML() ?? "";
+  }
+  return page.content();
+}
+async function getLinks(page, baseUrl) {
+  return page.evaluate((base) => {
+    return Array.from(document.querySelectorAll("a[href]")).map((a) => {
+      const href = a.href;
+      if (!href)
+        return null;
+      if (href.startsWith("http"))
+        return href;
+      if (base && href.startsWith("/"))
+        return new URL(href, base).href;
+      return null;
+    }).filter((h) => h !== null);
+  }, baseUrl ?? page.url());
+}
+async function getTitle(page) {
+  return page.title();
+}
+async function getUrl(page) {
+  return page.url();
+}
+async function getMetaTags(page) {
+  return page.evaluate(() => {
+    const meta = {};
+    document.querySelectorAll("meta[name], meta[property]").forEach((el) => {
+      const key = el.getAttribute("name") ?? el.getAttribute("property") ?? "";
+      const value = el.getAttribute("content") ?? "";
+      if (key)
+        meta[key] = value;
+    });
+    return meta;
+  });
+}
+async function findElements(page, selector) {
+  return page.$$(selector);
+}
+async function extractStructured(page, schema) {
+  const result = {};
+  for (const [field, selector] of Object.entries(schema)) {
+    const elements = await page.$$(selector);
+    if (elements.length === 0) {
+      result[field] = "";
+    } else if (elements.length === 1) {
+      result[field] = (await elements[0].textContent())?.trim() ?? "";
+    } else {
+      result[field] = await Promise.all(elements.map(async (el) => (await el.textContent())?.trim() ?? ""));
+    }
+  }
+  return result;
+}
+async function extractTable(page, selector) {
+  return page.evaluate((sel) => {
+    const table = document.querySelector(sel);
+    if (!table)
+      return [];
+    const rows = Array.from(table.querySelectorAll("tr"));
+    return rows.map((row) => Array.from(row.querySelectorAll("th, td")).map((cell) => cell.textContent?.trim() ?? ""));
+  }, selector);
+}
+async function getAriaSnapshot(page) {
+  try {
+    return await page.ariaSnapshot?.() ?? page.evaluate(() => {
+      function walk(el, indent = 0) {
+        const role = el.getAttribute("role") ?? el.tagName.toLowerCase();
+        const label = el.getAttribute("aria-label") ?? el.getAttribute("aria-labelledby") ?? el.textContent?.trim().slice(0, 50) ?? "";
+        const line = "  ".repeat(indent) + `[${role}] ${label}`;
+        const children = Array.from(el.children).map((c) => walk(c, indent + 1)).join(`
+`);
+        return children ? `${line}
+${children}` : line;
+      }
+      return walk(document.body);
+    });
+  } catch {
+    return page.evaluate(() => document.body.innerText?.slice(0, 2000) ?? "");
+  }
+}
+async function extract(page, opts = {}) {
+  const result = {};
+  const format = opts.format ?? "text";
+  switch (format) {
+    case "text":
+      result.text = await getText(page, opts.selector);
+      break;
+    case "html":
+      result.html = await getHTML(page, opts.selector);
+      break;
+    case "links":
+      result.links = await getLinks(page);
+      break;
+    case "table":
+      result.table = opts.selector ? await extractTable(page, opts.selector) : [];
+      break;
+    case "structured":
+      if (opts.schema)
+        result.structured = await extractStructured(page, opts.schema);
+      break;
+  }
+  return result;
+}
+// src/lib/network.ts
+function enableNetworkLogging(page, sessionId) {
+  const requestStart = new Map;
+  const onRequest = (req) => {
+    requestStart.set(req.url(), Date.now());
+  };
+  const onResponse = (res) => {
+    const start = requestStart.get(res.url()) ?? Date.now();
+    const duration = Date.now() - start;
+    const req = res.request();
+    try {
+      logRequest({
+        session_id: sessionId,
+        method: req.method(),
+        url: res.url(),
+        status_code: res.status(),
+        request_headers: JSON.stringify(req.headers()),
+        response_headers: JSON.stringify(res.headers()),
+        body_size: res.headers()["content-length"] != null ? parseInt(res.headers()["content-length"]) : undefined,
+        duration_ms: duration,
+        resource_type: req.resourceType()
+      });
+    } catch {}
+  };
+  page.on("request", onRequest);
+  page.on("response", onResponse);
+  return () => {
+    page.off("request", onRequest);
+    page.off("response", onResponse);
+  };
+}
+async function addInterceptRule(page, rule) {
+  await page.route(rule.pattern, async (route) => {
+    if (rule.action === "block") {
+      await route.abort();
+    } else if (rule.action === "modify" && rule.response) {
+      await route.fulfill({
+        status: rule.response.status,
+        body: rule.response.body,
+        headers: rule.response.headers
+      });
+    } else {
+      await route.continue();
+    }
+  });
+}
+async function clearInterceptRules(page) {
+  await page.unrouteAll();
+}
+function startHAR(page) {
+  const entries = [];
+  const requestStart = new Map;
+  const onRequest = (req) => {
+    requestStart.set(req.url() + req.method(), {
+      time: Date.now(),
+      method: req.method(),
+      headers: req.headers(),
+      postData: req.postData() ?? undefined
+    });
+  };
+  const onResponse = async (res) => {
+    const key = res.url() + res.request().method();
+    const start = requestStart.get(key);
+    if (!start)
+      return;
+    const duration = Date.now() - start.time;
+    const entry = {
+      startedDateTime: new Date(start.time).toISOString(),
+      time: duration,
+      request: {
+        method: start.method,
+        url: res.url(),
+        headers: Object.entries(start.headers).map(([name, value]) => ({ name, value })),
+        postData: start.postData ? { text: start.postData } : undefined
+      },
+      response: {
+        status: res.status(),
+        statusText: res.statusText(),
+        headers: Object.entries(res.headers()).map(([name, value]) => ({ name, value })),
+        content: {
+          size: parseInt(res.headers()["content-length"] ?? "0") || 0,
+          mimeType: res.headers()["content-type"] ?? "application/octet-stream"
+        }
+      },
+      timings: { send: 0, wait: duration, receive: 0 }
+    };
+    entries.push(entry);
+    requestStart.delete(key);
+  };
+  page.on("request", onRequest);
+  page.on("response", onResponse);
+  return {
+    entries,
+    stop: () => {
+      page.off("request", onRequest);
+      page.off("response", onResponse);
+      return {
+        log: {
+          version: "1.2",
+          creator: { name: "@hasna/browser", version: "0.0.1" },
+          entries
+        }
+      };
+    }
+  };
+}
+// src/lib/performance.ts
+async function getPerformanceMetrics(page) {
+  const navTiming = await page.evaluate(() => {
+    const t = performance.timing;
+    const nav = performance.getEntriesByType("navigation")[0];
+    return {
+      ttfb: nav ? nav.responseStart - nav.requestStart : t.responseStart - t.requestStart,
+      domInteractive: nav ? nav.domInteractive : t.domInteractive - t.navigationStart,
+      domComplete: nav ? nav.domComplete : t.domComplete - t.navigationStart,
+      loadEvent: nav ? nav.loadEventEnd : t.loadEventEnd - t.navigationStart
+    };
+  });
+  const paintEntries = await page.evaluate(() => {
+    const entries = performance.getEntriesByType("paint");
+    const fcp = entries.find((e) => e.name === "first-contentful-paint");
+    return { fcp: fcp?.startTime };
+  });
+  let heapMetrics = {};
+  try {
+    const cdp = await CDPClient.fromPage(page);
+    const cdpMetrics = await cdp.getPerformanceMetrics();
+    heapMetrics = {
+      js_heap_size_used: cdpMetrics.js_heap_size_used,
+      js_heap_size_total: cdpMetrics.js_heap_size_total
+    };
+  } catch {}
+  return {
+    fcp: paintEntries.fcp,
+    ttfb: navTiming.ttfb,
+    dom_interactive: navTiming.domInteractive,
+    dom_complete: navTiming.domComplete,
+    load_event: navTiming.loadEvent,
+    ...heapMetrics
+  };
+}
+async function getMemoryUsage(page) {
+  try {
+    const cdp = await CDPClient.fromPage(page);
+    const metrics = await cdp.getPerformanceMetrics();
+    return {
+      used: metrics.js_heap_size_used ?? 0,
+      total: metrics.js_heap_size_total ?? 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function getTimingEntries(page) {
+  return page.evaluate(() => performance.getEntriesByType("resource").map((e) => e.toJSON()));
+}
+async function startCoverage(page) {
+  const [jsCoverage, cssCoverage] = await Promise.all([
+    page.coverage.startJSCoverage(),
+    page.coverage.startCSSCoverage()
+  ]);
+  return {
+    stop: async () => {
+      const [jsEntries, cssEntries] = await Promise.all([
+        page.coverage.stopJSCoverage(),
+        page.coverage.stopCSSCoverage()
+      ]);
+      const jsFlat = jsEntries.map((e) => {
+        const text = e.source ?? "";
+        const ranges = e.functions.flatMap((f) => f.ranges.filter((r) => r.count > 0).map((r) => ({ start: r.startOffset, end: r.endOffset })));
+        return { url: e.url, text, ranges };
+      });
+      const cssFlat = cssEntries.map((e) => ({
+        url: e.url,
+        text: e.text ?? "",
+        ranges: e.ranges.map((r) => ({ start: r.start, end: r.end }))
+      }));
+      const totalJs = jsFlat.reduce((acc, e) => acc + e.text.length, 0);
+      const usedJs = jsFlat.reduce((acc, e) => acc + e.ranges.reduce((s, r) => s + (r.end - r.start), 0), 0);
+      const totalCss = cssFlat.reduce((acc, e) => acc + e.text.length, 0);
+      const usedCss = cssFlat.reduce((acc, e) => acc + e.ranges.reduce((s, r) => s + (r.end - r.start), 0), 0);
+      const totalBytes = totalJs + totalCss;
+      const usedBytes = usedJs + usedCss;
+      return {
+        js: jsFlat,
+        css: cssFlat,
+        totalBytes,
+        usedBytes,
+        unusedPercent: totalBytes > 0 ? (totalBytes - usedBytes) / totalBytes * 100 : 0
+      };
+    }
+  };
+}
+// src/lib/console.ts
+function enableConsoleCapture(page, sessionId) {
+  const onConsole = (msg) => {
+    const levelMap = {
+      log: "log",
+      warn: "warn",
+      error: "error",
+      debug: "debug",
+      info: "info",
+      warning: "warn"
+    };
+    const level = levelMap[msg.type()] ?? "log";
+    const location = msg.location();
+    try {
+      logConsoleMessage({
+        session_id: sessionId,
+        level,
+        message: msg.text(),
+        source: location.url || undefined,
+        line_number: location.lineNumber || undefined
+      });
+    } catch {}
+  };
+  page.on("console", onConsole);
+  return () => page.off("console", onConsole);
+}
+async function capturePageErrors(page, sessionId) {
+  const onError = (err) => {
+    try {
+      logConsoleMessage({
+        session_id: sessionId,
+        level: "error",
+        message: `[Page Error] ${err.message}`,
+        source: err.stack?.split(`
+`)[1]?.trim()
+      });
+    } catch {}
+  };
+  page.on("pageerror", onError);
+  return () => page.off("pageerror", onError);
+}
+// src/lib/screenshot.ts
+import { join as join2 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+var DATA_DIR = process.env["BROWSER_DATA_DIR"] ?? join2(homedir2(), ".browser");
+function getScreenshotDir(projectId) {
+  const base = join2(DATA_DIR, "screenshots");
+  const date = new Date().toISOString().split("T")[0];
+  const dir = projectId ? join2(base, projectId, date) : join2(base, date);
+  mkdirSync2(dir, { recursive: true });
+  return dir;
+}
+async function takeScreenshot(page, opts) {
+  try {
+    const dir = getScreenshotDir(opts?.projectId);
+    const timestamp = Date.now();
+    const format = opts?.format ?? "png";
+    const screenshotPath = opts?.path ?? join2(dir, `${timestamp}.${format}`);
+    const screenshotOpts = {
+      path: screenshotPath,
+      fullPage: opts?.fullPage ?? false,
+      type: format === "webp" ? "jpeg" : format,
+      quality: format === "jpeg" || format === "webp" ? opts?.quality ?? 90 : undefined
+    };
+    let buffer;
+    if (opts?.selector) {
+      const el = await page.$(opts.selector);
+      if (!el)
+        throw new BrowserError(`Element not found: ${opts.selector}`, "ELEMENT_NOT_FOUND");
+      buffer = await el.screenshot({ ...screenshotOpts });
+    } else {
+      buffer = await page.screenshot(screenshotOpts);
+    }
+    const viewportSize = page.viewportSize() ?? { width: 1280, height: 720 };
+    return {
+      path: screenshotPath,
+      base64: buffer.toString("base64"),
+      width: viewportSize.width,
+      height: viewportSize.height,
+      size_bytes: buffer.length
+    };
+  } catch (err) {
+    if (err instanceof BrowserError)
+      throw err;
+    throw new BrowserError(`Screenshot failed: ${err instanceof Error ? err.message : String(err)}`, "SCREENSHOT_FAILED");
+  }
+}
+async function generatePDF(page, opts) {
+  try {
+    const base = join2(DATA_DIR, "pdfs");
+    const date = new Date().toISOString().split("T")[0];
+    const dir = opts?.projectId ? join2(base, opts.projectId, date) : join2(base, date);
+    mkdirSync2(dir, { recursive: true });
+    const timestamp = Date.now();
+    const pdfPath = opts?.path ?? join2(dir, `${timestamp}.pdf`);
+    const buffer = await page.pdf({
+      path: pdfPath,
+      format: opts?.format ?? "A4",
+      landscape: opts?.landscape ?? false,
+      margin: opts?.margin,
+      printBackground: opts?.printBackground ?? true
+    });
+    return {
+      path: pdfPath,
+      base64: buffer.toString("base64"),
+      size_bytes: buffer.length
+    };
+  } catch (err) {
+    throw new BrowserError(`PDF generation failed: ${err instanceof Error ? err.message : String(err)}`, "PDF_FAILED");
+  }
+}
+// src/lib/storage.ts
+async function getCookies(page, filter) {
+  const cookies = await page.context().cookies();
+  if (filter?.name)
+    return cookies.filter((c) => c.name === filter.name);
+  if (filter?.domain)
+    return cookies.filter((c) => c.domain?.includes(filter.domain));
+  return cookies;
+}
+async function setCookie(page, cookie) {
+  await page.context().addCookies([cookie]);
+}
+async function clearCookies(page, filter) {
+  if (!filter) {
+    await page.context().clearCookies();
+    return;
+  }
+  const existing = await getCookies(page, filter);
+  for (const cookie of existing) {
+    await page.context().addCookies([{ ...cookie, expires: 0 }]);
+  }
+}
+async function getLocalStorage(page, key) {
+  return page.evaluate((k) => {
+    if (k)
+      return localStorage.getItem(k);
+    const result = {};
+    for (let i = 0;i < localStorage.length; i++) {
+      const itemKey = localStorage.key(i);
+      result[itemKey] = localStorage.getItem(itemKey);
+    }
+    return result;
+  }, key ?? null);
+}
+async function setLocalStorage(page, key, value) {
+  await page.evaluate(([k, v]) => localStorage.setItem(k, v), [key, value]);
+}
+async function clearLocalStorage(page) {
+  await page.evaluate(() => localStorage.clear());
+}
+async function getSessionStorage(page, key) {
+  return page.evaluate((k) => {
+    if (k)
+      return sessionStorage.getItem(k);
+    const result = {};
+    for (let i = 0;i < sessionStorage.length; i++) {
+      const itemKey = sessionStorage.key(i);
+      result[itemKey] = sessionStorage.getItem(itemKey);
+    }
+    return result;
+  }, key ?? null);
+}
+async function setSessionStorage(page, key, value) {
+  await page.evaluate(([k, v]) => sessionStorage.setItem(k, v), [key, value]);
+}
+async function clearSessionStorage(page) {
+  await page.evaluate(() => sessionStorage.clear());
+}
+async function getIndexedDB(page, dbName, storeName) {
+  return page.evaluate(([db, store]) => new Promise((resolve, reject) => {
+    const req = indexedDB.open(db);
+    req.onsuccess = () => {
+      const database = req.result;
+      const tx = database.transaction(store, "readonly");
+      const objectStore = tx.objectStore(store);
+      const all = objectStore.getAll();
+      all.onsuccess = () => resolve(all.result);
+      all.onerror = () => reject(all.error);
+    };
+    req.onerror = () => reject(req.error);
+  }), [dbName, storeName]);
+}
+// src/lib/recorder.ts
+var activeRecordings = new Map;
+function startRecording(sessionId, name, startUrl) {
+  const steps = [];
+  const recording = createRecording({ name, start_url: startUrl, steps });
+  activeRecordings.set(recording.id, {
+    id: recording.id,
+    steps,
+    cleanup: () => {}
+  });
+  return recording;
+}
+function attachPageListeners(page, recordingId) {
+  const active = activeRecordings.get(recordingId);
+  if (!active)
+    throw new BrowserError(`No active recording: ${recordingId}`, "RECORDING_NOT_ACTIVE");
+  const onFrameNav = () => {
+    active.steps.push({
+      type: "navigate",
+      url: page.url(),
+      timestamp: Date.now()
+    });
+  };
+  page.on("framenavigated", onFrameNav);
+  const cleanup = () => {
+    page.off("framenavigated", onFrameNav);
+  };
+  active.cleanup = cleanup;
+}
+function recordStep(recordingId, step) {
+  const active = activeRecordings.get(recordingId);
+  if (!active)
+    throw new BrowserError(`No active recording: ${recordingId}`, "RECORDING_NOT_ACTIVE");
+  active.steps.push({ ...step, timestamp: Date.now() });
+}
+function stopRecording(recordingId) {
+  const active = activeRecordings.get(recordingId);
+  if (!active)
+    throw new BrowserError(`No active recording: ${recordingId}`, "RECORDING_NOT_ACTIVE");
+  active.cleanup();
+  activeRecordings.delete(recordingId);
+  return updateRecording(recordingId, { steps: active.steps });
+}
+async function replayRecording(recordingId, page) {
+  const recording = getRecording(recordingId);
+  const startTime = Date.now();
+  let executed = 0;
+  let failed = 0;
+  const errors = [];
+  for (const step of recording.steps) {
+    try {
+      switch (step.type) {
+        case "navigate":
+          if (step.url)
+            await navigate(page, step.url);
+          break;
+        case "click":
+          if (step.selector)
+            await click(page, step.selector);
+          break;
+        case "type":
+          if (step.selector && step.value)
+            await type(page, step.selector, step.value);
+          break;
+        case "scroll":
+          await scroll(page, "down");
+          break;
+        case "hover":
+          if (step.selector) {
+            const el = await page.$(step.selector);
+            if (el)
+              await el.hover();
+          }
+          break;
+        case "evaluate":
+          if (step.value)
+            await page.evaluate(step.value);
+          break;
+        case "wait":
+          if (step.selector) {
+            await page.waitForSelector(step.selector, { timeout: 1e4 }).catch(() => {});
+          }
+          break;
+      }
+      executed++;
+    } catch (err) {
+      failed++;
+      errors.push(`Step ${step.type} failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return {
+    recording_id: recordingId,
+    success: failed === 0,
+    steps_executed: executed,
+    steps_failed: failed,
+    errors,
+    duration_ms: Date.now() - startTime
+  };
+}
+function exportRecording(recordingId, format = "json") {
+  const recording = getRecording(recordingId);
+  if (format === "json") {
+    return JSON.stringify(recording, null, 2);
+  }
+  if (format === "playwright") {
+    const lines2 = [
+      `import { test, expect } from '@playwright/test';`,
+      ``,
+      `test('${recording.name}', async ({ page }) => {`
+    ];
+    for (const step of recording.steps) {
+      switch (step.type) {
+        case "navigate":
+          lines2.push(`  await page.goto('${step.url}');`);
+          break;
+        case "click":
+          lines2.push(`  await page.click('${step.selector}');`);
+          break;
+        case "type":
+          lines2.push(`  await page.type('${step.selector}', '${step.value}');`);
+          break;
+        case "scroll":
+          lines2.push(`  await page.evaluate(() => window.scrollBy(0, 300));`);
+          break;
+        case "evaluate":
+          lines2.push(`  await page.evaluate(${step.value});`);
+          break;
+      }
+    }
+    lines2.push(`});`);
+    return lines2.join(`
+`);
+  }
+  const lines = [
+    `const puppeteer = require('puppeteer');`,
+    ``,
+    `(async () => {`,
+    `  const browser = await puppeteer.launch();`,
+    `  const page = await browser.newPage();`
+  ];
+  for (const step of recording.steps) {
+    switch (step.type) {
+      case "navigate":
+        lines.push(`  await page.goto('${step.url}');`);
+        break;
+      case "click":
+        lines.push(`  await page.click('${step.selector}');`);
+        break;
+      case "type":
+        lines.push(`  await page.type('${step.selector}', '${step.value}');`);
+        break;
+    }
+  }
+  lines.push(`  await browser.close();`, `})();`);
+  return lines.join(`
+`);
+}
+// src/lib/crawler.ts
+async function crawl(startUrl, opts = {}) {
+  const maxDepth = opts.maxDepth ?? 2;
+  const maxPages = opts.maxPages ?? 50;
+  const sameDomain = opts.sameDomain ?? true;
+  const engine = selectEngine("extract_links" /* EXTRACT_LINKS */, opts.engine);
+  const startDomain = new URL(startUrl).hostname;
+  const visited = new Set;
+  const pages = [];
+  const errors = [];
+  let browser;
+  if (engine === "lightpanda") {
+    browser = await connectLightpanda();
+  } else {
+    browser = await launchPlaywright({ headless: true });
+  }
+  const context = await browser.newContext({ viewport: { width: 1280, height: 720 } });
+  async function crawlPage(url, depth) {
+    if (depth > maxDepth || pages.length >= maxPages || visited.has(url))
+      return;
+    if (sameDomain && new URL(url).hostname !== startDomain)
+      return;
+    if (opts.filter && !opts.filter(url))
+      return;
+    visited.add(url);
+    const page = await context.newPage();
+    const crawled = { url, depth, links: [], error: undefined };
+    try {
+      const response = await page.goto(url, { waitUntil: "domcontentloaded", timeout: 15000 });
+      crawled.title = await page.title();
+      crawled.status_code = response?.status();
+      crawled.links = await getLinks(page, url);
+      pages.push(crawled);
+      await page.close();
+      for (const link of crawled.links) {
+        if (pages.length >= maxPages)
+          break;
+        await crawlPage(link, depth + 1);
+      }
+    } catch (err) {
+      crawled.error = err instanceof Error ? err.message : String(err);
+      errors.push(`${url}: ${crawled.error}`);
+      pages.push(crawled);
+      await page.close().catch(() => {});
+    }
+  }
+  try {
+    await crawlPage(startUrl, 0);
+  } finally {
+    await browser.close().catch(() => {});
+  }
+  const result = createCrawlResult({
+    project_id: opts.projectId,
+    start_url: startUrl,
+    depth: maxDepth,
+    pages,
+    errors
+  });
+  return result;
+}
+// src/lib/agents.ts
+function registerAgent2(name, opts = {}) {
+  return registerAgent(name, opts);
+}
+function heartbeat2(agentId) {
+  heartbeat(agentId);
+}
+function isAgentStale(agent, thresholdMs = 5 * 60 * 1000) {
+  const lastSeen = new Date(agent.last_seen).getTime();
+  return Date.now() - lastSeen > thresholdMs;
+}
+function getActiveAgents(thresholdMs = 5 * 60 * 1000) {
+  return listAgents().filter((a) => !isAgentStale(a, thresholdMs));
+}
+export {
+  waitForSelector,
+  waitForNavigation,
+  uploadFile,
+  updateSessionStatus,
+  updateRecording,
+  updateProject,
+  updateAgent,
+  type,
+  takeScreenshot,
+  stopRecording,
+  stopLightpanda,
+  startRecording,
+  startHAR,
+  startCoverage,
+  setSessionStorage,
+  setLocalStorage,
+  setCookie,
+  selectOption,
+  selectEngine,
+  scrollTo,
+  scroll,
+  resetDatabase,
+  replayRecording,
+  reload,
+  registerAgent2 as registerAgent,
+  recordStep,
+  recordHeartbeat,
+  pressKey,
+  navigate,
+  logRequest,
+  logConsoleMessage,
+  listSnapshots,
+  listSessions2 as listSessions,
+  listRecordings,
+  listProjects,
+  listHeartbeats,
+  listCrawlResults,
+  listAgents,
+  launchPlaywright,
+  launchLightpanda,
+  isLightpandaAvailable,
+  isEngineAvailable,
+  isAgentStale,
+  inferUseCase,
+  hover,
+  heartbeat2 as heartbeat,
+  hasActiveHandle,
+  goForward,
+  goBack,
+  getUrl,
+  getTitle,
+  getTimingEntries,
+  getText,
+  getSnapshot,
+  getSessionStorage,
+  getSessionPage,
+  getSessionEngine,
+  getSessionBrowser,
+  getSession,
+  getRecording,
+  getProjectByName,
+  getProject,
+  getPerformanceMetrics,
+  getPage,
+  getNetworkRequest,
+  getNetworkLog,
+  getMetaTags,
+  getMemoryUsage,
+  getLocalStorage,
+  getLinks,
+  getLightpandaBinaryPath,
+  getLastHeartbeat,
+  getIndexedDB,
+  getHTML,
+  getDatabase,
+  getDataDir,
+  getCrawlResult,
+  getCookies,
+  getConsoleMessage,
+  getConsoleLog,
+  getAriaSnapshot,
+  getAgentByName,
+  getAgent,
+  getActiveSessions,
+  getActiveAgents,
+  generatePDF,
+  findElements,
+  fill,
+  extractTable,
+  extractStructured,
+  extract,
+  exportRecording,
+  ensureProject,
+  enableNetworkLogging,
+  enableConsoleCapture,
+  deleteSnapshotsBySession,
+  deleteSnapshot,
+  deleteSession,
+  deleteRecording,
+  deleteProject,
+  deleteNetworkRequest,
+  deleteCrawlResult,
+  deleteAgent,
+  registerAgent as dbRegisterAgent,
+  listSessions as dbListSessions,
+  listRecordings as dbListRecordings,
+  listAgents as dbListAgents,
+  heartbeat as dbHeartbeat,
+  createSession as dbCreateSession,
+  closeSession as dbCloseSession,
+  createSnapshot,
+  createSession2 as createSession,
+  createRecording,
+  createProject,
+  createCrawlResult,
+  crawl,
+  connectLightpanda,
+  closeSession2 as closeSession,
+  closePage,
+  closeBrowser,
+  closeAllSessions,
+  click,
+  clearSessionStorage,
+  clearNetworkLog,
+  clearLocalStorage,
+  clearInterceptRules,
+  clearCookies,
+  clearConsoleLog,
+  cleanStaleAgents,
+  cleanOldHeartbeats,
+  checkBox,
+  capturePageErrors,
+  attachPageListeners,
+  addInterceptRule,
+  UseCase,
+  SessionNotFoundError,
+  RecordingNotFoundError,
+  ProjectNotFoundError,
+  NavigationError,
+  LightpandaPage,
+  EngineNotAvailableError,
+  ElementNotFoundError,
+  CDPClient,
+  BrowserPool,
+  BrowserError,
+  AgentNotFoundError
+};