opensteer 0.9.0 → 0.9.2

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;
     }
   }
@@ -1487,55 +1489,6 @@ arraySchema(headerEntrySchema, {
   title: "OrderedHeaders"
 });
 
-// ../protocol/src/captcha.ts
-var captchaTypeSchema = enumSchema(
-  ["recaptcha-v2", "hcaptcha", "turnstile"],
-  {
-    title: "CaptchaType"
-  }
-);
-var captchaProviderSchema = enumSchema(["2captcha", "capsolver"], {
-  title: "CaptchaProvider"
-});
-var captchaDetectionResultSchema = objectSchema(
-  {
-    type: captchaTypeSchema,
-    siteKey: stringSchema({ minLength: 1 }),
-    pageUrl: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "CaptchaDetectionResult",
-    required: ["type", "siteKey", "pageUrl"]
-  }
-);
-var opensteerCaptchaSolveInputSchema = objectSchema(
-  {
-    provider: captchaProviderSchema,
-    apiKey: stringSchema({ minLength: 1 }),
-    pageRef: pageRefSchema,
-    timeoutMs: integerSchema({ minimum: 1 }),
-    type: captchaTypeSchema,
-    siteKey: stringSchema({ minLength: 1 }),
-    pageUrl: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerCaptchaSolveInput",
-    required: ["provider", "apiKey"]
-  }
-);
-var opensteerCaptchaSolveOutputSchema = objectSchema(
-  {
-    captcha: captchaDetectionResultSchema,
-    token: stringSchema({ minLength: 1 }),
-    injected: { type: "boolean" },
-    provider: captchaProviderSchema
-  },
-  {
-    title: "OpensteerCaptchaSolveOutput",
-    required: ["captcha", "token", "injected", "provider"]
-  }
-);
-
 // ../protocol/src/storage.ts
 var jsonUnknownSchema = {};
 var cookieSameSiteSchema = enumSchema(["strict", "lax", "none"], {
@@ -1788,16 +1741,6 @@ var opensteerRequestPlanResponseExpectationSchema = objectSchema(
     required: ["status"]
   }
 );
-var opensteerRecipeRefSchema = objectSchema(
-  {
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerRecipeRef",
-    required: ["key"]
-  }
-);
 var opensteerRequestFailurePolicyHeaderMatchSchema = objectSchema(
   {
     name: stringSchema({ minLength: 1 }),
@@ -1853,46 +1796,9 @@ var opensteerRequestRetryPolicySchema = objectSchema(
     required: ["maxRetries"]
   }
 );
-var opensteerRecipeCachePolicySchema = enumSchema(
-  ["none", "untilFailure"],
-  {
-    title: "OpensteerRecipeCachePolicy"
-  }
-);
-var opensteerRequestPlanRecipeBindingSchema = objectSchema(
-  {
-    recipe: opensteerRecipeRefSchema,
-    cachePolicy: opensteerRecipeCachePolicySchema
-  },
-  {
-    title: "OpensteerRequestPlanRecipeBinding",
-    required: ["recipe"]
-  }
-);
-var opensteerRequestPlanRecoverBindingSchema = objectSchema(
-  {
-    recipe: opensteerRecipeRefSchema,
-    cachePolicy: opensteerRecipeCachePolicySchema,
-    failurePolicy: opensteerRequestFailurePolicySchema
-  },
-  {
-    title: "OpensteerRequestPlanRecoverBinding",
-    required: ["recipe", "failurePolicy"]
-  }
-);
-var opensteerRequestPlanRecipesSchema = objectSchema(
-  {
-    prepare: opensteerRequestPlanRecipeBindingSchema,
-    recover: opensteerRequestPlanRecoverBindingSchema
-  },
-  {
-    title: "OpensteerRequestPlanRecipes"
-  }
-);
 var opensteerRequestPlanAuthSchema = objectSchema(
   {
     strategy: enumSchema(["session-cookie", "bearer-token", "api-key", "custom"]),
-    recipe: opensteerRecipeRefSchema,
     failurePolicy: opensteerRequestFailurePolicySchema,
     description: stringSchema({ minLength: 1 })
   },
@@ -1908,7 +1814,6 @@ var opensteerRequestPlanPayloadSchema = objectSchema(
     parameters: arraySchema(opensteerRequestPlanParameterSchema),
     body: opensteerRequestPlanBodySchema,
     response: opensteerRequestPlanResponseExpectationSchema,
-    recipes: opensteerRequestPlanRecipesSchema,
     retryPolicy: opensteerRequestRetryPolicySchema,
     auth: opensteerRequestPlanAuthSchema
   },
@@ -1999,317 +1904,6 @@ var opensteerRequestBodyInputSchema = oneOfSchema(
     title: "OpensteerRequestBodyInput"
   }
 );
-var opensteerRecipeRetryOverridesSchema = objectSchema(
-  {
-    params: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeParams"
-    }),
-    headers: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeHeaders"
-    }),
-    query: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeQuery"
-    }),
-    body: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeBodyVariables"
-    })
-  },
-  {
-    title: "OpensteerRecipeRetryOverrides"
-  }
-);
-var opensteerRecipeStepResponseCaptureSchema = objectSchema(
-  {
-    header: objectSchema(
-      {
-        name: stringSchema({ minLength: 1 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeHeaderCapture",
-        required: ["name", "saveAs"]
-      }
-    ),
-    bodyJsonPointer: objectSchema(
-      {
-        pointer: stringSchema({ minLength: 1 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeBodyJsonPointerCapture",
-        required: ["pointer", "saveAs"]
-      }
-    ),
-    bodyText: objectSchema(
-      {
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeBodyTextCapture",
-        required: ["saveAs"]
-      }
-    )
-  },
-  {
-    title: "OpensteerRecipeStepResponseCapture"
-  }
-);
-var opensteerRecipeRequestStepInputSchema = objectSchema(
-  {
-    url: stringSchema({ minLength: 1 }),
-    transport: transportKindSchema,
-    pageRef: pageRefSchema,
-    cookieJar: stringSchema({ minLength: 1 }),
-    method: stringSchema({ minLength: 1 }),
-    headers: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeRequestHeaders"
-    }),
-    query: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeRequestQuery"
-    }),
-    body: opensteerRequestBodyInputSchema,
-    followRedirects: { type: "boolean" }
-  },
-  {
-    title: "OpensteerRecipeRequestStepInput",
-    required: ["url"]
-  }
-);
-var opensteerRecipeHookRefSchema = objectSchema(
-  {
-    specifier: stringSchema({ minLength: 1 }),
-    export: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerRecipeHookRef",
-    required: ["specifier", "export"]
-  }
-);
-var opensteerRecipeStepSchema = oneOfSchema(
-  [
-    objectSchema(
-      {
-        kind: enumSchema(["goto"]),
-        url: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeGotoStep",
-        required: ["kind", "url"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["reload"])
-      },
-      {
-        title: "OpensteerAuthRecipeReloadStep",
-        required: ["kind"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["waitForUrl"]),
-        includes: stringSchema({ minLength: 1 }),
-        timeoutMs: integerSchema({ minimum: 0 })
-      },
-      {
-        title: "OpensteerAuthRecipeWaitForUrlStep",
-        required: ["kind", "includes"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["waitForNetwork"]),
-        url: stringSchema({ minLength: 1 }),
-        hostname: stringSchema({ minLength: 1 }),
-        path: stringSchema({ minLength: 1 }),
-        method: stringSchema({ minLength: 1 }),
-        status: stringSchema({ minLength: 1 }),
-        includeBodies: { type: "boolean" },
-        timeoutMs: integerSchema({ minimum: 0 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerRecipeWaitForNetworkStep",
-        required: ["kind"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["waitForCookie"]),
-        name: stringSchema({ minLength: 1 }),
-        url: stringSchema({ minLength: 1 }),
-        timeoutMs: integerSchema({ minimum: 0 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeWaitForCookieStep",
-        required: ["kind", "name"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["waitForStorage"]),
-        area: enumSchema(["local", "session"]),
-        origin: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        timeoutMs: integerSchema({ minimum: 0 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeWaitForStorageStep",
-        required: ["kind", "area", "origin", "key"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["readCookie"]),
-        name: stringSchema({ minLength: 1 }),
-        url: stringSchema({ minLength: 1 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerAuthRecipeReadCookieStep",
-        required: ["kind", "name", "saveAs"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["readStorage"]),
-        area: enumSchema(["local", "session"]),
-        origin: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        pageUrl: stringSchema({ minLength: 1 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerRecipeReadStorageStep",
-        required: ["kind", "area", "origin", "key", "saveAs"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["evaluate"]),
-        script: stringSchema({ minLength: 1 }),
-        args: arraySchema(jsonValueSchema),
-        pageRef: pageRefSchema,
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerRecipeEvaluateStep",
-        required: ["kind", "script"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["syncCookiesToJar"]),
-        jar: stringSchema({ minLength: 1 }),
-        urls: arraySchema(stringSchema({ minLength: 1 }), {
-          minItems: 1
-        })
-      },
-      {
-        title: "OpensteerRecipeSyncCookiesToJarStep",
-        required: ["kind", "jar"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["request"]),
-        request: opensteerRecipeRequestStepInputSchema,
-        capture: opensteerRecipeStepResponseCaptureSchema
-      },
-      {
-        title: "OpensteerRecipeRequestStep",
-        required: ["kind", "request"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["sessionRequest"]),
-        request: opensteerRecipeRequestStepInputSchema,
-        capture: opensteerRecipeStepResponseCaptureSchema
-      },
-      {
-        title: "OpensteerAuthRecipeSessionRequestStep",
-        required: ["kind", "request"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["directRequest"]),
-        request: opensteerRecipeRequestStepInputSchema,
-        capture: opensteerRecipeStepResponseCaptureSchema
-      },
-      {
-        title: "OpensteerAuthRecipeDirectRequestStep",
-        required: ["kind", "request"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["solveCaptcha"]),
-        provider: captchaProviderSchema,
-        apiKey: stringSchema({ minLength: 1 }),
-        pageRef: pageRefSchema,
-        timeoutMs: integerSchema({ minimum: 1 }),
-        type: captchaTypeSchema,
-        siteKey: stringSchema({ minLength: 1 }),
-        pageUrl: stringSchema({ minLength: 1 }),
-        saveAs: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerRecipeSolveCaptchaStep",
-        required: ["kind", "provider", "apiKey"]
-      }
-    ),
-    objectSchema(
-      {
-        kind: enumSchema(["hook"]),
-        hook: opensteerRecipeHookRefSchema
-      },
-      {
-        title: "OpensteerRecipeHookStep",
-        required: ["kind", "hook"]
-      }
-    )
-  ],
-  {
-    title: "OpensteerRecipeStep"
-  }
-);
-var opensteerRecipePayloadSchema = objectSchema(
-  {
-    description: stringSchema({ minLength: 1 }),
-    steps: arraySchema(opensteerRecipeStepSchema, {
-      minItems: 1
-    }),
-    outputs: opensteerRecipeRetryOverridesSchema
-  },
-  {
-    title: "OpensteerRecipePayload",
-    required: ["steps"]
-  }
-);
-var opensteerRecipeRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    updatedAt: integerSchema({ minimum: 0 }),
-    contentHash: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), {
-      uniqueItems: true
-    }),
-    provenance: opensteerRegistryProvenanceSchema,
-    payload: opensteerRecipePayloadSchema
-  },
-  {
-    title: "OpensteerRecipeRecord",
-    required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-  }
-);
 var opensteerNetworkQueryInputSchema = objectSchema(
   {
     pageRef: pageRefSchema,
@@ -2708,85 +2302,6 @@ objectSchema(
     required: ["plans"]
   }
 );
-objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), {
-      uniqueItems: true
-    }),
-    provenance: opensteerRegistryProvenanceSchema,
-    payload: opensteerRecipePayloadSchema
-  },
-  {
-    title: "OpensteerWriteRecipeInput",
-    required: ["key", "version", "payload"]
-  }
-);
-objectSchema(
-  {
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerGetRecipeInput",
-    required: ["key"]
-  }
-);
-objectSchema(
-  {
-    key: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerListRecipesInput"
-  }
-);
-objectSchema(
-  {
-    recipes: arraySchema(opensteerRecipeRecordSchema)
-  },
-  {
-    title: "OpensteerListRecipesOutput",
-    required: ["recipes"]
-  }
-);
-objectSchema(
-  {
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    variables: recordSchema(stringSchema(), {
-      title: "OpensteerRecipeVariables"
-    })
-  },
-  {
-    title: "OpensteerRunRecipeInput",
-    required: ["key"]
-  }
-);
-objectSchema(
-  {
-    recipe: objectSchema(
-      {
-        id: stringSchema({ minLength: 1 }),
-        key: stringSchema({ minLength: 1 }),
-        version: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerResolvedRecipeRef",
-        required: ["id", "key", "version"]
-      }
-    ),
-    variables: recordSchema(stringSchema(), {
-      title: "OpensteerResolvedRecipeVariables"
-    }),
-    overrides: opensteerRecipeRetryOverridesSchema
-  },
-  {
-    title: "OpensteerRunRecipeOutput",
-    required: ["recipe", "variables"]
-  }
-);
 objectSchema(
   {
     key: stringSchema({ minLength: 1 }),
@@ -2893,17 +2408,7 @@ objectSchema(
       {
         attempted: { type: "boolean" },
         succeeded: { type: "boolean" },
-        matchedFailurePolicy: { type: "boolean" },
-        recipe: objectSchema(
-          {
-            key: stringSchema({ minLength: 1 }),
-            version: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerResolvedRecoveryRecipeRef",
-            required: ["key", "version"]
-          }
-        )
+        matchedFailurePolicy: { type: "boolean" }
       },
       {
         title: "OpensteerRequestRecoveryMetadata",
@@ -2942,6 +2447,69 @@ objectSchema(
   }
 );
 
+// ../protocol/src/state.ts
+var opensteerStateSnapshotCookieSchema = objectSchema(
+  {
+    name: stringSchema({ minLength: 1 }),
+    value: stringSchema(),
+    domain: stringSchema({ minLength: 1 }),
+    path: stringSchema({ minLength: 1 }),
+    secure: { type: "boolean" },
+    httpOnly: { type: "boolean" },
+    sameSite: enumSchema(["strict", "lax", "none"]),
+    priority: enumSchema(["low", "medium", "high"]),
+    partitionKey: stringSchema({ minLength: 1 }),
+    session: { type: "boolean" },
+    expiresAt: oneOfSchema([integerSchema({ minimum: 0 }), { type: "null" }])
+  },
+  {
+    title: "OpensteerStateSnapshotCookie",
+    required: ["name", "value", "domain", "path", "secure", "httpOnly", "session"]
+  }
+);
+var opensteerStateSnapshotSchema = objectSchema(
+  {
+    id: stringSchema({ minLength: 1 }),
+    capturedAt: integerSchema({ minimum: 0 }),
+    pageRef: pageRefSchema,
+    url: stringSchema({ minLength: 1 }),
+    cookies: arraySchema(opensteerStateSnapshotCookieSchema),
+    storage: storageSnapshotSchema,
+    hiddenFields: arraySchema(
+      objectSchema(
+        {
+          path: stringSchema({ minLength: 1 }),
+          name: stringSchema({ minLength: 1 }),
+          value: stringSchema()
+        },
+        {
+          title: "OpensteerStateSnapshotHiddenField",
+          required: ["path", "name", "value"]
+        }
+      )
+    ),
+    globals: recordSchema({}, { title: "OpensteerStateSnapshotGlobals" })
+  },
+  {
+    title: "OpensteerStateSnapshot",
+    required: ["id", "capturedAt"]
+  }
+);
+var opensteerStateDeltaSchema = objectSchema(
+  {
+    beforeStateId: stringSchema({ minLength: 1 }),
+    afterStateId: stringSchema({ minLength: 1 }),
+    cookiesChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
+    storageChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
+    hiddenFieldsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
+    globalsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
+  },
+  {
+    title: "OpensteerStateDelta",
+    required: ["cookiesChanged", "storageChanged", "hiddenFieldsChanged", "globalsChanged"]
+  }
+);
+
 // ../protocol/src/snapshots.ts
 var screenshotFormatSchema = enumSchema(["png", "jpeg", "webp"], {
   title: "ScreenshotFormat"
@@ -3715,6 +3283,55 @@ var opensteerArtifactReadOutputSchema = objectSchema(
   }
 );
 
+// ../protocol/src/captcha.ts
+var captchaTypeSchema = enumSchema(
+  ["recaptcha-v2", "hcaptcha", "turnstile"],
+  {
+    title: "CaptchaType"
+  }
+);
+var captchaProviderSchema = enumSchema(["2captcha", "capsolver"], {
+  title: "CaptchaProvider"
+});
+var captchaDetectionResultSchema = objectSchema(
+  {
+    type: captchaTypeSchema,
+    siteKey: stringSchema({ minLength: 1 }),
+    pageUrl: stringSchema({ minLength: 1 })
+  },
+  {
+    title: "CaptchaDetectionResult",
+    required: ["type", "siteKey", "pageUrl"]
+  }
+);
+var opensteerCaptchaSolveInputSchema = objectSchema(
+  {
+    provider: captchaProviderSchema,
+    apiKey: stringSchema({ minLength: 1 }),
+    pageRef: pageRefSchema,
+    timeoutMs: integerSchema({ minimum: 1 }),
+    type: captchaTypeSchema,
+    siteKey: stringSchema({ minLength: 1 }),
+    pageUrl: stringSchema({ minLength: 1 })
+  },
+  {
+    title: "OpensteerCaptchaSolveInput",
+    required: ["provider", "apiKey"]
+  }
+);
+var opensteerCaptchaSolveOutputSchema = objectSchema(
+  {
+    captcha: captchaDetectionResultSchema,
+    token: stringSchema({ minLength: 1 }),
+    injected: { type: "boolean" },
+    provider: captchaProviderSchema
+  },
+  {
+    title: "OpensteerCaptchaSolveOutput",
+    required: ["captcha", "token", "injected", "provider"]
+  }
+);
+
 // ../protocol/src/traces.ts
 var traceContextSchema = objectSchema(
   {
@@ -3970,1557 +3587,15 @@ var opensteerScriptSandboxOutputSchema = objectSchema(
       ],
       {
         title: "SandboxResult"
-      }
-    ),
-    capturedAjax: arraySchema(sandboxCapturedAjaxCallSchema),
-    errors: arraySchema(stringSchema({ minLength: 1 })),
-    durationMs: integerSchema({ minimum: 0 })
-  },
-  {
-    title: "OpensteerScriptSandboxOutput",
-    required: ["capturedAjax", "errors", "durationMs"]
-  }
-);
-
-// ../protocol/src/reverse.ts
-var opensteerStateSourceKindSchema = enumSchema(
-  ["temporary", "persistent", "attach"],
-  { title: "OpensteerStateSourceKind" }
-);
-var opensteerReverseCaseStatusSchema = enumSchema(
-  ["capturing", "analyzing", "ready", "attention"],
-  { title: "OpensteerReverseCaseStatus" }
-);
-var opensteerReverseChannelKindSchema = enumSchema(
-  ["http", "event-stream", "websocket"],
-  { title: "OpensteerReverseChannelKind" }
-);
-var opensteerReverseManualCalibrationModeSchema = enumSchema(
-  ["allow", "avoid", "require"],
-  { title: "OpensteerReverseManualCalibrationMode" }
-);
-var opensteerReverseCandidateBoundarySchema = enumSchema(
-  ["first-party", "same-site", "third-party"],
-  { title: "OpensteerReverseCandidateBoundary" }
-);
-var opensteerReverseAdvisoryTagSchema = enumSchema(
-  [
-    "data",
-    "facet",
-    "telemetry",
-    "subscription",
-    "navigation",
-    "document",
-    "route-data",
-    "search",
-    "tracking",
-    "unknown"
-  ],
-  { title: "OpensteerReverseAdvisoryTag" }
-);
-var opensteerReverseConstraintKindSchema = enumSchema(
-  [
-    "requires-browser",
-    "requires-cookie",
-    "requires-storage",
-    "requires-script",
-    "requires-guard",
-    "requires-live-state",
-    "opaque-body",
-    "unsupported"
-  ],
-  { title: "OpensteerReverseConstraintKind" }
-);
-var opensteerRequestInputLocationSchema = enumSchema(
-  ["path", "query", "header", "cookie", "body-field"],
-  { title: "OpensteerRequestInputLocation" }
-);
-var opensteerRequestInputRequirednessSchema = enumSchema(
-  ["required", "optional", "unknown"],
-  { title: "OpensteerRequestInputRequiredness" }
-);
-var opensteerRequestInputClassificationSchema = enumSchema(
-  ["managed", "static", "contextual", "volatile"],
-  { title: "OpensteerRequestInputClassification" }
-);
-var opensteerRequestInputSourceSchema = enumSchema(
-  [
-    "literal",
-    "cookie",
-    "storage",
-    "prior-response",
-    "page",
-    "script",
-    "guard-output",
-    "runtime-managed",
-    "unknown"
-  ],
-  { title: "OpensteerRequestInputSource" }
-);
-var opensteerRequestInputMaterializationPolicySchema = enumSchema(
-  ["copy", "omit", "recompute", "resolve"],
-  { title: "OpensteerRequestInputMaterializationPolicy" }
-);
-var opensteerRequestInputExportPolicySchema = enumSchema(
-  ["portable", "browser-bound", "blocked"],
-  { title: "OpensteerRequestInputExportPolicy" }
-);
-var opensteerReverseQueryViewSchema = enumSchema(
-  ["records", "clusters", "candidates"],
-  { title: "OpensteerReverseQueryView" }
-);
-var opensteerReverseSortKeySchema = enumSchema(
-  [
-    "observed-at",
-    "advisory-rank",
-    "target-hint-matches",
-    "response-richness",
-    "portability",
-    "boundary",
-    "success"
-  ],
-  { title: "OpensteerReverseSortKey" }
-);
-var opensteerReverseSortPresetSchema = enumSchema(
-  [
-    "advisory-rank",
-    "observed-at",
-    "portability",
-    "first-party",
-    "hint-match",
-    "response-richness"
-  ],
-  { title: "OpensteerReverseSortPreset" }
-);
-var opensteerReverseSortDirectionSchema = enumSchema(
-  ["asc", "desc"],
-  {
-    title: "OpensteerReverseSortDirection"
-  }
-);
-var opensteerObservationClusterRelationshipKindSchema = enumSchema(
-  ["seed", "preflight", "redirect", "retry", "duplicate", "follow-on"],
-  { title: "OpensteerObservationClusterRelationshipKind" }
-);
-var opensteerReverseReportKindSchema = enumSchema(
-  ["discovery", "package"],
-  { title: "OpensteerReverseReportKind" }
-);
-var opensteerReversePackageKindSchema = enumSchema(
-  ["portable-http", "browser-workflow"],
-  { title: "OpensteerReversePackageKind" }
-);
-var opensteerReversePackageReadinessSchema = enumSchema(
-  ["runnable", "draft", "unsupported"],
-  { title: "OpensteerReversePackageReadiness" }
-);
-var opensteerBodyCodecKindSchema = enumSchema(
-  [
-    "json",
-    "form-urlencoded",
-    "multipart",
-    "graphql",
-    "persisted-graphql",
-    "text",
-    "opaque-binary",
-    "sse",
-    "websocket-json",
-    "websocket-text",
-    "unknown"
-  ],
-  { title: "OpensteerBodyCodecKind" }
-);
-var opensteerExecutableResolverKindSchema = enumSchema(
-  [
-    "literal",
-    "cookie",
-    "storage",
-    "prior-record",
-    "binding",
-    "candidate",
-    "case",
-    "state-snapshot",
-    "artifact",
-    "manual",
-    "runtime-managed"
-  ],
-  { title: "OpensteerExecutableResolverKind" }
-);
-var opensteerValueReferenceKindSchema = enumSchema(
-  [
-    "literal",
-    "resolver",
-    "binding",
-    "candidate",
-    "case",
-    "record",
-    "artifact",
-    "state-snapshot",
-    "runtime",
-    "manual"
-  ],
-  { title: "OpensteerValueReferenceKind" }
-);
-var opensteerRuntimeValueKeySchema = enumSchema(
-  ["pageRef", "packageId", "caseId", "candidateId", "objective"],
-  { title: "OpensteerRuntimeValueKey" }
-);
-var opensteerValidationRuleKindSchema = enumSchema(
-  [
-    "status",
-    "json-structure",
-    "text-includes",
-    "stream-first-chunk",
-    "websocket-open",
-    "message-count-at-least"
-  ],
-  { title: "OpensteerValidationRuleKind" }
-);
-enumSchema(
-  ["operation", "await-record", "assert"],
-  { title: "OpensteerReverseWorkflowStepKind" }
-);
-var opensteerReverseRequirementKindSchema = enumSchema(
-  ["resolver", "guard", "workflow-step", "state", "channel", "unsupported"],
-  { title: "OpensteerReverseRequirementKind" }
-);
-var opensteerReverseRequirementStatusSchema = enumSchema(
-  ["required", "recommended"],
-  { title: "OpensteerReverseRequirementStatus" }
-);
-var opensteerReverseSuggestedEditKindSchema = enumSchema(
-  [
-    "set-resolver",
-    "attach-trace",
-    "replace-workflow",
-    "patch-step-input",
-    "switch-state-source",
-    "inspect-evidence",
-    "mark-unsupported"
-  ],
-  { title: "OpensteerReverseSuggestedEditKind" }
-);
-var jsonValueSchema2 = defineSchema({
-  title: "JsonValue"
-});
-var opensteerValueReferenceSchema = objectSchema(
-  {
-    kind: opensteerValueReferenceKindSchema,
-    pointer: stringSchema({ minLength: 1 }),
-    resolverId: stringSchema({ minLength: 1 }),
-    binding: stringSchema({ minLength: 1 }),
-    recordId: stringSchema({ minLength: 1 }),
-    artifactId: stringSchema({ minLength: 1 }),
-    stateSnapshotId: stringSchema({ minLength: 1 }),
-    runtimeKey: opensteerRuntimeValueKeySchema,
-    value: jsonValueSchema2,
-    placeholder: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerValueReference",
-    required: ["kind"]
-  }
-);
-var opensteerValueTemplateSchema = defineSchema({
-  title: "OpensteerValueTemplate"
-});
-var opensteerReverseTargetHintsSchema = objectSchema(
-  {
-    hosts: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    paths: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    operationNames: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    channels: arraySchema(opensteerReverseChannelKindSchema, { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReverseTargetHints"
-  }
-);
-var opensteerBodyCodecDescriptorSchema = objectSchema(
-  {
-    kind: opensteerBodyCodecKindSchema,
-    contentType: stringSchema({ minLength: 1 }),
-    operationName: stringSchema({ minLength: 1 }),
-    fieldPaths: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerBodyCodecDescriptor",
-    required: ["kind", "fieldPaths"]
-  }
-);
-var opensteerObservationClusterSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    observationId: stringSchema({ minLength: 1 }),
-    label: stringSchema({ minLength: 1 }),
-    channel: opensteerReverseChannelKindSchema,
-    method: stringSchema({ minLength: 1 }),
-    url: stringSchema({ minLength: 1 }),
-    matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    members: arraySchema(
-      objectSchema(
-        {
-          recordId: stringSchema({ minLength: 1 }),
-          observedAt: integerSchema({ minimum: 0 }),
-          resourceType: stringSchema({ minLength: 1 }),
-          status: integerSchema({ minimum: 0 }),
-          relation: opensteerObservationClusterRelationshipKindSchema,
-          relatedRecordId: stringSchema({ minLength: 1 }),
-          matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-        },
-        {
-          title: "OpensteerObservationClusterMember",
-          required: ["recordId", "relation", "matchedTargetHints"]
-        }
-      )
-    )
-  },
-  {
-    title: "OpensteerObservationCluster",
-    required: ["id", "observationId", "label", "channel", "url", "matchedTargetHints", "members"]
-  }
-);
-var opensteerStateSnapshotCookieSchema = objectSchema(
-  {
-    name: stringSchema({ minLength: 1 }),
-    value: stringSchema(),
-    domain: stringSchema({ minLength: 1 }),
-    path: stringSchema({ minLength: 1 }),
-    secure: { type: "boolean" },
-    httpOnly: { type: "boolean" },
-    sameSite: enumSchema(["strict", "lax", "none"]),
-    priority: enumSchema(["low", "medium", "high"]),
-    partitionKey: stringSchema({ minLength: 1 }),
-    session: { type: "boolean" },
-    expiresAt: oneOfSchema([integerSchema({ minimum: 0 }), { type: "null" }])
-  },
-  {
-    title: "OpensteerStateSnapshotCookie",
-    required: ["name", "value", "domain", "path", "secure", "httpOnly", "session"]
-  }
-);
-var opensteerStateSnapshotSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    capturedAt: integerSchema({ minimum: 0 }),
-    pageRef: pageRefSchema,
-    url: stringSchema({ minLength: 1 }),
-    cookies: arraySchema(opensteerStateSnapshotCookieSchema),
-    storage: storageSnapshotSchema,
-    hiddenFields: arraySchema(
-      objectSchema(
-        {
-          path: stringSchema({ minLength: 1 }),
-          name: stringSchema({ minLength: 1 }),
-          value: stringSchema()
-        },
-        {
-          title: "OpensteerStateSnapshotHiddenField",
-          required: ["path", "name", "value"]
-        }
-      )
-    ),
-    globals: recordSchema({}, { title: "OpensteerStateSnapshotGlobals" })
-  },
-  {
-    title: "OpensteerStateSnapshot",
-    required: ["id", "capturedAt"]
-  }
-);
-var opensteerStateDeltaSchema = objectSchema(
-  {
-    beforeStateId: stringSchema({ minLength: 1 }),
-    afterStateId: stringSchema({ minLength: 1 }),
-    cookiesChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    storageChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    hiddenFieldsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    globalsChanged: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerStateDelta",
-    required: ["cookiesChanged", "storageChanged", "hiddenFieldsChanged", "globalsChanged"]
-  }
-);
-var opensteerRequestInputDescriptorSchema = objectSchema(
-  {
-    name: stringSchema({ minLength: 1 }),
-    location: opensteerRequestInputLocationSchema,
-    path: stringSchema({ minLength: 1 }),
-    wireName: stringSchema({ minLength: 1 }),
-    requiredness: opensteerRequestInputRequirednessSchema,
-    classification: opensteerRequestInputClassificationSchema,
-    source: opensteerRequestInputSourceSchema,
-    materializationPolicy: opensteerRequestInputMaterializationPolicySchema,
-    exportPolicy: opensteerRequestInputExportPolicySchema,
-    originalValue: stringSchema(),
-    provenance: objectSchema(
-      {
-        recordId: stringSchema({ minLength: 1 }),
-        observationId: stringSchema({ minLength: 1 }),
-        sourcePointer: stringSchema({ minLength: 1 }),
-        notes: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerRequestInputDescriptorProvenance"
-      }
-    ),
-    unlockedByGuardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerRequestInputDescriptor",
-    required: [
-      "name",
-      "location",
-      "requiredness",
-      "classification",
-      "source",
-      "materializationPolicy",
-      "exportPolicy"
-    ]
-  }
-);
-var opensteerExecutableResolverSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: opensteerExecutableResolverKindSchema,
-    label: stringSchema({ minLength: 1 }),
-    status: enumSchema(["ready", "missing"]),
-    requiresBrowser: { type: "boolean" },
-    requiresLiveState: { type: "boolean" },
-    description: stringSchema({ minLength: 1 }),
-    inputNames: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    guardId: stringSchema({ minLength: 1 }),
-    traceId: stringSchema({ minLength: 1 }),
-    valueRef: opensteerValueReferenceSchema
-  },
-  {
-    title: "OpensteerExecutableResolver",
-    required: ["id", "kind", "label", "status", "requiresBrowser", "requiresLiveState"]
-  }
-);
-var opensteerReverseAdvisorySignalsSchema = objectSchema(
-  {
-    advisoryRank: numberSchema(),
-    observedAt: integerSchema({ minimum: 0 }),
-    targetHintMatches: integerSchema({ minimum: 0 }),
-    responseRichness: integerSchema({ minimum: 0 }),
-    portabilityWeight: integerSchema({ minimum: 0 }),
-    boundaryWeight: integerSchema({ minimum: 0 }),
-    successfulStatus: { type: "boolean" },
-    fetchLike: { type: "boolean" },
-    hasResponseBody: { type: "boolean" },
-    dataPathMatch: { type: "boolean" },
-    cookieInputCount: integerSchema({ minimum: 0 }),
-    storageInputCount: integerSchema({ minimum: 0 }),
-    volatileInputCount: integerSchema({ minimum: 0 }),
-    guardCount: integerSchema({ minimum: 0 })
-  },
-  {
-    title: "OpensteerReverseAdvisorySignals",
-    required: [
-      "advisoryRank",
-      "targetHintMatches",
-      "responseRichness",
-      "portabilityWeight",
-      "boundaryWeight",
-      "successfulStatus",
-      "fetchLike",
-      "hasResponseBody",
-      "dataPathMatch",
-      "cookieInputCount",
-      "storageInputCount",
-      "volatileInputCount",
-      "guardCount"
-    ]
-  }
-);
-var opensteerValidationRuleSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: opensteerValidationRuleKindSchema,
-    label: stringSchema({ minLength: 1 }),
-    required: { type: "boolean" },
-    expectedStatus: integerSchema({ minimum: 0 }),
-    structureHash: stringSchema({ minLength: 1 }),
-    textIncludes: stringSchema({ minLength: 1 }),
-    minimumCount: integerSchema({ minimum: 0 })
-  },
-  {
-    title: "OpensteerValidationRule",
-    required: ["id", "kind", "label", "required"]
-  }
-);
-var opensteerChannelDescriptorSchema = objectSchema(
-  {
-    kind: opensteerReverseChannelKindSchema,
-    recordKind: networkRecordKindSchema,
-    method: stringSchema({ minLength: 1 }),
-    url: stringSchema({ minLength: 1 }),
-    subprotocol: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerChannelDescriptor",
-    required: ["kind", "recordKind", "url"]
-  }
-);
-var opensteerReverseOperationWorkflowStepSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: enumSchema(["operation"]),
-    label: stringSchema({ minLength: 1 }),
-    operation: stringSchema({ minLength: 1 }),
-    input: opensteerValueTemplateSchema,
-    bindAs: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseOperationWorkflowStep",
-    required: ["id", "kind", "label", "operation", "input"]
-  }
-);
-var opensteerReverseAwaitRecordWorkflowStepSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: enumSchema(["await-record"]),
-    label: stringSchema({ minLength: 1 }),
-    channel: opensteerChannelDescriptorSchema,
-    recordId: stringSchema({ minLength: 1 }),
-    match: objectSchema(
-      {
-        recordId: stringSchema({ minLength: 1 }),
-        host: stringSchema({ minLength: 1 }),
-        path: stringSchema({ minLength: 1 }),
-        method: stringSchema({ minLength: 1 }),
-        channel: opensteerReverseChannelKindSchema,
-        status: integerSchema({ minimum: 0 }),
-        text: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReverseAwaitRecordMatch"
-      }
-    ),
-    validationRuleIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    timeoutMs: integerSchema({ minimum: 0 }),
-    bindAs: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseAwaitRecordWorkflowStep",
-    required: ["id", "kind", "label", "channel"]
-  }
-);
-var opensteerReverseAssertWorkflowStepSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: enumSchema(["assert"]),
-    label: stringSchema({ minLength: 1 }),
-    validationRuleIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    binding: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseAssertWorkflowStep",
-    required: ["id", "kind", "label", "validationRuleIds"]
-  }
-);
-var opensteerReverseWorkflowStepSchema = oneOfSchema(
-  [
-    opensteerReverseOperationWorkflowStepSchema,
-    opensteerReverseAwaitRecordWorkflowStepSchema,
-    opensteerReverseAssertWorkflowStepSchema
-  ],
-  {
-    title: "OpensteerReverseWorkflowStep"
-  }
-);
-var opensteerReversePackageRequirementsSchema = objectSchema(
-  {
-    requiresBrowser: { type: "boolean" },
-    requiresLiveState: { type: "boolean" },
-    manualCalibration: enumSchema(["not-needed", "recommended", "required"]),
-    stateSources: arraySchema(opensteerStateSourceKindSchema, { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReversePackageRequirements",
-    required: ["requiresBrowser", "requiresLiveState", "manualCalibration", "stateSources"]
-  }
-);
-var opensteerReverseAdvisoryTemplateSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    label: stringSchema({ minLength: 1 }),
-    channel: opensteerReverseChannelKindSchema,
-    execution: enumSchema(["transport", "page-observation"]),
-    stateSource: opensteerStateSourceKindSchema,
-    observationId: stringSchema({ minLength: 1 }),
-    transport: transportKindSchema,
-    guardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    resolverIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    requiresBrowser: { type: "boolean" },
-    requiresLiveState: { type: "boolean" },
-    viability: enumSchema(["ready", "draft", "unsupported"]),
-    notes: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseAdvisoryTemplate",
-    required: [
-      "id",
-      "label",
-      "channel",
-      "execution",
-      "stateSource",
-      "guardIds",
-      "resolverIds",
-      "requiresBrowser",
-      "requiresLiveState",
-      "viability"
-    ]
-  }
-);
-var opensteerReverseGuardRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: enumSchema(["interaction", "state", "script", "manual"]),
-    label: stringSchema({ minLength: 1 }),
-    status: enumSchema(["required", "satisfied", "unresolved"]),
-    interactionTraceId: stringSchema({ minLength: 1 }),
-    notes: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseGuardRecord",
-    required: ["id", "kind", "label", "status"]
-  }
-);
-var opensteerReverseObservationRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    capturedAt: integerSchema({ minimum: 0 }),
-    pageRef: pageRefSchema,
-    url: stringSchema({ minLength: 1 }),
-    stateSource: opensteerStateSourceKindSchema,
-    networkRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    scriptArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    interactionTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    stateSnapshotIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    notes: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseObservationRecord",
-    required: [
-      "id",
-      "capturedAt",
-      "stateSource",
-      "networkRecordIds",
-      "scriptArtifactIds",
-      "interactionTraceIds",
-      "stateSnapshotIds"
-    ]
-  }
-);
-var opensteerReverseObservedRecordSchema = objectSchema(
-  {
-    recordId: stringSchema({ minLength: 1 }),
-    observationId: stringSchema({ minLength: 1 }),
-    clusterId: stringSchema({ minLength: 1 }),
-    observedAt: integerSchema({ minimum: 0 }),
-    channel: opensteerChannelDescriptorSchema,
-    bodyCodec: opensteerBodyCodecDescriptorSchema,
-    resourceType: stringSchema({ minLength: 1 }),
-    status: integerSchema({ minimum: 0 }),
-    matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    relationKinds: arraySchema(opensteerObservationClusterRelationshipKindSchema, {
-      uniqueItems: true
-    })
-  },
-  {
-    title: "OpensteerReverseObservedRecord",
-    required: [
-      "recordId",
-      "observationId",
-      "clusterId",
-      "channel",
-      "bodyCodec",
-      "matchedTargetHints",
-      "relationKinds"
-    ]
-  }
-);
-var opensteerReverseCandidateRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    observationId: stringSchema({ minLength: 1 }),
-    clusterId: stringSchema({ minLength: 1 }),
-    recordId: stringSchema({ minLength: 1 }),
-    channel: opensteerChannelDescriptorSchema,
-    bodyCodec: opensteerBodyCodecDescriptorSchema,
-    boundary: opensteerReverseCandidateBoundarySchema,
-    summary: stringSchema({ minLength: 1 }),
-    matchedTargetHints: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    advisoryTags: arraySchema(opensteerReverseAdvisoryTagSchema, { uniqueItems: true }),
-    constraints: arraySchema(opensteerReverseConstraintKindSchema, { uniqueItems: true }),
-    signals: opensteerReverseAdvisorySignalsSchema,
-    inputs: arraySchema(opensteerRequestInputDescriptorSchema),
-    resolvers: arraySchema(opensteerExecutableResolverSchema),
-    guardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    scriptArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    advisoryTemplates: arraySchema(opensteerReverseAdvisoryTemplateSchema)
-  },
-  {
-    title: "OpensteerReverseCandidateRecord",
-    required: [
-      "id",
-      "observationId",
-      "clusterId",
-      "recordId",
-      "channel",
-      "bodyCodec",
-      "boundary",
-      "summary",
-      "matchedTargetHints",
-      "advisoryTags",
-      "constraints",
-      "signals",
-      "inputs",
-      "resolvers",
-      "guardIds",
-      "scriptArtifactIds",
-      "advisoryTemplates"
-    ]
-  }
-);
-var opensteerReverseReplayValidationSchema = objectSchema(
-  {
-    statusMatches: { type: "boolean" },
-    structureMatches: { type: "boolean" },
-    opened: { type: "boolean" },
-    firstChunkObserved: { type: "boolean" },
-    firstChunkMatches: { type: "boolean" },
-    messageObserved: { type: "boolean" },
-    messageCount: integerSchema({ minimum: 0 })
-  },
-  {
-    title: "OpensteerReverseReplayValidation"
-  }
-);
-var opensteerReverseReplayRunRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    candidateId: stringSchema({ minLength: 1 }),
-    templateId: stringSchema({ minLength: 1 }),
-    packageId: stringSchema({ minLength: 1 }),
-    success: { type: "boolean" },
-    channel: opensteerReverseChannelKindSchema,
-    kind: opensteerReversePackageKindSchema,
-    readiness: opensteerReversePackageReadinessSchema,
-    transport: transportKindSchema,
-    stateSource: opensteerStateSourceKindSchema,
-    executedStepIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    failedStepId: stringSchema({ minLength: 1 }),
-    bindings: recordSchema({}, { title: "OpensteerReverseReplayRunBindings" }),
-    recordId: stringSchema({ minLength: 1 }),
-    status: integerSchema({ minimum: 0 }),
-    validation: opensteerReverseReplayValidationSchema,
-    error: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseReplayRunRecord",
-    required: [
-      "id",
-      "createdAt",
-      "packageId",
-      "success",
-      "kind",
-      "readiness",
-      "executedStepIds",
-      "validation"
-    ]
-  }
-);
-var opensteerReverseExperimentRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    candidateId: stringSchema({ minLength: 1 }),
-    templateId: stringSchema({ minLength: 1 }),
-    kind: enumSchema(["replay-attempt", "field-variation"]),
-    hypothesis: stringSchema({ minLength: 1 }),
-    success: { type: "boolean" },
-    status: integerSchema({ minimum: 0 }),
-    notes: stringSchema({ minLength: 1 }),
-    validation: opensteerReverseReplayValidationSchema
-  },
-  {
-    title: "OpensteerReverseExperimentRecord",
-    required: ["id", "createdAt", "kind", "hypothesis", "success"]
-  }
-);
-var opensteerReverseRequirementSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: opensteerReverseRequirementKindSchema,
-    status: opensteerReverseRequirementStatusSchema,
-    label: stringSchema({ minLength: 1 }),
-    description: stringSchema({ minLength: 1 }),
-    blocking: { type: "boolean" },
-    resolverId: stringSchema({ minLength: 1 }),
-    guardId: stringSchema({ minLength: 1 }),
-    stepId: stringSchema({ minLength: 1 }),
-    inputNames: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    traceId: stringSchema({ minLength: 1 }),
-    artifactId: stringSchema({ minLength: 1 }),
-    recordId: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseRequirement",
-    required: ["id", "kind", "status", "label", "blocking"]
-  }
-);
-var opensteerReverseSuggestedEditSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    kind: opensteerReverseSuggestedEditKindSchema,
-    label: stringSchema({ minLength: 1 }),
-    description: stringSchema({ minLength: 1 }),
-    resolverId: stringSchema({ minLength: 1 }),
-    guardId: stringSchema({ minLength: 1 }),
-    stepId: stringSchema({ minLength: 1 }),
-    traceId: stringSchema({ minLength: 1 }),
-    artifactId: stringSchema({ minLength: 1 }),
-    recordId: stringSchema({ minLength: 1 }),
-    payload: jsonValueSchema2
-  },
-  {
-    title: "OpensteerReverseSuggestedEdit",
-    required: ["id", "kind", "label"]
-  }
-);
-var opensteerReverseExportRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    candidateId: stringSchema({ minLength: 1 }),
-    templateId: stringSchema({ minLength: 1 }),
-    packageId: stringSchema({ minLength: 1 }),
-    kind: opensteerReversePackageKindSchema,
-    readiness: opensteerReversePackageReadinessSchema,
-    requestPlanId: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseExportRecord",
-    required: ["id", "createdAt", "packageId", "kind", "readiness"]
-  }
-);
-var opensteerReverseCasePayloadSchema = objectSchema(
-  {
-    objective: stringSchema({ minLength: 1 }),
-    notes: stringSchema({ minLength: 1 }),
-    status: opensteerReverseCaseStatusSchema,
-    stateSource: opensteerStateSourceKindSchema,
-    observations: arraySchema(opensteerReverseObservationRecordSchema),
-    observationClusters: arraySchema(opensteerObservationClusterSchema),
-    observedRecords: arraySchema(opensteerReverseObservedRecordSchema),
-    candidates: arraySchema(opensteerReverseCandidateRecordSchema),
-    guards: arraySchema(opensteerReverseGuardRecordSchema),
-    stateSnapshots: arraySchema(opensteerStateSnapshotSchema),
-    stateDeltas: arraySchema(opensteerStateDeltaSchema),
-    experiments: arraySchema(opensteerReverseExperimentRecordSchema),
-    replayRuns: arraySchema(opensteerReverseReplayRunRecordSchema),
-    exports: arraySchema(opensteerReverseExportRecordSchema)
-  },
-  {
-    title: "OpensteerReverseCasePayload",
-    required: [
-      "objective",
-      "status",
-      "stateSource",
-      "observations",
-      "observationClusters",
-      "observedRecords",
-      "candidates",
-      "guards",
-      "stateSnapshots",
-      "stateDeltas",
-      "experiments",
-      "replayRuns",
-      "exports"
-    ]
-  }
-);
-objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    updatedAt: integerSchema({ minimum: 0 }),
-    contentHash: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    provenance: opensteerRegistryProvenanceSchema,
-    payload: opensteerReverseCasePayloadSchema
-  },
-  {
-    title: "OpensteerReverseCaseRecord",
-    required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-  }
-);
-var opensteerReversePackagePayloadSchema = objectSchema(
-  {
-    kind: opensteerReversePackageKindSchema,
-    readiness: opensteerReversePackageReadinessSchema,
-    caseId: stringSchema({ minLength: 1 }),
-    objective: stringSchema({ minLength: 1 }),
-    source: objectSchema(
-      {
-        kind: enumSchema(["record", "candidate"]),
-        id: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReversePackageSource",
-        required: ["kind", "id"]
-      }
-    ),
-    sourceRecordId: stringSchema({ minLength: 1 }),
-    candidateId: stringSchema({ minLength: 1 }),
-    candidate: opensteerReverseCandidateRecordSchema,
-    templateId: stringSchema({ minLength: 1 }),
-    template: opensteerReverseAdvisoryTemplateSchema,
-    channel: opensteerChannelDescriptorSchema,
-    stateSource: opensteerStateSourceKindSchema,
-    observationId: stringSchema({ minLength: 1 }),
-    transport: transportKindSchema,
-    guardIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    workflow: arraySchema(opensteerReverseWorkflowStepSchema),
-    resolvers: arraySchema(opensteerExecutableResolverSchema),
-    validators: arraySchema(opensteerValidationRuleSchema),
-    stateSnapshots: arraySchema(opensteerStateSnapshotSchema),
-    requirements: opensteerReversePackageRequirementsSchema,
-    requestPlanId: stringSchema({ minLength: 1 }),
-    unresolvedRequirements: arraySchema(opensteerReverseRequirementSchema),
-    suggestedEdits: arraySchema(opensteerReverseSuggestedEditSchema),
-    attachedTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    attachedArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    attachedRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    notes: stringSchema({ minLength: 1 }),
-    parentPackageId: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReversePackagePayload",
-    required: [
-      "kind",
-      "readiness",
-      "caseId",
-      "objective",
-      "source",
-      "sourceRecordId",
-      "guardIds",
-      "workflow",
-      "resolvers",
-      "validators",
-      "stateSnapshots",
-      "requirements",
-      "unresolvedRequirements",
-      "suggestedEdits",
-      "attachedTraceIds",
-      "attachedArtifactIds",
-      "attachedRecordIds"
-    ]
-  }
-);
-var opensteerReversePackageRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    updatedAt: integerSchema({ minimum: 0 }),
-    contentHash: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    provenance: opensteerRegistryProvenanceSchema,
-    payload: opensteerReversePackagePayloadSchema
-  },
-  {
-    title: "OpensteerReversePackageRecord",
-    required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-  }
-);
-var opensteerReverseCandidateReportItemSchema = objectSchema(
-  {
-    candidateId: stringSchema({ minLength: 1 }),
-    clusterId: stringSchema({ minLength: 1 }),
-    advisoryRank: numberSchema(),
-    bodyCodec: opensteerBodyCodecDescriptorSchema,
-    summary: stringSchema({ minLength: 1 }),
-    advisoryTags: arraySchema(opensteerReverseAdvisoryTagSchema, { uniqueItems: true }),
-    constraints: arraySchema(opensteerReverseConstraintKindSchema, { uniqueItems: true }),
-    signals: opensteerReverseAdvisorySignalsSchema,
-    reasons: arraySchema(stringSchema({ minLength: 1 }))
-  },
-  {
-    title: "OpensteerReverseCandidateAdvisoryItem",
-    required: [
-      "candidateId",
-      "clusterId",
-      "advisoryRank",
-      "bodyCodec",
-      "summary",
-      "advisoryTags",
-      "constraints",
-      "signals",
-      "reasons"
-    ]
-  }
-);
-var opensteerReverseDiscoverySummaryCountsSchema = objectSchema(
-  {
-    hosts: recordSchema(integerSchema({ minimum: 0 }), { title: "OpensteerReverseSummaryHosts" }),
-    channels: recordSchema(integerSchema({ minimum: 0 }), {
-      title: "OpensteerReverseSummaryChannels"
-    }),
-    resourceTypes: recordSchema(integerSchema({ minimum: 0 }), {
-      title: "OpensteerReverseSummaryResourceTypes"
-    }),
-    advisoryTags: recordSchema(integerSchema({ minimum: 0 }), {
-      title: "OpensteerReverseSummaryAdvisoryTags"
-    }),
-    constraints: recordSchema(integerSchema({ minimum: 0 }), {
-      title: "OpensteerReverseSummaryConstraints"
-    }),
-    relationKinds: recordSchema(integerSchema({ minimum: 0 }), {
-      title: "OpensteerReverseSummaryRelationKinds"
-    })
-  },
-  {
-    title: "OpensteerReverseDiscoverySummaryCounts",
-    required: [
-      "hosts",
-      "channels",
-      "resourceTypes",
-      "advisoryTags",
-      "constraints",
-      "relationKinds"
-    ]
-  }
-);
-var opensteerReverseReportPayloadSchema = objectSchema(
-  {
-    kind: opensteerReverseReportKindSchema,
-    caseId: stringSchema({ minLength: 1 }),
-    objective: stringSchema({ minLength: 1 }),
-    packageId: stringSchema({ minLength: 1 }),
-    packageKind: opensteerReversePackageKindSchema,
-    packageReadiness: opensteerReversePackageReadinessSchema,
-    observations: arraySchema(opensteerReverseObservationRecordSchema),
-    observationClusters: arraySchema(opensteerObservationClusterSchema),
-    observedRecords: arraySchema(opensteerReverseObservedRecordSchema),
-    guards: arraySchema(opensteerReverseGuardRecordSchema),
-    stateDeltas: arraySchema(opensteerStateDeltaSchema),
-    summaryCounts: opensteerReverseDiscoverySummaryCountsSchema,
-    candidateAdvisories: arraySchema(opensteerReverseCandidateReportItemSchema),
-    query: objectSchema(
-      {
-        view: opensteerReverseQueryViewSchema,
-        filters: objectSchema(
-          {
-            recordId: stringSchema({ minLength: 1 }),
-            clusterId: stringSchema({ minLength: 1 }),
-            candidateId: stringSchema({ minLength: 1 }),
-            host: stringSchema({ minLength: 1 }),
-            path: stringSchema({ minLength: 1 }),
-            method: stringSchema({ minLength: 1 }),
-            status: stringSchema({ minLength: 1 }),
-            resourceType: stringSchema({ minLength: 1 }),
-            channel: opensteerReverseChannelKindSchema,
-            boundary: opensteerReverseCandidateBoundarySchema,
-            advisoryTag: opensteerReverseAdvisoryTagSchema,
-            constraint: opensteerReverseConstraintKindSchema,
-            bodyCodec: opensteerBodyCodecKindSchema,
-            relationKind: opensteerObservationClusterRelationshipKindSchema,
-            hasGuards: { type: "boolean" },
-            hasResolvers: { type: "boolean" },
-            artifactId: stringSchema({ minLength: 1 }),
-            stateSnapshotId: stringSchema({ minLength: 1 }),
-            traceId: stringSchema({ minLength: 1 }),
-            evidenceRef: stringSchema({ minLength: 1 }),
-            text: stringSchema({ minLength: 1 })
-          },
-          {
-            title: "OpensteerReverseReportQueryFilters"
-          }
-        ),
-        sort: objectSchema(
-          {
-            preset: opensteerReverseSortPresetSchema,
-            keys: arraySchema(
-              objectSchema(
-                {
-                  key: opensteerReverseSortKeySchema,
-                  direction: opensteerReverseSortDirectionSchema
-                },
-                {
-                  title: "OpensteerReverseReportQuerySortTerm",
-                  required: ["key"]
-                }
-              ),
-              { minItems: 1 }
-            )
-          },
-          {
-            title: "OpensteerReverseReportQuerySort"
-          }
-        ),
-        limit: integerSchema({ minimum: 1 }),
-        totalCount: integerSchema({ minimum: 0 }),
-        nextCursor: stringSchema({ minLength: 1 }),
-        resultIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-      },
-      {
-        title: "OpensteerReverseQuerySnapshot",
-        required: ["view", "sort", "limit", "totalCount", "resultIds"]
-      }
-    ),
-    experiments: arraySchema(opensteerReverseExperimentRecordSchema),
-    replayRuns: arraySchema(opensteerReverseReplayRunRecordSchema),
-    unresolvedRequirements: arraySchema(opensteerReverseRequirementSchema),
-    suggestedEdits: arraySchema(opensteerReverseSuggestedEditSchema),
-    linkedNetworkRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    linkedInteractionTraceIds: arraySchema(stringSchema({ minLength: 1 }), {
-      uniqueItems: true
-    }),
-    linkedArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    linkedStateSnapshotIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    package: opensteerReversePackageRecordSchema
-  },
-  {
-    title: "OpensteerReverseReportPayload",
-    required: [
-      "kind",
-      "caseId",
-      "objective",
-      "observations",
-      "observationClusters",
-      "observedRecords",
-      "guards",
-      "stateDeltas",
-      "summaryCounts",
-      "candidateAdvisories",
-      "experiments",
-      "replayRuns",
-      "linkedNetworkRecordIds",
-      "linkedInteractionTraceIds",
-      "linkedArtifactIds",
-      "linkedStateSnapshotIds"
-    ]
-  }
-);
-var opensteerReverseReportRecordSchema = objectSchema(
-  {
-    id: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    createdAt: integerSchema({ minimum: 0 }),
-    updatedAt: integerSchema({ minimum: 0 }),
-    contentHash: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    provenance: opensteerRegistryProvenanceSchema,
-    payload: opensteerReverseReportPayloadSchema
-  },
-  {
-    title: "OpensteerReverseReportRecord",
-    required: ["id", "key", "version", "createdAt", "updatedAt", "contentHash", "tags", "payload"]
-  }
-);
-var opensteerReverseNetworkFilterSchema = objectSchema(
-  {
-    url: stringSchema({ minLength: 1 }),
-    hostname: stringSchema({ minLength: 1 }),
-    path: stringSchema({ minLength: 1 }),
-    method: stringSchema({ minLength: 1 }),
-    resourceType: stringSchema({ minLength: 1 }),
-    includeBodies: { type: "boolean" }
-  },
-  {
-    title: "OpensteerReverseCaptureNetworkFilter"
-  }
-);
-var opensteerReverseQueryFiltersSchema = objectSchema(
-  {
-    recordId: stringSchema({ minLength: 1 }),
-    clusterId: stringSchema({ minLength: 1 }),
-    candidateId: stringSchema({ minLength: 1 }),
-    host: stringSchema({ minLength: 1 }),
-    path: stringSchema({ minLength: 1 }),
-    method: stringSchema({ minLength: 1 }),
-    status: stringSchema({ minLength: 1 }),
-    resourceType: stringSchema({ minLength: 1 }),
-    channel: opensteerReverseChannelKindSchema,
-    boundary: opensteerReverseCandidateBoundarySchema,
-    advisoryTag: opensteerReverseAdvisoryTagSchema,
-    constraint: opensteerReverseConstraintKindSchema,
-    bodyCodec: opensteerBodyCodecKindSchema,
-    relationKind: opensteerObservationClusterRelationshipKindSchema,
-    hasGuards: { type: "boolean" },
-    hasResolvers: { type: "boolean" },
-    artifactId: stringSchema({ minLength: 1 }),
-    stateSnapshotId: stringSchema({ minLength: 1 }),
-    traceId: stringSchema({ minLength: 1 }),
-    evidenceRef: stringSchema({ minLength: 1 }),
-    text: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseQueryFilters"
-  }
-);
-var opensteerReverseQuerySortSchema = objectSchema(
-  {
-    preset: opensteerReverseSortPresetSchema,
-    keys: arraySchema(
-      objectSchema(
-        {
-          key: opensteerReverseSortKeySchema,
-          direction: opensteerReverseSortDirectionSchema
-        },
-        {
-          title: "OpensteerReverseSortTerm",
-          required: ["key"]
-        }
-      ),
-      { minItems: 1 }
-    )
-  },
-  {
-    title: "OpensteerReverseQuerySort"
-  }
-);
-var opensteerReverseQuerySnapshotSchema = objectSchema(
-  {
-    view: opensteerReverseQueryViewSchema,
-    filters: opensteerReverseQueryFiltersSchema,
-    sort: opensteerReverseQuerySortSchema,
-    limit: integerSchema({ minimum: 1, maximum: 200 }),
-    totalCount: integerSchema({ minimum: 0 }),
-    nextCursor: stringSchema({ minLength: 1 }),
-    resultIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReverseQuerySnapshot",
-    required: ["view", "sort", "limit", "totalCount", "resultIds"]
-  }
-);
-var opensteerReverseQueryRecordItemSchema = objectSchema(
-  {
-    record: opensteerReverseObservedRecordSchema,
-    candidateIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReverseQueryRecordItem",
-    required: ["record", "candidateIds"]
-  }
-);
-var opensteerReverseQueryClusterItemSchema = objectSchema(
-  {
-    cluster: opensteerObservationClusterSchema,
-    candidateIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReverseQueryClusterItem",
-    required: ["cluster", "candidateIds"]
-  }
-);
-var opensteerReverseQueryCandidateItemSchema = objectSchema(
-  {
-    candidate: opensteerReverseCandidateRecordSchema,
-    reasons: arraySchema(stringSchema({ minLength: 1 }))
-  },
-  {
-    title: "OpensteerReverseQueryCandidateItem",
-    required: ["candidate", "reasons"]
-  }
-);
-objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    objective: stringSchema({ minLength: 1 }),
-    notes: stringSchema({ minLength: 1 }),
-    tags: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    pageRef: pageRefSchema,
-    stateSource: opensteerStateSourceKindSchema,
-    network: opensteerReverseNetworkFilterSchema,
-    includeScripts: { type: "boolean" },
-    includeStorage: { type: "boolean" },
-    includeSessionStorage: { type: "boolean" },
-    includeIndexedDb: { type: "boolean" },
-    interactionTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    targetHints: opensteerReverseTargetHintsSchema,
-    captureWindowMs: integerSchema({ minimum: 0 }),
-    manualCalibration: opensteerReverseManualCalibrationModeSchema
-  },
-  {
-    title: "OpensteerReverseDiscoverInput"
-  }
-);
-objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    reportId: stringSchema({ minLength: 1 }),
-    summary: objectSchema(
-      {
-        observationIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        recordCount: integerSchema({ minimum: 0 }),
-        clusterCount: integerSchema({ minimum: 0 }),
-        candidateCount: integerSchema({ minimum: 0 })
-      },
-      {
-        title: "OpensteerReverseDiscoverSummary",
-        required: ["observationIds", "recordCount", "clusterCount", "candidateCount"]
-      }
-    ),
-    index: objectSchema(
-      {
-        views: arraySchema(opensteerReverseQueryViewSchema, { uniqueItems: true }),
-        sortableKeys: arraySchema(opensteerReverseSortKeySchema, { uniqueItems: true }),
-        channels: arraySchema(opensteerReverseChannelKindSchema, { uniqueItems: true }),
-        hosts: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-        relationKinds: arraySchema(opensteerObservationClusterRelationshipKindSchema, {
-          uniqueItems: true
-        })
-      },
-      {
-        title: "OpensteerReverseDiscoverIndex",
-        required: ["views", "sortableKeys", "channels", "hosts", "relationKinds"]
-      }
-    )
-  },
-  {
-    title: "OpensteerReverseDiscoverOutput",
-    required: ["caseId", "reportId", "summary", "index"]
-  }
-);
-objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    view: opensteerReverseQueryViewSchema,
-    filters: opensteerReverseQueryFiltersSchema,
-    sort: opensteerReverseQuerySortSchema,
-    limit: integerSchema({ minimum: 1, maximum: 200 }),
-    cursor: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseQueryInput",
-    required: ["caseId"]
-  }
-);
-objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    view: opensteerReverseQueryViewSchema,
-    query: opensteerReverseQuerySnapshotSchema,
-    totalCount: integerSchema({ minimum: 0 }),
-    nextCursor: stringSchema({ minLength: 1 }),
-    records: arraySchema(opensteerReverseQueryRecordItemSchema),
-    clusters: arraySchema(opensteerReverseQueryClusterItemSchema),
-    candidates: arraySchema(opensteerReverseQueryCandidateItemSchema)
-  },
-  {
-    title: "OpensteerReverseQueryOutput",
-    required: ["caseId", "view", "query", "totalCount"]
-  }
-);
-objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    source: objectSchema(
-      {
-        kind: enumSchema(["record", "candidate"]),
-        id: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReversePackageCreateSource",
-        required: ["kind", "id"]
-      }
-    ),
-    templateId: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    notes: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReversePackageCreateInput",
-    required: ["caseId", "source"]
-  }
-);
-objectSchema(
-  {
-    package: opensteerReversePackageRecordSchema,
-    report: opensteerReverseReportRecordSchema
-  },
-  {
-    title: "OpensteerReversePackageCreateOutput",
-    required: ["package", "report"]
-  }
-);
-objectSchema(
-  {
-    packageId: stringSchema({ minLength: 1 }),
-    pageRef: pageRefSchema
-  },
-  {
-    title: "OpensteerReversePackageRunInput",
-    required: ["packageId"]
-  }
-);
-objectSchema(
-  {
-    packageId: stringSchema({ minLength: 1 }),
-    caseId: stringSchema({ minLength: 1 }),
-    source: objectSchema(
-      {
-        kind: enumSchema(["record", "candidate"]),
-        id: stringSchema({ minLength: 1 })
-      },
-      {
-        title: "OpensteerReversePackageRunSource",
-        required: ["kind", "id"]
-      }
-    ),
-    candidateId: stringSchema({ minLength: 1 }),
-    templateId: stringSchema({ minLength: 1 }),
-    success: { type: "boolean" },
-    kind: opensteerReversePackageKindSchema,
-    readiness: opensteerReversePackageReadinessSchema,
-    channel: opensteerReverseChannelKindSchema,
-    transport: transportKindSchema,
-    stateSource: opensteerStateSourceKindSchema,
-    recordId: stringSchema({ minLength: 1 }),
-    status: integerSchema({ minimum: 0 }),
-    validation: opensteerReverseReplayValidationSchema,
-    executedStepIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    failedStepId: stringSchema({ minLength: 1 }),
-    bindings: recordSchema({}, { title: "OpensteerReversePackageRunBindings" }),
-    replayRunId: stringSchema({ minLength: 1 }),
-    unresolvedRequirements: arraySchema(opensteerReverseRequirementSchema),
-    suggestedEdits: arraySchema(opensteerReverseSuggestedEditSchema),
-    error: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReversePackageRunOutput",
-    required: [
-      "packageId",
-      "source",
-      "success",
-      "kind",
-      "readiness",
-      "validation",
-      "executedStepIds",
-      "bindings",
-      "unresolvedRequirements",
-      "suggestedEdits"
-    ]
-  }
-);
-objectSchema(
-  {
-    packageId: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReverseExportInput",
-    required: ["packageId"]
-  }
-);
-objectSchema(
-  {
-    package: opensteerReversePackageRecordSchema,
-    requestPlan: opensteerRequestPlanRecordSchema
-  },
-  {
-    title: "OpensteerReverseExportOutput",
-    required: ["package"]
-  }
-);
-objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    packageId: stringSchema({ minLength: 1 }),
-    reportId: stringSchema({ minLength: 1 }),
-    kind: opensteerReverseReportKindSchema
-  },
-  {
-    title: "OpensteerReverseReportInput"
-  }
-);
-objectSchema(
-  {
-    report: opensteerReverseReportRecordSchema
-  },
-  {
-    title: "OpensteerReverseReportOutput",
-    required: ["report"]
-  }
-);
-objectSchema(
-  {
-    packageId: stringSchema({ minLength: 1 })
-  },
-  {
-    title: "OpensteerReversePackageGetInput",
-    required: ["packageId"]
-  }
-);
-objectSchema(
-  {
-    package: opensteerReversePackageRecordSchema
-  },
-  {
-    title: "OpensteerReversePackageGetOutput",
-    required: ["package"]
-  }
-);
-objectSchema(
-  {
-    caseId: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    kind: opensteerReversePackageKindSchema,
-    readiness: opensteerReversePackageReadinessSchema
-  },
-  {
-    title: "OpensteerReversePackageListInput"
-  }
-);
-objectSchema(
-  {
-    packages: arraySchema(opensteerReversePackageRecordSchema)
-  },
-  {
-    title: "OpensteerReversePackageListOutput",
-    required: ["packages"]
-  }
-);
-objectSchema(
-  {
-    packageId: stringSchema({ minLength: 1 }),
-    key: stringSchema({ minLength: 1 }),
-    version: stringSchema({ minLength: 1 }),
-    notes: stringSchema({ minLength: 1 }),
-    workflow: arraySchema(opensteerReverseWorkflowStepSchema),
-    resolvers: arraySchema(opensteerExecutableResolverSchema),
-    validators: arraySchema(opensteerValidationRuleSchema),
-    attachedTraceIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    attachedArtifactIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    attachedRecordIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true }),
-    stateSnapshotIds: arraySchema(stringSchema({ minLength: 1 }), { uniqueItems: true })
-  },
-  {
-    title: "OpensteerReversePackagePatchInput",
-    required: ["packageId"]
-  }
-);
-objectSchema(
-  {
-    package: opensteerReversePackageRecordSchema,
-    report: opensteerReverseReportRecordSchema
+      }
+    ),
+    capturedAjax: arraySchema(sandboxCapturedAjaxCallSchema),
+    errors: arraySchema(stringSchema({ minLength: 1 })),
+    durationMs: integerSchema({ minimum: 0 })
   },
   {
-    title: "OpensteerReversePackagePatchOutput",
-    required: ["package", "report"]
+    title: "OpensteerScriptSandboxOutput",
+    required: ["capturedAjax", "errors", "durationMs"]
   }
 );
 
@@ -6375,12 +4450,12 @@ var opensteerDomExtractInputSchema = defineSchema({
   ),
   anyOf: [defineSchema({ required: ["persist"] }), defineSchema({ required: ["schema"] })]
 });
-var jsonValueSchema3 = recordSchema({}, { title: "JsonValueRecord" });
+var jsonValueSchema2 = recordSchema({}, { title: "JsonValueRecord" });
 var opensteerDomExtractOutputSchema = objectSchema(
   {
     data: oneOfSchema(
       [
-        jsonValueSchema3,
+        jsonValueSchema2,
         arraySchema({}),
         stringSchema(),
         numberSchema(),
@@ -6783,7 +4858,7 @@ var opensteerSemanticOperationSpecificationsBase = [
   }),
   defineSemanticOperationSpec({
     name: "artifact.read",
-    description: "Read a persisted artifact by ID so agents can inspect captured scripts, storage, cookies, or snapshots linked from reverse packages and reports.",
+    description: "Read a persisted artifact by ID so agents can inspect captured scripts, storage, cookies, or snapshots linked from recorded workflows.",
     inputSchema: opensteerArtifactReadInputSchema,
     outputSchema: opensteerArtifactReadOutputSchema,
     requiredCapabilities: []
@@ -6992,9 +5067,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 +5138,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 +5170,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 {
@@ -7204,76 +5279,6 @@ var FilesystemRequestPlanRegistry = class extends FilesystemRegistryStore {
     });
   }
 };
-var FilesystemAuthRecipeRegistry = class extends FilesystemRegistryStore {
-  constructor(rootPath) {
-    super(rootPath, ["registry", "auth-recipes"]);
-  }
-  async write(input) {
-    const id = normalizeNonEmptyString("id", input.id ?? `auth-recipe:${crypto.randomUUID()}`);
-    const key = normalizeNonEmptyString("key", input.key);
-    const version = normalizeNonEmptyString("version", input.version);
-    const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
-    const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
-    if (updatedAt < createdAt) {
-      throw new RangeError("updatedAt must be greater than or equal to createdAt");
-    }
-    const payload = input.payload;
-    const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
-    const provenance = normalizeProvenance2(input.provenance);
-    const record = {
-      id,
-      key,
-      version,
-      createdAt,
-      updatedAt,
-      contentHash,
-      tags: normalizeTags(input.tags),
-      ...provenance === void 0 ? {} : { provenance },
-      payload
-    };
-    return this.writeRecord(record);
-  }
-  async list(input = {}) {
-    const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
-    const records = await this.readAllRecords();
-    return key === void 0 ? records : records.filter((record) => record.key === key);
-  }
-};
-var FilesystemRecipeRegistry = class extends FilesystemRegistryStore {
-  constructor(rootPath) {
-    super(rootPath, ["registry", "recipes"]);
-  }
-  async write(input) {
-    const id = normalizeNonEmptyString("id", input.id ?? `recipe:${crypto.randomUUID()}`);
-    const key = normalizeNonEmptyString("key", input.key);
-    const version = normalizeNonEmptyString("version", input.version);
-    const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
-    const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
-    if (updatedAt < createdAt) {
-      throw new RangeError("updatedAt must be greater than or equal to createdAt");
-    }
-    const payload = input.payload;
-    const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
-    const provenance = normalizeProvenance2(input.provenance);
-    const record = {
-      id,
-      key,
-      version,
-      createdAt,
-      updatedAt,
-      contentHash,
-      tags: normalizeTags(input.tags),
-      ...provenance === void 0 ? {} : { provenance },
-      payload
-    };
-    return this.writeRecord(record);
-  }
-  async list(input = {}) {
-    const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
-    const records = await this.readAllRecords();
-    return key === void 0 ? records : records.filter((record) => record.key === key);
-  }
-};
 var FilesystemInteractionTraceRegistry = class extends FilesystemRegistryStore {
   constructor(rootPath) {
     super(rootPath, ["registry", "interaction-traces"]);
@@ -7309,163 +5314,15 @@ var FilesystemInteractionTraceRegistry = class extends FilesystemRegistryStore {
     return key === void 0 ? records : records.filter((record) => record.key === key);
   }
 };
-var FilesystemReverseCaseRegistry = class extends FilesystemRegistryStore {
-  constructor(rootPath) {
-    super(rootPath, ["registry", "reverse-cases"]);
-  }
-  async write(input) {
-    const id = normalizeNonEmptyString("id", input.id ?? `reverse-case:${crypto.randomUUID()}`);
-    const key = normalizeNonEmptyString("key", input.key);
-    const version = normalizeNonEmptyString("version", input.version);
-    const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
-    const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
-    if (updatedAt < createdAt) {
-      throw new RangeError("updatedAt must be greater than or equal to createdAt");
-    }
-    const payload = input.payload;
-    const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
-    const provenance = normalizeProvenance2(input.provenance);
-    const record = {
-      id,
-      key,
-      version,
-      createdAt,
-      updatedAt,
-      contentHash,
-      tags: normalizeTags(input.tags),
-      ...provenance === void 0 ? {} : { provenance },
-      payload
-    };
-    return this.writeRecord(record);
-  }
-  async list(input = {}) {
-    const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
-    const records = await this.readAllRecords();
-    return key === void 0 ? records : records.filter((record) => record.key === key);
-  }
-  async update(input) {
-    const id = normalizeNonEmptyString("id", input.id);
-    return withFilesystemLock(this.writeLockPath(), async () => {
-      const existing = await this.getById(id);
-      if (existing === void 0) {
-        throw new Error(`registry record ${id} was not found`);
-      }
-      const nextUpdatedAt = normalizeTimestamp(
-        "updatedAt",
-        input.updatedAt ?? Math.max(Date.now(), existing.updatedAt)
-      );
-      if (nextUpdatedAt < existing.createdAt) {
-        throw new RangeError("updatedAt must be greater than or equal to createdAt");
-      }
-      const nextPayload = input.payload;
-      const nextProvenance = normalizeProvenance2(input.provenance ?? existing.provenance);
-      const nextRecord = {
-        ...existing,
-        updatedAt: nextUpdatedAt,
-        contentHash: sha256Hex(Buffer.from(canonicalJsonString(nextPayload), "utf8")),
-        tags: normalizeTags(input.tags ?? existing.tags),
-        ...nextProvenance === void 0 ? {} : { provenance: nextProvenance },
-        payload: nextPayload
-      };
-      await writeJsonFileAtomic(this.recordPath(id), nextRecord);
-      return nextRecord;
-    });
-  }
-};
-var FilesystemReversePackageRegistry = class extends FilesystemRegistryStore {
-  constructor(rootPath) {
-    super(rootPath, ["registry", "reverse-packages"]);
-  }
-  async write(input) {
-    const id = normalizeNonEmptyString("id", input.id ?? `reverse-package:${crypto.randomUUID()}`);
-    const key = normalizeNonEmptyString("key", input.key);
-    const version = normalizeNonEmptyString("version", input.version);
-    const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
-    const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
-    if (updatedAt < createdAt) {
-      throw new RangeError("updatedAt must be greater than or equal to createdAt");
-    }
-    const payload = input.payload;
-    const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
-    const provenance = normalizeProvenance2(input.provenance);
-    const record = {
-      id,
-      key,
-      version,
-      createdAt,
-      updatedAt,
-      contentHash,
-      tags: normalizeTags(input.tags),
-      ...provenance === void 0 ? {} : { provenance },
-      payload
-    };
-    return this.writeRecord(record);
-  }
-  async list(input = {}) {
-    const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
-    const records = await this.readAllRecords();
-    return key === void 0 ? records : records.filter((record) => record.key === key);
-  }
-};
-var FilesystemReverseReportRegistry = class extends FilesystemRegistryStore {
-  constructor(rootPath) {
-    super(rootPath, ["registry", "reverse-reports"]);
-  }
-  async write(input) {
-    const id = normalizeNonEmptyString("id", input.id ?? `reverse-report:${crypto.randomUUID()}`);
-    const key = normalizeNonEmptyString("key", input.key);
-    const version = normalizeNonEmptyString("version", input.version);
-    const createdAt = normalizeTimestamp("createdAt", input.createdAt ?? Date.now());
-    const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? createdAt);
-    if (updatedAt < createdAt) {
-      throw new RangeError("updatedAt must be greater than or equal to createdAt");
-    }
-    const payload = input.payload;
-    const contentHash = sha256Hex(Buffer.from(canonicalJsonString(payload), "utf8"));
-    const provenance = normalizeProvenance2(input.provenance);
-    const record = {
-      id,
-      key,
-      version,
-      createdAt,
-      updatedAt,
-      contentHash,
-      tags: normalizeTags(input.tags),
-      ...provenance === void 0 ? {} : { provenance },
-      payload
-    };
-    return this.writeRecord(record);
-  }
-  async list(input = {}) {
-    const key = input.key === void 0 ? void 0 : normalizeNonEmptyString("key", input.key);
-    const records = await this.readAllRecords();
-    return key === void 0 ? records : records.filter((record) => record.key === key);
-  }
-};
 function createDescriptorRegistry(rootPath) {
   return new FilesystemDescriptorRegistry(rootPath);
 }
 function createRequestPlanRegistry(rootPath) {
   return new FilesystemRequestPlanRegistry(rootPath);
 }
-function createAuthRecipeRegistry(rootPath) {
-  return new FilesystemAuthRecipeRegistry(rootPath);
-}
-function createRecipeRegistry(rootPath) {
-  return new FilesystemRecipeRegistry(rootPath);
-}
 function createInteractionTraceRegistry(rootPath) {
   return new FilesystemInteractionTraceRegistry(rootPath);
 }
-function createReverseCaseRegistry(rootPath) {
-  return new FilesystemReverseCaseRegistry(rootPath);
-}
-function createReversePackageRegistry(rootPath) {
-  return new FilesystemReversePackageRegistry(rootPath);
-}
-function createReverseReportRegistry(rootPath) {
-  return new FilesystemReverseReportRegistry(rootPath);
-}
 var TAG_DELIMITER = "";
 var NODE_SQLITE_SPECIFIER = `node:${"sqlite"}`;
 var SAVED_NETWORK_SQLITE_SUPPORT_ERROR = "Saved-network operations require Node's built-in SQLite support. Use a Node runtime with node:sqlite enabled.";
@@ -7475,7 +5332,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 +5572,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 +6171,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 +6268,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 +6326,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 +6353,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 +6416,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 +6462,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 +6522,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 +6599,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 +6618,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 +6664,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 +6687,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 +6696,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);
@@ -8910,20 +6767,10 @@ async function createFilesystemOpensteerWorkspace(options) {
   await descriptors.initialize();
   const requestPlans = createRequestPlanRegistry(options.rootPath);
   await requestPlans.initialize();
-  const authRecipes = createAuthRecipeRegistry(options.rootPath);
-  await authRecipes.initialize();
-  const recipes = createRecipeRegistry(options.rootPath);
-  await recipes.initialize();
   const savedNetwork = createSavedNetworkStore(options.rootPath);
   await savedNetwork.initialize();
-  const reverseCases = createReverseCaseRegistry(options.rootPath);
-  await reverseCases.initialize();
   const interactionTraces = createInteractionTraceRegistry(options.rootPath);
   await interactionTraces.initialize();
-  const reversePackages = createReversePackageRegistry(options.rootPath);
-  await reversePackages.initialize();
-  const reverseReports = createReverseReportRegistry(options.rootPath);
-  await reverseReports.initialize();
   const traces = createTraceStore(options.rootPath, artifacts);
   await traces.initialize();
   const observations = createObservationStore(options.rootPath, artifacts);
@@ -8949,13 +6796,8 @@ async function createFilesystemOpensteerWorkspace(options) {
     registry: {
       descriptors,
       requestPlans,
-      authRecipes,
-      recipes,
       savedNetwork,
-      reverseCases,
-      interactionTraces,
-      reversePackages,
-      reverseReports
+      interactionTraces
     },
     lock(task) {
       return withFilesystemLock(lockPath, task);
@@ -9605,9 +7447,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 +7979,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 +8039,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 +8170,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 +9707,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 +9742,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 +9930,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 +10028,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 +10079,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 +10412,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 +10517,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 +10603,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 +10731,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 +10769,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 +10804,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 +10825,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 +10894,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 +11163,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 +11482,8 @@ function collectPersistedValueNodeRefs(node) {
     return [
       {
         path: sanitizeElementPath(node.$path),
-        replacePath: (path15) => {
-          node.$path = sanitizeElementPath(path15);
+        replacePath: (path18) => {
+          node.$path = sanitizeElementPath(path18);
         }
       }
     ];
@@ -13655,13 +11497,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,24 +11913,174 @@ 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});
-function isProcessRunning(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);
+    return true;
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+    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 {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
-    return code !== "ESRCH";
+    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 = [
@@ -14101,7 +12093,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 +12108,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 +12120,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 +12141,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 +12173,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 +12190,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 +12219,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 +12253,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 +12283,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 +12349,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 +12386,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 +12410,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 +12453,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 +12463,7 @@ function detectLocalChromeInstallations() {
         resolveBinaryFromPath("chromium"),
         resolveBinaryFromPath("chromium-browser")
       ]),
-      userDataDir: path7.join(os.homedir(), ".config", "chromium")
+      userDataDir: path10.join(os.homedir(), ".config", "chromium")
     }
   ];
 }
@@ -14483,8 +12475,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 +12488,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 +12500,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 +12733,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 +12780,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 +12817,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 +12850,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 +12860,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 +13342,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 +13384,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 +13942,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 +14004,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 +14077,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 +14115,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 +14145,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 +14211,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 +14239,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 +14253,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 +14404,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 +14434,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 +14608,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 +14756,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 +14818,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 +14840,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 +14886,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 +14965,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 +15001,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 +15082,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 +15283,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 +15359,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 +15368,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 +15566,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 +15578,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 +15628,7 @@ function resolveCloudConfig(input = {}) {
 
 // ../runtime-core/package.json
 var package_default = {
-  version: "0.2.0"};
+  version: "0.2.2"};
 
 // ../runtime-core/src/version.ts
 var OPENSTEER_RUNTIME_CORE_VERSION = package_default.version;
@@ -17889,11 +16384,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 +16445,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 +16456,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 +18910,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 +18935,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 +19101,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 +19145,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 +19199,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 +19243,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 +19480,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 +25269,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 +25692,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 +25727,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({
@@ -27427,7 +25922,7 @@ var Opensteer = class {
       scroll: (input) => this.scroll(input)
     };
     this.network = {
-      query: (input = {}) => this.queryNetwork(input),
+      query: (input = {}) => this.runtime.queryNetwork(input),
       detail: (recordId, options2) => this.runtime.getNetworkDetail({ recordId, ...options2 })
     };
   }
@@ -27461,9 +25956,6 @@ var Opensteer = class {
     } : input;
     return (await this.runtime.evaluate(normalized)).value;
   }
-  async evaluateJson(input) {
-    return this.evaluate(input);
-  }
   async addInitScript(input) {
     return this.runtime.addInitScript(
       typeof input === "string" ? {
@@ -27500,34 +25992,6 @@ var Opensteer = class {
   async extract(input) {
     return (await this.runtime.extract(input)).data;
   }
-  async queryNetwork(input = {}) {
-    return this.runtime.queryNetwork(input);
-  }
-  async waitForNetwork(input) {
-    const { timeoutMs, pollIntervalMs, ...query } = input;
-    const timeoutAt = Date.now() + (timeoutMs ?? 3e4);
-    const pollInterval = pollIntervalMs ?? 100;
-    const baseline = new Set(
-      (await this.runtime.queryNetwork({ ...query, limit: 200 })).records.map(
-        (record) => record.recordId
-      )
-    );
-    while (true) {
-      const next = (await this.runtime.queryNetwork({ ...query, limit: 200 })).records.find(
-        (record) => !baseline.has(record.recordId)
-      );
-      if (next !== void 0) {
-        return next;
-      }
-      if (Date.now() >= timeoutAt) {
-        throw new Error("waitForNetwork timed out");
-      }
-      await delay2(pollInterval);
-    }
-  }
-  async waitForResponse(input) {
-    return this.waitForNetwork(input);
-  }
   async waitForPage(input = {}) {
     const baseline = new Set((await this.runtime.listPages()).pages.map((page) => page.pageRef));
     const timeoutAt = Date.now() + (input.timeoutMs ?? 3e4);
@@ -27551,7 +26015,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 +26167,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));
 }