opensteer 0.8.9 → 0.8.11

package/dist/cli/bin.cjs

@@ -59,7 +59,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // package.json
 var package_default = {
-  version: "0.8.8"};
+  version: "0.8.10"};
 util.promisify(child_process.execFile);
 Math.floor(Date.now() - process.uptime() * 1e3);
 ({ ...process.env});
@@ -690,8 +690,8 @@ function buildBrowserWebSocketUrl(httpUrl, webSocketPath) {
   const protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
   return `${protocol}//${httpUrl.host}${normalizeWebSocketPath(webSocketPath)}`;
 }
-function normalizeWebSocketPath(path17) {
-  return path17.startsWith("/") ? path17 : `/${path17}`;
+function normalizeWebSocketPath(path18) {
+  return path18.startsWith("/") ? path18 : `/${path18}`;
 }
 function rewriteBrowserWebSocketHost(browserWsUrl, requestedUrl) {
   try {
@@ -1305,30 +1305,30 @@ function isPlainObject(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function canonicalizeJsonValue(value, path17) {
+function canonicalizeJsonValue(value, path18) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) {
-      throw new TypeError(`${path17} must be a finite JSON number`);
+      throw new TypeError(`${path18} must be a finite JSON number`);
     }
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path17}[${index}]`));
+    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path18}[${index}]`));
   }
   if (!isPlainObject(value)) {
-    throw new TypeError(`${path17} must be a plain JSON object`);
+    throw new TypeError(`${path18} must be a plain JSON object`);
   }
   const sorted = Object.keys(value).sort((left, right) => left.localeCompare(right));
   const result = {};
   for (const key of sorted) {
     const entry = value[key];
     if (entry === void 0) {
-      throw new TypeError(`${path17}.${key} must not be undefined`);
+      throw new TypeError(`${path18}.${key} must not be undefined`);
     }
-    result[key] = canonicalizeJsonValue(entry, `${path17}.${key}`);
+    result[key] = canonicalizeJsonValue(entry, `${path18}.${key}`);
   }
   return result;
 }
@@ -1825,31 +1825,31 @@ function oneOfSchema(members, options = {}) {
 }
 
 // ../protocol/src/validation.ts
-function validateJsonSchema(schema, value, path17 = "$") {
-  return validateSchemaNode(schema, value, path17);
+function validateJsonSchema(schema, value, path18 = "$") {
+  return validateSchemaNode(schema, value, path18);
 }
-function validateSchemaNode(schema, value, path17) {
+function validateSchemaNode(schema, value, path18) {
   const issues = [];
   if ("const" in schema && !isJsonValueEqual(schema.const, value)) {
     issues.push({
-      path: path17,
+      path: path18,
       message: `must equal ${JSON.stringify(schema.const)}`
     });
     return issues;
   }
   if (schema.enum !== void 0 && !schema.enum.some((candidate) => isJsonValueEqual(candidate, value))) {
     issues.push({
-      path: path17,
+      path: path18,
       message: `must be one of ${schema.enum.map((candidate) => JSON.stringify(candidate)).join(", ")}`
     });
     return issues;
   }
   if (schema.oneOf !== void 0) {
-    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path17));
+    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path18));
     const validBranches = branchIssues.filter((current) => current.length === 0).length;
     if (validBranches !== 1) {
       issues.push({
-        path: path17,
+        path: path18,
         message: validBranches === 0 ? "must match exactly one supported shape" : "matches multiple supported shapes"
       });
       return issues;
@@ -1857,11 +1857,11 @@ function validateSchemaNode(schema, value, path17) {
   }
   if (schema.anyOf !== void 0) {
     const hasMatch = schema.anyOf.some(
-      (member) => validateSchemaNode(member, value, path17).length === 0
+      (member) => validateSchemaNode(member, value, path18).length === 0
     );
     if (!hasMatch) {
       issues.push({
-        path: path17,
+        path: path18,
         message: "must match at least one supported shape"
       });
       return issues;
@@ -1869,7 +1869,7 @@ function validateSchemaNode(schema, value, path17) {
   }
   if (schema.allOf !== void 0) {
     for (const member of schema.allOf) {
-      issues.push(...validateSchemaNode(member, value, path17));
+      issues.push(...validateSchemaNode(member, value, path18));
     }
     if (issues.length > 0) {
       return issues;
@@ -1877,7 +1877,7 @@ function validateSchemaNode(schema, value, path17) {
   }
   if (schema.type !== void 0 && !matchesSchemaType(schema.type, value)) {
     issues.push({
-      path: path17,
+      path: path18,
       message: `must be ${describeSchemaType(schema.type)}`
     });
     return issues;
@@ -1885,19 +1885,19 @@ function validateSchemaNode(schema, value, path17) {
   if (typeof value === "string") {
     if (schema.minLength !== void 0 && value.length < schema.minLength) {
       issues.push({
-        path: path17,
+        path: path18,
         message: `must have length >= ${String(schema.minLength)}`
       });
     }
     if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
       issues.push({
-        path: path17,
+        path: path18,
         message: `must have length <= ${String(schema.maxLength)}`
       });
     }
     if (schema.pattern !== void 0 && !new RegExp(schema.pattern).test(value)) {
       issues.push({
-        path: path17,
+        path: path18,
         message: `must match pattern ${schema.pattern}`
       });
     }
@@ -1906,25 +1906,25 @@ function validateSchemaNode(schema, value, path17) {
   if (typeof value === "number") {
     if (schema.minimum !== void 0 && value < schema.minimum) {
       issues.push({
-        path: path17,
+        path: path18,
         message: `must be >= ${String(schema.minimum)}`
       });
     }
     if (schema.maximum !== void 0 && value > schema.maximum) {
       issues.push({
-        path: path17,
+        path: path18,
         message: `must be <= ${String(schema.maximum)}`
       });
     }
     if (schema.exclusiveMinimum !== void 0 && value <= schema.exclusiveMinimum) {
       issues.push({
-        path: path17,
+        path: path18,
         message: `must be > ${String(schema.exclusiveMinimum)}`
       });
     }
     if (schema.exclusiveMaximum !== void 0 && value >= schema.exclusiveMaximum) {
       issues.push({
-        path: path17,
+        path: path18,
         message: `must be < ${String(schema.exclusiveMaximum)}`
       });
     }
@@ -1933,13 +1933,13 @@ function validateSchemaNode(schema, value, path17) {
   if (Array.isArray(value)) {
     if (schema.minItems !== void 0 && value.length < schema.minItems) {
       issues.push({
-        path: path17,
+        path: path18,
         message: `must have at least ${String(schema.minItems)} items`
       });
     }
     if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
       issues.push({
-        path: path17,
+        path: path18,
         message: `must have at most ${String(schema.maxItems)} items`
       });
     }
@@ -1949,7 +1949,7 @@ function validateSchemaNode(schema, value, path17) {
         const key = JSON.stringify(item);
         if (seen.has(key)) {
           issues.push({
-            path: path17,
+            path: path18,
             message: "must not contain duplicate items"
           });
           break;
@@ -1959,7 +1959,7 @@ function validateSchemaNode(schema, value, path17) {
     }
     if (schema.items !== void 0) {
       for (let index = 0; index < value.length; index += 1) {
-        issues.push(...validateSchemaNode(schema.items, value[index], `${path17}[${String(index)}]`));
+        issues.push(...validateSchemaNode(schema.items, value[index], `${path18}[${String(index)}]`));
       }
     }
     return issues;
@@ -1969,7 +1969,7 @@ function validateSchemaNode(schema, value, path17) {
     for (const requiredKey of schema.required ?? []) {
       if (!(requiredKey in value)) {
         issues.push({
-          path: joinObjectPath(path17, requiredKey),
+          path: joinObjectPath(path18, requiredKey),
           message: "is required"
         });
       }
@@ -1978,13 +1978,13 @@ function validateSchemaNode(schema, value, path17) {
       const propertySchema = properties[key];
       if (propertySchema !== void 0) {
         issues.push(
-          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path17, key))
+          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path18, key))
         );
         continue;
       }
       if (schema.additionalProperties === false) {
         issues.push({
-          path: joinObjectPath(path17, key),
+          path: joinObjectPath(path18, key),
           message: "is not allowed"
         });
         continue;
@@ -1994,7 +1994,7 @@ function validateSchemaNode(schema, value, path17) {
           ...validateSchemaNode(
             schema.additionalProperties,
             propertyValue,
-            joinObjectPath(path17, key)
+            joinObjectPath(path18, key)
           )
         );
       }
@@ -2238,8 +2238,8 @@ function matchesNetworkRecordFilters(record, filters) {
     }
   }
   if (filters.path !== void 0) {
-    const path17 = getParsedUrl().pathname;
-    if (!includesCaseInsensitive(path17, filters.path)) {
+    const path18 = getParsedUrl().pathname;
+    if (!includesCaseInsensitive(path18, filters.path)) {
       return false;
     }
   }
@@ -2283,6 +2283,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",
@@ -7472,9 +7475,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 })
   },
@@ -7574,18 +7591,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"
 });
@@ -10299,7 +10304,7 @@ async function clearPersistedSessionRecord(rootPath, provider) {
   await promises.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;
@@ -11727,11 +11732,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);
@@ -11975,14 +11994,14 @@ function toPortableBrowserProfileCookieRecord(cookie) {
   if (!name || !domain) {
     return null;
   }
-  const path17 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
+  const path18 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
   const expiresAt = typeof cookie.expires === "number" && Number.isFinite(cookie.expires) && cookie.expires > 0 ? Math.floor(cookie.expires * 1e3) : null;
   const sameSite = normalizeSameSite(cookie.sameSite);
   return {
     name,
     value: cookie.value,
     domain,
-    path: path17,
+    path: path18,
     secure: cookie.secure,
     httpOnly: cookie.httpOnly,
     ...sameSite === void 0 ? {} : { sameSite },
@@ -12082,7 +12101,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();
@@ -12108,6 +12131,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"
@@ -12298,9 +12345,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 }
   };
 }
@@ -12315,15 +12364,7 @@ var OPENSTEER_RUNTIME_CORE_VERSION = package_default2.version;
 // ../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 {
@@ -12440,6 +12481,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") {
@@ -12475,6 +12517,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,
@@ -13017,9 +13066,9 @@ var IFRAME_URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "poster",
   "ping"
 ]);
-function buildArrayFieldPathCandidates(path17) {
-  const strict = path17.nodes.length ? buildPathCandidates(path17.nodes) : [];
-  const relaxedNodes = stripPositionClauses(path17.nodes);
+function buildArrayFieldPathCandidates(path18) {
+  const strict = path18.nodes.length ? buildPathCandidates(path18.nodes) : [];
+  const relaxedNodes = stripPositionClauses(path18.nodes);
   const relaxed = relaxedNodes.length ? buildPathCandidates(relaxedNodes) : [];
   return dedupeSelectors([...strict, ...relaxed]);
 }
@@ -13546,8 +13595,8 @@ function cloneStructuralElementAnchor(anchor) {
     nodes: anchor.nodes.map(clonePathNode)
   };
 }
-function buildPathSelectorHint(path17) {
-  const nodes = path17?.nodes || [];
+function buildPathSelectorHint(path18) {
+  const nodes = path18?.nodes || [];
   const last = nodes[nodes.length - 1];
   if (!last) {
     return "*";
@@ -13596,15 +13645,15 @@ function sanitizeStructuralElementAnchor(anchor) {
     nodes: sanitizeNodes(anchor.nodes)
   };
 }
-function sanitizeReplayElementPath(path17) {
+function sanitizeReplayElementPath(path18) {
   return {
     resolution: "deterministic",
-    context: sanitizeContext(path17.context),
-    nodes: sanitizeNodes(path17.nodes)
+    context: sanitizeContext(path18.context),
+    nodes: sanitizeNodes(path18.nodes)
   };
 }
-function sanitizeElementPath(path17) {
-  return sanitizeReplayElementPath(path17);
+function sanitizeElementPath(path18) {
+  return sanitizeReplayElementPath(path18);
 }
 function buildLocalStructuralElementAnchor(index, rawTargetNode) {
   const targetNode = requireElementNode(index, rawTargetNode);
@@ -13727,8 +13776,8 @@ function buildTargetNotFoundMessage(domPath, diagnostics) {
   }
   return `${base} Target depth ${String(depth)}. Candidate counts: ${sample}.`;
 }
-function buildArrayFieldCandidates(path17) {
-  return buildArrayFieldPathCandidates(path17);
+function buildArrayFieldCandidates(path18) {
+  return buildArrayFieldPathCandidates(path18);
 }
 function firstDefinedAttribute(node, keys) {
   for (const key of keys) {
@@ -15205,21 +15254,21 @@ var DefaultDomRuntime = class {
     return match;
   }
   async resolvePathTarget(session, pageRef, rawPath, source, description, descriptor) {
-    const path17 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path17.context);
-    const target = resolveDomPathInScope(context.index, path17.nodes, context.scope);
+    const path18 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path18.context);
+    const target = resolveDomPathInScope(context.index, path18.nodes, context.scope);
     if (!target) {
-      throwTargetNotFound(context.index, path17.nodes, context.scope);
+      throwTargetNotFound(context.index, path18.nodes, context.scope);
     }
     if (target.node.nodeRef === void 0) {
       throw new Error(
-        `resolved path "${buildPathSelectorHint(path17)}" does not point to a live element`
+        `resolved path "${buildPathSelectorHint(path18)}" does not point to a live element`
       );
     }
     const anchor = await this.buildAnchorFromSnapshotNode(session, context.snapshot, target.node);
     return this.createResolvedTarget(source, context.snapshot, target.node, anchor, {
       ...description === void 0 ? {} : { description },
-      replayPath: path17,
+      replayPath: path18,
       ...source === "path" || source === "descriptor" ? { selectorUsed: target.selector } : {},
       ...descriptor === void 0 ? {} : { descriptor }
     });
@@ -15240,9 +15289,9 @@ var DefaultDomRuntime = class {
     });
   }
   async queryAllByElementPath(session, pageRef, rawPath) {
-    const path17 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path17.context);
-    return queryAllDomPathInScope(context.index, path17.nodes, context.scope).filter(
+    const path18 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path18.context);
+    return queryAllDomPathInScope(context.index, path18.nodes, context.scope).filter(
       (node) => node.nodeRef !== void 0
     ).map((node) => this.createSnapshotTarget(context.snapshot, node));
   }
@@ -15428,16 +15477,16 @@ var DefaultDomRuntime = class {
     const index = createSnapshotIndex(item.snapshot);
     return this.resolveFirstArrayFieldTargetInNode(index, item.node, field.path);
   }
-  resolveFirstArrayFieldTargetInNode(index, rootNode, path17) {
-    const normalizedPath = sanitizeElementPath(path17);
+  resolveFirstArrayFieldTargetInNode(index, rootNode, path18) {
+    const normalizedPath = sanitizeElementPath(path18);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
     }
     return resolveFirstWithinNodeBySelectors(index, rootNode, selectors);
   }
-  resolveUniqueArrayFieldTargetInNode(index, rootNode, path17) {
-    const normalizedPath = sanitizeElementPath(path17);
+  resolveUniqueArrayFieldTargetInNode(index, rootNode, path18) {
+    const normalizedPath = sanitizeElementPath(path18);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
@@ -16813,7 +16862,7 @@ function diffStringMap(prefix, left, right, includeUnchanged, output) {
     diffScalarField(`${prefix}.${key}`, left[key], right[key], includeUnchanged, output);
   }
 }
-function diffScalarField(path17, left, right, includeUnchanged, output) {
+function diffScalarField(path18, left, right, includeUnchanged, output) {
   const leftValue = stringifyFieldValue(left);
   const rightValue = stringifyFieldValue(right);
   const kind = leftValue === void 0 ? rightValue === void 0 ? "unchanged" : "added" : rightValue === void 0 ? "removed" : leftValue === rightValue ? "unchanged" : "changed";
@@ -16821,7 +16870,7 @@ function diffScalarField(path17, left, right, includeUnchanged, output) {
     return;
   }
   output.push({
-    path: path17,
+    path: path18,
     kind,
     ...leftValue === void 0 ? {} : { leftValue },
     ...rightValue === void 0 ? {} : { rightValue },
@@ -17827,9 +17876,9 @@ function matchReverseTargetHints(channel, codec, targetHints) {
       matches.add(`host:${host}`);
     }
   }
-  for (const path17 of targetHints.paths ?? []) {
-    if (url.pathname.includes(path17)) {
-      matches.add(`path:${path17}`);
+  for (const path18 of targetHints.paths ?? []) {
+    if (url.pathname.includes(path18)) {
+      matches.add(`path:${path18}`);
     }
   }
   for (const operationName of targetHints.operationNames ?? []) {
@@ -19665,8 +19714,8 @@ function encodeDataPath(tokens) {
   }
   return out;
 }
-function parseDataPath(path17) {
-  const input = path17.trim();
+function parseDataPath(path18) {
+  const input = path18.trim();
   if (input.length === 0) {
     return [];
   }
@@ -19716,8 +19765,8 @@ function parseDataPath(path17) {
 function inflateDataPathObject(flat) {
   let root = {};
   let initialized = false;
-  for (const [path17, value] of Object.entries(flat)) {
-    const tokens = parseDataPath(path17);
+  for (const [path18, value] of Object.entries(flat)) {
+    const tokens = parseDataPath(path18);
     if (!tokens || tokens.length === 0) {
       continue;
     }
@@ -20049,8 +20098,8 @@ function buildVariantDescriptorFromCluster(descriptors) {
     fields: mergedFields
   };
 }
-function minimizePathMatchClauses(path17, mode) {
-  const normalized = sanitizeElementPath(path17);
+function minimizePathMatchClauses(path18, mode) {
+  const normalized = sanitizeElementPath(path18);
   const nodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = node.attrs || {};
@@ -20154,8 +20203,8 @@ function seedMinimalAttrClause(attrs) {
   }
   return null;
 }
-function relaxPathForSingleSample(path17, mode) {
-  const normalized = sanitizeElementPath(path17);
+function relaxPathForSingleSample(path18, mode) {
+  const normalized = sanitizeElementPath(path18);
   const relaxedNodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = normalizeAttrsForSingleSample(node.attrs || {});
@@ -20240,8 +20289,8 @@ function shouldKeepAttrForSingleSample(key) {
   }
   return true;
 }
-function buildPathStructureKey(path17) {
-  const normalized = sanitizeElementPath(path17);
+function buildPathStructureKey(path18) {
+  const normalized = sanitizeElementPath(path18);
   return canonicalJsonString({
     context: (normalized.context || []).map((hop) => ({
       kind: hop.kind,
@@ -20368,30 +20417,30 @@ function buildArrayItemNode(fields) {
   }
   return node;
 }
-function insertNodeAtPath(root, path17, node) {
-  const tokens = parseDataPath(path17);
+function insertNodeAtPath(root, path18, node) {
+  const tokens = parseDataPath(path18);
   if (!tokens || !tokens.length) {
     throw new Error(
-      `Invalid persisted extraction path "${path17}": expected a non-empty object path.`
+      `Invalid persisted extraction path "${path18}": expected a non-empty object path.`
     );
   }
   if (tokens.some((token) => token.kind === "index")) {
     throw new Error(
-      `Invalid persisted extraction path "${path17}": nested array indices are not supported in cached descriptors.`
+      `Invalid persisted extraction path "${path18}": nested array indices are not supported in cached descriptors.`
     );
   }
   let current = root;
   for (let index = 0; index < tokens.length; index += 1) {
     const token = tokens[index];
     if (!token || token.kind !== "prop") {
-      throw new Error(`Invalid persisted extraction path "${path17}": expected object segment.`);
+      throw new Error(`Invalid persisted extraction path "${path18}": expected object segment.`);
     }
     const isLast = index === tokens.length - 1;
     if (isLast) {
       const existing = current[token.key];
       if (existing) {
         throw new Error(
-          `Conflicting persisted extraction path "${path17}" detected while building descriptor tree.`
+          `Conflicting persisted extraction path "${path18}" detected while building descriptor tree.`
         );
       }
       current[token.key] = node;
@@ -20406,7 +20455,7 @@ function insertNodeAtPath(root, path17, node) {
     }
     if (!isPersistedObjectNode(next)) {
       throw new Error(
-        `Conflicting persisted extraction path "${path17}" detected at "${token.key}".`
+        `Conflicting persisted extraction path "${path18}" detected at "${token.key}".`
       );
     }
     current = next;
@@ -20441,7 +20490,7 @@ function buildItemRootForArrayIndex(entries) {
   }
   const paths = entries.map(
     (entry) => isPersistablePathField(entry.source) ? sanitizeElementPath(entry.source.path) : null
-  ).filter((path17) => path17 !== null);
+  ).filter((path18) => path18 !== null);
   if (!paths.length) {
     return null;
   }
@@ -20462,7 +20511,7 @@ function getCommonPathPrefixLength(paths) {
   if (!paths.length) {
     return 0;
   }
-  const nodeChains = paths.map((path17) => path17.nodes);
+  const nodeChains = paths.map((path18) => path18.nodes);
   const minLength = Math.min(...nodeChains.map((nodes) => nodes.length));
   if (!Number.isFinite(minLength) || minLength <= 0) {
     return 0;
@@ -20531,30 +20580,30 @@ function mergeElementPathsByMajority(paths) {
   if (!paths.length) {
     return null;
   }
-  const normalized = paths.map((path17) => sanitizeElementPath(path17));
+  const normalized = paths.map((path18) => sanitizeElementPath(path18));
   const contextKey = pickModeString(
-    normalized.map((path17) => canonicalJsonString(path17.context)),
+    normalized.map((path18) => canonicalJsonString(path18.context)),
     1
   );
   if (!contextKey) {
     return null;
   }
-  const sameContext = normalized.filter((path17) => canonicalJsonString(path17.context) === contextKey);
+  const sameContext = normalized.filter((path18) => canonicalJsonString(path18.context) === contextKey);
   if (!sameContext.length) {
     return null;
   }
   const targetLength = pickModeNumber(
-    sameContext.map((path17) => path17.nodes.length),
+    sameContext.map((path18) => path18.nodes.length),
     1
   ) ?? sameContext[0]?.nodes.length ?? 0;
-  const aligned = sameContext.filter((path17) => path17.nodes.length === targetLength);
+  const aligned = sameContext.filter((path18) => path18.nodes.length === targetLength);
   if (!aligned.length) {
     return null;
   }
   const threshold = majorityThreshold(aligned.length);
   const nodes = [];
   for (let index = 0; index < targetLength; index += 1) {
-    const nodesAtIndex = aligned.map((path17) => path17.nodes[index]).filter((node) => node !== void 0);
+    const nodesAtIndex = aligned.map((path18) => path18.nodes[index]).filter((node) => node !== void 0);
     if (!nodesAtIndex.length) {
       return null;
     }
@@ -20800,8 +20849,8 @@ function clonePathContext(context) {
 function clonePathNodes(nodes) {
   return JSON.parse(JSON.stringify(nodes || []));
 }
-function cloneElementPath2(path17) {
-  return JSON.parse(JSON.stringify(path17));
+function cloneElementPath2(path18) {
+  return JSON.parse(JSON.stringify(path18));
 }
 function clonePersistedOpensteerExtractionNode(node) {
   return JSON.parse(JSON.stringify(node));
@@ -21119,8 +21168,8 @@ function collectPersistedValueNodeRefs(node) {
     return [
       {
         path: sanitizeElementPath(node.$path),
-        replacePath: (path17) => {
-          node.$path = sanitizeElementPath(path17);
+        replacePath: (path18) => {
+          node.$path = sanitizeElementPath(path18);
         }
       }
     ];
@@ -21134,13 +21183,13 @@ function collectPersistedValueNodeRefs(node) {
   }
   return refs;
 }
-function hasPositionClause(path17) {
-  return path17.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
+function hasPositionClause(path18) {
+  return path18.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
 }
-function stripPositionClauses2(path17) {
+function stripPositionClauses2(path18) {
   return sanitizeElementPath({
-    context: path17.context,
-    nodes: path17.nodes.map((node) => ({
+    context: path18.context,
+    nodes: path18.nodes.map((node) => ({
       ...node,
       match: node.match.filter((clause) => clause.kind !== "position")
     }))
@@ -21550,8 +21599,8 @@ function normalizeNonEmptyString2(name, value) {
 function normalizeKey(value) {
   return String(value ?? "").trim();
 }
-function labelForPath(path17) {
-  return path17.trim().length === 0 ? "$" : path17;
+function labelForPath(path18) {
+  return path18.trim().length === 0 ? "$" : path18;
 }
 function sha256Hex3(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
@@ -23255,11 +23304,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, delay4 = 0, ...args) {
+    return this.registerTimer(false, callback, delay4, args);
   }
-  setInterval(callback, delay2 = 0, ...args) {
-    return this.registerTimer(true, callback, delay2, args);
+  setInterval(callback, delay4 = 0, ...args) {
+    return this.registerTimer(true, callback, delay4, args);
   }
   clearTimeout(timerId) {
     this.clearTimer(timerId);
@@ -23280,9 +23329,9 @@ var SandboxClock = class {
       this.clearTimer(timerId);
     }
   }
-  registerTimer(repeat, callback, delay2, args) {
+  registerTimer(repeat, callback, delay4, args) {
     const timerId = this.nextTimerId++;
-    const normalizedDelay = Math.max(0, delay2);
+    const normalizedDelay = Math.max(0, delay4);
     const record = {
       callback,
       args,
@@ -23789,6 +23838,7 @@ function diffInteractionTraces(left, right) {
 // ../runtime-core/src/sdk/runtime.ts
 var requireForAuthRecipeHook = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href)));
 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 {
@@ -24452,6 +24502,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 {
@@ -29928,6 +29981,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") {
@@ -30084,6 +30160,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;
@@ -31439,12 +31521,12 @@ function extractReverseRuntimeValue(value, pointer) {
   }
   return readDotPath(value, pointer);
 }
-function readDotPath(value, path17) {
-  if (path17.length === 0) {
+function readDotPath(value, path18) {
+  if (path18.length === 0) {
     return value;
   }
   let current = value;
-  for (const segment of path17.split(".").filter((entry) => entry.length > 0)) {
+  for (const segment of path18.split(".").filter((entry) => entry.length > 0)) {
     if (current === null || current === void 0) {
       return void 0;
     }
@@ -31917,7 +31999,7 @@ function parseSetCookieHeader(value, requestUrl) {
   }
   const url = new URL(requestUrl);
   let domain = url.hostname;
-  let path17 = defaultCookiePath(url.pathname);
+  let path18 = defaultCookiePath(url.pathname);
   let secure = url.protocol === "https:";
   let expiresAt;
   const cookieValue = rawValueParts.join("=").trim();
@@ -31930,7 +32012,7 @@ function parseSetCookieHeader(value, requestUrl) {
       continue;
     }
     if (key === "path" && attributeValue.length > 0) {
-      path17 = attributeValue;
+      path18 = attributeValue;
       continue;
     }
     if (key === "secure") {
@@ -31956,7 +32038,7 @@ function parseSetCookieHeader(value, requestUrl) {
       name,
       value: cookieValue,
       domain,
-      path: path17,
+      path: path18,
       secure,
       ...expiresAt === void 0 ? {} : { expiresAt }
     }
@@ -33137,6 +33219,1770 @@ function screenshotMediaType(format2) {
       return "image/webp";
   }
 }
+
+// ../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 delay2(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 delay2(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(", ")} }`;
+}
 var OpensteerSemanticRestError = class extends Error {
   opensteerError;
   statusCode;
@@ -33152,6 +34998,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}`);
@@ -33161,7 +35010,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(),
@@ -33183,6 +35032,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 };
       }
@@ -33316,7 +35168,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__default.default(wsUrl);
     this.socket = socket;
@@ -33681,7 +35536,7 @@ var CloudSessionProxy = class {
   cloud;
   observability;
   sessionId;
-  sessionBaseUrl;
+  semanticGrant;
   client;
   automation;
   workspaceStore;
@@ -33732,7 +35587,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,
@@ -33974,13 +35829,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()
     });
@@ -33999,7 +35853,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 promises.rm(this.rootPath, { recursive: true, force: true }).catch(() => void 0);
       }
@@ -34015,39 +35869,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) {
@@ -34056,15 +35927,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);
   }
@@ -34113,6 +35985,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;
@@ -34128,6 +36037,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]";
+}
 var OpensteerRuntime = class extends OpensteerSessionRuntime {
   constructor(options = {}) {
     const publicWorkspace = normalizeWorkspace2(options.workspace);
@@ -34360,9 +36278,11 @@ async function describeCloudLane(input) {
     status: "connected",
     current: input.current,
     summary: input.record.sessionId,
-    detail: input.record.baseUrl,
     sessionId: input.record.sessionId,
-    baseUrl: input.record.baseUrl
+    ...input.cloudConfig === void 0 ? {} : {
+      detail: input.cloudConfig.baseUrl,
+      baseUrl: input.cloudConfig.baseUrl
+    }
   };
   if (input.cloudConfig === void 0) {
     return base;
@@ -34406,6 +36326,214 @@ function formatLaneRow(input) {
   const summary = input.summary.padEnd(16, " ");
   return `${input.marker} ${provider} ${status} ${summary}${input.detail ?? ""}`.trimEnd();
 }
+async function runOpensteerRecordCommand(input) {
+  const stdout = input.stdout ?? process.stdout;
+  const stderr = input.stderr ?? process.stderr;
+  const outputPath = resolveRecordOutputPath({
+    rootDir: input.rootDir,
+    workspace: input.workspace,
+    ...input.outputPath === void 0 ? {} : { outputPath: input.outputPath }
+  });
+  const runtime = input.runtime;
+  const collector = new FlowRecorderCollector(createRecorderRuntimeAdapter(runtime), {
+    ...input.pollIntervalMs === void 0 ? {} : { pollIntervalMs: input.pollIntervalMs },
+    onAction: (action) => {
+      stderr.write(`${formatRecordedAction(action)}
+`);
+    }
+  });
+  stderr.write(
+    `Recording browser actions for workspace "${input.workspace}". Click "Stop recording" in the browser when you're done.
+`
+  );
+  let closed = false;
+  try {
+    const opened = await runtime.open({
+      url: input.url
+    });
+    await collector.install();
+    collector.start();
+    await collector.waitForStop();
+    const actions = await collector.stop();
+    const script = generateReplayScript({
+      actions,
+      workspace: input.workspace,
+      startUrl: opened.url
+    });
+    await promises.mkdir(path7__default.default.dirname(outputPath), { recursive: true });
+    await promises.writeFile(outputPath, script, "utf8");
+    if (input.closeSession !== void 0) {
+      await input.closeSession();
+      closed = true;
+    }
+    stdout.write(`${outputPath}
+`);
+    stderr.write(`Wrote replay script to ${outputPath}
+`);
+  } finally {
+    if (!closed) {
+      await runtime.disconnect().catch(() => void 0);
+    }
+  }
+}
+async function runOpensteerCloudRecordCommand(input) {
+  const stdout = input.stdout ?? process.stdout;
+  const stderr = input.stderr ?? process.stderr;
+  const outputPath = resolveRecordOutputPath({
+    rootDir: input.rootDir,
+    workspace: input.workspace,
+    ...input.outputPath === void 0 ? {} : { outputPath: input.outputPath }
+  });
+  let cloud;
+  const resolveCloud = () => {
+    cloud ??= new OpensteerCloudClient(input.cloudConfig);
+    return cloud;
+  };
+  const runtime = input.runtime ?? new CloudSessionProxy(resolveCloud(), {
+    rootDir: input.rootDir,
+    workspace: input.workspace
+  });
+  const client = input.client ?? resolveCloud();
+  const sleep5 = input.sleep ?? delay3;
+  let closed = false;
+  try {
+    await runtime.open({
+      url: input.url,
+      ...input.browser === void 0 ? {} : { browser: input.browser },
+      ...input.launch === void 0 ? {} : { launch: input.launch },
+      ...input.context === void 0 ? {} : { context: input.context }
+    });
+    const sessionId = await resolveCloudRecordingSessionId(runtime);
+    const sessionUrl = buildCloudRecordingSessionUrl(input.cloudConfig, sessionId);
+    await client.startSessionRecording(sessionId);
+    stderr.write(
+      `Recording browser actions for workspace "${input.workspace}". Open ${sessionUrl} and click "Stop recording" in the browser session toolbar when you're done.
+`
+    );
+    const completed = await waitForCloudRecordingCompletion({
+      client,
+      sessionId,
+      ...input.pollIntervalMs === void 0 ? {} : { pollIntervalMs: input.pollIntervalMs },
+      sleep: sleep5
+    });
+    if (completed.result === void 0) {
+      throw new Error("Cloud recording completed without a replay script.");
+    }
+    await promises.mkdir(path7__default.default.dirname(outputPath), { recursive: true });
+    await promises.writeFile(outputPath, completed.result.script, "utf8");
+    await runtime.close();
+    closed = true;
+    stdout.write(`${outputPath}
+`);
+    stderr.write(`Cloud browser session: ${sessionUrl}
+`);
+    stderr.write(`Wrote replay script to ${outputPath}
+`);
+  } finally {
+    if (!closed) {
+      await runtime.close().catch(() => void 0);
+    }
+  }
+}
+function resolveRecordOutputPath(input) {
+  if (input.outputPath !== void 0) {
+    return path7__default.default.resolve(input.rootDir, input.outputPath);
+  }
+  return path7__default.default.join(
+    resolveFilesystemWorkspacePath({
+      rootDir: input.rootDir,
+      workspace: input.workspace
+    }),
+    "recorded-flow.ts"
+  );
+}
+function createRecorderRuntimeAdapter(runtime) {
+  return {
+    addInitScript: (input) => runtime.addInitScript(input),
+    evaluate: async (input) => {
+      const output = await runtime.evaluate({
+        script: input.script,
+        ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef }
+      });
+      return output.value;
+    },
+    listPages: async () => {
+      const output = await runtime.listPages();
+      return {
+        pages: output.pages.map((page) => ({
+          pageRef: page.pageRef,
+          url: page.url,
+          ...page.openerPageRef === void 0 ? {} : { openerPageRef: page.openerPageRef }
+        }))
+      };
+    }
+  };
+}
+function buildCloudRecordingSessionUrl(cloudConfig, sessionId) {
+  const baseUrl = cloudConfig.appBaseUrl;
+  if (!baseUrl || baseUrl.trim().length === 0) {
+    throw new Error(
+      'record with provider=cloud requires OPENSTEER_CLOUD_APP_BASE_URL or "--cloud-app-base-url".'
+    );
+  }
+  return `${baseUrl.replace(/\/+$/, "")}/browsers/${encodeURIComponent(sessionId)}`;
+}
+async function resolveCloudRecordingSessionId(runtime) {
+  const info = await runtime.info();
+  if (typeof info.sessionId !== "string" || info.sessionId.length === 0) {
+    throw new Error("Cloud recording could not resolve the created session id.");
+  }
+  return info.sessionId;
+}
+async function waitForCloudRecordingCompletion(input) {
+  const pollIntervalMs = input.pollIntervalMs ?? 1e3;
+  for (; ; ) {
+    const state = await input.client.getSessionRecording(input.sessionId);
+    if (state.status === "completed") {
+      return state;
+    }
+    if (state.status === "failed") {
+      throw new Error(state.error ?? "Cloud recording failed.");
+    }
+    await input.sleep(pollIntervalMs);
+  }
+}
+function formatRecordedAction(action) {
+  const time = new Date(action.timestamp).toISOString().slice(11, 19);
+  switch (action.kind) {
+    case "click":
+      return `[${time}] click ${action.pageId} -> ${action.selector ?? "<unknown>"}`;
+    case "dblclick":
+      return `[${time}] dblclick ${action.pageId} -> ${action.selector ?? "<unknown>"}`;
+    case "type":
+      return `[${time}] type ${action.pageId} -> ${action.selector ?? "<unknown>"} -> ${JSON.stringify(action.detail.text)}`;
+    case "keypress":
+      return `[${time}] keypress ${action.pageId} -> ${action.detail.key}`;
+    case "scroll":
+      return `[${time}] scroll ${action.pageId} -> (${String(action.detail.deltaX)}, ${String(action.detail.deltaY)})`;
+    case "select-option":
+      return `[${time}] select ${action.pageId} -> ${action.selector ?? "<unknown>"} -> ${JSON.stringify(action.detail.value)}`;
+    case "navigate":
+      return `[${time}] navigate ${action.pageId} -> ${action.detail.url}`;
+    case "new-tab":
+      return `[${time}] new-tab ${action.pageId} -> ${action.detail.initialUrl}`;
+    case "close-tab":
+      return `[${time}] close-tab ${action.pageId}`;
+    case "switch-tab":
+      return `[${time}] switch-tab -> ${action.detail.toPageId}`;
+    case "go-back":
+      return `[${time}] go-back ${action.pageId}`;
+    case "go-forward":
+      return `[${time}] go-forward ${action.pageId}`;
+    case "reload":
+      return `[${time}] reload ${action.pageId}`;
+  }
+}
+function delay3(ms) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
+  });
+}
 
 // src/cli/bin.ts
 var OPERATION_ALIASES = /* @__PURE__ */ new Map([
@@ -34497,6 +36625,10 @@ async function main() {
     await handleStatusCommand(parsed);
     return;
   }
+  if (parsed.command[0] === "record") {
+    await handleRecordCommandEntry(parsed);
+    return;
+  }
   const operation = parsed.command[0] === "run" ? parsed.rest[0] : resolveOperation(parsed.command);
   if (!operation) {
     throw new Error(`Unknown command: ${parsed.command.join(" ")}`);
@@ -34641,6 +36773,100 @@ async function handleBrowserCommand(parsed) {
       throw new Error(`Unknown browser command: ${parsed.command.join(" ")}`);
   }
 }
+async function handleRecordCommandEntry(parsed) {
+  if (parsed.options.workspace === void 0) {
+    throw new Error('record requires "--workspace <id>".');
+  }
+  const url = parsed.options.url ?? parsed.rest[0];
+  if (url === void 0) {
+    throw new Error('record requires "--url <value>" or a positional URL.');
+  }
+  const provider = resolveCliProvider(parsed);
+  assertCloudCliOptionsMatchProvider(parsed, provider.mode);
+  const engineName = resolveCliEngineName(parsed);
+  if (engineName !== "playwright") {
+    throw new Error("record requires engine=playwright.");
+  }
+  const rootDir = process2__default.default.cwd();
+  const recordBrowser = parsed.options.browser;
+  if (provider.mode === "cloud") {
+    if (typeof recordBrowser === "object") {
+      throw new Error('record does not support browser.mode="attach".');
+    }
+    const runtimeProvider = buildCliRuntimeProvider(parsed, provider.mode);
+    const runtimeConfig = resolveOpensteerRuntimeConfig({
+      ...runtimeProvider === void 0 ? {} : { provider: runtimeProvider },
+      environment: process2__default.default.env
+    });
+    await runOpensteerCloudRecordCommand({
+      cloudConfig: runtimeConfig.cloud,
+      workspace: parsed.options.workspace,
+      url,
+      rootDir,
+      ...recordBrowser === void 0 ? {} : { browser: recordBrowser },
+      ...parsed.options.launch === void 0 ? {} : { launch: parsed.options.launch },
+      ...parsed.options.context === void 0 ? {} : { context: parsed.options.context },
+      ...parsed.options.output === void 0 ? {} : { outputPath: parsed.options.output }
+    });
+    return;
+  }
+  if (parsed.options.launch?.headless === true) {
+    throw new Error('record requires a headed browser. Remove "--headless true".');
+  }
+  if (recordBrowser !== void 0 && recordBrowser !== "persistent") {
+    throw new Error('record only supports "--browser persistent".');
+  }
+  const launch = {
+    ...parsed.options.launch ?? {},
+    headless: false
+  };
+  const browserManager = new OpensteerBrowserManager({
+    rootDir,
+    workspace: parsed.options.workspace,
+    engineName,
+    browser: "persistent",
+    launch,
+    ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
+  });
+  const runtime = createOpensteerSemanticRuntime({
+    provider: {
+      mode: "local"
+    },
+    engine: engineName,
+    runtimeOptions: {
+      rootPath: browserManager.rootPath,
+      cleanupRootOnClose: browserManager.cleanupRootOnDisconnect,
+      workspace: parsed.options.workspace,
+      browser: "persistent",
+      launch,
+      ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
+    }
+  });
+  await runOpensteerRecordCommand({
+    runtime,
+    closeSession: () => closeOwnedLocalBrowserSession(runtime, browserManager),
+    workspace: parsed.options.workspace,
+    url,
+    rootDir,
+    ...parsed.options.output === void 0 ? {} : { outputPath: parsed.options.output }
+  });
+}
+async function closeOwnedLocalBrowserSession(runtime, browserManager) {
+  let closeError;
+  try {
+    await runtime.close();
+  } catch (error) {
+    closeError = error;
+  }
+  try {
+    await browserManager.close();
+  } catch (error) {
+    closeError ??= error;
+  }
+  if (closeError !== void 0) {
+    throw closeError;
+  }
+}
 function buildOperationInput(operation, parsed) {
   if (parsed.options.inputJson !== void 0) {
     return parsed.options.inputJson;
@@ -34721,6 +36947,46 @@ function resolveOperation(command) {
   }
   return void 0;
 }
+var CLI_OPTION_SPECS = {
+  workspace: { kind: "value" },
+  url: { kind: "value" },
+  output: { kind: "value" },
+  engine: { kind: "value" },
+  provider: { kind: "value" },
+  "cloud-base-url": { kind: "value" },
+  "cloud-api-key": { kind: "value" },
+  "cloud-app-base-url": { kind: "value" },
+  "cloud-profile-id": { kind: "value" },
+  "cloud-profile-reuse-if-active": { kind: "boolean" },
+  json: { kind: "boolean" },
+  agent: { kind: "value", multiple: true },
+  skill: { kind: "value", multiple: true },
+  global: { kind: "boolean" },
+  yes: { kind: "boolean" },
+  copy: { kind: "boolean" },
+  all: { kind: "boolean" },
+  list: { kind: "boolean" },
+  browser: { kind: "value" },
+  "attach-endpoint": { kind: "value" },
+  "attach-header": { kind: "value", multiple: true },
+  "fresh-tab": { kind: "boolean" },
+  headless: { kind: "boolean" },
+  "executable-path": { kind: "value" },
+  arg: { kind: "value", multiple: true },
+  "timeout-ms": { kind: "value" },
+  "context-json": { kind: "value" },
+  "input-json": { kind: "value" },
+  "schema-json": { kind: "value" },
+  "source-user-data-dir": { kind: "value" },
+  "source-profile-directory": { kind: "value" },
+  selector: { kind: "value" },
+  description: { kind: "value" },
+  element: { kind: "value" },
+  text: { kind: "value" },
+  "press-enter": { kind: "boolean" },
+  direction: { kind: "value" },
+  amount: { kind: "value" }
+};
 function parseCommandLine(argv) {
   const leadingTokens = [];
   let index = 0;
@@ -34734,18 +37000,43 @@ function parseCommandLine(argv) {
   const rawOptions = /* @__PURE__ */ new Map();
   while (index < argv.length) {
     const token = argv[index];
+    if (token === "--") {
+      rest.push(...argv.slice(index + 1));
+      break;
+    }
     if (!token.startsWith("--")) {
       rest.push(token);
       index += 1;
       continue;
     }
-    const key = token.slice(2);
-    const next = argv[index + 1];
-    if (next === void 0 || next.startsWith("--")) {
-      rawOptions.set(key, [...rawOptions.get(key) ?? [], "true"]);
+    const separator = token.indexOf("=");
+    const key = token.slice(2, separator === -1 ? void 0 : separator);
+    const spec = CLI_OPTION_SPECS[key];
+    if (spec === void 0) {
+      throw new Error(`Unknown option: --${key}.`);
+    }
+    if (separator !== -1) {
+      const value = token.slice(separator + 1);
+      rawOptions.set(key, [...rawOptions.get(key) ?? [], value]);
       index += 1;
       continue;
     }
+    const next = argv[index + 1];
+    if (spec.kind === "boolean") {
+      if (next === void 0 || next.startsWith("--")) {
+        rawOptions.set(key, [...rawOptions.get(key) ?? [], "true"]);
+        index += 1;
+        continue;
+      }
+      rawOptions.set(key, [...rawOptions.get(key) ?? [], next]);
+      index += 2;
+      continue;
+    }
+    if (next === void 0 || next.startsWith("--")) {
+      throw new Error(
+        `Option "--${key}" requires a value.${next?.startsWith("--") === true ? ` Use "--${key}=<value>" when the value begins with "--".` : ``}`
+      );
+    }
     rawOptions.set(key, [...rawOptions.get(key) ?? [], next]);
     index += 2;
   }
@@ -34776,6 +37067,8 @@ function parseCommandLine(argv) {
     ...timeoutMs === void 0 ? {} : { timeoutMs }
   };
   const workspace = readSingle(rawOptions, "workspace");
+  const url = readSingle(rawOptions, "url");
+  const output = readSingle(rawOptions, "output");
   const sourceUserDataDir = readSingle(rawOptions, "source-user-data-dir");
   const sourceProfileDirectory = readSingle(rawOptions, "source-profile-directory");
   const selector = readSingle(rawOptions, "selector");
@@ -34792,6 +37085,7 @@ function parseCommandLine(argv) {
   const provider = providerValue === void 0 ? void 0 : normalizeOpensteerProviderMode(providerValue, "--provider");
   const cloudBaseUrl = readSingle(rawOptions, "cloud-base-url");
   const cloudApiKey = readSingle(rawOptions, "cloud-api-key");
+  const cloudAppBaseUrl = readSingle(rawOptions, "cloud-app-base-url");
   const cloudProfileId = readSingle(rawOptions, "cloud-profile-id");
   const cloudProfileReuseIfActive = readOptionalBoolean(
     rawOptions,
@@ -34807,10 +37101,13 @@ function parseCommandLine(argv) {
   const list = readOptionalBoolean(rawOptions, "list");
   const options = {
     ...workspace === void 0 ? {} : { workspace },
+    ...url === void 0 ? {} : { url },
+    ...output === void 0 ? {} : { output },
     ...requestedEngineName === void 0 ? {} : { requestedEngineName },
     ...provider === void 0 ? {} : { provider },
     ...cloudBaseUrl === void 0 ? {} : { cloudBaseUrl },
     ...cloudApiKey === void 0 ? {} : { cloudApiKey },
+    ...cloudAppBaseUrl === void 0 ? {} : { cloudAppBaseUrl },
     ...cloudProfileId === void 0 ? {} : { cloudProfileId },
     ...cloudProfileReuseIfActive === void 0 ? {} : { cloudProfileReuseIfActive },
     ...json === void 0 ? {} : { json },
@@ -34895,7 +37192,7 @@ function buildCliRuntimeProvider(parsed, providerMode) {
     return explicitProvider?.mode === "local" ? explicitProvider : void 0;
   }
   const browserProfile = buildCliBrowserProfile(parsed);
-  const hasCloudOverrides = parsed.options.cloudBaseUrl !== void 0 || parsed.options.cloudApiKey !== void 0 || browserProfile !== void 0;
+  const hasCloudOverrides = parsed.options.cloudBaseUrl !== void 0 || parsed.options.cloudApiKey !== void 0 || parsed.options.cloudAppBaseUrl !== void 0 || browserProfile !== void 0;
   if (!hasCloudOverrides && explicitProvider?.mode !== "cloud") {
     return void 0;
   }
@@ -34903,11 +37200,12 @@ function buildCliRuntimeProvider(parsed, providerMode) {
     mode: "cloud",
     ...parsed.options.cloudBaseUrl === void 0 ? {} : { baseUrl: parsed.options.cloudBaseUrl },
     ...parsed.options.cloudApiKey === void 0 ? {} : { apiKey: parsed.options.cloudApiKey },
+    ...parsed.options.cloudAppBaseUrl === void 0 ? {} : { appBaseUrl: parsed.options.cloudAppBaseUrl },
     ...browserProfile === void 0 ? {} : { browserProfile }
   };
 }
 function assertCloudCliOptionsMatchProvider(parsed, providerMode) {
-  if (providerMode !== "cloud" && (parsed.options.cloudBaseUrl !== void 0 || parsed.options.cloudApiKey !== void 0 || parsed.options.cloudProfileId !== void 0 || parsed.options.cloudProfileReuseIfActive === true)) {
+  if (providerMode !== "cloud" && (parsed.options.cloudBaseUrl !== void 0 || parsed.options.cloudApiKey !== void 0 || parsed.options.cloudAppBaseUrl !== void 0 || parsed.options.cloudProfileId !== void 0 || parsed.options.cloudProfileReuseIfActive === true)) {
     throw new Error(
       'Cloud-specific options require provider=cloud. Set "--provider cloud" or OPENSTEER_PROVIDER=cloud.'
     );
@@ -35006,6 +37304,9 @@ function resolveCommandLength(tokens) {
   if (tokens[0] === "status") {
     return 1;
   }
+  if (tokens[0] === "record") {
+    return 1;
+  }
   for (let length = Math.min(3, tokens.length); length >= 1; length -= 1) {
     if (OPERATION_ALIASES.has(tokens.slice(0, length).join(" "))) {
       return length;
@@ -35023,6 +37324,7 @@ Usage:
   opensteer click --workspace <id> (--element <n> | --selector <css> | --description <text>)
   opensteer input --workspace <id> --text <value> (--element <n> | --selector <css> | --description <text>)
   opensteer extract --workspace <id> --description <text> [--schema-json <json>]
+  opensteer record --workspace <id> --url <url> [--output <path>]
   opensteer close --workspace <id>
   opensteer status [--workspace <id>] [--json]
 
@@ -35040,9 +37342,12 @@ Common options:
   --help
   --version
   --workspace <id>
+  --url <url>
+  --output <path>
   --provider local|cloud
   --cloud-base-url <url>
   --cloud-api-key <key>
+  --cloud-app-base-url <url>
   --cloud-profile-id <id>
   --cloud-profile-reuse-if-active <true|false>
   --json <true|false>