opensteer 0.8.9 → 0.8.10

package/dist/{chunk-RO6WAWWG.js → chunk-F3X6UOEN.js}

@@ -10806,7 +10806,8 @@ async function captureActionBoundarySnapshot(engine, pageRef) {
   }
   return {
     pageRef,
-    documentRef: mainFrame.documentRef
+    documentRef: mainFrame.documentRef,
+    url: mainFrame.url
   };
 }
 function createActionBoundaryDiagnostics(input) {
@@ -14749,7 +14750,7 @@ async function clearPersistedSessionRecord(rootPath, provider) {
   await rm(resolveLiveSessionRecordPath(rootPath, provider), { force: true });
 }
 function isPersistedCloudSessionRecord(value) {
-  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "cloud" && typeof value.sessionId === "string" && value.sessionId.length > 0 && typeof value.baseUrl === "string" && value.baseUrl.length > 0 && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
+  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "cloud" && typeof value.sessionId === "string" && value.sessionId.length > 0 && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
 }
 function isPersistedLocalBrowserSessionRecord(value) {
   return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "local" && (value.engine === "playwright" || value.engine === "abp") && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt) && typeof value.userDataDir === "string" && value.userDataDir.length > 0;
@@ -22408,11 +22409,11 @@ var SandboxClock = class {
   performanceNow() {
     return this.mode === "manual" ? this.manualNow - this.startedAt : (globalThis.performance?.now() ?? 0) - this.performanceStartedAt;
   }
-  setTimeout(callback, delay2 = 0, ...args) {
-    return this.registerTimer(false, callback, delay2, args);
+  setTimeout(callback, delay3 = 0, ...args) {
+    return this.registerTimer(false, callback, delay3, args);
   }
-  setInterval(callback, delay2 = 0, ...args) {
-    return this.registerTimer(true, callback, delay2, args);
+  setInterval(callback, delay3 = 0, ...args) {
+    return this.registerTimer(true, callback, delay3, args);
   }
   clearTimeout(timerId) {
     this.clearTimer(timerId);
@@ -22433,9 +22434,9 @@ var SandboxClock = class {
       this.clearTimer(timerId);
     }
   }
-  registerTimer(repeat, callback, delay2, args) {
+  registerTimer(repeat, callback, delay3, args) {
     const timerId = this.nextTimerId++;
-    const normalizedDelay = Math.max(0, delay2);
+    const normalizedDelay = Math.max(0, delay3);
     const record = {
       callback,
       args,
@@ -22942,6 +22943,7 @@ function diffInteractionTraces(left, right) {
 // ../runtime-core/src/sdk/runtime.ts
 var requireForAuthRecipeHook = createRequire(import.meta.url);
 var MUTATION_CAPTURE_FINALIZE_TIMEOUT_MS = 5e3;
+var PERSISTED_NETWORK_FLUSH_TIMEOUT_MS = 5e3;
 var PENDING_OPERATION_EVENT_CAPTURE_LIMIT = 64;
 var PENDING_OPERATION_EVENT_CAPTURE_SKEW_MS = 1e3;
 var OpensteerSessionRuntime = class {
@@ -29081,6 +29083,29 @@ var OpensteerSessionRuntime = class {
     return snapshot.sessionStorage?.filter((entry) => entry.origin === origin).find((entry) => pageUrl === void 0 || entry.origin === new URL(pageUrl).origin)?.entries.find((entry) => entry.key === key)?.value;
   }
   async flushPersistedNetworkHistory() {
+    if (this.sessionRef === void 0) {
+      return;
+    }
+    const root = await this.ensureRoot();
+    try {
+      await withDetachedTimeoutSignal(PERSISTED_NETWORK_FLUSH_TIMEOUT_MS, async (signal) => {
+        const browserRecords = await this.readBrowserNetworkRecords(
+          {
+            includeBodies: true,
+            includeCurrentPageOnly: false
+          },
+          signal
+        );
+        await this.networkHistory.persist(browserRecords, root.registry.savedNetwork, {
+          bodyWriteMode: "authoritative",
+          redactSecretHeaders: false
+        });
+      });
+    } catch (error) {
+      if (!isIgnorableRuntimeBindingError(error)) {
+        throw error;
+      }
+    }
   }
   toDomTargetRef(target) {
     if (target.kind === "description") {
@@ -29237,6 +29262,12 @@ var OpensteerSessionRuntime = class {
       return "live";
     } catch (error) {
       if (isIgnorableRuntimeBindingError(error)) {
+        const remainingPages = await engine.listPages({ sessionRef }).catch(() => void 0);
+        const replacementPageRef = remainingPages?.[0]?.pageRef;
+        if (replacementPageRef !== void 0) {
+          this.pageRef = replacementPageRef;
+          return "live";
+        }
         return "invalid";
       }
       throw error;
@@ -32291,197 +32322,1798 @@ function screenshotMediaType(format2) {
   }
 }
 
-// src/sdk/runtime.ts
-var OpensteerRuntime = class extends OpensteerSessionRuntime {
-  constructor(options = {}) {
-    const publicWorkspace = normalizeWorkspace2(options.workspace);
-    const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path7.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", randomUUID()) : resolveFilesystemWorkspacePath({
-      rootDir: path7.resolve(options.rootDir ?? process.cwd()),
-      workspace: publicWorkspace
-    }));
-    const cleanupRootOnClose = options.cleanupRootOnClose ?? publicWorkspace === void 0;
-    const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
-    assertSupportedEngineOptions({
-      engineName,
-      ...options.browser === void 0 ? {} : { browser: options.browser },
-      ...options.context === void 0 ? {} : { context: options.context }
-    });
-    super(
-      buildSharedRuntimeOptions({
-        name: publicWorkspace ?? "default",
-        rootPath,
-        ...publicWorkspace === void 0 ? {} : { workspaceName: publicWorkspace },
-        ...options.browser === void 0 ? {} : { browser: options.browser },
-        ...options.launch === void 0 ? {} : { launch: options.launch },
-        ...options.context === void 0 ? {} : { context: options.context },
-        engineName,
-        ...options.engine === void 0 ? {} : { engine: options.engine },
-        ...options.engineFactory === void 0 ? {} : { engineFactory: options.engineFactory },
-        ...options.policy === void 0 ? {} : { policy: options.policy },
-        ...options.descriptorStore === void 0 ? {} : { descriptorStore: options.descriptorStore },
-        ...options.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: options.extractionDescriptorStore },
-        ...options.registryOverrides === void 0 ? {} : { registryOverrides: options.registryOverrides },
-        cleanupRootOnClose,
-        ...options.observability === void 0 ? {} : { observability: options.observability },
-        ...options.observationSessionId === void 0 ? {} : { observationSessionId: options.observationSessionId },
-        ...options.observationSink === void 0 ? {} : { observationSink: options.observationSink }
-      })
-    );
+// ../runtime-core/src/recorder/browser-scripts.ts
+var SINGLE_ATTRIBUTE_PRIORITY = Array.from(
+  /* @__PURE__ */ new Set(["data-testid", "data-test", "data-qa", "data-cy", "id", ...STABLE_PRIMARY_ATTR_KEYS])
+);
+var FLOW_RECORDER_INSTALL_SOURCE = String.raw`(() => {
+  const TOP_LEVEL_ONLY = (() => {
+    try {
+      return window.top === window.self;
+    } catch {
+      return false;
+    }
+  })();
+  if (!TOP_LEVEL_ONLY) {
+    return;
   }
-};
-var OpensteerSessionRuntime2 = class extends OpensteerSessionRuntime {
-  constructor(options) {
-    const rootPath = options.rootPath ?? path7.resolve(options.rootDir ?? process.cwd());
-    const cleanupRootOnClose = options.cleanupRootOnClose ?? false;
-    const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
-    assertSupportedEngineOptions({
-      engineName,
-      ...options.browser === void 0 ? {} : { browser: options.browser },
-      ...options.context === void 0 ? {} : { context: options.context }
-    });
-    super(
-      buildSharedRuntimeOptions({
-        name: options.name,
-        rootPath,
-        ...options.browser === void 0 ? {} : { browser: options.browser },
-        ...options.launch === void 0 ? {} : { launch: options.launch },
-        ...options.context === void 0 ? {} : { context: options.context },
-        engineName,
-        ...options.engine === void 0 ? {} : { engine: options.engine },
-        ...options.engineFactory === void 0 ? {} : { engineFactory: options.engineFactory },
-        ...options.policy === void 0 ? {} : { policy: options.policy },
-        ...options.descriptorStore === void 0 ? {} : { descriptorStore: options.descriptorStore },
-        ...options.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: options.extractionDescriptorStore },
-        ...options.registryOverrides === void 0 ? {} : { registryOverrides: options.registryOverrides },
-        cleanupRootOnClose,
-        ...options.observability === void 0 ? {} : { observability: options.observability },
-        ...options.observationSessionId === void 0 ? {} : { observationSessionId: options.observationSessionId },
-        ...options.observationSink === void 0 ? {} : { observationSink: options.observationSink }
-      })
-    );
+
+  const globalScope = globalThis;
+  const recorderKey = "__opensteerFlowRecorder";
+  const historyStateKey = "__opensteerFlowRecorderHistory";
+  const recorderUiAttribute = "data-opensteer-recorder-ui";
+  const queueLimit = 1000;
+  const singleAttributePriority = ${JSON.stringify(SINGLE_ATTRIBUTE_PRIORITY)};
+  const stablePrimaryAttrKeys = new Set(${JSON.stringify([...STABLE_PRIMARY_ATTR_KEYS])});
+  const matchAttributePriority = ${JSON.stringify([...MATCH_ATTRIBUTE_PRIORITY])};
+  const attributeDenyKeys = new Set(${JSON.stringify([...ATTRIBUTE_DENY_KEYS])});
+  const lazyLoadingMediaTags = new Set(${JSON.stringify([...LAZY_LOADING_MEDIA_TAGS])});
+  const volatileLazyLoadingAttrs = new Set(${JSON.stringify([...VOLATILE_LAZY_LOADING_ATTRS])});
+  const volatileClassTokens = new Set(${JSON.stringify([...VOLATILE_CLASS_TOKENS])});
+  const volatileLazyClassTokens = new Set(${JSON.stringify([...VOLATILE_LAZY_CLASS_TOKENS])});
+
+  const previous = globalScope[recorderKey];
+  if (previous && typeof previous.dispose === "function") {
+    previous.dispose();
   }
-};
-function buildSharedRuntimeOptions(input) {
-  const ownership = resolveOwnership(input.browser);
-  const engineFactory = input.engineFactory ?? ((factoryOptions) => new OpensteerBrowserManager({
-    rootPath: input.rootPath,
-    ...input.workspaceName === void 0 ? {} : { workspace: input.workspaceName },
-    engineName: input.engineName,
-    ...(factoryOptions.browser ?? input.browser) === void 0 ? {} : { browser: factoryOptions.browser ?? input.browser },
-    ...(factoryOptions.launch ?? input.launch) === void 0 ? {} : { launch: factoryOptions.launch ?? input.launch },
-    ...(factoryOptions.context ?? input.context) === void 0 ? {} : { context: factoryOptions.context ?? input.context }
-  }).createEngine());
-  return {
-    name: input.name,
-    ...input.workspaceName === void 0 ? {} : { workspaceName: input.workspaceName },
-    rootPath: input.rootPath,
-    ...input.engine === void 0 ? {} : { engine: input.engine },
-    ...input.engine === void 0 ? { engineFactory } : {},
-    ...input.policy === void 0 ? {} : { policy: input.policy },
-    ...input.descriptorStore === void 0 ? {} : { descriptorStore: input.descriptorStore },
-    ...input.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: input.extractionDescriptorStore },
-    ...input.registryOverrides === void 0 ? {} : { registryOverrides: input.registryOverrides },
-    cleanupRootOnClose: input.cleanupRootOnClose,
-    ...input.observability === void 0 ? {} : { observability: input.observability },
-    ...input.observationSessionId === void 0 ? {} : { observationSessionId: input.observationSessionId },
-    ...input.observationSink === void 0 ? {} : { observationSink: input.observationSink },
-    sessionInfo: {
-      provider: {
-        mode: "local",
-        ownership,
-        engine: input.engineName
-      },
-      ...input.workspaceName === void 0 ? {} : { workspace: input.workspaceName },
-      reconnectable: !input.cleanupRootOnClose
+
+  const queue = [];
+  const cleanup = [];
+  const inputFlushTimers = new Map();
+  const pendingInputs = new Map();
+  let stopRequested = false;
+  let pendingWheel = undefined;
+
+  const actionTargetTags = new Set([
+    "a",
+    "button",
+    "input",
+    "label",
+    "option",
+    "select",
+    "summary",
+    "textarea",
+  ]);
+
+  function now() {
+    return Date.now();
+  }
+
+  function enqueue(entry) {
+    queue.push({
+      ...entry,
+      timestamp: typeof entry.timestamp === "number" ? entry.timestamp : now(),
+    });
+    if (queue.length > queueLimit) {
+      queue.splice(0, queue.length - queueLimit);
     }
-  };
-}
-function normalizeWorkspace2(workspace) {
-  if (workspace === void 0) {
-    return void 0;
   }
-  const trimmed = workspace.trim();
-  return trimmed.length === 0 ? void 0 : trimmed;
-}
-function resolveOwnership(browser) {
-  return typeof browser === "object" && browser.mode === "attach" ? "attached" : "owned";
-}
 
-// src/provider/config.ts
-var OPENSTEER_PROVIDER_MODES = ["local", "cloud"];
-function assertProviderSupportsEngine(provider, engine) {
-  if (engine !== "abp") {
-    return;
+  function isRecorderUiNode(node) {
+    let current = node instanceof Node ? node : null;
+    while (current) {
+      if (current instanceof Element && current.hasAttribute(recorderUiAttribute)) {
+        return true;
+      }
+      const root = typeof current.getRootNode === "function" ? current.getRootNode() : null;
+      if (root instanceof ShadowRoot) {
+        current = root.host;
+        continue;
+      }
+      current = current instanceof Element ? current.parentElement : null;
+    }
+    return false;
   }
-  if (provider === "cloud") {
-    throw new Error(
-      "ABP is not supported for provider=cloud. Cloud provider currently requires Playwright."
-    );
+
+  function isValidAttributeName(name) {
+    if (typeof name !== "string") {
+      return false;
+    }
+    const normalized = name.trim();
+    if (normalized.length === 0) {
+      return false;
+    }
+    if (/[\s"'<>/]/.test(normalized)) {
+      return false;
+    }
+    return /^[A-Za-z_][A-Za-z0-9_:\-.]*$/.test(normalized);
   }
-}
-function normalizeOpensteerProviderMode(value, source = "OPENSTEER_PROVIDER") {
-  const normalized = value.trim().toLowerCase();
-  if (normalized === OPENSTEER_PROVIDER_MODES[0] || normalized === OPENSTEER_PROVIDER_MODES[1]) {
-    return normalized;
+
+  function escapeAttributeValue(value) {
+    return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
   }
-  throw new Error(
-    `${source} must be one of ${OPENSTEER_PROVIDER_MODES.join(", ")}; received "${value}".`
-  );
-}
-function resolveOpensteerProvider(input = {}) {
-  if (input.provider) {
-    return {
-      mode: input.provider.mode,
-      source: "explicit"
-    };
+
+  function escapeIdentifier(value) {
+    if (typeof CSS !== "undefined" && typeof CSS.escape === "function") {
+      return CSS.escape(value);
+    }
+    return String(value).replace(/[^A-Za-z0-9_-]/g, (character) => {
+      const codePoint = character.codePointAt(0);
+      return "\\" + (codePoint == null ? "" : codePoint.toString(16)) + " ";
+    });
   }
-  if (input.environmentProvider !== void 0 && input.environmentProvider.trim().length > 0) {
-    return {
-      mode: normalizeOpensteerProviderMode(input.environmentProvider),
-      source: "env"
-    };
+
+  function normalizeClassValue(element, rawValue) {
+    const tag = element.tagName.toLowerCase();
+    const tokens = String(rawValue)
+      .split(/\s+/u)
+      .map((token) => token.trim())
+      .filter(Boolean)
+      .filter((token) => !volatileClassTokens.has(token))
+      .filter((token) => !(lazyLoadingMediaTags.has(tag) && volatileLazyClassTokens.has(token)));
+    return tokens.join(" ");
   }
-  return {
-    mode: "local",
-    source: "default"
-  };
-}
-var execFile2 = promisify(execFile);
-var NODE_SQLITE_SPECIFIER2 = `node:${"sqlite"}`;
-var CHROME_EPOCH_OFFSET = 11644473600000000n;
-var CHROME_HMAC_PREFIX_LENGTH = 32;
-async function readBrowserCookies(input = {}) {
-  const brand2 = resolveRequestedBrand(input);
-  const userDataDir = resolveBrandUserDataDir(brand2, input.userDataDir);
-  const profileDirectory = input.profileDirectory ?? "Default";
-  const cookiesPath = join(userDataDir, profileDirectory, "Cookies");
-  if (!existsSync(cookiesPath)) {
-    throw new Error(
-      `Cookies database not found at "${cookiesPath}". Verify the browser brand, user-data-dir, and profile-directory are correct.`
-    );
+
+  function shouldKeepAttribute(element, name, value) {
+    const key = String(name || "")
+      .trim()
+      .toLowerCase();
+    if (!key || !String(value || "").trim()) {
+      return false;
+    }
+    if (!isValidAttributeName(key)) {
+      return false;
+    }
+    if (key === "c") {
+      return false;
+    }
+    if (/^on[a-z]/i.test(key)) {
+      return false;
+    }
+    if (attributeDenyKeys.has(key)) {
+      return false;
+    }
+    if (key.startsWith("data-os-") || key.startsWith("data-opensteer-")) {
+      return false;
+    }
+    if (lazyLoadingMediaTags.has(element.tagName.toLowerCase()) && volatileLazyLoadingAttrs.has(key)) {
+      return false;
+    }
+    return true;
   }
-  const tempDir = await mkdtemp(join(tmpdir(), "opensteer-cookies-"));
-  try {
-    await copyCookiesDatabase(cookiesPath, tempDir);
-    const decryptionKey = await resolveDecryptionKey(brand2.id, userDataDir);
-    const rows = queryAllCookies(join(tempDir, "Cookies"));
-    const cookies = decryptCookieRows(rows, decryptionKey);
-    return {
-      cookies,
-      brandId: brand2.id,
-      brandDisplayName: brand2.displayName,
-      userDataDir,
-      profileDirectory
-    };
-  } finally {
-    await rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
+
+  function readAttributeValue(element, key) {
+    if (key === "class") {
+      const normalized = normalizeClassValue(element, element.getAttribute("class") || "");
+      return normalized.length === 0 ? undefined : normalized;
+    }
+    const value = element.getAttribute(key);
+    if (!shouldKeepAttribute(element, key, value || "")) {
+      return undefined;
+    }
+    return value || undefined;
   }
-}
-function resolveRequestedBrand(input) {
-  if (input.brandId !== void 0) {
-    return getBrowserBrand(input.brandId);
+
+  function buildSingleAttributeSelector(element, key, value) {
+    if (!value) {
+      return undefined;
+    }
+    const tag = element.tagName.toLowerCase();
+    if (key === "id") {
+      const idSelector = "#" + escapeIdentifier(value);
+      return element.matches(idSelector)
+        ? idSelector
+        : tag + '[id="' + escapeAttributeValue(value) + '"]';
+    }
+    return tag + "[" + key + '="' + escapeAttributeValue(value) + '"]';
   }
-  const installed = detectInstalledBrowserBrands()[0];
+
+  function isUniqueSelector(selector, element) {
+    if (!selector) {
+      return false;
+    }
+    let matches;
+    try {
+      matches = document.querySelectorAll(selector);
+    } catch {
+      return false;
+    }
+    return matches.length === 1 && matches[0] === element;
+  }
+
+  function nearestRecordTarget(node) {
+    if (isRecorderUiNode(node)) {
+      return null;
+    }
+    let current = node instanceof Element ? node : null;
+    while (current) {
+      if (current.hasAttribute(recorderUiAttribute)) {
+        return null;
+      }
+      const tag = current.tagName.toLowerCase();
+      if (
+        actionTargetTags.has(tag) ||
+        current.hasAttribute("data-testid") ||
+        current.hasAttribute("data-test") ||
+        current.hasAttribute("data-qa") ||
+        current.hasAttribute("data-cy") ||
+        current.hasAttribute("role") ||
+        current.hasAttribute("aria-label") ||
+        current.hasAttribute("name")
+      ) {
+        return current;
+      }
+      current = current.parentElement;
+    }
+    return node instanceof Element ? node : null;
+  }
+
+  function buildSegmentSelector(element) {
+    const tag = element.tagName.toLowerCase();
+    for (const key of matchAttributePriority) {
+      const value = readAttributeValue(element, key);
+      if (!value) {
+        continue;
+      }
+      if (key === "class") {
+        const tokens = value
+          .split(/\s+/u)
+          .map((token) => token.trim())
+          .filter(Boolean)
+          .slice(0, 2);
+        if (tokens.length === 0) {
+          continue;
+        }
+        return tag + tokens.map((token) => "." + escapeIdentifier(token)).join("");
+      }
+      return key === "id"
+        ? tag + '[id="' + escapeAttributeValue(value) + '"]'
+        : tag + "[" + key + '="' + escapeAttributeValue(value) + '"]';
+    }
+    return tag;
+  }
+
+  function nthOfTypeSegment(element, baseSelector) {
+    const parent = element.parentElement;
+    if (!parent) {
+      return baseSelector;
+    }
+    const sameType = Array.from(parent.children).filter(
+      (child) => child.tagName === element.tagName,
+    );
+    if (sameType.length <= 1) {
+      return baseSelector;
+    }
+    const index = sameType.indexOf(element) + 1;
+    return baseSelector + ":nth-of-type(" + String(index) + ")";
+  }
+
+  function buildSelector(node) {
+    const element = nearestRecordTarget(node);
+    if (!(element instanceof Element)) {
+      return undefined;
+    }
+
+    for (const key of singleAttributePriority) {
+      const value = readAttributeValue(element, key);
+      const selector = buildSingleAttributeSelector(element, key, value);
+      if (selector && isUniqueSelector(selector, element)) {
+        return selector;
+      }
+      if (value && !stablePrimaryAttrKeys.has(key) && key !== "id") {
+        const tagQualified =
+          element.tagName.toLowerCase() + "[" + key + '="' + escapeAttributeValue(value) + '"]';
+        if (isUniqueSelector(tagQualified, element)) {
+          return tagQualified;
+        }
+      }
+    }
+
+    const segments = [];
+    let current = element;
+    let depth = 0;
+    while (current && depth < 6) {
+      const segment = nthOfTypeSegment(current, buildSegmentSelector(current));
+      segments.unshift(segment);
+      const selector = segments.join(" > ");
+      if (isUniqueSelector(selector, element)) {
+        return selector;
+      }
+      current = current.parentElement;
+      depth += 1;
+    }
+
+    const fallback = segments.join(" > ");
+    return fallback.length > 0 ? fallback : element.tagName.toLowerCase();
+  }
+
+  function readTargetValue(target) {
+    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {
+      return target.value;
+    }
+    if (target instanceof HTMLSelectElement) {
+      return target.value;
+    }
+    if (target instanceof HTMLElement && target.isContentEditable) {
+      return target.textContent || "";
+    }
+    return undefined;
+  }
+
+  function flushPendingInput(selector) {
+    const pending = pendingInputs.get(selector);
+    if (!pending) {
+      return;
+    }
+    pendingInputs.delete(selector);
+    const timer = inputFlushTimers.get(selector);
+    if (timer !== undefined) {
+      clearTimeout(timer);
+      inputFlushTimers.delete(selector);
+    }
+    enqueue({
+      kind: "type",
+      selector,
+      text: pending.text,
+      timestamp: pending.timestamp,
+    });
+  }
+
+  function flushAllInputs() {
+    for (const selector of Array.from(pendingInputs.keys())) {
+      flushPendingInput(selector);
+    }
+  }
+
+  function flushPendingWheel() {
+    if (!pendingWheel) {
+      return;
+    }
+    clearTimeout(pendingWheel.timerId);
+    enqueue({
+      kind: "scroll",
+      selector: pendingWheel.selector,
+      deltaX: pendingWheel.deltaX,
+      deltaY: pendingWheel.deltaY,
+      timestamp: pendingWheel.timestamp,
+    });
+    pendingWheel = undefined;
+  }
+
+  function scheduleInputFlush(selector) {
+    const existing = inputFlushTimers.get(selector);
+    if (existing !== undefined) {
+      clearTimeout(existing);
+    }
+    const timerId = setTimeout(() => {
+      flushPendingInput(selector);
+    }, 400);
+    inputFlushTimers.set(selector, timerId);
+  }
+
+  function updateHistoryState(mode, nextUrl) {
+    let state;
+    try {
+      const raw = sessionStorage.getItem(historyStateKey);
+      state = raw ? JSON.parse(raw) : undefined;
+    } catch {
+      state = undefined;
+    }
+    if (!state || !Array.isArray(state.entries) || typeof state.index !== "number") {
+      state = { entries: [location.href], index: 0 };
+    }
+    if (mode === "replace") {
+      state.entries[state.index] = nextUrl;
+    } else if (mode === "push") {
+      state.entries = state.entries.slice(0, state.index + 1);
+      state.entries.push(nextUrl);
+      state.index = state.entries.length - 1;
+    } else if (mode === "back") {
+      state.index = Math.max(0, state.index - 1);
+    } else if (mode === "forward") {
+      state.index = Math.min(state.entries.length - 1, state.index + 1);
+    }
+    try {
+      sessionStorage.setItem(historyStateKey, JSON.stringify(state));
+    } catch {}
+    return state;
+  }
+
+  function readHistoryState() {
+    try {
+      const raw = sessionStorage.getItem(historyStateKey);
+      const parsed = raw ? JSON.parse(raw) : undefined;
+      if (
+        parsed &&
+        Array.isArray(parsed.entries) &&
+        parsed.entries.every((entry) => typeof entry === "string") &&
+        typeof parsed.index === "number"
+      ) {
+        return parsed;
+      }
+    } catch {}
+    return undefined;
+  }
+
+  function classifyHistoryTraversal(currentUrl) {
+    const state = readHistoryState();
+    if (!state) {
+      return undefined;
+    }
+    if (state.entries[state.index - 1] === currentUrl) {
+      updateHistoryState("back", currentUrl);
+      return "go-back";
+    }
+    if (state.entries[state.index + 1] === currentUrl) {
+      updateHistoryState("forward", currentUrl);
+      return "go-forward";
+    }
+    const existingIndex = state.entries.lastIndexOf(currentUrl);
+    if (existingIndex !== -1) {
+      if (existingIndex < state.index) {
+        while (readHistoryState()?.index > existingIndex) {
+          updateHistoryState("back", currentUrl);
+        }
+        return "go-back";
+      }
+      if (existingIndex > state.index) {
+        while (readHistoryState()?.index < existingIndex) {
+          updateHistoryState("forward", currentUrl);
+        }
+        return "go-forward";
+      }
+    }
+    return undefined;
+  }
+
+  function onInstall() {
+    const currentUrl = location.href;
+    const navigationEntry =
+      typeof performance.getEntriesByType === "function"
+        ? performance.getEntriesByType("navigation")[0]
+        : undefined;
+    const navigationType =
+      navigationEntry && typeof navigationEntry.type === "string" ? navigationEntry.type : undefined;
+    const existingState = readHistoryState();
+
+    if (!existingState) {
+      updateHistoryState("replace", currentUrl);
+      return;
+    }
+
+    if (navigationType === "reload") {
+      updateHistoryState("replace", currentUrl);
+      enqueue({
+        kind: "reload",
+        url: currentUrl,
+      });
+      return;
+    }
+
+    if (navigationType === "back_forward") {
+      const traversal = classifyHistoryTraversal(currentUrl);
+      if (traversal === "go-back" || traversal === "go-forward") {
+        enqueue({
+          kind: traversal,
+          url: currentUrl,
+        });
+        return;
+      }
+    }
+
+    if (existingState.entries[existingState.index] !== currentUrl) {
+      updateHistoryState("push", currentUrl);
+      enqueue({
+        kind: "navigate",
+        url: currentUrl,
+        source: "full-navigation",
+      });
+    }
+  }
+
+  function modifierKeys(event) {
+    const modifiers = [];
+    if (event.altKey) {
+      modifiers.push("Alt");
+    }
+    if (event.ctrlKey) {
+      modifiers.push("Control");
+    }
+    if (event.metaKey) {
+      modifiers.push("Meta");
+    }
+    if (event.shiftKey) {
+      modifiers.push("Shift");
+    }
+    return modifiers;
+  }
+
+  function addListener(target, type, listener, options) {
+    target.addEventListener(type, listener, options);
+    cleanup.push(() => {
+      target.removeEventListener(type, listener, options);
+    });
+  }
+
+  function requestStop() {
+    stopRequested = true;
+  }
+
+  function mountStopButton() {
+    if (document.querySelector("[" + recorderUiAttribute + "]")) {
+      return true;
+    }
+    if (stopRequested) {
+      return true;
+    }
+    const parent = document.body || document.documentElement;
+    if (!(parent instanceof HTMLElement)) {
+      return false;
+    }
+
+    const host = document.createElement("div");
+    host.setAttribute(recorderUiAttribute, "true");
+    const shadowRoot = host.attachShadow({ mode: "open" });
+    const style = document.createElement("style");
+    style.textContent = [
+      ":host {",
+      "  all: initial;",
+      "  display: block;",
+      "  position: fixed;",
+      "  top: 16px;",
+      "  right: 16px;",
+      "  z-index: 2147483647;",
+      "  pointer-events: auto;",
+      "  color-scheme: only light;",
+      "  contain: content;",
+      "  isolation: isolate;",
+      "}",
+      "button {",
+      "  appearance: none;",
+      "  border: 1px solid rgba(15, 23, 42, 0.2);",
+      "  border-radius: 999px;",
+      "  background: rgba(15, 23, 42, 0.92);",
+      "  color: #ffffff;",
+      "  color-scheme: only light;",
+      "  cursor: pointer;",
+      "  font: 600 12px/1.2 ui-sans-serif, system-ui, sans-serif;",
+      "  letter-spacing: 0.01em;",
+      "  padding: 10px 14px;",
+      "  box-shadow: 0 10px 30px rgba(15, 23, 42, 0.22);",
+      "}",
+      "button:hover {",
+      "  background: rgba(15, 23, 42, 0.98);",
+      "}",
+      "button:focus-visible {",
+      "  outline: 2px solid #2563eb;",
+      "  outline-offset: 2px;",
+      "}",
+      "button:disabled {",
+      "  cursor: wait;",
+      "  opacity: 0.8;",
+      "}",
+    ].join("\n");
+    const button = document.createElement("button");
+    button.type = "button";
+    button.textContent = "Stop recording";
+    button.setAttribute("aria-label", "Stop recording");
+    const consumePointerEvent = (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+    };
+    for (const type of ["pointerdown", "mousedown", "mouseup", "click"]) {
+      button.addEventListener(type, consumePointerEvent);
+    }
+    button.addEventListener("click", () => {
+      requestStop();
+      host.remove();
+    });
+    shadowRoot.append(style, button);
+    parent.appendChild(host);
+    cleanup.push(() => {
+      host.remove();
+    });
+    return true;
+  }
+
+  function ensureStopButtonMounted() {
+    if (mountStopButton()) {
+      return;
+    }
+
+    const observer = new MutationObserver(() => {
+      if (!mountStopButton()) {
+        return;
+      }
+      observer.disconnect();
+    });
+    observer.observe(document, {
+      childList: true,
+      subtree: true,
+    });
+    cleanup.push(() => {
+      observer.disconnect();
+    });
+  }
+
+  addListener(document, "click", (event) => {
+    if (!event.isTrusted) {
+      return;
+    }
+    const target = nearestRecordTarget(event.target);
+    if (!(target instanceof Element)) {
+      return;
+    }
+    const tag = target.tagName.toLowerCase();
+    if (tag === "select" || tag === "option") {
+      return;
+    }
+    const selector = buildSelector(target);
+    if (!selector) {
+      return;
+    }
+    enqueue({
+      kind: "click",
+      selector,
+      button: event.button,
+      modifiers: modifierKeys(event),
+    });
+  }, true);
+
+  addListener(document, "dblclick", (event) => {
+    if (!event.isTrusted) {
+      return;
+    }
+    const target = nearestRecordTarget(event.target);
+    if (!(target instanceof Element)) {
+      return;
+    }
+    const selector = buildSelector(target);
+    if (!selector) {
+      return;
+    }
+    enqueue({
+      kind: "dblclick",
+      selector,
+    });
+  }, true);
+
+  addListener(document, "input", (event) => {
+    if (!event.isTrusted) {
+      return;
+    }
+    const target = nearestRecordTarget(event.target);
+    if (!(target instanceof Element)) {
+      return;
+    }
+    const selector = buildSelector(target);
+    const text = readTargetValue(target);
+    if (!selector || typeof text !== "string") {
+      return;
+    }
+    pendingInputs.set(selector, {
+      selector,
+      text,
+      timestamp: now(),
+    });
+    scheduleInputFlush(selector);
+  }, true);
+
+  addListener(document, "change", (event) => {
+    if (!event.isTrusted) {
+      return;
+    }
+    const target = nearestRecordTarget(event.target);
+    if (!(target instanceof HTMLSelectElement)) {
+      return;
+    }
+    const selector = buildSelector(target);
+    if (!selector) {
+      return;
+    }
+    const selectedOption = target.selectedOptions && target.selectedOptions.length > 0
+      ? target.selectedOptions[0]
+      : undefined;
+    enqueue({
+      kind: "select-option",
+      selector,
+      value: target.value,
+      ...(selectedOption === undefined ? {} : { label: selectedOption.label || selectedOption.textContent || "" }),
+    });
+  }, true);
+
+  addListener(document, "keydown", (event) => {
+    if (!event.isTrusted) {
+      return;
+    }
+    const allowedKeys = new Set([
+      "ArrowDown",
+      "ArrowLeft",
+      "ArrowRight",
+      "ArrowUp",
+      "Backspace",
+      "Delete",
+      "Enter",
+      "Escape",
+      "Tab",
+    ]);
+    if (!allowedKeys.has(event.key)) {
+      return;
+    }
+    const target = nearestRecordTarget(event.target);
+    const selector = target instanceof Element ? buildSelector(target) : undefined;
+    if (event.key === "Enter" && selector) {
+      flushPendingInput(selector);
+    }
+    enqueue({
+      kind: "keypress",
+      key: event.key,
+      modifiers: modifierKeys(event),
+      ...(selector === undefined ? {} : { selector }),
+    });
+  }, true);
+
+  addListener(document, "wheel", (event) => {
+    if (!event.isTrusted) {
+      return;
+    }
+    const target = nearestRecordTarget(event.target);
+    const selector = target instanceof Element ? buildSelector(target) : undefined;
+    if (pendingWheel && pendingWheel.selector === selector) {
+      pendingWheel.deltaX += event.deltaX;
+      pendingWheel.deltaY += event.deltaY;
+      clearTimeout(pendingWheel.timerId);
+      pendingWheel.timerId = setTimeout(flushPendingWheel, 250);
+      return;
+    }
+    flushPendingWheel();
+    pendingWheel = {
+      selector,
+      deltaX: event.deltaX,
+      deltaY: event.deltaY,
+      timestamp: now(),
+      timerId: setTimeout(flushPendingWheel, 250),
+    };
+  }, true);
+
+  const originalPushState = history.pushState.bind(history);
+  history.pushState = function pushState(state, unused, url) {
+    const beforeUrl = location.href;
+    const output = originalPushState.apply(this, arguments);
+    const nextUrl = location.href;
+    if (nextUrl !== beforeUrl) {
+      updateHistoryState("push", nextUrl);
+      enqueue({
+        kind: "navigate",
+        url: nextUrl,
+        source: "push-state",
+      });
+    }
+    return output;
+  };
+  cleanup.push(() => {
+    history.pushState = originalPushState;
+  });
+
+  const originalReplaceState = history.replaceState.bind(history);
+  history.replaceState = function replaceState(state, unused, url) {
+    const beforeUrl = location.href;
+    const output = originalReplaceState.apply(this, arguments);
+    const nextUrl = location.href;
+    if (nextUrl !== beforeUrl) {
+      updateHistoryState("replace", nextUrl);
+      enqueue({
+        kind: "navigate",
+        url: nextUrl,
+        source: "replace-state",
+      });
+    }
+    return output;
+  };
+  cleanup.push(() => {
+    history.replaceState = originalReplaceState;
+  });
+
+  addListener(globalScope, "popstate", () => {
+    const currentUrl = location.href;
+    const traversal = classifyHistoryTraversal(currentUrl);
+    if (traversal === "go-back" || traversal === "go-forward") {
+      enqueue({
+        kind: traversal,
+        url: currentUrl,
+      });
+      return;
+    }
+    if (readHistoryState()?.entries[readHistoryState().index] !== currentUrl) {
+      updateHistoryState("push", currentUrl);
+      enqueue({
+        kind: "navigate",
+        url: currentUrl,
+        source: "history-traversal",
+      });
+    }
+  });
+
+  addListener(globalScope, "hashchange", () => {
+    const currentUrl = location.href;
+    updateHistoryState("replace", currentUrl);
+    enqueue({
+      kind: "navigate",
+      url: currentUrl,
+      source: "hashchange",
+    });
+  });
+
+  function drain() {
+    flushAllInputs();
+    flushPendingWheel();
+    return {
+      url: location.href,
+      focused: document.hasFocus(),
+      visibilityState: document.visibilityState,
+      stopRequested,
+      events: queue.splice(0, queue.length),
+    };
+  }
+
+  globalScope[recorderKey] = {
+    installed: true,
+    debugSelector(target) {
+      return buildSelector(target);
+    },
+    drain,
+    requestStop,
+    dispose() {
+      flushAllInputs();
+      flushPendingWheel();
+      for (const dispose of cleanup.splice(0, cleanup.length)) {
+        dispose();
+      }
+      for (const timerId of inputFlushTimers.values()) {
+        clearTimeout(timerId);
+      }
+      inputFlushTimers.clear();
+      pendingInputs.clear();
+      delete globalScope[recorderKey];
+    },
+  };
+
+  ensureStopButtonMounted();
+  onInstall();
+})();`;
+var FLOW_RECORDER_INSTALL_SCRIPT = FLOW_RECORDER_INSTALL_SOURCE;
+var FLOW_RECORDER_DRAIN_SCRIPT = String.raw`(() => {
+  const recorder = globalThis.__opensteerFlowRecorder;
+  if (!recorder || typeof recorder.drain !== "function") {
+    return {
+      url: location.href,
+      focused: document.hasFocus(),
+      visibilityState: document.visibilityState,
+      stopRequested: false,
+      events: [],
+    };
+  }
+  return recorder.drain();
+})();`;
+
+// ../runtime-core/src/recorder/event-collector.ts
+var FlowRecorderCollector = class {
+  runtime;
+  pollIntervalMs;
+  onAction;
+  pages = /* @__PURE__ */ new Map();
+  actions = [];
+  nextPageOrdinal = 0;
+  runningLoop;
+  loopStopRequested = false;
+  stopDetected = false;
+  focusedPageId;
+  stopWaiters = [];
+  constructor(runtime, options = {}) {
+    this.runtime = runtime;
+    this.pollIntervalMs = options.pollIntervalMs ?? 250;
+    this.onAction = options.onAction;
+  }
+  async install() {
+    await this.runtime.addInitScript({
+      script: FLOW_RECORDER_INSTALL_SCRIPT
+    });
+    const { pages } = await this.runtime.listPages();
+    for (const page of pages) {
+      this.ensureKnownPage(page.pageRef, page.url, page.openerPageRef);
+    }
+    await Promise.all(
+      pages.map(
+        (page) => this.runtime.evaluate({
+          script: FLOW_RECORDER_INSTALL_SCRIPT,
+          pageRef: page.pageRef
+        }).catch(() => void 0)
+      )
+    );
+    const evaluatedPages = await this.readEvaluatedPages(pages);
+    for (const page of evaluatedPages) {
+      this.updateKnownPage(page.pageRef, page.currentUrl, page.openerPageRef);
+    }
+    this.focusedPageId = evaluatedPages.find((page) => page.focused)?.pageId ?? this.focusedPageId;
+  }
+  start() {
+    if (this.runningLoop !== void 0) {
+      return;
+    }
+    this.loopStopRequested = false;
+    this.runningLoop = this.runLoop();
+  }
+  async stop() {
+    this.loopStopRequested = true;
+    if (this.runningLoop !== void 0) {
+      await this.runningLoop;
+      this.runningLoop = void 0;
+    }
+    if (!this.stopDetected) {
+      await this.pollOnce().catch(() => void 0);
+    }
+    return this.actions.slice();
+  }
+  getActions() {
+    return this.actions.slice();
+  }
+  async waitForStop() {
+    if (this.stopDetected) {
+      return;
+    }
+    await new Promise((resolve4) => {
+      this.stopWaiters.push(resolve4);
+    });
+  }
+  async pollOnce() {
+    const pollTimestamp = Date.now();
+    const { pages } = await this.runtime.listPages();
+    const previousPageRefs = new Set(this.pages.keys());
+    const evaluatedPages = await this.readEvaluatedPages(pages);
+    if (!this.stopDetected && evaluatedPages.some((page) => page.stopRequested)) {
+      this.stopDetected = true;
+      this.loopStopRequested = true;
+      for (const resolve4 of this.stopWaiters.splice(0, this.stopWaiters.length)) {
+        resolve4();
+      }
+    }
+    const actions = this.normalizePoll({
+      pollTimestamp,
+      previousPageRefs,
+      listedPages: pages,
+      evaluatedPages
+    });
+    if (actions.length === 0) {
+      return [];
+    }
+    actions.sort((left, right) => {
+      const timestampOrder = left.timestamp - right.timestamp;
+      if (timestampOrder !== 0) {
+        return timestampOrder;
+      }
+      return actionSortPriority(left.kind) - actionSortPriority(right.kind);
+    });
+    for (const action of actions) {
+      this.actions.push(action);
+      if (this.onAction !== void 0) {
+        await this.onAction(action);
+      }
+    }
+    return actions;
+  }
+  async runLoop() {
+    while (!this.loopStopRequested) {
+      try {
+        await this.pollOnce();
+      } catch {
+      }
+      if (this.loopStopRequested) {
+        break;
+      }
+      await delay(this.pollIntervalMs);
+    }
+  }
+  async readEvaluatedPages(listedPages) {
+    const pages = await Promise.all(
+      listedPages.map(async (page) => {
+        const knownPage = this.ensureKnownPage(page.pageRef, page.url, page.openerPageRef);
+        const snapshot = await this.readSnapshot(page.pageRef, page.url);
+        this.updateKnownPage(page.pageRef, snapshot.url, page.openerPageRef);
+        return {
+          pageRef: page.pageRef,
+          pageId: knownPage.pageId,
+          previousUrl: knownPage.currentUrl,
+          currentUrl: snapshot.url,
+          focused: snapshot.focused || snapshot.visibilityState === "visible",
+          stopRequested: snapshot.stopRequested,
+          events: snapshot.events,
+          ...page.openerPageRef === void 0 ? {} : { openerPageRef: page.openerPageRef },
+          ...knownPage.openerPageId === void 0 ? {} : { openerPageId: knownPage.openerPageId }
+        };
+      })
+    );
+    return pages;
+  }
+  async readSnapshot(pageRef, fallbackUrl) {
+    const value = await this.runtime.evaluate({
+      script: FLOW_RECORDER_DRAIN_SCRIPT,
+      pageRef
+    });
+    return normalizeSnapshot(value, fallbackUrl);
+  }
+  normalizePoll(input) {
+    const listedPageRefs = new Set(input.listedPages.map((page) => page.pageRef));
+    const actions = [];
+    const firstEventTimestampByPage = /* @__PURE__ */ new Map();
+    for (const evaluatedPage of input.evaluatedPages) {
+      const firstTimestamp = evaluatedPage.events[0]?.timestamp;
+      if (firstTimestamp !== void 0) {
+        firstEventTimestampByPage.set(evaluatedPage.pageRef, firstTimestamp);
+      }
+    }
+    for (const listedPage of input.listedPages) {
+      if (!input.previousPageRefs.has(listedPage.pageRef)) {
+        const created = this.ensureKnownPage(listedPage.pageRef, listedPage.url, listedPage.openerPageRef);
+        actions.push({
+          kind: "new-tab",
+          timestamp: Math.max(0, (firstEventTimestampByPage.get(listedPage.pageRef) ?? input.pollTimestamp) - 1),
+          pageId: created.pageId,
+          pageUrl: listedPage.url,
+          detail: {
+            kind: "new-tab",
+            ...created.openerPageId === void 0 ? {} : { openerPageId: created.openerPageId },
+            initialUrl: listedPage.url
+          }
+        });
+      }
+    }
+    for (const [pageRef, knownPage] of [...this.pages.entries()]) {
+      if (listedPageRefs.has(pageRef)) {
+        continue;
+      }
+      actions.push({
+        kind: "close-tab",
+        timestamp: input.pollTimestamp,
+        pageId: knownPage.pageId,
+        pageUrl: knownPage.currentUrl,
+        detail: {
+          kind: "close-tab"
+        }
+      });
+      this.pages.delete(pageRef);
+    }
+    for (const evaluatedPage of input.evaluatedPages) {
+      const knownPage = this.pages.get(evaluatedPage.pageRef);
+      if (!knownPage) {
+        continue;
+      }
+      if (evaluatedPage.previousUrl !== evaluatedPage.currentUrl && !evaluatedPage.events.some(
+        (event) => event.kind === "navigate" || event.kind === "reload" || event.kind === "go-back" || event.kind === "go-forward"
+      )) {
+        actions.push({
+          kind: "navigate",
+          timestamp: Math.max(
+            0,
+            (firstEventTimestampByPage.get(evaluatedPage.pageRef) ?? input.pollTimestamp) - 1
+          ),
+          pageId: knownPage.pageId,
+          pageUrl: evaluatedPage.currentUrl,
+          detail: {
+            kind: "navigate",
+            url: evaluatedPage.currentUrl,
+            source: "poll"
+          }
+        });
+      }
+      actions.push(
+        ...evaluatedPage.events.flatMap(
+          (event) => this.normalizeRawEvent(event, knownPage, evaluatedPage.currentUrl)
+        )
+      );
+      this.updateKnownPage(evaluatedPage.pageRef, evaluatedPage.currentUrl, evaluatedPage.openerPageRef);
+    }
+    const focusedPage = input.evaluatedPages.find((page) => page.focused);
+    if (focusedPage !== void 0 && focusedPage.pageId !== this.focusedPageId) {
+      actions.push({
+        kind: "switch-tab",
+        timestamp: Math.max(
+          0,
+          (firstEventTimestampByPage.get(focusedPage.pageRef) ?? input.pollTimestamp) - 1
+        ),
+        pageId: focusedPage.pageId,
+        pageUrl: focusedPage.currentUrl,
+        detail: {
+          kind: "switch-tab",
+          ...this.focusedPageId === void 0 ? {} : { fromPageId: this.focusedPageId },
+          toPageId: focusedPage.pageId
+        }
+      });
+      this.focusedPageId = focusedPage.pageId;
+    }
+    return dedupeConsecutiveSwitchActions(actions);
+  }
+  normalizeRawEvent(event, page, currentUrl) {
+    switch (event.kind) {
+      case "navigate":
+        return [
+          {
+            kind: "navigate",
+            timestamp: event.timestamp,
+            pageId: page.pageId,
+            pageUrl: event.url,
+            detail: {
+              kind: "navigate",
+              url: event.url,
+              source: event.source
+            }
+          }
+        ];
+      case "click":
+        return [
+          {
+            kind: "click",
+            timestamp: event.timestamp,
+            pageId: page.pageId,
+            pageUrl: currentUrl,
+            selector: event.selector,
+            detail: {
+              kind: "click",
+              button: event.button,
+              modifiers: event.modifiers
+            }
+          }
+        ];
+      case "dblclick":
+        return [
+          {
+            kind: "dblclick",
+            timestamp: event.timestamp,
+            pageId: page.pageId,
+            pageUrl: currentUrl,
+            selector: event.selector,
+            detail: {
+              kind: "dblclick"
+            }
+          }
+        ];
+      case "type":
+        return [
+          {
+            kind: "type",
+            timestamp: event.timestamp,
+            pageId: page.pageId,
+            pageUrl: currentUrl,
+            selector: event.selector,
+            detail: {
+              kind: "type",
+              text: event.text
+            }
+          }
+        ];
+      case "keypress":
+        return [
+          {
+            kind: "keypress",
+            timestamp: event.timestamp,
+            pageId: page.pageId,
+            pageUrl: currentUrl,
+            ...event.selector === void 0 ? {} : { selector: event.selector },
+            detail: {
+              kind: "keypress",
+              key: event.key,
+              modifiers: event.modifiers
+            }
+          }
+        ];
+      case "scroll":
+        return [
+          {
+            kind: "scroll",
+            timestamp: event.timestamp,
+            pageId: page.pageId,
+            pageUrl: currentUrl,
+            ...event.selector === void 0 ? {} : { selector: event.selector },
+            detail: {
+              kind: "scroll",
+              deltaX: event.deltaX,
+              deltaY: event.deltaY
+            }
+          }
+        ];
+      case "select-option":
+        return [
+          {
+            kind: "select-option",
+            timestamp: event.timestamp,
+            pageId: page.pageId,
+            pageUrl: currentUrl,
+            selector: event.selector,
+            detail: {
+              kind: "select-option",
+              value: event.value,
+              ...event.label === void 0 ? {} : { label: event.label }
+            }
+          }
+        ];
+      case "reload":
+        return [
+          {
+            kind: "reload",
+            timestamp: event.timestamp,
+            pageId: page.pageId,
+            pageUrl: event.url,
+            detail: {
+              kind: "reload",
+              url: event.url
+            }
+          }
+        ];
+      case "go-back":
+        return [
+          {
+            kind: "go-back",
+            timestamp: event.timestamp,
+            pageId: page.pageId,
+            pageUrl: event.url,
+            detail: {
+              kind: "go-back",
+              url: event.url
+            }
+          }
+        ];
+      case "go-forward":
+        return [
+          {
+            kind: "go-forward",
+            timestamp: event.timestamp,
+            pageId: page.pageId,
+            pageUrl: event.url,
+            detail: {
+              kind: "go-forward",
+              url: event.url
+            }
+          }
+        ];
+    }
+  }
+  ensureKnownPage(pageRef, url, openerPageRef) {
+    const existing = this.pages.get(pageRef);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const openerPageId = openerPageRef === void 0 ? void 0 : this.pages.get(openerPageRef)?.pageId;
+    const page = {
+      pageId: `page${String(this.nextPageOrdinal++)}`,
+      pageRef,
+      currentUrl: url,
+      ...openerPageRef === void 0 ? {} : { openerPageRef },
+      ...openerPageId === void 0 ? {} : { openerPageId }
+    };
+    this.pages.set(pageRef, page);
+    return page;
+  }
+  updateKnownPage(pageRef, url, openerPageRef) {
+    const current = this.pages.get(pageRef);
+    if (current === void 0) {
+      this.ensureKnownPage(pageRef, url, openerPageRef);
+      return;
+    }
+    const openerPageId = openerPageRef === void 0 ? void 0 : this.pages.get(openerPageRef)?.pageId;
+    this.pages.set(pageRef, {
+      ...current,
+      currentUrl: url,
+      ...openerPageRef === void 0 ? {} : { openerPageRef },
+      ...openerPageId === void 0 ? {} : { openerPageId }
+    });
+  }
+};
+function normalizeSnapshot(value, fallbackUrl) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {
+      url: fallbackUrl,
+      focused: false,
+      visibilityState: "hidden",
+      stopRequested: false,
+      events: []
+    };
+  }
+  const snapshot = value;
+  return {
+    url: typeof snapshot.url === "string" ? snapshot.url : fallbackUrl,
+    focused: snapshot.focused === true,
+    visibilityState: snapshot.visibilityState === "visible" || snapshot.visibilityState === "prerender" || snapshot.visibilityState === "hidden" ? snapshot.visibilityState : "hidden",
+    stopRequested: snapshot.stopRequested === true,
+    events: Array.isArray(snapshot.events) ? snapshot.events : []
+  };
+}
+function dedupeConsecutiveSwitchActions(actions) {
+  const deduped = [];
+  for (const action of actions) {
+    const previous = deduped[deduped.length - 1];
+    if (previous?.kind === "switch-tab" && action.kind === "switch-tab" && previous.pageId === action.pageId) {
+      continue;
+    }
+    deduped.push(action);
+  }
+  return deduped;
+}
+function actionSortPriority(kind) {
+  switch (kind) {
+    case "new-tab":
+      return 0;
+    case "switch-tab":
+      return 1;
+    case "navigate":
+    case "go-back":
+    case "go-forward":
+    case "reload":
+      return 2;
+    case "click":
+    case "dblclick":
+      return 3;
+    case "type":
+    case "keypress":
+    case "select-option":
+      return 4;
+    case "scroll":
+      return 5;
+    case "close-tab":
+      return 6;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+
+// ../runtime-core/src/recorder/codegen.ts
+var DISPATCH_KEY_SCRIPT = String.raw`(key) => {
+  const target = document.activeElement;
+  if (!(target instanceof Element)) {
+    throw new Error("No active element is available for key replay.");
+  }
+  const normalizedKey = String(key);
+  const eventInit = {
+    key: normalizedKey,
+    code: normalizedKey,
+    bubbles: true,
+    cancelable: true,
+  };
+  target.dispatchEvent(new KeyboardEvent("keydown", eventInit));
+  target.dispatchEvent(new KeyboardEvent("keyup", eventInit));
+}`;
+var SELECT_OPTION_SCRIPT = String.raw`(selector, value) => {
+  const target = document.querySelector(String(selector));
+  if (!(target instanceof HTMLSelectElement)) {
+    throw new Error("Unable to find a <select> element for option replay.");
+  }
+  target.value = String(value);
+  target.dispatchEvent(new Event("input", { bubbles: true }));
+  target.dispatchEvent(new Event("change", { bubbles: true }));
+}`;
+var HISTORY_ACTION_SCRIPT = String.raw`(action) => {
+  const normalized = String(action);
+  if (normalized === "back") {
+    history.back();
+    return;
+  }
+  if (normalized === "forward") {
+    history.forward();
+    return;
+  }
+  if (normalized === "reload") {
+    location.reload();
+    return;
+  }
+  throw new Error("Unsupported history action: " + normalized);
+}`;
+var WINDOW_SCROLL_SCRIPT = String.raw`(deltaX, deltaY) => {
+  window.scrollBy(Number(deltaX), Number(deltaY));
+}`;
+function generateReplayScript(options) {
+  const pageIds = collectPageIds(options.actions);
+  const initialPageId = pageIds[0] ?? "page0";
+  const lines = [
+    `import { Opensteer } from "opensteer";`,
+    ``,
+    `const opensteer = new Opensteer({`,
+    `  workspace: ${JSON.stringify(options.workspace)},`,
+    `  browser: "persistent",`,
+    `});`,
+    ``,
+    `const ${initialPageId} = (await opensteer.open(${JSON.stringify(options.startUrl)})).pageRef;`,
+    `let activePageRef: string | undefined = ${initialPageId};`,
+    ``,
+    `async function ensureActive(pageRef: string): Promise<void> {`,
+    `  if (activePageRef === pageRef) {`,
+    `    return;`,
+    `  }`,
+    `  await opensteer.activatePage({ pageRef });`,
+    `  activePageRef = pageRef;`,
+    `}`,
+    ``,
+    `async function dispatchKey(pageRef: string, key: string): Promise<void> {`,
+    `  await ensureActive(pageRef);`,
+    `  await opensteer.evaluate({`,
+    `    pageRef,`,
+    `    script: ${JSON.stringify(DISPATCH_KEY_SCRIPT)},`,
+    `    args: [key],`,
+    `  });`,
+    `}`,
+    ``,
+    `async function selectOption(pageRef: string, selector: string, value: string): Promise<void> {`,
+    `  await ensureActive(pageRef);`,
+    `  await opensteer.evaluate({`,
+    `    pageRef,`,
+    `    script: ${JSON.stringify(SELECT_OPTION_SCRIPT)},`,
+    `    args: [selector, value],`,
+    `  });`,
+    `}`,
+    ``,
+    `async function runHistoryAction(pageRef: string, action: "back" | "forward" | "reload"): Promise<void> {`,
+    `  await ensureActive(pageRef);`,
+    `  await opensteer.evaluate({`,
+    `    pageRef,`,
+    `    script: ${JSON.stringify(HISTORY_ACTION_SCRIPT)},`,
+    `    args: [action],`,
+    `  });`,
+    `}`,
+    ``,
+    `try {`
+  ];
+  const declaredPages = /* @__PURE__ */ new Set([initialPageId]);
+  for (let index = 0; index < options.actions.length; index += 1) {
+    const action = options.actions[index];
+    const pageVar = action.pageId;
+    if (action.kind === "type") {
+      const nextAction = options.actions[index + 1];
+      const mergedPressEnter = nextAction?.kind === "keypress" && nextAction.pageId === action.pageId && nextAction.selector === action.selector && nextAction.detail.kind === "keypress" && nextAction.detail.key === "Enter" && nextAction.detail.modifiers.length === 0;
+      lines.push(`  await ensureActive(${pageVar});`);
+      lines.push(
+        `  await opensteer.input({ selector: ${JSON.stringify(requireSelector(action))}, text: ${JSON.stringify(action.detail.text)}${mergedPressEnter ? `, pressEnter: true` : ``} });`
+      );
+      if (mergedPressEnter) {
+        index += 1;
+      }
+      continue;
+    }
+    if (action.kind === "switch-tab" && options.actions[index - 1]?.kind === "new-tab" && options.actions[index - 1]?.pageId === action.pageId) {
+      continue;
+    }
+    switch (action.kind) {
+      case "navigate":
+        lines.push(`  await ensureActive(${pageVar});`);
+        lines.push(`  await opensteer.goto(${JSON.stringify(action.detail.url)});`);
+        break;
+      case "click":
+        lines.push(`  await ensureActive(${pageVar});`);
+        lines.push(
+          `  await opensteer.click({ selector: ${JSON.stringify(requireSelector(action))} });`
+        );
+        break;
+      case "dblclick":
+        lines.push(`  await ensureActive(${pageVar});`);
+        lines.push(
+          `  await opensteer.click({ selector: ${JSON.stringify(requireSelector(action))} });`
+        );
+        lines.push(
+          `  await opensteer.click({ selector: ${JSON.stringify(requireSelector(action))} });`
+        );
+        break;
+      case "keypress":
+        lines.push(
+          `  await dispatchKey(${pageVar}, ${JSON.stringify(action.detail.key)});`
+        );
+        break;
+      case "scroll": {
+        const { direction, amount, isWindowScroll } = normalizeScrollAction(action);
+        lines.push(`  await ensureActive(${pageVar});`);
+        if (isWindowScroll) {
+          lines.push(`  await opensteer.evaluate({`);
+          lines.push(`    pageRef: ${pageVar},`);
+          lines.push(`    script: ${JSON.stringify(WINDOW_SCROLL_SCRIPT)},`);
+          lines.push(
+            `    args: [${String(action.detail.deltaX)}, ${String(action.detail.deltaY)}],`
+          );
+          lines.push(`  });`);
+        } else {
+          lines.push(
+            `  await opensteer.scroll({ selector: ${JSON.stringify(requireSelector(action))}, direction: ${JSON.stringify(direction)}, amount: ${String(amount)} });`
+          );
+        }
+        break;
+      }
+      case "select-option":
+        lines.push(
+          `  await selectOption(${pageVar}, ${JSON.stringify(requireSelector(action))}, ${JSON.stringify(action.detail.value)});`
+        );
+        break;
+      case "new-tab": {
+        const openerPageVar = action.detail.openerPageId;
+        const shouldUseWaitForPage = shouldUsePopupWait(options.actions, index, openerPageVar);
+        const creationLine = shouldUseWaitForPage && openerPageVar !== void 0 ? `  const ${pageVar} = (await opensteer.waitForPage({ openerPageRef: ${openerPageVar}, timeoutMs: 30_000 })).pageRef;` : `  const ${pageVar} = (await opensteer.newPage({${renderNewPageArguments(action.detail.openerPageId, action.detail.initialUrl)}})).pageRef;`;
+        lines.push(creationLine);
+        lines.push(`  activePageRef = ${pageVar};`);
+        declaredPages.add(pageVar);
+        break;
+      }
+      case "close-tab":
+        lines.push(`  await opensteer.closePage({ pageRef: ${pageVar} });`);
+        lines.push(`  if (activePageRef === ${pageVar}) {`);
+        lines.push(`    activePageRef = undefined;`);
+        lines.push(`  }`);
+        break;
+      case "switch-tab":
+        lines.push(`  await ensureActive(${pageVar});`);
+        break;
+      case "go-back":
+        lines.push(`  await runHistoryAction(${pageVar}, "back");`);
+        break;
+      case "go-forward":
+        lines.push(`  await runHistoryAction(${pageVar}, "forward");`);
+        break;
+      case "reload":
+        lines.push(`  await runHistoryAction(${pageVar}, "reload");`);
+        break;
+    }
+  }
+  lines.push(`} finally {`);
+  lines.push(`  await opensteer.close();`);
+  lines.push(`}`);
+  lines.push(``);
+  return `${lines.join("\n")}
+`;
+}
+function collectPageIds(actions) {
+  const orderedIds = /* @__PURE__ */ new Set(["page0"]);
+  for (const action of actions) {
+    orderedIds.add(action.pageId);
+    if (action.kind === "new-tab" && action.detail.openerPageId !== void 0) {
+      orderedIds.add(action.detail.openerPageId);
+    }
+    if (action.kind === "switch-tab" && action.detail.fromPageId !== void 0) {
+      orderedIds.add(action.detail.fromPageId);
+    }
+    if (action.kind === "switch-tab") {
+      orderedIds.add(action.detail.toPageId);
+    }
+  }
+  return [...orderedIds].sort(comparePageIds);
+}
+function comparePageIds(left, right) {
+  const leftMatch = /^page(\d+)$/u.exec(left);
+  const rightMatch = /^page(\d+)$/u.exec(right);
+  if (leftMatch && rightMatch) {
+    return Number(leftMatch[1]) - Number(rightMatch[1]);
+  }
+  return left.localeCompare(right);
+}
+function requireSelector(action) {
+  if (action.selector === void 0) {
+    throw new Error(`Action "${action.kind}" on ${action.pageId} is missing a selector.`);
+  }
+  return action.selector;
+}
+function normalizeScrollAction(action) {
+  const horizontal = Math.abs(action.detail.deltaX);
+  const vertical = Math.abs(action.detail.deltaY);
+  if (vertical >= horizontal) {
+    return {
+      direction: action.detail.deltaY < 0 ? "up" : "down",
+      amount: Math.max(1, Math.round(vertical)),
+      isWindowScroll: action.selector === void 0
+    };
+  }
+  return {
+    direction: action.detail.deltaX < 0 ? "left" : "right",
+    amount: Math.max(1, Math.round(horizontal)),
+    isWindowScroll: action.selector === void 0
+  };
+}
+function shouldUsePopupWait(actions, newTabIndex, openerPageId) {
+  if (openerPageId === void 0 || newTabIndex === 0) {
+    return false;
+  }
+  const previousAction = actions[newTabIndex - 1];
+  if (previousAction === void 0 || previousAction.pageId !== openerPageId) {
+    return false;
+  }
+  return previousAction.kind === "click" || previousAction.kind === "dblclick" || previousAction.kind === "keypress";
+}
+function renderNewPageArguments(openerPageId, initialUrl) {
+  const argumentsList = [];
+  if (openerPageId !== void 0) {
+    argumentsList.push(` openerPageRef: ${openerPageId}`);
+  }
+  if (initialUrl.length > 0 && initialUrl !== "about:blank") {
+    argumentsList.push(` url: ${JSON.stringify(initialUrl)}`);
+  }
+  if (argumentsList.length === 0) {
+    return ``;
+  }
+  return ` ${argumentsList.join(",")}`.trimStart();
+}
+
+// src/sdk/runtime.ts
+var OpensteerRuntime = class extends OpensteerSessionRuntime {
+  constructor(options = {}) {
+    const publicWorkspace = normalizeWorkspace2(options.workspace);
+    const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path7.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", randomUUID()) : resolveFilesystemWorkspacePath({
+      rootDir: path7.resolve(options.rootDir ?? process.cwd()),
+      workspace: publicWorkspace
+    }));
+    const cleanupRootOnClose = options.cleanupRootOnClose ?? publicWorkspace === void 0;
+    const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
+    assertSupportedEngineOptions({
+      engineName,
+      ...options.browser === void 0 ? {} : { browser: options.browser },
+      ...options.context === void 0 ? {} : { context: options.context }
+    });
+    super(
+      buildSharedRuntimeOptions({
+        name: publicWorkspace ?? "default",
+        rootPath,
+        ...publicWorkspace === void 0 ? {} : { workspaceName: publicWorkspace },
+        ...options.browser === void 0 ? {} : { browser: options.browser },
+        ...options.launch === void 0 ? {} : { launch: options.launch },
+        ...options.context === void 0 ? {} : { context: options.context },
+        engineName,
+        ...options.engine === void 0 ? {} : { engine: options.engine },
+        ...options.engineFactory === void 0 ? {} : { engineFactory: options.engineFactory },
+        ...options.policy === void 0 ? {} : { policy: options.policy },
+        ...options.descriptorStore === void 0 ? {} : { descriptorStore: options.descriptorStore },
+        ...options.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: options.extractionDescriptorStore },
+        ...options.registryOverrides === void 0 ? {} : { registryOverrides: options.registryOverrides },
+        cleanupRootOnClose,
+        ...options.observability === void 0 ? {} : { observability: options.observability },
+        ...options.observationSessionId === void 0 ? {} : { observationSessionId: options.observationSessionId },
+        ...options.observationSink === void 0 ? {} : { observationSink: options.observationSink }
+      })
+    );
+  }
+};
+var OpensteerSessionRuntime2 = class extends OpensteerSessionRuntime {
+  constructor(options) {
+    const rootPath = options.rootPath ?? path7.resolve(options.rootDir ?? process.cwd());
+    const cleanupRootOnClose = options.cleanupRootOnClose ?? false;
+    const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
+    assertSupportedEngineOptions({
+      engineName,
+      ...options.browser === void 0 ? {} : { browser: options.browser },
+      ...options.context === void 0 ? {} : { context: options.context }
+    });
+    super(
+      buildSharedRuntimeOptions({
+        name: options.name,
+        rootPath,
+        ...options.browser === void 0 ? {} : { browser: options.browser },
+        ...options.launch === void 0 ? {} : { launch: options.launch },
+        ...options.context === void 0 ? {} : { context: options.context },
+        engineName,
+        ...options.engine === void 0 ? {} : { engine: options.engine },
+        ...options.engineFactory === void 0 ? {} : { engineFactory: options.engineFactory },
+        ...options.policy === void 0 ? {} : { policy: options.policy },
+        ...options.descriptorStore === void 0 ? {} : { descriptorStore: options.descriptorStore },
+        ...options.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: options.extractionDescriptorStore },
+        ...options.registryOverrides === void 0 ? {} : { registryOverrides: options.registryOverrides },
+        cleanupRootOnClose,
+        ...options.observability === void 0 ? {} : { observability: options.observability },
+        ...options.observationSessionId === void 0 ? {} : { observationSessionId: options.observationSessionId },
+        ...options.observationSink === void 0 ? {} : { observationSink: options.observationSink }
+      })
+    );
+  }
+};
+function buildSharedRuntimeOptions(input) {
+  const ownership = resolveOwnership(input.browser);
+  const engineFactory = input.engineFactory ?? ((factoryOptions) => new OpensteerBrowserManager({
+    rootPath: input.rootPath,
+    ...input.workspaceName === void 0 ? {} : { workspace: input.workspaceName },
+    engineName: input.engineName,
+    ...(factoryOptions.browser ?? input.browser) === void 0 ? {} : { browser: factoryOptions.browser ?? input.browser },
+    ...(factoryOptions.launch ?? input.launch) === void 0 ? {} : { launch: factoryOptions.launch ?? input.launch },
+    ...(factoryOptions.context ?? input.context) === void 0 ? {} : { context: factoryOptions.context ?? input.context }
+  }).createEngine());
+  return {
+    name: input.name,
+    ...input.workspaceName === void 0 ? {} : { workspaceName: input.workspaceName },
+    rootPath: input.rootPath,
+    ...input.engine === void 0 ? {} : { engine: input.engine },
+    ...input.engine === void 0 ? { engineFactory } : {},
+    ...input.policy === void 0 ? {} : { policy: input.policy },
+    ...input.descriptorStore === void 0 ? {} : { descriptorStore: input.descriptorStore },
+    ...input.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: input.extractionDescriptorStore },
+    ...input.registryOverrides === void 0 ? {} : { registryOverrides: input.registryOverrides },
+    cleanupRootOnClose: input.cleanupRootOnClose,
+    ...input.observability === void 0 ? {} : { observability: input.observability },
+    ...input.observationSessionId === void 0 ? {} : { observationSessionId: input.observationSessionId },
+    ...input.observationSink === void 0 ? {} : { observationSink: input.observationSink },
+    sessionInfo: {
+      provider: {
+        mode: "local",
+        ownership,
+        engine: input.engineName
+      },
+      ...input.workspaceName === void 0 ? {} : { workspace: input.workspaceName },
+      reconnectable: !input.cleanupRootOnClose
+    }
+  };
+}
+function normalizeWorkspace2(workspace) {
+  if (workspace === void 0) {
+    return void 0;
+  }
+  const trimmed = workspace.trim();
+  return trimmed.length === 0 ? void 0 : trimmed;
+}
+function resolveOwnership(browser) {
+  return typeof browser === "object" && browser.mode === "attach" ? "attached" : "owned";
+}
+
+// src/provider/config.ts
+var OPENSTEER_PROVIDER_MODES = ["local", "cloud"];
+function assertProviderSupportsEngine(provider, engine) {
+  if (engine !== "abp") {
+    return;
+  }
+  if (provider === "cloud") {
+    throw new Error(
+      "ABP is not supported for provider=cloud. Cloud provider currently requires Playwright."
+    );
+  }
+}
+function normalizeOpensteerProviderMode(value, source = "OPENSTEER_PROVIDER") {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === OPENSTEER_PROVIDER_MODES[0] || normalized === OPENSTEER_PROVIDER_MODES[1]) {
+    return normalized;
+  }
+  throw new Error(
+    `${source} must be one of ${OPENSTEER_PROVIDER_MODES.join(", ")}; received "${value}".`
+  );
+}
+function resolveOpensteerProvider(input = {}) {
+  if (input.provider) {
+    return {
+      mode: input.provider.mode,
+      source: "explicit"
+    };
+  }
+  if (input.environmentProvider !== void 0 && input.environmentProvider.trim().length > 0) {
+    return {
+      mode: normalizeOpensteerProviderMode(input.environmentProvider),
+      source: "env"
+    };
+  }
+  return {
+    mode: "local",
+    source: "default"
+  };
+}
+var execFile2 = promisify(execFile);
+var NODE_SQLITE_SPECIFIER2 = `node:${"sqlite"}`;
+var CHROME_EPOCH_OFFSET = 11644473600000000n;
+var CHROME_HMAC_PREFIX_LENGTH = 32;
+async function readBrowserCookies(input = {}) {
+  const brand2 = resolveRequestedBrand(input);
+  const userDataDir = resolveBrandUserDataDir(brand2, input.userDataDir);
+  const profileDirectory = input.profileDirectory ?? "Default";
+  const cookiesPath = join(userDataDir, profileDirectory, "Cookies");
+  if (!existsSync(cookiesPath)) {
+    throw new Error(
+      `Cookies database not found at "${cookiesPath}". Verify the browser brand, user-data-dir, and profile-directory are correct.`
+    );
+  }
+  const tempDir = await mkdtemp(join(tmpdir(), "opensteer-cookies-"));
+  try {
+    await copyCookiesDatabase(cookiesPath, tempDir);
+    const decryptionKey = await resolveDecryptionKey(brand2.id, userDataDir);
+    const rows = queryAllCookies(join(tempDir, "Cookies"));
+    const cookies = decryptCookieRows(rows, decryptionKey);
+    return {
+      cookies,
+      brandId: brand2.id,
+      brandDisplayName: brand2.displayName,
+      userDataDir,
+      profileDirectory
+    };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+function resolveRequestedBrand(input) {
+  if (input.brandId !== void 0) {
+    return getBrowserBrand(input.brandId);
+  }
+  const installed = detectInstalledBrowserBrands()[0];
   if (!installed) {
     throw new Error(
       "No Chromium browser found. Install a supported browser or pass brandId explicitly."
@@ -32515,11 +34147,25 @@ function queryAllCookies(dbPath) {
        FROM cookies`
     );
     stmt.setReadBigInts(true);
-    return stmt.all();
+    return stmt.all().map(toRawCookieRow);
   } finally {
     database.close();
   }
 }
+function toRawCookieRow(row) {
+  return {
+    host_key: row.host_key,
+    name: row.name,
+    value: row.value,
+    encrypted_value: row.encrypted_value,
+    path: row.path,
+    expires_utc: row.expires_utc,
+    is_secure: row.is_secure,
+    is_httponly: row.is_httponly,
+    samesite: row.samesite,
+    is_persistent: row.is_persistent
+  };
+}
 async function resolveDecryptionKey(brandId, userDataDir) {
   if (process.platform === "darwin") {
     const password = await resolveKeychainPassword(brandId);
@@ -32870,7 +34516,11 @@ var OpensteerCloudClient = class {
         ...input.browser === void 0 ? {} : { browser: input.browser },
         ...input.context === void 0 ? {} : { context: input.context },
         ...input.browserProfile === void 0 ? {} : { browserProfile: input.browserProfile },
-        ...input.observability === void 0 ? {} : { observability: input.observability }
+        ...input.observability === void 0 ? {} : { observability: input.observability },
+        ...input.sourceType === void 0 ? {} : { sourceType: input.sourceType },
+        ...input.sourceRef === void 0 ? {} : { sourceRef: input.sourceRef },
+        ...input.localWorkspaceRootPath === void 0 ? {} : { localWorkspaceRootPath: input.localWorkspaceRootPath },
+        ...input.locality === void 0 ? {} : { locality: input.locality }
       }
     });
     return await response.json();
@@ -33042,12 +34692,12 @@ var OpensteerCloudClient = class {
           `Unexpected cloud session status "${String(session.status)}" while waiting for close.`
         );
       }
-      await delay(CLOUD_CLOSE_POLL_INTERVAL_MS);
+      await delay2(CLOUD_CLOSE_POLL_INTERVAL_MS);
     }
     throw new Error(`Timed out waiting for cloud session ${sessionId} to close.`);
   }
 };
-function delay(ms) {
+function delay2(ms) {
   return new Promise((resolve4) => {
     setTimeout(resolve4, ms);
   });
@@ -33107,6 +34757,9 @@ var OpensteerSemanticRestClient = class {
     this.connection = connection;
   }
   async invoke(operation, input) {
+    return this.invokeInternal(operation, input, false);
+  }
+  async invokeInternal(operation, input, hasRetried) {
     const endpoint = opensteerSemanticRestEndpoints.find((entry) => entry.name === operation);
     if (!endpoint) {
       throw new Error(`unsupported semantic operation ${operation}`);
@@ -33116,7 +34769,7 @@ var OpensteerSemanticRestClient = class {
     });
     let response;
     try {
-      response = await fetch(`${this.connection.baseUrl}${endpoint.path}`, {
+      response = await fetch(`${await this.connection.getBaseUrl()}${endpoint.path}`, {
         method: "POST",
         headers: {
           authorization: await this.connection.getAuthorizationHeader(),
@@ -33138,6 +34791,9 @@ var OpensteerSemanticRestClient = class {
       }
       return envelope.data;
     } catch (error) {
+      if (!hasRetried && this.connection.handleError && await this.connection.handleError(error, { operation })) {
+        return this.invokeInternal(operation, input, true);
+      }
       if (operation === "session.close" && isFetchFailure(error)) {
         return { closed: true };
       }
@@ -33271,7 +34927,10 @@ var OpensteerCloudAutomationClient = class {
   }
   async connect() {
     const grant = await this.issueGrant("automation");
-    const wsUrl = new URL(grant.wsUrl);
+    if (grant.transport !== "ws") {
+      throw new Error(`cloud issued an invalid ${grant.kind} grant transport`);
+    }
+    const wsUrl = new URL(grant.url);
     wsUrl.searchParams.set("token", grant.token);
     const socket = new WebSocket2(wsUrl);
     this.socket = socket;
@@ -33636,7 +35295,7 @@ var CloudSessionProxy = class {
   cloud;
   observability;
   sessionId;
-  sessionBaseUrl;
+  semanticGrant;
   client;
   automation;
   workspaceStore;
@@ -33687,7 +35346,7 @@ var CloudSessionProxy = class {
       reconnectable: this.workspace !== void 0 || this.sessionId !== void 0 || persisted !== void 0,
       capabilities: {
         semanticOperations: opensteerSemanticOperationNames,
-        sessionGrants: ["automation", "view", "cdp"],
+        sessionGrants: ["semantic", "automation", "view", "cdp"],
         instrumentation: {
           route: true,
           interceptScript: true,
@@ -33929,13 +35588,12 @@ var CloudSessionProxy = class {
     return this.requireClient().invoke("computer.execute", input);
   }
   async close() {
-    const session = await this.loadPersistedSession() ?? (this.sessionId === void 0 || this.sessionBaseUrl === void 0 ? void 0 : {
+    const session = await this.loadPersistedSession() ?? (this.sessionId === void 0 ? void 0 : {
       layout: "opensteer-session",
       version: 1,
       provider: "cloud",
       ...this.workspace === void 0 ? {} : { workspace: this.workspace },
       sessionId: this.sessionId,
-      baseUrl: this.sessionBaseUrl,
       startedAt: Date.now(),
       updatedAt: Date.now()
     });
@@ -33954,7 +35612,7 @@ var CloudSessionProxy = class {
       this.automation = void 0;
       this.client = void 0;
       this.sessionId = void 0;
-      this.sessionBaseUrl = void 0;
+      this.semanticGrant = void 0;
       if (this.cleanupRootOnClose) {
         await rm(this.rootPath, { recursive: true, force: true }).catch(() => void 0);
       }
@@ -33970,39 +35628,56 @@ var CloudSessionProxy = class {
     await this.automation?.close().catch(() => void 0);
     this.automation = void 0;
     this.sessionId = void 0;
-    this.sessionBaseUrl = void 0;
+    this.semanticGrant = void 0;
   }
   async ensureSession(input = {}) {
     if (this.client) {
       return;
     }
     assertSupportedCloudBrowserMode(input.browser);
+    const localCloud = this.shouldUseLocalCloudTransport();
+    const browserProfile = resolveCloudBrowserProfile(this.cloud, input);
     const persisted = await this.loadPersistedSession();
     if (persisted !== void 0 && await this.isReusableCloudSession(persisted.sessionId)) {
-      await this.syncRegistryToCloud();
+      if (localCloud) {
+        void this.syncRegistryToCloud();
+      } else {
+        await this.syncRegistryToCloud();
+      }
       this.bindClient(persisted);
       return;
     }
-    await this.syncRegistryToCloud();
-    const session = await this.cloud.createSession({
+    if (localCloud) {
+      void this.syncRegistryToCloud();
+    } else {
+      await this.syncRegistryToCloud();
+    }
+    const baseCreateInput = {
       ...this.workspace === void 0 ? {} : { name: this.workspace },
       ...input.launch === void 0 ? {} : { browser: input.launch },
       ...input.context === void 0 ? {} : { context: input.context },
       ...this.observability === void 0 ? {} : { observability: this.observability },
-      ...resolveCloudBrowserProfile(this.cloud, input) === void 0 ? {} : { browserProfile: resolveCloudBrowserProfile(this.cloud, input) }
-    });
+      ...browserProfile === void 0 ? {} : { browserProfile }
+    };
+    const createInput = localCloud && this.workspace !== void 0 ? {
+      ...baseCreateInput,
+      sourceType: "local-cloud",
+      sourceRef: this.workspace,
+      localWorkspaceRootPath: this.rootPath,
+      locality: "auto"
+    } : baseCreateInput;
+    const session = await this.cloud.createSession(createInput);
     const record = {
       layout: "opensteer-session",
       version: 1,
       provider: "cloud",
       ...this.workspace === void 0 ? {} : { workspace: this.workspace },
       sessionId: session.sessionId,
-      baseUrl: session.baseUrl,
       startedAt: Date.now(),
       updatedAt: Date.now()
     };
     await this.writePersistedSession(record);
-    this.bindClient(record);
+    this.bindClient(record, session.initialGrants?.semantic);
   }
   async syncRegistryToCloud() {
     if (this.workspace === void 0) {
@@ -34011,15 +35686,16 @@ var CloudSessionProxy = class {
     try {
       const workspaceStore = await this.ensureWorkspaceStore();
       await syncLocalRegistryToCloud(this.cloud, this.workspace, workspaceStore);
-    } catch (error) {
+    } catch {
     }
   }
-  bindClient(record) {
+  bindClient(record, initialSemanticGrant) {
     this.sessionId = record.sessionId;
-    this.sessionBaseUrl = record.baseUrl;
+    this.semanticGrant = initialSemanticGrant?.kind === "semantic" ? initialSemanticGrant : void 0;
     this.client = new OpensteerSemanticRestClient({
-      baseUrl: record.baseUrl,
-      getAuthorizationHeader: async () => this.cloud.buildAuthorizationHeader()
+      getBaseUrl: async () => (await this.ensureSemanticGrant()).url,
+      getAuthorizationHeader: async () => `Bearer ${(await this.ensureSemanticGrant()).token}`,
+      handleError: (error) => this.handleSemanticClientError(error)
     });
     this.automation = new OpensteerCloudAutomationClient(this.cloud, record.sessionId);
   }
@@ -34068,6 +35744,43 @@ var CloudSessionProxy = class {
     }
     return this.automation;
   }
+  async ensureSemanticGrant(forceRefresh = false) {
+    if (!forceRefresh && this.semanticGrant?.kind === "semantic" && this.semanticGrant.expiresAt > Date.now() + 1e4) {
+      return this.semanticGrant;
+    }
+    if (!this.sessionId) {
+      throw new Error("Cloud session has not been initialized.");
+    }
+    const issued = await this.cloud.issueAccess(this.sessionId, ["semantic"]);
+    const grant = issued.grants.semantic;
+    if (!grant || grant.transport !== "http") {
+      throw new Error("cloud did not issue a valid semantic grant");
+    }
+    this.semanticGrant = grant;
+    return grant;
+  }
+  async handleSemanticClientError(error) {
+    if (!(error instanceof OpensteerSemanticRestError)) {
+      return false;
+    }
+    if (error.statusCode !== 401 && error.statusCode !== 404) {
+      return false;
+    }
+    this.semanticGrant = void 0;
+    try {
+      await this.ensureSemanticGrant(true);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  shouldUseLocalCloudTransport() {
+    if (this.workspace === void 0) {
+      return false;
+    }
+    const config = this.cloud.getConfig();
+    return isLoopbackBaseUrl(config.baseUrl);
+  }
 };
 function resolveCloudBrowserProfile(cloud, input) {
   return input.browserProfile ?? cloud.getConfig().browserProfile;
@@ -34083,8 +35796,29 @@ function assertSupportedCloudBrowserMode(browser) {
 function isMissingCloudSessionError(error) {
   return error instanceof Error && /\b404\b/.test(error.message);
 }
+function isLoopbackBaseUrl(baseUrl) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    return false;
+  }
+  return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1" || url.hostname === "[::1]";
+}
 
 // src/sdk/runtime-resolution.ts
+var LOCAL_ONLY_RUNTIME_OPTION_KEYS = [
+  "launch",
+  "context",
+  "engine",
+  "engineFactory",
+  "policy",
+  "descriptorStore",
+  "extractionDescriptorStore",
+  "registryOverrides",
+  "observationSessionId",
+  "observationSink"
+];
 function resolveOpensteerRuntimeConfig(input = {}) {
   const environment = input.environment ?? process.env;
   const provider = resolveOpensteerProvider({
@@ -34109,8 +35843,15 @@ function createOpensteerSemanticRuntime(input = {}) {
     ...input.provider === void 0 ? {} : { provider: input.provider },
     ...input.environment === void 0 ? {} : { environment: input.environment }
   });
-  assertProviderSupportsEngine(config.provider.mode, engine);
-  if (config.provider.mode === "cloud") {
+  const localOnlyRuntimeOptions = listLocalOnlyRuntimeOptions(runtimeOptions);
+  const providerMode = config.provider.mode === "cloud" && config.provider.source !== "explicit" && localOnlyRuntimeOptions.length > 0 ? "local" : config.provider.mode;
+  if (config.provider.mode === "cloud" && config.provider.source === "explicit" && localOnlyRuntimeOptions.length > 0) {
+    throw new Error(
+      `provider=cloud does not support local runtime options: ${localOnlyRuntimeOptions.join(", ")}.`
+    );
+  }
+  assertProviderSupportsEngine(providerMode, engine);
+  if (providerMode === "cloud") {
     return new CloudSessionProxy(new OpensteerCloudClient(config.cloud), {
       ...runtimeOptions.rootDir === void 0 ? {} : { rootDir: runtimeOptions.rootDir },
       ...runtimeOptions.rootPath === void 0 ? {} : { rootPath: runtimeOptions.rootPath },
@@ -34124,6 +35865,9 @@ function createOpensteerSemanticRuntime(input = {}) {
     engineName: engine
   });
 }
+function listLocalOnlyRuntimeOptions(runtimeOptions) {
+  return LOCAL_ONLY_RUNTIME_OPTION_KEYS.filter((key) => runtimeOptions[key] !== void 0);
+}
 var ENV_FILENAMES = [".env", ".env.local"];
 var OPENSTEER_ENV_PREFIX = "OPENSTEER_";
 var opensteerEnvironmentCache = /* @__PURE__ */ new Map();
@@ -34227,6 +35971,6 @@ function isOpensteerEnvironmentKey(key) {
   return key.startsWith(OPENSTEER_ENV_PREFIX);
 }
 
-export { CloudSessionProxy, DEFAULT_OPENSTEER_ENGINE, DEFERRED_MATCH_ATTR_KEYS, ElementPathError, MATCH_ATTRIBUTE_PRIORITY, OPENSTEER_DOM_ACTION_BRIDGE_SYMBOL, OPENSTEER_ENGINE_NAMES, OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT, OPENSTEER_FILESYSTEM_WORKSPACE_VERSION, OpensteerAttachAmbiguousError, OpensteerBrowserManager, OpensteerCloudClient, OpensteerRuntime, OpensteerSessionRuntime2 as OpensteerSessionRuntime, STABLE_PRIMARY_ATTR_KEYS, assertProviderSupportsEngine, buildArrayFieldPathCandidates, buildDomDescriptorKey, buildDomDescriptorPayload, buildDomDescriptorVersion, buildPathCandidates, buildPathSelectorHint, buildSegmentSelector, clearPersistedSessionRecord, cloneElementPath, cloneReplayElementPath, cloneStructuralElementAnchor, createArtifactStore, createDomRuntime, createFilesystemOpensteerWorkspace, createObservationStore, createOpensteerExtractionDescriptorStore, createOpensteerSemanticRuntime, defaultFallbackPolicy, defaultPolicy, defaultRetryPolicy, defaultSettlePolicy, defaultTimeoutPolicy, delayWithSignal, discoverLocalCdpBrowsers, dispatchSemanticOperation, hashDomDescriptorDescription, inspectCdpEndpoint, isCurrentUrlField, isProcessRunning, isValidCssAttributeKey, listLocalChromeProfiles, loadEnvironment, manifestToExternalBinaryLocation, normalizeExtractedValue, normalizeObservabilityConfig, normalizeOpensteerEngineName, normalizeOpensteerProviderMode, normalizeWorkspaceId, parseDomDescriptorRecord, parseExtractionDescriptorRecord, pathExists, readPersistedCloudSessionRecord, readPersistedLocalBrowserSessionRecord, readPersistedSessionRecord, resolveCloudConfig, resolveCloudSessionRecordPath, resolveDomActionBridge, resolveExtractedValueInContext, resolveFilesystemWorkspacePath, resolveLiveSessionRecordPath, resolveLocalSessionRecordPath, resolveOpensteerEngineName, resolveOpensteerEnvironment, resolveOpensteerProvider, resolveOpensteerRuntimeConfig, runWithPolicyTimeout, sanitizeElementPath, sanitizeReplayElementPath, sanitizeStructuralElementAnchor, settleWithPolicy, shouldKeepAttributeForPath, writePersistedSessionRecord };
-//# sourceMappingURL=chunk-RO6WAWWG.js.map
-//# sourceMappingURL=chunk-RO6WAWWG.js.map
+export { CloudSessionProxy, DEFAULT_OPENSTEER_ENGINE, DEFERRED_MATCH_ATTR_KEYS, ElementPathError, FlowRecorderCollector, MATCH_ATTRIBUTE_PRIORITY, OPENSTEER_DOM_ACTION_BRIDGE_SYMBOL, OPENSTEER_ENGINE_NAMES, OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT, OPENSTEER_FILESYSTEM_WORKSPACE_VERSION, OpensteerAttachAmbiguousError, OpensteerBrowserManager, OpensteerCloudClient, OpensteerRuntime, OpensteerSessionRuntime2 as OpensteerSessionRuntime, STABLE_PRIMARY_ATTR_KEYS, assertProviderSupportsEngine, buildArrayFieldPathCandidates, buildDomDescriptorKey, buildDomDescriptorPayload, buildDomDescriptorVersion, buildPathCandidates, buildPathSelectorHint, buildSegmentSelector, clearPersistedSessionRecord, cloneElementPath, cloneReplayElementPath, cloneStructuralElementAnchor, createArtifactStore, createDomDescriptorStore, createDomRuntime, createFilesystemOpensteerWorkspace, createObservationStore, createOpensteerExtractionDescriptorStore, createOpensteerSemanticRuntime, defaultFallbackPolicy, defaultPolicy, defaultRetryPolicy, defaultSettlePolicy, defaultTimeoutPolicy, delayWithSignal, discoverLocalCdpBrowsers, dispatchSemanticOperation, generateReplayScript, hashDomDescriptorDescription, inspectCdpEndpoint, isCurrentUrlField, isProcessRunning, isValidCssAttributeKey, listLocalChromeProfiles, loadEnvironment, manifestToExternalBinaryLocation, normalizeExtractedValue, normalizeObservabilityConfig, normalizeOpensteerEngineName, normalizeOpensteerProviderMode, normalizeWorkspaceId, parseDomDescriptorRecord, parseExtractionDescriptorRecord, pathExists, readPersistedCloudSessionRecord, readPersistedLocalBrowserSessionRecord, readPersistedSessionRecord, resolveCloudConfig, resolveCloudSessionRecordPath, resolveDomActionBridge, resolveExtractedValueInContext, resolveFilesystemWorkspacePath, resolveLiveSessionRecordPath, resolveLocalSessionRecordPath, resolveOpensteerEngineName, resolveOpensteerEnvironment, resolveOpensteerProvider, resolveOpensteerRuntimeConfig, runWithPolicyTimeout, sanitizeElementPath, sanitizeReplayElementPath, sanitizeStructuralElementAnchor, settleWithPolicy, shouldKeepAttributeForPath, writePersistedSessionRecord };
+//# sourceMappingURL=chunk-F3X6UOEN.js.map
+//# sourceMappingURL=chunk-F3X6UOEN.js.map