opensteer 0.9.0 → 0.9.1

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var path7 = require('path');
+var path10 = require('path');
 var crypto = require('crypto');
 var promises = require('fs/promises');
 var url = require('url');
@@ -10,6 +10,7 @@ var os = require('os');
 var enginePlaywright = require('@opensteer/engine-playwright');
 var util = require('util');
 var fs = require('fs');
+var module$1 = require('module');
 var zlib = require('zlib');
 var async_hooks = require('async_hooks');
 var sharp = require('sharp');
@@ -18,6 +19,7 @@ var prettier = require('prettier');
 var vm = require('vm');
 var WebSocket2 = require('ws');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 function _interopNamespace(e) {
@@ -38,7 +40,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var path7__default = /*#__PURE__*/_interopDefault(path7);
+var path10__default = /*#__PURE__*/_interopDefault(path10);
 var sharp__default = /*#__PURE__*/_interopDefault(sharp);
 var cheerio__namespace = /*#__PURE__*/_interopNamespace(cheerio);
 var prettier__namespace = /*#__PURE__*/_interopNamespace(prettier);
@@ -60,30 +62,30 @@ function isPlainObject(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function canonicalizeJsonValue(value, path15) {
+function canonicalizeJsonValue(value, path18) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) {
-      throw new TypeError(`${path15} must be a finite JSON number`);
+      throw new TypeError(`${path18} must be a finite JSON number`);
     }
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path15}[${index}]`));
+    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path18}[${index}]`));
   }
   if (!isPlainObject(value)) {
-    throw new TypeError(`${path15} must be a plain JSON object`);
+    throw new TypeError(`${path18} must be a plain JSON object`);
   }
   const sorted = Object.keys(value).sort((left, right) => left.localeCompare(right));
   const result = {};
   for (const key of sorted) {
     const entry = value[key];
     if (entry === void 0) {
-      throw new TypeError(`${path15}.${key} must not be undefined`);
+      throw new TypeError(`${path18}.${key} must not be undefined`);
     }
-    result[key] = canonicalizeJsonValue(entry, `${path15}.${key}`);
+    result[key] = canonicalizeJsonValue(entry, `${path18}.${key}`);
   }
   return result;
 }
@@ -120,7 +122,7 @@ function joinStoragePath(...segments) {
   return segments.join("/");
 }
 function resolveStoragePath(rootPath, relativePath) {
-  if (path7__default.default.isAbsolute(relativePath)) {
+  if (path10__default.default.isAbsolute(relativePath)) {
     throw new TypeError(`storage path ${relativePath} must be relative`);
   }
   const segments = relativePath.split("/");
@@ -132,7 +134,7 @@ function resolveStoragePath(rootPath, relativePath) {
       throw new TypeError(`storage path ${relativePath} must not contain path traversal`);
     }
   }
-  return path7__default.default.join(rootPath, ...segments);
+  return path10__default.default.join(rootPath, ...segments);
 }
 async function ensureDirectory(directoryPath) {
   await promises.mkdir(directoryPath, { recursive: true });
@@ -152,7 +154,7 @@ async function writeJsonFileAtomic(filePath, value) {
   await writeTextFileAtomic(filePath, stableJsonString(value));
 }
 async function writeTextFileAtomic(filePath, value) {
-  await ensureDirectory(path7__default.default.dirname(filePath));
+  await ensureDirectory(path10__default.default.dirname(filePath));
   const temporaryPath = `${filePath}.${crypto.randomUUID()}.tmp`;
   await promises.writeFile(temporaryPath, value, "utf8");
   await promises.rename(temporaryPath, filePath);
@@ -161,7 +163,7 @@ async function writeJsonFileExclusive(filePath, value) {
   await writeTextFileExclusive(filePath, stableJsonString(value));
 }
 async function writeTextFileExclusive(filePath, value) {
-  await ensureDirectory(path7__default.default.dirname(filePath));
+  await ensureDirectory(path10__default.default.dirname(filePath));
   const handle = await promises.open(filePath, "wx");
   try {
     await handle.writeFile(value, "utf8");
@@ -170,7 +172,7 @@ async function writeTextFileExclusive(filePath, value) {
   }
 }
 async function writeBufferIfMissing(filePath, value) {
-  await ensureDirectory(path7__default.default.dirname(filePath));
+  await ensureDirectory(path10__default.default.dirname(filePath));
   try {
     const handle = await promises.open(filePath, "wx");
     try {
@@ -204,7 +206,7 @@ function isAlreadyExistsError(error) {
   return error?.code === "EEXIST";
 }
 async function withFilesystemLock(lockPath, task) {
-  await ensureDirectory(path7__default.default.dirname(lockPath));
+  await ensureDirectory(path10__default.default.dirname(lockPath));
   let attempt = 0;
   while (true) {
     try {
@@ -259,8 +261,8 @@ async function readStructuredPayload(objectPath) {
 var FilesystemArtifactStore = class {
   constructor(rootPath) {
     this.rootPath = rootPath;
-    this.manifestsDirectory = path7__default.default.join(this.rootPath, "artifacts", "manifests");
-    this.objectsDirectory = path7__default.default.join(this.rootPath, "artifacts", "objects", "sha256");
+    this.manifestsDirectory = path10__default.default.join(this.rootPath, "artifacts", "manifests");
+    this.objectsDirectory = path10__default.default.join(this.rootPath, "artifacts", "objects", "sha256");
   }
   manifestsDirectory;
   objectsDirectory;
@@ -485,7 +487,7 @@ var FilesystemArtifactStore = class {
     }
   }
   manifestPath(artifactId) {
-    return path7__default.default.join(this.manifestsDirectory, `${encodePathSegment(artifactId)}.json`);
+    return path10__default.default.join(this.manifestsDirectory, `${encodePathSegment(artifactId)}.json`);
   }
 };
 function createArtifactStore(rootPath) {
@@ -580,31 +582,31 @@ function oneOfSchema(members, options = {}) {
 }
 
 // ../protocol/src/validation.ts
-function validateJsonSchema(schema, value, path15 = "$") {
-  return validateSchemaNode(schema, value, path15);
+function validateJsonSchema(schema, value, path18 = "$") {
+  return validateSchemaNode(schema, value, path18);
 }
-function validateSchemaNode(schema, value, path15) {
+function validateSchemaNode(schema, value, path18) {
   const issues = [];
   if ("const" in schema && !isJsonValueEqual(schema.const, value)) {
     issues.push({
-      path: path15,
+      path: path18,
       message: `must equal ${JSON.stringify(schema.const)}`
     });
     return issues;
   }
   if (schema.enum !== void 0 && !schema.enum.some((candidate) => isJsonValueEqual(candidate, value))) {
     issues.push({
-      path: path15,
+      path: path18,
       message: `must be one of ${schema.enum.map((candidate) => JSON.stringify(candidate)).join(", ")}`
     });
     return issues;
   }
   if (schema.oneOf !== void 0) {
-    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path15));
+    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path18));
     const validBranches = branchIssues.filter((current) => current.length === 0).length;
     if (validBranches !== 1) {
       issues.push({
-        path: path15,
+        path: path18,
         message: validBranches === 0 ? "must match exactly one supported shape" : "matches multiple supported shapes"
       });
       return issues;
@@ -612,11 +614,11 @@ function validateSchemaNode(schema, value, path15) {
   }
   if (schema.anyOf !== void 0) {
     const hasMatch = schema.anyOf.some(
-      (member) => validateSchemaNode(member, value, path15).length === 0
+      (member) => validateSchemaNode(member, value, path18).length === 0
     );
     if (!hasMatch) {
       issues.push({
-        path: path15,
+        path: path18,
         message: "must match at least one supported shape"
       });
       return issues;
@@ -624,7 +626,7 @@ function validateSchemaNode(schema, value, path15) {
   }
   if (schema.allOf !== void 0) {
     for (const member of schema.allOf) {
-      issues.push(...validateSchemaNode(member, value, path15));
+      issues.push(...validateSchemaNode(member, value, path18));
     }
     if (issues.length > 0) {
       return issues;
@@ -632,7 +634,7 @@ function validateSchemaNode(schema, value, path15) {
   }
   if (schema.type !== void 0 && !matchesSchemaType(schema.type, value)) {
     issues.push({
-      path: path15,
+      path: path18,
       message: `must be ${describeSchemaType(schema.type)}`
     });
     return issues;
@@ -640,19 +642,19 @@ function validateSchemaNode(schema, value, path15) {
   if (typeof value === "string") {
     if (schema.minLength !== void 0 && value.length < schema.minLength) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must have length >= ${String(schema.minLength)}`
       });
     }
     if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must have length <= ${String(schema.maxLength)}`
       });
     }
     if (schema.pattern !== void 0 && !new RegExp(schema.pattern).test(value)) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must match pattern ${schema.pattern}`
       });
     }
@@ -661,25 +663,25 @@ function validateSchemaNode(schema, value, path15) {
   if (typeof value === "number") {
     if (schema.minimum !== void 0 && value < schema.minimum) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must be >= ${String(schema.minimum)}`
       });
     }
     if (schema.maximum !== void 0 && value > schema.maximum) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must be <= ${String(schema.maximum)}`
       });
     }
     if (schema.exclusiveMinimum !== void 0 && value <= schema.exclusiveMinimum) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must be > ${String(schema.exclusiveMinimum)}`
       });
     }
     if (schema.exclusiveMaximum !== void 0 && value >= schema.exclusiveMaximum) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must be < ${String(schema.exclusiveMaximum)}`
       });
     }
@@ -688,13 +690,13 @@ function validateSchemaNode(schema, value, path15) {
   if (Array.isArray(value)) {
     if (schema.minItems !== void 0 && value.length < schema.minItems) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must have at least ${String(schema.minItems)} items`
       });
     }
     if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
       issues.push({
-        path: path15,
+        path: path18,
         message: `must have at most ${String(schema.maxItems)} items`
       });
     }
@@ -704,7 +706,7 @@ function validateSchemaNode(schema, value, path15) {
         const key = JSON.stringify(item);
         if (seen.has(key)) {
           issues.push({
-            path: path15,
+            path: path18,
             message: "must not contain duplicate items"
           });
           break;
@@ -714,7 +716,7 @@ function validateSchemaNode(schema, value, path15) {
     }
     if (schema.items !== void 0) {
       for (let index = 0; index < value.length; index += 1) {
-        issues.push(...validateSchemaNode(schema.items, value[index], `${path15}[${String(index)}]`));
+        issues.push(...validateSchemaNode(schema.items, value[index], `${path18}[${String(index)}]`));
       }
     }
     return issues;
@@ -724,7 +726,7 @@ function validateSchemaNode(schema, value, path15) {
     for (const requiredKey of schema.required ?? []) {
       if (!(requiredKey in value)) {
         issues.push({
-          path: joinObjectPath(path15, requiredKey),
+          path: joinObjectPath(path18, requiredKey),
           message: "is required"
         });
       }
@@ -733,13 +735,13 @@ function validateSchemaNode(schema, value, path15) {
       const propertySchema = properties[key];
       if (propertySchema !== void 0) {
         issues.push(
-          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path15, key))
+          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path18, key))
         );
         continue;
       }
       if (schema.additionalProperties === false) {
         issues.push({
-          path: joinObjectPath(path15, key),
+          path: joinObjectPath(path18, key),
           message: "is not allowed"
         });
         continue;
@@ -749,7 +751,7 @@ function validateSchemaNode(schema, value, path15) {
           ...validateSchemaNode(
             schema.additionalProperties,
             propertyValue,
-            joinObjectPath(path15, key)
+            joinObjectPath(path18, key)
           )
         );
       }
@@ -993,8 +995,8 @@ function matchesNetworkRecordFilters(record, filters) {
     }
   }
   if (filters.path !== void 0) {
-    const path15 = getParsedUrl().pathname;
-    if (!includesCaseInsensitive(path15, filters.path)) {
+    const path18 = getParsedUrl().pathname;
+    if (!includesCaseInsensitive(path18, filters.path)) {
       return false;
     }
   }
@@ -6992,9 +6994,9 @@ function compareByCreatedAtAndId(left, right) {
 var FilesystemRegistryStore = class {
   constructor(rootPath, registryRelativePath) {
     this.registryRelativePath = registryRelativePath;
-    const basePath = path7__default.default.join(rootPath, ...registryRelativePath);
-    this.recordsDirectory = path7__default.default.join(basePath, "records");
-    this.indexesDirectory = path7__default.default.join(basePath, "indexes", "by-key");
+    const basePath = path10__default.default.join(rootPath, ...registryRelativePath);
+    this.recordsDirectory = path10__default.default.join(basePath, "records");
+    this.indexesDirectory = path10__default.default.join(basePath, "indexes", "by-key");
   }
   recordsDirectory;
   indexesDirectory;
@@ -7063,7 +7065,7 @@ var FilesystemRegistryStore = class {
   async readRecordsFromDirectory() {
     const files = await listJsonFiles(this.recordsDirectory);
     const records = await Promise.all(
-      files.map((fileName) => readJsonFile(path7__default.default.join(this.recordsDirectory, fileName)))
+      files.map((fileName) => readJsonFile(path10__default.default.join(this.recordsDirectory, fileName)))
     );
     records.sort(compareByCreatedAtAndId);
     return records;
@@ -7095,17 +7097,17 @@ var FilesystemRegistryStore = class {
     return record;
   }
   recordPath(id) {
-    return path7__default.default.join(this.recordsDirectory, `${encodePathSegment(id)}.json`);
+    return path10__default.default.join(this.recordsDirectory, `${encodePathSegment(id)}.json`);
   }
   indexPath(key, version) {
-    return path7__default.default.join(
+    return path10__default.default.join(
       this.indexesDirectory,
       encodePathSegment(key),
       `${encodePathSegment(version)}.json`
     );
   }
   writeLockPath() {
-    return path7__default.default.join(path7__default.default.dirname(this.recordsDirectory), ".write.lock");
+    return path10__default.default.join(path10__default.default.dirname(this.recordsDirectory), ".write.lock");
   }
 };
 var FilesystemDescriptorRegistry = class extends FilesystemRegistryStore {
@@ -7475,7 +7477,7 @@ var SqliteSavedNetworkStore = class {
   directoryInitialization;
   databaseInitialization;
   constructor(rootPath) {
-    this.databasePath = path7__default.default.join(rootPath, "registry", "saved-network.sqlite");
+    this.databasePath = path10__default.default.join(rootPath, "registry", "saved-network.sqlite");
   }
   async initialize() {
     await this.ensureDatabaseDirectory();
@@ -7715,7 +7717,7 @@ var SqliteSavedNetworkStore = class {
     }
   }
   async ensureDatabaseDirectory() {
-    this.directoryInitialization ??= ensureDirectory(path7__default.default.dirname(this.databasePath)).catch(
+    this.directoryInitialization ??= ensureDirectory(path10__default.default.dirname(this.databasePath)).catch(
       (error) => {
         this.directoryInitialization = void 0;
         throw error;
@@ -8314,7 +8316,7 @@ var FilesystemObservationStoreImpl = class {
   constructor(rootPath, artifacts) {
     this.rootPath = rootPath;
     this.artifacts = artifacts;
-    this.sessionsDirectory = path7__default.default.join(this.rootPath, "observations", "sessions");
+    this.sessionsDirectory = path10__default.default.join(this.rootPath, "observations", "sessions");
   }
   sessionsDirectory;
   redactors = /* @__PURE__ */ new Map();
@@ -8411,7 +8413,7 @@ var FilesystemObservationStoreImpl = class {
           ...raw.artifactIds === void 0 || raw.artifactIds.length === 0 ? {} : { artifactIds: [...raw.artifactIds] }
         };
         await writeJsonFileExclusive(
-          path7__default.default.join(this.sessionEventsDirectory(sessionId), eventFileName(sequence)),
+          path10__default.default.join(this.sessionEventsDirectory(sessionId), eventFileName(sequence)),
           event
         );
         updatedAt = Math.max(updatedAt, createdAt);
@@ -8469,7 +8471,7 @@ var FilesystemObservationStoreImpl = class {
     }
     const files = await listJsonFiles(directoryPath);
     const events = await Promise.all(
-      files.map((fileName) => readJsonFile(path7__default.default.join(directoryPath, fileName)))
+      files.map((fileName) => readJsonFile(path10__default.default.join(directoryPath, fileName)))
     );
     const filtered = events.filter((event) => {
       if (input.kind !== void 0 && event.kind !== input.kind) return false;
@@ -8496,7 +8498,7 @@ var FilesystemObservationStoreImpl = class {
     const files = await listJsonFiles(directoryPath);
     const artifacts = await Promise.all(
       files.map(
-        (fileName) => readJsonFile(path7__default.default.join(directoryPath, fileName))
+        (fileName) => readJsonFile(path10__default.default.join(directoryPath, fileName))
       )
     );
     const filtered = artifacts.filter((artifact) => {
@@ -8559,25 +8561,25 @@ var FilesystemObservationStoreImpl = class {
     )).filter((value) => value !== void 0);
   }
   sessionDirectory(sessionId) {
-    return path7__default.default.join(this.sessionsDirectory, encodePathSegment(sessionId));
+    return path10__default.default.join(this.sessionsDirectory, encodePathSegment(sessionId));
   }
   sessionManifestPath(sessionId) {
-    return path7__default.default.join(this.sessionDirectory(sessionId), "session.json");
+    return path10__default.default.join(this.sessionDirectory(sessionId), "session.json");
   }
   sessionEventsDirectory(sessionId) {
-    return path7__default.default.join(this.sessionDirectory(sessionId), "events");
+    return path10__default.default.join(this.sessionDirectory(sessionId), "events");
   }
   sessionArtifactsDirectory(sessionId) {
-    return path7__default.default.join(this.sessionDirectory(sessionId), "artifacts");
+    return path10__default.default.join(this.sessionDirectory(sessionId), "artifacts");
   }
   sessionArtifactPath(sessionId, artifactId) {
-    return path7__default.default.join(
+    return path10__default.default.join(
       this.sessionArtifactsDirectory(sessionId),
       `${encodePathSegment(artifactId)}.json`
     );
   }
   sessionLockPath(sessionId) {
-    return path7__default.default.join(this.sessionDirectory(sessionId), ".lock");
+    return path10__default.default.join(this.sessionDirectory(sessionId), ".lock");
   }
   async reconcileSessionManifest(sessionId) {
     const session = await this.getSession(sessionId);
@@ -8605,14 +8607,14 @@ var FilesystemObservationStoreImpl = class {
       Promise.all(
         eventFiles.map(
           (fileName) => readJsonFile(
-            path7__default.default.join(this.sessionEventsDirectory(sessionId), fileName)
+            path10__default.default.join(this.sessionEventsDirectory(sessionId), fileName)
           )
         )
       ),
       Promise.all(
         artifactFiles.map(
           (fileName) => readJsonFile(
-            path7__default.default.join(this.sessionArtifactsDirectory(sessionId), fileName)
+            path10__default.default.join(this.sessionArtifactsDirectory(sessionId), fileName)
           )
         )
       )
@@ -8665,7 +8667,7 @@ var FilesystemTraceStore = class {
   constructor(rootPath, artifacts) {
     this.rootPath = rootPath;
     this.artifacts = artifacts;
-    this.runsDirectory = path7__default.default.join(this.rootPath, "traces", "runs");
+    this.runsDirectory = path10__default.default.join(this.rootPath, "traces", "runs");
   }
   runsDirectory;
   async initialize() {
@@ -8742,7 +8744,7 @@ var FilesystemTraceStore = class {
         ...input.error === void 0 ? {} : { error: input.error }
       };
       await writeJsonFileExclusive(
-        path7__default.default.join(this.runEntriesDirectory(runId), sequenceFileName(sequence)),
+        path10__default.default.join(this.runEntriesDirectory(runId), sequenceFileName(sequence)),
         entry
       );
       await writeJsonFileAtomic(this.runManifestPath(runId), {
@@ -8761,7 +8763,7 @@ var FilesystemTraceStore = class {
     const files = await listJsonFiles(entriesDirectory);
     return Promise.all(
       files.map(
-        (fileName) => readJsonFile(path7__default.default.join(entriesDirectory, fileName))
+        (fileName) => readJsonFile(path10__default.default.join(entriesDirectory, fileName))
       )
     );
   }
@@ -8807,16 +8809,16 @@ var FilesystemTraceStore = class {
     return { trace, artifacts };
   }
   runDirectory(runId) {
-    return path7__default.default.join(this.runsDirectory, encodeURIComponent(runId));
+    return path10__default.default.join(this.runsDirectory, encodeURIComponent(runId));
   }
   runEntriesDirectory(runId) {
-    return path7__default.default.join(this.runDirectory(runId), "entries");
+    return path10__default.default.join(this.runDirectory(runId), "entries");
   }
   runManifestPath(runId) {
-    return path7__default.default.join(this.runDirectory(runId), "manifest.json");
+    return path10__default.default.join(this.runDirectory(runId), "manifest.json");
   }
   runWriteLockPath(runId) {
-    return path7__default.default.join(this.runDirectory(runId), ".append.lock");
+    return path10__default.default.join(this.runDirectory(runId), ".append.lock");
   }
 };
 function createTraceStore(rootPath, artifacts) {
@@ -8830,7 +8832,7 @@ function normalizeWorkspaceId(workspace) {
   return encodePathSegment(workspace);
 }
 function resolveFilesystemWorkspacePath(input) {
-  return path7__default.default.join(
+  return path10__default.default.join(
     input.rootDir,
     ".opensteer",
     "workspaces",
@@ -8839,18 +8841,18 @@ function resolveFilesystemWorkspacePath(input) {
 }
 async function createFilesystemOpensteerWorkspace(options) {
   await ensureDirectory(options.rootPath);
-  const manifestPath = path7__default.default.join(options.rootPath, "workspace.json");
-  const browserPath = path7__default.default.join(options.rootPath, "browser");
-  const browserManifestPath = path7__default.default.join(browserPath, "manifest.json");
-  const browserUserDataDir = path7__default.default.join(browserPath, "user-data");
-  const livePath = path7__default.default.join(options.rootPath, "live");
-  const liveLocalPath = path7__default.default.join(livePath, "local.json");
-  const liveCloudPath = path7__default.default.join(livePath, "cloud.json");
-  const artifactsPath = path7__default.default.join(options.rootPath, "artifacts");
-  const tracesPath = path7__default.default.join(options.rootPath, "traces");
-  const observationsPath = path7__default.default.join(options.rootPath, "observations");
-  const registryPath = path7__default.default.join(options.rootPath, "registry");
-  const lockPath = path7__default.default.join(options.rootPath, ".lock");
+  const manifestPath = path10__default.default.join(options.rootPath, "workspace.json");
+  const browserPath = path10__default.default.join(options.rootPath, "browser");
+  const browserManifestPath = path10__default.default.join(browserPath, "manifest.json");
+  const browserUserDataDir = path10__default.default.join(browserPath, "user-data");
+  const livePath = path10__default.default.join(options.rootPath, "live");
+  const liveLocalPath = path10__default.default.join(livePath, "local.json");
+  const liveCloudPath = path10__default.default.join(livePath, "cloud.json");
+  const artifactsPath = path10__default.default.join(options.rootPath, "artifacts");
+  const tracesPath = path10__default.default.join(options.rootPath, "traces");
+  const observationsPath = path10__default.default.join(options.rootPath, "observations");
+  const registryPath = path10__default.default.join(options.rootPath, "registry");
+  const lockPath = path10__default.default.join(options.rootPath, ".lock");
   let manifest;
   if (await pathExists(manifestPath)) {
     manifest = await readJsonFile(manifestPath);
@@ -9605,9 +9607,9 @@ var IFRAME_URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "poster",
   "ping"
 ]);
-function buildArrayFieldPathCandidates(path15) {
-  const strict = path15.nodes.length ? buildPathCandidates(path15.nodes) : [];
-  const relaxedNodes = stripPositionClauses(path15.nodes);
+function buildArrayFieldPathCandidates(path18) {
+  const strict = path18.nodes.length ? buildPathCandidates(path18.nodes) : [];
+  const relaxedNodes = stripPositionClauses(path18.nodes);
   const relaxed = relaxedNodes.length ? buildPathCandidates(relaxedNodes) : [];
   return dedupeSelectors([...strict, ...relaxed]);
 }
@@ -10137,18 +10139,18 @@ function cloneStructuralElementAnchor(anchor) {
     nodes: anchor.nodes.map(clonePathNode)
   };
 }
-function cloneReplayElementPath(path15) {
+function cloneReplayElementPath(path18) {
   return {
     resolution: "deterministic",
-    context: cloneContext(path15.context),
-    nodes: path15.nodes.map(clonePathNode)
+    context: cloneContext(path18.context),
+    nodes: path18.nodes.map(clonePathNode)
   };
 }
-function cloneElementPath(path15) {
-  return cloneReplayElementPath(path15);
+function cloneElementPath(path18) {
+  return cloneReplayElementPath(path18);
 }
-function buildPathSelectorHint(path15) {
-  const nodes = path15?.nodes || [];
+function buildPathSelectorHint(path18) {
+  const nodes = path18?.nodes || [];
   const last = nodes[nodes.length - 1];
   if (!last) {
     return "*";
@@ -10197,15 +10199,15 @@ function sanitizeStructuralElementAnchor(anchor) {
     nodes: sanitizeNodes(anchor.nodes)
   };
 }
-function sanitizeReplayElementPath(path15) {
+function sanitizeReplayElementPath(path18) {
   return {
     resolution: "deterministic",
-    context: sanitizeContext(path15.context),
-    nodes: sanitizeNodes(path15.nodes)
+    context: sanitizeContext(path18.context),
+    nodes: sanitizeNodes(path18.nodes)
   };
 }
-function sanitizeElementPath(path15) {
-  return sanitizeReplayElementPath(path15);
+function sanitizeElementPath(path18) {
+  return sanitizeReplayElementPath(path18);
 }
 function buildLocalStructuralElementAnchor(index, rawTargetNode) {
   const targetNode = requireElementNode(index, rawTargetNode);
@@ -10328,8 +10330,8 @@ function buildTargetNotFoundMessage(domPath, diagnostics) {
   }
   return `${base} Target depth ${String(depth)}. Candidate counts: ${sample}.`;
 }
-function buildArrayFieldCandidates(path15) {
-  return buildArrayFieldPathCandidates(path15);
+function buildArrayFieldCandidates(path18) {
+  return buildArrayFieldPathCandidates(path18);
 }
 function firstDefinedAttribute(node, keys) {
   for (const key of keys) {
@@ -11865,21 +11867,21 @@ var DefaultDomRuntime = class {
     return match;
   }
   async resolvePathTarget(session, pageRef, rawPath, source, persist, descriptor) {
-    const path15 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path15.context);
-    const target = resolveDomPathInScope(context.index, path15.nodes, context.scope);
+    const path18 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path18.context);
+    const target = resolveDomPathInScope(context.index, path18.nodes, context.scope);
     if (!target) {
-      throwTargetNotFound(context.index, path15.nodes, context.scope);
+      throwTargetNotFound(context.index, path18.nodes, context.scope);
     }
     if (target.node.nodeRef === void 0) {
       throw new Error(
-        `resolved path "${buildPathSelectorHint(path15)}" does not point to a live element`
+        `resolved path "${buildPathSelectorHint(path18)}" does not point to a live element`
       );
     }
     const anchor = await this.buildAnchorFromSnapshotNode(session, context.snapshot, target.node);
     return this.createResolvedTarget(source, context.snapshot, target.node, anchor, {
       ...persist === void 0 ? {} : { persist },
-      replayPath: path15,
+      replayPath: path18,
       ...source === "path" || source === "descriptor" ? { selectorUsed: target.selector } : {},
       ...descriptor === void 0 ? {} : { descriptor }
     });
@@ -11900,9 +11902,9 @@ var DefaultDomRuntime = class {
     });
   }
   async queryAllByElementPath(session, pageRef, rawPath) {
-    const path15 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path15.context);
-    return queryAllDomPathInScope(context.index, path15.nodes, context.scope).filter(
+    const path18 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path18.context);
+    return queryAllDomPathInScope(context.index, path18.nodes, context.scope).filter(
       (node) => node.nodeRef !== void 0
     ).map((node) => this.createSnapshotTarget(context.snapshot, node));
   }
@@ -12088,16 +12090,16 @@ var DefaultDomRuntime = class {
     const index = createSnapshotIndex(item.snapshot);
     return this.resolveFirstArrayFieldTargetInNode(index, item.node, field.path);
   }
-  resolveFirstArrayFieldTargetInNode(index, rootNode, path15) {
-    const normalizedPath = sanitizeElementPath(path15);
+  resolveFirstArrayFieldTargetInNode(index, rootNode, path18) {
+    const normalizedPath = sanitizeElementPath(path18);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
     }
     return resolveFirstWithinNodeBySelectors(index, rootNode, selectors);
   }
-  resolveUniqueArrayFieldTargetInNode(index, rootNode, path15) {
-    const normalizedPath = sanitizeElementPath(path15);
+  resolveUniqueArrayFieldTargetInNode(index, rootNode, path18) {
+    const normalizedPath = sanitizeElementPath(path18);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
@@ -12186,8 +12188,8 @@ function encodeDataPath(tokens) {
   }
   return out;
 }
-function parseDataPath(path15) {
-  const input = path15.trim();
+function parseDataPath(path18) {
+  const input = path18.trim();
   if (input.length === 0) {
     return [];
   }
@@ -12237,8 +12239,8 @@ function parseDataPath(path15) {
 function inflateDataPathObject(flat) {
   let root = {};
   let initialized = false;
-  for (const [path15, value] of Object.entries(flat)) {
-    const tokens = parseDataPath(path15);
+  for (const [path18, value] of Object.entries(flat)) {
+    const tokens = parseDataPath(path18);
     if (!tokens || tokens.length === 0) {
       continue;
     }
@@ -12570,8 +12572,8 @@ function buildVariantDescriptorFromCluster(descriptors) {
     fields: mergedFields
   };
 }
-function minimizePathMatchClauses(path15, mode) {
-  const normalized = sanitizeElementPath(path15);
+function minimizePathMatchClauses(path18, mode) {
+  const normalized = sanitizeElementPath(path18);
   const nodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = node.attrs || {};
@@ -12675,8 +12677,8 @@ function seedMinimalAttrClause(attrs) {
   }
   return null;
 }
-function relaxPathForSingleSample(path15, mode) {
-  const normalized = sanitizeElementPath(path15);
+function relaxPathForSingleSample(path18, mode) {
+  const normalized = sanitizeElementPath(path18);
   const relaxedNodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = normalizeAttrsForSingleSample(node.attrs || {});
@@ -12761,8 +12763,8 @@ function shouldKeepAttrForSingleSample(key) {
   }
   return true;
 }
-function buildPathStructureKey(path15) {
-  const normalized = sanitizeElementPath(path15);
+function buildPathStructureKey(path18) {
+  const normalized = sanitizeElementPath(path18);
   return canonicalJsonString({
     context: (normalized.context || []).map((hop) => ({
       kind: hop.kind,
@@ -12889,30 +12891,30 @@ function buildArrayItemNode(fields) {
   }
   return node;
 }
-function insertNodeAtPath(root, path15, node) {
-  const tokens = parseDataPath(path15);
+function insertNodeAtPath(root, path18, node) {
+  const tokens = parseDataPath(path18);
   if (!tokens || !tokens.length) {
     throw new Error(
-      `Invalid persisted extraction path "${path15}": expected a non-empty object path.`
+      `Invalid persisted extraction path "${path18}": expected a non-empty object path.`
     );
   }
   if (tokens.some((token) => token.kind === "index")) {
     throw new Error(
-      `Invalid persisted extraction path "${path15}": nested array indices are not supported in cached descriptors.`
+      `Invalid persisted extraction path "${path18}": nested array indices are not supported in cached descriptors.`
     );
   }
   let current = root;
   for (let index = 0; index < tokens.length; index += 1) {
     const token = tokens[index];
     if (!token || token.kind !== "prop") {
-      throw new Error(`Invalid persisted extraction path "${path15}": expected object segment.`);
+      throw new Error(`Invalid persisted extraction path "${path18}": expected object segment.`);
     }
     const isLast = index === tokens.length - 1;
     if (isLast) {
       const existing = current[token.key];
       if (existing) {
         throw new Error(
-          `Conflicting persisted extraction path "${path15}" detected while building descriptor tree.`
+          `Conflicting persisted extraction path "${path18}" detected while building descriptor tree.`
         );
       }
       current[token.key] = node;
@@ -12927,7 +12929,7 @@ function insertNodeAtPath(root, path15, node) {
     }
     if (!isPersistedObjectNode(next)) {
       throw new Error(
-        `Conflicting persisted extraction path "${path15}" detected at "${token.key}".`
+        `Conflicting persisted extraction path "${path18}" detected at "${token.key}".`
       );
     }
     current = next;
@@ -12962,7 +12964,7 @@ function buildItemRootForArrayIndex(entries) {
   }
   const paths = entries.map(
     (entry) => isPersistablePathField(entry.source) ? sanitizeElementPath(entry.source.path) : null
-  ).filter((path15) => path15 !== null);
+  ).filter((path18) => path18 !== null);
   if (!paths.length) {
     return null;
   }
@@ -12983,7 +12985,7 @@ function getCommonPathPrefixLength(paths) {
   if (!paths.length) {
     return 0;
   }
-  const nodeChains = paths.map((path15) => path15.nodes);
+  const nodeChains = paths.map((path18) => path18.nodes);
   const minLength = Math.min(...nodeChains.map((nodes) => nodes.length));
   if (!Number.isFinite(minLength) || minLength <= 0) {
     return 0;
@@ -13052,30 +13054,30 @@ function mergeElementPathsByMajority(paths) {
   if (!paths.length) {
     return null;
   }
-  const normalized = paths.map((path15) => sanitizeElementPath(path15));
+  const normalized = paths.map((path18) => sanitizeElementPath(path18));
   const contextKey = pickModeString(
-    normalized.map((path15) => canonicalJsonString(path15.context)),
+    normalized.map((path18) => canonicalJsonString(path18.context)),
     1
   );
   if (!contextKey) {
     return null;
   }
-  const sameContext = normalized.filter((path15) => canonicalJsonString(path15.context) === contextKey);
+  const sameContext = normalized.filter((path18) => canonicalJsonString(path18.context) === contextKey);
   if (!sameContext.length) {
     return null;
   }
   const targetLength = pickModeNumber(
-    sameContext.map((path15) => path15.nodes.length),
+    sameContext.map((path18) => path18.nodes.length),
     1
   ) ?? sameContext[0]?.nodes.length ?? 0;
-  const aligned = sameContext.filter((path15) => path15.nodes.length === targetLength);
+  const aligned = sameContext.filter((path18) => path18.nodes.length === targetLength);
   if (!aligned.length) {
     return null;
   }
   const threshold = majorityThreshold(aligned.length);
   const nodes = [];
   for (let index = 0; index < targetLength; index += 1) {
-    const nodesAtIndex = aligned.map((path15) => path15.nodes[index]).filter((node) => node !== void 0);
+    const nodesAtIndex = aligned.map((path18) => path18.nodes[index]).filter((node) => node !== void 0);
     if (!nodesAtIndex.length) {
       return null;
     }
@@ -13321,8 +13323,8 @@ function clonePathContext(context) {
 function clonePathNodes(nodes) {
   return JSON.parse(JSON.stringify(nodes || []));
 }
-function cloneElementPath2(path15) {
-  return JSON.parse(JSON.stringify(path15));
+function cloneElementPath2(path18) {
+  return JSON.parse(JSON.stringify(path18));
 }
 function clonePersistedOpensteerExtractionNode(node) {
   return JSON.parse(JSON.stringify(node));
@@ -13640,8 +13642,8 @@ function collectPersistedValueNodeRefs(node) {
     return [
       {
         path: sanitizeElementPath(node.$path),
-        replacePath: (path15) => {
-          node.$path = sanitizeElementPath(path15);
+        replacePath: (path18) => {
+          node.$path = sanitizeElementPath(path18);
         }
       }
     ];
@@ -13655,13 +13657,13 @@ function collectPersistedValueNodeRefs(node) {
   }
   return refs;
 }
-function hasPositionClause(path15) {
-  return path15.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
+function hasPositionClause(path18) {
+  return path18.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
 }
-function stripPositionClauses2(path15) {
+function stripPositionClauses2(path18) {
   return sanitizeElementPath({
-    context: path15.context,
-    nodes: path15.nodes.map((node) => ({
+    context: path18.context,
+    nodes: path18.nodes.map((node) => ({
       ...node,
       match: node.match.filter((clause) => clause.kind !== "position")
     }))
@@ -14071,17 +14073,57 @@ function normalizeNonEmptyString2(name, value) {
 function normalizeKey(value) {
   return String(value ?? "").trim();
 }
-function labelForPath(path15) {
-  return path15.trim().length === 0 ? "$" : path15;
+function labelForPath(path18) {
+  return path18.trim().length === 0 ? "$" : path18;
 }
 function sha256Hex3(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
-util.promisify(child_process.execFile);
-Math.floor(Date.now() - process.uptime() * 1e3);
-({ ...process.env});
-({
-  pid: process.pid});
+var execFileAsync = util.promisify(child_process.execFile);
+var PROCESS_STARTED_AT_MS = Math.floor(Date.now() - process.uptime() * 1e3);
+var PROCESS_START_TIME_TOLERANCE_MS = 1e3;
+var PROCESS_LIST_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+var PS_COMMAND_ENV = { ...process.env, LC_ALL: "C" };
+var LINUX_STAT_START_TIME_FIELD_INDEX = 19;
+var CURRENT_PROCESS_OWNER = {
+  pid: process.pid,
+  processStartedAtMs: PROCESS_STARTED_AT_MS
+};
+var linuxClockTicksPerSecondPromise = null;
+function parseProcessOwner(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const parsed = value;
+  const pid = Number(parsed.pid);
+  const processStartedAtMs = Number(parsed.processStartedAtMs);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+  if (!Number.isInteger(processStartedAtMs) || processStartedAtMs <= 0) {
+    return null;
+  }
+  return {
+    pid,
+    processStartedAtMs
+  };
+}
+function processOwnersEqual(left, right) {
+  if (!left || !right) {
+    return left === right;
+  }
+  return left.pid === right.pid && left.processStartedAtMs === right.processStartedAtMs;
+}
+async function getProcessLiveness(owner) {
+  if (owner.pid === process.pid && hasMatchingProcessStartTime(owner.processStartedAtMs, PROCESS_STARTED_AT_MS)) {
+    return "live";
+  }
+  const startedAtMs = await readProcessStartedAtMs(owner.pid);
+  if (typeof startedAtMs === "number") {
+    return hasMatchingProcessStartTime(owner.processStartedAtMs, startedAtMs) ? "live" : "dead";
+  }
+  return isProcessRunning(owner.pid) ? "unknown" : "dead";
+}
 function isProcessRunning(pid) {
   try {
     process.kill(pid, 0);
@@ -14091,6 +14133,116 @@ function isProcessRunning(pid) {
     return code !== "ESRCH";
   }
 }
+function hasMatchingProcessStartTime(expectedStartedAtMs, actualStartedAtMs) {
+  return Math.abs(expectedStartedAtMs - actualStartedAtMs) <= PROCESS_START_TIME_TOLERANCE_MS;
+}
+async function readProcessStartedAtMs(pid) {
+  if (pid <= 0) {
+    return null;
+  }
+  if (process.platform === "linux") {
+    return readLinuxProcessStartedAtMs(pid);
+  }
+  if (process.platform === "win32") {
+    return readWindowsProcessStartedAtMs(pid);
+  }
+  return readPsProcessStartedAtMs(pid);
+}
+async function readLinuxProcessStartedAtMs(pid) {
+  let statRaw;
+  try {
+    statRaw = await promises.readFile(`/proc/${String(pid)}/stat`, "utf8");
+  } catch {
+    return null;
+  }
+  const startTicks = parseLinuxProcessStartTicks(statRaw);
+  if (startTicks === null) {
+    return null;
+  }
+  const [bootTimeMs, clockTicksPerSecond] = await Promise.all([
+    readLinuxBootTimeMs(),
+    readLinuxClockTicksPerSecond()
+  ]);
+  if (bootTimeMs === null || clockTicksPerSecond === null) {
+    return null;
+  }
+  return Math.floor(bootTimeMs + startTicks * 1e3 / clockTicksPerSecond);
+}
+function parseLinuxProcessStartTicks(statRaw) {
+  const closingParenIndex = statRaw.lastIndexOf(")");
+  if (closingParenIndex === -1) {
+    return null;
+  }
+  const fields = statRaw.slice(closingParenIndex + 2).trim().split(/\s+/);
+  const startTicks = Number(fields[LINUX_STAT_START_TIME_FIELD_INDEX]);
+  return Number.isFinite(startTicks) && startTicks >= 0 ? startTicks : null;
+}
+async function readLinuxBootTimeMs() {
+  try {
+    const statRaw = await promises.readFile("/proc/stat", "utf8");
+    const bootTimeLine = statRaw.split("\n").find((line) => line.startsWith("btime "));
+    if (!bootTimeLine) {
+      return null;
+    }
+    const bootTimeSeconds = Number.parseInt(bootTimeLine.slice("btime ".length), 10);
+    return Number.isFinite(bootTimeSeconds) ? bootTimeSeconds * 1e3 : null;
+  } catch {
+    return null;
+  }
+}
+async function readLinuxClockTicksPerSecond() {
+  if (!linuxClockTicksPerSecondPromise) {
+    linuxClockTicksPerSecondPromise = execFileAsync("getconf", ["CLK_TCK"], {
+      encoding: "utf8",
+      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+    }).then(({ stdout }) => {
+      const value = Number.parseInt(stdout.trim(), 10);
+      return Number.isFinite(value) && value > 0 ? value : null;
+    }).catch(() => null);
+  }
+  return linuxClockTicksPerSecondPromise;
+}
+async function readWindowsProcessStartedAtMs(pid) {
+  try {
+    const { stdout } = await execFileAsync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-Command",
+        `(Get-Process -Id ${String(pid)}).StartTime.ToUniversalTime().ToString("o")`
+      ],
+      {
+        encoding: "utf8",
+        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+      }
+    );
+    const isoTimestamp = stdout.trim();
+    if (!isoTimestamp) {
+      return null;
+    }
+    const startedAtMs = Date.parse(isoTimestamp);
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
+async function readPsProcessStartedAtMs(pid) {
+  try {
+    const { stdout } = await execFileAsync("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      env: PS_COMMAND_ENV,
+      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+    });
+    const startedAt = stdout.trim();
+    if (!startedAt) {
+      return null;
+    }
+    const startedAtMs = Date.parse(startedAt.replace(/\s+/g, " "));
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
 var CHROME_SINGLETON_ARTIFACTS = [
   "SingletonCookie",
   "SingletonLock",
@@ -14101,7 +14253,7 @@ var CHROME_SINGLETON_ARTIFACTS = [
 async function clearChromeSingletonEntries(userDataDir) {
   await Promise.all(
     CHROME_SINGLETON_ARTIFACTS.map(
-      (entry) => promises.rm(path7.join(userDataDir, entry), {
+      (entry) => promises.rm(path10.join(userDataDir, entry), {
         recursive: true,
         force: true
       }).catch(() => void 0)
@@ -14116,7 +14268,7 @@ async function sanitizeChromeProfile(userDataDir) {
   await Promise.all(profileDirs.map((dir) => sanitizeProfilePreferences(userDataDir, dir)));
 }
 async function sanitizeProfilePreferences(userDataDir, profileDir) {
-  const prefsPath = path7.join(userDataDir, profileDir, "Preferences");
+  const prefsPath = path10.join(userDataDir, profileDir, "Preferences");
   try {
     const raw = await promises.readFile(prefsPath, "utf8");
     const prefs = JSON.parse(raw);
@@ -14128,7 +14280,7 @@ async function sanitizeProfilePreferences(userDataDir, profileDir) {
     profile.exited_cleanly = true;
     prefs.profile = profile;
     await promises.writeFile(prefsPath, JSON.stringify(prefs), "utf8");
-    await promises.rm(path7.join(userDataDir, profileDir, "Secure Preferences"), { force: true }).catch(
+    await promises.rm(path10.join(userDataDir, profileDir, "Secure Preferences"), { force: true }).catch(
       () => void 0
     );
   } catch {
@@ -14149,9 +14301,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join(WINDOWS_PROGRAM_FILES, "Google", "Chrome", "Application", "chrome.exe"),
-        path7.join(WINDOWS_PROGRAM_FILES_X86, "Google", "Chrome", "Application", "chrome.exe"),
-        path7.join("~", "AppData", "Local", "Google", "Chrome", "Application", "chrome.exe")
+        path10.join(WINDOWS_PROGRAM_FILES, "Google", "Chrome", "Application", "chrome.exe"),
+        path10.join(WINDOWS_PROGRAM_FILES_X86, "Google", "Chrome", "Application", "chrome.exe"),
+        path10.join("~", "AppData", "Local", "Google", "Chrome", "Application", "chrome.exe")
       ],
       userDataDir: "~/AppData/Local/Google/Chrome/User Data",
       processNames: ["/google/chrome/application/chrome.exe"]
@@ -14181,7 +14333,7 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join("~", "AppData", "Local", "Google", "Chrome SxS", "Application", "chrome.exe")
+        path10.join("~", "AppData", "Local", "Google", "Chrome SxS", "Application", "chrome.exe")
       ],
       userDataDir: "~/AppData/Local/Google/Chrome SxS/User Data",
       processNames: ["/google/chrome sxs/application/chrome.exe"]
@@ -14198,9 +14350,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join(WINDOWS_PROGRAM_FILES, "Chromium", "Application", "chrome.exe"),
-        path7.join(WINDOWS_PROGRAM_FILES_X86, "Chromium", "Application", "chrome.exe"),
-        path7.join("~", "AppData", "Local", "Chromium", "Application", "chrome.exe")
+        path10.join(WINDOWS_PROGRAM_FILES, "Chromium", "Application", "chrome.exe"),
+        path10.join(WINDOWS_PROGRAM_FILES_X86, "Chromium", "Application", "chrome.exe"),
+        path10.join("~", "AppData", "Local", "Chromium", "Application", "chrome.exe")
       ],
       userDataDir: "~/AppData/Local/Chromium/User Data",
       processNames: ["/chromium/application/chrome.exe"]
@@ -14227,15 +14379,15 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join(WINDOWS_PROGRAM_FILES, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
-        path7.join(
+        path10.join(WINDOWS_PROGRAM_FILES, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+        path10.join(
           WINDOWS_PROGRAM_FILES_X86,
           "BraveSoftware",
           "Brave-Browser",
           "Application",
           "brave.exe"
         ),
-        path7.join("~", "AppData", "Local", "BraveSoftware", "Brave-Browser", "Application", "brave.exe")
+        path10.join("~", "AppData", "Local", "BraveSoftware", "Brave-Browser", "Application", "brave.exe")
       ],
       userDataDir: "~/AppData/Local/BraveSoftware/Brave-Browser/User Data",
       processNames: ["/bravesoftware/brave-browser/application/brave.exe"]
@@ -14261,9 +14413,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join(WINDOWS_PROGRAM_FILES, "Microsoft", "Edge", "Application", "msedge.exe"),
-        path7.join(WINDOWS_PROGRAM_FILES_X86, "Microsoft", "Edge", "Application", "msedge.exe"),
-        path7.join("~", "AppData", "Local", "Microsoft", "Edge", "Application", "msedge.exe")
+        path10.join(WINDOWS_PROGRAM_FILES, "Microsoft", "Edge", "Application", "msedge.exe"),
+        path10.join(WINDOWS_PROGRAM_FILES_X86, "Microsoft", "Edge", "Application", "msedge.exe"),
+        path10.join("~", "AppData", "Local", "Microsoft", "Edge", "Application", "msedge.exe")
       ],
       userDataDir: "~/AppData/Local/Microsoft/Edge/User Data",
       processNames: ["/microsoft/edge/application/msedge.exe"]
@@ -14291,9 +14443,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path7.join(WINDOWS_PROGRAM_FILES, "Vivaldi", "Application", "vivaldi.exe"),
-        path7.join(WINDOWS_PROGRAM_FILES_X86, "Vivaldi", "Application", "vivaldi.exe"),
-        path7.join("~", "AppData", "Local", "Vivaldi", "Application", "vivaldi.exe")
+        path10.join(WINDOWS_PROGRAM_FILES, "Vivaldi", "Application", "vivaldi.exe"),
+        path10.join(WINDOWS_PROGRAM_FILES_X86, "Vivaldi", "Application", "vivaldi.exe"),
+        path10.join("~", "AppData", "Local", "Vivaldi", "Application", "vivaldi.exe")
       ],
       userDataDir: "~/AppData/Local/Vivaldi/User Data",
       processNames: ["/vivaldi/application/vivaldi.exe"]
@@ -14357,35 +14509,35 @@ function detectInstalledBrowserBrands() {
       brandId: brand2.id,
       displayName: brand2.displayName,
       executablePath,
-      userDataDir: path7.resolve(expandHome(platformConfig.userDataDir))
+      userDataDir: path10.resolve(expandHome(platformConfig.userDataDir))
     });
   }
   return installations;
 }
 function resolveBrandUserDataDir(brand2, explicitDir) {
   if (explicitDir !== void 0) {
-    return path7.resolve(expandHome(explicitDir));
+    return path10.resolve(expandHome(explicitDir));
   }
   const platformConfig = resolveBrandPlatformConfig(brand2);
   if (!platformConfig) {
     throw new Error(`${brand2.displayName} is not supported on ${process.platform}.`);
   }
-  return path7.resolve(expandHome(platformConfig.userDataDir));
+  return path10.resolve(expandHome(platformConfig.userDataDir));
 }
 function resolveExecutableCandidates(candidates) {
-  return candidates.map((candidate) => candidate ? path7.resolve(expandHome(candidate)) : null);
+  return candidates.map((candidate) => candidate ? path10.resolve(expandHome(candidate)) : null);
 }
 
 // src/local-browser/chrome-discovery.ts
 function expandHome(value) {
   if (value === "~" || value.startsWith("~/")) {
-    return path7.join(os.homedir(), value.slice(1));
+    return path10.join(os.homedir(), value.slice(1));
   }
   return value;
 }
 function resolveChromeUserDataDir(userDataDir) {
   const installation = detectLocalChromeInstallations().find(
-    (candidate) => fs.existsSync(path7.join(candidate.userDataDir, "Local State")) || candidate.executablePath !== null
+    (candidate) => fs.existsSync(path10.join(candidate.userDataDir, "Local State")) || candidate.executablePath !== null
   );
   if (!installation) {
     throw new Error("Could not find a local Chrome or Chromium profile directory.");
@@ -14394,7 +14546,7 @@ function resolveChromeUserDataDir(userDataDir) {
 }
 function resolveChromeExecutablePath(executablePath) {
   if (executablePath !== void 0) {
-    const resolvedPath = path7.resolve(expandHome(executablePath));
+    const resolvedPath = path10.resolve(expandHome(executablePath));
     if (!fs.existsSync(resolvedPath)) {
       throw new Error(`Chrome executable was not found at "${resolvedPath}".`);
     }
@@ -14418,37 +14570,37 @@ function detectLocalChromeInstallations() {
           "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
           "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"
         ]),
-        userDataDir: path7.join(os.homedir(), "Library", "Application Support", "Google", "Chrome")
+        userDataDir: path10.join(os.homedir(), "Library", "Application Support", "Google", "Chrome")
       },
       {
         brand: "chromium",
         executablePath: firstExistingPath(["/Applications/Chromium.app/Contents/MacOS/Chromium"]),
-        userDataDir: path7.join(os.homedir(), "Library", "Application Support", "Chromium")
+        userDataDir: path10.join(os.homedir(), "Library", "Application Support", "Chromium")
       }
     ];
   }
   if (process.platform === "win32") {
     const programFiles = process.env.PROGRAMFILES ?? "C:\\Program Files";
     const programFilesX86 = process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)";
-    const localAppData = process.env.LOCALAPPDATA ?? path7.join(os.homedir(), "AppData", "Local");
+    const localAppData = process.env.LOCALAPPDATA ?? path10.join(os.homedir(), "AppData", "Local");
     return [
       {
         brand: "chrome",
         executablePath: firstExistingPath([
-          path7.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
-          path7.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
-          path7.join(localAppData, "Google", "Chrome", "Application", "chrome.exe")
+          path10.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
+          path10.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
+          path10.join(localAppData, "Google", "Chrome", "Application", "chrome.exe")
         ]),
-        userDataDir: path7.join(localAppData, "Google", "Chrome", "User Data")
+        userDataDir: path10.join(localAppData, "Google", "Chrome", "User Data")
       },
       {
         brand: "chromium",
         executablePath: firstExistingPath([
-          path7.join(programFiles, "Chromium", "Application", "chrome.exe"),
-          path7.join(programFilesX86, "Chromium", "Application", "chrome.exe"),
-          path7.join(localAppData, "Chromium", "Application", "chrome.exe")
+          path10.join(programFiles, "Chromium", "Application", "chrome.exe"),
+          path10.join(programFilesX86, "Chromium", "Application", "chrome.exe"),
+          path10.join(localAppData, "Chromium", "Application", "chrome.exe")
         ]),
-        userDataDir: path7.join(localAppData, "Chromium", "User Data")
+        userDataDir: path10.join(localAppData, "Chromium", "User Data")
       }
     ];
   }
@@ -14461,7 +14613,7 @@ function detectLocalChromeInstallations() {
         resolveBinaryFromPath("google-chrome"),
         resolveBinaryFromPath("google-chrome-stable")
       ]),
-      userDataDir: path7.join(os.homedir(), ".config", "google-chrome")
+      userDataDir: path10.join(os.homedir(), ".config", "google-chrome")
     },
     {
       brand: "chromium",
@@ -14471,7 +14623,7 @@ function detectLocalChromeInstallations() {
         resolveBinaryFromPath("chromium"),
         resolveBinaryFromPath("chromium-browser")
       ]),
-      userDataDir: path7.join(os.homedir(), ".config", "chromium")
+      userDataDir: path10.join(os.homedir(), ".config", "chromium")
     }
   ];
 }
@@ -14483,8 +14635,8 @@ function detectLocalBrowserInstallations() {
   }));
 }
 function listLocalChromeProfiles(userDataDir = resolveChromeUserDataDir()) {
-  const resolvedUserDataDir = path7.resolve(expandHome(userDataDir));
-  const localStatePath = path7.join(resolvedUserDataDir, "Local State");
+  const resolvedUserDataDir = path10.resolve(expandHome(userDataDir));
+  const localStatePath = path10.join(resolvedUserDataDir, "Local State");
   if (!fs.existsSync(localStatePath)) {
     return [];
   }
@@ -14496,7 +14648,7 @@ function listLocalChromeProfiles(userDataDir = resolveChromeUserDataDir()) {
     }
     return Object.entries(infoCache).map(([directory, info]) => {
       const record = info && typeof info === "object" && !Array.isArray(info) ? info : {};
-      const name = typeof record.name === "string" && record.name.trim().length > 0 ? record.name.trim() : directory || path7.basename(directory);
+      const name = typeof record.name === "string" && record.name.trim().length > 0 ? record.name.trim() : directory || path10.basename(directory);
       return {
         directory,
         name,
@@ -14508,7 +14660,7 @@ function listLocalChromeProfiles(userDataDir = resolveChromeUserDataDir()) {
   }
 }
 function readDevToolsActivePort(userDataDir) {
-  const devToolsPath = path7.join(userDataDir, "DevToolsActivePort");
+  const devToolsPath = path10.join(userDataDir, "DevToolsActivePort");
   if (!fs.existsSync(devToolsPath)) {
     return null;
   }
@@ -14741,8 +14893,8 @@ function buildBrowserWebSocketUrl(httpUrl, webSocketPath) {
   const protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
   return `${protocol}//${httpUrl.host}${normalizeWebSocketPath(webSocketPath)}`;
 }
-function normalizeWebSocketPath(path15) {
-  return path15.startsWith("/") ? path15 : `/${path15}`;
+function normalizeWebSocketPath(path18) {
+  return path18.startsWith("/") ? path18 : `/${path18}`;
 }
 function rewriteBrowserWebSocketHost(browserWsUrl, requestedUrl) {
   try {
@@ -14788,20 +14940,20 @@ var SESSION_SKIPPED_PROFILE_DIRECTORIES = /* @__PURE__ */ new Set([
   "Network"
 ]);
 async function createBrowserProfileSnapshot(input) {
-  const sourceUserDataDir = path7.resolve(expandHome(input.sourceUserDataDir));
-  const targetUserDataDir = path7.resolve(expandHome(input.targetUserDataDir));
+  const sourceUserDataDir = path10.resolve(expandHome(input.sourceUserDataDir));
+  const targetUserDataDir = path10.resolve(expandHome(input.targetUserDataDir));
   const profileDirectory = input.profileDirectory?.trim();
   const copyMode = input.copyMode;
   await promises.mkdir(targetUserDataDir, { recursive: true });
   await clearChromeSingletonEntries(targetUserDataDir);
   if (profileDirectory) {
-    const sourceProfileDir = path7.join(sourceUserDataDir, profileDirectory);
+    const sourceProfileDir = path10.join(sourceUserDataDir, profileDirectory);
     if (!fs.existsSync(sourceProfileDir)) {
       throw new Error(
         `Chrome profile "${profileDirectory}" was not found in "${sourceUserDataDir}".`
       );
     }
-    await promises.cp(sourceProfileDir, path7.join(targetUserDataDir, profileDirectory), {
+    await promises.cp(sourceProfileDir, path10.join(targetUserDataDir, profileDirectory), {
       recursive: true,
       filter: (candidate) => shouldCopyEntry({
         candidatePath: candidate,
@@ -14825,8 +14977,8 @@ async function copyRootLevelEntries(input) {
     if (CHROME_SINGLETON_ENTRIES.has(entry) || entry === input.selectedProfileDirectory) {
       continue;
     }
-    const sourcePath = path7.join(input.sourceUserDataDir, entry);
-    const targetPath = path7.join(input.targetUserDataDir, entry);
+    const sourcePath = path10.join(input.sourceUserDataDir, entry);
+    const targetPath = path10.join(input.targetUserDataDir, entry);
     const entryStat = await promises.stat(sourcePath).catch(() => null);
     if (!entryStat) {
       continue;
@@ -14858,7 +15010,7 @@ async function copyRootLevelEntries(input) {
   }
 }
 function isProfileDirectory(userDataDir, entry) {
-  return fs.existsSync(path7.join(userDataDir, entry, "Preferences"));
+  return fs.existsSync(path10.join(userDataDir, entry, "Preferences"));
 }
 function shouldCopyEntry(input) {
   const entryName = input.candidatePath.split("/").at(-1)?.split("\\").at(-1) ?? input.candidatePath;
@@ -14868,7 +15020,7 @@ function shouldCopyEntry(input) {
   if (input.copyMode !== "session") {
     return true;
   }
-  const relativePath = path7.relative(input.rootPath, input.candidatePath);
+  const relativePath = path10.relative(input.rootPath, input.candidatePath);
   if (relativePath.length === 0) {
     return true;
   }
@@ -15350,7 +15502,7 @@ function pickStealthProfilePreset(overrides) {
 var OPENSTEER_LIVE_SESSION_LAYOUT = "opensteer-session";
 var OPENSTEER_LIVE_SESSION_VERSION = 1;
 function resolveLiveSessionRecordPath(rootPath, provider) {
-  return path7__default.default.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
+  return path10__default.default.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
 }
 function resolveLocalSessionRecordPath(rootPath) {
   return resolveLiveSessionRecordPath(rootPath, "local");
@@ -15392,6 +15544,446 @@ function isPersistedCloudSessionRecord(value) {
 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;
 }
+function resolveOpensteerStateDir() {
+  const explicit = process.env.OPENSTEER_HOME?.trim();
+  if (explicit) {
+    return path10__default.default.resolve(explicit);
+  }
+  if (process.platform === "win32") {
+    return path10__default.default.join(
+      process.env.LOCALAPPDATA ?? path10__default.default.join(os.homedir(), "AppData", "Local"),
+      "Opensteer"
+    );
+  }
+  if (process.platform === "darwin") {
+    return path10__default.default.join(os.homedir(), "Library", "Application Support", "Opensteer");
+  }
+  return path10__default.default.join(
+    process.env.XDG_STATE_HOME ?? path10__default.default.join(os.homedir(), ".local", "state"),
+    "opensteer"
+  );
+}
+function resolveLocalViewRootDir() {
+  return path10__default.default.join(resolveOpensteerStateDir(), "local-view");
+}
+function resolveLocalViewPreferencesPath() {
+  return path10__default.default.join(resolveLocalViewRootDir(), "preferences.json");
+}
+function resolveLocalViewServiceDir() {
+  return path10__default.default.join(resolveLocalViewRootDir(), "service");
+}
+function resolveLocalViewSessionsDir() {
+  return path10__default.default.join(resolveLocalViewRootDir(), "sessions");
+}
+function resolveLocalViewServiceLockDir() {
+  return path10__default.default.join(resolveLocalViewServiceDir(), "startup.lock");
+}
+function resolveLocalViewServiceStatePath() {
+  return path10__default.default.join(resolveLocalViewServiceDir(), "state.json");
+}
+
+// src/local-view/preferences.ts
+var OPENSTEER_LOCAL_VIEW_PREFERENCES_LAYOUT = "opensteer-local-view-preferences";
+var OPENSTEER_LOCAL_VIEW_PREFERENCES_VERSION = 1;
+async function resolveLocalViewMode() {
+  const preferences = await readLocalViewPreferences();
+  return preferences?.mode ?? "auto";
+}
+async function readLocalViewPreferences() {
+  const preferencesPath = resolveLocalViewPreferencesPath();
+  if (!await pathExists(preferencesPath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(preferencesPath);
+  return isPersistedLocalViewPreferences(parsed) ? parsed : void 0;
+}
+function isPersistedLocalViewPreferences(value) {
+  return value?.layout === OPENSTEER_LOCAL_VIEW_PREFERENCES_LAYOUT && value.version === OPENSTEER_LOCAL_VIEW_PREFERENCES_VERSION && (value.mode === "auto" || value.mode === "manual") && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
+}
+var LOCK_OWNER_FILE = "owner.json";
+var LOCK_RECLAIMER_DIR = "reclaimer";
+var LOCK_RETRY_DELAY_MS = 50;
+async function acquireDirLock(lockDirPath) {
+  while (true) {
+    const releaseLock = await tryAcquireDirLock(lockDirPath);
+    if (releaseLock) {
+      return releaseLock;
+    }
+    await sleep(LOCK_RETRY_DELAY_MS);
+  }
+}
+async function tryAcquireDirLock(lockDirPath) {
+  await promises.mkdir(path10.dirname(lockDirPath), { recursive: true });
+  while (true) {
+    const tempLockDirPath = `${lockDirPath}-${String(process.pid)}-${String(CURRENT_PROCESS_OWNER.processStartedAtMs)}-${crypto.randomUUID()}`;
+    try {
+      await promises.mkdir(tempLockDirPath);
+      await writeLockOwner(tempLockDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await promises.rename(tempLockDirPath, lockDirPath);
+        break;
+      } catch (error) {
+        if (!wasDirPublishedByAnotherProcess(error, lockDirPath)) {
+          throw error;
+        }
+      }
+    } finally {
+      await promises.rm(tempLockDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+    const owner = await readLockOwner(lockDirPath);
+    if ((!owner || await getProcessLiveness(owner) === "dead") && await tryReclaimStaleLock(lockDirPath, owner)) {
+      continue;
+    }
+    return null;
+  }
+  return async () => {
+    await promises.rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  };
+}
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function wasDirPublishedByAnotherProcess(error, targetDirPath) {
+  const code = getErrorCode(error);
+  return fs.existsSync(targetDirPath) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
+}
+async function writeLockOwner(lockDirPath, owner) {
+  await promises.writeFile(path10.join(lockDirPath, LOCK_OWNER_FILE), JSON.stringify(owner));
+}
+async function readLockOwner(lockDirPath) {
+  return readLockParticipant(path10.join(lockDirPath, LOCK_OWNER_FILE));
+}
+async function readLockParticipant(filePath) {
+  return (await readLockParticipantRecord(filePath)).owner;
+}
+async function readLockParticipantRecord(filePath) {
+  try {
+    const raw = await promises.readFile(filePath, "utf8");
+    return {
+      exists: true,
+      owner: parseProcessOwner(JSON.parse(raw))
+    };
+  } catch (error) {
+    return {
+      exists: getErrorCode(error) !== "ENOENT",
+      owner: null
+    };
+  }
+}
+async function readLockReclaimerRecord(lockDirPath) {
+  return readLockParticipantRecord(path10.join(buildLockReclaimerDirPath(lockDirPath), LOCK_OWNER_FILE));
+}
+async function tryReclaimStaleLock(lockDirPath, expectedOwner) {
+  if (!await tryAcquireLockReclaimer(lockDirPath)) {
+    return false;
+  }
+  let reclaimed = false;
+  try {
+    const owner = await readLockOwner(lockDirPath);
+    if (!processOwnersEqual(owner, expectedOwner)) {
+      return false;
+    }
+    if (owner && await getProcessLiveness(owner) !== "dead") {
+      return false;
+    }
+    await promises.rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+    reclaimed = !fs.existsSync(lockDirPath);
+    return reclaimed;
+  } finally {
+    if (!reclaimed) {
+      await promises.rm(buildLockReclaimerDirPath(lockDirPath), {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+  }
+}
+async function tryAcquireLockReclaimer(lockDirPath) {
+  const reclaimerDirPath = buildLockReclaimerDirPath(lockDirPath);
+  while (true) {
+    const tempReclaimerDirPath = `${reclaimerDirPath}-${String(process.pid)}-${String(CURRENT_PROCESS_OWNER.processStartedAtMs)}-${crypto.randomUUID()}`;
+    try {
+      await promises.mkdir(tempReclaimerDirPath);
+      await writeLockOwner(tempReclaimerDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await promises.rename(tempReclaimerDirPath, reclaimerDirPath);
+        return true;
+      } catch (error) {
+        if (getErrorCode(error) === "ENOENT") {
+          return false;
+        }
+        if (!wasDirPublishedByAnotherProcess(error, reclaimerDirPath)) {
+          throw error;
+        }
+      }
+    } catch (error) {
+      if (getErrorCode(error) === "ENOENT") {
+        return false;
+      }
+      throw error;
+    } finally {
+      await promises.rm(tempReclaimerDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+    const reclaimerRecord = await readLockReclaimerRecord(lockDirPath);
+    if (!reclaimerRecord.exists || !reclaimerRecord.owner) {
+      return false;
+    }
+    if (await getProcessLiveness(reclaimerRecord.owner) !== "dead") {
+      return false;
+    }
+    await promises.rm(reclaimerDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  }
+}
+function buildLockReclaimerDirPath(lockDirPath) {
+  return path10.join(lockDirPath, LOCK_RECLAIMER_DIR);
+}
+async function sleep(ms) {
+  await new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+var OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT = "opensteer-local-view-service";
+var OPENSTEER_LOCAL_VIEW_SERVICE_VERSION = 3;
+async function readLocalViewServiceState() {
+  const statePath = resolveLocalViewServiceStatePath();
+  if (!await pathExists(statePath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(statePath);
+  if (!isPersistedLocalViewServiceState(parsed)) {
+    return void 0;
+  }
+  return parsed;
+}
+async function isLocalViewServiceStateLive(state) {
+  return await getLocalViewServiceStateLiveness(state) !== "dead";
+}
+async function getLocalViewServiceStateLiveness(state) {
+  if (state === void 0) {
+    return "dead";
+  }
+  return getProcessLiveness({
+    pid: state.pid,
+    processStartedAtMs: state.processStartedAtMs
+  });
+}
+function isPersistedLocalViewServiceState(value) {
+  return value?.layout === OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT && value.version === OPENSTEER_LOCAL_VIEW_SERVICE_VERSION && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.processStartedAtMs === "number" && Number.isFinite(value.processStartedAtMs) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.port === "number" && Number.isFinite(value.port) && typeof value.token === "string" && value.token.length > 0 && typeof value.url === "string" && value.url.length > 0;
+}
+
+// src/local-view/service.ts
+var LOCAL_VIEW_STARTUP_TIMEOUT_MS = 1e4;
+var LOCAL_VIEW_STARTUP_POLL_MS = 100;
+async function ensureLocalViewServiceRunning() {
+  const current = await readReachableLocalViewServiceState();
+  if (current !== void 0) {
+    return current;
+  }
+  const releaseLock = await acquireDirLock(resolveLocalViewServiceLockDir());
+  try {
+    const lockedState = await readReachableLocalViewServiceState();
+    if (lockedState !== void 0) {
+      return lockedState;
+    }
+    await spawnLocalViewService();
+    const started = await waitForLocalViewService();
+    if (!started) {
+      throw new Error("Timed out while starting the local view service.");
+    }
+    return started;
+  } finally {
+    await releaseLock();
+  }
+}
+function spawnLocalViewService() {
+  const command = resolveLocalViewSpawnCommand();
+  const child = child_process.spawn(command.executable, command.args, {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      ...command.env ?? {},
+      OPENSTEER_LOCAL_VIEW_BOOT_TOKEN: process.env.OPENSTEER_LOCAL_VIEW_BOOT_TOKEN ?? crypto.randomBytes(24).toString("hex")
+    },
+    detached: process.platform !== "win32",
+    stdio: "ignore"
+  });
+  child.unref();
+}
+async function waitForLocalViewService() {
+  const deadline = Date.now() + LOCAL_VIEW_STARTUP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const state = await readReachableLocalViewServiceState();
+    if (state !== void 0) {
+      return state;
+    }
+    await delay(LOCAL_VIEW_STARTUP_POLL_MS);
+  }
+  return void 0;
+}
+async function readReachableLocalViewServiceState() {
+  const state = await readLocalViewServiceState();
+  if (state === void 0 || !await isLocalViewServiceStateLive(state)) {
+    return void 0;
+  }
+  return await isLocalViewServiceReachable(state.url, state.token) ? state : void 0;
+}
+async function isLocalViewServiceReachable(baseUrl, token) {
+  try {
+    const response = await fetch(new URL("/api/health", baseUrl), {
+      headers: {
+        "x-opensteer-local-token": token
+      }
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function resolveLocalViewSpawnCommand() {
+  const moduleDir = path10__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+  const distServicePath = findExistingPath([
+    path10__default.default.join(moduleDir, "local-view", "serve-entry.js"),
+    path10__default.default.join(moduleDir, "serve-entry.js"),
+    path10__default.default.join(moduleDir, "..", "local-view", "serve-entry.js")
+  ]);
+  if (distServicePath) {
+    return {
+      executable: process.execPath,
+      args: [distServicePath]
+    };
+  }
+  const distCliPath = findExistingPath([
+    path10__default.default.join(moduleDir, "cli", "bin.js"),
+    path10__default.default.join(moduleDir, "..", "cli", "bin.js")
+  ]);
+  if (distCliPath) {
+    return {
+      executable: process.execPath,
+      args: [distCliPath, "view", "serve"]
+    };
+  }
+  const srcServicePath = findExistingPath([
+    path10__default.default.join(moduleDir, "serve-entry.ts"),
+    path10__default.default.join(moduleDir, "..", "local-view", "serve-entry.ts"),
+    path10__default.default.join(moduleDir, "..", "src", "local-view", "serve-entry.ts")
+  ]);
+  if (srcServicePath) {
+    const require2 = 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)));
+    const tsxLoaderPath = require2.resolve("tsx");
+    const tsconfigPath = findNearestTsconfig(path10__default.default.resolve(moduleDir, "..", "..", ".."));
+    return {
+      executable: process.execPath,
+      args: ["--import", tsxLoaderPath, srcServicePath],
+      ...tsconfigPath ? { env: { TSX_TSCONFIG_PATH: tsconfigPath } } : {}
+    };
+  }
+  const srcCliPath = findExistingPath([
+    path10__default.default.join(moduleDir, "..", "cli", "bin.ts"),
+    path10__default.default.join(moduleDir, "..", "src", "cli", "bin.ts")
+  ]);
+  if (srcCliPath) {
+    const require2 = 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)));
+    const tsxLoaderPath = require2.resolve("tsx");
+    const tsconfigPath = findNearestTsconfig(path10__default.default.resolve(moduleDir, "..", "..", ".."));
+    return {
+      executable: process.execPath,
+      args: ["--import", tsxLoaderPath, srcCliPath, "view", "serve"],
+      ...tsconfigPath ? { env: { TSX_TSCONFIG_PATH: tsconfigPath } } : {}
+    };
+  }
+  throw new Error(`Could not resolve the Opensteer CLI entrypoint from ${moduleDir}.`);
+}
+function findExistingPath(candidates) {
+  return candidates.find((candidate) => fs.existsSync(candidate));
+}
+function findNearestTsconfig(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    const candidate = path10__default.default.join(currentDir, "tsconfig.json");
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parentDir = path10__default.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
+  });
+}
+var OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT = "opensteer-local-view-session";
+var OPENSTEER_LOCAL_VIEW_SESSION_VERSION = 1;
+function buildLocalViewSessionId(input) {
+  const hash = crypto.createHash("sha256").update(`${input.rootPath}
+${String(input.pid)}
+${String(input.startedAt)}`).digest("hex");
+  return `local_${hash.slice(0, 24)}`;
+}
+function createLocalViewSessionManifest(input) {
+  return {
+    layout: OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT,
+    version: OPENSTEER_LOCAL_VIEW_SESSION_VERSION,
+    sessionId: buildLocalViewSessionId({
+      rootPath: input.rootPath,
+      pid: input.live.pid,
+      startedAt: input.live.startedAt
+    }),
+    rootPath: input.rootPath,
+    ...input.workspace === void 0 ? {} : { workspace: input.workspace },
+    engine: input.live.engine,
+    ownership: input.ownership,
+    pid: input.live.pid,
+    startedAt: input.live.startedAt,
+    updatedAt: Date.now()
+  };
+}
+async function writeLocalViewSessionManifest(manifest) {
+  await ensureDirectory(resolveLocalViewSessionsDir());
+  await writeJsonFileAtomic(resolveLocalViewSessionManifestPath(manifest.sessionId), manifest);
+}
+async function deleteLocalViewSessionManifest(sessionId) {
+  await promises.rm(resolveLocalViewSessionManifestPath(sessionId), { force: true }).catch(() => void 0);
+}
+function resolveLocalViewSessionManifestPath(sessionId) {
+  return path10__default.default.join(resolveLocalViewSessionsDir(), `${sessionId}.json`);
+}
+
+// src/local-view/registration.ts
+async function bestEffortRegisterLocalViewSession(input) {
+  try {
+    const manifest = createLocalViewSessionManifest(input);
+    await writeLocalViewSessionManifest(manifest);
+    if (await resolveLocalViewMode() === "auto") {
+      void ensureLocalViewServiceRunning().catch(() => void 0);
+    }
+    return manifest;
+  } catch {
+    return void 0;
+  }
+}
+async function bestEffortUnregisterLocalViewSession(sessionId) {
+  if (!sessionId) {
+    return;
+  }
+  await deleteLocalViewSessionManifest(sessionId).catch(() => void 0);
+}
 
 // ../runtime-core/src/internal/engine-selection.ts
 var OPENSTEER_ENGINE_NAMES = ["playwright", "abp"];
@@ -15510,8 +16102,8 @@ var OpensteerBrowserManager = class {
       ...options.browser === void 0 ? {} : { browser: options.browser },
       ...this.contextOptions === void 0 ? {} : { context: this.contextOptions }
     });
-    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path7__default.default.join(os.tmpdir(), `${TEMPORARY_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
-      rootDir: path7__default.default.resolve(options.rootDir ?? process.cwd()),
+    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path10__default.default.join(os.tmpdir(), `${TEMPORARY_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
+      rootDir: path10__default.default.resolve(options.rootDir ?? process.cwd()),
       workspace: this.workspace
     }));
     this.cleanupRootOnDisconnect = this.workspace === void 0;
@@ -15572,7 +16164,7 @@ var OpensteerBrowserManager = class {
         userDataDir: "browser/user-data",
         bootstrap: {
           kind: "cloneLocalProfile",
-          sourceUserDataDir: path7__default.default.resolve(input.sourceUserDataDir),
+          sourceUserDataDir: path10__default.default.resolve(input.sourceUserDataDir),
           ...input.sourceProfileDirectory === void 0 ? {} : { sourceProfileDirectory: input.sourceProfileDirectory }
         }
       };
@@ -15645,6 +16237,12 @@ var OpensteerBrowserManager = class {
             `workspace "${this.workspace}" already has a live ${live.engine} browser. Close it before reopening with engine "abp".`
           );
         }
+        await bestEffortRegisterLocalViewSession({
+          rootPath: workspace.rootPath,
+          ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+          live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
+          ownership: "owned"
+        });
         return this.createAdoptedAbpEngine(live);
       }
       await this.ensurePersistentBrowserManifest(workspace);
@@ -15677,9 +16275,17 @@ var OpensteerBrowserManager = class {
         ...launch?.browserExecutablePath === void 0 ? {} : { executablePath: launch.browserExecutablePath }
       };
       await this.writeLivePersistentBrowser(workspace, liveRecord);
+      const persistedLiveRecord = toPersistedLocalBrowserSessionRecord(this.workspace, liveRecord);
+      await bestEffortRegisterLocalViewSession({
+        rootPath: workspace.rootPath,
+        ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+        live: persistedLiveRecord,
+        ownership: "owned"
+      });
       try {
         return await this.createAdoptedAbpEngine(liveRecord);
       } catch (error) {
+        await this.unregisterLocalViewSessionForRecord(workspace.rootPath, persistedLiveRecord);
         await terminateProcess(launched.process.pid ?? 0).catch(() => void 0);
         await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
         throw error;
@@ -15699,23 +16305,45 @@ var OpensteerBrowserManager = class {
     });
   }
   async createTemporaryEngine() {
-    const userDataDir = await promises.mkdtemp(path7__default.default.join(os.tmpdir(), "opensteer-temporary-browser-"));
+    const userDataDir = await promises.mkdtemp(path10__default.default.join(os.tmpdir(), "opensteer-temporary-browser-"));
     await clearChromeSingletonEntries(userDataDir);
     const launched = await launchOwnedBrowser({
       userDataDir,
       ...this.launchOptions === void 0 ? {} : { launch: this.launchOptions },
       ...this.contextOptions?.viewport === void 0 ? {} : { viewport: this.contextOptions.viewport }
     });
+    const temporaryLiveRecord = {
+      layout: "opensteer-session",
+      version: 1,
+      provider: "local",
+      engine: "playwright",
+      endpoint: launched.endpoint,
+      pid: launched.pid,
+      startedAt: Date.now(),
+      updatedAt: Date.now(),
+      executablePath: launched.executablePath,
+      userDataDir
+    };
+    await writePersistedSessionRecord(this.rootPath, temporaryLiveRecord);
+    const localViewManifest = await bestEffortRegisterLocalViewSession({
+      rootPath: this.rootPath,
+      live: temporaryLiveRecord,
+      ownership: "owned"
+    });
     try {
       return await this.createAttachedEngine({
         endpoint: launched.endpoint,
         freshTab: false,
         onDispose: async () => {
+          await bestEffortUnregisterLocalViewSession(localViewManifest?.sessionId);
+          await clearPersistedSessionRecord(this.rootPath, "local").catch(() => void 0);
           await terminateProcess(launched.pid).catch(() => void 0);
           await promises.rm(userDataDir, { recursive: true, force: true }).catch(() => void 0);
         }
       });
     } catch (error) {
+      await bestEffortUnregisterLocalViewSession(localViewManifest?.sessionId);
+      await clearPersistedSessionRecord(this.rootPath, "local").catch(() => void 0);
       await terminateProcess(launched.pid).catch(() => void 0);
       await promises.rm(userDataDir, { recursive: true, force: true }).catch(() => void 0);
       throw error;
@@ -15743,6 +16371,12 @@ var OpensteerBrowserManager = class {
         if (live.endpoint === void 0) {
           throw new Error("workspace live browser record is missing a DevTools endpoint.");
         }
+        await bestEffortRegisterLocalViewSession({
+          rootPath: workspace.rootPath,
+          ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+          live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
+          ownership: "owned"
+        });
         return this.createAttachedEngine({
           endpoint: live.endpoint,
           freshTab: false,
@@ -15765,6 +16399,13 @@ var OpensteerBrowserManager = class {
         userDataDir: workspace.browserUserDataDir
       };
       await this.writeLivePersistentBrowser(workspace, liveRecord);
+      const persistedLiveRecord = toPersistedLocalBrowserSessionRecord(this.workspace, liveRecord);
+      await bestEffortRegisterLocalViewSession({
+        rootPath: workspace.rootPath,
+        ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+        live: persistedLiveRecord,
+        ownership: "owned"
+      });
       try {
         return await this.createAttachedEngine({
           endpoint: launched.endpoint,
@@ -15772,6 +16413,7 @@ var OpensteerBrowserManager = class {
           onDispose: async () => void 0
         });
       } catch (error) {
+        await this.unregisterLocalViewSessionForRecord(workspace.rootPath, persistedLiveRecord);
         await terminateProcess(launched.pid).catch(() => void 0);
         await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
         throw error;
@@ -15922,6 +16564,10 @@ var OpensteerBrowserManager = class {
       await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
       return;
     }
+    await this.unregisterLocalViewSessionForRecord(
+      workspace.rootPath,
+      toPersistedLocalBrowserSessionRecord(this.workspace, live)
+    );
     if (live.engine === "playwright") {
       if (live.endpoint !== void 0) {
         await requestBrowserClose(live.endpoint).catch(() => void 0);
@@ -15948,6 +16594,15 @@ var OpensteerBrowserManager = class {
       throw new Error(`browser.${method}() requires a persistent workspace browser.`);
     }
   }
+  async unregisterLocalViewSessionForRecord(rootPath, record) {
+    await bestEffortUnregisterLocalViewSession(
+      buildLocalViewSessionId({
+        rootPath,
+        pid: record.pid,
+        startedAt: record.startedAt
+      })
+    );
+  }
 };
 function normalizeWorkspace(workspace) {
   const normalized = workspace?.trim();
@@ -16113,7 +16768,7 @@ async function waitForDevToolsEndpoint(input) {
     if (exitCode !== null) {
       throw new Error(formatChromeLaunchError(input.stderrLines));
     }
-    await sleep(DEVTOOLS_POLL_INTERVAL_MS);
+    await sleep2(DEVTOOLS_POLL_INTERVAL_MS);
   }
   throw new Error(formatChromeLaunchError(input.stderrLines));
 }
@@ -16261,12 +16916,12 @@ async function waitForProcessExit(pid, timeoutMs) {
     if (!isProcessRunning(pid)) {
       return true;
     }
-    await sleep(50);
+    await sleep2(50);
   }
   return !isProcessRunning(pid);
 }
 function resolveAbpSessionDir(workspace) {
-  return path7__default.default.join(workspace.livePath, "abp-session");
+  return path10__default.default.join(workspace.livePath, "abp-session");
 }
 async function allocateEphemeralPort() {
   const { allocatePort } = await loadAbpModule();
@@ -16323,14 +16978,14 @@ function resolveStealthProfile(input) {
 function isStealthProfile(input) {
   return input.id !== void 0 && input.platform !== void 0 && input.browserBrand !== void 0 && input.browserVersion !== void 0 && input.userAgent !== void 0 && input.viewport !== void 0 && input.screenResolution !== void 0 && input.devicePixelRatio !== void 0 && input.maxTouchPoints !== void 0 && input.webglVendor !== void 0 && input.webglRenderer !== void 0 && input.fonts !== void 0 && input.canvasNoiseSeed !== void 0 && input.audioNoiseSeed !== void 0 && input.locale !== void 0 && input.timezoneId !== void 0;
 }
-async function sleep(ms) {
+async function sleep2(ms) {
   await new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 var ENV_FILENAMES = [".env", ".env.local"];
 var OPENSTEER_ENV_PREFIX = "OPENSTEER_";
 var opensteerEnvironmentCache = /* @__PURE__ */ new Map();
 function resolveOpensteerEnvironment(cwd = process.cwd(), baseEnv = process.env) {
-  const resolvedCwd = path7__default.default.resolve(cwd);
+  const resolvedCwd = path10__default.default.resolve(cwd);
   const signature = buildEnvironmentSignature(baseEnv, isOpensteerEnvironmentKey);
   const cached = opensteerEnvironmentCache.get(resolvedCwd);
   if (cached && cached.signature === signature) {
@@ -16345,10 +17000,10 @@ function resolveOpensteerEnvironment(cwd = process.cwd(), baseEnv = process.env)
 }
 function collectDirectories(cwd) {
   const directories = [];
-  let current = path7__default.default.resolve(cwd);
+  let current = path10__default.default.resolve(cwd);
   for (; ; ) {
     directories.unshift(current);
-    const parent = path7__default.default.dirname(current);
+    const parent = path10__default.default.dirname(current);
     if (parent === current) {
       return directories;
     }
@@ -16391,7 +17046,7 @@ function resolveEnvironmentFiles(cwd, baseEnv, predicate) {
   const directories = collectDirectories(cwd);
   for (const directory of directories) {
     for (const filename of ENV_FILENAMES) {
-      const filePath = path7__default.default.join(directory, filename);
+      const filePath = path10__default.default.join(directory, filename);
       if (!fs.existsSync(filePath)) {
         continue;
       }
@@ -16470,17 +17125,17 @@ async function readBrowserCookies(input = {}) {
   const brand2 = resolveRequestedBrand(input);
   const userDataDir = resolveBrandUserDataDir(brand2, input.userDataDir);
   const profileDirectory = input.profileDirectory ?? "Default";
-  const cookiesPath = path7.join(userDataDir, profileDirectory, "Cookies");
+  const cookiesPath = path10.join(userDataDir, profileDirectory, "Cookies");
   if (!fs.existsSync(cookiesPath)) {
     throw new Error(
       `Cookies database not found at "${cookiesPath}". Verify the browser brand, user-data-dir, and profile-directory are correct.`
     );
   }
-  const tempDir = await promises.mkdtemp(path7.join(os.tmpdir(), "opensteer-cookies-"));
+  const tempDir = await promises.mkdtemp(path10.join(os.tmpdir(), "opensteer-cookies-"));
   try {
     await copyCookiesDatabase(cookiesPath, tempDir);
     const decryptionKey = await resolveDecryptionKey(brand2.id, userDataDir);
-    const rows = queryAllCookies(path7.join(tempDir, "Cookies"));
+    const rows = queryAllCookies(path10.join(tempDir, "Cookies"));
     const cookies = decryptCookieRows(rows, decryptionKey);
     return {
       cookies,
@@ -16506,11 +17161,11 @@ function resolveRequestedBrand(input) {
   return installed.brand;
 }
 async function copyCookiesDatabase(cookiesPath, destDir) {
-  await promises.copyFile(cookiesPath, path7.join(destDir, "Cookies"));
+  await promises.copyFile(cookiesPath, path10.join(destDir, "Cookies"));
   for (const suffix of ["-wal", "-journal", "-shm"]) {
     const src = cookiesPath + suffix;
     if (fs.existsSync(src)) {
-      await promises.copyFile(src, path7.join(destDir, "Cookies" + suffix)).catch(() => void 0);
+      await promises.copyFile(src, path10.join(destDir, "Cookies" + suffix)).catch(() => void 0);
     }
   }
 }
@@ -16587,7 +17242,7 @@ async function resolveKeychainPassword(brandId) {
   }
 }
 async function resolveWindowsMasterKey(userDataDir) {
-  const localStatePath = path7.join(userDataDir, "Local State");
+  const localStatePath = path10.join(userDataDir, "Local State");
   let localState;
   try {
     localState = JSON.parse(await promises.readFile(localStatePath, "utf8"));
@@ -16788,14 +17443,14 @@ function toPortableBrowserProfileCookieRecord(cookie) {
   if (!name || !domain) {
     return null;
   }
-  const path15 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
+  const path18 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
   const expiresAt = typeof cookie.expires === "number" && Number.isFinite(cookie.expires) && cookie.expires > 0 ? Math.floor(cookie.expires * 1e3) : null;
   const sameSite = normalizeSameSite(cookie.sameSite);
   return {
     name,
     value: cookie.value,
     domain,
-    path: path15,
+    path: path18,
     secure: cookie.secure,
     httpOnly: cookie.httpOnly,
     ...sameSite === void 0 ? {} : { sameSite },
@@ -16864,7 +17519,7 @@ async function waitForBrowserProfileImport(client, importId) {
     if (current.status === "failed") {
       throw new Error(current.error ?? "Browser profile sync failed.");
     }
-    await sleep2(DEFAULT_POLL_INTERVAL_MS);
+    await sleep3(DEFAULT_POLL_INTERVAL_MS);
   }
   throw new Error(`Timed out waiting for browser profile sync "${importId}" to finish.`);
 }
@@ -16873,7 +17528,7 @@ function normalizePlatform(platform) {
   if (platform === "win32") return "windows";
   return platform;
 }
-async function sleep2(ms) {
+async function sleep3(ms) {
   await new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
@@ -17071,7 +17726,7 @@ var OpensteerCloudClient = class {
           `Unexpected cloud session status "${String(session.status)}" while waiting for close.`
         );
       }
-      await delay(CLOUD_CLOSE_POLL_INTERVAL_MS);
+      await delay2(CLOUD_CLOSE_POLL_INTERVAL_MS);
     }
     throw new Error(`Timed out waiting for cloud session ${sessionId} to close.`);
   }
@@ -17083,7 +17738,7 @@ function createRequestSignal(options) {
   }
   return AbortSignal.any([options.signal, timeoutSignal]);
 }
-function delay(ms) {
+function delay2(ms) {
   return new Promise((resolve4) => {
     setTimeout(resolve4, ms);
   });
@@ -17133,7 +17788,7 @@ function resolveCloudConfig(input = {}) {
 
 // ../runtime-core/package.json
 var package_default = {
-  version: "0.2.0"};
+  version: "0.2.1"};
 
 // ../runtime-core/src/version.ts
 var OPENSTEER_RUNTIME_CORE_VERSION = package_default.version;
@@ -17889,11 +18544,11 @@ var NetworkHistory = class {
 var MATCHED_TLS_BINARY_NAMES = ["curl-impersonate-chrome", "curl_chrome"];
 async function executeMatchedTlsTransportRequest(input) {
   const binary = await resolveMatchedTlsBinary();
-  const workingDirectory = await promises.mkdtemp(path7__default.default.join(os.tmpdir(), "opensteer-matched-tls-"));
-  const headersPath = path7__default.default.join(workingDirectory, "headers.txt");
-  const bodyPath = path7__default.default.join(workingDirectory, "body.bin");
-  const cookiesPath = path7__default.default.join(workingDirectory, "cookies.txt");
-  const requestBodyPath = path7__default.default.join(workingDirectory, "request-body.bin");
+  const workingDirectory = await promises.mkdtemp(path10__default.default.join(os.tmpdir(), "opensteer-matched-tls-"));
+  const headersPath = path10__default.default.join(workingDirectory, "headers.txt");
+  const bodyPath = path10__default.default.join(workingDirectory, "body.bin");
+  const cookiesPath = path10__default.default.join(workingDirectory, "cookies.txt");
+  const requestBodyPath = path10__default.default.join(workingDirectory, "request-body.bin");
   try {
     await promises.writeFile(cookiesPath, toNetscapeCookieJar(input.cookies ?? []), "utf8");
     if (input.request.body !== void 0) {
@@ -17950,10 +18605,10 @@ async function executeMatchedTlsTransportRequest(input) {
   }
 }
 async function resolveMatchedTlsBinary() {
-  const pathEntries = (process.env.PATH ?? "").split(path7__default.default.delimiter).filter((entry) => entry.length > 0);
+  const pathEntries = (process.env.PATH ?? "").split(path10__default.default.delimiter).filter((entry) => entry.length > 0);
   for (const directory of pathEntries) {
     for (const name of MATCHED_TLS_BINARY_NAMES) {
-      const candidate = path7__default.default.join(directory, name);
+      const candidate = path10__default.default.join(directory, name);
       if (await isExecutable(candidate)) {
         return candidate;
       }
@@ -17961,7 +18616,7 @@ async function resolveMatchedTlsBinary() {
     const files = await readDirSafe(directory);
     const discovered = files.find((file) => file.startsWith("curl_chrome"));
     if (discovered !== void 0) {
-      const candidate = path7__default.default.join(directory, discovered);
+      const candidate = path10__default.default.join(directory, discovered);
       if (await isExecutable(candidate)) {
         return candidate;
       }
@@ -20415,11 +21070,11 @@ var SandboxClock = class {
   performanceNow() {
     return this.mode === "manual" ? this.manualNow - this.startedAt : (globalThis.performance?.now() ?? 0) - this.performanceStartedAt;
   }
-  setTimeout(callback, delay3 = 0, ...args) {
-    return this.registerTimer(false, callback, delay3, args);
+  setTimeout(callback, delay4 = 0, ...args) {
+    return this.registerTimer(false, callback, delay4, args);
   }
-  setInterval(callback, delay3 = 0, ...args) {
-    return this.registerTimer(true, callback, delay3, args);
+  setInterval(callback, delay4 = 0, ...args) {
+    return this.registerTimer(true, callback, delay4, args);
   }
   clearTimeout(timerId) {
     this.clearTimer(timerId);
@@ -20440,9 +21095,9 @@ var SandboxClock = class {
       this.clearTimer(timerId);
     }
   }
-  registerTimer(repeat, callback, delay3, args) {
+  registerTimer(repeat, callback, delay4, args) {
     const timerId = this.nextTimerId++;
-    const normalizedDelay = Math.max(0, delay3);
+    const normalizedDelay = Math.max(0, delay4);
     const record = {
       callback,
       args,
@@ -20606,7 +21261,7 @@ async function pollTask(apiKey, taskId, signal) {
   const deadline = Date.now() + 12e4;
   while (Date.now() < deadline) {
     signal?.throwIfAborted?.();
-    await sleep3(3e3, signal);
+    await sleep4(3e3, signal);
     const response = await fetch(CAPSOLVER_GET_TASK_RESULT_URL, {
       method: "POST",
       headers: {
@@ -20650,7 +21305,7 @@ function extractCaptchaToken(solution) {
 function readString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function sleep3(ms, signal) {
+function sleep4(ms, signal) {
   return new Promise((resolve4, reject) => {
     const timeout = setTimeout(resolve4, ms);
     const abort = () => {
@@ -20704,7 +21359,7 @@ async function pollTask2(apiKey, taskId, signal) {
   const deadline = Date.now() + 12e4;
   while (Date.now() < deadline) {
     signal?.throwIfAborted?.();
-    await sleep4(5e3, signal);
+    await sleep5(5e3, signal);
     const response = await fetch(TWO_CAPTCHA_GET_TASK_RESULT_URL, {
       method: "POST",
       headers: {
@@ -20748,7 +21403,7 @@ function extractCaptchaToken2(solution) {
 function readString2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function sleep4(ms, signal) {
+function sleep5(ms, signal) {
   return new Promise((resolve4, reject) => {
     const timeout = setTimeout(resolve4, ms);
     const abort = () => {
@@ -20985,7 +21640,7 @@ var OpensteerSessionRuntime = class {
     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 ?? path7__default.default.resolve(process.cwd(), ".opensteer", "temporary", crypto.randomUUID());
+    this.rootPath = options.workspace?.rootPath ?? options.rootPath ?? path10__default.default.resolve(process.cwd(), ".opensteer", "temporary", crypto.randomUUID());
     this.injectedEngine = options.engine;
     this.engineFactory = options.engineFactory;
     this.policy = options.policy ?? defaultPolicy();
@@ -26774,8 +27429,8 @@ var CloudSessionProxy = class {
     this.workspace = options.workspace;
     this.policy = options.policy ?? defaultPolicy();
     this.observability = options.observability;
-    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path7__default.default.join(os.tmpdir(), `${TEMPORARY_CLOUD_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
-      rootDir: path7__default.default.resolve(options.rootDir ?? process.cwd()),
+    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path10__default.default.join(os.tmpdir(), `${TEMPORARY_CLOUD_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
+      rootDir: path10__default.default.resolve(options.rootDir ?? process.cwd()),
       workspace: this.workspace
     }));
     this.cleanupRootOnClose = options.cleanupRootOnClose ?? this.workspace === void 0;
@@ -27197,8 +27852,8 @@ function isLoopbackBaseUrl(baseUrl) {
 var OpensteerRuntime = class extends OpensteerSessionRuntime {
   constructor(options = {}) {
     const publicWorkspace = normalizeWorkspace2(options.workspace);
-    const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path7__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : resolveFilesystemWorkspacePath({
-      rootDir: path7__default.default.resolve(options.rootDir ?? process.cwd()),
+    const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path10__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : resolveFilesystemWorkspacePath({
+      rootDir: path10__default.default.resolve(options.rootDir ?? process.cwd()),
       workspace: publicWorkspace
     }));
     const cleanupRootOnClose = options.cleanupRootOnClose ?? publicWorkspace === void 0;
@@ -27232,7 +27887,7 @@ var OpensteerRuntime = class extends OpensteerSessionRuntime {
 };
 var OpensteerSessionRuntime2 = class extends OpensteerSessionRuntime {
   constructor(options) {
-    const rootPath = options.rootPath ?? path7__default.default.resolve(options.rootDir ?? process.cwd());
+    const rootPath = options.rootPath ?? path10__default.default.resolve(options.rootDir ?? process.cwd());
     const cleanupRootOnClose = options.cleanupRootOnClose ?? false;
     const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
     assertSupportedEngineOptions({
@@ -27522,7 +28177,7 @@ var Opensteer = class {
       if (Date.now() >= timeoutAt) {
         throw new Error("waitForNetwork timed out");
       }
-      await delay2(pollInterval);
+      await delay3(pollInterval);
     }
   }
   async waitForResponse(input) {
@@ -27551,7 +28206,7 @@ var Opensteer = class {
       if (Date.now() >= timeoutAt) {
         throw new Error("waitForPage timed out");
       }
-      await delay2(pollIntervalMs);
+      await delay3(pollIntervalMs);
     }
   }
   async snapshot(mode = "action") {
@@ -27703,7 +28358,7 @@ function decodeBody(response) {
   }
   return Uint8Array.from(Buffer.from(response.body.data, "base64"));
 }
-function delay2(ms) {
+function delay3(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }