opensteer 0.8.9 → 0.8.11

package/dist/{chunk-RO6WAWWG.js → chunk-33FDEOQY.js}

@@ -1560,6 +1560,9 @@ function isBrowserCoreError(value) {
 // ../browser-core/src/cdp-visual-stability.ts
 var DEFAULT_VISUAL_STABILITY_SETTLE_MS = 750;
 
+// ../browser-core/src/post-load-tracker.ts
+var DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS = 400;
+
 // ../protocol/src/identity.ts
 var refPrefixes = [
   "session",
@@ -6749,9 +6752,23 @@ var opensteerInspectStorageInputSchema = objectSchema(
     title: "OpensteerInspectStorageInput"
   }
 );
+var opensteerComputerMouseButtonSchema = enumSchema(["left", "middle", "right"], {
+  title: "OpensteerComputerMouseButton"
+});
+var opensteerComputerKeyModifierSchema = enumSchema(
+  ["Shift", "Control", "Alt", "Meta"],
+  {
+    title: "OpensteerComputerKeyModifier"
+  }
+);
 var opensteerDomClickInputSchema = objectSchema(
   {
     target: opensteerTargetInputSchema,
+    button: opensteerComputerMouseButtonSchema,
+    clickCount: integerSchema({ minimum: 1 }),
+    modifiers: arraySchema(opensteerComputerKeyModifierSchema, {
+      uniqueItems: true
+    }),
     persistAsDescription: stringSchema(),
     captureNetwork: stringSchema({ minLength: 1 })
   },
@@ -6851,18 +6868,6 @@ var opensteerSessionCloseOutputSchema = objectSchema(
     required: ["closed"]
   }
 );
-var opensteerComputerMouseButtonSchema = enumSchema(
-  ["left", "middle", "right"],
-  {
-    title: "OpensteerComputerMouseButton"
-  }
-);
-var opensteerComputerKeyModifierSchema = enumSchema(
-  ["Shift", "Control", "Alt", "Meta"],
-  {
-    title: "OpensteerComputerKeyModifier"
-  }
-);
 var opensteerComputerAnnotationSchema = enumSchema(opensteerComputerAnnotationNames, {
   title: "OpensteerComputerAnnotation"
 });
@@ -9053,6 +9058,7 @@ var NAVIGATION_VISUAL_STABILITY_PROFILE = {
   scope: "visible-frames",
   timeoutMs: 7e3
 };
+var NAVIGATION_POST_LOAD_CAPTURE_WINDOW_MS = 1e3;
 var defaultDomActionSettleObserver = {
   async settle(input) {
     if (input.trigger !== "dom-action") {
@@ -9088,6 +9094,13 @@ var defaultNavigationSettleObserver = {
       return false;
     }
     try {
+      await input.engine.waitForPostLoadQuiet({
+        pageRef: input.pageRef,
+        timeoutMs: effectiveTimeout,
+        quietMs: DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS,
+        captureWindowMs: Math.min(NAVIGATION_POST_LOAD_CAPTURE_WINDOW_MS, effectiveTimeout),
+        signal: input.signal
+      });
       await input.engine.waitForVisualStability({
         pageRef: input.pageRef,
         timeoutMs: effectiveTimeout,
@@ -10799,15 +10812,7 @@ var MemoryDomDescriptorStore = class {
 // ../runtime-core/src/action-boundary.ts
 var actionBoundaryDiagnosticsBySignal = /* @__PURE__ */ new WeakMap();
 async function captureActionBoundarySnapshot(engine, pageRef) {
-  const frames = await engine.listFrames({ pageRef });
-  const mainFrame = frames.find((frame) => frame.isMainFrame);
-  if (!mainFrame) {
-    throw new Error(`page ${pageRef} does not expose a main frame`);
-  }
-  return {
-    pageRef,
-    documentRef: mainFrame.documentRef
-  };
+  return engine.getActionBoundarySnapshot({ pageRef });
 }
 function createActionBoundaryDiagnostics(input) {
   return {
@@ -14749,7 +14754,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 +22413,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 +22438,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 +22947,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 {
@@ -23605,6 +23611,9 @@ var OpensteerSessionRuntime = class {
         const result = await this.requireDom().click({
           pageRef,
           target,
+          ...input.button === void 0 ? {} : { button: input.button },
+          ...input.clickCount === void 0 ? {} : { clickCount: input.clickCount },
+          ...input.modifiers === void 0 ? {} : { modifiers: input.modifiers },
           timeout
         });
         return {
@@ -29081,6 +29090,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 +29269,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,6 +32329,1770 @@ function screenshotMediaType(format2) {
   }
 }
 
+// ../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])
+);
+function createFlowRecorderInstallScript(options = {}) {
+  const normalizedOptions = {
+    showStopButton: options.showStopButton ?? true
+  };
+  return String.raw`(() => {
+  const TOP_LEVEL_ONLY = (() => {
+    try {
+      return window.top === window.self;
+    } catch {
+      return false;
+    }
+  })();
+  if (!TOP_LEVEL_ONLY) {
+    return;
+  }
+
+  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 options = ${JSON.stringify(normalizedOptions)};
+
+  const previous = globalScope[recorderKey];
+  if (previous && typeof previous.dispose === "function") {
+    previous.dispose();
+  }
+
+  const queue = [];
+  const cleanup = [];
+  const inputFlushTimers = new Map();
+  const pendingInputs = new Map();
+  let historyStateCache = undefined;
+  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 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;
+  }
+
+  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 escapeAttributeValue(value) {
+    return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+
+  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)) + " ";
+    });
+  }
+
+  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(" ");
+  }
+
+  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;
+  }
+
+  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 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) + '"]';
+  }
+
+  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 createDefaultHistoryState(currentUrl) {
+    return {
+      entries: [currentUrl],
+      index: 0,
+    };
+  }
+
+  function normalizeHistoryState(state) {
+    if (
+      !state ||
+      !Array.isArray(state.entries) ||
+      !state.entries.every((entry) => typeof entry === "string") ||
+      !Number.isInteger(state.index)
+    ) {
+      return undefined;
+    }
+    const entries = state.entries.slice();
+    if (entries.length === 0) {
+      return createDefaultHistoryState(location.href);
+    }
+    return {
+      entries,
+      index: Math.min(entries.length - 1, Math.max(0, state.index)),
+    };
+  }
+
+  function writeHistoryState(state) {
+    const normalized = normalizeHistoryState(state) ?? createDefaultHistoryState(location.href);
+    historyStateCache = normalized;
+    try {
+      sessionStorage.setItem(historyStateKey, JSON.stringify(normalized));
+    } catch {}
+    return normalized;
+  }
+
+  function applyHistoryState(state, mode, nextUrl) {
+    const current = normalizeHistoryState(state) ?? createDefaultHistoryState(location.href);
+    const nextState = {
+      entries: current.entries.slice(),
+      index: current.index,
+    };
+    if (mode === "replace") {
+      nextState.entries[nextState.index] = nextUrl;
+    } else if (mode === "push") {
+      nextState.entries = nextState.entries.slice(0, nextState.index + 1);
+      nextState.entries.push(nextUrl);
+      nextState.index = nextState.entries.length - 1;
+    } else if (mode === "back") {
+      nextState.index = Math.max(0, nextState.index - 1);
+    } else if (mode === "forward") {
+      nextState.index = Math.min(nextState.entries.length - 1, nextState.index + 1);
+    }
+    return nextState;
+  }
+
+  function updateHistoryState(mode, nextUrl) {
+    return writeHistoryState(applyHistoryState(readHistoryState(), mode, nextUrl));
+  }
+
+  function readHistoryState() {
+    const cached = normalizeHistoryState(historyStateCache);
+    if (cached) {
+      historyStateCache = cached;
+      return cached;
+    }
+    try {
+      const raw = sessionStorage.getItem(historyStateKey);
+      const parsed = normalizeHistoryState(raw ? JSON.parse(raw) : undefined);
+      if (parsed) {
+        historyStateCache = parsed;
+        return parsed;
+      }
+    } catch {}
+    return undefined;
+  }
+
+  function classifyHistoryTraversal(currentUrl) {
+    const state = readHistoryState();
+    if (!state) {
+      return undefined;
+    }
+    if (state.entries[state.index] === currentUrl) {
+      return undefined;
+    }
+    if (state.entries[state.index - 1] === currentUrl) {
+      writeHistoryState({
+        entries: state.entries,
+        index: state.index - 1,
+      });
+      return "go-back";
+    }
+    if (state.entries[state.index + 1] === currentUrl) {
+      writeHistoryState({
+        entries: state.entries,
+        index: state.index + 1,
+      });
+      return "go-forward";
+    }
+    const existingIndex = state.entries.lastIndexOf(currentUrl);
+    if (existingIndex !== -1 && existingIndex !== state.index) {
+      writeHistoryState({
+        entries: state.entries,
+        index: existingIndex,
+      });
+      return existingIndex < state.index ? "go-back" : "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;",
+      "}",
+    ].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;
+    }
+    const state = readHistoryState();
+    if (state?.entries[state.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];
+    },
+  };
+
+  if (options.showStopButton) {
+    ensureStopButtonMounted();
+  }
+  onInstall();
+})();`;
+}
+var FLOW_RECORDER_INSTALL_SCRIPT = createFlowRecorderInstallScript();
+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;
+  installScript;
+  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;
+    this.installScript = options.installScript ?? FLOW_RECORDER_INSTALL_SCRIPT;
+  }
+  async install() {
+    await this.runtime.addInitScript({
+      script: this.installScript
+    });
+    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: this.installScript,
+          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();
+  }
+  getPages() {
+    return [...this.pages.values()].map((page) => ({
+      pageId: page.pageId,
+      pageRef: page.pageRef,
+      ...page.openerPageRef === void 0 ? {} : { openerPageRef: page.openerPageRef },
+      ...page.openerPageId === void 0 ? {} : { openerPageId: page.openerPageId },
+      currentUrl: page.currentUrl
+    })).sort((left, right) => comparePageIds(left.pageId, right.pageId));
+  }
+  getFocusedPageId() {
+    return this.focusedPageId;
+  }
+  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 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 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 replayTarget = resolveReplayTarget(options);
+  const initialPages = orderInitialPages(resolveInitialPages(options));
+  const activeInitialPageId = resolveActiveInitialPageId(options, initialPages);
+  const initialPageId = initialPages[0]?.pageId ?? "page0";
+  const lines = [
+    `import { Opensteer } from "opensteer";`,
+    ``,
+    ...renderOpensteerBootstrap(replayTarget),
+    ``,
+    `const ${initialPageId} = (await opensteer.open(${JSON.stringify(initialPages[0]?.initialUrl ?? "")})).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 (const page of initialPages.slice(1)) {
+    const openerPageId = page.openerPageId !== void 0 && declaredPages.has(page.openerPageId) ? page.openerPageId : void 0;
+    lines.push(
+      `  const ${page.pageId} = (await opensteer.newPage(${renderNewPageInput(openerPageId, page.initialUrl)})).pageRef;`
+    );
+    lines.push(`  activePageRef = ${page.pageId};`);
+    declaredPages.add(page.pageId);
+  }
+  if (activeInitialPageId !== void 0 && activeInitialPageId !== initialPageId) {
+    lines.push(`  await ensureActive(${activeInitialPageId});`);
+  }
+  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))}, clickCount: 2 });`
+        );
+        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(${renderNewPageInput(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 resolveReplayTarget(options) {
+  if (options.replayTarget !== void 0) {
+    return options.replayTarget;
+  }
+  if (options.workspace !== void 0) {
+    return {
+      kind: "local",
+      workspace: options.workspace
+    };
+  }
+  throw new Error("Replay codegen requires either replayTarget or workspace.");
+}
+function resolveInitialPages(options) {
+  if (options.initialPages !== void 0 && options.initialPages.length > 0) {
+    const unique = /* @__PURE__ */ new Set();
+    return options.initialPages.map((page) => {
+      if (unique.has(page.pageId)) {
+        throw new Error(`Duplicate initial page id "${page.pageId}" in recording bootstrap.`);
+      }
+      unique.add(page.pageId);
+      return page;
+    });
+  }
+  const startUrl = options.startUrl;
+  if (startUrl === void 0) {
+    throw new Error("Replay codegen requires startUrl when initialPages is not provided.");
+  }
+  return [
+    {
+      pageId: "page0",
+      initialUrl: startUrl
+    }
+  ];
+}
+function resolveActiveInitialPageId(options, initialPages) {
+  if (options.activePageId !== void 0) {
+    return options.activePageId;
+  }
+  return initialPages[0]?.pageId;
+}
+function renderOpensteerBootstrap(replayTarget) {
+  if (replayTarget.kind === "local") {
+    return [
+      `const opensteer = new Opensteer({`,
+      `  workspace: ${JSON.stringify(replayTarget.workspace)},`,
+      `  browser: "persistent",`,
+      `});`
+    ];
+  }
+  return [
+    renderRequireEnvHelper(replayTarget),
+    ``,
+    `const opensteer = new Opensteer({`,
+    `  provider: {`,
+    `    mode: "cloud",`,
+    `    baseUrl: requireEnv(${JSON.stringify(replayTarget.baseUrlEnvVar ?? "OPENSTEER_BASE_URL")}),`,
+    `    apiKey: requireEnv(${JSON.stringify(replayTarget.apiKeyEnvVar ?? "OPENSTEER_API_KEY")}),`,
+    ...renderCloudBrowserProfile(replayTarget),
+    `  },`,
+    `});`
+  ];
+}
+function renderRequireEnvHelper(replayTarget) {
+  const baseUrlEnvVar = replayTarget.baseUrlEnvVar ?? "OPENSTEER_BASE_URL";
+  const apiKeyEnvVar = replayTarget.apiKeyEnvVar ?? "OPENSTEER_API_KEY";
+  return [
+    `function requireEnv(name: string): string {`,
+    `  const value = process.env[name];`,
+    `  if (typeof value === "string" && value.trim().length > 0) {`,
+    `    return value;`,
+    `  }`,
+    `  throw new Error(\`Missing environment variable \${name}. Set ${baseUrlEnvVar} and ${apiKeyEnvVar} before replaying this recording.\`);`,
+    `}`
+  ].join("\n");
+}
+function renderCloudBrowserProfile(replayTarget) {
+  if (replayTarget.browserProfileId === void 0) {
+    return [];
+  }
+  return [
+    `    browserProfile: {`,
+    `      profileId: ${JSON.stringify(replayTarget.browserProfileId)},`,
+    ...replayTarget.reuseBrowserProfileIfActive ? [`      reuseIfActive: true,`] : [],
+    `    },`
+  ];
+}
+function orderInitialPages(initialPages) {
+  const ordered = [];
+  const declared = /* @__PURE__ */ new Set();
+  const remaining = [...initialPages];
+  while (remaining.length > 0) {
+    let advanced = false;
+    for (let index = 0; index < remaining.length; index += 1) {
+      const page = remaining[index];
+      if (page.openerPageId !== void 0 && !declared.has(page.openerPageId)) {
+        continue;
+      }
+      ordered.push(page);
+      declared.add(page.pageId);
+      remaining.splice(index, 1);
+      advanced = true;
+      break;
+    }
+    if (!advanced) {
+      ordered.push(...remaining.splice(0, remaining.length));
+    }
+  }
+  return ordered;
+}
+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 renderNewPageInput(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(", ")} }`;
+}
+
 // src/sdk/runtime.ts
 var OpensteerRuntime = class extends OpensteerSessionRuntime {
   constructor(options = {}) {
@@ -32515,11 +34317,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 +34686,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();
@@ -32896,6 +34716,30 @@ var OpensteerCloudClient = class {
     });
     return await response.json();
   }
+  async getSessionRecording(sessionId) {
+    const response = await this.request(`/v1/sessions/${encodeURIComponent(sessionId)}/recording`, {
+      method: "GET"
+    });
+    return await response.json();
+  }
+  async startSessionRecording(sessionId) {
+    const response = await this.request(
+      `/v1/sessions/${encodeURIComponent(sessionId)}/recording/start`,
+      {
+        method: "POST"
+      }
+    );
+    return await response.json();
+  }
+  async stopSessionRecording(sessionId) {
+    const response = await this.request(
+      `/v1/sessions/${encodeURIComponent(sessionId)}/recording/stop`,
+      {
+        method: "POST"
+      }
+    );
+    return await response.json();
+  }
   async closeSession(sessionId) {
     const response = await this.request(`/v1/sessions/${encodeURIComponent(sessionId)}`, {
       method: "DELETE"
@@ -33042,12 +34886,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);
   });
@@ -33086,9 +34930,11 @@ function resolveCloudConfig(input = {}) {
   if (!baseUrl || baseUrl.trim().length === 0) {
     throw new Error("provider=cloud requires OPENSTEER_BASE_URL or provider.baseUrl.");
   }
+  const appBaseUrl = cloudProvider?.appBaseUrl ?? input.environment?.OPENSTEER_CLOUD_APP_BASE_URL;
   return {
     apiKey: apiKey.trim(),
     baseUrl: baseUrl.trim().replace(/\/+$/, ""),
+    ...appBaseUrl === void 0 || appBaseUrl.trim().length === 0 ? {} : { appBaseUrl: appBaseUrl.trim().replace(/\/+$/, "") },
     ...cloudProvider?.browserProfile === void 0 ? {} : { browserProfile: cloudProvider.browserProfile }
   };
 }
@@ -33107,6 +34953,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 +34965,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 +34987,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 +35123,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 +35491,7 @@ var CloudSessionProxy = class {
   cloud;
   observability;
   sessionId;
-  sessionBaseUrl;
+  semanticGrant;
   client;
   automation;
   workspaceStore;
@@ -33687,7 +35542,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 +35784,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 +35808,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 +35824,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 +35882,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 +35940,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,6 +35992,15 @@ 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
 function resolveOpensteerRuntimeConfig(input = {}) {
@@ -34227,6 +36145,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-33FDEOQY.js.map
+//# sourceMappingURL=chunk-33FDEOQY.js.map