opensteer 0.6.0 → 0.6.2

package/dist/{chunk-SGZYTGY3.js → chunk-F2VDVOJO.js}

@@ -1,263 +1,515 @@
+import {
+  OpensteerCloudError,
+  cloudNotLaunchedError,
+  cloudUnsupportedMethodError,
+  createCloudRuntimeState,
+  createKeychainStore,
+  extractErrorMessage,
+  normalizeError,
+  normalizeNamespace,
+  readCloudActionDescription,
+  resolveCloudSelection,
+  resolveConfigWithEnv,
+  resolveNamespace,
+  resolveNamespaceDir
+} from "./chunk-WDRMHPWL.js";
 import {
   flattenExtractionDataToFieldPlan
 } from "./chunk-3H5RRIMZ.js";
 
-// src/error-normalization.ts
-function extractErrorMessage(error, fallback = "Unknown error.") {
-  if (error instanceof Error) {
-    const message = error.message.trim();
-    if (message) return message;
-    const name = error.name.trim();
-    if (name) return name;
+// src/browser/chrome.ts
+import { homedir, platform } from "os";
+import { join } from "path";
+function expandHome(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return join(homedir(), p.slice(1));
   }
-  if (typeof error === "string" && error.trim()) {
-    return error.trim();
+  return p;
+}
+
+// src/browser/chromium-profile.ts
+import { promisify } from "util";
+import { execFile } from "child_process";
+import { createDecipheriv, createHash, pbkdf2Sync } from "crypto";
+import {
+  cp,
+  copyFile,
+  mkdtemp,
+  readdir,
+  readFile,
+  rm
+} from "fs/promises";
+import { existsSync, statSync } from "fs";
+import { basename, dirname, join as join2 } from "path";
+import { tmpdir } from "os";
+import { chromium } from "playwright";
+var execFileAsync = promisify(execFile);
+var CHROMIUM_EPOCH_MICROS = 11644473600000000n;
+var AES_BLOCK_BYTES = 16;
+var MAC_KEY_ITERATIONS = 1003;
+var LINUX_KEY_ITERATIONS = 1;
+var KEY_LENGTH = 16;
+var KEY_SALT = "saltysalt";
+var DEFAULT_CHROMIUM_BRAND = {
+  macService: "Chrome Safe Storage",
+  macAccount: "Chrome",
+  linuxApplications: ["chrome", "google-chrome"]
+};
+var CHROMIUM_BRANDS = [
+  {
+    match: ["bravesoftware", "brave-browser"],
+    brand: {
+      macService: "Brave Safe Storage",
+      macAccount: "Brave",
+      linuxApplications: ["brave-browser", "brave"]
+    }
+  },
+  {
+    match: ["microsoft", "edge"],
+    brand: {
+      macService: "Microsoft Edge Safe Storage",
+      macAccount: "Microsoft Edge",
+      linuxApplications: ["microsoft-edge"],
+      playwrightChannel: "msedge"
+    }
+  },
+  {
+    match: ["google", "chrome beta"],
+    brand: {
+      macService: "Chrome Beta Safe Storage",
+      macAccount: "Chrome Beta",
+      linuxApplications: ["chrome-beta"],
+      playwrightChannel: "chrome-beta"
+    }
+  },
+  {
+    match: ["google", "chrome"],
+    brand: {
+      macService: "Chrome Safe Storage",
+      macAccount: "Chrome",
+      linuxApplications: ["chrome", "google-chrome"],
+      playwrightChannel: "chrome"
+    }
+  },
+  {
+    match: ["chromium"],
+    brand: {
+      macService: "Chromium Safe Storage",
+      macAccount: "Chromium",
+      linuxApplications: ["chromium"]
+    }
   }
-  const record = asRecord(error);
-  const recordMessage = toNonEmptyString(record?.message) || toNonEmptyString(record?.error);
-  if (recordMessage) {
-    return recordMessage;
+];
+function directoryExists(filePath) {
+  try {
+    return statSync(filePath).isDirectory();
+  } catch {
+    return false;
   }
-  return fallback;
 }
-function normalizeError(error, fallback = "Unknown error.", maxCauseDepth = 2) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  return normalizeErrorInternal(error, fallback, maxCauseDepth, seen);
+function fileExists(filePath) {
+  try {
+    return statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
 }
-function normalizeErrorInternal(error, fallback, depthRemaining, seen) {
-  const record = asRecord(error);
-  if (record) {
-    if (seen.has(record)) {
-      return {
-        message: extractErrorMessage(error, fallback)
-      };
+function resolveCookieDbPath(profileDir) {
+  const candidates = [join2(profileDir, "Network", "Cookies"), join2(profileDir, "Cookies")];
+  for (const candidate of candidates) {
+    if (fileExists(candidate)) {
+      return candidate;
     }
-    seen.add(record);
-  }
-  const message = extractErrorMessage(error, fallback);
-  const code = extractCode(error);
-  const name = extractName(error);
-  const details = extractDetails(error);
-  if (depthRemaining <= 0) {
-    return compactErrorInfo({
-      message,
-      ...code ? { code } : {},
-      ...name ? { name } : {},
-      ...details ? { details } : {}
-    });
-  }
-  const cause = extractCause(error);
-  if (!cause) {
-    return compactErrorInfo({
-      message,
-      ...code ? { code } : {},
-      ...name ? { name } : {},
-      ...details ? { details } : {}
-    });
   }
-  const normalizedCause = normalizeErrorInternal(
-    cause,
-    "Caused by an unknown error.",
-    depthRemaining - 1,
-    seen
-  );
-  return compactErrorInfo({
-    message,
-    ...code ? { code } : {},
-    ...name ? { name } : {},
-    ...details ? { details } : {},
-    cause: normalizedCause
-  });
+  return null;
 }
-function compactErrorInfo(info) {
-  const safeDetails = toJsonSafeRecord(info.details);
+async function selectProfileDirFromUserDataDir(userDataDir) {
+  const entries = await readdir(userDataDir, {
+    withFileTypes: true
+  }).catch(() => []);
+  const candidates = entries.filter((entry) => entry.isDirectory()).map((entry) => join2(userDataDir, entry.name)).filter((entryPath) => resolveCookieDbPath(entryPath));
+  return candidates;
+}
+async function resolveChromiumProfileLocation(inputPath) {
+  const expandedPath = expandHome(inputPath.trim());
+  if (!expandedPath) {
+    throw new Error("Profile path cannot be empty.");
+  }
+  if (fileExists(expandedPath) && basename(expandedPath) === "Cookies") {
+    const directParent = dirname(expandedPath);
+    const profileDir = basename(directParent) === "Network" ? dirname(directParent) : directParent;
+    const userDataDir = dirname(profileDir);
+    return {
+      userDataDir,
+      profileDir,
+      profileDirectory: basename(profileDir),
+      cookieDbPath: expandedPath,
+      localStatePath: fileExists(join2(userDataDir, "Local State")) ? join2(userDataDir, "Local State") : null
+    };
+  }
+  if (fileExists(expandedPath)) {
+    throw new Error(
+      `Unsupported profile source "${inputPath}". Pass a Chromium profile directory, user-data dir, or Cookies database path.`
+    );
+  }
+  if (!directoryExists(expandedPath)) {
+    throw new Error(
+      `Could not find a Chromium profile at "${inputPath}".`
+    );
+  }
+  const directCookieDb = resolveCookieDbPath(expandedPath);
+  if (directCookieDb) {
+    const userDataDir = dirname(expandedPath);
+    return {
+      userDataDir,
+      profileDir: expandedPath,
+      profileDirectory: basename(expandedPath),
+      cookieDbPath: directCookieDb,
+      localStatePath: fileExists(join2(userDataDir, "Local State")) ? join2(userDataDir, "Local State") : null
+    };
+  }
+  const localStatePath = join2(expandedPath, "Local State");
+  if (!fileExists(localStatePath)) {
+    throw new Error(
+      `Unsupported profile source "${inputPath}". Pass a Chromium profile directory, user-data dir, or Cookies database path.`
+    );
+  }
+  const profileDirs = await selectProfileDirFromUserDataDir(expandedPath);
+  if (profileDirs.length === 0) {
+    throw new Error(
+      `No Chromium profile with a Cookies database was found under "${inputPath}".`
+    );
+  }
+  if (profileDirs.length > 1) {
+    const candidates = profileDirs.map((entry) => basename(entry)).join(", ");
+    throw new Error(
+      `"${inputPath}" contains multiple Chromium profiles (${candidates}). Pass a specific profile directory such as "${profileDirs[0]}".`
+    );
+  }
+  const selectedProfileDir = profileDirs[0];
+  const cookieDbPath = resolveCookieDbPath(selectedProfileDir);
+  if (!cookieDbPath) {
+    throw new Error(
+      `No Chromium Cookies database was found for "${inputPath}".`
+    );
+  }
   return {
-    message: info.message,
-    ...info.code ? { code: info.code } : {},
-    ...info.name ? { name: info.name } : {},
-    ...safeDetails ? { details: safeDetails } : {},
-    ...info.cause ? { cause: info.cause } : {}
+    userDataDir: expandedPath,
+    profileDir: selectedProfileDir,
+    profileDirectory: basename(selectedProfileDir),
+    cookieDbPath,
+    localStatePath
   };
 }
-function extractCode(error) {
-  const record = asRecord(error);
-  const raw = record?.code;
-  if (typeof raw === "string" && raw.trim()) {
-    return raw.trim();
+function resolvePersistentChromiumLaunchProfile(inputPath) {
+  const expandedPath = expandHome(inputPath.trim());
+  if (!expandedPath) {
+    return {
+      userDataDir: inputPath
+    };
   }
-  if (typeof raw === "number" && Number.isFinite(raw)) {
-    return String(raw);
+  if (fileExists(expandedPath) && basename(expandedPath) === "Cookies") {
+    const directParent = dirname(expandedPath);
+    const profileDir = basename(directParent) === "Network" ? dirname(directParent) : directParent;
+    return {
+      userDataDir: dirname(profileDir),
+      profileDirectory: basename(profileDir)
+    };
   }
-  return void 0;
+  if (directoryExists(expandedPath) && resolveCookieDbPath(expandedPath) && fileExists(join2(dirname(expandedPath), "Local State"))) {
+    return {
+      userDataDir: dirname(expandedPath),
+      profileDirectory: basename(expandedPath)
+    };
+  }
+  return {
+    userDataDir: expandedPath
+  };
 }
-function extractName(error) {
-  if (error instanceof Error && error.name.trim()) {
-    return error.name.trim();
-  }
-  const record = asRecord(error);
-  return toNonEmptyString(record?.name);
-}
-function extractDetails(error) {
-  const record = asRecord(error);
-  if (!record) return void 0;
-  const details = {};
-  const rawDetails = asRecord(record.details);
-  if (rawDetails) {
-    Object.assign(details, rawDetails);
-  }
-  const action = toNonEmptyString(record.action);
-  if (action) {
-    details.action = action;
-  }
-  const selectorUsed = toNonEmptyString(record.selectorUsed);
-  if (selectorUsed) {
-    details.selectorUsed = selectorUsed;
-  }
-  if (typeof record.status === "number" && Number.isFinite(record.status)) {
-    details.status = record.status;
-  }
-  const failure = asRecord(record.failure);
-  if (failure) {
-    const failureCode = toNonEmptyString(failure.code);
-    const classificationSource = toNonEmptyString(
-      failure.classificationSource
-    );
-    const failureDetails = asRecord(failure.details);
-    if (failureCode || classificationSource || failureDetails) {
-      details.actionFailure = {
-        ...failureCode ? { code: failureCode } : {},
-        ...classificationSource ? { classificationSource } : {},
-        ...failureDetails ? { details: failureDetails } : {}
-      };
+function detectChromiumBrand(location) {
+  const normalizedPath = location.userDataDir.toLowerCase();
+  for (const candidate of CHROMIUM_BRANDS) {
+    if (candidate.match.every((fragment) => normalizedPath.includes(fragment))) {
+      return candidate.brand;
     }
   }
-  return Object.keys(details).length ? details : void 0;
+  return DEFAULT_CHROMIUM_BRAND;
 }
-function extractCause(error) {
-  if (error instanceof Error) {
-    return error.cause;
+async function createSqliteSnapshot(dbPath) {
+  const snapshotDir = await mkdtemp(join2(tmpdir(), "opensteer-cookie-db-"));
+  const snapshotPath = join2(snapshotDir, "Cookies");
+  await copyFile(dbPath, snapshotPath);
+  for (const suffix of ["-wal", "-shm", "-journal"]) {
+    const source = `${dbPath}${suffix}`;
+    if (!existsSync(source)) {
+      continue;
+    }
+    await copyFile(source, `${snapshotPath}${suffix}`);
   }
-  const record = asRecord(error);
-  return record?.cause;
+  return {
+    snapshotPath,
+    cleanup: async () => {
+      await rm(snapshotDir, { recursive: true, force: true });
+    }
+  };
 }
-function asRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return null;
+async function querySqliteJson(dbPath, query) {
+  const result = await execFileAsync("sqlite3", ["-json", dbPath, query], {
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024
+  });
+  const stdout = result.stdout;
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return [];
   }
-  return value;
-}
-function toNonEmptyString(value) {
-  if (typeof value !== "string") return void 0;
-  const normalized = value.trim();
-  return normalized.length ? normalized : void 0;
+  return JSON.parse(trimmed);
 }
-function toJsonSafeRecord(value) {
-  if (!value) return void 0;
-  const sanitized = toJsonSafeValue(value, /* @__PURE__ */ new WeakSet());
-  if (!sanitized || typeof sanitized !== "object" || Array.isArray(sanitized)) {
-    return void 0;
+function convertChromiumTimestampToUnixSeconds(value) {
+  if (!value || value === "0") {
+    return -1;
   }
-  const record = sanitized;
-  return Object.keys(record).length > 0 ? record : void 0;
-}
-function toJsonSafeValue(value, seen) {
-  if (value === null) return null;
-  if (typeof value === "string" || typeof value === "boolean") {
-    return value;
+  const micros = BigInt(value);
+  if (micros <= CHROMIUM_EPOCH_MICROS) {
+    return -1;
   }
-  if (typeof value === "number") {
-    return Number.isFinite(value) ? value : null;
+  return Number((micros - CHROMIUM_EPOCH_MICROS) / 1000000n);
+}
+function mapChromiumSameSite(value) {
+  if (value === 2) {
+    return "Strict";
   }
-  if (typeof value === "bigint") {
-    return value.toString();
+  if (value === 0) {
+    return "None";
   }
-  if (value === void 0 || typeof value === "function" || typeof value === "symbol") {
-    return void 0;
+  return "Lax";
+}
+function stripChromiumPadding(buffer) {
+  const paddingLength = buffer[buffer.length - 1];
+  if (paddingLength <= 0 || paddingLength > AES_BLOCK_BYTES) {
+    return buffer;
   }
-  if (value instanceof Date) {
-    return Number.isNaN(value.getTime()) ? null : value.toISOString();
+  return buffer.subarray(0, buffer.length - paddingLength);
+}
+function stripDomainHashPrefix(buffer, hostKey) {
+  if (buffer.length < 32) {
+    return buffer;
   }
-  if (Array.isArray(value)) {
-    if (seen.has(value)) return "[Circular]";
-    seen.add(value);
-    const output = value.map((item) => {
-      const next = toJsonSafeValue(item, seen);
-      return next === void 0 ? null : next;
-    });
-    seen.delete(value);
-    return output;
-  }
-  if (value instanceof Set) {
-    if (seen.has(value)) return "[Circular]";
-    seen.add(value);
-    const output = Array.from(value, (item) => {
-      const next = toJsonSafeValue(item, seen);
-      return next === void 0 ? null : next;
-    });
-    seen.delete(value);
-    return output;
+  const domainHash = createHash("sha256").update(hostKey, "utf8").digest();
+  if (buffer.subarray(0, 32).equals(domainHash)) {
+    return buffer.subarray(32);
   }
-  if (value instanceof Map) {
-    if (seen.has(value)) return "[Circular]";
-    seen.add(value);
-    const output = {};
-    for (const [key, item] of value.entries()) {
-      const normalizedKey = String(key);
-      const next = toJsonSafeValue(item, seen);
-      if (next !== void 0) {
-        output[normalizedKey] = next;
-      }
+  return buffer;
+}
+function decryptChromiumAes128CbcValue(encryptedValue, key, hostKey) {
+  const ciphertext = encryptedValue.length > 3 && encryptedValue[0] === 118 && encryptedValue[1] === 49 && (encryptedValue[2] === 48 || encryptedValue[2] === 49) ? encryptedValue.subarray(3) : encryptedValue;
+  const iv = Buffer.alloc(AES_BLOCK_BYTES, " ");
+  const decipher = createDecipheriv("aes-128-cbc", key, iv);
+  const plaintext = Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final()
+  ]);
+  return stripDomainHashPrefix(stripChromiumPadding(plaintext), hostKey).toString(
+    "utf8"
+  );
+}
+function decryptChromiumAes256GcmValue(encryptedValue, key) {
+  const nonce = encryptedValue.subarray(3, 15);
+  const ciphertext = encryptedValue.subarray(15, encryptedValue.length - 16);
+  const authTag = encryptedValue.subarray(encryptedValue.length - 16);
+  const decipher = createDecipheriv("aes-256-gcm", key, nonce);
+  decipher.setAuthTag(authTag);
+  return Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final()
+  ]).toString("utf8");
+}
+async function dpapiUnprotect(buffer) {
+  const script = [
+    `$inputBytes = [Convert]::FromBase64String('${buffer.toString("base64")}')`,
+    "$plainBytes = [System.Security.Cryptography.ProtectedData]::Unprotect(",
+    "  $inputBytes,",
+    "  $null,",
+    "  [System.Security.Cryptography.DataProtectionScope]::CurrentUser",
+    ")",
+    "[Convert]::ToBase64String($plainBytes)"
+  ].join("\n");
+  const { stdout } = await execFileAsync(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-Command", script],
+    {
+      encoding: "utf8",
+      maxBuffer: 8 * 1024 * 1024
     }
-    seen.delete(value);
-    return output;
+  );
+  return Buffer.from(stdout.trim(), "base64");
+}
+async function buildChromiumDecryptor(location) {
+  if (process.platform === "darwin") {
+    const brand = detectChromiumBrand(location);
+    const keychainStore = createKeychainStore();
+    const password = keychainStore?.get(brand.macService, brand.macAccount) ?? null;
+    if (!password) {
+      throw new Error(
+        `Unable to read ${brand.macService} from macOS Keychain.`
+      );
+    }
+    const key = pbkdf2Sync(password, KEY_SALT, MAC_KEY_ITERATIONS, KEY_LENGTH, "sha1");
+    return async (row) => decryptChromiumAes128CbcValue(
+      Buffer.from(row.encrypted_value || "", "hex"),
+      key,
+      row.host_key
+    );
+  }
+  if (process.platform === "linux") {
+    const brand = detectChromiumBrand(location);
+    const keychainStore = createKeychainStore();
+    const password = keychainStore?.get(brand.macService, brand.macAccount) ?? brand.linuxApplications.map((application) => keychainStore?.get(application, application) ?? null).find(Boolean) ?? null;
+    const key = pbkdf2Sync(
+      password || "peanuts",
+      KEY_SALT,
+      LINUX_KEY_ITERATIONS,
+      KEY_LENGTH,
+      "sha1"
+    );
+    return async (row) => decryptChromiumAes128CbcValue(
+      Buffer.from(row.encrypted_value || "", "hex"),
+      key,
+      row.host_key
+    );
   }
-  if (typeof value === "object") {
-    const objectValue = value;
-    if (seen.has(objectValue)) return "[Circular]";
-    seen.add(objectValue);
-    const output = {};
-    for (const [key, item] of Object.entries(objectValue)) {
-      const next = toJsonSafeValue(item, seen);
-      if (next !== void 0) {
-        output[key] = next;
+  if (process.platform === "win32") {
+    if (!location.localStatePath) {
+      throw new Error(
+        `Unable to locate Chromium Local State for profile: ${location.profileDir}`
+      );
+    }
+    const localState = JSON.parse(
+      await readFile(location.localStatePath, "utf8")
+    );
+    const encryptedKeyBase64 = localState.os_crypt?.encrypted_key;
+    if (!encryptedKeyBase64) {
+      throw new Error(
+        `Local State did not include os_crypt.encrypted_key for ${location.userDataDir}`
+      );
+    }
+    const encryptedKey = Buffer.from(encryptedKeyBase64, "base64");
+    const masterKey = await dpapiUnprotect(encryptedKey.subarray(5));
+    return async (row) => {
+      const encryptedValue = Buffer.from(row.encrypted_value || "", "hex");
+      if (encryptedValue.length > 4 && encryptedValue[0] === 1 && encryptedValue[1] === 0 && encryptedValue[2] === 0 && encryptedValue[3] === 0) {
+        const decrypted = await dpapiUnprotect(encryptedValue);
+        return decrypted.toString("utf8");
       }
+      return decryptChromiumAes256GcmValue(encryptedValue, masterKey);
+    };
+  }
+  throw new Error(
+    `Local Chromium cookie sync is not supported on ${process.platform}.`
+  );
+}
+function buildPlaywrightCookie(row, value) {
+  if (!row.name.trim()) {
+    return null;
+  }
+  if (!row.host_key.trim()) {
+    return null;
+  }
+  const expires = row.has_expires === 1 ? convertChromiumTimestampToUnixSeconds(row.expires_utc) : -1;
+  if (expires !== -1 && expires <= Math.floor(Date.now() / 1e3)) {
+    return null;
+  }
+  return {
+    name: row.name,
+    value,
+    domain: row.host_key,
+    path: row.path || "/",
+    expires,
+    httpOnly: row.is_httponly === 1,
+    secure: row.is_secure === 1,
+    sameSite: mapChromiumSameSite(row.samesite)
+  };
+}
+async function loadCookiesFromLocalProfileDir(inputPath, options = {}) {
+  const location = await resolveChromiumProfileLocation(inputPath);
+  try {
+    return await loadCookiesFromSqlite(location);
+  } catch (error) {
+    if (!isMissingSqliteBinary(error)) {
+      throw error;
     }
-    seen.delete(objectValue);
-    return output;
   }
-  return void 0;
+  return await loadCookiesFromBrowserSnapshot(location, options);
 }
-
-// src/storage/namespace.ts
-import path from "path";
-var DEFAULT_NAMESPACE = "default";
-function normalizeNamespace(input) {
-  const raw = String(input || "").trim().replace(/\\/g, "/");
-  if (!raw) return DEFAULT_NAMESPACE;
-  const segments = raw.split("/").map((segment) => sanitizeNamespaceSegment(segment)).filter((segment) => Boolean(segment));
-  if (!segments.length) return DEFAULT_NAMESPACE;
-  return segments.join("/");
-}
-function resolveNamespaceDir(rootDir, namespace) {
-  const selectorsRoot = path.resolve(rootDir, ".opensteer", "selectors");
-  const normalizedNamespace = normalizeNamespace(namespace);
-  const namespaceDir = path.resolve(selectorsRoot, normalizedNamespace);
-  const relative = path.relative(selectorsRoot, namespaceDir);
-  if (relative === "" || relative === ".") return namespaceDir;
-  if (relative.startsWith("..") || path.isAbsolute(relative)) {
-    throw new Error(
-      `Namespace "${namespace}" resolves outside selectors root.`
-    );
+async function loadCookiesFromSqlite(location) {
+  const snapshot = await createSqliteSnapshot(location.cookieDbPath);
+  try {
+    const rows = await querySqliteJson(
+      snapshot.snapshotPath,
+      [
+        "SELECT",
+        "  host_key,",
+        "  name,",
+        "  value,",
+        "  hex(encrypted_value) AS encrypted_value,",
+        "  path,",
+        "  CAST(expires_utc AS TEXT) AS expires_utc,",
+        "  is_secure,",
+        "  is_httponly,",
+        "  has_expires,",
+        "  samesite",
+        "FROM cookies"
+      ].join(" ")
+    );
+    const decryptValue = await buildChromiumDecryptor(location);
+    const cookies = [];
+    for (const row of rows) {
+      let value = row.value || "";
+      if (!value && row.encrypted_value) {
+        value = await decryptValue(row);
+      }
+      const cookie = buildPlaywrightCookie(row, value);
+      if (cookie) {
+        cookies.push(cookie);
+      }
+    }
+    return cookies;
+  } finally {
+    await snapshot.cleanup();
+  }
+}
+async function loadCookiesFromBrowserSnapshot(location, options) {
+  const snapshotRootDir = await mkdtemp(join2(tmpdir(), "opensteer-profile-"));
+  const snapshotProfileDir = join2(
+    snapshotRootDir,
+    basename(location.profileDir)
+  );
+  let context = null;
+  try {
+    await cp(location.profileDir, snapshotProfileDir, {
+      recursive: true
+    });
+    if (location.localStatePath) {
+      await copyFile(location.localStatePath, join2(snapshotRootDir, "Local State"));
+    }
+    const brand = detectChromiumBrand(location);
+    const args = [`--profile-directory=${basename(snapshotProfileDir)}`];
+    context = await chromium.launchPersistentContext(snapshotRootDir, {
+      channel: brand.playwrightChannel,
+      headless: options.headless ?? true,
+      timeout: options.timeout ?? 12e4,
+      args
+    });
+    return await context.cookies();
+  } finally {
+    await context?.close().catch(() => void 0);
+    await rm(snapshotRootDir, { recursive: true, force: true });
   }
-  return namespaceDir;
 }
-function sanitizeNamespaceSegment(segment) {
-  const trimmed = String(segment || "").trim();
-  if (!trimmed || trimmed === "." || trimmed === "..") return "";
-  const replaced = trimmed.replace(/[^a-zA-Z0-9_-]+/g, "_");
-  const collapsed = replaced.replace(/_+/g, "_");
-  const bounded = collapsed.replace(/^_+|_+$/g, "");
-  return bounded || "";
+function isMissingSqliteBinary(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
+  );
 }
 
 // src/navigation.ts
@@ -829,7 +1081,7 @@ function createEmptyRegistry(name) {
 
 // src/storage/local.ts
 import fs from "fs";
-import path2 from "path";
+import path from "path";
 var LocalSelectorStorage = class {
   rootDir;
   namespace;
@@ -850,16 +1102,16 @@ var LocalSelectorStorage = class {
     return `${safe}.json`;
   }
   getOpensteerDir() {
-    return path2.join(this.rootDir, ".opensteer");
+    return path.join(this.rootDir, ".opensteer");
   }
   getNamespaceDir() {
     return resolveNamespaceDir(this.rootDir, this.namespace);
   }
   getRegistryPath() {
-    return path2.join(this.getNamespaceDir(), "index.json");
+    return path.join(this.getNamespaceDir(), "index.json");
   }
   getSelectorPath(id) {
-    return path2.join(this.getNamespaceDir(), this.getSelectorFileName(id));
+    return path.join(this.getNamespaceDir(), this.getSelectorFileName(id));
   }
   ensureDirs() {
     fs.mkdirSync(this.getNamespaceDir(), { recursive: true });
@@ -1195,11 +1447,11 @@ var OS_INSTANCE_TOKEN_KEY = "__opensteerInstanceToken";
 
 // src/element-path/build.ts
 var MAX_ATTRIBUTE_VALUE_LENGTH = 300;
-function cloneElementPath(path5) {
-  return JSON.parse(JSON.stringify(path5));
+function cloneElementPath(path3) {
+  return JSON.parse(JSON.stringify(path3));
 }
-function buildPathSelectorHint(path5) {
-  const nodes = path5?.nodes || [];
+function buildPathSelectorHint(path3) {
+  const nodes = path3?.nodes || [];
   const last = nodes[nodes.length - 1];
   if (!last) return "*";
   return buildSegmentSelector(last);
@@ -1208,9 +1460,9 @@ async function buildElementPathFromSelector(page, selector) {
   try {
     const handle = await page.mainFrame().locator(selector).first().elementHandle({ timeout: 1500 });
     if (!handle) return null;
-    const path5 = await buildElementPathFromHandle(handle);
+    const path3 = await buildElementPathFromHandle(handle);
     await handle.dispose();
-    return path5;
+    return path3;
   } catch {
     return null;
   }
@@ -1623,11 +1875,11 @@ async function buildElementPathFromHandle(handle) {
   if (!out) return null;
   return sanitizeElementPath(out);
 }
-function sanitizeElementPath(path5) {
+function sanitizeElementPath(path3) {
   const cleanNodes = (nodes) => (Array.isArray(nodes) ? nodes : []).map(
     (raw) => normalizePathNode(raw)
   );
-  const context = (Array.isArray(path5?.context) ? path5.context : []).filter(
+  const context = (Array.isArray(path3?.context) ? path3.context : []).filter(
     (hop) => hop && (hop.kind === "iframe" || hop.kind === "shadow")
   ).map((hop) => ({
     kind: hop.kind,
@@ -1635,7 +1887,7 @@ function sanitizeElementPath(path5) {
   }));
   return {
     context,
-    nodes: cleanNodes(path5?.nodes || [])
+    nodes: cleanNodes(path3?.nodes || [])
   };
 }
 function normalizePathNode(raw) {
@@ -2074,16 +2326,16 @@ async function serializeFrameRecursive(frame, baseContext, frameKey) {
           nodeTableIndexByKey.set(key, index);
           return index;
         },
-        packDomPath(path5) {
-          return path5.map((node) => helpers.internPathNode(node));
+        packDomPath(path3) {
+          return path3.map((node) => helpers.internPathNode(node));
         },
-        packElementPath(path5) {
+        packElementPath(path3) {
           return {
-            context: (path5.context || []).map((hop) => ({
+            context: (path3.context || []).map((hop) => ({
               kind: "shadow",
               host: helpers.packDomPath(hop.host)
             })),
-            nodes: helpers.packDomPath(path5.nodes)
+            nodes: helpers.packDomPath(path3.nodes)
           };
         },
         ensureNodeId(el) {
@@ -2172,7 +2424,7 @@ async function serializeFrameRecursive(frame, baseContext, frameKey) {
   const nodePaths = /* @__PURE__ */ new Map();
   const nodeMeta = /* @__PURE__ */ new Map();
   for (const [index, entry] of frameSnapshot.entries.entries()) {
-    const path5 = decodeSerializedElementPath(
+    const path3 = decodeSerializedElementPath(
       frameSnapshot.nodeTable,
       entry.path,
       `entries[${index}].path`
@@ -2180,9 +2432,9 @@ async function serializeFrameRecursive(frame, baseContext, frameKey) {
     nodePaths.set(entry.nodeId, {
       context: [
         ...baseContext,
-        ...path5.context || []
+        ...path3.context || []
       ],
-      nodes: path5.nodes
+      nodes: path3.nodes
     });
     nodeMeta.set(entry.nodeId, {
       frameToken: frameSnapshot.frameToken,
@@ -2222,8 +2474,8 @@ async function serializeFrameRecursive(frame, baseContext, frameKey) {
       hostEl.after(
         `<${OS_IFRAME_BOUNDARY_TAG} ${OS_BOUNDARY_ATTR}="iframe">${childResult.html}</${OS_IFRAME_BOUNDARY_TAG}>`
       );
-      for (const [nodeId, path5] of childResult.nodePaths.entries()) {
-        nodePaths.set(nodeId, path5);
+      for (const [nodeId, path3] of childResult.nodePaths.entries()) {
+        nodePaths.set(nodeId, path3);
       }
       for (const [nodeId, meta] of childResult.nodeMeta.entries()) {
         nodeMeta.set(nodeId, meta);
@@ -2235,8 +2487,8 @@ async function serializeFrameRecursive(frame, baseContext, frameKey) {
     }
   }
   const sanitizedPaths = /* @__PURE__ */ new Map();
-  for (const [nodeId, path5] of nodePaths.entries()) {
-    sanitizedPaths.set(nodeId, sanitizeElementPath(path5));
+  for (const [nodeId, path3] of nodePaths.entries()) {
+    sanitizedPaths.set(nodeId, sanitizeElementPath(path3));
   }
   return {
     html: $.html(),
@@ -3058,11 +3310,11 @@ async function assignCounters(page, html, nodePaths, nodeMeta) {
     if (!nodeId) return;
     const counter = nextCounter++;
     assignedByNodeId.set(nodeId, counter);
-    const path5 = nodePaths.get(nodeId);
+    const path3 = nodePaths.get(nodeId);
     el.attr("c", String(counter));
     el.removeAttr(OS_NODE_ID_ATTR);
-    if (path5) {
-      counterIndex.set(counter, cloneElementPath(path5));
+    if (path3) {
+      counterIndex.set(counter, cloneElementPath(path3));
     }
   });
   try {
@@ -3301,10 +3553,10 @@ var ElementPathError = class extends Error {
 
 // src/element-path/resolver.ts
 async function resolveElementPath(page, rawPath) {
-  const path5 = sanitizeElementPath(rawPath);
+  const path3 = sanitizeElementPath(rawPath);
   let frame = page.mainFrame();
   let rootHandle = null;
-  for (const hop of path5.context) {
+  for (const hop of path3.context) {
     const host = await resolveDomPath(frame, hop.host, rootHandle);
     if (!host) {
       await disposeHandle(rootHandle);
@@ -3343,17 +3595,17 @@ async function resolveElementPath(page, rawPath) {
     await disposeHandle(rootHandle);
     rootHandle = shadowRoot;
   }
-  const target = await resolveDomPath(frame, path5.nodes, rootHandle);
+  const target = await resolveDomPath(frame, path3.nodes, rootHandle);
   if (!target) {
     const diagnostics = await collectCandidateDiagnostics(
       frame,
-      path5.nodes,
+      path3.nodes,
       rootHandle
     );
     await disposeHandle(rootHandle);
     throw new ElementPathError(
       "ERR_PATH_TARGET_NOT_FOUND",
-      buildTargetNotFoundMessage(path5.nodes, diagnostics)
+      buildTargetNotFoundMessage(path3.nodes, diagnostics)
     );
   }
   await disposeHandle(rootHandle);
@@ -3362,12 +3614,12 @@ async function resolveElementPath(page, rawPath) {
       selector: target.selector,
       mode: target.mode,
       count: target.count,
-      targetDepth: path5.nodes.length
+      targetDepth: path3.nodes.length
     });
   }
   return {
     element: target.element,
-    usedSelector: target.selector || buildPathSelectorHint(path5)
+    usedSelector: target.selector || buildPathSelectorHint(path3)
   };
 }
 async function resolveDomPath(frame, domPath, rootHandle) {
@@ -3522,6 +3774,16 @@ async function disposeHandle(handle) {
 
 // src/extract-value-normalization.ts
 var URL_LIST_ATTRIBUTES = /* @__PURE__ */ new Set(["srcset", "imagesrcset", "ping"]);
+var IFRAME_URL_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "href",
+  "src",
+  "srcset",
+  "imagesrcset",
+  "action",
+  "formaction",
+  "poster",
+  "ping"
+]);
 function normalizeExtractedValue(raw, attribute) {
   if (raw == null) return null;
   const rawText = String(raw);
@@ -3537,6 +3799,19 @@ function normalizeExtractedValue(raw, attribute) {
   const text = rawText.replace(/\s+/g, " ").trim();
   return text || null;
 }
+function resolveExtractedValueInContext(normalizedValue, options) {
+  if (normalizedValue == null) return null;
+  const normalizedAttribute = String(options.attribute || "").trim().toLowerCase();
+  if (!options.insideIframe) return normalizedValue;
+  if (!IFRAME_URL_ATTRIBUTES.has(normalizedAttribute)) return normalizedValue;
+  const baseURI = String(options.baseURI || "").trim();
+  if (!baseURI) return normalizedValue;
+  try {
+    return new URL(normalizedValue, baseURI).href;
+  } catch {
+    return normalizedValue;
+  }
+}
 function pickSingleListAttributeValue(attribute, raw) {
   if (attribute === "ping") {
     const firstUrl = raw.trim().split(/\s+/)[0] || "";
@@ -3692,6 +3967,36 @@ function readDescriptorToken(value, index) {
   };
 }
 
+// src/extract-value-reader.ts
+async function readExtractedValueFromHandle(element, options) {
+  const insideIframe = await isElementInsideIframe(element);
+  const payload = await element.evaluate(
+    (target, browserOptions) => {
+      const ownerDocument = target.ownerDocument;
+      return {
+        raw: browserOptions.attribute ? target.getAttribute(browserOptions.attribute) : target.textContent,
+        baseURI: ownerDocument?.baseURI || null
+      };
+    },
+    {
+      attribute: options.attribute
+    }
+  );
+  const normalizedValue = normalizeExtractedValue(
+    payload.raw,
+    options.attribute
+  );
+  return resolveExtractedValueInContext(normalizedValue, {
+    attribute: options.attribute,
+    baseURI: payload.baseURI,
+    insideIframe
+  });
+}
+async function isElementInsideIframe(element) {
+  const ownerFrame = await element.ownerFrame();
+  return !!ownerFrame?.parentFrame();
+}
+
 // src/html/counter-runtime.ts
 var CounterResolutionError = class extends Error {
   code;
@@ -3714,13 +4019,14 @@ async function resolveCounterElement(page, counter) {
   if (entry.count > 1) {
     throw buildCounterAmbiguousError(counter);
   }
-  const handle = await resolveUniqueHandleInFrame(entry.frame, normalized);
-  const element = handle.asElement();
-  if (!element) {
-    await handle.dispose();
+  const resolution = await resolveCounterElementInFrame(entry.frame, normalized);
+  if (resolution.status === "ambiguous") {
+    throw buildCounterAmbiguousError(counter);
+  }
+  if (resolution.status === "missing") {
     throw buildCounterNotFoundError(counter);
   }
-  return element;
+  return resolution.element;
 }
 async function resolveCountersBatch(page, requests) {
   const out = {};
@@ -3734,41 +4040,57 @@ async function resolveCountersBatch(page, requests) {
     }
   }
   const valueCache = /* @__PURE__ */ new Map();
-  for (const request of requests) {
-    const normalized = normalizeCounter(request.counter);
-    if (normalized == null) {
-      out[request.key] = null;
-      continue;
-    }
-    const entry = scan.get(normalized);
-    if (!entry || entry.count <= 0 || !entry.frame) {
-      out[request.key] = null;
-      continue;
-    }
-    const cacheKey = `${normalized}:${request.attribute || ""}`;
-    if (valueCache.has(cacheKey)) {
-      out[request.key] = valueCache.get(cacheKey);
-      continue;
-    }
-    const read = await readCounterValueInFrame(
-      entry.frame,
-      normalized,
-      request.attribute
-    );
-    if (read.status === "ambiguous") {
-      throw buildCounterAmbiguousError(normalized);
-    }
-    if (read.status === "missing") {
-      valueCache.set(cacheKey, null);
-      out[request.key] = null;
-      continue;
+  const elementCache = /* @__PURE__ */ new Map();
+  try {
+    for (const request of requests) {
+      const normalized = normalizeCounter(request.counter);
+      if (normalized == null) {
+        out[request.key] = null;
+        continue;
+      }
+      const entry = scan.get(normalized);
+      if (!entry || entry.count <= 0 || !entry.frame) {
+        out[request.key] = null;
+        continue;
+      }
+      const cacheKey = `${normalized}:${request.attribute || ""}`;
+      if (valueCache.has(cacheKey)) {
+        out[request.key] = valueCache.get(cacheKey);
+        continue;
+      }
+      if (!elementCache.has(normalized)) {
+        elementCache.set(
+          normalized,
+          await resolveCounterElementInFrame(entry.frame, normalized)
+        );
+      }
+      const resolution = elementCache.get(normalized);
+      if (resolution.status === "ambiguous") {
+        throw buildCounterAmbiguousError(normalized);
+      }
+      if (resolution.status === "missing") {
+        valueCache.set(cacheKey, null);
+        out[request.key] = null;
+        continue;
+      }
+      const value = await readCounterValueFromElement(
+        resolution.element,
+        request.attribute
+      );
+      if (value.status === "missing") {
+        await resolution.element.dispose();
+        elementCache.set(normalized, {
+          status: "missing"
+        });
+        valueCache.set(cacheKey, null);
+        out[request.key] = null;
+        continue;
+      }
+      valueCache.set(cacheKey, value.value);
+      out[request.key] = value.value;
     }
-    const normalizedValue = normalizeExtractedValue(
-      read.value ?? null,
-      request.attribute
-    );
-    valueCache.set(cacheKey, normalizedValue);
-    out[request.key] = normalizedValue;
+  } finally {
+    await disposeResolvedCounterElements(elementCache.values());
   }
   return out;
 }
@@ -3840,73 +4162,79 @@ async function scanCounterOccurrences(page, counters) {
   }
   return out;
 }
-async function resolveUniqueHandleInFrame(frame, counter) {
-  return frame.evaluateHandle((targetCounter) => {
-    const matches = [];
-    const walk = (root) => {
-      const children = Array.from(root.children);
-      for (const child of children) {
-        if (child.getAttribute("c") === targetCounter) {
-          matches.push(child);
-        }
-        walk(child);
-        if (child.shadowRoot) {
-          walk(child.shadowRoot);
+async function resolveCounterElementInFrame(frame, counter) {
+  try {
+    const handle = await frame.evaluateHandle((targetCounter) => {
+      const matches = [];
+      const walk = (root) => {
+        const children = Array.from(root.children);
+        for (const child of children) {
+          if (child.getAttribute("c") === targetCounter) {
+            matches.push(child);
+          }
+          walk(child);
+          if (child.shadowRoot) {
+            walk(child.shadowRoot);
+          }
         }
+      };
+      walk(document);
+      if (!matches.length) {
+        return "missing";
       }
-    };
-    walk(document);
-    if (matches.length !== 1) {
-      return null;
+      if (matches.length > 1) {
+        return "ambiguous";
+      }
+      return matches[0];
+    }, String(counter));
+    const element = handle.asElement();
+    if (element) {
+      return {
+        status: "resolved",
+        element
+      };
+    }
+    const status = await handle.jsonValue();
+    await handle.dispose();
+    return status === "ambiguous" ? { status: "ambiguous" } : { status: "missing" };
+  } catch (error) {
+    if (isRecoverableCounterReadRace(error)) {
+      return {
+        status: "missing"
+      };
     }
-    return matches[0];
-  }, String(counter));
+    throw error;
+  }
 }
-async function readCounterValueInFrame(frame, counter, attribute) {
+async function readCounterValueFromElement(element, attribute) {
   try {
-    return await frame.evaluate(
-      ({ targetCounter, attribute: attribute2 }) => {
-        const matches = [];
-        const walk = (root) => {
-          const children = Array.from(root.children);
-          for (const child of children) {
-            if (child.getAttribute("c") === targetCounter) {
-              matches.push(child);
-            }
-            walk(child);
-            if (child.shadowRoot) {
-              walk(child.shadowRoot);
-            }
-          }
-        };
-        walk(document);
-        if (!matches.length) {
-          return {
-            status: "missing"
-          };
-        }
-        if (matches.length > 1) {
-          return {
-            status: "ambiguous"
-          };
-        }
-        const target = matches[0];
-        const value = attribute2 ? target.getAttribute(attribute2) : target.textContent;
-        return {
-          status: "ok",
-          value
-        };
-      },
-      {
-        targetCounter: String(counter),
-        attribute
-      }
-    );
-  } catch {
     return {
-      status: "missing"
+      status: "ok",
+      value: await readExtractedValueFromHandle(element, {
+        attribute
+      })
     };
+  } catch (error) {
+    if (isRecoverableCounterReadRace(error)) {
+      return {
+        status: "missing"
+      };
+    }
+    throw error;
+  }
+}
+async function disposeResolvedCounterElements(resolutions) {
+  const disposals = [];
+  for (const resolution of resolutions) {
+    if (resolution.status !== "resolved") continue;
+    disposals.push(resolution.element.dispose());
   }
+  await Promise.all(disposals);
+}
+function isRecoverableCounterReadRace(error) {
+  if (!(error instanceof Error)) return false;
+  const message = error.message;
+  return message.includes("Execution context was destroyed") || message.includes("Cannot find context with specified id") || message.includes("Cannot find execution context") || message.includes("Frame was detached") || message.includes("Element is not attached to the DOM") || message.includes("Element is detached");
 }
 function buildCounterNotFoundError(counter) {
   return new CounterResolutionError(
@@ -4391,10 +4719,10 @@ function classifyPathResolutionFailure(action, err) {
 }
 
 // src/actions/click.ts
-async function performClick(page, path5, options) {
+async function performClick(page, path3, options) {
   let resolved;
   try {
-    resolved = await resolveElementPath(page, path5);
+    resolved = await resolveElementPath(page, path3);
   } catch (err) {
     const failure = classifyPathResolutionFailure("click", err);
     return { ok: false, error: failure.message, failure };
@@ -4407,7 +4735,7 @@ async function performClick(page, path5, options) {
     });
     return {
       ok: true,
-      path: path5,
+      path: path3,
       usedSelector: resolved.usedSelector
     };
   } catch (err) {
@@ -4424,10 +4752,10 @@ async function performClick(page, path5, options) {
 }
 
 // src/actions/hover.ts
-async function performHover(page, path5, options) {
+async function performHover(page, path3, options) {
   let resolved;
   try {
-    resolved = await resolveElementPath(page, path5);
+    resolved = await resolveElementPath(page, path3);
   } catch (err) {
     const failure = classifyPathResolutionFailure("hover", err);
     return { ok: false, error: failure.message, failure };
@@ -4439,7 +4767,7 @@ async function performHover(page, path5, options) {
     });
     return {
       ok: true,
-      path: path5,
+      path: path3,
       usedSelector: resolved.usedSelector
     };
   } catch (err) {
@@ -4456,10 +4784,10 @@ async function performHover(page, path5, options) {
 }
 
 // src/actions/input.ts
-async function performInput(page, path5, options) {
+async function performInput(page, path3, options) {
   let resolved;
   try {
-    resolved = await resolveElementPath(page, path5);
+    resolved = await resolveElementPath(page, path3);
   } catch (err) {
     const failure = classifyPathResolutionFailure("input", err);
     return { ok: false, error: failure.message, failure };
@@ -4475,7 +4803,7 @@ async function performInput(page, path5, options) {
     }
     return {
       ok: true,
-      path: path5,
+      path: path3,
       usedSelector: resolved.usedSelector
     };
   } catch (err) {
@@ -4507,9 +4835,9 @@ function getScrollDelta(options) {
       return { x: 0, y: absoluteAmount };
   }
 }
-async function performScroll(page, path5, options) {
+async function performScroll(page, path3, options) {
   const { x, y } = getScrollDelta(options);
-  if (!path5) {
+  if (!path3) {
     await page.evaluate(
       ({ deltaX, deltaY }) => {
         window.scrollBy(deltaX, deltaY);
@@ -4520,7 +4848,7 @@ async function performScroll(page, path5, options) {
   }
   let resolved;
   try {
-    resolved = await resolveElementPath(page, path5);
+    resolved = await resolveElementPath(page, path3);
   } catch (err) {
     const failure = classifyPathResolutionFailure("scroll", err);
     return { ok: false, error: failure.message, failure };
@@ -4536,7 +4864,7 @@ async function performScroll(page, path5, options) {
     );
     return {
       ok: true,
-      path: path5,
+      path: path3,
       usedSelector: resolved.usedSelector
     };
   } catch (err) {
@@ -4553,10 +4881,10 @@ async function performScroll(page, path5, options) {
 }
 
 // src/actions/select.ts
-async function performSelect(page, path5, options) {
+async function performSelect(page, path3, options) {
   let resolved;
   try {
-    resolved = await resolveElementPath(page, path5);
+    resolved = await resolveElementPath(page, path3);
   } catch (err) {
     const failure = classifyPathResolutionFailure("select", err);
     return { ok: false, error: failure.message, failure };
@@ -4582,7 +4910,7 @@ async function performSelect(page, path5, options) {
     }
     return {
       ok: true,
-      path: path5,
+      path: path3,
       usedSelector: resolved.usedSelector
     };
   } catch (err) {
@@ -4599,17 +4927,6 @@ async function performSelect(page, path5, options) {
 }
 
 // src/actions/extract.ts
-async function readFieldValueFromHandle(element, options) {
-  const raw = await element.evaluate(
-    (target, payload) => {
-      return payload.attribute ? target.getAttribute(payload.attribute) : target.textContent;
-    },
-    {
-      attribute: options.attribute
-    }
-  );
-  return normalizeExtractedValue(raw, options.attribute);
-}
 async function extractWithPaths(page, fields) {
   const result = {};
   for (const field of fields) {
@@ -4621,7 +4938,7 @@ async function extractWithPaths(page, fields) {
       continue;
     }
     try {
-      result[field.key] = await readFieldValueFromHandle(
+      result[field.key] = await readExtractedValueFromHandle(
         resolved.element,
         {
           attribute: field.attribute
@@ -4661,7 +4978,7 @@ async function extractArrayRowsWithPaths(page, array) {
           field.candidates
         ) : item;
         try {
-          const value = target ? await readFieldValueFromHandle(target, {
+          const value = target ? await readExtractedValueFromHandle(target, {
             attribute: field.attribute
           }) : null;
           if (key) {
@@ -4688,8 +5005,8 @@ async function countArrayItemsWithPath(page, itemParentPath) {
   await Promise.all(items.map((item) => item.dispose()));
   return count;
 }
-async function queryAllByElementPath(page, path5) {
-  const normalized = sanitizeElementPath(path5);
+async function queryAllByElementPath(page, path3) {
+  const normalized = sanitizeElementPath(path3);
   const scope = await resolvePathScope(page, normalized.context);
   if (!scope) return [];
   try {
@@ -4861,9 +5178,9 @@ async function queryFirstByCandidates(selectors, query) {
   }
   return fallback;
 }
-function buildArrayFieldPathCandidates(path5) {
-  const strict = path5.nodes.length ? buildPathCandidates(path5.nodes) : [];
-  const relaxedNodes = stripPositionClauses(path5.nodes);
+function buildArrayFieldPathCandidates(path3) {
+  const strict = path3.nodes.length ? buildPathCandidates(path3.nodes) : [];
+  const relaxedNodes = stripPositionClauses(path3.nodes);
   const relaxed = relaxedNodes.length ? buildPathCandidates(relaxedNodes) : [];
   return dedupeSelectors([...strict, ...relaxed]);
 }
@@ -4976,7 +5293,7 @@ async function closeTab(context, activePage, index) {
 }
 
 // src/actions/cookies.ts
-import { readFile, writeFile } from "fs/promises";
+import { readFile as readFile2, writeFile } from "fs/promises";
 async function getCookies(context, url) {
   return context.cookies(url ? [url] : void 0);
 }
@@ -4991,7 +5308,7 @@ async function exportCookies(context, filePath, url) {
   await writeFile(filePath, JSON.stringify(cookies, null, 2), "utf-8");
 }
 async function importCookies(context, filePath) {
-  const raw = await readFile(filePath, "utf-8");
+  const raw = await readFile2(filePath, "utf-8");
   const cookies = JSON.parse(raw);
   await context.addCookies(cookies);
 }
@@ -5005,8 +5322,8 @@ async function typeText(page, text) {
 }
 
 // src/actions/element-info.ts
-async function getElementText(page, path5) {
-  const resolved = await resolveElementPath(page, path5);
+async function getElementText(page, path3) {
+  const resolved = await resolveElementPath(page, path3);
   try {
     const text = await resolved.element.textContent();
     return text ?? "";
@@ -5014,16 +5331,16 @@ async function getElementText(page, path5) {
     await resolved.element.dispose();
   }
 }
-async function getElementValue(page, path5) {
-  const resolved = await resolveElementPath(page, path5);
+async function getElementValue(page, path3) {
+  const resolved = await resolveElementPath(page, path3);
   try {
     return await resolved.element.inputValue();
   } finally {
     await resolved.element.dispose();
   }
 }
-async function getElementAttributes(page, path5) {
-  const resolved = await resolveElementPath(page, path5);
+async function getElementAttributes(page, path3) {
+  const resolved = await resolveElementPath(page, path3);
   try {
     return await resolved.element.evaluate((el) => {
       const attrs = {};
@@ -5036,8 +5353,8 @@ async function getElementAttributes(page, path5) {
     await resolved.element.dispose();
   }
 }
-async function getElementBoundingBox(page, path5) {
-  const resolved = await resolveElementPath(page, path5);
+async function getElementBoundingBox(page, path3) {
+  const resolved = await resolveElementPath(page, path3);
   try {
     return await resolved.element.boundingBox();
   } finally {
@@ -5063,10 +5380,10 @@ async function getPageTitle(page) {
 }
 
 // src/actions/file-upload.ts
-async function performFileUpload(page, path5, filePaths) {
+async function performFileUpload(page, path3, filePaths) {
   let resolved;
   try {
-    resolved = await resolveElementPath(page, path5);
+    resolved = await resolveElementPath(page, path3);
   } catch (err) {
     const failure = classifyPathResolutionFailure("uploadFile", err);
     return { ok: false, error: failure.message, failure };
@@ -5075,7 +5392,7 @@ async function performFileUpload(page, path5, filePaths) {
     await resolved.element.setInputFiles(filePaths);
     return {
       ok: true,
-      path: path5,
+      path: path3,
       usedSelector: resolved.usedSelector
     };
   } catch (err) {
@@ -5112,32 +5429,6 @@ var OpensteerActionError = class extends Error {
 // src/cloud/contracts.ts
 var cloudSessionContractVersion = "v3";
 
-// src/cloud/errors.ts
-var OpensteerCloudError = class extends Error {
-  code;
-  status;
-  details;
-  constructor(code, message, status, details) {
-    super(message);
-    this.name = "OpensteerCloudError";
-    this.code = code;
-    this.status = status;
-    this.details = details;
-  }
-};
-function cloudUnsupportedMethodError(method, message) {
-  return new OpensteerCloudError(
-    "CLOUD_UNSUPPORTED_METHOD",
-    message || `${method} is not supported in cloud mode.`
-  );
-}
-function cloudNotLaunchedError() {
-  return new OpensteerCloudError(
-    "CLOUD_SESSION_NOT_FOUND",
-    "Cloud session is not connected. Call launch() first."
-  );
-}
-
 // src/cloud/action-ws-client.ts
 import WebSocket from "ws";
 var ActionWsClient = class _ActionWsClient {
@@ -5275,7 +5566,7 @@ function withTokenQuery(wsUrl, token) {
 
 // src/cloud/local-cache-sync.ts
 import fs2 from "fs";
-import path3 from "path";
+import path2 from "path";
 function collectLocalSelectorCacheEntries(storage, options = {}) {
   const debug = options.debug === true;
   const namespace = storage.getNamespace();
@@ -5285,7 +5576,7 @@ function collectLocalSelectorCacheEntries(storage, options = {}) {
   const fileNames = fs2.readdirSync(namespaceDir);
   for (const fileName of fileNames) {
     if (fileName === "index.json" || !fileName.endsWith(".json")) continue;
-    const filePath = path3.join(namespaceDir, fileName);
+    const filePath = path2.join(namespaceDir, fileName);
     const selector = readSelectorFile(filePath, debug);
     if (!selector) continue;
     const descriptionHash = normalizeDescriptionHash(selector.id);
@@ -5407,324 +5698,6 @@ function dedupeNewest(entries) {
   return [...byKey.values()];
 }
 
-// src/cloud/cdp-client.ts
-import {
-  chromium
-} from "playwright";
-var CloudCdpClient = class {
-  async connect(args) {
-    const endpoint = withTokenQuery2(args.wsUrl, args.token);
-    let browser;
-    try {
-      browser = await chromium.connectOverCDP(endpoint);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to connect to cloud CDP endpoint.";
-      throw new OpensteerCloudError("CLOUD_TRANSPORT_ERROR", message);
-    }
-    const contexts = browser.contexts();
-    const context = contexts[0];
-    if (!context) {
-      await browser.close();
-      throw new OpensteerCloudError(
-        "CLOUD_INTERNAL",
-        "Cloud browser returned no context."
-      );
-    }
-    const preferred = selectPreferredContextPage(browser, contexts);
-    if (preferred) {
-      return preferred;
-    }
-    const page = context.pages()[0] || await context.newPage();
-    return { browser, context, page };
-  }
-};
-function selectPreferredContextPage(browser, contexts) {
-  let aboutBlankCandidate = null;
-  for (const context of contexts) {
-    for (const page of context.pages()) {
-      const url = safePageUrl(page);
-      if (!isInternalOrEmptyUrl(url)) {
-        return { browser, context, page };
-      }
-      if (!aboutBlankCandidate && url === "about:blank") {
-        aboutBlankCandidate = { browser, context, page };
-      }
-    }
-  }
-  return aboutBlankCandidate;
-}
-function safePageUrl(page) {
-  try {
-    return page.url();
-  } catch {
-    return "";
-  }
-}
-function isInternalOrEmptyUrl(url) {
-  if (!url) return true;
-  if (url === "about:blank") return true;
-  return url.startsWith("chrome://") || url.startsWith("devtools://") || url.startsWith("edge://");
-}
-function withTokenQuery2(wsUrl, token) {
-  const url = new URL(wsUrl);
-  url.searchParams.set("token", token);
-  return url.toString();
-}
-
-// src/cloud/session-client.ts
-var CACHE_IMPORT_BATCH_SIZE = 200;
-var CloudSessionClient = class {
-  baseUrl;
-  key;
-  authScheme;
-  constructor(baseUrl, key, authScheme = "api-key") {
-    this.baseUrl = normalizeBaseUrl(baseUrl);
-    this.key = key;
-    this.authScheme = authScheme;
-  }
-  async create(request) {
-    const response = await fetch(`${this.baseUrl}/sessions`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...this.authHeaders()
-      },
-      body: JSON.stringify(request)
-    });
-    if (!response.ok) {
-      throw await parseHttpError(response);
-    }
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      throw new OpensteerCloudError(
-        "CLOUD_CONTRACT_MISMATCH",
-        "Invalid cloud session create response: expected a JSON object.",
-        response.status
-      );
-    }
-    return parseCreateResponse(body, response.status);
-  }
-  async close(sessionId) {
-    const response = await fetch(`${this.baseUrl}/sessions/${sessionId}`, {
-      method: "DELETE",
-      headers: {
-        ...this.authHeaders()
-      }
-    });
-    if (response.status === 204) {
-      return;
-    }
-    if (!response.ok) {
-      throw await parseHttpError(response);
-    }
-  }
-  async importSelectorCache(request) {
-    if (!request.entries.length) {
-      return zeroImportResponse();
-    }
-    let totals = zeroImportResponse();
-    for (let offset = 0; offset < request.entries.length; offset += CACHE_IMPORT_BATCH_SIZE) {
-      const batch = request.entries.slice(
-        offset,
-        offset + CACHE_IMPORT_BATCH_SIZE
-      );
-      const response = await this.importSelectorCacheBatch(batch);
-      totals = mergeImportResponse(totals, response);
-    }
-    return totals;
-  }
-  async importSelectorCacheBatch(entries) {
-    const response = await fetch(`${this.baseUrl}/selector-cache/import`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...this.authHeaders()
-      },
-      body: JSON.stringify({ entries })
-    });
-    if (!response.ok) {
-      throw await parseHttpError(response);
-    }
-    return await response.json();
-  }
-  authHeaders() {
-    if (this.authScheme === "bearer") {
-      return {
-        authorization: `Bearer ${this.key}`
-      };
-    }
-    return {
-      "x-api-key": this.key
-    };
-  }
-};
-function normalizeBaseUrl(baseUrl) {
-  return baseUrl.replace(/\/+$/, "");
-}
-function parseCreateResponse(body, status) {
-  const root = requireObject(
-    body,
-    "Invalid cloud session create response: expected a JSON object.",
-    status
-  );
-  const sessionId = requireString(root, "sessionId", status);
-  const actionWsUrl = requireString(root, "actionWsUrl", status);
-  const cdpWsUrl = requireString(root, "cdpWsUrl", status);
-  const actionToken = requireString(root, "actionToken", status);
-  const cdpToken = requireString(root, "cdpToken", status);
-  const cloudSessionUrl = requireString(root, "cloudSessionUrl", status);
-  const cloudSessionRoot = requireObject(
-    root.cloudSession,
-    "Invalid cloud session create response: cloudSession must be an object.",
-    status
-  );
-  const cloudSession = {
-    sessionId: requireString(cloudSessionRoot, "sessionId", status, "cloudSession"),
-    workspaceId: requireString(
-      cloudSessionRoot,
-      "workspaceId",
-      status,
-      "cloudSession"
-    ),
-    state: requireString(cloudSessionRoot, "state", status, "cloudSession"),
-    createdAt: requireNumber(cloudSessionRoot, "createdAt", status, "cloudSession"),
-    sourceType: requireSourceType(cloudSessionRoot, "sourceType", status, "cloudSession"),
-    sourceRef: optionalString(cloudSessionRoot, "sourceRef", status, "cloudSession"),
-    label: optionalString(cloudSessionRoot, "label", status, "cloudSession")
-  };
-  const expiresAt = optionalNumber(root, "expiresAt", status);
-  return {
-    sessionId,
-    actionWsUrl,
-    cdpWsUrl,
-    actionToken,
-    cdpToken,
-    expiresAt,
-    cloudSessionUrl,
-    cloudSession
-  };
-}
-function requireObject(value, message, status) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new OpensteerCloudError("CLOUD_CONTRACT_MISMATCH", message, status);
-  }
-  return value;
-}
-function requireString(source, field, status, parent) {
-  const value = source[field];
-  if (typeof value !== "string" || !value.trim()) {
-    throw new OpensteerCloudError(
-      "CLOUD_CONTRACT_MISMATCH",
-      `Invalid cloud session create response: ${formatFieldPath(
-        field,
-        parent
-      )} must be a non-empty string.`,
-      status
-    );
-  }
-  return value;
-}
-function requireNumber(source, field, status, parent) {
-  const value = source[field];
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new OpensteerCloudError(
-      "CLOUD_CONTRACT_MISMATCH",
-      `Invalid cloud session create response: ${formatFieldPath(
-        field,
-        parent
-      )} must be a finite number.`,
-      status
-    );
-  }
-  return value;
-}
-function optionalString(source, field, status, parent) {
-  const value = source[field];
-  if (value == null) {
-    return void 0;
-  }
-  if (typeof value !== "string") {
-    throw new OpensteerCloudError(
-      "CLOUD_CONTRACT_MISMATCH",
-      `Invalid cloud session create response: ${formatFieldPath(
-        field,
-        parent
-      )} must be a string when present.`,
-      status
-    );
-  }
-  return value;
-}
-function optionalNumber(source, field, status, parent) {
-  const value = source[field];
-  if (value == null) {
-    return void 0;
-  }
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new OpensteerCloudError(
-      "CLOUD_CONTRACT_MISMATCH",
-      `Invalid cloud session create response: ${formatFieldPath(
-        field,
-        parent
-      )} must be a finite number when present.`,
-      status
-    );
-  }
-  return value;
-}
-function requireSourceType(source, field, status, parent) {
-  const value = source[field];
-  if (value === "agent-thread" || value === "agent-run" || value === "local-cloud" || value === "manual") {
-    return value;
-  }
-  throw new OpensteerCloudError(
-    "CLOUD_CONTRACT_MISMATCH",
-    `Invalid cloud session create response: ${formatFieldPath(
-      field,
-      parent
-    )} must be one of "agent-thread", "agent-run", "local-cloud", or "manual".`,
-    status
-  );
-}
-function formatFieldPath(field, parent) {
-  return parent ? `"${parent}.${field}"` : `"${field}"`;
-}
-function zeroImportResponse() {
-  return {
-    imported: 0,
-    inserted: 0,
-    updated: 0,
-    skipped: 0
-  };
-}
-function mergeImportResponse(first, second) {
-  return {
-    imported: first.imported + second.imported,
-    inserted: first.inserted + second.inserted,
-    updated: first.updated + second.updated,
-    skipped: first.skipped + second.skipped
-  };
-}
-async function parseHttpError(response) {
-  let body = null;
-  try {
-    body = await response.json();
-  } catch {
-    body = null;
-  }
-  const code = typeof body?.code === "string" ? toCloudErrorCode(body.code) : "CLOUD_TRANSPORT_ERROR";
-  const message = typeof body?.error === "string" ? body.error : `Cloud request failed with status ${response.status}.`;
-  return new OpensteerCloudError(code, message, response.status, body?.details);
-}
-function toCloudErrorCode(code) {
-  if (code === "CLOUD_AUTH_FAILED" || code === "CLOUD_SESSION_NOT_FOUND" || code === "CLOUD_SESSION_CLOSED" || code === "CLOUD_UNSUPPORTED_METHOD" || code === "CLOUD_INVALID_REQUEST" || code === "CLOUD_MODEL_NOT_ALLOWED" || code === "CLOUD_ACTION_FAILED" || code === "CLOUD_INTERNAL" || code === "CLOUD_CAPACITY_EXHAUSTED" || code === "CLOUD_RUNTIME_UNAVAILABLE" || code === "CLOUD_RUNTIME_MISMATCH" || code === "CLOUD_SESSION_STALE" || code === "CLOUD_CONTRACT_MISMATCH" || code === "CLOUD_CONTROL_PLANE_ERROR") {
-    return code;
-  }
-  return "CLOUD_TRANSPORT_ERROR";
-}
-
 // src/agent/errors.ts
 var OpensteerAgentError = class extends Error {
   constructor(message, cause) {
@@ -7149,15 +7122,15 @@ async function executeAgentAction(page, action) {
       return;
     }
     case "drag": {
-      const path5 = normalizePath(action.path);
-      if (!path5.length) {
+      const path3 = normalizePath(action.path);
+      if (!path3.length) {
         throw new OpensteerAgentActionError(
           "Drag action requires a non-empty path."
         );
       }
-      await page.mouse.move(path5[0].x, path5[0].y);
+      await page.mouse.move(path3[0].x, path3[0].y);
       await page.mouse.down();
-      for (const point of path5.slice(1)) {
+      for (const point of path3.slice(1)) {
         await page.mouse.move(point.x, point.y);
       }
       await page.mouse.up();
@@ -7253,10 +7226,10 @@ async function maybeFocusPoint(page, action) {
     clickCount: 1
   });
 }
-function normalizePath(path5) {
-  if (!Array.isArray(path5)) return [];
+function normalizePath(path3) {
+  if (!Array.isArray(path3)) return [];
   const points = [];
-  for (const entry of path5) {
+  for (const entry of path3) {
     if (!entry || typeof entry !== "object") continue;
     const candidate = entry;
     const x = Number(candidate.x);
@@ -7345,24 +7318,22 @@ var OpensteerCuaAgentHandler = class {
   page;
   config;
   client;
-  debug;
+  cursorController;
   onMutatingAction;
-  cursorOverlayInjected = false;
   constructor(options) {
     this.page = options.page;
     this.config = options.config;
     this.client = options.client;
-    this.debug = options.debug;
+    this.cursorController = options.cursorController;
     this.onMutatingAction = options.onMutatingAction;
   }
   async execute(options) {
     const instruction = options.instruction;
     const maxSteps = options.maxSteps ?? 20;
     await this.initializeClient();
-    const highlightCursor = options.highlightCursor === true;
     this.client.setActionHandler(async (action) => {
-      if (highlightCursor) {
-        await this.maybeRenderCursor(action);
+      if (this.cursorController.isEnabled()) {
+        await this.maybePreviewCursor(action);
       }
       await executeAgentAction(this.page, action);
       this.client.setCurrentUrl(this.page.url());
@@ -7393,6 +7364,7 @@ var OpensteerCuaAgentHandler = class {
     const viewport = await this.resolveViewport();
     this.client.setViewport(viewport.width, viewport.height);
     this.client.setCurrentUrl(this.page.url());
+    await this.cursorController.attachPage(this.page);
     this.client.setScreenshotProvider(async () => {
       const buffer = await this.page.screenshot({
         fullPage: false,
@@ -7421,55 +7393,615 @@ var OpensteerCuaAgentHandler = class {
     }
     return DEFAULT_CUA_VIEWPORT;
   }
-  async maybeRenderCursor(action) {
+  async maybePreviewCursor(action) {
     const x = typeof action.x === "number" ? action.x : null;
     const y = typeof action.y === "number" ? action.y : null;
     if (x == null || y == null) {
       return;
     }
+    await this.cursorController.preview({ x, y }, "agent");
+  }
+};
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+
+// src/cursor/motion.ts
+var DEFAULT_SNAPPY_OPTIONS = {
+  minDurationMs: 46,
+  maxDurationMs: 170,
+  maxPoints: 14
+};
+function planSnappyCursorMotion(from, to, options = {}) {
+  const resolved = {
+    ...DEFAULT_SNAPPY_OPTIONS,
+    ...options
+  };
+  const dx = to.x - from.x;
+  const dy = to.y - from.y;
+  const distance = Math.hypot(dx, dy);
+  if (distance < 5) {
+    return {
+      points: [roundPoint(to)],
+      stepDelayMs: 0
+    };
+  }
+  const durationMs = clamp(
+    44 + distance * 0.26,
+    resolved.minDurationMs,
+    resolved.maxDurationMs
+  );
+  const rawPoints = clamp(
+    Math.round(durationMs / 13),
+    4,
+    resolved.maxPoints
+  );
+  const sign = deterministicBendSign(from, to);
+  const nx = -dy / distance;
+  const ny = dx / distance;
+  const bend = clamp(distance * 0.12, 8, 28) * sign;
+  const c1 = {
+    x: from.x + dx * 0.28 + nx * bend,
+    y: from.y + dy * 0.28 + ny * bend
+  };
+  const c2 = {
+    x: from.x + dx * 0.74 + nx * bend * 0.58,
+    y: from.y + dy * 0.74 + ny * bend * 0.58
+  };
+  const points = [];
+  for (let i = 1; i <= rawPoints; i += 1) {
+    const t = i / rawPoints;
+    const sampled = cubicBezier(from, c1, c2, to, t);
+    if (i !== rawPoints) {
+      const previous = points[points.length - 1];
+      if (previous && distanceBetween(previous, sampled) < 1.4) {
+        continue;
+      }
+    }
+    points.push(roundPoint(sampled));
+  }
+  if (distance > 220) {
+    const settle = {
+      x: to.x - dx / distance,
+      y: to.y - dy / distance
+    };
+    const last = points[points.length - 1];
+    if (!last || distanceBetween(last, settle) > 1.2) {
+      points.splice(Math.max(0, points.length - 1), 0, roundPoint(settle));
+    }
+  }
+  const deduped = dedupeAdjacent(points);
+  const stepDelayMs = deduped.length > 1 ? Math.round(durationMs / deduped.length) : 0;
+  return {
+    points: deduped.length ? deduped : [roundPoint(to)],
+    stepDelayMs
+  };
+}
+function cubicBezier(p0, p1, p2, p3, t) {
+  const inv = 1 - t;
+  const inv2 = inv * inv;
+  const inv3 = inv2 * inv;
+  const t2 = t * t;
+  const t3 = t2 * t;
+  return {
+    x: inv3 * p0.x + 3 * inv2 * t * p1.x + 3 * inv * t2 * p2.x + t3 * p3.x,
+    y: inv3 * p0.y + 3 * inv2 * t * p1.y + 3 * inv * t2 * p2.y + t3 * p3.y
+  };
+}
+function deterministicBendSign(from, to) {
+  const seed = Math.sin(
+    from.x * 12.9898 + from.y * 78.233 + to.x * 37.719 + to.y * 19.113
+  ) * 43758.5453;
+  const fractional = seed - Math.floor(seed);
+  return fractional >= 0.5 ? 1 : -1;
+}
+function roundPoint(point) {
+  return {
+    x: Math.round(point.x * 100) / 100,
+    y: Math.round(point.y * 100) / 100
+  };
+}
+function distanceBetween(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function dedupeAdjacent(points) {
+  const out = [];
+  for (const point of points) {
+    const last = out[out.length - 1];
+    if (last && last.x === point.x && last.y === point.y) {
+      continue;
+    }
+    out.push(point);
+  }
+  return out;
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+// src/cursor/renderers/svg-overlay.ts
+var PULSE_DURATION_MS = 220;
+var HOST_ELEMENT_ID = "__os_cr";
+var SvgCursorRenderer = class {
+  page = null;
+  active = false;
+  reason = "disabled";
+  lastMessage;
+  async initialize(page) {
+    this.page = page;
+    if (page.isClosed()) {
+      this.markInactive("page_closed");
+      return;
+    }
+    try {
+      await page.evaluate(injectCursor, HOST_ELEMENT_ID);
+      this.active = true;
+      this.reason = void 0;
+      this.lastMessage = void 0;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.markInactive("renderer_error", message);
+    }
+  }
+  isActive() {
+    return this.active;
+  }
+  status() {
+    return {
+      enabled: true,
+      active: this.active,
+      reason: this.reason ? this.lastMessage ? `${this.reason}: ${this.lastMessage}` : this.reason : void 0
+    };
+  }
+  async move(point, style) {
+    if (!this.active || !this.page || this.page.isClosed()) return;
     try {
-      if (!this.cursorOverlayInjected) {
-        await this.page.evaluate(() => {
-          if (document.getElementById("__opensteer_cua_cursor")) return;
-          const cursor = document.createElement("div");
-          cursor.id = "__opensteer_cua_cursor";
-          cursor.style.position = "fixed";
-          cursor.style.width = "14px";
-          cursor.style.height = "14px";
-          cursor.style.borderRadius = "999px";
-          cursor.style.background = "rgba(255, 51, 51, 0.85)";
-          cursor.style.border = "2px solid rgba(255, 255, 255, 0.95)";
-          cursor.style.boxShadow = "0 0 0 3px rgba(255, 51, 51, 0.25)";
-          cursor.style.pointerEvents = "none";
-          cursor.style.zIndex = "2147483647";
-          cursor.style.transform = "translate(-9999px, -9999px)";
-          cursor.style.transition = "transform 80ms linear";
-          document.documentElement.appendChild(cursor);
+      const ok = await this.page.evaluate(moveCursor, {
+        id: HOST_ELEMENT_ID,
+        x: point.x,
+        y: point.y,
+        size: style.size,
+        fill: colorToRgba(style.fillColor),
+        outline: colorToRgba(style.outlineColor)
+      });
+      if (!ok) {
+        await this.reinject();
+        await this.page.evaluate(moveCursor, {
+          id: HOST_ELEMENT_ID,
+          x: point.x,
+          y: point.y,
+          size: style.size,
+          fill: colorToRgba(style.fillColor),
+          outline: colorToRgba(style.outlineColor)
+        });
+      }
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async pulse(point, style) {
+    if (!this.active || !this.page || this.page.isClosed()) return;
+    try {
+      const ok = await this.page.evaluate(pulseCursor, {
+        id: HOST_ELEMENT_ID,
+        x: point.x,
+        y: point.y,
+        size: style.size,
+        fill: colorToRgba(style.fillColor),
+        outline: colorToRgba(style.outlineColor),
+        halo: colorToRgba(style.haloColor),
+        pulseMs: PULSE_DURATION_MS
+      });
+      if (!ok) {
+        await this.reinject();
+        await this.page.evaluate(pulseCursor, {
+          id: HOST_ELEMENT_ID,
+          x: point.x,
+          y: point.y,
+          size: style.size,
+          fill: colorToRgba(style.fillColor),
+          outline: colorToRgba(style.outlineColor),
+          halo: colorToRgba(style.haloColor),
+          pulseMs: PULSE_DURATION_MS
         });
-        this.cursorOverlayInjected = true;
       }
-      await this.page.evaluate(
-        ({ px, py }) => {
-          const cursor = document.getElementById("__opensteer_cua_cursor");
-          if (!cursor) return;
-          cursor.style.transform = `translate(${Math.round(px - 7)}px, ${Math.round(py - 7)}px)`;
-        },
-        { px: x, py: y }
-      );
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async clear() {
+    if (!this.page || this.page.isClosed()) return;
+    try {
+      await this.page.evaluate(removeCursor, HOST_ELEMENT_ID);
+    } catch {
+    }
+  }
+  async dispose() {
+    if (this.page && !this.page.isClosed()) {
+      try {
+        await this.page.evaluate(removeCursor, HOST_ELEMENT_ID);
+      } catch {
+      }
+    }
+    this.active = false;
+    this.reason = "disabled";
+    this.lastMessage = void 0;
+    this.page = null;
+  }
+  async reinject() {
+    if (!this.page || this.page.isClosed()) return;
+    try {
+      await this.page.evaluate(injectCursor, HOST_ELEMENT_ID);
+    } catch {
+    }
+  }
+  markInactive(reason, message) {
+    this.active = false;
+    this.reason = reason;
+    this.lastMessage = message;
+  }
+  handleError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (isPageGone(message)) {
+      this.markInactive("page_closed", message);
+    }
+  }
+};
+function injectCursor(hostId) {
+  const win = window;
+  if (win[hostId]) return;
+  const host = document.createElement("div");
+  host.style.cssText = "position:fixed;top:0;left:0;width:0;height:0;z-index:2147483647;pointer-events:none;";
+  const shadow = host.attachShadow({ mode: "closed" });
+  const wrapper = document.createElement("div");
+  wrapper.style.cssText = "position:fixed;top:0;left:0;pointer-events:none;will-change:transform;display:none;";
+  wrapper.innerHTML = `
+        <svg width="28" height="28" viewBox="0 0 28 28" fill="none" xmlns="http://www.w3.org/2000/svg" style="filter:drop-shadow(0 1px 2px rgba(0,0,0,0.3));display:block;">
+            <path d="M3 2L3 23L8.5 17.5L13 26L17 24L12.5 15.5L20 15.5L3 2Z"
+                  fill="white" stroke="black" stroke-width="1.5" stroke-linejoin="round"/>
+        </svg>
+        <div data-role="pulse" style="position:absolute;top:0;left:0;width:24px;height:24px;border-radius:50%;pointer-events:none;opacity:0;transform:translate(-8px,-8px);"></div>
+    `;
+  shadow.appendChild(wrapper);
+  document.documentElement.appendChild(host);
+  Object.defineProperty(window, hostId, {
+    value: {
+      host,
+      wrapper,
+      path: wrapper.querySelector("path"),
+      pulse: wrapper.querySelector('[data-role="pulse"]')
+    },
+    configurable: true,
+    enumerable: false
+  });
+}
+function moveCursor(args) {
+  const refs = window[args.id];
+  if (!refs) return false;
+  const scale = args.size / 20;
+  refs.wrapper.style.transform = `translate(${args.x}px, ${args.y}px) scale(${scale})`;
+  refs.wrapper.style.display = "block";
+  if (refs.path) {
+    refs.path.setAttribute("fill", args.fill);
+    refs.path.setAttribute("stroke", args.outline);
+  }
+  return true;
+}
+function pulseCursor(args) {
+  const refs = window[args.id];
+  if (!refs) return false;
+  const scale = args.size / 20;
+  refs.wrapper.style.transform = `translate(${args.x}px, ${args.y}px) scale(${scale})`;
+  refs.wrapper.style.display = "block";
+  if (refs.path) {
+    refs.path.setAttribute("fill", args.fill);
+    refs.path.setAttribute("stroke", args.outline);
+  }
+  const ring = refs.pulse;
+  if (!ring) return true;
+  ring.style.background = args.halo;
+  ring.style.opacity = "0.7";
+  ring.style.width = "24px";
+  ring.style.height = "24px";
+  ring.style.transition = `all ${args.pulseMs}ms ease-out`;
+  ring.offsetHeight;
+  ring.style.width = "48px";
+  ring.style.height = "48px";
+  ring.style.opacity = "0";
+  ring.style.transform = "translate(-20px, -20px)";
+  setTimeout(() => {
+    ring.style.transition = "none";
+    ring.style.width = "24px";
+    ring.style.height = "24px";
+    ring.style.transform = "translate(-8px, -8px)";
+    ring.style.opacity = "0";
+  }, args.pulseMs);
+  return true;
+}
+function removeCursor(hostId) {
+  const refs = window[hostId];
+  if (refs) {
+    refs.host.remove();
+    delete window[hostId];
+  }
+}
+function colorToRgba(c) {
+  return `rgba(${Math.round(c.r)},${Math.round(c.g)},${Math.round(c.b)},${c.a})`;
+}
+function isPageGone(message) {
+  const m = message.toLowerCase();
+  return m.includes("closed") || m.includes("detached") || m.includes("destroyed") || m.includes("target");
+}
+
+// src/cursor/controller.ts
+var DEFAULT_STYLE = {
+  size: 20,
+  fillColor: {
+    r: 255,
+    g: 255,
+    b: 255,
+    a: 0.96
+  },
+  outlineColor: {
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 1
+  },
+  haloColor: {
+    r: 35,
+    g: 162,
+    b: 255,
+    a: 0.38
+  },
+  pulseScale: 2.15
+};
+var REINITIALIZE_BACKOFF_MS = 1e3;
+var FIRST_MOVE_CENTER_DISTANCE_THRESHOLD = 16;
+var FIRST_MOVE_MAX_TRAVEL = 220;
+var FIRST_MOVE_NEAR_TARGET_X_OFFSET = 28;
+var FIRST_MOVE_NEAR_TARGET_Y_OFFSET = 18;
+var MOTION_PLANNERS = {
+  snappy: planSnappyCursorMotion
+};
+var CursorController = class {
+  debug;
+  renderer;
+  page = null;
+  listenerPage = null;
+  lastPoint = null;
+  initializedForPage = false;
+  lastInitializeAttemptAt = 0;
+  enabled;
+  profile;
+  style;
+  onDomContentLoaded = () => {
+    void this.restoreCursorAfterNavigation();
+  };
+  constructor(options = {}) {
+    const config = options.config || {};
+    this.debug = Boolean(options.debug);
+    this.enabled = config.enabled === true;
+    this.profile = config.profile ?? "snappy";
+    this.style = mergeStyle(config.style);
+    this.renderer = options.renderer ?? new SvgCursorRenderer();
+  }
+  setEnabled(enabled) {
+    if (this.enabled && !enabled) {
+      this.lastPoint = null;
+      void this.clear();
+    }
+    this.enabled = enabled;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  getStatus() {
+    if (!this.enabled) {
+      return {
+        enabled: false,
+        active: false,
+        reason: "disabled"
+      };
+    }
+    const status = this.renderer.status();
+    if (!this.initializedForPage && !status.active) {
+      return {
+        enabled: true,
+        active: false,
+        reason: "not_initialized"
+      };
+    }
+    return status;
+  }
+  async attachPage(page) {
+    if (this.page !== page) {
+      this.detachPageListeners();
+      this.page = page;
+      this.lastPoint = null;
+      this.initializedForPage = false;
+      this.lastInitializeAttemptAt = 0;
+    }
+    this.attachPageListeners(page);
+  }
+  async preview(point, intent) {
+    if (!this.enabled || !point) return;
+    if (!this.page || this.page.isClosed()) return;
+    try {
+      await this.ensureInitialized();
+      if (!this.renderer.isActive()) {
+        await this.reinitializeIfEligible();
+      }
+      if (!this.renderer.isActive()) return;
+      const start = this.resolveMotionStart(point);
+      const motion = this.planMotion(start, point);
+      for (const step of motion.points) {
+        await this.renderer.move(step, this.style);
+        if (motion.stepDelayMs > 0) {
+          await sleep4(motion.stepDelayMs);
+        }
+      }
+      if (shouldPulse(intent)) {
+        await this.renderer.pulse(point, this.style);
+      }
+      this.lastPoint = point;
     } catch (error) {
       if (this.debug) {
         const message = error instanceof Error ? error.message : String(error);
-        console.warn(`[opensteer] cursor overlay failed: ${message}`);
+        console.warn(`[opensteer] cursor preview failed: ${message}`);
       }
     }
   }
+  async clear() {
+    try {
+      await this.renderer.clear();
+    } catch (error) {
+      if (this.debug) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[opensteer] cursor clear failed: ${message}`);
+      }
+    }
+  }
+  async dispose() {
+    this.detachPageListeners();
+    this.lastPoint = null;
+    this.initializedForPage = false;
+    this.lastInitializeAttemptAt = 0;
+    this.page = null;
+    await this.renderer.dispose();
+  }
+  async ensureInitialized() {
+    if (!this.page || this.page.isClosed()) return;
+    if (this.initializedForPage) return;
+    await this.initializeRenderer();
+  }
+  attachPageListeners(page) {
+    if (this.listenerPage === page) {
+      return;
+    }
+    this.detachPageListeners();
+    page.on("domcontentloaded", this.onDomContentLoaded);
+    this.listenerPage = page;
+  }
+  detachPageListeners() {
+    if (!this.listenerPage) {
+      return;
+    }
+    this.listenerPage.off("domcontentloaded", this.onDomContentLoaded);
+    this.listenerPage = null;
+  }
+  planMotion(from, to) {
+    return MOTION_PLANNERS[this.profile](from, to);
+  }
+  async reinitializeIfEligible() {
+    if (!this.page || this.page.isClosed()) return;
+    const elapsed = Date.now() - this.lastInitializeAttemptAt;
+    if (elapsed < REINITIALIZE_BACKOFF_MS) return;
+    await this.initializeRenderer();
+  }
+  async initializeRenderer() {
+    if (!this.page || this.page.isClosed()) return;
+    this.lastInitializeAttemptAt = Date.now();
+    await this.renderer.initialize(this.page);
+    this.initializedForPage = true;
+  }
+  async restoreCursorAfterNavigation() {
+    if (!this.enabled || !this.lastPoint) return;
+    if (!this.page || this.page.isClosed()) return;
+    try {
+      if (!this.renderer.isActive()) {
+        await this.reinitializeIfEligible();
+      }
+      if (!this.renderer.isActive()) {
+        return;
+      }
+      await this.renderer.move(this.lastPoint, this.style);
+    } catch (error) {
+      if (this.debug) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(
+          `[opensteer] cursor restore after navigation failed: ${message}`
+        );
+      }
+    }
+  }
+  resolveMotionStart(target) {
+    if (this.lastPoint) {
+      return this.lastPoint;
+    }
+    const viewport = this.page?.viewportSize();
+    if (!viewport?.width || !viewport?.height) {
+      return target;
+    }
+    const centerPoint = {
+      x: viewport.width / 2,
+      y: viewport.height / 2
+    };
+    if (distanceBetween2(centerPoint, target) > FIRST_MOVE_CENTER_DISTANCE_THRESHOLD) {
+      const dx = target.x - centerPoint.x;
+      const dy = target.y - centerPoint.y;
+      const distance = Math.hypot(dx, dy);
+      if (distance > FIRST_MOVE_MAX_TRAVEL) {
+        const ux = dx / distance;
+        const uy = dy / distance;
+        return {
+          x: target.x - ux * FIRST_MOVE_MAX_TRAVEL,
+          y: target.y - uy * FIRST_MOVE_MAX_TRAVEL
+        };
+      }
+      return centerPoint;
+    }
+    return {
+      x: clamp2(target.x - FIRST_MOVE_NEAR_TARGET_X_OFFSET, 0, viewport.width),
+      y: clamp2(target.y - FIRST_MOVE_NEAR_TARGET_Y_OFFSET, 0, viewport.height)
+    };
+  }
 };
-function sleep3(ms) {
-  return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+function mergeStyle(style) {
+  return {
+    size: normalizeFinite(style?.size, DEFAULT_STYLE.size, 4, 48),
+    pulseScale: normalizeFinite(
+      style?.pulseScale,
+      DEFAULT_STYLE.pulseScale,
+      1,
+      3
+    ),
+    fillColor: normalizeColor(style?.fillColor, DEFAULT_STYLE.fillColor),
+    outlineColor: normalizeColor(
+      style?.outlineColor,
+      DEFAULT_STYLE.outlineColor
+    ),
+    haloColor: normalizeColor(style?.haloColor, DEFAULT_STYLE.haloColor)
+  };
+}
+function normalizeColor(color, fallback) {
+  if (!color) return { ...fallback };
+  return {
+    r: normalizeFinite(color.r, fallback.r, 0, 255),
+    g: normalizeFinite(color.g, fallback.g, 0, 255),
+    b: normalizeFinite(color.b, fallback.b, 0, 255),
+    a: normalizeFinite(color.a, fallback.a, 0, 1)
+  };
+}
+function normalizeFinite(value, fallback, min, max) {
+  const numeric = typeof value === "number" && Number.isFinite(value) ? value : fallback;
+  return Math.min(max, Math.max(min, numeric));
+}
+function distanceBetween2(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function clamp2(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function shouldPulse(intent) {
+  return intent === "click" || intent === "dblclick" || intent === "rightclick" || intent === "agent";
+}
+function sleep4(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // src/opensteer.ts
-import { createHash, randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID } from "crypto";
 
 // src/browser/pool.ts
 import {
@@ -7813,19 +8345,10 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/browser/chrome.ts
-import { homedir, platform } from "os";
-import { join } from "path";
-function expandHome(p) {
-  if (p.startsWith("~/") || p === "~") {
-    return join(homedir(), p.slice(1));
-  }
-  return p;
-}
-
 // src/browser/pool.ts
 var BrowserPool = class {
   browser = null;
+  persistentContext = null;
   cdpProxy = null;
   defaults;
   constructor(defaults = {}) {
@@ -7841,16 +8364,23 @@ var BrowserPool = class {
     if (connectUrl) {
       return this.connectToRunning(connectUrl, options.timeout);
     }
-    if (channel || profileDir) {
-      return this.launchWithProfile(options, channel, profileDir);
+    if (profileDir) {
+      return this.launchPersistentProfile(options, channel, profileDir);
+    }
+    if (channel) {
+      return this.launchWithChannel(options, channel);
     }
     return this.launchSandbox(options);
   }
   async close() {
     const browser = this.browser;
+    const persistentContext = this.persistentContext;
     this.browser = null;
+    this.persistentContext = null;
     try {
-      if (browser) {
+      if (persistentContext) {
+        await persistentContext.close();
+      } else if (browser) {
         await browser.close();
       }
     } finally {
@@ -7876,6 +8406,7 @@ var BrowserPool = class {
         timeout: timeout ?? 3e4
       });
       this.browser = browser;
+      this.persistentContext = null;
       const contexts = browser.contexts();
       if (contexts.length === 0) {
         throw new Error(
@@ -7891,442 +8422,69 @@ var BrowserPool = class {
         await browser.close().catch(() => void 0);
       }
       this.browser = null;
-      this.cdpProxy?.close();
-      this.cdpProxy = null;
-      throw error;
-    }
-  }
-  async launchWithProfile(options, channel, profileDir) {
-    const args = [];
-    if (profileDir) {
-      args.push(`--user-data-dir=${expandHome(profileDir)}`);
-    }
-    const browser = await chromium2.launch({
-      channel,
-      headless: options.headless ?? this.defaults.headless,
-      executablePath: options.executablePath ?? this.defaults.executablePath ?? void 0,
-      slowMo: options.slowMo ?? this.defaults.slowMo ?? 0,
-      args
-    });
-    this.browser = browser;
-    const contexts = browser.contexts();
-    let context;
-    let page;
-    if (contexts.length > 0) {
-      context = contexts[0];
-      const pages = context.pages();
-      page = pages.length > 0 ? pages[0] : await context.newPage();
-    } else {
-      context = await browser.newContext(options.context || {});
-      page = await context.newPage();
-    }
-    return { browser, context, page, isExternal: false };
-  }
-  async launchSandbox(options) {
-    const browser = await chromium2.launch({
-      headless: options.headless ?? this.defaults.headless,
-      executablePath: options.executablePath ?? this.defaults.executablePath ?? void 0,
-      slowMo: options.slowMo ?? this.defaults.slowMo ?? 0
-    });
-    const context = await browser.newContext(options.context || {});
-    const page = await context.newPage();
-    this.browser = browser;
-    return { browser, context, page, isExternal: false };
-  }
-};
-
-// src/config.ts
-import fs3 from "fs";
-import path4 from "path";
-import { fileURLToPath } from "url";
-import { parse as parseDotenv } from "dotenv";
-var DEFAULT_CONFIG = {
-  browser: {
-    headless: false,
-    executablePath: void 0,
-    slowMo: 0,
-    connectUrl: void 0,
-    channel: void 0,
-    profileDir: void 0
-  },
-  storage: {
-    rootDir: process.cwd()
-  },
-  model: "gpt-5.1",
-  debug: false
-};
-function dotenvFileOrder(nodeEnv) {
-  const normalized = nodeEnv?.trim() || "";
-  const files = [];
-  if (normalized) {
-    files.push(`.env.${normalized}.local`);
-  }
-  if (normalized !== "test") {
-    files.push(".env.local");
-  }
-  if (normalized) {
-    files.push(`.env.${normalized}`);
-  }
-  files.push(".env");
-  return files;
-}
-function loadDotenvValues(rootDir, baseEnv, options = {}) {
-  const values = {};
-  if (parseBool(baseEnv.OPENSTEER_DISABLE_DOTENV_AUTOLOAD) === true) {
-    return values;
-  }
-  const debug = options.debug ?? parseBool(baseEnv.OPENSTEER_DEBUG) === true;
-  const baseDir = path4.resolve(rootDir);
-  const nodeEnv = baseEnv.NODE_ENV?.trim() || "";
-  for (const filename of dotenvFileOrder(nodeEnv)) {
-    const filePath = path4.join(baseDir, filename);
-    if (!fs3.existsSync(filePath)) continue;
-    try {
-      const raw = fs3.readFileSync(filePath, "utf8");
-      const parsed = parseDotenv(raw);
-      for (const [key, value] of Object.entries(parsed)) {
-        if (values[key] === void 0) {
-          values[key] = value;
-        }
-      }
-    } catch (error) {
-      const message = extractErrorMessage(
-        error,
-        "Unable to read or parse dotenv file."
-      );
-      if (debug) {
-        console.warn(
-          `[opensteer] failed to load dotenv file "${filePath}": ${message}`
-        );
-      }
-      continue;
-    }
-  }
-  return values;
-}
-function resolveEnv(rootDir, options = {}) {
-  const baseEnv = process.env;
-  const dotenvValues = loadDotenvValues(rootDir, baseEnv, options);
-  return {
-    ...dotenvValues,
-    ...baseEnv
-  };
-}
-function hasOwn(config, key) {
-  if (!config || typeof config !== "object") return false;
-  return Object.prototype.hasOwnProperty.call(config, key);
-}
-function hasLegacyAiConfig(config) {
-  return hasOwn(config, "ai");
-}
-function assertNoLegacyAiConfig(source, config) {
-  if (hasLegacyAiConfig(config)) {
-    throw new Error(
-      `Legacy "ai" config is no longer supported in ${source}. Use top-level "model" instead.`
-    );
-  }
-}
-function assertNoLegacyRuntimeConfig(source, config) {
-  if (!config || typeof config !== "object") return;
-  const configRecord = config;
-  if (hasOwn(configRecord, "runtime")) {
-    throw new Error(
-      `Legacy "runtime" config is no longer supported in ${source}. Use top-level "cloud" instead.`
-    );
-  }
-  if (hasOwn(configRecord, "mode")) {
-    throw new Error(
-      `Top-level "mode" config is no longer supported in ${source}. Use "cloud: true" to enable cloud mode.`
-    );
-  }
-  if (hasOwn(configRecord, "remote")) {
-    throw new Error(
-      `Top-level "remote" config is no longer supported in ${source}. Use "cloud" options instead.`
-    );
-  }
-  if (hasOwn(configRecord, "apiKey")) {
-    throw new Error(
-      `Top-level "apiKey" config is not supported in ${source}. Use "cloud.apiKey" instead.`
-    );
-  }
-}
-function loadConfigFile(rootDir, options = {}) {
-  const configPath = path4.join(rootDir, ".opensteer", "config.json");
-  if (!fs3.existsSync(configPath)) return {};
-  try {
-    const raw = fs3.readFileSync(configPath, "utf8");
-    return JSON.parse(raw);
-  } catch (error) {
-    const message = extractErrorMessage(
-      error,
-      "Unable to read or parse config file."
-    );
-    if (options.debug) {
-      console.warn(
-        `[opensteer] failed to load config file "${configPath}": ${message}`
-      );
-    }
-    return {};
-  }
-}
-function mergeDeep(base, patch) {
-  const out = {
-    ...base
-  };
-  for (const [key, value] of Object.entries(patch || {})) {
-    const currentValue = out[key];
-    if (value && typeof value === "object" && !Array.isArray(value) && currentValue && typeof currentValue === "object" && !Array.isArray(currentValue)) {
-      out[key] = mergeDeep(
-        currentValue,
-        value
-      );
-      continue;
-    }
-    if (value !== void 0) {
-      out[key] = value;
-    }
-  }
-  return out;
-}
-function parseBool(value) {
-  if (value == null) return void 0;
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "true" || normalized === "1") return true;
-  if (normalized === "false" || normalized === "0") return false;
-  return void 0;
-}
-function parseNumber(value) {
-  if (value == null || value.trim() === "") return void 0;
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) return void 0;
-  return parsed;
-}
-function parseRuntimeMode(value, source) {
-  if (value == null) return void 0;
-  if (typeof value !== "string") {
-    throw new Error(
-      `Invalid ${source} value "${String(value)}". Use "local" or "cloud".`
-    );
-  }
-  const normalized = value.trim().toLowerCase();
-  if (!normalized) return void 0;
-  if (normalized === "local" || normalized === "cloud") {
-    return normalized;
-  }
-  throw new Error(
-    `Invalid ${source} value "${value}". Use "local" or "cloud".`
-  );
-}
-function parseAuthScheme(value, source) {
-  if (value == null) return void 0;
-  if (typeof value !== "string") {
-    throw new Error(
-      `Invalid ${source} value "${String(value)}". Use "api-key" or "bearer".`
-    );
-  }
-  const normalized = value.trim().toLowerCase();
-  if (!normalized) return void 0;
-  if (normalized === "api-key" || normalized === "bearer") {
-    return normalized;
-  }
-  throw new Error(
-    `Invalid ${source} value "${value}". Use "api-key" or "bearer".`
-  );
-}
-function parseCloudAnnounce(value, source) {
-  if (value == null) return void 0;
-  if (typeof value !== "string") {
-    throw new Error(
-      `Invalid ${source} value "${String(value)}". Use "always", "off", or "tty".`
-    );
-  }
-  const normalized = value.trim().toLowerCase();
-  if (!normalized) return void 0;
-  if (normalized === "always" || normalized === "off" || normalized === "tty") {
-    return normalized;
-  }
-  throw new Error(
-    `Invalid ${source} value "${value}". Use "always", "off", or "tty".`
-  );
-}
-function resolveOpensteerApiKey(env) {
-  const value = env.OPENSTEER_API_KEY?.trim();
-  if (!value) return void 0;
-  return value;
-}
-function resolveOpensteerBaseUrl(env) {
-  const value = env.OPENSTEER_BASE_URL?.trim();
-  if (!value) return void 0;
-  return value;
-}
-function resolveOpensteerAuthScheme(env) {
-  return parseAuthScheme(env.OPENSTEER_AUTH_SCHEME, "OPENSTEER_AUTH_SCHEME");
-}
-function normalizeCloudOptions(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return void 0;
-  }
-  return value;
-}
-function parseCloudEnabled(value, source) {
-  if (value == null) return void 0;
-  if (typeof value === "boolean") return value;
-  if (typeof value === "object" && !Array.isArray(value)) return true;
-  throw new Error(
-    `Invalid ${source} value "${String(value)}". Use true, false, or a cloud options object.`
-  );
-}
-function resolveCloudSelection(config, env = process.env) {
-  const configCloud = parseCloudEnabled(config.cloud, "cloud");
-  if (configCloud !== void 0) {
-    return {
-      cloud: configCloud,
-      source: "config.cloud"
-    };
-  }
-  const envMode = parseRuntimeMode(env.OPENSTEER_MODE, "OPENSTEER_MODE");
-  if (envMode) {
-    return {
-      cloud: envMode === "cloud",
-      source: "env.OPENSTEER_MODE"
-    };
-  }
-  return {
-    cloud: false,
-    source: "default"
-  };
-}
-function resolveConfigWithEnv(input = {}) {
-  const processEnv = process.env;
-  const debugHint = typeof input.debug === "boolean" ? input.debug : parseBool(processEnv.OPENSTEER_DEBUG) === true;
-  const initialRootDir = input.storage?.rootDir ?? process.cwd();
-  const runtimeDefaults = mergeDeep(DEFAULT_CONFIG, {
-    storage: {
-      rootDir: initialRootDir
-    }
-  });
-  assertNoLegacyAiConfig("Opensteer constructor config", input);
-  assertNoLegacyRuntimeConfig("Opensteer constructor config", input);
-  const fileConfig = loadConfigFile(initialRootDir, {
-    debug: debugHint
-  });
-  assertNoLegacyAiConfig(".opensteer/config.json", fileConfig);
-  assertNoLegacyRuntimeConfig(".opensteer/config.json", fileConfig);
-  const fileRootDir = typeof fileConfig.storage?.rootDir === "string" ? fileConfig.storage.rootDir : void 0;
-  const envRootDir = input.storage?.rootDir ?? fileRootDir ?? initialRootDir;
-  const env = resolveEnv(envRootDir, {
-    debug: debugHint
-  });
-  if (env.OPENSTEER_AI_MODEL) {
-    throw new Error(
-      "OPENSTEER_AI_MODEL is no longer supported. Use OPENSTEER_MODEL instead."
-    );
+      this.persistentContext = null;
+      this.cdpProxy?.close();
+      this.cdpProxy = null;
+      throw error;
+    }
   }
-  if (env.OPENSTEER_RUNTIME != null) {
-    throw new Error(
-      "OPENSTEER_RUNTIME is no longer supported. Use OPENSTEER_MODE instead."
+  async launchPersistentProfile(options, channel, profileDir) {
+    const args = [];
+    const launchProfile = resolvePersistentChromiumLaunchProfile(profileDir);
+    if (launchProfile.profileDirectory) {
+      args.push(`--profile-directory=${launchProfile.profileDirectory}`);
+    }
+    const context = await chromium2.launchPersistentContext(
+      launchProfile.userDataDir,
+      {
+        channel,
+        headless: options.headless ?? this.defaults.headless,
+        executablePath: options.executablePath ?? this.defaults.executablePath ?? void 0,
+        slowMo: options.slowMo ?? this.defaults.slowMo ?? 0,
+        timeout: options.timeout,
+        ...options.context || {},
+        args
+      }
     );
+    const browser = context.browser();
+    if (!browser) {
+      await context.close().catch(() => void 0);
+      throw new Error("Persistent browser launch did not expose a browser instance.");
+    }
+    this.browser = browser;
+    this.persistentContext = context;
+    const pages = context.pages();
+    const page = pages.length > 0 ? pages[0] : await context.newPage();
+    return { browser, context, page, isExternal: false };
   }
-  const envConfig = {
-    browser: {
-      headless: parseBool(env.OPENSTEER_HEADLESS),
-      executablePath: env.OPENSTEER_BROWSER_PATH || void 0,
-      slowMo: parseNumber(env.OPENSTEER_SLOW_MO),
-      connectUrl: env.OPENSTEER_CONNECT_URL || void 0,
-      channel: env.OPENSTEER_CHANNEL || void 0,
-      profileDir: env.OPENSTEER_PROFILE_DIR || void 0
-    },
-    model: env.OPENSTEER_MODEL || void 0,
-    debug: parseBool(env.OPENSTEER_DEBUG)
-  };
-  const mergedWithFile = mergeDeep(runtimeDefaults, fileConfig);
-  const mergedWithEnv = mergeDeep(mergedWithFile, envConfig);
-  const resolved = mergeDeep(mergedWithEnv, input);
-  const envApiKey = resolveOpensteerApiKey(env);
-  const envBaseUrl = resolveOpensteerBaseUrl(env);
-  const envAuthScheme = resolveOpensteerAuthScheme(env);
-  const envCloudAnnounce = parseCloudAnnounce(
-    env.OPENSTEER_REMOTE_ANNOUNCE,
-    "OPENSTEER_REMOTE_ANNOUNCE"
-  );
-  const inputCloudOptions = normalizeCloudOptions(input.cloud);
-  const inputAuthScheme = parseAuthScheme(
-    inputCloudOptions?.authScheme,
-    "cloud.authScheme"
-  );
-  const inputCloudAnnounce = parseCloudAnnounce(
-    inputCloudOptions?.announce,
-    "cloud.announce"
-  );
-  const inputHasCloudApiKey = Boolean(
-    inputCloudOptions && Object.prototype.hasOwnProperty.call(inputCloudOptions, "apiKey")
-  );
-  const inputHasCloudBaseUrl = Boolean(
-    inputCloudOptions && Object.prototype.hasOwnProperty.call(inputCloudOptions, "baseUrl")
-  );
-  const cloudSelection = resolveCloudSelection({
-    cloud: resolved.cloud
-  }, env);
-  if (cloudSelection.cloud) {
-    const resolvedCloud = normalizeCloudOptions(resolved.cloud) ?? {};
-    const authScheme = inputAuthScheme ?? envAuthScheme ?? parseAuthScheme(resolvedCloud.authScheme, "cloud.authScheme") ?? "api-key";
-    const announce = inputCloudAnnounce ?? envCloudAnnounce ?? parseCloudAnnounce(resolvedCloud.announce, "cloud.announce") ?? "always";
-    resolved.cloud = {
-      ...resolvedCloud,
-      authScheme,
-      announce
-    };
-  }
-  if (envApiKey && cloudSelection.cloud && !inputHasCloudApiKey) {
-    resolved.cloud = {
-      ...normalizeCloudOptions(resolved.cloud) ?? {},
-      apiKey: envApiKey
-    };
-  }
-  if (envBaseUrl && cloudSelection.cloud && !inputHasCloudBaseUrl) {
-    resolved.cloud = {
-      ...normalizeCloudOptions(resolved.cloud) ?? {},
-      baseUrl: envBaseUrl
-    };
+  async launchWithChannel(options, channel) {
+    const browser = await chromium2.launch({
+      channel,
+      headless: options.headless ?? this.defaults.headless,
+      executablePath: options.executablePath ?? this.defaults.executablePath ?? void 0,
+      slowMo: options.slowMo ?? this.defaults.slowMo ?? 0,
+      timeout: options.timeout
+    });
+    this.browser = browser;
+    this.persistentContext = null;
+    const context = await browser.newContext(options.context || {});
+    const page = await context.newPage();
+    return { browser, context, page, isExternal: false };
   }
-  return {
-    config: resolved,
-    env
-  };
-}
-function resolveNamespace(config, rootDir) {
-  if (config.name && config.name.trim()) {
-    return normalizeNamespace(config.name);
-  }
-  const caller = getCallerFilePath();
-  if (!caller) return normalizeNamespace("default");
-  const relative = path4.relative(rootDir, caller);
-  const cleaned = relative.replace(/\\/g, "/").replace(/\.(ts|tsx|js|mjs|cjs)$/, "");
-  return normalizeNamespace(cleaned || "default");
-}
-function getCallerFilePath() {
-  const stack = new Error().stack;
-  if (!stack) return null;
-  const lines = stack.split("\n").slice(2);
-  for (const line of lines) {
-    const match = line.match(/\((.*):(\d+):(\d+)\)/) || line.match(/at\s+(.*):(\d+):(\d+)/);
-    if (!match) continue;
-    const rawPath = match[1];
-    if (!rawPath) continue;
-    if (rawPath.includes("node:internal")) continue;
-    if (rawPath.includes("node_modules")) continue;
-    if (rawPath.includes("/opensteer-oss/src/")) continue;
-    try {
-      if (rawPath.startsWith("file://")) {
-        return fileURLToPath(rawPath);
-      }
-      return rawPath;
-    } catch {
-      continue;
-    }
+  async launchSandbox(options) {
+    const browser = await chromium2.launch({
+      headless: options.headless ?? this.defaults.headless,
+      executablePath: options.executablePath ?? this.defaults.executablePath ?? void 0,
+      slowMo: options.slowMo ?? this.defaults.slowMo ?? 0,
+      timeout: options.timeout
+    });
+    const context = await browser.newContext(options.context || {});
+    const page = await context.newPage();
+    this.browser = browser;
+    this.persistentContext = null;
+    return { browser, context, page, isExternal: false };
   }
-  return null;
-}
+};
 
 // src/action-wait.ts
 var ROBUST_PROFILE = {
@@ -8521,7 +8679,7 @@ var AdaptiveNetworkTracker = class {
         this.idleSince = 0;
       }
       const remaining = Math.max(1, options.deadline - now);
-      await sleep4(Math.min(NETWORK_POLL_MS, remaining));
+      await sleep5(Math.min(NETWORK_POLL_MS, remaining));
     }
   }
   handleRequestStarted = (request) => {
@@ -8566,7 +8724,7 @@ var AdaptiveNetworkTracker = class {
     return false;
   }
 };
-async function sleep4(ms) {
+async function sleep5(ms) {
   await new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -8590,8 +8748,8 @@ function stableStringify(value) {
 }
 
 // src/extraction/data-path.ts
-function parseDataPath(path5) {
-  const input = String(path5 || "").trim();
+function parseDataPath(path3) {
+  const input = String(path3 || "").trim();
   if (!input) return [];
   if (input.includes("..")) return null;
   if (input.startsWith(".") || input.endsWith(".")) return null;
@@ -8647,8 +8805,8 @@ function joinDataPath(base, key) {
 function inflateDataPathObject(flat) {
   let root = {};
   let initialized = false;
-  for (const [path5, value] of Object.entries(flat || {})) {
-    const tokens = parseDataPath(path5);
+  for (const [path3, value] of Object.entries(flat || {})) {
+    const tokens = parseDataPath(path3);
     if (!tokens || !tokens.length) continue;
     if (!initialized) {
       root = tokens[0]?.kind === "index" ? [] : {};
@@ -9023,8 +9181,8 @@ function buildVariantDescriptorFromCluster(descriptors) {
     fields: mergedFields
   };
 }
-function minimizePathMatchClauses(path5, mode) {
-  const normalized = sanitizeElementPath(path5);
+function minimizePathMatchClauses(path3, mode) {
+  const normalized = sanitizeElementPath(path3);
   const nodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = node.attrs || {};
@@ -9127,8 +9285,8 @@ function seedMinimalAttrClause(attrs) {
   }
   return null;
 }
-function relaxPathForSingleSample(path5, mode) {
-  const normalized = sanitizeElementPath(path5);
+function relaxPathForSingleSample(path3, mode) {
+  const normalized = sanitizeElementPath(path3);
   const relaxedNodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = normalizeAttrsForSingleSample(node.attrs || {});
@@ -9198,8 +9356,8 @@ function shouldKeepAttrForSingleSample(key) {
   }
   return true;
 }
-function buildPathStructureKey(path5) {
-  const normalized = sanitizeElementPath(path5);
+function buildPathStructureKey(path3) {
+  const normalized = sanitizeElementPath(path3);
   return stableStringify({
     context: (normalized.context || []).map((hop) => ({
       kind: hop.kind,
@@ -9313,16 +9471,16 @@ function buildArrayItemNode(fields) {
   }
   return node;
 }
-function insertNodeAtPath(root, path5, node) {
-  const tokens = parseDataPath(path5);
+function insertNodeAtPath(root, path3, node) {
+  const tokens = parseDataPath(path3);
   if (!tokens || !tokens.length) {
     throw new Error(
-      `Invalid persisted extraction path "${path5}": expected a non-empty object path.`
+      `Invalid persisted extraction path "${path3}": expected a non-empty object path.`
     );
   }
   if (tokens.some((token) => token.kind === "index")) {
     throw new Error(
-      `Invalid persisted extraction path "${path5}": nested array indices are not supported in cached descriptors.`
+      `Invalid persisted extraction path "${path3}": nested array indices are not supported in cached descriptors.`
     );
   }
   let current = root;
@@ -9330,7 +9488,7 @@ function insertNodeAtPath(root, path5, node) {
     const token = tokens[i];
     if (token.kind !== "prop") {
       throw new Error(
-        `Invalid persisted extraction path "${path5}": expected object segment.`
+        `Invalid persisted extraction path "${path3}": expected object segment.`
       );
     }
     const isLast = i === tokens.length - 1;
@@ -9338,7 +9496,7 @@ function insertNodeAtPath(root, path5, node) {
       const existing = current[token.key];
       if (existing) {
         throw new Error(
-          `Conflicting persisted extraction path "${path5}" detected while building descriptor tree.`
+          `Conflicting persisted extraction path "${path3}" detected while building descriptor tree.`
         );
       }
       current[token.key] = node;
@@ -9353,7 +9511,7 @@ function insertNodeAtPath(root, path5, node) {
     }
     if (!isPersistedObjectNode(next)) {
       throw new Error(
-        `Conflicting persisted extraction path "${path5}" detected at "${token.key}".`
+        `Conflicting persisted extraction path "${path3}" detected at "${token.key}".`
       );
     }
     current = next;
@@ -9379,7 +9537,7 @@ function buildItemRootForArrayIndex(entries) {
   if (!entries.length) return null;
   const paths = entries.map(
     (entry) => isPersistablePathField(entry.source) ? sanitizeElementPath(entry.source.path) : null
-  ).filter((path5) => !!path5);
+  ).filter((path3) => !!path3);
   if (!paths.length) return null;
   const prefixLength = getCommonPathPrefixLength(paths);
   if (prefixLength <= 0) return null;
@@ -9392,7 +9550,7 @@ function buildItemRootForArrayIndex(entries) {
 }
 function getCommonPathPrefixLength(paths) {
   if (!paths.length) return 0;
-  const nodeChains = paths.map((path5) => path5.nodes);
+  const nodeChains = paths.map((path3) => path3.nodes);
   const minLength = Math.min(...nodeChains.map((nodes) => nodes.length));
   if (!Number.isFinite(minLength) || minLength <= 0) return 0;
   for (let i = 0; i < minLength; i++) {
@@ -9449,28 +9607,28 @@ function toRelativeElementPath(absolute, root) {
 }
 function mergeElementPathsByMajority(paths) {
   if (!paths.length) return null;
-  const normalized = paths.map((path5) => sanitizeElementPath(path5));
+  const normalized = paths.map((path3) => sanitizeElementPath(path3));
   const contextKey = pickModeString(
-    normalized.map((path5) => stableStringify(path5.context)),
+    normalized.map((path3) => stableStringify(path3.context)),
     1
   );
   if (!contextKey) return null;
   const sameContext = normalized.filter(
-    (path5) => stableStringify(path5.context) === contextKey
+    (path3) => stableStringify(path3.context) === contextKey
   );
   if (!sameContext.length) return null;
   const targetLength = pickModeNumber(
-    sameContext.map((path5) => path5.nodes.length),
+    sameContext.map((path3) => path3.nodes.length),
     1
   ) ?? sameContext[0]?.nodes.length ?? 0;
   const aligned = sameContext.filter(
-    (path5) => path5.nodes.length === targetLength
+    (path3) => path3.nodes.length === targetLength
   );
   if (!aligned.length) return null;
   const threshold = majorityThreshold(aligned.length);
   const nodes = [];
   for (let i = 0; i < targetLength; i++) {
-    const nodesAtIndex = aligned.map((path5) => path5.nodes[i]).filter((node) => !!node);
+    const nodesAtIndex = aligned.map((path3) => path3.nodes[i]).filter((node) => !!node);
     if (!nodesAtIndex.length) return null;
     nodes.push(mergePathNodeByMajority(nodesAtIndex, threshold));
   }
@@ -9720,8 +9878,8 @@ function collectValueNodes(node) {
     return [
       {
         path: node.$path,
-        replacePath(path5) {
-          node.$path = path5;
+        replacePath(path3) {
+          node.$path = path3;
         }
       }
     ];
@@ -9733,10 +9891,10 @@ function collectValueNodes(node) {
       if (isPersistedValueNode(child)) {
         refs.push({
           path: child.$path,
-          replacePath(path5) {
+          replacePath(path3) {
             const next = current[key];
             if (!isPersistedValueNode(next)) return;
-            next.$path = path5;
+            next.$path = path3;
           }
         });
         continue;
@@ -9749,8 +9907,8 @@ function collectValueNodes(node) {
   visit(node);
   return refs;
 }
-function hasPositionClause(path5) {
-  return path5.nodes.some(
+function hasPositionClause(path3) {
+  return path3.nodes.some(
     (node) => (node.match || []).some((clause) => clause.kind === "position")
   );
 }
@@ -9866,49 +10024,16 @@ async function validateRowSelectors(item, fields) {
     return out;
   }, fields);
 }
-function stripPositionClauses2(path5) {
+function stripPositionClauses2(path3) {
   return {
-    context: path5.context,
-    nodes: path5.nodes.map((node) => ({
+    context: path3.context,
+    nodes: path3.nodes.map((node) => ({
       ...node,
       match: (node.match || []).filter((clause) => clause.kind !== "position")
     }))
   };
 }
 
-// src/cloud/runtime.ts
-var DEFAULT_CLOUD_BASE_URL = "https://api.opensteer.com";
-function createCloudRuntimeState(key, baseUrl = resolveCloudBaseUrl(), authScheme = "api-key") {
-  const normalizedBaseUrl = normalizeCloudBaseUrl(baseUrl);
-  return {
-    sessionClient: new CloudSessionClient(
-      normalizedBaseUrl,
-      key,
-      authScheme
-    ),
-    cdpClient: new CloudCdpClient(),
-    baseUrl: normalizedBaseUrl,
-    actionClient: null,
-    sessionId: null,
-    localRunId: null,
-    cloudSessionUrl: null
-  };
-}
-function resolveCloudBaseUrl() {
-  const value = process.env.OPENSTEER_BASE_URL?.trim();
-  if (!value) return DEFAULT_CLOUD_BASE_URL;
-  return normalizeCloudBaseUrl(value);
-}
-function normalizeCloudBaseUrl(value) {
-  return value.replace(/\/+$/, "");
-}
-function readCloudActionDescription(payload) {
-  const description = payload.description;
-  if (typeof description !== "string") return void 0;
-  const normalized = description.trim();
-  return normalized.length ? normalized : void 0;
-}
-
 // src/opensteer.ts
 var CLOUD_INTERACTION_METHODS = /* @__PURE__ */ new Set([
   "click",
@@ -9935,6 +10060,7 @@ var Opensteer = class _Opensteer {
   ownsBrowser = false;
   snapshotCache = null;
   agentExecutionInFlight = false;
+  cursorController = null;
   constructor(config = {}) {
     const resolvedRuntime = resolveConfigWithEnv(config);
     const resolved = resolvedRuntime.config;
@@ -9956,15 +10082,29 @@ var Opensteer = class _Opensteer {
     if (cloudSelection.cloud) {
       const cloudConfig = resolved.cloud && typeof resolved.cloud === "object" ? resolved.cloud : void 0;
       const apiKey = cloudConfig?.apiKey?.trim();
-      if (!apiKey) {
+      const accessToken = cloudConfig?.accessToken?.trim();
+      if (apiKey && accessToken) {
+        throw new Error(
+          "Cloud mode cannot use both cloud.apiKey and cloud.accessToken. Set only one credential."
+        );
+      }
+      let credential = "";
+      let authScheme = cloudConfig?.authScheme ?? "api-key";
+      if (accessToken) {
+        credential = accessToken;
+        authScheme = "bearer";
+      } else if (apiKey) {
+        credential = apiKey;
+      }
+      if (!credential) {
         throw new Error(
-          "Cloud mode requires a non-empty API key via cloud.apiKey or OPENSTEER_API_KEY."
+          "Cloud mode requires credentials via cloud.apiKey/cloud.accessToken or OPENSTEER_API_KEY/OPENSTEER_ACCESS_TOKEN."
         );
       }
       this.cloud = createCloudRuntimeState(
-        apiKey,
+        credential,
         cloudConfig?.baseUrl,
-        cloudConfig?.authScheme
+        authScheme
       );
     } else {
       this.cloud = null;
@@ -10189,6 +10329,19 @@ var Opensteer = class _Opensteer {
     }
     return true;
   }
+  buildCloudSessionLaunchConfig(options) {
+    const cloudConfig = this.config.cloud && typeof this.config.cloud === "object" ? this.config.cloud : void 0;
+    const browserProfile = normalizeCloudBrowserProfilePreference(
+      options.cloudBrowserProfile ?? cloudConfig?.browserProfile,
+      options.cloudBrowserProfile ? "launch options" : "Opensteer config"
+    );
+    if (!browserProfile) {
+      return void 0;
+    }
+    return {
+      browserProfile
+    };
+  }
   async launch(options = {}) {
     if (this.pageRef && !this.ownsBrowser) {
       throw new Error(
@@ -10211,6 +10364,7 @@ var Opensteer = class _Opensteer {
         }
         localRunId = this.cloud.localRunId || buildLocalRunId(this.namespace);
         this.cloud.localRunId = localRunId;
+        const launchConfig = this.buildCloudSessionLaunchConfig(options);
         const session2 = await this.cloud.sessionClient.create({
           cloudSessionContractVersion,
           sourceType: "local-cloud",
@@ -10218,7 +10372,8 @@ var Opensteer = class _Opensteer {
           localRunId,
           name: this.namespace,
           model: this.config.model,
-          launchContext: options.context || void 0
+          launchContext: options.context || void 0,
+          launchConfig
         });
         sessionId = session2.sessionId;
         actionClient = await ActionWsClient.connect({
@@ -10236,6 +10391,9 @@ var Opensteer = class _Opensteer {
         this.pageRef = cdpConnection.page;
         this.ownsBrowser = true;
         this.snapshotCache = null;
+        if (this.cursorController) {
+          await this.cursorController.attachPage(this.pageRef);
+        }
         this.cloud.actionClient = actionClient;
         this.cloud.sessionId = sessionId;
         this.cloud.cloudSessionUrl = session2.cloudSessionUrl;
@@ -10276,6 +10434,9 @@ var Opensteer = class _Opensteer {
     this.pageRef = session.page;
     this.ownsBrowser = true;
     this.snapshotCache = null;
+    if (this.cursorController) {
+      await this.cursorController.attachPage(this.pageRef);
+    }
   }
   static from(page, config = {}) {
     const resolvedRuntime = resolveConfigWithEnv(config);
@@ -10320,6 +10481,9 @@ var Opensteer = class _Opensteer {
       if (sessionId) {
         await this.cloud.sessionClient.close(sessionId).catch(() => void 0);
       }
+      if (this.cursorController) {
+        await this.cursorController.dispose().catch(() => void 0);
+      }
       return;
     }
     if (this.ownsBrowser) {
@@ -10329,6 +10493,9 @@ var Opensteer = class _Opensteer {
     this.pageRef = null;
     this.contextRef = null;
     this.ownsBrowser = false;
+    if (this.cursorController) {
+      await this.cursorController.dispose().catch(() => void 0);
+    }
   }
   async syncLocalSelectorCacheToCloud() {
     if (!this.cloud) return;
@@ -10455,12 +10622,22 @@ var Opensteer = class _Opensteer {
             resolution.counter
           );
         }
-        await this.runWithPostActionWait("hover", options.wait, async () => {
-          await handle.hover({
-            force: options.force,
-            position: options.position
-          });
-        });
+        await this.runWithCursorPreview(
+          () => this.resolveHandleTargetPoint(handle, options.position),
+          "hover",
+          async () => {
+            await this.runWithPostActionWait(
+              "hover",
+              options.wait,
+              async () => {
+                await handle.hover({
+                  force: options.force,
+                  position: options.position
+                });
+              }
+            );
+          }
+        );
       } catch (err) {
         const failure = classifyActionFailure({
           action: "hover",
@@ -10494,26 +10671,32 @@ var Opensteer = class _Opensteer {
     if (!resolution.path) {
       throw new Error("Unable to resolve element path for hover action.");
     }
-    const path5 = resolution.path;
-    const result = await this.runWithPostActionWait(
+    const path3 = resolution.path;
+    const result = await this.runWithCursorPreview(
+      () => this.resolvePathTargetPoint(path3, options.position),
       "hover",
-      options.wait,
       async () => {
-        const actionResult = await performHover(this.page, path5, options);
-        if (!actionResult.ok) {
-          const failure = actionResult.failure || classifyActionFailure({
-            action: "hover",
-            error: actionResult.error || defaultActionFailureMessage("hover"),
-            fallbackMessage: defaultActionFailureMessage("hover")
-          });
-          throw this.buildActionError(
-            "hover",
-            options.description,
-            failure,
-            actionResult.usedSelector || null
-          );
-        }
-        return actionResult;
+        return await this.runWithPostActionWait(
+          "hover",
+          options.wait,
+          async () => {
+            const actionResult = await performHover(this.page, path3, options);
+            if (!actionResult.ok) {
+              const failure = actionResult.failure || classifyActionFailure({
+                action: "hover",
+                error: actionResult.error || defaultActionFailureMessage("hover"),
+                fallbackMessage: defaultActionFailureMessage("hover")
+              });
+              throw this.buildActionError(
+                "hover",
+                options.description,
+                failure,
+                actionResult.usedSelector || null
+              );
+            }
+            return actionResult;
+          }
+        );
       }
     );
     this.snapshotCache = null;
@@ -10554,16 +10737,26 @@ var Opensteer = class _Opensteer {
             resolution.counter
           );
         }
-        await this.runWithPostActionWait("input", options.wait, async () => {
-          if (options.clear !== false) {
-            await handle.fill(options.text);
-          } else {
-            await handle.type(options.text);
-          }
-          if (options.pressEnter) {
-            await handle.press("Enter", { noWaitAfter: true });
+        await this.runWithCursorPreview(
+          () => this.resolveHandleTargetPoint(handle),
+          "input",
+          async () => {
+            await this.runWithPostActionWait(
+              "input",
+              options.wait,
+              async () => {
+                if (options.clear !== false) {
+                  await handle.fill(options.text);
+                } else {
+                  await handle.type(options.text);
+                }
+                if (options.pressEnter) {
+                  await handle.press("Enter", { noWaitAfter: true });
+                }
+              }
+            );
           }
-        });
+        );
       } catch (err) {
         const failure = classifyActionFailure({
           action: "input",
@@ -10597,26 +10790,32 @@ var Opensteer = class _Opensteer {
     if (!resolution.path) {
       throw new Error("Unable to resolve element path for input action.");
     }
-    const path5 = resolution.path;
-    const result = await this.runWithPostActionWait(
+    const path3 = resolution.path;
+    const result = await this.runWithCursorPreview(
+      () => this.resolvePathTargetPoint(path3),
       "input",
-      options.wait,
       async () => {
-        const actionResult = await performInput(this.page, path5, options);
-        if (!actionResult.ok) {
-          const failure = actionResult.failure || classifyActionFailure({
-            action: "input",
-            error: actionResult.error || defaultActionFailureMessage("input"),
-            fallbackMessage: defaultActionFailureMessage("input")
-          });
-          throw this.buildActionError(
-            "input",
-            options.description,
-            failure,
-            actionResult.usedSelector || null
-          );
-        }
-        return actionResult;
+        return await this.runWithPostActionWait(
+          "input",
+          options.wait,
+          async () => {
+            const actionResult = await performInput(this.page, path3, options);
+            if (!actionResult.ok) {
+              const failure = actionResult.failure || classifyActionFailure({
+                action: "input",
+                error: actionResult.error || defaultActionFailureMessage("input"),
+                fallbackMessage: defaultActionFailureMessage("input")
+              });
+              throw this.buildActionError(
+                "input",
+                options.description,
+                failure,
+                actionResult.usedSelector || null
+              );
+            }
+            return actionResult;
+          }
+        );
       }
     );
     this.snapshotCache = null;
@@ -10657,21 +10856,27 @@ var Opensteer = class _Opensteer {
             resolution.counter
           );
         }
-        await this.runWithPostActionWait(
+        await this.runWithCursorPreview(
+          () => this.resolveHandleTargetPoint(handle),
           "select",
-          options.wait,
           async () => {
-            if (options.value != null) {
-              await handle.selectOption(options.value);
-            } else if (options.label != null) {
-              await handle.selectOption({ label: options.label });
-            } else if (options.index != null) {
-              await handle.selectOption({ index: options.index });
-            } else {
-              throw new Error(
-                "Select requires value, label, or index."
-              );
-            }
+            await this.runWithPostActionWait(
+              "select",
+              options.wait,
+              async () => {
+                if (options.value != null) {
+                  await handle.selectOption(options.value);
+                } else if (options.label != null) {
+                  await handle.selectOption({ label: options.label });
+                } else if (options.index != null) {
+                  await handle.selectOption({ index: options.index });
+                } else {
+                  throw new Error(
+                    "Select requires value, label, or index."
+                  );
+                }
+              }
+            );
           }
         );
       } catch (err) {
@@ -10707,26 +10912,32 @@ var Opensteer = class _Opensteer {
     if (!resolution.path) {
       throw new Error("Unable to resolve element path for select action.");
     }
-    const path5 = resolution.path;
-    const result = await this.runWithPostActionWait(
+    const path3 = resolution.path;
+    const result = await this.runWithCursorPreview(
+      () => this.resolvePathTargetPoint(path3),
       "select",
-      options.wait,
       async () => {
-        const actionResult = await performSelect(this.page, path5, options);
-        if (!actionResult.ok) {
-          const failure = actionResult.failure || classifyActionFailure({
-            action: "select",
-            error: actionResult.error || defaultActionFailureMessage("select"),
-            fallbackMessage: defaultActionFailureMessage("select")
-          });
-          throw this.buildActionError(
-            "select",
-            options.description,
-            failure,
-            actionResult.usedSelector || null
-          );
-        }
-        return actionResult;
+        return await this.runWithPostActionWait(
+          "select",
+          options.wait,
+          async () => {
+            const actionResult = await performSelect(this.page, path3, options);
+            if (!actionResult.ok) {
+              const failure = actionResult.failure || classifyActionFailure({
+                action: "select",
+                error: actionResult.error || defaultActionFailureMessage("select"),
+                fallbackMessage: defaultActionFailureMessage("select")
+              });
+              throw this.buildActionError(
+                "select",
+                options.description,
+                failure,
+                actionResult.usedSelector || null
+              );
+            }
+            return actionResult;
+          }
+        );
       }
     );
     this.snapshotCache = null;
@@ -10768,13 +10979,23 @@ var Opensteer = class _Opensteer {
           );
         }
         const delta = getScrollDelta2(options);
-        await this.runWithPostActionWait("scroll", options.wait, async () => {
-          await handle.evaluate((el, value) => {
-            if (el instanceof HTMLElement) {
-              el.scrollBy(value.x, value.y);
-            }
-          }, delta);
-        });
+        await this.runWithCursorPreview(
+          () => this.resolveHandleTargetPoint(handle),
+          "scroll",
+          async () => {
+            await this.runWithPostActionWait(
+              "scroll",
+              options.wait,
+              async () => {
+                await handle.evaluate((el, value) => {
+                  if (el instanceof HTMLElement) {
+                    el.scrollBy(value.x, value.y);
+                  }
+                }, delta);
+              }
+            );
+          }
+        );
       } catch (err) {
         const failure = classifyActionFailure({
           action: "scroll",
@@ -10805,29 +11026,35 @@ var Opensteer = class _Opensteer {
         `[c="${resolution.counter}"]`
       );
     }
-    const result = await this.runWithPostActionWait(
+    const result = await this.runWithCursorPreview(
+      () => resolution.path ? this.resolvePathTargetPoint(resolution.path) : this.resolveViewportAnchorPoint(),
       "scroll",
-      options.wait,
       async () => {
-        const actionResult = await performScroll(
-          this.page,
-          resolution.path,
-          options
+        return await this.runWithPostActionWait(
+          "scroll",
+          options.wait,
+          async () => {
+            const actionResult = await performScroll(
+              this.page,
+              resolution.path,
+              options
+            );
+            if (!actionResult.ok) {
+              const failure = actionResult.failure || classifyActionFailure({
+                action: "scroll",
+                error: actionResult.error || defaultActionFailureMessage("scroll"),
+                fallbackMessage: defaultActionFailureMessage("scroll")
+              });
+              throw this.buildActionError(
+                "scroll",
+                options.description,
+                failure,
+                actionResult.usedSelector || null
+              );
+            }
+            return actionResult;
+          }
         );
-        if (!actionResult.ok) {
-          const failure = actionResult.failure || classifyActionFailure({
-            action: "scroll",
-            error: actionResult.error || defaultActionFailureMessage("scroll"),
-            fallbackMessage: defaultActionFailureMessage("scroll")
-          });
-          throw this.buildActionError(
-            "scroll",
-            options.description,
-            failure,
-            actionResult.usedSelector || null
-          );
-        }
-        return actionResult;
       }
     );
     this.snapshotCache = null;
@@ -10981,7 +11208,7 @@ var Opensteer = class _Opensteer {
         const text = await handle.textContent();
         return text ?? "";
       },
-      (path5) => getElementText(this.page, path5)
+      (path3) => getElementText(this.page, path3)
     );
   }
   async getElementValue(options) {
@@ -10997,7 +11224,7 @@ var Opensteer = class _Opensteer {
       async (handle) => {
         return await handle.inputValue();
       },
-      (path5) => getElementValue(this.page, path5)
+      (path3) => getElementValue(this.page, path3)
     );
   }
   async getElementAttributes(options) {
@@ -11019,7 +11246,7 @@ var Opensteer = class _Opensteer {
           return attrs;
         });
       },
-      (path5) => getElementAttributes(this.page, path5)
+      (path3) => getElementAttributes(this.page, path3)
     );
   }
   async getElementBoundingBox(options) {
@@ -11035,7 +11262,7 @@ var Opensteer = class _Opensteer {
       async (handle) => {
         return await handle.boundingBox();
       },
-      (path5) => getElementBoundingBox(this.page, path5)
+      (path3) => getElementBoundingBox(this.page, path3)
     );
   }
   async getHtml(selector) {
@@ -11113,11 +11340,17 @@ var Opensteer = class _Opensteer {
             resolution.counter
           );
         }
-        await this.runWithPostActionWait(
+        await this.runWithCursorPreview(
+          () => this.resolveHandleTargetPoint(handle),
           "uploadFile",
-          options.wait,
           async () => {
-            await handle.setInputFiles(options.paths);
+            await this.runWithPostActionWait(
+              "uploadFile",
+              options.wait,
+              async () => {
+                await handle.setInputFiles(options.paths);
+              }
+            );
           }
         );
       } catch (err) {
@@ -11153,30 +11386,36 @@ var Opensteer = class _Opensteer {
     if (!resolution.path) {
       throw new Error("Unable to resolve element path for file upload.");
     }
-    const path5 = resolution.path;
-    const result = await this.runWithPostActionWait(
+    const path3 = resolution.path;
+    const result = await this.runWithCursorPreview(
+      () => this.resolvePathTargetPoint(path3),
       "uploadFile",
-      options.wait,
       async () => {
-        const actionResult = await performFileUpload(
-          this.page,
-          path5,
-          options.paths
+        return await this.runWithPostActionWait(
+          "uploadFile",
+          options.wait,
+          async () => {
+            const actionResult = await performFileUpload(
+              this.page,
+              path3,
+              options.paths
+            );
+            if (!actionResult.ok) {
+              const failure = actionResult.failure || classifyActionFailure({
+                action: "uploadFile",
+                error: actionResult.error || defaultActionFailureMessage("uploadFile"),
+                fallbackMessage: defaultActionFailureMessage("uploadFile")
+              });
+              throw this.buildActionError(
+                "uploadFile",
+                options.description,
+                failure,
+                actionResult.usedSelector || null
+              );
+            }
+            return actionResult;
+          }
         );
-        if (!actionResult.ok) {
-          const failure = actionResult.failure || classifyActionFailure({
-            action: "uploadFile",
-            error: actionResult.error || defaultActionFailureMessage("uploadFile"),
-            fallbackMessage: defaultActionFailureMessage("uploadFile")
-          });
-          throw this.buildActionError(
-            "uploadFile",
-            options.description,
-            failure,
-            actionResult.usedSelector || null
-          );
-        }
-        return actionResult;
       }
     );
     this.snapshotCache = null;
@@ -11277,9 +11516,9 @@ var Opensteer = class _Opensteer {
     const schemaHash = computeSchemaHash(options.schema);
     let fields = await this.buildFieldTargetsFromPlan(options.plan);
     if (!fields.length && options.plan.paths) {
-      fields = Object.entries(options.plan.paths).map(([key, path5]) => ({
+      fields = Object.entries(options.plan.paths).map(([key, path3]) => ({
         key,
-        path: this.normalizePath(path5)
+        path: this.normalizePath(path3)
       }));
     }
     if (!fields.length) {
@@ -11312,6 +11551,25 @@ var Opensteer = class _Opensteer {
   getConfig() {
     return this.config;
   }
+  setCursorEnabled(enabled) {
+    this.getCursorController().setEnabled(enabled);
+  }
+  getCursorState() {
+    const controller = this.cursorController;
+    if (!controller) {
+      return {
+        enabled: this.config.cursor?.enabled === true,
+        active: false,
+        reason: this.config.cursor?.enabled === true ? "not_initialized" : "disabled"
+      };
+    }
+    const status = controller.getStatus();
+    return {
+      enabled: status.enabled,
+      active: status.active,
+      reason: status.reason
+    };
+  }
   getStorage() {
     return this.storage;
   }
@@ -11339,24 +11597,107 @@ var Opensteer = class _Opensteer {
         this.agentExecutionInFlight = true;
         try {
           const options = normalizeExecuteOptions(instructionOrOptions);
+          const cursorController = this.getCursorController();
+          const previousCursorEnabled = cursorController.isEnabled();
+          if (options.highlightCursor !== void 0) {
+            cursorController.setEnabled(options.highlightCursor);
+          }
           const handler = new OpensteerCuaAgentHandler({
             page: this.page,
             config: resolvedAgentConfig,
             client: createCuaClient(resolvedAgentConfig),
-            debug: Boolean(this.config.debug),
+            cursorController,
             onMutatingAction: () => {
               this.snapshotCache = null;
             }
           });
-          const result = await handler.execute(options);
-          this.snapshotCache = null;
-          return result;
+          try {
+            const result = await handler.execute(options);
+            this.snapshotCache = null;
+            return result;
+          } finally {
+            if (options.highlightCursor !== void 0) {
+              cursorController.setEnabled(previousCursorEnabled);
+            }
+          }
         } finally {
           this.agentExecutionInFlight = false;
         }
       }
     };
   }
+  getCursorController() {
+    if (!this.cursorController) {
+      this.cursorController = new CursorController({
+        config: this.config.cursor,
+        debug: Boolean(this.config.debug)
+      });
+      if (this.pageRef) {
+        void this.cursorController.attachPage(this.pageRef);
+      }
+    }
+    return this.cursorController;
+  }
+  async runWithCursorPreview(pointResolver, intent, execute) {
+    if (this.isCursorPreviewEnabled()) {
+      const point = await pointResolver();
+      await this.previewCursorPoint(point, intent);
+    }
+    return await execute();
+  }
+  isCursorPreviewEnabled() {
+    return this.cursorController ? this.cursorController.isEnabled() : this.config.cursor?.enabled === true;
+  }
+  async previewCursorPoint(point, intent) {
+    const cursor = this.getCursorController();
+    await cursor.attachPage(this.page);
+    await cursor.preview(point, intent);
+  }
+  resolveCursorPointFromBoundingBox(box, position) {
+    if (position) {
+      return {
+        x: box.x + position.x,
+        y: box.y + position.y
+      };
+    }
+    return {
+      x: box.x + box.width / 2,
+      y: box.y + box.height / 2
+    };
+  }
+  async resolveHandleTargetPoint(handle, position) {
+    try {
+      const box = await handle.boundingBox();
+      if (!box) return null;
+      return this.resolveCursorPointFromBoundingBox(box, position);
+    } catch {
+      return null;
+    }
+  }
+  async resolvePathTargetPoint(path3, position) {
+    if (!path3) {
+      return null;
+    }
+    let resolved = null;
+    try {
+      resolved = await resolveElementPath(this.page, path3);
+      return await this.resolveHandleTargetPoint(resolved.element, position);
+    } catch {
+      return null;
+    } finally {
+      await resolved?.element.dispose().catch(() => void 0);
+    }
+  }
+  async resolveViewportAnchorPoint() {
+    const viewport = this.page.viewportSize();
+    if (viewport?.width && viewport?.height) {
+      return {
+        x: viewport.width / 2,
+        y: viewport.height / 2
+      };
+    }
+    return null;
+  }
   async runWithPostActionWait(action, waitOverride, execute) {
     const waitSession = createPostActionWaitSession(
       this.page,
@@ -11389,13 +11730,19 @@ var Opensteer = class _Opensteer {
             resolution.counter
           );
         }
-        await this.runWithPostActionWait(method, options.wait, async () => {
-          await handle.click({
-            button: options.button,
-            clickCount: options.clickCount,
-            modifiers: options.modifiers
-          });
-        });
+        await this.runWithCursorPreview(
+          () => this.resolveHandleTargetPoint(handle),
+          method,
+          async () => {
+            await this.runWithPostActionWait(method, options.wait, async () => {
+              await handle.click({
+                button: options.button,
+                clickCount: options.clickCount,
+                modifiers: options.modifiers
+              });
+            });
+          }
+        );
       } catch (err) {
         const failure = classifyActionFailure({
           action: method,
@@ -11429,26 +11776,32 @@ var Opensteer = class _Opensteer {
     if (!resolution.path) {
       throw new Error("Unable to resolve element path for click action.");
     }
-    const path5 = resolution.path;
-    const result = await this.runWithPostActionWait(
+    const path3 = resolution.path;
+    const result = await this.runWithCursorPreview(
+      () => this.resolvePathTargetPoint(path3),
       method,
-      options.wait,
       async () => {
-        const actionResult = await performClick(this.page, path5, options);
-        if (!actionResult.ok) {
-          const failure = actionResult.failure || classifyActionFailure({
-            action: method,
-            error: actionResult.error || defaultActionFailureMessage(method),
-            fallbackMessage: defaultActionFailureMessage(method)
-          });
-          throw this.buildActionError(
-            method,
-            options.description,
-            failure,
-            actionResult.usedSelector || null
-          );
-        }
-        return actionResult;
+        return await this.runWithPostActionWait(
+          method,
+          options.wait,
+          async () => {
+            const actionResult = await performClick(this.page, path3, options);
+            if (!actionResult.ok) {
+              const failure = actionResult.failure || classifyActionFailure({
+                action: method,
+                error: actionResult.error || defaultActionFailureMessage(method),
+                fallbackMessage: defaultActionFailureMessage(method)
+              });
+              throw this.buildActionError(
+                method,
+                options.description,
+                failure,
+                actionResult.usedSelector || null
+              );
+            }
+            return actionResult;
+          }
+        );
       }
     );
     this.snapshotCache = null;
@@ -11487,14 +11840,14 @@ var Opensteer = class _Opensteer {
       };
     }
     if (options.selector) {
-      const path5 = await this.buildPathFromSelector(options.selector);
-      if (!path5) {
+      const path3 = await this.buildPathFromSelector(options.selector);
+      if (!path3) {
         throw new Error(
           `Unable to build element path from selector: ${options.selector}`
         );
       }
       return {
-        path: path5,
+        path: path3,
         counter: null,
         shouldPersist: Boolean(storageKey),
         source: "selector"
@@ -11554,9 +11907,9 @@ var Opensteer = class _Opensteer {
           counter: parsedCounter
         };
       }
-      const path5 = await this.buildPathFromSelector(response);
-      return path5 ? {
-        path: path5
+      const path3 = await this.buildPathFromSelector(response);
+      return path3 ? {
+        path: path3
       } : null;
     }
     if (!response || typeof response !== "object") {
@@ -11574,9 +11927,9 @@ var Opensteer = class _Opensteer {
       };
     }
     if (record.selector) {
-      const path5 = await this.buildPathFromSelector(record.selector);
-      return path5 ? {
-        path: path5
+      const path3 = await this.buildPathFromSelector(record.selector);
+      return path3 ? {
+        path: path3
       } : null;
     }
     return null;
@@ -11678,10 +12031,10 @@ var Opensteer = class _Opensteer {
     if (fallback.nodes.length) return fallback;
     return normalizedBuilt;
   }
-  async withHandleIframeContext(handle, path5) {
+  async withHandleIframeContext(handle, path3) {
     const ownFrame = await handle.ownerFrame();
     if (!ownFrame) {
-      return this.normalizePath(path5);
+      return this.normalizePath(path3);
     }
     let frame = ownFrame;
     let prefix = [];
@@ -11708,11 +12061,11 @@ var Opensteer = class _Opensteer {
       frame = parent;
     }
     if (!prefix.length) {
-      return this.normalizePath(path5);
+      return this.normalizePath(path3);
     }
     return this.normalizePath({
-      context: [...prefix, ...cloneContextHops(path5.context)],
-      nodes: cloneElementPath(path5).nodes
+      context: [...prefix, ...cloneContextHops(path3.context)],
+      nodes: cloneElementPath(path3).nodes
     });
   }
   async readPathFromCounterIndex(counter) {
@@ -11726,11 +12079,11 @@ var Opensteer = class _Opensteer {
     return normalized;
   }
   async buildPathFromSelector(selector) {
-    const path5 = await buildElementPathFromSelector(this.page, selector);
-    if (!path5) return null;
-    return this.normalizePath(path5);
+    const path3 = await buildElementPathFromSelector(this.page, selector);
+    if (!path3) return null;
+    return this.normalizePath(path3);
   }
-  persistPath(id, method, description, path5) {
+  persistPath(id, method, description, path3) {
     const now = Date.now();
     const safeFile = this.storage.getSelectorFileName(id);
     const existing = this.storage.readSelector(id);
@@ -11739,7 +12092,7 @@ var Opensteer = class _Opensteer {
       id,
       method,
       description: description || `${method} path`,
-      path: this.normalizePath(path5),
+      path: this.normalizePath(path3),
       metadata: {
         createdAt,
         updatedAt: now,
@@ -11929,9 +12282,9 @@ var Opensteer = class _Opensteer {
     }
     let fields = await this.buildFieldTargetsFromPlan(normalized);
     if (!fields.length && normalized.paths) {
-      fields = Object.entries(normalized.paths).map(([key, path5]) => ({
+      fields = Object.entries(normalized.paths).map(([key, path3]) => ({
         key,
-        path: this.normalizePath(path5)
+        path: this.normalizePath(path3)
       }));
     }
     if (!fields.length && normalized.data !== void 0) {
@@ -11995,13 +12348,13 @@ var Opensteer = class _Opensteer {
         return;
       }
       if (normalized.selector) {
-        const path5 = await this.buildPathFromSelector(
+        const path3 = await this.buildPathFromSelector(
           normalized.selector
         );
-        if (path5) {
+        if (path3) {
           fields.push({
             key: fieldKey,
-            path: path5,
+            path: path3,
             attribute: normalized.attribute
           });
         } else {
@@ -12039,11 +12392,11 @@ var Opensteer = class _Opensteer {
         continue;
       }
       if (!fieldPlan.selector) continue;
-      const path5 = await this.buildPathFromSelector(fieldPlan.selector);
-      if (!path5) continue;
+      const path3 = await this.buildPathFromSelector(fieldPlan.selector);
+      if (!path3) continue;
       fields.push({
         key,
-        path: path5,
+        path: path3,
         attribute: fieldPlan.attribute
       });
     }
@@ -12112,15 +12465,15 @@ var Opensteer = class _Opensteer {
         });
         continue;
       }
-      const path5 = await this.buildPathFromElement(field.counter);
-      if (!path5) {
+      const path3 = await this.buildPathFromElement(field.counter);
+      if (!path3) {
         throw new Error(
           `Unable to persist extraction schema field "${field.key}": counter ${field.counter} could not be converted into a stable element path.`
         );
       }
       resolved.push({
         key: field.key,
-        path: path5,
+        path: path3,
         attribute: field.attribute
       });
     }
@@ -12137,10 +12490,10 @@ var Opensteer = class _Opensteer {
   }
   resolveStorageKey(description) {
     if (!description) return null;
-    return createHash("sha256").update(description).digest("hex").slice(0, 16);
+    return createHash2("sha256").update(description).digest("hex").slice(0, 16);
   }
-  normalizePath(path5) {
-    return sanitizeElementPath(path5);
+  normalizePath(path3) {
+    return sanitizeElementPath(path3);
   }
 };
 function formatActionFailureMessage(action, description, cause) {
@@ -12150,8 +12503,8 @@ function formatActionFailureMessage(action, description, cause) {
 function cloneContextHops(context) {
   return JSON.parse(JSON.stringify(context || []));
 }
-function collectIframeContextPrefix(path5) {
-  const context = path5.context || [];
+function collectIframeContextPrefix(path3) {
+  const context = path3.context || [];
   let lastIframeIndex = -1;
   for (let index = 0; index < context.length; index += 1) {
     if (context[index]?.kind === "iframe") {
@@ -12209,7 +12562,7 @@ function normalizeExtractSource(source) {
 }
 function computeSchemaHash(schema) {
   const stable = stableStringify(schema);
-  return createHash("sha256").update(stable).digest("hex");
+  return createHash2("sha256").update(stable).digest("hex");
 }
 function buildPathMap(fields) {
   const out = {};
@@ -12443,15 +12796,34 @@ function isInternalOrBlankPageUrl(url) {
   if (url === "about:blank") return true;
   return url.startsWith("chrome://") || url.startsWith("devtools://") || url.startsWith("edge://");
 }
+function normalizeCloudBrowserProfilePreference(value, source) {
+  if (!value) {
+    return void 0;
+  }
+  const profileId = typeof value.profileId === "string" ? value.profileId.trim() : "";
+  if (!profileId) {
+    throw new Error(
+      `Invalid cloud browser profile in ${source}: profileId must be a non-empty string.`
+    );
+  }
+  if (value.reuseIfActive !== void 0 && typeof value.reuseIfActive !== "boolean") {
+    throw new Error(
+      `Invalid cloud browser profile in ${source}: reuseIfActive must be a boolean.`
+    );
+  }
+  return {
+    profileId,
+    reuseIfActive: value.reuseIfActive
+  };
+}
 function buildLocalRunId(namespace) {
   const normalized = namespace.trim() || "default";
   return `${normalized}-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
 }
 
 export {
-  normalizeError,
-  normalizeNamespace,
-  resolveNamespaceDir,
+  expandHome,
+  loadCookiesFromLocalProfileDir,
   waitForVisualStability,
   createEmptyRegistry,
   LocalSelectorStorage,
@@ -12512,13 +12884,8 @@ export {
   performFileUpload,
   OpensteerActionError,
   cloudSessionContractVersion,
-  OpensteerCloudError,
-  cloudUnsupportedMethodError,
-  cloudNotLaunchedError,
   ActionWsClient,
   collectLocalSelectorCacheEntries,
-  CloudCdpClient,
-  CloudSessionClient,
   OpensteerAgentError,
   OpensteerAgentConfigError,
   OpensteerAgentProviderError,
@@ -12529,5 +12896,8 @@ export {
   resolveAgentConfig,
   createCuaClient,
   OpensteerCuaAgentHandler,
+  planSnappyCursorMotion,
+  SvgCursorRenderer,
+  CursorController,
   Opensteer
 };