opensteer 0.8.2 → 0.8.4

package/dist/index.cjs

@@ -16,6 +16,7 @@ var cheerio = require('cheerio');
 var prettier = require('prettier');
 var vm = require('vm');
 var zlib = require('zlib');
+var WebSocket2 = require('ws');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -43,10 +44,11 @@ var sharp__default = /*#__PURE__*/_interopDefault(sharp);
 var cheerio__namespace = /*#__PURE__*/_interopNamespace(cheerio);
 var prettier__namespace = /*#__PURE__*/_interopNamespace(prettier);
 var vm__default = /*#__PURE__*/_interopDefault(vm);
+var WebSocket2__default = /*#__PURE__*/_interopDefault(WebSocket2);
 
-// src/root.ts
+// ../runtime-core/src/root.ts
 
-// src/json.ts
+// ../runtime-core/src/json.ts
 function isPlainObject(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -54,30 +56,30 @@ function isPlainObject(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function canonicalizeJsonValue(value, path11) {
+function canonicalizeJsonValue(value, path13) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) {
-      throw new TypeError(`${path11} must be a finite JSON number`);
+      throw new TypeError(`${path13} must be a finite JSON number`);
     }
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path11}[${index}]`));
+    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path13}[${index}]`));
   }
   if (!isPlainObject(value)) {
-    throw new TypeError(`${path11} must be a plain JSON object`);
+    throw new TypeError(`${path13} 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(`${path11}.${key} must not be undefined`);
+      throw new TypeError(`${path13}.${key} must not be undefined`);
     }
-    result[key] = canonicalizeJsonValue(entry, `${path11}.${key}`);
+    result[key] = canonicalizeJsonValue(entry, `${path13}.${key}`);
   }
   return result;
 }
@@ -92,7 +94,7 @@ function stableJsonString(value) {
 `;
 }
 
-// src/internal/filesystem.ts
+// ../runtime-core/src/internal/filesystem.ts
 var LOCK_RETRY_DELAYS_MS = [1, 2, 5, 10, 20, 50];
 function normalizeNonEmptyString(name, value) {
   const normalized = value.trim();
@@ -220,7 +222,7 @@ async function withFilesystemLock(lockPath, task) {
   }
 }
 
-// src/artifacts.ts
+// ../runtime-core/src/artifacts.ts
 function normalizeScope(scope) {
   if (scope === void 0) {
     return {};
@@ -574,31 +576,31 @@ function oneOfSchema(members, options = {}) {
 }
 
 // ../protocol/src/validation.ts
-function validateJsonSchema(schema, value, path11 = "$") {
-  return validateSchemaNode(schema, value, path11);
+function validateJsonSchema(schema, value, path13 = "$") {
+  return validateSchemaNode(schema, value, path13);
 }
-function validateSchemaNode(schema, value, path11) {
+function validateSchemaNode(schema, value, path13) {
   const issues = [];
   if ("const" in schema && !isJsonValueEqual(schema.const, value)) {
     issues.push({
-      path: path11,
+      path: path13,
       message: `must equal ${JSON.stringify(schema.const)}`
     });
     return issues;
   }
   if (schema.enum !== void 0 && !schema.enum.some((candidate) => isJsonValueEqual(candidate, value))) {
     issues.push({
-      path: path11,
+      path: path13,
       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, path11));
+    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path13));
     const validBranches = branchIssues.filter((current) => current.length === 0).length;
     if (validBranches !== 1) {
       issues.push({
-        path: path11,
+        path: path13,
         message: validBranches === 0 ? "must match exactly one supported shape" : "matches multiple supported shapes"
       });
       return issues;
@@ -606,11 +608,11 @@ function validateSchemaNode(schema, value, path11) {
   }
   if (schema.anyOf !== void 0) {
     const hasMatch = schema.anyOf.some(
-      (member) => validateSchemaNode(member, value, path11).length === 0
+      (member) => validateSchemaNode(member, value, path13).length === 0
     );
     if (!hasMatch) {
       issues.push({
-        path: path11,
+        path: path13,
         message: "must match at least one supported shape"
       });
       return issues;
@@ -618,7 +620,7 @@ function validateSchemaNode(schema, value, path11) {
   }
   if (schema.allOf !== void 0) {
     for (const member of schema.allOf) {
-      issues.push(...validateSchemaNode(member, value, path11));
+      issues.push(...validateSchemaNode(member, value, path13));
     }
     if (issues.length > 0) {
       return issues;
@@ -626,7 +628,7 @@ function validateSchemaNode(schema, value, path11) {
   }
   if (schema.type !== void 0 && !matchesSchemaType(schema.type, value)) {
     issues.push({
-      path: path11,
+      path: path13,
       message: `must be ${describeSchemaType(schema.type)}`
     });
     return issues;
@@ -634,19 +636,19 @@ function validateSchemaNode(schema, value, path11) {
   if (typeof value === "string") {
     if (schema.minLength !== void 0 && value.length < schema.minLength) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must have length >= ${String(schema.minLength)}`
       });
     }
     if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must have length <= ${String(schema.maxLength)}`
       });
     }
     if (schema.pattern !== void 0 && !new RegExp(schema.pattern).test(value)) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must match pattern ${schema.pattern}`
       });
     }
@@ -655,25 +657,25 @@ function validateSchemaNode(schema, value, path11) {
   if (typeof value === "number") {
     if (schema.minimum !== void 0 && value < schema.minimum) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must be >= ${String(schema.minimum)}`
       });
     }
     if (schema.maximum !== void 0 && value > schema.maximum) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must be <= ${String(schema.maximum)}`
       });
     }
     if (schema.exclusiveMinimum !== void 0 && value <= schema.exclusiveMinimum) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must be > ${String(schema.exclusiveMinimum)}`
       });
     }
     if (schema.exclusiveMaximum !== void 0 && value >= schema.exclusiveMaximum) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must be < ${String(schema.exclusiveMaximum)}`
       });
     }
@@ -682,13 +684,13 @@ function validateSchemaNode(schema, value, path11) {
   if (Array.isArray(value)) {
     if (schema.minItems !== void 0 && value.length < schema.minItems) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must have at least ${String(schema.minItems)} items`
       });
     }
     if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
       issues.push({
-        path: path11,
+        path: path13,
         message: `must have at most ${String(schema.maxItems)} items`
       });
     }
@@ -698,7 +700,7 @@ function validateSchemaNode(schema, value, path11) {
         const key = JSON.stringify(item);
         if (seen.has(key)) {
           issues.push({
-            path: path11,
+            path: path13,
             message: "must not contain duplicate items"
           });
           break;
@@ -708,7 +710,7 @@ function validateSchemaNode(schema, value, path11) {
     }
     if (schema.items !== void 0) {
       for (let index = 0; index < value.length; index += 1) {
-        issues.push(...validateSchemaNode(schema.items, value[index], `${path11}[${String(index)}]`));
+        issues.push(...validateSchemaNode(schema.items, value[index], `${path13}[${String(index)}]`));
       }
     }
     return issues;
@@ -718,7 +720,7 @@ function validateSchemaNode(schema, value, path11) {
     for (const requiredKey of schema.required ?? []) {
       if (!(requiredKey in value)) {
         issues.push({
-          path: joinObjectPath(path11, requiredKey),
+          path: joinObjectPath(path13, requiredKey),
           message: "is required"
         });
       }
@@ -727,13 +729,13 @@ function validateSchemaNode(schema, value, path11) {
       const propertySchema = properties[key];
       if (propertySchema !== void 0) {
         issues.push(
-          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path11, key))
+          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path13, key))
         );
         continue;
       }
       if (schema.additionalProperties === false) {
         issues.push({
-          path: joinObjectPath(path11, key),
+          path: joinObjectPath(path13, key),
           message: "is not allowed"
         });
         continue;
@@ -743,7 +745,7 @@ function validateSchemaNode(schema, value, path11) {
           ...validateSchemaNode(
             schema.additionalProperties,
             propertyValue,
-            joinObjectPath(path11, key)
+            joinObjectPath(path13, key)
           )
         );
       }
@@ -987,8 +989,8 @@ function matchesNetworkRecordFilters(record, filters) {
     }
   }
   if (filters.path !== void 0) {
-    const path11 = getParsedUrl().pathname;
-    if (!includesCaseInsensitive(path11, filters.path)) {
+    const path13 = getParsedUrl().pathname;
+    if (!includesCaseInsensitive(path13, filters.path)) {
       return false;
     }
   }
@@ -1785,12 +1787,6 @@ var opensteerRegistryProvenanceSchema = objectSchema(
     required: ["source"]
   }
 );
-var opensteerRequestPlanLifecycleSchema = enumSchema(
-  ["draft", "active", "deprecated", "retired"],
-  {
-    title: "OpensteerRequestPlanLifecycle"
-  }
-);
 var opensteerRequestPlanFreshnessSchema = objectSchema(
   {
     lastValidatedAt: integerSchema({ minimum: 0 }),
@@ -1813,23 +1809,12 @@ var opensteerRequestPlanRecordSchema = objectSchema(
       uniqueItems: true
     }),
     provenance: opensteerRegistryProvenanceSchema,
-    lifecycle: opensteerRequestPlanLifecycleSchema,
     freshness: opensteerRequestPlanFreshnessSchema,
     payload: opensteerRequestPlanPayloadSchema
   },
   {
     title: "OpensteerRequestPlanRecord",
-    required: [
-      "id",
-      "key",
-      "version",
-      "createdAt",
-      "updatedAt",
-      "contentHash",
-      "tags",
-      "lifecycle",
-      "payload"
-    ]
+    required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
   }
 );
 var jsonValueSchema = defineSchema({
@@ -2272,7 +2257,6 @@ var opensteerWriteRequestPlanInputSchema = objectSchema(
       uniqueItems: true
     }),
     provenance: opensteerRegistryProvenanceSchema,
-    lifecycle: opensteerRequestPlanLifecycleSchema,
     freshness: opensteerRequestPlanFreshnessSchema,
     payload: opensteerRequestPlanPayloadSchema
   },
@@ -2513,7 +2497,7 @@ var opensteerInferRequestPlanInputSchema = objectSchema(
     recordId: stringSchema({ minLength: 1 }),
     key: stringSchema({ minLength: 1 }),
     version: stringSchema({ minLength: 1 }),
-    lifecycle: opensteerRequestPlanLifecycleSchema
+    transport: transportKindSchema
   },
   {
     title: "OpensteerInferRequestPlanInput",
@@ -5703,6 +5687,65 @@ var opensteerComputerAnnotationNames = [
   "grid",
   "selected"
 ];
+var opensteerSemanticOperationNames = [
+  "session.open",
+  "page.list",
+  "page.new",
+  "page.activate",
+  "page.close",
+  "page.goto",
+  "page.evaluate",
+  "page.add-init-script",
+  "page.snapshot",
+  "dom.click",
+  "dom.hover",
+  "dom.input",
+  "dom.scroll",
+  "dom.extract",
+  "network.query",
+  "network.save",
+  "network.clear",
+  "network.minimize",
+  "network.diff",
+  "network.probe",
+  "reverse.discover",
+  "reverse.query",
+  "reverse.package.create",
+  "reverse.package.run",
+  "reverse.export",
+  "reverse.report",
+  "reverse.package.get",
+  "reverse.package.list",
+  "reverse.package.patch",
+  "interaction.capture",
+  "interaction.get",
+  "interaction.diff",
+  "interaction.replay",
+  "artifact.read",
+  "inspect.cookies",
+  "inspect.storage",
+  "scripts.capture",
+  "scripts.beautify",
+  "scripts.deobfuscate",
+  "scripts.sandbox",
+  "captcha.solve",
+  "request.raw",
+  "request-plan.infer",
+  "request-plan.write",
+  "request-plan.get",
+  "request-plan.list",
+  "recipe.write",
+  "recipe.get",
+  "recipe.list",
+  "recipe.run",
+  "auth-recipe.write",
+  "auth-recipe.get",
+  "auth-recipe.list",
+  "auth-recipe.run",
+  "request.execute",
+  "computer.execute",
+  "session.close"
+];
 function defineSemanticOperationSpec(spec) {
   return spec;
 }
@@ -7002,7 +7045,7 @@ function resolveDomActionBridge(engine) {
   return isDomActionBridgeFactory(candidate) ? candidate.call(engine) : void 0;
 }
 
-// src/registry.ts
+// ../runtime-core/src/registry.ts
 function normalizeTags(tags) {
   if (tags === void 0) {
     return [];
@@ -7068,9 +7111,7 @@ var FilesystemRegistryStore = class {
     if (input.version !== void 0) {
       return this.resolveIndexedRecord(key, normalizeNonEmptyString("version", input.version));
     }
-    const matches = (await this.readAllRecords()).filter(
-      (record) => this.isActive(record) && record.key === key
-    );
+    const matches = (await this.readAllRecords()).filter((record) => record.key === key);
     matches.sort(compareByCreatedAtAndId);
     return matches[0];
   }
@@ -7193,8 +7234,10 @@ var FilesystemDescriptorRegistry = class extends FilesystemRegistryStore {
     };
     return this.writeRecord(record);
   }
-  isActive(_record) {
-    return true;
+  async list(input = {}) {
+    const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
+    const records = await this.readAllRecords();
+    return key === void 0 ? records : records.filter((record) => record.key === key);
   }
 };
 var FilesystemRequestPlanRegistry = class extends FilesystemRegistryStore {
@@ -7224,7 +7267,6 @@ var FilesystemRequestPlanRegistry = class extends FilesystemRegistryStore {
       tags: normalizeTags(input.tags),
       ...provenance === void 0 ? {} : { provenance },
       payload,
-      lifecycle: input.lifecycle ?? "active",
       ...freshness === void 0 ? {} : { freshness }
     };
     return this.writeRecord(record);
@@ -7234,7 +7276,7 @@ var FilesystemRequestPlanRegistry = class extends FilesystemRegistryStore {
     const records = await this.readAllRecords();
     return key === void 0 ? records : records.filter((record) => record.key === key);
   }
-  async updateMetadata(input) {
+  async updateFreshness(input) {
     const id = normalizeNonEmptyString("id", input.id);
     return withFilesystemLock(this.writeLockPath(), async () => {
       const existing = await this.getById(id);
@@ -7252,16 +7294,12 @@ var FilesystemRequestPlanRegistry = class extends FilesystemRegistryStore {
       const nextRecord = {
         ...existing,
         updatedAt: nextUpdatedAt,
-        lifecycle: input.lifecycle ?? existing.lifecycle,
         ...nextFreshness === void 0 ? {} : { freshness: nextFreshness }
       };
       await writeJsonFileAtomic(this.recordPath(id), nextRecord);
       return nextRecord;
     });
   }
-  isActive(record) {
-    return record.lifecycle === "active";
-  }
 };
 var FilesystemAuthRecipeRegistry = class extends FilesystemRegistryStore {
   constructor(rootPath) {
@@ -7297,9 +7335,6 @@ var FilesystemAuthRecipeRegistry = class extends FilesystemRegistryStore {
     const records = await this.readAllRecords();
     return key === void 0 ? records : records.filter((record) => record.key === key);
   }
-  isActive(_record) {
-    return true;
-  }
 };
 var FilesystemRecipeRegistry = class extends FilesystemRegistryStore {
   constructor(rootPath) {
@@ -7335,9 +7370,6 @@ var FilesystemRecipeRegistry = class extends FilesystemRegistryStore {
     const records = await this.readAllRecords();
     return key === void 0 ? records : records.filter((record) => record.key === key);
   }
-  isActive(_record) {
-    return true;
-  }
 };
 var FilesystemInteractionTraceRegistry = class extends FilesystemRegistryStore {
   constructor(rootPath) {
@@ -7373,9 +7405,6 @@ var FilesystemInteractionTraceRegistry = class extends FilesystemRegistryStore {
     const records = await this.readAllRecords();
     return key === void 0 ? records : records.filter((record) => record.key === key);
   }
-  isActive(_record) {
-    return true;
-  }
 };
 var FilesystemReverseCaseRegistry = class extends FilesystemRegistryStore {
   constructor(rootPath) {
@@ -7439,9 +7468,6 @@ var FilesystemReverseCaseRegistry = class extends FilesystemRegistryStore {
       return nextRecord;
     });
   }
-  isActive(_record) {
-    return true;
-  }
 };
 var FilesystemReversePackageRegistry = class extends FilesystemRegistryStore {
   constructor(rootPath) {
@@ -7477,9 +7503,6 @@ var FilesystemReversePackageRegistry = class extends FilesystemRegistryStore {
     const records = await this.readAllRecords();
     return key === void 0 ? records : records.filter((record) => record.key === key);
   }
-  isActive(_record) {
-    return true;
-  }
 };
 var FilesystemReverseReportRegistry = class extends FilesystemRegistryStore {
   constructor(rootPath) {
@@ -7515,9 +7538,6 @@ var FilesystemReverseReportRegistry = class extends FilesystemRegistryStore {
     const records = await this.readAllRecords();
     return key === void 0 ? records : records.filter((record) => record.key === key);
   }
-  isActive(_record) {
-    return true;
-  }
 };
 function createDescriptorRegistry(rootPath) {
   return new FilesystemDescriptorRegistry(rootPath);
@@ -8236,7 +8256,7 @@ function createTraceStore(rootPath, artifacts) {
   return new FilesystemTraceStore(rootPath, artifacts);
 }
 
-// src/root.ts
+// ../runtime-core/src/root.ts
 var OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT = "opensteer-workspace";
 var OPENSTEER_FILESYSTEM_WORKSPACE_VERSION = 2;
 function normalizeWorkspaceId(workspace) {
@@ -8257,7 +8277,8 @@ async function createFilesystemOpensteerWorkspace(options) {
   const browserManifestPath = path6__default.default.join(browserPath, "manifest.json");
   const browserUserDataDir = path6__default.default.join(browserPath, "user-data");
   const livePath = path6__default.default.join(options.rootPath, "live");
-  const liveBrowserPath = path6__default.default.join(livePath, "browser.json");
+  const liveLocalPath = path6__default.default.join(livePath, "local.json");
+  const liveCloudPath = path6__default.default.join(livePath, "cloud.json");
   const artifactsPath = path6__default.default.join(options.rootPath, "artifacts");
   const tracesPath = path6__default.default.join(options.rootPath, "traces");
   const registryPath = path6__default.default.join(options.rootPath, "registry");
@@ -8332,7 +8353,8 @@ async function createFilesystemOpensteerWorkspace(options) {
     browserManifestPath,
     browserUserDataDir,
     livePath,
-    liveBrowserPath,
+    liveLocalPath,
+    liveCloudPath,
     artifactsPath,
     tracesPath,
     registryPath,
@@ -8356,7 +8378,7 @@ async function createFilesystemOpensteerWorkspace(options) {
   };
 }
 
-// src/policy/defaults.ts
+// ../runtime-core/src/policy/defaults.ts
 var DEFAULT_TIMEOUTS = {
   "session.open": 3e4,
   "page.goto": 3e4,
@@ -8439,7 +8461,7 @@ function defaultPolicy() {
   return DEFAULT_POLICY;
 }
 
-// src/policy/settle.ts
+// ../runtime-core/src/policy/settle.ts
 async function settleWithPolicy(policy, input) {
   for (const observer of policy.observers ?? []) {
     if (await observer.settle(input)) {
@@ -8478,7 +8500,7 @@ function abortError() {
   return error;
 }
 
-// src/policy/timeout.ts
+// ../runtime-core/src/policy/timeout.ts
 var PolicyTimeoutController = class {
   constructor(input, budgetMs) {
     this.input = input;
@@ -8588,7 +8610,17 @@ function abortError2() {
   return error;
 }
 
-// src/runtimes/dom/match-policy.ts
+// ../runtime-core/src/runtimes/dom/errors.ts
+var ElementPathError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ElementPathError";
+    this.code = code;
+  }
+};
+
+// ../runtime-core/src/runtimes/dom/match-policy.ts
 var ATTRIBUTE_DENY_KEYS = /* @__PURE__ */ new Set([
   "style",
   "nonce",
@@ -8820,7 +8852,7 @@ function getClauseAttributeValue(node, clause) {
   return String(raw);
 }
 
-// src/runtimes/dom/match-selectors.ts
+// ../runtime-core/src/runtimes/dom/match-selectors.ts
 function buildPathCandidates(domPath) {
   const nodes = Array.isArray(domPath) ? domPath : [];
   if (!nodes.length) {
@@ -8905,7 +8937,7 @@ function buildSuffixCandidates(segments) {
   return out;
 }
 
-// src/runtimes/dom/extraction.ts
+// ../runtime-core/src/runtimes/dom/extraction.ts
 var URL_LIST_ATTRIBUTES = /* @__PURE__ */ new Set(["srcset", "imagesrcset", "ping"]);
 var IFRAME_URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "href",
@@ -8917,9 +8949,9 @@ var IFRAME_URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "poster",
   "ping"
 ]);
-function buildArrayFieldPathCandidates(path11) {
-  const strict = path11.nodes.length ? buildPathCandidates(path11.nodes) : [];
-  const relaxedNodes = stripPositionClauses(path11.nodes);
+function buildArrayFieldPathCandidates(path13) {
+  const strict = path13.nodes.length ? buildPathCandidates(path13.nodes) : [];
+  const relaxedNodes = stripPositionClauses(path13.nodes);
   const relaxed = relaxedNodes.length ? buildPathCandidates(relaxedNodes) : [];
   return dedupeSelectors([...strict, ...relaxed]);
 }
@@ -9151,16 +9183,6 @@ function readDescriptorToken(value, index) {
     nextIndex: cursor
   };
 }
-
-// src/runtimes/dom/errors.ts
-var ElementPathError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "ElementPathError";
-    this.code = code;
-  }
-};
 var selectorAdapter = {
   isTag(node) {
     return node.kind === "element" && node.source.nodeType === 1;
@@ -9228,6 +9250,45 @@ var selectorAdapter = {
   },
   equals(left, right) {
     return left === right;
+  },
+  existsOne(test, nodes) {
+    return selectorAdapter.findOne(test, nodes) !== null;
+  },
+  findAll(test, nodes) {
+    const matches = [];
+    const visit = (node) => {
+      if (selectorAdapter.isTag(node) && test(node)) {
+        matches.push(node);
+      }
+      for (const child of selectorAdapter.getChildren(node)) {
+        visit(child);
+      }
+    };
+    for (const node of nodes) {
+      visit(node);
+    }
+    return matches;
+  },
+  findOne(test, nodes) {
+    const visit = (node) => {
+      if (selectorAdapter.isTag(node) && test(node)) {
+        return node;
+      }
+      for (const child of selectorAdapter.getChildren(node)) {
+        const match = visit(child);
+        if (match !== null) {
+          return match;
+        }
+      }
+      return null;
+    };
+    for (const node of nodes) {
+      const match = visit(node);
+      if (match !== null) {
+        return match;
+      }
+    }
+    return null;
   }
 };
 function createDomSnapshotIndex(snapshot) {
@@ -9411,7 +9472,7 @@ function sortNodes(nodes) {
   return [...nodes].sort((left, right) => left.snapshotNodeId - right.snapshotNodeId);
 }
 
-// src/runtimes/dom/path.ts
+// ../runtime-core/src/runtimes/dom/path.ts
 var MAX_ATTRIBUTE_VALUE_LENGTH = 300;
 function cloneStructuralElementAnchor(anchor) {
   return {
@@ -9420,18 +9481,18 @@ function cloneStructuralElementAnchor(anchor) {
     nodes: anchor.nodes.map(clonePathNode)
   };
 }
-function cloneReplayElementPath(path11) {
+function cloneReplayElementPath(path13) {
   return {
     resolution: "deterministic",
-    context: cloneContext(path11.context),
-    nodes: path11.nodes.map(clonePathNode)
+    context: cloneContext(path13.context),
+    nodes: path13.nodes.map(clonePathNode)
   };
 }
-function cloneElementPath(path11) {
-  return cloneReplayElementPath(path11);
+function cloneElementPath(path13) {
+  return cloneReplayElementPath(path13);
 }
-function buildPathSelectorHint(path11) {
-  const nodes = path11?.nodes || [];
+function buildPathSelectorHint(path13) {
+  const nodes = path13?.nodes || [];
   const last = nodes[nodes.length - 1];
   if (!last) {
     return "*";
@@ -9480,15 +9541,15 @@ function sanitizeStructuralElementAnchor(anchor) {
     nodes: sanitizeNodes(anchor.nodes)
   };
 }
-function sanitizeReplayElementPath(path11) {
+function sanitizeReplayElementPath(path13) {
   return {
     resolution: "deterministic",
-    context: sanitizeContext(path11.context),
-    nodes: sanitizeNodes(path11.nodes)
+    context: sanitizeContext(path13.context),
+    nodes: sanitizeNodes(path13.nodes)
   };
 }
-function sanitizeElementPath(path11) {
-  return sanitizeReplayElementPath(path11);
+function sanitizeElementPath(path13) {
+  return sanitizeReplayElementPath(path13);
 }
 function buildLocalStructuralElementAnchor(index, rawTargetNode) {
   const targetNode = requireElementNode(index, rawTargetNode);
@@ -9611,8 +9672,8 @@ function buildTargetNotFoundMessage(domPath, diagnostics) {
   }
   return `${base} Target depth ${String(depth)}. Candidate counts: ${sample}.`;
 }
-function buildArrayFieldCandidates(path11) {
-  return buildArrayFieldPathCandidates(path11);
+function buildArrayFieldCandidates(path13) {
+  return buildArrayFieldPathCandidates(path13);
 }
 function firstDefinedAttribute(node, keys) {
   for (const key of keys) {
@@ -9886,24 +9947,31 @@ function collectChildrenInScope(index, node, scopeHostNodeRef) {
 function getShadowScopeNodeRef(index, node) {
   return findContainingShadowHostNode(index, node)?.nodeRef;
 }
+
+// ../runtime-core/src/runtimes/dom/descriptors.ts
 function createDomDescriptorStore(options) {
-  const namespace = normalizeNamespace(options.namespace);
+  const namespace = normalizeDomDescriptorNamespace(options.namespace);
   if (options.root) {
     return new FilesystemDomDescriptorStore(options.root.registry.descriptors, namespace);
   }
   return new MemoryDomDescriptorStore(namespace);
 }
-function descriptionKey(namespace, method, description) {
-  return `dom:${namespace}:${method}:${sha256Hex2(description.trim())}`;
+function hashDomDescriptorDescription(description) {
+  return sha256Hex2(description.trim());
 }
-function normalizeNamespace(namespace) {
+function buildDomDescriptorKey(options) {
+  return `dom:${normalizeDomDescriptorNamespace(options.namespace)}:${options.method}:${hashDomDescriptorDescription(
+    options.description
+  )}`;
+}
+function normalizeDomDescriptorNamespace(namespace) {
   const normalized = String(namespace || "default").trim();
   return normalized.length === 0 ? "default" : normalized;
 }
 function sha256Hex2(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
-function buildPayload(input) {
+function buildDomDescriptorPayload(input) {
   return {
     kind: "dom-target",
     method: input.method,
@@ -9912,6 +9980,9 @@ function buildPayload(input) {
     ...input.sourceUrl === void 0 ? {} : { sourceUrl: input.sourceUrl }
   };
 }
+function buildDomDescriptorVersion(payload) {
+  return sha256Hex2(canonicalJsonString(payload));
+}
 function parseDomDescriptorRecord(record) {
   const payload = record.payload;
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
@@ -9953,7 +10024,11 @@ var FilesystemDomDescriptorStore = class {
   }
   async read(input) {
     const record = await this.registry.resolve({
-      key: descriptionKey(this.namespace, input.method, input.description)
+      key: buildDomDescriptorKey({
+        namespace: this.namespace,
+        method: input.method,
+        description: input.description
+      })
     });
     if (!record) {
       return void 0;
@@ -9961,9 +10036,13 @@ var FilesystemDomDescriptorStore = class {
     return parseDomDescriptorRecord(record);
   }
   async write(input) {
-    const payload = buildPayload(input);
-    const key = descriptionKey(this.namespace, input.method, input.description);
-    const version = sha256Hex2(canonicalJsonString(payload));
+    const payload = buildDomDescriptorPayload(input);
+    const key = buildDomDescriptorKey({
+      namespace: this.namespace,
+      method: input.method,
+      description: input.description
+    });
+    const version = buildDomDescriptorVersion(payload);
     const existing = await this.registry.resolve({ key, version });
     if (existing) {
       const parsed2 = parseDomDescriptorRecord(existing);
@@ -10001,12 +10080,22 @@ var MemoryDomDescriptorStore = class {
   latestByKey = /* @__PURE__ */ new Map();
   recordsByKey = /* @__PURE__ */ new Map();
   async read(input) {
-    return this.latestByKey.get(descriptionKey(this.namespace, input.method, input.description));
+    return this.latestByKey.get(
+      buildDomDescriptorKey({
+        namespace: this.namespace,
+        method: input.method,
+        description: input.description
+      })
+    );
   }
   async write(input) {
-    const payload = buildPayload(input);
-    const key = descriptionKey(this.namespace, input.method, input.description);
-    const version = sha256Hex2(canonicalJsonString(payload));
+    const payload = buildDomDescriptorPayload(input);
+    const key = buildDomDescriptorKey({
+      namespace: this.namespace,
+      method: input.method,
+      description: input.description
+    });
+    const version = buildDomDescriptorVersion(payload);
     const existing = this.recordsByKey.get(key)?.get(version);
     if (existing) {
       return existing;
@@ -10028,7 +10117,7 @@ var MemoryDomDescriptorStore = class {
   }
 };
 
-// src/runtimes/dom/executor.ts
+// ../runtime-core/src/runtimes/dom/executor.ts
 var MAX_DOM_ACTION_ATTEMPTS = 3;
 var DEFAULT_SCROLL_OPTIONS = {
   block: "center",
@@ -10592,7 +10681,7 @@ function pointFallsWithinQuads(point, quads) {
   return quads.some((quad) => rectContainsPoint(quadBounds(quad), point));
 }
 
-// src/runtimes/dom/runtime.ts
+// ../runtime-core/src/runtimes/dom/runtime.ts
 var SnapshotSession = class {
   constructor(engine) {
     this.engine = engine;
@@ -10649,7 +10738,7 @@ var DefaultDomRuntime = class {
   bridge;
   constructor(options) {
     this.engine = options.engine;
-    this.descriptors = createDomDescriptorStore({
+    this.descriptors = options.descriptorStore ?? createDomDescriptorStore({
       ...options.root === void 0 ? {} : { root: options.root },
       ...options.namespace === void 0 ? {} : { namespace: options.namespace }
     });
@@ -10996,21 +11085,21 @@ var DefaultDomRuntime = class {
     return match;
   }
   async resolvePathTarget(session, pageRef, rawPath, source, description, descriptor) {
-    const path11 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path11.context);
-    const target = resolveDomPathInScope(context.index, path11.nodes, context.scope);
+    const path13 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path13.context);
+    const target = resolveDomPathInScope(context.index, path13.nodes, context.scope);
     if (!target) {
-      throwTargetNotFound(context.index, path11.nodes, context.scope);
+      throwTargetNotFound(context.index, path13.nodes, context.scope);
     }
     if (target.node.nodeRef === void 0) {
       throw new Error(
-        `resolved path "${buildPathSelectorHint(path11)}" does not point to a live element`
+        `resolved path "${buildPathSelectorHint(path13)}" 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: path11,
+      replayPath: path13,
       ...source === "path" || source === "descriptor" ? { selectorUsed: target.selector } : {},
       ...descriptor === void 0 ? {} : { descriptor }
     });
@@ -11031,9 +11120,9 @@ var DefaultDomRuntime = class {
     });
   }
   async queryAllByElementPath(session, pageRef, rawPath) {
-    const path11 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path11.context);
-    return queryAllDomPathInScope(context.index, path11.nodes, context.scope).filter(
+    const path13 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path13.context);
+    return queryAllDomPathInScope(context.index, path13.nodes, context.scope).filter(
       (node) => node.nodeRef !== void 0
     ).map((node) => this.createSnapshotTarget(context.snapshot, node));
   }
@@ -11219,16 +11308,16 @@ var DefaultDomRuntime = class {
     const index = createSnapshotIndex(item.snapshot);
     return this.resolveFirstArrayFieldTargetInNode(index, item.node, field.path);
   }
-  resolveFirstArrayFieldTargetInNode(index, rootNode, path11) {
-    const normalizedPath = sanitizeElementPath(path11);
+  resolveFirstArrayFieldTargetInNode(index, rootNode, path13) {
+    const normalizedPath = sanitizeElementPath(path13);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
     }
     return resolveFirstWithinNodeBySelectors(index, rootNode, selectors);
   }
-  resolveUniqueArrayFieldTargetInNode(index, rootNode, path11) {
-    const normalizedPath = sanitizeElementPath(path11);
+  resolveUniqueArrayFieldTargetInNode(index, rootNode, path13) {
+    const normalizedPath = sanitizeElementPath(path13);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
@@ -11317,9 +11406,6 @@ async function clearChromeSingletonEntries(userDataDir) {
   );
 }
 async function sanitizeChromeProfile(userDataDir) {
-  if (!fs.existsSync(userDataDir)) {
-    return;
-  }
   const entries = await promises.readdir(userDataDir).catch(() => []);
   const profileDirs = entries.filter(
     (entry) => entry === "Default" || /^Profile \d+$/i.test(entry)
@@ -11328,9 +11414,6 @@ async function sanitizeChromeProfile(userDataDir) {
 }
 async function sanitizeProfilePreferences(userDataDir, profileDir) {
   const prefsPath = path6.join(userDataDir, profileDir, "Preferences");
-  if (!fs.existsSync(prefsPath)) {
-    return;
-  }
   try {
     const raw = await promises.readFile(prefsPath, "utf8");
     const prefs = JSON.parse(raw);
@@ -12101,8 +12184,8 @@ function buildBrowserWebSocketUrl(httpUrl, webSocketPath) {
   const protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
   return `${protocol}//${httpUrl.host}${normalizeWebSocketPath(webSocketPath)}`;
 }
-function normalizeWebSocketPath(path11) {
-  return path11.startsWith("/") ? path11 : `/${path11}`;
+function normalizeWebSocketPath(path13) {
+  return path13.startsWith("/") ? path13 : `/${path13}`;
 }
 function rewriteBrowserWebSocketHost(browserWsUrl, requestedUrl) {
   try {
@@ -12238,20 +12321,121 @@ function shouldCopyEntry(input) {
 
 // src/local-browser/stealth-init-script.ts
 function generateStealthInitScript(profile) {
-  const encodedProfile = JSON.stringify(profile);
+  const encodedProfile = JSON.stringify({
+    ...profile,
+    platformString: getPlatformString(profile.platform),
+    userAgentData: buildUserAgentData(profile)
+  });
   return `(() => {
   const profile = ${encodedProfile};
+  var define = function(target, key, value) {
+    Object.defineProperty(target, key, {
+      configurable: true,
+      get: typeof value === 'function' ? value : function() { return value; },
+    });
+  };
 
-  // --- navigator.webdriver safety net ---
-  // --disable-blink-features=AutomationControlled handles this at the flag level
-  // and CDP handles it at the protocol level, but some Chrome builds still leak
-  // webdriver=true when --remote-debugging-port is active.
+  // --- navigator / screen mirrors for future pages ---
   if (navigator.webdriver === true) {
     Object.defineProperty(Navigator.prototype, 'webdriver', {
       configurable: true,
       get: function() { return false; },
     });
   }
+  define(Navigator.prototype, 'platform', profile.platformString);
+  define(Navigator.prototype, 'userAgent', profile.userAgent);
+  define(Navigator.prototype, 'language', profile.locale);
+  define(Navigator.prototype, 'languages', [profile.locale, 'en']);
+  define(Navigator.prototype, 'maxTouchPoints', profile.maxTouchPoints);
+  define(window, 'devicePixelRatio', profile.devicePixelRatio);
+  define(window.screen, 'width', profile.screenResolution.width);
+  define(window.screen, 'height', profile.screenResolution.height);
+  define(window.screen, 'availWidth', profile.screenResolution.width);
+  define(window.screen, 'availHeight', profile.screenResolution.height - 40);
+  define(window.screen, 'colorDepth', 24);
+  define(window.screen, 'pixelDepth', 24);
+  define(Navigator.prototype, 'userAgentData', {
+    brands: profile.userAgentData.brands,
+    mobile: false,
+    platform: profile.userAgentData.platform,
+    toJSON: function() {
+      return {
+        brands: this.brands,
+        mobile: this.mobile,
+        platform: this.platform,
+      };
+    },
+    getHighEntropyValues: async function(hints) {
+      var source = {
+        architecture: profile.userAgentData.architecture,
+        bitness: profile.userAgentData.bitness,
+        brands: profile.userAgentData.brands,
+        fullVersionList: profile.userAgentData.fullVersionList,
+        mobile: false,
+        model: '',
+        platform: profile.userAgentData.platform,
+        platformVersion: profile.userAgentData.platformVersion,
+        uaFullVersion: profile.browserVersion,
+        wow64: false,
+      };
+      var values = {};
+      for (var i = 0; i < hints.length; i++) {
+        var hint = hints[i];
+        if (Object.prototype.hasOwnProperty.call(source, hint)) {
+          values[hint] = source[hint];
+        }
+      }
+      return values;
+    },
+  });
+
+  if (typeof Intl !== 'undefined' && Intl.DateTimeFormat) {
+    var originalResolvedOptions = Intl.DateTimeFormat.prototype.resolvedOptions;
+    Intl.DateTimeFormat.prototype.resolvedOptions = function() {
+      var options = originalResolvedOptions.call(this);
+      options.timeZone = profile.timezoneId;
+      return options;
+    };
+  }
+
+  if (Date.prototype.getTimezoneOffset) {
+    var originalGetTimezoneOffset = Date.prototype.getTimezoneOffset;
+    var calculateTimezoneOffset = function(date) {
+      try {
+        var formatter = new Intl.DateTimeFormat('en-US', {
+          timeZone: profile.timezoneId,
+          hour12: false,
+          year: 'numeric',
+          month: '2-digit',
+          day: '2-digit',
+          hour: '2-digit',
+          minute: '2-digit',
+          second: '2-digit',
+        });
+        var parts = formatter.formatToParts(date);
+        var values = {};
+        for (var i = 0; i < parts.length; i++) {
+          if (parts[i].type !== 'literal') {
+            values[parts[i].type] = Number(parts[i].value);
+          }
+        }
+        var utcTime = Date.UTC(
+          values.year,
+          values.month - 1,
+          values.day,
+          values.hour,
+          values.minute,
+          values.second,
+        );
+        return Math.round((date.getTime() - utcTime) / 60000);
+      } catch {
+        return originalGetTimezoneOffset.call(date);
+      }
+    };
+    Date.prototype.getTimezoneOffset = function() {
+      return calculateTimezoneOffset(this);
+    };
+  }
 
   // --- CDP Runtime.enable leak defense ---
   var _wrap = function(name) {
@@ -12325,6 +12509,34 @@ function generateStealthInitScript(profile) {
   }
 })();`;
 }
+function buildUserAgentData(profile) {
+  const majorVersion = profile.browserVersion.split(".")[0] ?? "136";
+  const platformData = {
+    macos: { platform: "macOS", platformVersion: "14.4.0", architecture: "arm" },
+    windows: { platform: "Windows", platformVersion: "15.0.0", architecture: "x86" },
+    linux: { platform: "Linux", platformVersion: "6.5.0", architecture: "x86" }
+  };
+  const platformInfo = platformData[profile.platform];
+  return {
+    architecture: platformInfo.architecture,
+    bitness: "64",
+    brands: [
+      { brand: "Chromium", version: majorVersion },
+      ...profile.browserBrand === "edge" ? [{ brand: "Microsoft Edge", version: majorVersion }] : [{ brand: "Google Chrome", version: majorVersion }],
+      { brand: "Not-A.Brand", version: "99" }
+    ],
+    fullVersionList: [
+      { brand: "Chromium", version: profile.browserVersion },
+      ...profile.browserBrand === "edge" ? [{ brand: "Microsoft Edge", version: profile.browserVersion }] : [{ brand: "Google Chrome", version: profile.browserVersion }],
+      { brand: "Not-A.Brand", version: "99.0.0.0" }
+    ],
+    platform: platformInfo.platform,
+    platformVersion: platformInfo.platformVersion
+  };
+}
+function getPlatformString(platform) {
+  return platform === "macos" ? "MacIntel" : platform === "windows" ? "Win32" : "Linux x86_64";
+}
 
 // src/local-browser/stealth.ts
 var STEALTH_INIT_SCRIPT = `(() => {
@@ -12368,8 +12580,9 @@ var STEALTH_INIT_SCRIPT = `(() => {
   ['debug', 'log', 'info', 'error', 'warn', 'trace', 'dir'].forEach(_wrap);
 })();`;
 async function injectBrowserStealthScripts(context, input = {}) {
-  if (input.profile !== void 0 && input.page !== void 0) {
-    await applyCdpStealthOverrides(context, input.page, input.profile);
+  if (input.profile !== void 0) {
+    await installContextNetworkHeaders(context, input.profile);
+    await installCdpStealthOverrides(context, input.profile, input.page);
   }
   if (typeof context.addInitScript === "function") {
     await context.addInitScript({
@@ -12390,11 +12603,12 @@ function buildUserAgentMetadata(profile) {
     { brand: "Not-A.Brand", version: "99.0.0.0" }
   ];
   const platformMap = {
+    // Chromium keeps the reduced macOS UA token frozen to Intel even on Apple Silicon.
     macos: { platform: "macOS", platformVersion: "14.4.0", architecture: "arm" },
     windows: { platform: "Windows", platformVersion: "15.0.0", architecture: "x86" },
     linux: { platform: "Linux", platformVersion: "6.5.0", architecture: "x86" }
   };
-  const platformInfo = platformMap[profile.platform] ?? platformMap.linux;
+  const platformInfo = platformMap[profile.platform];
   return {
     brands,
     fullVersionList,
@@ -12407,7 +12621,28 @@ function buildUserAgentMetadata(profile) {
     wow64: false
   };
 }
-async function applyCdpStealthOverrides(context, page, profile) {
+async function installCdpStealthOverrides(context, profile, initialPage) {
+  const pages = initialPage === void 0 ? context.pages() : Array.from(/* @__PURE__ */ new Set([initialPage, ...context.pages()]));
+  await Promise.all(pages.map((page) => applyPageOverrides(context, page, profile)));
+  const appliedPages = /* @__PURE__ */ new WeakSet();
+  const applyFuturePageOverrides = async (page) => {
+    if (appliedPages.has(page)) {
+      return;
+    }
+    appliedPages.add(page);
+    await applyPageOverrides(context, page, profile);
+  };
+  if (typeof context.on === "function") {
+    context.on("page", applyFuturePageOverrides);
+  }
+}
+async function installContextNetworkHeaders(context, profile) {
+  if (typeof context.setExtraHTTPHeaders !== "function") {
+    return;
+  }
+  await context.setExtraHTTPHeaders(buildStealthRequestHeaders(profile)).catch(() => void 0);
+}
+async function applyPageOverrides(context, page, profile) {
   const contextWithCdp = context;
   if (typeof contextWithCdp.newCDPSession !== "function") {
     return;
@@ -12419,31 +12654,50 @@ async function applyCdpStealthOverrides(context, page, profile) {
     return;
   }
   try {
-    const platformString = profile.platform === "macos" ? "MacIntel" : profile.platform === "windows" ? "Win32" : "Linux x86_64";
-    await cdp.send("Network.setUserAgentOverride", {
-      userAgent: profile.userAgent,
-      acceptLanguage: `${profile.locale},en;q=0.9`,
-      platform: platformString,
-      userAgentMetadata: buildUserAgentMetadata(profile)
-    });
-    await cdp.send("Emulation.setDeviceMetricsOverride", {
-      width: profile.viewport.width,
-      height: profile.viewport.height,
-      deviceScaleFactor: profile.devicePixelRatio,
-      mobile: false,
-      screenWidth: profile.screenResolution.width,
-      screenHeight: profile.screenResolution.height
-    });
-    await cdp.send("Emulation.setLocaleOverride", {
-      locale: profile.locale
-    }).catch(() => void 0);
-    await cdp.send("Emulation.setTimezoneOverride", {
-      timezoneId: profile.timezoneId
-    }).catch(() => void 0);
-    await cdp.detach();
+    await applyCdpStealthCommands((method, params) => cdp.send(method, params), profile);
   } catch {
+  } finally {
+    await cdp.detach().catch(() => void 0);
   }
 }
+async function applyCdpStealthCommands(send, profile) {
+  await send("Network.setUserAgentOverride", {
+    userAgent: profile.userAgent,
+    acceptLanguage: `${profile.locale},en;q=0.9`,
+    platform: getPlatformString2(profile.platform),
+    userAgentMetadata: buildUserAgentMetadata(profile)
+  });
+  await send("Emulation.setDeviceMetricsOverride", {
+    width: profile.viewport.width,
+    height: profile.viewport.height,
+    deviceScaleFactor: profile.devicePixelRatio,
+    mobile: false,
+    screenWidth: profile.screenResolution.width,
+    screenHeight: profile.screenResolution.height
+  });
+  await send("Emulation.setLocaleOverride", {
+    locale: profile.locale
+  }).catch(() => void 0);
+  await send("Emulation.setTimezoneOverride", {
+    timezoneId: profile.timezoneId
+  }).catch(() => void 0);
+}
+function buildStealthRequestHeaders(profile) {
+  const metadata = buildUserAgentMetadata(profile);
+  return {
+    "Accept-Language": `${profile.locale},en;q=0.9`,
+    "Sec-CH-UA": metadata.brands.map(formatClientHintBrand).join(", "),
+    "Sec-CH-UA-Mobile": "?0",
+    "Sec-CH-UA-Platform": `"${metadata.platform}"`,
+    "User-Agent": profile.userAgent
+  };
+}
+function formatClientHintBrand(brand2) {
+  return `"${brand2.brand}";v="${brand2.version}"`;
+}
+function getPlatformString2(platform) {
+  return platform === "macos" ? "MacIntel" : platform === "windows" ? "Win32" : "Linux x86_64";
+}
 
 // src/local-browser/stealth-profiles.ts
 var PROFILE_PRESETS = [
@@ -12536,8 +12790,53 @@ function pickStealthProfilePreset(overrides) {
   const pool = candidates.length > 0 ? candidates : PROFILE_PRESETS;
   return pool[Math.floor(Math.random() * pool.length)];
 }
+var OPENSTEER_LIVE_SESSION_LAYOUT = "opensteer-session";
+var OPENSTEER_LIVE_SESSION_VERSION = 1;
+function resolveLiveSessionRecordPath(rootPath, provider) {
+  return path6__default.default.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
+}
+function resolveLocalSessionRecordPath(rootPath) {
+  return resolveLiveSessionRecordPath(rootPath, "local");
+}
+function resolveCloudSessionRecordPath(rootPath) {
+  return resolveLiveSessionRecordPath(rootPath, "cloud");
+}
+async function readPersistedSessionRecord(rootPath, provider) {
+  const sessionPath = resolveLiveSessionRecordPath(rootPath, provider);
+  if (!await pathExists(sessionPath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(sessionPath);
+  if (provider === "local" && isPersistedLocalBrowserSessionRecord(parsed)) {
+    return parsed;
+  }
+  if (provider === "cloud" && isPersistedCloudSessionRecord(parsed)) {
+    return parsed;
+  }
+  return void 0;
+}
+async function readPersistedCloudSessionRecord(rootPath) {
+  const record = await readPersistedSessionRecord(rootPath, "cloud");
+  return record?.provider === "cloud" ? record : void 0;
+}
+async function readPersistedLocalBrowserSessionRecord(rootPath) {
+  const record = await readPersistedSessionRecord(rootPath, "local");
+  return record?.provider === "local" ? record : void 0;
+}
+async function writePersistedSessionRecord(rootPath, record) {
+  await writeJsonFileAtomic(resolveLiveSessionRecordPath(rootPath, record.provider), record);
+}
+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);
+}
+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;
+}
 
-// src/internal/engine-selection.ts
+// ../runtime-core/src/internal/engine-selection.ts
 var OPENSTEER_ENGINE_NAMES = ["playwright", "abp"];
 var DEFAULT_OPENSTEER_ENGINE = "playwright";
 function resolveOpensteerEngineName(input = {}) {
@@ -12740,7 +13039,7 @@ var OpensteerBrowserManager = class {
       await this.closePersistentBrowser(workspace);
       await promises.rm(resolveAbpSessionDir(workspace), { recursive: true, force: true });
       await promises.rm(workspace.browserPath, { recursive: true, force: true });
-      await promises.rm(workspace.liveBrowserPath, { force: true });
+      await clearPersistedSessionRecord(workspace.rootPath, "local");
       await ensureDirectory(workspace.browserUserDataDir);
     });
   }
@@ -12751,7 +13050,7 @@ var OpensteerBrowserManager = class {
       await this.closePersistentBrowser(workspace);
       await promises.rm(resolveAbpSessionDir(workspace), { recursive: true, force: true });
       await promises.rm(workspace.browserPath, { recursive: true, force: true });
-      await promises.rm(workspace.liveBrowserPath, { force: true });
+      await clearPersistedSessionRecord(workspace.rootPath, "local");
     });
   }
   async close() {
@@ -12829,12 +13128,12 @@ var OpensteerBrowserManager = class {
         sessionDir: resolveAbpSessionDir(workspace),
         ...launch?.browserExecutablePath === void 0 ? {} : { executablePath: launch.browserExecutablePath }
       };
-      await writeJsonFileAtomic(workspace.liveBrowserPath, liveRecord);
+      await this.writeLivePersistentBrowser(workspace, liveRecord);
       try {
         return await this.createAdoptedAbpEngine(liveRecord);
       } catch (error) {
         await terminateProcess(launched.process.pid ?? 0).catch(() => void 0);
-        await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+        await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
         throw error;
       }
     });
@@ -12917,7 +13216,7 @@ var OpensteerBrowserManager = class {
         executablePath: launched.executablePath,
         userDataDir: workspace.browserUserDataDir
       };
-      await writeJsonFileAtomic(workspace.liveBrowserPath, liveRecord);
+      await this.writeLivePersistentBrowser(workspace, liveRecord);
       try {
         return await this.createAttachedEngine({
           endpoint: launched.endpoint,
@@ -12926,7 +13225,7 @@ var OpensteerBrowserManager = class {
         });
       } catch (error) {
         await terminateProcess(launched.pid).catch(() => void 0);
-        await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+        await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
         throw error;
       }
     });
@@ -12946,7 +13245,10 @@ var OpensteerBrowserManager = class {
       const stealthProfile = resolveStealthProfile(this.contextOptions?.stealthProfile);
       await injectBrowserStealthScripts(
         context,
-        stealthProfile === void 0 ? {} : { profile: stealthProfile, page }
+        stealthProfile === void 0 ? {} : {
+          profile: stealthProfile,
+          page
+        }
       );
       const engine = await enginePlaywright.createPlaywrightBrowserCoreEngine({
         browser,
@@ -13029,7 +13331,7 @@ var OpensteerBrowserManager = class {
       return void 0;
     }
     if (!isProcessRunning(live.pid)) {
-      await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+      await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
       return void 0;
     }
     if (live.engine === "playwright") {
@@ -13048,19 +13350,8 @@ var OpensteerBrowserManager = class {
     return live;
   }
   async readStoredLiveBrowser(workspace) {
-    if (!await pathExists(workspace.liveBrowserPath)) {
-      return void 0;
-    }
-    const live = await readJsonFile(
-      workspace.liveBrowserPath
-    );
-    if (live.engine === "abp") {
-      return live;
-    }
-    return {
-      ...live,
-      engine: "playwright"
-    };
+    const live = await readPersistedLocalBrowserSessionRecord(workspace.rootPath);
+    return live === void 0 ? void 0 : toWorkspaceLiveBrowserRecord(live);
   }
   async resolveLivePersistentEngineName() {
     if (this.mode !== "persistent") {
@@ -13080,7 +13371,7 @@ var OpensteerBrowserManager = class {
   async closePersistentBrowser(workspace) {
     const live = await this.readStoredLiveBrowser(workspace);
     if (!live) {
-      await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+      await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
       return;
     }
     if (live.engine === "playwright") {
@@ -13088,15 +13379,21 @@ var OpensteerBrowserManager = class {
         await requestBrowserClose(live.endpoint).catch(() => void 0);
       }
       if (await waitForProcessExit(live.pid, BROWSER_CLOSE_TIMEOUT_MS)) {
-        await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+        await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
         return;
       }
       await terminateProcess(live.pid).catch(() => void 0);
-      await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+      await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
       return;
     }
     await terminateProcess(live.pid).catch(() => void 0);
-    await promises.rm(workspace.liveBrowserPath, { force: true }).catch(() => void 0);
+    await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+  }
+  async writeLivePersistentBrowser(workspace, live) {
+    await writePersistedSessionRecord(
+      workspace.rootPath,
+      toPersistedLocalBrowserSessionRecord(this.workspace, live)
+    );
   }
   requirePersistentMode(method) {
     if (this.mode !== "persistent" || this.workspace === void 0) {
@@ -13108,6 +13405,38 @@ function normalizeWorkspace(workspace) {
   const normalized = workspace?.trim();
   return normalized === void 0 || normalized.length === 0 ? void 0 : normalized;
 }
+function toPersistedLocalBrowserSessionRecord(workspace, live) {
+  return {
+    layout: "opensteer-session",
+    version: 1,
+    provider: "local",
+    ...workspace === void 0 ? {} : { workspace },
+    engine: live.engine,
+    ...live.endpoint === void 0 ? {} : { endpoint: live.endpoint },
+    ...live.baseUrl === void 0 ? {} : { baseUrl: live.baseUrl },
+    ...live.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: live.remoteDebuggingUrl },
+    ...live.sessionDir === void 0 ? {} : { sessionDir: live.sessionDir },
+    pid: live.pid,
+    startedAt: live.startedAt,
+    updatedAt: Date.now(),
+    ...live.executablePath === void 0 ? {} : { executablePath: live.executablePath },
+    userDataDir: live.userDataDir
+  };
+}
+function toWorkspaceLiveBrowserRecord(record) {
+  return {
+    mode: "persistent",
+    engine: record.engine,
+    ...record.endpoint === void 0 ? {} : { endpoint: record.endpoint },
+    ...record.baseUrl === void 0 ? {} : { baseUrl: record.baseUrl },
+    ...record.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: record.remoteDebuggingUrl },
+    ...record.sessionDir === void 0 ? {} : { sessionDir: record.sessionDir },
+    pid: record.pid,
+    startedAt: record.startedAt,
+    ...record.executablePath === void 0 ? {} : { executablePath: record.executablePath },
+    userDataDir: record.userDataDir
+  };
+}
 function resolveBrowserMode(workspace, browser) {
   if (browser === void 0) {
     return workspace === void 0 ? "temporary" : "persistent";
@@ -13187,9 +13516,7 @@ function buildChromeArgs(userDataDir, launch, viewport) {
   if (isHeadless) {
     args.push("--headless=new");
   }
-  const hasUserWindowSize = (launch?.args ?? []).some(
-    (entry) => entry.startsWith("--window-size")
-  );
+  const hasUserWindowSize = (launch?.args ?? []).some((entry) => entry.startsWith("--window-size"));
   if (!hasUserWindowSize) {
     const width = viewport?.width ?? 1440;
     const height = viewport?.height ?? 900;
@@ -13387,7 +13714,14 @@ async function sleep(ms) {
   await new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 
-// src/internal/errors.ts
+// ../runtime-core/package.json
+var package_default = {
+  version: "0.1.0"};
+
+// ../runtime-core/src/version.ts
+var OPENSTEER_RUNTIME_CORE_VERSION = package_default.version;
+
+// ../runtime-core/src/internal/errors.ts
 function normalizeThrownOpensteerError(error, fallbackMessage) {
   if (isOpensteerProtocolError(error)) {
     return toOpensteerError(error);
@@ -13398,15 +13732,6 @@ function normalizeThrownOpensteerError(error, fallbackMessage) {
       ...error.details === void 0 ? {} : { details: error.details }
     });
   }
-  if (error instanceof OpensteerAttachAmbiguousError) {
-    return createOpensteerError("conflict", error.message, {
-      details: {
-        candidates: error.candidates,
-        code: error.code,
-        name: error.name
-      }
-    });
-  }
   if (error instanceof Error) {
     return createOpensteerError("operation-failed", error.message, {
       details: {
@@ -13576,7 +13901,7 @@ function roundScale(value) {
   return Number(value.toFixed(6));
 }
 
-// src/runtimes/computer-use/trace-enrichment.ts
+// ../runtime-core/src/runtimes/computer-use/trace-enrichment.ts
 async function enrichComputerUseTrace(input) {
   const tracePoints = toTracePoints(input.action);
   if (tracePoints.length === 0) {
@@ -13669,7 +13994,7 @@ function toOpensteerResolvedTarget(target) {
   };
 }
 
-// src/runtimes/computer-use/runtime.ts
+// ../runtime-core/src/runtimes/computer-use/runtime.ts
 function createComputerUseRuntime(options) {
   return new DefaultComputerUseRuntime(options);
 }
@@ -13764,7 +14089,7 @@ function normalizeScreenshotOptions(input) {
   };
 }
 
-// src/sdk/semantic-dispatch.ts
+// ../runtime-core/src/sdk/semantic-dispatch.ts
 async function dispatchSemanticOperation(runtime, operation, input, options = {}) {
   switch (operation) {
     case "session.open":
@@ -14025,7 +14350,7 @@ async function dispatchSemanticOperation(runtime, operation, input, options = {}
   }
 }
 
-// src/requests/shared.ts
+// ../runtime-core/src/requests/shared.ts
 var REDACTED_HEADER_VALUE = "[redacted]";
 var HTTP_HEADER_NAME_PATTERN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
 var SECRET_HEADER_NAMES = /* @__PURE__ */ new Set([
@@ -14241,14 +14566,14 @@ function resolveTextEncoding(charset) {
   }
 }
 
-// src/requests/errors.ts
+// ../runtime-core/src/requests/errors.ts
 function invalidRequestPlanError(message, details = {}) {
   return new OpensteerProtocolError("invalid-request", message, {
     details
   });
 }
 
-// src/requests/plans/index.ts
+// ../runtime-core/src/requests/plans/index.ts
 var HTTP_METHOD_PATTERN = /^[A-Za-z]+$/;
 var URL_TEMPLATE_PLACEHOLDER_PATTERN = /\{([A-Za-z][A-Za-z0-9_-]*)\}/g;
 function assertValidRequestPlanPayload(payload) {
@@ -14656,7 +14981,7 @@ function normalizeTrimmedString(field, value) {
   return normalized;
 }
 
-// src/requests/inference.ts
+// ../runtime-core/src/requests/inference.ts
 function inferRequestPlanFromNetworkRecord(record, input, options = {}) {
   const url = new URL(record.record.url);
   const defaultQuery = Array.from(url.searchParams.entries()).map(
@@ -14669,9 +14994,10 @@ function inferRequestPlanFromNetworkRecord(record, input, options = {}) {
   const responseContentType = headerValue(record.record.responseHeaders, "content-type") ?? record.record.responseBody?.mimeType;
   const defaultHeaders = inferDefaultHeaders(record);
   const auth = inferAuth(record.record.requestHeaders);
+  const body = inferRequestPlanBody(record.record.requestBody, requestContentType);
   const payload = normalizeRequestPlanPayload({
     transport: {
-      kind: "context-http"
+      kind: input.transport ?? "context-http"
     },
     endpoint: {
       method: record.record.method,
@@ -14679,12 +15005,7 @@ function inferRequestPlanFromNetworkRecord(record, input, options = {}) {
       ...defaultQuery.length === 0 ? {} : { defaultQuery },
       ...defaultHeaders.length === 0 ? {} : { defaultHeaders }
     },
-    ...requestContentType === void 0 && record.record.requestBody === void 0 ? {} : {
-      body: {
-        ...requestContentType === void 0 ? {} : { contentType: requestContentType },
-        required: true
-      }
-    },
+    ...body === void 0 ? {} : { body },
     ...record.record.status === void 0 ? {} : {
       response: {
         status: record.record.status,
@@ -14696,7 +15017,6 @@ function inferRequestPlanFromNetworkRecord(record, input, options = {}) {
   return {
     key: input.key,
     version: input.version,
-    lifecycle: input.lifecycle ?? "draft",
     provenance: {
       source: record.source === "saved" ? "saved-network-record" : "live-network-record",
       sourceId: record.recordId,
@@ -14740,34 +15060,78 @@ function inferAuth(headers) {
   }
   return void 0;
 }
-
-// src/reverse/materialization.ts
-var ALWAYS_OMIT_HEADER_NAMES = /* @__PURE__ */ new Set(["content-length", "host", "priority"]);
-var BROWSER_OWNED_HEADER_PREFIXES = ["sec-"];
-function isManagedRequestHeaderName(name, transport) {
-  const normalized = normalizeHeaderName(name);
-  if (!isValidHttpHeaderName(name)) {
-    return true;
-  }
-  if (normalized.startsWith(":")) {
-    return true;
-  }
-  if (ALWAYS_OMIT_HEADER_NAMES.has(normalized)) {
-    return true;
-  }
-  if (transport !== void 0 && (transport === "page-http" || transport === "session-http")) {
-    if (BROWSER_OWNED_HEADER_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
-      return true;
-    }
-  }
-  return false;
-}
-function stripManagedRequestHeaders(headers, transport) {
-  if (headers === void 0 || headers.length === 0) {
+function inferRequestPlanBody(body, contentType) {
+  if (body === void 0) {
     return void 0;
   }
-  const filtered = headers.filter((header) => !isManagedRequestHeaderName(header.name, transport));
-  return filtered.length === 0 ? void 0 : filtered.map((header) => ({ ...header }));
+  const text = Buffer.from(body.data, "base64").toString("utf8");
+  const normalizedContentType = contentType?.toLowerCase();
+  const trimmedText = text.trim();
+  const parsedJson = parseJsonBody(trimmedText);
+  if (normalizedContentType?.includes("application/json") === true || normalizedContentType?.includes("+json") === true || parsedJson !== void 0) {
+    return {
+      kind: "json",
+      required: true,
+      ...contentType === void 0 ? {} : { contentType },
+      template: parsedJson ?? text
+    };
+  }
+  if (normalizedContentType?.includes("application/x-www-form-urlencoded") === true) {
+    return {
+      kind: "form",
+      required: true,
+      ...contentType === void 0 ? {} : { contentType },
+      fields: Array.from(new URLSearchParams(text).entries()).map(([name, value]) => ({
+        name,
+        value
+      }))
+    };
+  }
+  return {
+    kind: "text",
+    required: true,
+    ...contentType === void 0 ? {} : { contentType },
+    template: text
+  };
+}
+function parseJsonBody(value) {
+  if (value.length === 0 || !value.startsWith("{") && !value.startsWith("[")) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+
+// ../runtime-core/src/reverse/materialization.ts
+var ALWAYS_OMIT_HEADER_NAMES = /* @__PURE__ */ new Set(["content-length", "host", "priority"]);
+var BROWSER_OWNED_HEADER_PREFIXES = ["sec-"];
+function isManagedRequestHeaderName(name, transport) {
+  const normalized = normalizeHeaderName(name);
+  if (!isValidHttpHeaderName(name)) {
+    return true;
+  }
+  if (normalized.startsWith(":")) {
+    return true;
+  }
+  if (ALWAYS_OMIT_HEADER_NAMES.has(normalized)) {
+    return true;
+  }
+  if (transport !== void 0 && (transport === "page-http" || transport === "session-http")) {
+    if (BROWSER_OWNED_HEADER_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
+      return true;
+    }
+  }
+  return false;
+}
+function stripManagedRequestHeaders(headers, transport) {
+  if (headers === void 0 || headers.length === 0) {
+    return void 0;
+  }
+  const filtered = headers.filter((header) => !isManagedRequestHeaderName(header.name, transport));
+  return filtered.length === 0 ? void 0 : filtered.map((header) => ({ ...header }));
 }
 function finalizeMaterializedTransportRequest(request, transport) {
   const headers = stripManagedRequestHeaders(request.headers, transport);
@@ -14777,7 +15141,7 @@ function finalizeMaterializedTransportRequest(request, transport) {
   };
 }
 
-// src/network/diff.ts
+// ../runtime-core/src/network/diff.ts
 function diffNetworkRecords(left, right, input) {
   const requestDiffs = [];
   const responseDiffs = [];
@@ -14937,7 +15301,7 @@ function diffStringMap(prefix, left, right, includeUnchanged, output) {
     diffScalarField(`${prefix}.${key}`, left[key], right[key], includeUnchanged, output);
   }
 }
-function diffScalarField(path11, left, right, includeUnchanged, output) {
+function diffScalarField(path13, 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";
@@ -14945,7 +15309,7 @@ function diffScalarField(path11, left, right, includeUnchanged, output) {
     return;
   }
   output.push({
-    path: path11,
+    path: path13,
     kind,
     ...leftValue === void 0 ? {} : { leftValue },
     ...rightValue === void 0 ? {} : { rightValue },
@@ -15134,7 +15498,7 @@ var NetworkJournal = class {
   }
 };
 
-// src/network/minimize.ts
+// ../runtime-core/src/network/minimize.ts
 function prepareMinimizationRequest(record, preserve = []) {
   const requestUrl = new URL(record.record.url);
   const preservedNames = new Set(
@@ -15547,7 +15911,7 @@ function resolveBodyEncoding2(charset) {
   }
 }
 
-// src/network/probe.ts
+// ../runtime-core/src/network/probe.ts
 var TRANSPORT_PROBE_LADDER = [
   "direct-http",
   "matched-tls",
@@ -15559,7 +15923,7 @@ function selectTransportProbeRecommendation(results) {
   return results.find((entry) => entry.success)?.transport ?? results.at(-1)?.transport ?? "session-http";
 }
 
-// src/reverse/analysis.ts
+// ../runtime-core/src/reverse/analysis.ts
 var TELEMETRY_HOST_PATTERNS = [
   "google-analytics",
   "doubleclick",
@@ -15899,9 +16263,9 @@ function matchReverseTargetHints(channel, codec, targetHints) {
       matches.add(`host:${host}`);
     }
   }
-  for (const path11 of targetHints.paths ?? []) {
-    if (url.pathname.includes(path11)) {
-      matches.add(`path:${path11}`);
+  for (const path13 of targetHints.paths ?? []) {
+    if (url.pathname.includes(path13)) {
+      matches.add(`path:${path13}`);
     }
   }
   for (const operationName of targetHints.operationNames ?? []) {
@@ -16753,7 +17117,7 @@ function looksHighEntropy(value) {
   return uniqueCharacters >= Math.min(20, Math.floor(trimmed.length * 0.6));
 }
 
-// src/reverse/discovery.ts
+// ../runtime-core/src/reverse/discovery.ts
 function clusterReverseObservationRecords(input) {
   const groups = /* @__PURE__ */ new Map();
   for (const item of sortClusterableRecords(input.records)) {
@@ -17060,7 +17424,7 @@ async function readDirSafe(directory) {
   }
 }
 
-// src/reverse/validation.ts
+// ../runtime-core/src/reverse/validation.ts
 function buildReverseValidationRules(input) {
   switch (input.channel.kind) {
     case "http":
@@ -17337,7 +17701,7 @@ function jsonStructureShape(value) {
   return typeof value;
 }
 
-// src/reverse/workflows.ts
+// ../runtime-core/src/reverse/workflows.ts
 function buildReversePackageWorkflow(input) {
   if (input.template === void 0 && input.executeStepInput === void 0) {
     return [];
@@ -17706,7 +18070,7 @@ function dedupeSuggestedEdits(suggestions) {
   return [...new Map(suggestions.map((suggestion) => [suggestion.id, suggestion])).values()];
 }
 
-// src/sdk/extraction-data-path.ts
+// ../runtime-core/src/sdk/extraction-data-path.ts
 function joinDataPath(base, key) {
   const normalizedBase = base.trim();
   const normalizedKey = key.trim();
@@ -17737,8 +18101,8 @@ function encodeDataPath(tokens) {
   }
   return out;
 }
-function parseDataPath(path11) {
-  const input = path11.trim();
+function parseDataPath(path13) {
+  const input = path13.trim();
   if (input.length === 0) {
     return [];
   }
@@ -17788,8 +18152,8 @@ function parseDataPath(path11) {
 function inflateDataPathObject(flat) {
   let root = {};
   let initialized = false;
-  for (const [path11, value] of Object.entries(flat)) {
-    const tokens = parseDataPath(path11);
+  for (const [path13, value] of Object.entries(flat)) {
+    const tokens = parseDataPath(path13);
     if (!tokens || tokens.length === 0) {
       continue;
     }
@@ -17847,7 +18211,7 @@ function assignDataPathValue(root, tokens, value) {
   }
 }
 
-// src/sdk/extraction-consolidation.ts
+// ../runtime-core/src/sdk/extraction-consolidation.ts
 var STRUCTURAL_ATTR_KEYS = /* @__PURE__ */ new Set([
   "class",
   "role",
@@ -18121,8 +18485,8 @@ function buildVariantDescriptorFromCluster(descriptors) {
     fields: mergedFields
   };
 }
-function minimizePathMatchClauses(path11, mode) {
-  const normalized = sanitizeElementPath(path11);
+function minimizePathMatchClauses(path13, mode) {
+  const normalized = sanitizeElementPath(path13);
   const nodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = node.attrs || {};
@@ -18226,8 +18590,8 @@ function seedMinimalAttrClause(attrs) {
   }
   return null;
 }
-function relaxPathForSingleSample(path11, mode) {
-  const normalized = sanitizeElementPath(path11);
+function relaxPathForSingleSample(path13, mode) {
+  const normalized = sanitizeElementPath(path13);
   const relaxedNodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = normalizeAttrsForSingleSample(node.attrs || {});
@@ -18312,8 +18676,8 @@ function shouldKeepAttrForSingleSample(key) {
   }
   return true;
 }
-function buildPathStructureKey(path11) {
-  const normalized = sanitizeElementPath(path11);
+function buildPathStructureKey(path13) {
+  const normalized = sanitizeElementPath(path13);
   return canonicalJsonString({
     context: (normalized.context || []).map((hop) => ({
       kind: hop.kind,
@@ -18440,30 +18804,30 @@ function buildArrayItemNode(fields) {
   }
   return node;
 }
-function insertNodeAtPath(root, path11, node) {
-  const tokens = parseDataPath(path11);
+function insertNodeAtPath(root, path13, node) {
+  const tokens = parseDataPath(path13);
   if (!tokens || !tokens.length) {
     throw new Error(
-      `Invalid persisted extraction path "${path11}": expected a non-empty object path.`
+      `Invalid persisted extraction path "${path13}": expected a non-empty object path.`
     );
   }
   if (tokens.some((token) => token.kind === "index")) {
     throw new Error(
-      `Invalid persisted extraction path "${path11}": nested array indices are not supported in cached descriptors.`
+      `Invalid persisted extraction path "${path13}": 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 "${path11}": expected object segment.`);
+      throw new Error(`Invalid persisted extraction path "${path13}": 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 "${path11}" detected while building descriptor tree.`
+          `Conflicting persisted extraction path "${path13}" detected while building descriptor tree.`
         );
       }
       current[token.key] = node;
@@ -18478,7 +18842,7 @@ function insertNodeAtPath(root, path11, node) {
     }
     if (!isPersistedObjectNode(next)) {
       throw new Error(
-        `Conflicting persisted extraction path "${path11}" detected at "${token.key}".`
+        `Conflicting persisted extraction path "${path13}" detected at "${token.key}".`
       );
     }
     current = next;
@@ -18513,7 +18877,7 @@ function buildItemRootForArrayIndex(entries) {
   }
   const paths = entries.map(
     (entry) => isPersistablePathField(entry.source) ? sanitizeElementPath(entry.source.path) : null
-  ).filter((path11) => path11 !== null);
+  ).filter((path13) => path13 !== null);
   if (!paths.length) {
     return null;
   }
@@ -18534,7 +18898,7 @@ function getCommonPathPrefixLength(paths) {
   if (!paths.length) {
     return 0;
   }
-  const nodeChains = paths.map((path11) => path11.nodes);
+  const nodeChains = paths.map((path13) => path13.nodes);
   const minLength = Math.min(...nodeChains.map((nodes) => nodes.length));
   if (!Number.isFinite(minLength) || minLength <= 0) {
     return 0;
@@ -18603,30 +18967,30 @@ function mergeElementPathsByMajority(paths) {
   if (!paths.length) {
     return null;
   }
-  const normalized = paths.map((path11) => sanitizeElementPath(path11));
+  const normalized = paths.map((path13) => sanitizeElementPath(path13));
   const contextKey = pickModeString(
-    normalized.map((path11) => canonicalJsonString(path11.context)),
+    normalized.map((path13) => canonicalJsonString(path13.context)),
     1
   );
   if (!contextKey) {
     return null;
   }
-  const sameContext = normalized.filter((path11) => canonicalJsonString(path11.context) === contextKey);
+  const sameContext = normalized.filter((path13) => canonicalJsonString(path13.context) === contextKey);
   if (!sameContext.length) {
     return null;
   }
   const targetLength = pickModeNumber(
-    sameContext.map((path11) => path11.nodes.length),
+    sameContext.map((path13) => path13.nodes.length),
     1
   ) ?? sameContext[0]?.nodes.length ?? 0;
-  const aligned = sameContext.filter((path11) => path11.nodes.length === targetLength);
+  const aligned = sameContext.filter((path13) => path13.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((path11) => path11.nodes[index]).filter((node) => node !== void 0);
+    const nodesAtIndex = aligned.map((path13) => path13.nodes[index]).filter((node) => node !== void 0);
     if (!nodesAtIndex.length) {
       return null;
     }
@@ -18872,8 +19236,8 @@ function clonePathContext(context) {
 function clonePathNodes(nodes) {
   return JSON.parse(JSON.stringify(nodes || []));
 }
-function cloneElementPath2(path11) {
-  return JSON.parse(JSON.stringify(path11));
+function cloneElementPath2(path13) {
+  return JSON.parse(JSON.stringify(path13));
 }
 function clonePersistedOpensteerExtractionNode(node) {
   return JSON.parse(JSON.stringify(node));
@@ -18894,7 +19258,7 @@ function isPersistedObjectNode(node) {
   return !!node && typeof node === "object" && !Array.isArray(node) && !isPersistedOpensteerExtractionValueNode(node) && !isPersistedOpensteerExtractionSourceNode(node) && !isPersistedOpensteerExtractionArrayNode(node);
 }
 
-// src/sdk/extraction.ts
+// ../runtime-core/src/sdk/extraction.ts
 function assertValidOpensteerExtractionSchemaRoot(schema) {
   if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
     throw new Error("Invalid extraction schema: expected a JSON object at the top level.");
@@ -18981,7 +19345,7 @@ async function replayOpensteerExtractionPayload(options) {
   return extractPersistedObjectNode(options.pageRef, options.dom, options.payload);
 }
 function createOpensteerExtractionDescriptorStore(options) {
-  const namespace = normalizeNamespace2(options.namespace);
+  const namespace = normalizeNamespace(options.namespace);
   if (options.root) {
     return new FilesystemOpensteerExtractionDescriptorStore(
       options.root.registry.descriptors,
@@ -19159,12 +19523,12 @@ async function resolvePersistableFieldTargets(options) {
         anchor: field.anchor
       }
     });
-    const path11 = resolved.replayPath ?? await options.dom.buildPath({
+    const path13 = resolved.replayPath ?? await options.dom.buildPath({
       locator: resolved.locator
     });
     fields.push({
       key: field.key,
-      path: sanitizeElementPath(path11),
+      path: sanitizeElementPath(path13),
       ...field.attribute === void 0 ? {} : { attribute: field.attribute }
     });
   }
@@ -19247,8 +19611,8 @@ function collectPersistedValueNodeRefs(node) {
     return [
       {
         path: sanitizeElementPath(node.$path),
-        replacePath: (path11) => {
-          node.$path = sanitizeElementPath(path11);
+        replacePath: (path13) => {
+          node.$path = sanitizeElementPath(path13);
         }
       }
     ];
@@ -19262,13 +19626,13 @@ function collectPersistedValueNodeRefs(node) {
   }
   return refs;
 }
-function hasPositionClause(path11) {
-  return path11.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
+function hasPositionClause(path13) {
+  return path13.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
 }
-function stripPositionClauses2(path11) {
+function stripPositionClauses2(path13) {
   return sanitizeElementPath({
-    context: path11.context,
-    nodes: path11.nodes.map((node) => ({
+    context: path13.context,
+    nodes: path13.nodes.map((node) => ({
       ...node,
       match: node.match.filter((clause) => clause.kind !== "position")
     }))
@@ -19478,11 +19842,11 @@ function normalizeSchemaField(value) {
     ...attribute === void 0 ? {} : { attribute }
   };
 }
-function normalizeNamespace2(namespace) {
+function normalizeNamespace(namespace) {
   const normalized = String(namespace ?? "default").trim();
   return normalized.length === 0 ? "default" : normalized;
 }
-function descriptionKey2(namespace, description) {
+function descriptionKey(namespace, description) {
   return `extract:${namespace}:${sha256Hex3(description.trim())}`;
 }
 function parseExtractionDescriptorRecord(record) {
@@ -19585,7 +19949,7 @@ var FilesystemOpensteerExtractionDescriptorStore = class {
   }
   async read(input) {
     const record = await this.registry.resolve({
-      key: descriptionKey2(this.namespace, input.description)
+      key: descriptionKey(this.namespace, input.description)
     });
     return record === void 0 ? void 0 : parseExtractionDescriptorRecord(record);
   }
@@ -19597,7 +19961,7 @@ var FilesystemOpensteerExtractionDescriptorStore = class {
       ...input.schemaHash === void 0 ? {} : { schemaHash: input.schemaHash },
       ...input.sourceUrl === void 0 ? {} : { sourceUrl: input.sourceUrl }
     };
-    const key = descriptionKey2(this.namespace, input.description);
+    const key = descriptionKey(this.namespace, input.description);
     const version = sha256Hex3(canonicalJsonString(payload));
     const existing = await this.registry.resolve({ key, version });
     if (existing) {
@@ -19636,7 +20000,7 @@ var MemoryOpensteerExtractionDescriptorStore = class {
   latestByKey = /* @__PURE__ */ new Map();
   recordsByKey = /* @__PURE__ */ new Map();
   async read(input) {
-    return this.latestByKey.get(descriptionKey2(this.namespace, input.description));
+    return this.latestByKey.get(descriptionKey(this.namespace, input.description));
   }
   async write(input) {
     const payload = {
@@ -19646,7 +20010,7 @@ var MemoryOpensteerExtractionDescriptorStore = class {
       ...input.schemaHash === void 0 ? {} : { schemaHash: input.schemaHash },
       ...input.sourceUrl === void 0 ? {} : { sourceUrl: input.sourceUrl }
     };
-    const key = descriptionKey2(this.namespace, input.description);
+    const key = descriptionKey(this.namespace, input.description);
     const version = sha256Hex3(canonicalJsonString(payload));
     const existing = this.recordsByKey.get(key)?.get(version);
     if (existing) {
@@ -19678,18 +20042,19 @@ function normalizeNonEmptyString2(name, value) {
 function normalizeKey(value) {
   return String(value ?? "").trim();
 }
-function labelForPath(path11) {
-  return path11.trim().length === 0 ? "$" : path11;
+function labelForPath(path13) {
+  return path13.trim().length === 0 ? "$" : path13;
 }
 function sha256Hex3(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
 
-// src/sdk/snapshot/constants.ts
+// ../runtime-core/src/sdk/snapshot/constants.ts
 var OPENSTEER_INTERACTIVE_ATTR = "data-opensteer-interactive";
 var OPENSTEER_HIDDEN_ATTR = "data-opensteer-hidden";
 var OPENSTEER_SCROLLABLE_ATTR = "data-opensteer-scrollable";
 var OPENSTEER_NODE_ID_ATTR = "data-os-node-id";
+var OPENSTEER_SPARSE_COUNTER_ATTR = "data-os-c";
 var OPENSTEER_BOUNDARY_ATTR = "data-os-boundary";
 var OPENSTEER_UNAVAILABLE_ATTR = "data-os-unavailable";
 var OPENSTEER_IFRAME_BOUNDARY_TAG = "os-iframe-root";
@@ -19753,7 +20118,7 @@ var VOID_TAGS = /* @__PURE__ */ new Set([
   "wbr"
 ]);
 
-// src/sdk/snapshot/cleaner.ts
+// ../runtime-core/src/sdk/snapshot/cleaner.ts
 var STRIP_TAGS = /* @__PURE__ */ new Set(["script", "style", "noscript", "meta", "link", "template"]);
 var TEXT_ATTR_MAX = 150;
 var URL_ATTR_MAX = 500;
@@ -20193,8 +20558,83 @@ var VOID_TAGS2 = /* @__PURE__ */ new Set([
   "wbr"
 ]);
 
-// src/sdk/snapshot/compiler.ts
+// ../runtime-core/src/sdk/snapshot/compiler.ts
+async function assignSparseCountersToLiveDom(engine, pageRef) {
+  try {
+    await engine.evaluatePage({
+      pageRef,
+      script: `(() => {
+        let counter = 1;
+        const walk = (root) => {
+          for (const child of root.children) {
+            child.setAttribute('data-os-c', String(counter++));
+            walk(child);
+            if (child.shadowRoot) walk(child.shadowRoot);
+          }
+        };
+        walk(document);
+      })()`
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function syncDenseCountersToLiveDom(engine, pageRef, sparseToDirectMapping) {
+  const mappingObj = Object.fromEntries(sparseToDirectMapping);
+  await engine.evaluatePage({
+    pageRef,
+    script: `((mapping) => {
+      const walk = (root) => {
+        for (const child of root.children) {
+          child.removeAttribute('c');
+          const sparse = child.getAttribute('data-os-c');
+          if (sparse !== null) {
+            const dense = mapping[sparse];
+            if (dense !== undefined) {
+              child.setAttribute('c', String(dense));
+            }
+            child.removeAttribute('data-os-c');
+          }
+          walk(child);
+          if (child.shadowRoot) walk(child.shadowRoot);
+        }
+      };
+      walk(document);
+    })`,
+    args: [mappingObj]
+  });
+}
+function renumberCountersDensely(cleanedHtml, counterRecords) {
+  const $ = cheerio__namespace.load(cleanedHtml, { xmlMode: false });
+  const newRecords = /* @__PURE__ */ new Map();
+  const sparseToDirectMapping = /* @__PURE__ */ new Map();
+  let nextDense = 1;
+  $("[c]").each(function renumberElement() {
+    const el = $(this);
+    const oldC = Number.parseInt(String(el.attr("c") || ""), 10);
+    if (!Number.isFinite(oldC)) {
+      return;
+    }
+    const record = counterRecords.get(oldC);
+    if (!record) {
+      return;
+    }
+    const denseC = nextDense++;
+    el.attr("c", String(denseC));
+    newRecords.set(denseC, { ...record, element: denseC });
+    if (record.sparseCounter !== void 0) {
+      sparseToDirectMapping.set(record.sparseCounter, denseC);
+    }
+  });
+  return {
+    html: $.html(),
+    counterRecords: newRecords,
+    sparseToDirectMapping
+  };
+}
 async function compileOpensteerSnapshot(options) {
+  const liveCountersEnabled = await assignSparseCountersToLiveDom(options.engine, options.pageRef);
   const pageInfo = await options.engine.getPageInfo({ pageRef: options.pageRef });
   const mainSnapshot = await getMainDocumentSnapshot(options.engine, options.pageRef);
   const snapshotsByDocumentRef = await collectDocumentSnapshots(options.engine, mainSnapshot);
@@ -20213,13 +20653,24 @@ async function compileOpensteerSnapshot(options) {
   const compiledHtml = assignCounters(rawHtml, renderedNodes);
   const cleanedHtml = options.mode === "extraction" ? cleanForExtraction(compiledHtml.html) : cleanForAction(compiledHtml.html);
   const filtered = retainVisibleCounterRecords(cleanedHtml, compiledHtml.counterRecords);
+  const dense = renumberCountersDensely(cleanedHtml, filtered);
+  if (liveCountersEnabled && dense.sparseToDirectMapping.size > 0) {
+    try {
+      await syncDenseCountersToLiveDom(
+        options.engine,
+        options.pageRef,
+        dense.sparseToDirectMapping
+      );
+    } catch {
+    }
+  }
   return {
     url: pageInfo.url,
     title: pageInfo.title,
     mode: options.mode,
-    html: cleanedHtml,
-    counters: [...filtered.values()].map(toPublicCounterRecord),
-    counterRecords: filtered
+    html: dense.html,
+    counters: [...dense.counterRecords.values()].map(toPublicCounterRecord),
+    counterRecords: dense.counterRecords
   };
 }
 async function getMainDocumentSnapshot(engine, pageRef) {
@@ -20448,6 +20899,9 @@ function assignCounters(rawHtml, renderedNodes) {
     if (!rendered) {
       return;
     }
+    const rawSparseCounter = el.attr(OPENSTEER_SPARSE_COUNTER_ATTR);
+    el.removeAttr(OPENSTEER_SPARSE_COUNTER_ATTR);
+    const sparseCounter = rawSparseCounter ? Number.parseInt(rawSparseCounter, 10) : void 0;
     const counter = nextCounter++;
     el.attr("c", String(counter));
     counterRecords.set(counter, {
@@ -20465,7 +20919,8 @@ function assignCounters(rawHtml, renderedNodes) {
       shadowDepth: rendered.shadowDepth,
       interactive: rendered.interactive,
       locator: rendered.locator,
-      anchor: rendered.anchor
+      anchor: rendered.anchor,
+      ...sparseCounter !== void 0 && Number.isFinite(sparseCounter) ? { sparseCounter } : {}
     });
   });
   return {
@@ -20744,7 +21199,7 @@ async function beautifyScriptContent(content) {
   });
 }
 
-// src/scripts/deobfuscate.ts
+// ../runtime-core/src/scripts/deobfuscate.ts
 async function deobfuscateScriptContent(input) {
   const webcrack = await loadWebcrack();
   const result = await webcrack(input.content, {
@@ -20802,7 +21257,7 @@ function inferTransforms(original, deobfuscated) {
   return [...inferred];
 }
 
-// src/scripts/sandbox-shims/minimal.ts
+// ../runtime-core/src/scripts/sandbox-shims/minimal.ts
 function createMinimalSandboxGlobals(options) {
   return {
     console: options.console,
@@ -20826,7 +21281,7 @@ function createMinimalSandboxGlobals(options) {
   };
 }
 
-// src/scripts/sandbox-shims/standard.ts
+// ../runtime-core/src/scripts/sandbox-shims/standard.ts
 function createStandardSandboxGlobals(options) {
   const globals = createMinimalSandboxGlobals(options);
   const eventApi = createEventTargetApi();
@@ -21097,7 +21552,7 @@ function normalizeErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/scripts/sandbox-shims/full.ts
+// ../runtime-core/src/scripts/sandbox-shims/full.ts
 function createFullSandboxGlobals(options) {
   const globals = createStandardSandboxGlobals(options);
   const eventListeners = /* @__PURE__ */ new WeakMap();
@@ -21217,7 +21672,7 @@ function createFullSandboxGlobals(options) {
   };
 }
 
-// src/scripts/sandbox.ts
+// ../runtime-core/src/scripts/sandbox.ts
 async function runScriptSandbox(input) {
   const startedAt = Date.now();
   const errors = [];
@@ -21441,7 +21896,7 @@ function normalizeErrorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/captcha/solver-capsolver.ts
+// ../runtime-core/src/captcha/solver-capsolver.ts
 var CAPSOLVER_CREATE_TASK_URL = "https://api.capsolver.com/createTask";
 var CAPSOLVER_GET_TASK_RESULT_URL = "https://api.capsolver.com/getTaskResult";
 function createCapSolver(apiKey) {
@@ -21539,7 +21994,7 @@ function sleep2(ms, signal) {
   });
 }
 
-// src/captcha/solver-2captcha.ts
+// ../runtime-core/src/captcha/solver-2captcha.ts
 var TWO_CAPTCHA_CREATE_TASK_URL = "https://api.2captcha.com/createTask";
 var TWO_CAPTCHA_GET_TASK_RESULT_URL = "https://api.2captcha.com/getTaskResult";
 function createTwoCaptchaSolver(apiKey) {
@@ -21637,7 +22092,7 @@ function sleep3(ms, signal) {
   });
 }
 
-// src/captcha/detect.ts
+// ../runtime-core/src/captcha/detect.ts
 var CAPTCHA_DETECTION_SCRIPT = `(() => {
   const pageUrl = location.href;
   const findSiteKey = (selectors) => {
@@ -21699,7 +22154,7 @@ async function detectCaptchaOnPage(engine, pageRef) {
   return candidate;
 }
 
-// src/captcha/inject.ts
+// ../runtime-core/src/captcha/inject.ts
 async function injectCaptchaToken(input) {
   const result = await input.engine.evaluatePage({
     pageRef: input.pageRef,
@@ -21755,7 +22210,7 @@ var CAPTCHA_INJECTION_SCRIPT = `(({ type, token }) => {
   return true;
 })`;
 
-// src/interaction/diff.ts
+// ../runtime-core/src/interaction/diff.ts
 function diffInteractionTraces(left, right) {
   const eventSequenceMismatches = [];
   const eventPropertyMismatches = [];
@@ -21824,20 +22279,19 @@ function diffInteractionTraces(left, right) {
   };
 }
 
-// src/sdk/runtime.ts
+// ../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('index.cjs', document.baseURI).href)));
-var OpensteerRuntime = class {
+var OpensteerSessionRuntime = class {
   workspace;
   rootPath;
-  publicWorkspace;
-  configuredBrowser;
-  configuredLaunch;
-  configuredContext;
-  configuredEngineName;
+  workspaceName;
   injectedEngine;
   engineFactory;
   policy;
+  injectedDescriptorStore;
+  registryOverrides;
   cleanupRootOnClose;
+  sessionInfoBase;
   root;
   engine;
   dom;
@@ -21852,39 +22306,52 @@ var OpensteerRuntime = class {
   cookieJars = /* @__PURE__ */ new Map();
   recipeCache = /* @__PURE__ */ new Map();
   ownsEngine = false;
-  constructor(options = {}) {
-    this.publicWorkspace = options.workspace?.trim() === void 0 || options.workspace?.trim().length === 0 ? void 0 : options.workspace.trim();
-    this.workspace = normalizeNamespace3(options.workspace);
-    this.rootPath = options.rootPath ?? (this.publicWorkspace === void 0 ? path6__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : path6__default.default.resolve(
-      options.rootDir ?? process.cwd(),
-      ".opensteer",
-      "workspaces",
-      encodeURIComponent(this.publicWorkspace)
-    ));
-    this.configuredBrowser = options.browser;
-    this.configuredLaunch = options.launch;
-    this.configuredContext = options.context;
-    this.configuredEngineName = options.engineName;
+  constructor(options) {
+    this.workspace = normalizeNamespace2(options.name);
+    this.workspaceName = options.workspaceName?.trim() === void 0 || options.workspaceName?.trim().length === 0 ? void 0 : options.workspaceName.trim();
+    this.root = options.workspace;
+    this.rootPath = options.workspace?.rootPath ?? options.rootPath ?? path6__default.default.resolve(process.cwd(), ".opensteer", "temporary", crypto.randomUUID());
     this.injectedEngine = options.engine;
-    this.engineFactory = options.engineFactory ?? ((factoryOptions) => {
-      const browser = factoryOptions.browser ?? this.configuredBrowser;
-      const launch = factoryOptions.launch ?? this.configuredLaunch;
-      const context = factoryOptions.context ?? this.configuredContext;
-      return new OpensteerBrowserManager({
-        rootPath: this.rootPath,
-        ...this.publicWorkspace === void 0 ? {} : { workspace: this.publicWorkspace },
-        ...this.configuredEngineName === void 0 ? {} : { engineName: this.configuredEngineName },
-        ...browser === void 0 ? {} : { browser },
-        ...launch === void 0 ? {} : { launch },
-        ...context === void 0 ? {} : { context }
-      }).createEngine();
-    });
+    this.engineFactory = options.engineFactory;
     this.policy = options.policy ?? defaultPolicy();
-    this.cleanupRootOnClose = options.cleanupRootOnClose ?? this.publicWorkspace === void 0;
+    this.injectedDescriptorStore = options.descriptorStore;
+    this.registryOverrides = options.registryOverrides;
+    this.cleanupRootOnClose = options.cleanupRootOnClose ?? options.workspace === void 0;
+    this.sessionInfoBase = options.sessionInfo ?? {};
+    if (this.injectedEngine === void 0 && this.engineFactory === void 0) {
+      throw new Error("OpensteerSessionRuntime requires an engine or engineFactory.");
+    }
+  }
+  async info() {
+    const base = this.sessionInfoBase;
+    return {
+      provider: base.provider ?? {
+        kind: "local",
+        ownership: "owned",
+        engine: "playwright"
+      },
+      ...base.workspace === void 0 ? {} : { workspace: base.workspace },
+      ...this.sessionRef === void 0 ? {} : { sessionId: this.sessionRef },
+      ...this.pageRef === void 0 ? {} : { activePageRef: this.pageRef },
+      reconnectable: base.reconnectable ?? !this.cleanupRootOnClose,
+      capabilities: base.capabilities ?? {
+        semanticOperations: opensteerSemanticOperationNames,
+        instrumentation: {
+          route: true,
+          interceptScript: true,
+          networkStream: false
+        }
+      },
+      ...base.grants === void 0 ? {} : { grants: base.grants },
+      runtime: base.runtime ?? {
+        protocolVersion: OPENSTEER_PROTOCOL_VERSION,
+        runtimeCoreVersion: OPENSTEER_RUNTIME_CORE_VERSION
+      }
+    };
   }
   async open(input = {}, options = {}) {
     assertValidSemanticOperationInput("session.open", input);
-    if (input.workspace !== void 0 && normalizeNamespace3(input.workspace) !== this.workspace) {
+    if (input.workspace !== void 0 && normalizeNamespace2(input.workspace) !== this.workspace) {
       throw new Error(
         `session.open requested workspace "${input.workspace}" but runtime is bound to "${this.workspace}"`
       );
@@ -24300,8 +24767,7 @@ var OpensteerRuntime = class {
     const inferred = inferRequestPlanFromNetworkRecord(record, {
       recordId: candidate.recordId,
       key: input.key,
-      version: input.version,
-      lifecycle: "draft"
+      version: input.version
     });
     const defaultHeaders = inferred.payload.endpoint.defaultHeaders === void 0 ? void 0 : stripManagedRequestHeaders(
       inferred.payload.endpoint.defaultHeaders,
@@ -24929,8 +25395,7 @@ var OpensteerRuntime = class {
           recordId: input.recordId,
           id: record.id,
           key: record.key,
-          version: record.version,
-          lifecycle: record.lifecycle
+          version: record.version
         }
       });
       return record;
@@ -24971,8 +25436,7 @@ var OpensteerRuntime = class {
         data: {
           id: record.id,
           key: record.key,
-          version: record.version,
-          lifecycle: record.lifecycle
+          version: record.version
         }
       });
       return record;
@@ -25018,8 +25482,7 @@ var OpensteerRuntime = class {
         data: {
           id: record.id,
           key: record.key,
-          version: record.version,
-          lifecycle: record.lifecycle
+          version: record.version
         }
       });
       return record;
@@ -25890,18 +26353,12 @@ var OpensteerRuntime = class {
     }
     if (target.kind === "element") {
       const counter = this.latestSnapshot?.counterRecords.get(target.element);
-      if (!counter) {
-        throw new Error(`no counter ${String(target.element)} is available in the latest snapshot`);
-      }
+      const elementTarget = counter ? { kind: "live", locator: counter.locator, anchor: counter.anchor } : { kind: "selector", selector: `[c="${String(target.element)}"]` };
       const resolved2 = await timeout.runStep(
         () => this.requireDom().resolveTarget({
           pageRef,
           method,
-          target: {
-            kind: "live",
-            locator: counter.locator,
-            anchor: counter.anchor
-          }
+          target: elementTarget
         })
       );
       const stablePath2 = resolved2.replayPath ?? await timeout.runStep(
@@ -26251,14 +26708,14 @@ var OpensteerRuntime = class {
     return saved;
   }
   resolveCurrentStateSource() {
-    const browser = this.configuredBrowser;
-    if (browser === void 0 || browser === "temporary") {
-      return "temporary";
+    const ownership = this.sessionInfoBase.provider?.ownership;
+    if (ownership === "attached") {
+      return "attach";
     }
-    if (browser === "persistent") {
+    if (this.workspaceName !== void 0 || this.cleanupRootOnClose === false) {
       return "persistent";
     }
-    return "attach";
+    return "temporary";
   }
   async resolveReverseCaseById(caseId) {
     const record = await (await this.ensureRoot()).registry.reverseCases.getById(caseId);
@@ -27144,7 +27601,7 @@ var OpensteerRuntime = class {
   }
   async touchRequestPlanFreshness(plan) {
     const freshness = touchFreshness(plan.freshness);
-    await this.requireRoot().registry.requestPlans.updateMetadata({
+    await this.requireRoot().registry.requestPlans.updateFreshness({
       id: plan.id,
       ...freshness === void 0 ? {} : { freshness }
     });
@@ -27813,21 +28270,40 @@ var OpensteerRuntime = class {
       };
     }
     const counter = this.latestSnapshot?.counterRecords.get(target.element);
-    if (!counter) {
-      throw new Error(`no counter ${String(target.element)} is available in the latest snapshot`);
+    if (counter) {
+      return {
+        kind: "live",
+        locator: counter.locator,
+        anchor: counter.anchor
+      };
     }
     return {
-      kind: "live",
-      locator: counter.locator,
-      anchor: counter.anchor
+      kind: "selector",
+      selector: `[c="${String(target.element)}"]`
     };
   }
   async ensureRoot() {
-    this.root ??= await createFilesystemOpensteerWorkspace({
-      rootPath: this.rootPath,
-      ...this.publicWorkspace === void 0 ? {} : { workspace: this.publicWorkspace },
-      scope: this.publicWorkspace === void 0 ? "temporary" : "workspace"
-    });
+    if (!this.root) {
+      const workspace = await createFilesystemOpensteerWorkspace({
+        rootPath: this.rootPath,
+        ...this.workspaceName === void 0 ? {} : { workspace: this.workspaceName },
+        scope: this.workspaceName === void 0 ? "temporary" : "workspace"
+      });
+      if (this.registryOverrides) {
+        const overrides = this.registryOverrides;
+        this.root = {
+          ...workspace,
+          registry: {
+            ...workspace.registry,
+            ...overrides.requestPlans === void 0 ? {} : { requestPlans: overrides.requestPlans },
+            ...overrides.authRecipes === void 0 ? {} : { authRecipes: overrides.authRecipes },
+            ...overrides.recipes === void 0 ? {} : { recipes: overrides.recipes }
+          }
+        };
+      } else {
+        this.root = workspace;
+      }
+    }
     return this.root;
   }
   async ensureEngine(overrides = {}) {
@@ -27839,15 +28315,10 @@ var OpensteerRuntime = class {
       this.ownsEngine = false;
       return this.engine;
     }
-    const browser = overrides.browser ?? this.configuredBrowser;
-    const launch = overrides.launch ?? this.configuredLaunch;
-    const context = overrides.context ?? this.configuredContext;
-    const factoryOptions = {
-      ...browser === void 0 ? {} : { browser },
-      ...launch === void 0 ? {} : { launch },
-      ...context === void 0 ? {} : { context }
-    };
-    this.engine = await this.engineFactory(factoryOptions);
+    if (this.engineFactory === void 0) {
+      throw new Error("Opensteer engine factory is not initialized");
+    }
+    this.engine = await this.engineFactory(overrides);
     this.ownsEngine = true;
     return this.engine;
   }
@@ -27858,6 +28329,7 @@ var OpensteerRuntime = class {
       engine,
       root,
       namespace: this.workspace,
+      ...this.injectedDescriptorStore === void 0 ? {} : { descriptorStore: this.injectedDescriptorStore },
       policy: this.policy
     });
     this.computer = createComputerUseRuntime({
@@ -28304,6 +28776,9 @@ function parseContentType2(contentType) {
   };
 }
 function toJsonValueOrNull(value) {
+  if (value === void 0) {
+    return null;
+  }
   return toCanonicalJsonValue(value) ?? null;
 }
 function stringifyRecipeVariableValue(value) {
@@ -28441,7 +28916,6 @@ function buildMinimizedRequestPlan(input) {
       sourceId: input.record.recordId,
       ...input.record.source === "saved" && input.record.savedAt !== void 0 ? { capturedAt: input.record.savedAt } : {}
     },
-    lifecycle: "draft",
     payload: normalizeRequestPlanPayload({
       transport: {
         kind: input.transport
@@ -29101,12 +29575,12 @@ function extractReverseRuntimeValue(value, pointer) {
   }
   return readDotPath(value, pointer);
 }
-function readDotPath(value, path11) {
-  if (path11.length === 0) {
+function readDotPath(value, path13) {
+  if (path13.length === 0) {
     return value;
   }
   let current = value;
-  for (const segment of path11.split(".").filter((entry) => entry.length > 0)) {
+  for (const segment of path13.split(".").filter((entry) => entry.length > 0)) {
     if (current === null || current === void 0) {
       return void 0;
     }
@@ -29579,7 +30053,7 @@ function parseSetCookieHeader(value, requestUrl) {
   }
   const url = new URL(requestUrl);
   let domain = url.hostname;
-  let path11 = defaultCookiePath(url.pathname);
+  let path13 = defaultCookiePath(url.pathname);
   let secure = url.protocol === "https:";
   let expiresAt;
   const cookieValue = rawValueParts.join("=").trim();
@@ -29592,7 +30066,7 @@ function parseSetCookieHeader(value, requestUrl) {
       continue;
     }
     if (key === "path" && attributeValue.length > 0) {
-      path11 = attributeValue;
+      path13 = attributeValue;
       continue;
     }
     if (key === "secure") {
@@ -29618,7 +30092,7 @@ function parseSetCookieHeader(value, requestUrl) {
       name,
       value: cookieValue,
       domain,
-      path: path11,
+      path: path13,
       secure,
       ...expiresAt === void 0 ? {} : { expiresAt }
     }
@@ -30596,7 +31070,7 @@ function directionToDelta(direction, amount) {
       return { x: amount, y: 0 };
   }
 }
-function normalizeNamespace3(value) {
+function normalizeNamespace2(value) {
   const normalized = String(value ?? "default").trim();
   return normalized.length === 0 ? "default" : normalized;
 }
@@ -30642,45 +31116,145 @@ function screenshotMediaType(format2) {
   }
 }
 
-// src/mode/config.ts
-var OPENSTEER_EXECUTION_MODES = ["local", "cloud"];
-function assertExecutionModeSupportsEngine(mode, engine) {
+// src/sdk/runtime.ts
+var OpensteerRuntime = class extends OpensteerSessionRuntime {
+  constructor(options = {}) {
+    const publicWorkspace = normalizeWorkspace2(options.workspace);
+    const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path6__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : resolveFilesystemWorkspacePath({
+      rootDir: path6__default.default.resolve(options.rootDir ?? process.cwd()),
+      workspace: publicWorkspace
+    }));
+    const cleanupRootOnClose = options.cleanupRootOnClose ?? publicWorkspace === void 0;
+    const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
+    assertSupportedEngineOptions({
+      engineName,
+      ...options.browser === void 0 ? {} : { browser: options.browser },
+      ...options.context === void 0 ? {} : { context: options.context }
+    });
+    super(
+      buildSharedRuntimeOptions({
+        name: publicWorkspace ?? "default",
+        rootPath,
+        ...publicWorkspace === void 0 ? {} : { workspaceName: publicWorkspace },
+        ...options.browser === void 0 ? {} : { browser: options.browser },
+        ...options.launch === void 0 ? {} : { launch: options.launch },
+        ...options.context === void 0 ? {} : { context: options.context },
+        engineName,
+        ...options.engine === void 0 ? {} : { engine: options.engine },
+        ...options.engineFactory === void 0 ? {} : { engineFactory: options.engineFactory },
+        ...options.policy === void 0 ? {} : { policy: options.policy },
+        ...options.descriptorStore === void 0 ? {} : { descriptorStore: options.descriptorStore },
+        cleanupRootOnClose
+      })
+    );
+  }
+};
+var OpensteerSessionRuntime2 = class extends OpensteerSessionRuntime {
+  constructor(options) {
+    const rootPath = options.rootPath ?? path6__default.default.resolve(options.rootDir ?? process.cwd());
+    const cleanupRootOnClose = options.cleanupRootOnClose ?? false;
+    const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
+    assertSupportedEngineOptions({
+      engineName,
+      ...options.browser === void 0 ? {} : { browser: options.browser },
+      ...options.context === void 0 ? {} : { context: options.context }
+    });
+    super(
+      buildSharedRuntimeOptions({
+        name: options.name,
+        rootPath,
+        ...options.browser === void 0 ? {} : { browser: options.browser },
+        ...options.launch === void 0 ? {} : { launch: options.launch },
+        ...options.context === void 0 ? {} : { context: options.context },
+        engineName,
+        ...options.engine === void 0 ? {} : { engine: options.engine },
+        ...options.engineFactory === void 0 ? {} : { engineFactory: options.engineFactory },
+        ...options.policy === void 0 ? {} : { policy: options.policy },
+        ...options.descriptorStore === void 0 ? {} : { descriptorStore: options.descriptorStore },
+        cleanupRootOnClose
+      })
+    );
+  }
+};
+function buildSharedRuntimeOptions(input) {
+  const ownership = resolveOwnership(input.browser);
+  const engineFactory = input.engineFactory ?? ((factoryOptions) => new OpensteerBrowserManager({
+    rootPath: input.rootPath,
+    ...input.workspaceName === void 0 ? {} : { workspace: input.workspaceName },
+    engineName: input.engineName,
+    ...(factoryOptions.browser ?? input.browser) === void 0 ? {} : { browser: factoryOptions.browser ?? input.browser },
+    ...(factoryOptions.launch ?? input.launch) === void 0 ? {} : { launch: factoryOptions.launch ?? input.launch },
+    ...(factoryOptions.context ?? input.context) === void 0 ? {} : { context: factoryOptions.context ?? input.context }
+  }).createEngine());
+  return {
+    name: input.name,
+    ...input.workspaceName === void 0 ? {} : { workspaceName: input.workspaceName },
+    rootPath: input.rootPath,
+    ...input.engine === void 0 ? {} : { engine: input.engine },
+    ...input.engine === void 0 ? { engineFactory } : {},
+    ...input.policy === void 0 ? {} : { policy: input.policy },
+    ...input.descriptorStore === void 0 ? {} : { descriptorStore: input.descriptorStore },
+    cleanupRootOnClose: input.cleanupRootOnClose,
+    sessionInfo: {
+      provider: {
+        kind: "local",
+        ownership,
+        engine: input.engineName
+      },
+      ...input.workspaceName === void 0 ? {} : { workspace: input.workspaceName },
+      reconnectable: !input.cleanupRootOnClose
+    }
+  };
+}
+function normalizeWorkspace2(workspace) {
+  if (workspace === void 0) {
+    return void 0;
+  }
+  const trimmed = workspace.trim();
+  return trimmed.length === 0 ? void 0 : trimmed;
+}
+function resolveOwnership(browser) {
+  return typeof browser === "object" && browser.mode === "attach" ? "attached" : "owned";
+}
+
+// src/provider/config.ts
+var OPENSTEER_PROVIDER_KINDS = ["local", "cloud"];
+function assertProviderSupportsEngine(provider, engine) {
   if (engine !== "abp") {
     return;
   }
-  if (mode === "cloud") {
+  if (provider === "cloud") {
     throw new Error(
-      "ABP is not supported in cloud mode. Cloud mode currently requires Playwright."
+      "ABP is not supported for provider=cloud. Cloud provider currently requires Playwright."
     );
   }
 }
-function normalizeOpensteerExecutionMode(value, source = "OPENSTEER_MODE") {
+function normalizeOpensteerProviderKind(value, source = "OPENSTEER_PROVIDER") {
   const normalized = value.trim().toLowerCase();
-  if (normalized === OPENSTEER_EXECUTION_MODES[0] || normalized === OPENSTEER_EXECUTION_MODES[1]) {
+  if (normalized === OPENSTEER_PROVIDER_KINDS[0] || normalized === OPENSTEER_PROVIDER_KINDS[1]) {
     return normalized;
   }
   throw new Error(
-    `${source} must be one of ${OPENSTEER_EXECUTION_MODES.join(", ")}; received "${value}".`
+    `${source} must be one of ${OPENSTEER_PROVIDER_KINDS.join(", ")}; received "${value}".`
   );
 }
-function resolveOpensteerExecutionMode(input = {}) {
-  const explicitFlags = [input.local, input.cloud].filter(Boolean).length;
-  if (explicitFlags > 1) {
-    throw new Error("Choose exactly one execution mode: local or cloud.");
-  }
-  if (input.explicit) {
-    return input.explicit;
-  }
-  if (input.local) {
-    return "local";
-  }
-  if (input.cloud) {
-    return "cloud";
+function resolveOpensteerProvider(input = {}) {
+  if (input.provider) {
+    return {
+      kind: input.provider.kind,
+      source: "explicit"
+    };
   }
-  if (input.environment !== void 0 && input.environment.trim().length > 0) {
-    return normalizeOpensteerExecutionMode(input.environment);
+  if (input.environmentProvider !== void 0 && input.environmentProvider.trim().length > 0) {
+    return {
+      kind: normalizeOpensteerProviderKind(input.environmentProvider),
+      source: "env"
+    };
   }
-  return "local";
+  return {
+    kind: "local",
+    source: "default"
+  };
 }
 var execFile2 = util.promisify(child_process.execFile);
 var DEFAULT_CAPTURE_TIMEOUT_MS = 3e4;
@@ -31077,14 +31651,14 @@ function toPortableBrowserProfileCookieRecord(cookie) {
   if (!name || !domain) {
     return null;
   }
-  const path11 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
+  const path13 = 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: path11,
+    path: path13,
     secure: cookie.secure,
     httpOnly: cookie.httpOnly,
     ...sameSite === void 0 ? {} : { sameSite },
@@ -31261,6 +31835,15 @@ var OpensteerCloudClient = class {
     });
     return await response.json();
   }
+  async issueAccess(sessionId, capabilities) {
+    const response = await this.request(`/v1/sessions/${encodeURIComponent(sessionId)}/access`, {
+      method: "POST",
+      body: {
+        capabilities
+      }
+    });
+    return await response.json();
+  }
   async closeSession(sessionId) {
     const response = await this.request(`/v1/sessions/${encodeURIComponent(sessionId)}`, {
       method: "DELETE"
@@ -31316,6 +31899,34 @@ var OpensteerCloudClient = class {
   async syncBrowserProfileCookies(input) {
     return syncBrowserProfileCookies(this, input);
   }
+  async importSelectorCache(entries) {
+    const response = await this.request("/selector-cache/import", {
+      method: "POST",
+      body: { entries }
+    });
+    return await response.json();
+  }
+  async importRequestPlans(entries) {
+    const response = await this.request("/registry/request-plans/import", {
+      method: "POST",
+      body: { entries }
+    });
+    return await response.json();
+  }
+  async importRecipes(entries) {
+    const response = await this.request("/registry/recipes/import", {
+      method: "POST",
+      body: { entries }
+    });
+    return await response.json();
+  }
+  async importAuthRecipes(entries) {
+    const response = await this.request("/registry/auth-recipes/import", {
+      method: "POST",
+      body: { entries }
+    });
+    return await response.json();
+  }
   buildAuthorizationHeader() {
     return `Bearer ${this.config.apiKey}`;
   }
@@ -31386,22 +31997,26 @@ function wrapCloudFetchError(error, input) {
 
 // src/cloud/config.ts
 function resolveCloudConfig(input = {}) {
-  const mode = resolveOpensteerExecutionMode({
-    ...input.mode === void 0 ? {} : { explicit: input.mode },
-    ...input.enabled === void 0 ? {} : { cloud: input.enabled },
-    ...process.env.OPENSTEER_MODE === void 0 ? {} : { environment: process.env.OPENSTEER_MODE }
+  const provider = resolveOpensteerProvider({
+    ...input.provider === void 0 ? {} : { provider: input.provider },
+    ...input.environmentProvider === void 0 ? {} : { environmentProvider: input.environmentProvider }
   });
-  if (mode !== "cloud") {
+  if (provider.kind !== "cloud") {
     return void 0;
   }
-  const apiKey = input.apiKey ?? process.env.OPENSTEER_API_KEY;
+  const cloudProvider = input.provider?.kind === "cloud" ? input.provider : void 0;
+  const apiKey = cloudProvider?.apiKey ?? process.env.OPENSTEER_API_KEY;
   if (!apiKey || apiKey.trim().length === 0) {
-    throw new Error("Cloud mode requires OPENSTEER_API_KEY or cloud.apiKey.");
+    throw new Error("provider=cloud requires OPENSTEER_API_KEY or provider.apiKey.");
+  }
+  const baseUrl = cloudProvider?.baseUrl ?? process.env.OPENSTEER_BASE_URL;
+  if (!baseUrl || baseUrl.trim().length === 0) {
+    throw new Error("provider=cloud requires OPENSTEER_BASE_URL or provider.baseUrl.");
   }
   return {
     apiKey: apiKey.trim(),
-    baseUrl: (input.baseUrl ?? process.env.OPENSTEER_BASE_URL ?? "https://api.opensteer.dev").trim().replace(/\/+$/, ""),
-    ...input.browserProfile === void 0 ? {} : { browserProfile: input.browserProfile }
+    baseUrl: baseUrl.trim().replace(/\/+$/, ""),
+    ...cloudProvider?.browserProfile === void 0 ? {} : { browserProfile: cloudProvider.browserProfile }
   };
 }
 var OpensteerSemanticRestError = class extends Error {
@@ -31466,58 +32081,475 @@ function isFetchFailure(error) {
   }
   return error.name === "TypeError" || /fetch failed/i.test(error.message);
 }
-
-// src/cloud/session-proxy.ts
-var CLOUD_SESSION_LAYOUT = "opensteer-cloud-session";
-var CLOUD_SESSION_VERSION = 1;
-var TEMPORARY_CLOUD_WORKSPACE_PREFIX = "opensteer-cloud-workspace-";
-var SUPPORTED_CLOUD_OPERATIONS = /* @__PURE__ */ new Set([
-  "session.open",
-  "page.goto",
-  "page.snapshot",
-  "dom.click",
-  "dom.hover",
-  "dom.input",
-  "dom.scroll",
-  "dom.extract",
-  "network.query",
-  "network.save",
-  "network.clear",
-  "request.raw",
-  "request-plan.infer",
-  "request-plan.write",
-  "request-plan.get",
-  "request-plan.list",
-  "request.execute",
-  "computer.execute",
-  "session.close"
-]);
-function resolveCloudSessionRecordPath(rootPath) {
-  return path6__default.default.join(rootPath, "live", "cloud-session.json");
+var OpensteerCloudAutomationError = class extends Error {
+  opensteerError;
+  constructor(error) {
+    super(error.message);
+    this.name = "OpensteerCloudAutomationError";
+    this.opensteerError = error;
+  }
+};
+var OpensteerCloudAutomationClient = class {
+  constructor(cloud, sessionId) {
+    this.cloud = cloud;
+    this.sessionId = sessionId;
+  }
+  socket;
+  connectPromise;
+  pending = /* @__PURE__ */ new Map();
+  routes = /* @__PURE__ */ new Map();
+  grant;
+  async invoke(operation, input) {
+    await this.ensureConnected();
+    const requestId = `automation:${crypto.randomUUID()}`;
+    const message = {
+      protocol: OPENSTEER_PROTOCOL_NAME,
+      version: OPENSTEER_PROTOCOL_VERSION,
+      kind: "invoke",
+      requestId,
+      operation,
+      sentAt: Date.now(),
+      ...input === void 0 ? {} : { input }
+    };
+    return new Promise((resolve5, reject) => {
+      this.pending.set(requestId, {
+        resolve: (value) => resolve5(value),
+        reject
+      });
+      try {
+        this.requireSocket().send(JSON.stringify(message));
+      } catch (error) {
+        this.pending.delete(requestId);
+        reject(error);
+      }
+    });
+  }
+  async getSessionInfo() {
+    const result = await this.invoke("session.info", {});
+    const sessionInfo = result;
+    assertCompatibleRuntimeCoreVersion(sessionInfo);
+    return sessionInfo;
+  }
+  async route(input) {
+    const routeId = `route:${crypto.randomUUID()}`;
+    const registration = await this.invoke("route.register", {
+      routeId,
+      ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef },
+      urlPattern: input.urlPattern,
+      ...input.resourceTypes === void 0 ? {} : { resourceTypes: input.resourceTypes },
+      ...input.times === void 0 ? {} : { times: input.times },
+      includeOriginal: true
+    });
+    this.routes.set(routeId, {
+      kind: "route",
+      routeId,
+      input
+    });
+    return registration;
+  }
+  async interceptScript(input) {
+    const routeId = `route:${crypto.randomUUID()}`;
+    const registration = await this.invoke("route.register", {
+      routeId,
+      ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef },
+      urlPattern: input.urlPattern,
+      resourceTypes: ["script"],
+      ...input.times === void 0 ? {} : { times: input.times },
+      includeOriginal: true
+    });
+    this.routes.set(routeId, {
+      kind: "intercept-script",
+      routeId,
+      input
+    });
+    return registration;
+  }
+  async close() {
+    this.connectPromise = void 0;
+    this.grant = void 0;
+    if (!this.socket) {
+      return;
+    }
+    const socket = this.socket;
+    this.socket = void 0;
+    for (const [requestId, pending] of this.pending) {
+      pending.reject(new Error(`automation connection closed before ${requestId} completed`));
+    }
+    this.pending.clear();
+    await new Promise((resolve5) => {
+      socket.once("close", () => resolve5());
+      socket.close();
+    }).catch(() => void 0);
+  }
+  async ensureConnected() {
+    if (this.socket?.readyState === WebSocket2__default.default.OPEN) {
+      return;
+    }
+    if (this.connectPromise) {
+      await this.connectPromise;
+      return;
+    }
+    this.connectPromise = this.connect();
+    try {
+      await this.connectPromise;
+    } finally {
+      this.connectPromise = void 0;
+    }
+  }
+  async connect() {
+    const grant = await this.issueGrant("automation");
+    const wsUrl = new URL(grant.wsUrl);
+    wsUrl.searchParams.set("token", grant.token);
+    const socket = new WebSocket2__default.default(wsUrl);
+    this.socket = socket;
+    socket.on("message", (data, isBinary) => {
+      if (isBinary) {
+        return;
+      }
+      this.handleMessage(data.toString());
+    });
+    socket.on("close", () => {
+      if (this.socket === socket) {
+        this.socket = void 0;
+      }
+    });
+    socket.on("error", (error) => {
+      for (const pending of this.pending.values()) {
+        pending.reject(error);
+      }
+      this.pending.clear();
+    });
+    await new Promise((resolve5, reject) => {
+      socket.once("open", () => resolve5());
+      socket.once("error", reject);
+    });
+    this.send({
+      protocol: OPENSTEER_PROTOCOL_NAME,
+      version: OPENSTEER_PROTOCOL_VERSION,
+      kind: "hello",
+      sessionId: this.sessionId,
+      grantKind: grant.kind
+    });
+    await this.restoreRoutes();
+  }
+  async restoreRoutes() {
+    const stored = [...this.routes.values()];
+    this.routes.clear();
+    for (const registration of stored) {
+      if (registration.kind === "route") {
+        await this.route(registration.input);
+      } else {
+        await this.interceptScript(registration.input);
+      }
+    }
+  }
+  handleMessage(json) {
+    const message = JSON.parse(json);
+    if (message.protocol !== OPENSTEER_PROTOCOL_NAME) {
+      return;
+    }
+    switch (message.kind) {
+      case "result": {
+        const pending = this.pending.get(message.requestId);
+        if (!pending) {
+          return;
+        }
+        this.pending.delete(message.requestId);
+        pending.resolve(message.data);
+        return;
+      }
+      case "error": {
+        if (!message.requestId) {
+          return;
+        }
+        const pending = this.pending.get(message.requestId);
+        if (!pending) {
+          return;
+        }
+        this.pending.delete(message.requestId);
+        pending.reject(new OpensteerCloudAutomationError(message.error));
+        return;
+      }
+      case "event":
+        void this.handleEvent(message.event, message.data);
+        return;
+      case "pong":
+        return;
+    }
+  }
+  async handleEvent(event, payload) {
+    if (event !== "route.request") {
+      return;
+    }
+    const data = asRecord(payload);
+    const request = asRecord(data.request);
+    const original = asRecord(data.original);
+    const routeId = typeof data.routeId === "string" ? data.routeId : "";
+    const routeRequestId = typeof data.routeRequestId === "string" ? data.routeRequestId : "";
+    if (!routeId || !routeRequestId) {
+      return;
+    }
+    const registration = this.routes.get(routeId);
+    if (!registration) {
+      await this.invoke("route.resolve", {
+        routeRequestId,
+        decision: { kind: "continue" }
+      }).catch(() => void 0);
+      return;
+    }
+    try {
+      const decision = registration.kind === "route" ? await registration.input.handler({
+        request: toRouteRequest(request),
+        fetchOriginal: async () => toFetchedRouteResponse(original)
+      }) : {
+        kind: "fulfill",
+        body: await registration.input.handler({
+          url: typeof request.url === "string" ? request.url : "",
+          content: typeof original.body === "string" ? original.body : "",
+          headers: Array.isArray(original.headers) ? original.headers.filter(isHeaderEntry) : [],
+          status: typeof original.status === "number" ? original.status : 200
+        }),
+        headers: Array.isArray(original.headers) ? original.headers.filter(isHeaderEntry) : [],
+        status: typeof original.status === "number" ? original.status : 200,
+        contentType: findHeaderValue(
+          Array.isArray(original.headers) ? original.headers.filter(isHeaderEntry) : [],
+          "content-type"
+        ) ?? "application/javascript; charset=utf-8"
+      };
+      await this.invoke("route.resolve", {
+        routeRequestId,
+        decision: serializeRouteDecision(decision)
+      }).catch(() => void 0);
+    } catch {
+      await this.invoke("route.resolve", {
+        routeRequestId,
+        decision: { kind: "continue" }
+      }).catch(() => void 0);
+    }
+  }
+  async issueGrant(kind) {
+    if (this.grant && this.grant.kind === kind && this.grant.expiresAt > Date.now() + 1e4) {
+      return this.grant;
+    }
+    const issued = await this.cloud.issueAccess(this.sessionId, [kind]);
+    const grant = issued.grants[kind];
+    if (!grant) {
+      throw new OpensteerCloudAutomationError(
+        createOpensteerError(
+          "permission-denied",
+          `cloud did not issue an ${kind} automation grant`
+        )
+      );
+    }
+    this.grant = grant;
+    return grant;
+  }
+  requireSocket() {
+    if (!this.socket || this.socket.readyState !== WebSocket2__default.default.OPEN) {
+      throw new Error("cloud automation socket is not connected");
+    }
+    return this.socket;
+  }
+  send(message) {
+    this.requireSocket().send(JSON.stringify(message));
+  }
+};
+function assertCompatibleRuntimeCoreVersion(sessionInfo) {
+  const runtimeCoreVersion = sessionInfo.runtime?.runtimeCoreVersion;
+  if (runtimeCoreVersion === void 0) {
+    return;
+  }
+  const expectedMajor = parseMajorVersion(OPENSTEER_RUNTIME_CORE_VERSION);
+  const actualMajor = parseMajorVersion(runtimeCoreVersion);
+  if (expectedMajor === null || actualMajor === null || expectedMajor === actualMajor) {
+    return;
+  }
+  throw new Error(
+    `cloud runtime-core major version ${runtimeCoreVersion} is incompatible with local SDK runtime-core ${OPENSTEER_RUNTIME_CORE_VERSION}`
+  );
 }
-async function readPersistedCloudSessionRecord(rootPath) {
-  const sessionPath = resolveCloudSessionRecordPath(rootPath);
-  if (!await pathExists(sessionPath)) {
-    return void 0;
+function parseMajorVersion(version) {
+  const major = Number.parseInt(version.split(".", 1)[0] ?? "", 10);
+  return Number.isFinite(major) ? major : null;
+}
+function serializeRouteDecision(decision) {
+  if (decision.kind === "continue") {
+    return { kind: "continue" };
   }
-  const parsed = await readJsonFile(sessionPath);
-  if (parsed.layout !== CLOUD_SESSION_LAYOUT || parsed.version !== CLOUD_SESSION_VERSION || parsed.mode !== "cloud" || typeof parsed.sessionId !== "string" || parsed.sessionId.length === 0 || typeof parsed.baseUrl !== "string" || parsed.baseUrl.length === 0 || typeof parsed.startedAt !== "number" || !Number.isFinite(parsed.startedAt) || typeof parsed.updatedAt !== "number" || !Number.isFinite(parsed.updatedAt)) {
+  if (decision.kind === "abort") {
+    return {
+      kind: "abort",
+      ...decision.errorCode === void 0 ? {} : { errorCode: decision.errorCode }
+    };
+  }
+  return {
+    kind: "fulfill",
+    ...decision.status === void 0 ? {} : { status: decision.status },
+    ...decision.headers === void 0 ? {} : { headers: decision.headers },
+    ...decision.body === void 0 ? {} : typeof decision.body === "string" ? { body: decision.body } : { bodyBase64: Buffer.from(decision.body).toString("base64") },
+    ...decision.contentType === void 0 ? {} : { contentType: decision.contentType }
+  };
+}
+function toRouteRequest(record) {
+  const pageRef = typeof record.pageRef === "string" ? record.pageRef : void 0;
+  return {
+    url: typeof record.url === "string" ? record.url : "",
+    method: typeof record.method === "string" ? record.method : "GET",
+    headers: Array.isArray(record.headers) ? record.headers.filter(isHeaderEntry) : [],
+    resourceType: typeof record.resourceType === "string" ? record.resourceType : "other",
+    ...pageRef === void 0 ? {} : { pageRef },
+    ...typeof record.postData === "string" ? {
+      postData: {
+        bytes: Uint8Array.from(Buffer.from(record.postData)),
+        encoding: "identity",
+        truncated: false,
+        capturedByteLength: Buffer.byteLength(record.postData)
+      }
+    } : {}
+  };
+}
+function toFetchedRouteResponse(record) {
+  return {
+    url: typeof record.url === "string" ? record.url : "",
+    status: typeof record.status === "number" ? record.status : 200,
+    statusText: typeof record.statusText === "string" ? record.statusText : "OK",
+    headers: Array.isArray(record.headers) ? record.headers.filter(isHeaderEntry) : [],
+    ...typeof record.body === "string" ? {
+      body: {
+        bytes: Uint8Array.from(Buffer.from(record.body)),
+        encoding: "identity",
+        truncated: false,
+        capturedByteLength: Buffer.byteLength(record.body)
+      }
+    } : {},
+    redirected: Boolean(record.redirected)
+  };
+}
+function findHeaderValue(headers, name) {
+  return headers.find((header) => header.name.toLowerCase() === name)?.value;
+}
+function isHeaderEntry(value) {
+  return value !== null && typeof value === "object" && typeof value.name === "string" && typeof value.value === "string";
+}
+function asRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+
+// src/cloud/registry-sync.ts
+var REGISTRY_SYNC_MAX_PAYLOAD_BYTES = 15e5;
+var REGISTRY_SYNC_MAX_ENTRIES_PER_BATCH = 100;
+async function syncLocalRegistryToCloud(client, workspace, store) {
+  const [descriptors, requestPlans, recipes, authRecipes] = await Promise.all([
+    store.registry.descriptors.list(),
+    store.registry.requestPlans.list(),
+    store.registry.recipes.list(),
+    store.registry.authRecipes.list()
+  ]);
+  const selectorEntries = descriptors.flatMap((record) => {
+    const entry = toSelectorCacheImportEntry(workspace, record);
+    return entry === void 0 ? [] : [entry];
+  });
+  await Promise.all([
+    importInBatches(selectorEntries, (entries) => client.importSelectorCache(entries)),
+    importInBatches(
+      requestPlans.map((record) => toRequestPlanImportEntry(workspace, record)),
+      (entries) => client.importRequestPlans(entries)
+    ),
+    importInBatches(
+      recipes.map((record) => toRegistryImportEntry(workspace, record)),
+      (entries) => client.importRecipes(entries)
+    ),
+    importInBatches(
+      authRecipes.map((record) => toRegistryImportEntry(workspace, record)),
+      (entries) => client.importAuthRecipes(entries)
+    )
+  ]);
+}
+function toSelectorCacheImportEntry(workspace, record) {
+  const descriptor = parseDomDescriptorRecord(record);
+  if (descriptor === void 0) {
     return void 0;
   }
   return {
-    layout: CLOUD_SESSION_LAYOUT,
-    version: CLOUD_SESSION_VERSION,
-    mode: "cloud",
-    ...parsed.workspace === void 0 ? {} : { workspace: parsed.workspace },
-    sessionId: parsed.sessionId,
-    baseUrl: parsed.baseUrl,
-    startedAt: parsed.startedAt,
-    updatedAt: parsed.updatedAt
+    workspace,
+    method: descriptor.payload.method,
+    descriptionHash: hashDomDescriptorDescription(descriptor.payload.description),
+    description: descriptor.payload.description,
+    path: descriptor.payload.path,
+    createdAt: descriptor.createdAt,
+    updatedAt: descriptor.updatedAt
+  };
+}
+function toRegistryImportEntry(workspace, record) {
+  return {
+    workspace,
+    recordId: record.id,
+    key: record.key,
+    version: record.version,
+    contentHash: record.contentHash,
+    tags: record.tags,
+    ...record.provenance === void 0 ? {} : { provenance: record.provenance },
+    payload: record.payload,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
   };
 }
-async function hasPersistedCloudSession(rootPath) {
-  return await readPersistedCloudSessionRecord(rootPath) !== void 0;
+function toRequestPlanImportEntry(workspace, record) {
+  return {
+    workspace,
+    recordId: record.id,
+    key: record.key,
+    version: record.version,
+    contentHash: record.contentHash,
+    tags: record.tags,
+    ...record.provenance === void 0 ? {} : { provenance: record.provenance },
+    payload: record.payload,
+    ...record.freshness === void 0 ? {} : { freshness: record.freshness },
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  };
+}
+async function importInBatches(entries, importBatch) {
+  if (entries.length === 0) {
+    return;
+  }
+  for (const batch of chunkEntries(entries)) {
+    await importBatch(batch);
+  }
+}
+function chunkEntries(entries) {
+  const batches = [];
+  let currentBatch = [];
+  for (const entry of entries) {
+    if (payloadByteLength([entry]) > REGISTRY_SYNC_MAX_PAYLOAD_BYTES) {
+      continue;
+    }
+    if (currentBatch.length === 0) {
+      currentBatch = [entry];
+      continue;
+    }
+    const nextBatch = [...currentBatch, entry];
+    if (nextBatch.length > REGISTRY_SYNC_MAX_ENTRIES_PER_BATCH || payloadByteLength(nextBatch) > REGISTRY_SYNC_MAX_PAYLOAD_BYTES) {
+      batches.push(currentBatch);
+      currentBatch = [entry];
+      continue;
+    }
+    currentBatch = nextBatch;
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  return batches;
 }
+function payloadByteLength(entries) {
+  return Buffer.byteLength(JSON.stringify({ entries }), "utf8");
+}
+
+// src/cloud/session-proxy.ts
+var TEMPORARY_CLOUD_WORKSPACE_PREFIX = "opensteer-cloud-workspace-";
 var CloudSessionProxy = class {
   rootPath;
   workspace;
@@ -31526,6 +32558,7 @@ var CloudSessionProxy = class {
   sessionId;
   sessionBaseUrl;
   client;
+  automation;
   workspaceStore;
   constructor(cloud, options = {}) {
     this.cloud = cloud;
@@ -31546,27 +32579,73 @@ var CloudSessionProxy = class {
       ...input.url === void 0 ? {} : { url: input.url }
     });
   }
+  async info() {
+    const persisted = this.client !== void 0 || this.sessionId !== void 0 ? void 0 : await this.loadPersistedSession();
+    if (this.client === void 0 && this.sessionId === void 0 && persisted !== void 0 && await this.isReusableCloudSession(persisted.sessionId)) {
+      this.bindClient(persisted);
+    }
+    if (this.automation) {
+      try {
+        const sessionInfo = await this.automation.getSessionInfo();
+        return {
+          ...sessionInfo,
+          ...this.workspace === void 0 ? {} : { workspace: this.workspace }
+        };
+      } catch {
+      }
+    }
+    return {
+      provider: {
+        kind: "cloud",
+        ownership: "managed",
+        engine: "playwright",
+        baseUrl: this.cloud.getConfig().baseUrl
+      },
+      ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+      ...this.sessionId === void 0 ? persisted?.sessionId === void 0 ? {} : { sessionId: persisted.sessionId } : { sessionId: this.sessionId },
+      reconnectable: this.workspace !== void 0 || this.sessionId !== void 0 || persisted !== void 0,
+      capabilities: {
+        semanticOperations: opensteerSemanticOperationNames,
+        sessionGrants: ["automation", "view", "cdp"],
+        instrumentation: {
+          route: true,
+          interceptScript: true,
+          networkStream: true
+        }
+      },
+      runtime: {
+        protocolVersion: OPENSTEER_PROTOCOL_VERSION,
+        runtimeCoreVersion: OPENSTEER_RUNTIME_CORE_VERSION
+      }
+    };
+  }
   async listPages(input = {}) {
-    throw unsupportedCloudOperation("page.list");
+    await this.ensureSession();
+    return this.requireClient().invoke("page.list", input);
   }
   async newPage(input = {}) {
-    throw unsupportedCloudOperation("page.new");
+    await this.ensureSession();
+    return this.requireAutomation().invoke("page.new", input);
   }
   async activatePage(input) {
-    throw unsupportedCloudOperation("page.activate");
+    await this.ensureSession();
+    return this.requireClient().invoke("page.activate", input);
   }
   async closePage(input = {}) {
-    throw unsupportedCloudOperation("page.close");
+    await this.ensureSession();
+    return this.requireClient().invoke("page.close", input);
   }
   async goto(input) {
     await this.ensureSession();
     return this.requireClient().invoke("page.goto", input);
   }
   async evaluate(input) {
-    throw unsupportedCloudOperation("page.evaluate");
+    await this.ensureSession();
+    return this.requireAutomation().invoke("page.evaluate", input);
   }
   async addInitScript(input) {
-    throw unsupportedCloudOperation("page.add-init-script");
+    await this.ensureSession();
+    return this.requireClient().invoke("page.add-init-script", input);
   }
   async snapshot(input = {}) {
     await this.ensureSession();
@@ -31601,80 +32680,112 @@ var CloudSessionProxy = class {
     return this.requireClient().invoke("network.save", input);
   }
   async minimizeNetwork(input) {
-    throw unsupportedCloudOperation("network.minimize");
+    await this.ensureSession();
+    return this.requireClient().invoke("network.minimize", input);
   }
   async diffNetwork(input) {
-    throw unsupportedCloudOperation("network.diff");
+    await this.ensureSession();
+    return this.requireClient().invoke("network.diff", input);
   }
   async probeNetwork(input) {
-    throw unsupportedCloudOperation("network.probe");
+    await this.ensureSession();
+    return this.requireClient().invoke("network.probe", input);
   }
   async discoverReverse(input) {
-    throw unsupportedCloudOperation("reverse.discover");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.discover", input);
   }
   async queryReverse(input) {
-    throw unsupportedCloudOperation("reverse.query");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.query", input);
   }
   async createReversePackage(input) {
-    throw unsupportedCloudOperation("reverse.package.create");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.package.create", input);
   }
   async runReversePackage(input) {
-    throw unsupportedCloudOperation("reverse.package.run");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.package.run", input);
   }
   async exportReverse(input) {
-    throw unsupportedCloudOperation("reverse.export");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.export", input);
   }
   async getReverseReport(input) {
-    throw unsupportedCloudOperation("reverse.report");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.report", input);
   }
   async getReversePackage(input) {
-    throw unsupportedCloudOperation("reverse.package.get");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.package.get", input);
   }
   async listReversePackages(input = {}) {
-    throw unsupportedCloudOperation("reverse.package.list");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.package.list", input);
   }
   async patchReversePackage(input) {
-    throw unsupportedCloudOperation("reverse.package.patch");
+    await this.ensureSession();
+    return this.requireClient().invoke("reverse.package.patch", input);
   }
   async captureInteraction(input) {
-    throw unsupportedCloudOperation("interaction.capture");
+    await this.ensureSession();
+    return this.requireClient().invoke("interaction.capture", input);
   }
   async getInteraction(input) {
-    throw unsupportedCloudOperation("interaction.get");
+    await this.ensureSession();
+    return this.requireClient().invoke("interaction.get", input);
   }
   async diffInteraction(input) {
-    throw unsupportedCloudOperation("interaction.diff");
+    await this.ensureSession();
+    return this.requireClient().invoke("interaction.diff", input);
   }
   async replayInteraction(input) {
-    throw unsupportedCloudOperation("interaction.replay");
+    await this.ensureSession();
+    return this.requireClient().invoke("interaction.replay", input);
   }
   async clearNetwork(input = {}) {
     await this.ensureSession();
     return this.requireClient().invoke("network.clear", input);
   }
   async captureScripts(input = {}) {
-    throw unsupportedCloudOperation("scripts.capture");
+    await this.ensureSession();
+    return this.requireClient().invoke("scripts.capture", input);
   }
   async readArtifact(input) {
-    throw unsupportedCloudOperation("artifact.read");
+    await this.ensureSession();
+    return this.requireClient().invoke("artifact.read", input);
   }
   async beautifyScript(input) {
-    throw unsupportedCloudOperation("scripts.beautify");
+    await this.ensureSession();
+    return this.requireClient().invoke("scripts.beautify", input);
   }
   async deobfuscateScript(input) {
-    throw unsupportedCloudOperation("scripts.deobfuscate");
+    await this.ensureSession();
+    return this.requireClient().invoke("scripts.deobfuscate", input);
   }
   async sandboxScript(input) {
-    throw unsupportedCloudOperation("scripts.sandbox");
+    await this.ensureSession();
+    return this.requireClient().invoke("scripts.sandbox", input);
   }
   async solveCaptcha(input) {
-    throw unsupportedCloudOperation("captcha.solve");
+    await this.ensureSession();
+    return this.requireClient().invoke("captcha.solve", input);
   }
   async getCookies(input = {}) {
-    throw unsupportedCloudOperation("inspect.cookies");
+    await this.ensureSession();
+    return this.requireAutomation().invoke("inspect.cookies", input);
+  }
+  async route(input) {
+    await this.ensureSession();
+    return this.requireAutomation().route(input);
+  }
+  async interceptScript(input) {
+    await this.ensureSession();
+    return this.requireAutomation().interceptScript(input);
   }
   async getStorageSnapshot(input = {}) {
-    throw unsupportedCloudOperation("inspect.storage");
+    await this.ensureSession();
+    return this.requireClient().invoke("inspect.storage", input);
   }
   async rawRequest(input) {
     await this.ensureSession();
@@ -31697,28 +32808,36 @@ var CloudSessionProxy = class {
     return this.requireClient().invoke("request-plan.list", input);
   }
   async writeAuthRecipe(input) {
-    throw unsupportedCloudOperation("auth-recipe.write");
+    await this.ensureSession();
+    return this.requireClient().invoke("auth-recipe.write", input);
   }
   async writeRecipe(input) {
-    throw unsupportedCloudOperation("recipe.write");
+    await this.ensureSession();
+    return this.requireClient().invoke("recipe.write", input);
   }
   async getAuthRecipe(input) {
-    throw unsupportedCloudOperation("auth-recipe.get");
+    await this.ensureSession();
+    return this.requireClient().invoke("auth-recipe.get", input);
   }
   async getRecipe(input) {
-    throw unsupportedCloudOperation("recipe.get");
+    await this.ensureSession();
+    return this.requireClient().invoke("recipe.get", input);
   }
   async listAuthRecipes(input = {}) {
-    throw unsupportedCloudOperation("auth-recipe.list");
+    await this.ensureSession();
+    return this.requireClient().invoke("auth-recipe.list", input);
   }
   async listRecipes(input = {}) {
-    throw unsupportedCloudOperation("recipe.list");
+    await this.ensureSession();
+    return this.requireClient().invoke("recipe.list", input);
   }
   async runAuthRecipe(input) {
-    throw unsupportedCloudOperation("auth-recipe.run");
+    await this.ensureSession();
+    return this.requireClient().invoke("auth-recipe.run", input);
   }
   async runRecipe(input) {
-    throw unsupportedCloudOperation("recipe.run");
+    await this.ensureSession();
+    return this.requireClient().invoke("recipe.run", input);
   }
   async request(input) {
     await this.ensureSession();
@@ -31730,9 +32849,9 @@ var CloudSessionProxy = class {
   }
   async close() {
     const session = await this.loadPersistedSession() ?? (this.sessionId === void 0 || this.sessionBaseUrl === void 0 ? void 0 : {
-      layout: CLOUD_SESSION_LAYOUT,
-      version: CLOUD_SESSION_VERSION,
-      mode: "cloud",
+      layout: "opensteer-session",
+      version: 1,
+      provider: "cloud",
       ...this.workspace === void 0 ? {} : { workspace: this.workspace },
       sessionId: this.sessionId,
       baseUrl: this.sessionBaseUrl,
@@ -31749,7 +32868,9 @@ var CloudSessionProxy = class {
         });
       }
     } finally {
+      await this.automation?.close().catch(() => void 0);
       await this.clearPersistedSession();
+      this.automation = void 0;
       this.client = void 0;
       this.sessionId = void 0;
       this.sessionBaseUrl = void 0;
@@ -31765,6 +32886,8 @@ var CloudSessionProxy = class {
       return;
     }
     this.client = void 0;
+    await this.automation?.close().catch(() => void 0);
+    this.automation = void 0;
     this.sessionId = void 0;
     this.sessionBaseUrl = void 0;
   }
@@ -31775,9 +32898,11 @@ var CloudSessionProxy = class {
     assertSupportedCloudBrowserMode(input.browser);
     const persisted = await this.loadPersistedSession();
     if (persisted !== void 0 && await this.isReusableCloudSession(persisted.sessionId)) {
+      await this.syncRegistryToCloud();
       this.bindClient(persisted);
       return;
     }
+    await this.syncRegistryToCloud();
     const session = await this.cloud.createSession({
       ...this.workspace === void 0 ? {} : { name: this.workspace },
       ...input.launch === void 0 ? {} : { browser: input.launch },
@@ -31785,9 +32910,9 @@ var CloudSessionProxy = class {
       ...resolveCloudBrowserProfile(this.cloud, input) === void 0 ? {} : { browserProfile: resolveCloudBrowserProfile(this.cloud, input) }
     });
     const record = {
-      layout: CLOUD_SESSION_LAYOUT,
-      version: CLOUD_SESSION_VERSION,
-      mode: "cloud",
+      layout: "opensteer-session",
+      version: 1,
+      provider: "cloud",
       ...this.workspace === void 0 ? {} : { workspace: this.workspace },
       sessionId: session.sessionId,
       baseUrl: session.baseUrl,
@@ -31797,6 +32922,16 @@ var CloudSessionProxy = class {
     await this.writePersistedSession(record);
     this.bindClient(record);
   }
+  async syncRegistryToCloud() {
+    if (this.workspace === void 0) {
+      return;
+    }
+    try {
+      const workspaceStore = await this.ensureWorkspaceStore();
+      await syncLocalRegistryToCloud(this.cloud, this.workspace, workspaceStore);
+    } catch {
+    }
+  }
   bindClient(record) {
     this.sessionId = record.sessionId;
     this.sessionBaseUrl = record.baseUrl;
@@ -31804,6 +32939,7 @@ var CloudSessionProxy = class {
       baseUrl: record.baseUrl,
       getAuthorizationHeader: async () => this.cloud.buildAuthorizationHeader()
     });
+    this.automation = new OpensteerCloudAutomationClient(this.cloud, record.sessionId);
   }
   async ensureWorkspaceStore() {
     if (this.workspaceStore !== void 0) {
@@ -31822,10 +32958,10 @@ var CloudSessionProxy = class {
   }
   async writePersistedSession(record) {
     const workspace = await this.ensureWorkspaceStore();
-    await writeJsonFileAtomic(resolveCloudSessionRecordPath(workspace.rootPath), record);
+    await writePersistedSessionRecord(workspace.rootPath, record);
   }
   async clearPersistedSession() {
-    await promises.rm(resolveCloudSessionRecordPath(this.rootPath), { force: true }).catch(() => void 0);
+    await clearPersistedSessionRecord(this.rootPath, "cloud").catch(() => void 0);
   }
   async isReusableCloudSession(sessionId) {
     try {
@@ -31844,6 +32980,12 @@ var CloudSessionProxy = class {
     }
     return this.client;
   }
+  requireAutomation() {
+    if (!this.automation) {
+      throw new Error("Cloud automation session has not been initialized.");
+    }
+    return this.automation;
+  }
 };
 function resolveCloudBrowserProfile(cloud, input) {
   return input.browserProfile ?? cloud.getConfig().browserProfile;
@@ -31859,49 +33001,33 @@ function assertSupportedCloudBrowserMode(browser) {
 function isMissingCloudSessionError(error) {
   return error instanceof Error && /\b404\b/.test(error.message);
 }
-function unsupportedCloudOperation(operation) {
-  return new OpensteerProtocolError(
-    "unsupported-operation",
-    `Cloud mode does not currently support ${operation}.`,
-    {
-      details: {
-        mode: "cloud",
-        operation,
-        supportedOperations: [...SUPPORTED_CLOUD_OPERATIONS]
-      }
-    }
-  );
-}
 
 // src/sdk/runtime-resolution.ts
 function resolveOpensteerRuntimeConfig(input = {}) {
-  const mode = resolveOpensteerExecutionMode({
-    ...input.mode === void 0 ? {} : { explicit: input.mode },
-    cloud: input.cloud !== void 0 && input.cloud !== false,
-    ...input.environmentMode === void 0 ? {} : { environment: input.environmentMode }
+  const provider = resolveOpensteerProvider({
+    ...input.provider === void 0 ? {} : { provider: input.provider },
+    ...input.environmentProvider === void 0 ? {} : { environmentProvider: input.environmentProvider }
   });
-  if (mode === "cloud") {
+  if (provider.kind === "cloud") {
     return {
-      mode,
+      provider,
       cloud: resolveCloudConfig({
-        enabled: true,
-        ...typeof input.cloud === "object" ? input.cloud : {},
-        mode
+        ...input.provider === void 0 ? {} : { provider: input.provider },
+        ...input.environmentProvider === void 0 ? {} : { environmentProvider: input.environmentProvider }
       })
     };
   }
-  return { mode };
+  return { provider };
 }
 function createOpensteerSemanticRuntime(input = {}) {
   const runtimeOptions = input.runtimeOptions ?? {};
   const engine = input.engine ?? runtimeOptions.engineName ?? DEFAULT_OPENSTEER_ENGINE;
   const config = resolveOpensteerRuntimeConfig({
-    ...input.cloud === void 0 ? {} : { cloud: input.cloud },
-    ...input.mode === void 0 ? {} : { mode: input.mode },
-    ...process.env.OPENSTEER_MODE === void 0 ? {} : { environmentMode: process.env.OPENSTEER_MODE }
+    ...input.provider === void 0 ? {} : { provider: input.provider },
+    ...process.env.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: process.env.OPENSTEER_PROVIDER }
   });
-  assertExecutionModeSupportsEngine(config.mode, engine);
-  if (config.mode === "cloud") {
+  assertProviderSupportsEngine(config.provider.kind, engine);
+  if (config.provider.kind === "cloud") {
     return new CloudSessionProxy(new OpensteerCloudClient(config.cloud), {
       ...runtimeOptions.rootDir === void 0 ? {} : { rootDir: runtimeOptions.rootDir },
       ...runtimeOptions.rootPath === void 0 ? {} : { rootPath: runtimeOptions.rootPath },
@@ -31921,38 +33047,37 @@ var Opensteer = class {
   browserManager;
   browser;
   constructor(options = {}) {
+    const { provider, engineName, ...runtimeOptions } = options;
     const runtimeConfig = resolveOpensteerRuntimeConfig({
-      ...options.cloud === void 0 ? {} : { cloud: options.cloud },
-      ...process.env.OPENSTEER_MODE === void 0 ? {} : { environmentMode: process.env.OPENSTEER_MODE }
+      ...provider === void 0 ? {} : { provider },
+      ...process.env.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: process.env.OPENSTEER_PROVIDER }
     });
-    if (runtimeConfig.mode === "cloud") {
+    if (runtimeConfig.provider.kind === "cloud") {
       this.browserManager = void 0;
       this.runtime = createOpensteerSemanticRuntime({
-        mode: runtimeConfig.mode,
-        ...options.cloud === void 0 ? {} : { cloud: options.cloud },
-        ...options.engineName === void 0 ? {} : { engine: options.engineName },
+        ...provider === void 0 ? {} : { provider },
+        ...engineName === void 0 ? {} : { engine: engineName },
         runtimeOptions: {
-          ...options
+          ...runtimeOptions
         }
       });
       this.browser = createUnsupportedBrowserController();
       return;
     }
     this.browserManager = new OpensteerBrowserManager({
-      ...options.rootDir === void 0 ? {} : { rootDir: options.rootDir },
-      ...options.rootPath === void 0 ? {} : { rootPath: options.rootPath },
-      ...options.workspace === void 0 ? {} : { workspace: options.workspace },
-      ...options.engineName === void 0 ? {} : { engineName: options.engineName },
-      ...options.browser === void 0 ? {} : { browser: options.browser },
-      ...options.launch === void 0 ? {} : { launch: options.launch },
-      ...options.context === void 0 ? {} : { context: options.context }
+      ...runtimeOptions.rootDir === void 0 ? {} : { rootDir: runtimeOptions.rootDir },
+      ...runtimeOptions.rootPath === void 0 ? {} : { rootPath: runtimeOptions.rootPath },
+      ...runtimeOptions.workspace === void 0 ? {} : { workspace: runtimeOptions.workspace },
+      ...engineName === void 0 ? {} : { engineName },
+      ...runtimeOptions.browser === void 0 ? {} : { browser: runtimeOptions.browser },
+      ...runtimeOptions.launch === void 0 ? {} : { launch: runtimeOptions.launch },
+      ...runtimeOptions.context === void 0 ? {} : { context: runtimeOptions.context }
     });
     this.runtime = createOpensteerSemanticRuntime({
-      mode: runtimeConfig.mode,
-      ...options.cloud === void 0 ? {} : { cloud: options.cloud },
-      ...options.engineName === void 0 ? {} : { engine: options.engineName },
+      ...provider === void 0 ? {} : { provider },
+      ...engineName === void 0 ? {} : { engine: engineName },
       runtimeOptions: {
-        ...options,
+        ...runtimeOptions,
         rootPath: this.browserManager.rootPath,
         cleanupRootOnClose: this.browserManager.cleanupRootOnDisconnect
       }
@@ -31967,6 +33092,9 @@ var Opensteer = class {
   async open(input = {}) {
     return this.runtime.open(typeof input === "string" ? { url: input } : input);
   }
+  async info() {
+    return this.runtime.info();
+  }
   async listPages(input = {}) {
     return this.runtime.listPages(input);
   }
@@ -31998,10 +33126,6 @@ var Opensteer = class {
     } : input;
     return this.runtime.addInitScript(normalized);
   }
-  async snapshot(input = {}) {
-    const mode = typeof input === "string" ? input : input.mode;
-    return this.runtime.snapshot(mode === void 0 ? {} : { mode });
-  }
   async click(input) {
     const normalized = normalizeTargetOptions(input);
     return this.runtime.click(normalized);
@@ -32081,6 +33205,9 @@ var Opensteer = class {
       await delay2(pollIntervalMs);
     }
   }
+  async snapshot(input = {}) {
+    return this.runtime.snapshot(typeof input === "string" ? { mode: input } : input);
+  }
   async saveNetwork(input) {
     return this.runtime.saveNetwork(input);
   }
@@ -32225,12 +33352,15 @@ var Opensteer = class {
     await this.runtime.disconnect();
   }
   requireOwnedInstrumentationRuntime(method) {
-    if (this.runtime instanceof OpensteerRuntime) {
+    if (isInstrumentableRuntime(this.runtime)) {
       return this.runtime;
     }
-    throw new Error(`${method}() is only available on owned local SDK sessions.`);
+    throw new Error(`${method}() is not available for this session runtime.`);
   }
 };
+function isInstrumentableRuntime(runtime) {
+  return typeof runtime.route === "function" && typeof runtime.interceptScript === "function";
+}
 function createUnsupportedBrowserController() {
   const fail = async () => {
     throw new Error("browser.* helpers are only available in local mode.");
@@ -32297,11 +33427,14 @@ exports.OpensteerAttachAmbiguousError = OpensteerAttachAmbiguousError;
 exports.OpensteerBrowserManager = OpensteerBrowserManager;
 exports.OpensteerCloudClient = OpensteerCloudClient;
 exports.OpensteerRuntime = OpensteerRuntime;
+exports.OpensteerSessionRuntime = OpensteerSessionRuntime2;
 exports.STABLE_PRIMARY_ATTR_KEYS = STABLE_PRIMARY_ATTR_KEYS;
+exports.assertProviderSupportsEngine = assertProviderSupportsEngine;
 exports.buildArrayFieldPathCandidates = buildArrayFieldPathCandidates;
 exports.buildPathCandidates = buildPathCandidates;
 exports.buildPathSelectorHint = buildPathSelectorHint;
 exports.buildSegmentSelector = buildSegmentSelector;
+exports.clearPersistedSessionRecord = clearPersistedSessionRecord;
 exports.cloneElementPath = cloneElementPath;
 exports.cloneReplayElementPath = cloneReplayElementPath;
 exports.cloneStructuralElementAnchor = cloneStructuralElementAnchor;
@@ -32316,23 +33449,26 @@ exports.defaultTimeoutPolicy = defaultTimeoutPolicy;
 exports.delayWithSignal = delayWithSignal;
 exports.discoverLocalCdpBrowsers = discoverLocalCdpBrowsers;
 exports.dispatchSemanticOperation = dispatchSemanticOperation;
-exports.hasPersistedCloudSession = hasPersistedCloudSession;
 exports.inspectCdpEndpoint = inspectCdpEndpoint;
 exports.isCurrentUrlField = isCurrentUrlField;
 exports.isValidCssAttributeKey = isValidCssAttributeKey;
 exports.listLocalChromeProfiles = listLocalChromeProfiles;
 exports.normalizeExtractedValue = normalizeExtractedValue;
 exports.normalizeOpensteerEngineName = normalizeOpensteerEngineName;
-exports.normalizeOpensteerExecutionMode = normalizeOpensteerExecutionMode;
+exports.normalizeOpensteerProviderKind = normalizeOpensteerProviderKind;
 exports.normalizeWorkspaceId = normalizeWorkspaceId;
 exports.readPersistedCloudSessionRecord = readPersistedCloudSessionRecord;
+exports.readPersistedLocalBrowserSessionRecord = readPersistedLocalBrowserSessionRecord;
+exports.readPersistedSessionRecord = readPersistedSessionRecord;
 exports.resolveCloudConfig = resolveCloudConfig;
 exports.resolveCloudSessionRecordPath = resolveCloudSessionRecordPath;
 exports.resolveDomActionBridge = resolveDomActionBridge;
 exports.resolveExtractedValueInContext = resolveExtractedValueInContext;
 exports.resolveFilesystemWorkspacePath = resolveFilesystemWorkspacePath;
+exports.resolveLiveSessionRecordPath = resolveLiveSessionRecordPath;
+exports.resolveLocalSessionRecordPath = resolveLocalSessionRecordPath;
 exports.resolveOpensteerEngineName = resolveOpensteerEngineName;
-exports.resolveOpensteerExecutionMode = resolveOpensteerExecutionMode;
+exports.resolveOpensteerProvider = resolveOpensteerProvider;
 exports.resolveOpensteerRuntimeConfig = resolveOpensteerRuntimeConfig;
 exports.runWithPolicyTimeout = runWithPolicyTimeout;
 exports.sanitizeElementPath = sanitizeElementPath;
@@ -32340,5 +33476,6 @@ exports.sanitizeReplayElementPath = sanitizeReplayElementPath;
 exports.sanitizeStructuralElementAnchor = sanitizeStructuralElementAnchor;
 exports.settleWithPolicy = settleWithPolicy;
 exports.shouldKeepAttributeForPath = shouldKeepAttributeForPath;
+exports.writePersistedSessionRecord = writePersistedSessionRecord;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map