opensteer 0.8.8 → 0.8.9

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var path6 = require('path');
+var path7 = 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 async_hooks = require('async_hooks');
 var module$1 = require('module');
 var sharp = require('sharp');
 var cheerio = require('cheerio');
@@ -39,14 +40,19 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var path6__default = /*#__PURE__*/_interopDefault(path6);
+var path7__default = /*#__PURE__*/_interopDefault(path7);
 var sharp__default = /*#__PURE__*/_interopDefault(sharp);
 var cheerio__namespace = /*#__PURE__*/_interopNamespace(cheerio);
 var prettier__namespace = /*#__PURE__*/_interopNamespace(prettier);
 var vm__default = /*#__PURE__*/_interopDefault(vm);
 var WebSocket2__default = /*#__PURE__*/_interopDefault(WebSocket2);
 
-// ../runtime-core/src/root.ts
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // ../runtime-core/src/json.ts
 function isPlainObject(value) {
@@ -56,30 +62,30 @@ function isPlainObject(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function canonicalizeJsonValue(value, path13) {
+function canonicalizeJsonValue(value, path15) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) {
-      throw new TypeError(`${path13} must be a finite JSON number`);
+      throw new TypeError(`${path15} must be a finite JSON number`);
     }
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path13}[${index}]`));
+    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path15}[${index}]`));
   }
   if (!isPlainObject(value)) {
-    throw new TypeError(`${path13} must be a plain JSON object`);
+    throw new TypeError(`${path15} 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(`${path13}.${key} must not be undefined`);
+      throw new TypeError(`${path15}.${key} must not be undefined`);
     }
-    result[key] = canonicalizeJsonValue(entry, `${path13}.${key}`);
+    result[key] = canonicalizeJsonValue(entry, `${path15}.${key}`);
   }
   return result;
 }
@@ -116,7 +122,7 @@ function joinStoragePath(...segments) {
   return segments.join("/");
 }
 function resolveStoragePath(rootPath, relativePath) {
-  if (path6__default.default.isAbsolute(relativePath)) {
+  if (path7__default.default.isAbsolute(relativePath)) {
     throw new TypeError(`storage path ${relativePath} must be relative`);
   }
   const segments = relativePath.split("/");
@@ -128,7 +134,7 @@ function resolveStoragePath(rootPath, relativePath) {
       throw new TypeError(`storage path ${relativePath} must not contain path traversal`);
     }
   }
-  return path6__default.default.join(rootPath, ...segments);
+  return path7__default.default.join(rootPath, ...segments);
 }
 async function ensureDirectory(directoryPath) {
   await promises.mkdir(directoryPath, { recursive: true });
@@ -148,7 +154,7 @@ async function writeJsonFileAtomic(filePath, value) {
   await writeTextFileAtomic(filePath, stableJsonString(value));
 }
 async function writeTextFileAtomic(filePath, value) {
-  await ensureDirectory(path6__default.default.dirname(filePath));
+  await ensureDirectory(path7__default.default.dirname(filePath));
   const temporaryPath = `${filePath}.${crypto.randomUUID()}.tmp`;
   await promises.writeFile(temporaryPath, value, "utf8");
   await promises.rename(temporaryPath, filePath);
@@ -157,7 +163,7 @@ async function writeJsonFileExclusive(filePath, value) {
   await writeTextFileExclusive(filePath, stableJsonString(value));
 }
 async function writeTextFileExclusive(filePath, value) {
-  await ensureDirectory(path6__default.default.dirname(filePath));
+  await ensureDirectory(path7__default.default.dirname(filePath));
   const handle = await promises.open(filePath, "wx");
   try {
     await handle.writeFile(value, "utf8");
@@ -166,7 +172,7 @@ async function writeTextFileExclusive(filePath, value) {
   }
 }
 async function writeBufferIfMissing(filePath, value) {
-  await ensureDirectory(path6__default.default.dirname(filePath));
+  await ensureDirectory(path7__default.default.dirname(filePath));
   try {
     const handle = await promises.open(filePath, "wx");
     try {
@@ -200,7 +206,7 @@ function isAlreadyExistsError(error) {
   return error?.code === "EEXIST";
 }
 async function withFilesystemLock(lockPath, task) {
-  await ensureDirectory(path6__default.default.dirname(lockPath));
+  await ensureDirectory(path7__default.default.dirname(lockPath));
   let attempt = 0;
   while (true) {
     try {
@@ -212,7 +218,7 @@ async function withFilesystemLock(lockPath, task) {
       }
       const delayMs = LOCK_RETRY_DELAYS_MS[Math.min(attempt, LOCK_RETRY_DELAYS_MS.length - 1)];
       attempt += 1;
-      await new Promise((resolve5) => setTimeout(resolve5, delayMs));
+      await new Promise((resolve4) => setTimeout(resolve4, delayMs));
     }
   }
   try {
@@ -255,8 +261,8 @@ async function readStructuredPayload(objectPath) {
 var FilesystemArtifactStore = class {
   constructor(rootPath) {
     this.rootPath = rootPath;
-    this.manifestsDirectory = path6__default.default.join(this.rootPath, "artifacts", "manifests");
-    this.objectsDirectory = path6__default.default.join(this.rootPath, "artifacts", "objects", "sha256");
+    this.manifestsDirectory = path7__default.default.join(this.rootPath, "artifacts", "manifests");
+    this.objectsDirectory = path7__default.default.join(this.rootPath, "artifacts", "objects", "sha256");
   }
   manifestsDirectory;
   objectsDirectory;
@@ -481,7 +487,7 @@ var FilesystemArtifactStore = class {
     }
   }
   manifestPath(artifactId) {
-    return path6__default.default.join(this.manifestsDirectory, `${encodePathSegment(artifactId)}.json`);
+    return path7__default.default.join(this.manifestsDirectory, `${encodePathSegment(artifactId)}.json`);
   }
 };
 function createArtifactStore(rootPath) {
@@ -576,31 +582,31 @@ function oneOfSchema(members, options = {}) {
 }
 
 // ../protocol/src/validation.ts
-function validateJsonSchema(schema, value, path13 = "$") {
-  return validateSchemaNode(schema, value, path13);
+function validateJsonSchema(schema, value, path15 = "$") {
+  return validateSchemaNode(schema, value, path15);
 }
-function validateSchemaNode(schema, value, path13) {
+function validateSchemaNode(schema, value, path15) {
   const issues = [];
   if ("const" in schema && !isJsonValueEqual(schema.const, value)) {
     issues.push({
-      path: path13,
+      path: path15,
       message: `must equal ${JSON.stringify(schema.const)}`
     });
     return issues;
   }
   if (schema.enum !== void 0 && !schema.enum.some((candidate) => isJsonValueEqual(candidate, value))) {
     issues.push({
-      path: path13,
+      path: path15,
       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, path13));
+    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path15));
     const validBranches = branchIssues.filter((current) => current.length === 0).length;
     if (validBranches !== 1) {
       issues.push({
-        path: path13,
+        path: path15,
         message: validBranches === 0 ? "must match exactly one supported shape" : "matches multiple supported shapes"
       });
       return issues;
@@ -608,11 +614,11 @@ function validateSchemaNode(schema, value, path13) {
   }
   if (schema.anyOf !== void 0) {
     const hasMatch = schema.anyOf.some(
-      (member) => validateSchemaNode(member, value, path13).length === 0
+      (member) => validateSchemaNode(member, value, path15).length === 0
     );
     if (!hasMatch) {
       issues.push({
-        path: path13,
+        path: path15,
         message: "must match at least one supported shape"
       });
       return issues;
@@ -620,7 +626,7 @@ function validateSchemaNode(schema, value, path13) {
   }
   if (schema.allOf !== void 0) {
     for (const member of schema.allOf) {
-      issues.push(...validateSchemaNode(member, value, path13));
+      issues.push(...validateSchemaNode(member, value, path15));
     }
     if (issues.length > 0) {
       return issues;
@@ -628,7 +634,7 @@ function validateSchemaNode(schema, value, path13) {
   }
   if (schema.type !== void 0 && !matchesSchemaType(schema.type, value)) {
     issues.push({
-      path: path13,
+      path: path15,
       message: `must be ${describeSchemaType(schema.type)}`
     });
     return issues;
@@ -636,19 +642,19 @@ function validateSchemaNode(schema, value, path13) {
   if (typeof value === "string") {
     if (schema.minLength !== void 0 && value.length < schema.minLength) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must have length >= ${String(schema.minLength)}`
       });
     }
     if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must have length <= ${String(schema.maxLength)}`
       });
     }
     if (schema.pattern !== void 0 && !new RegExp(schema.pattern).test(value)) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must match pattern ${schema.pattern}`
       });
     }
@@ -657,25 +663,25 @@ function validateSchemaNode(schema, value, path13) {
   if (typeof value === "number") {
     if (schema.minimum !== void 0 && value < schema.minimum) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must be >= ${String(schema.minimum)}`
       });
     }
     if (schema.maximum !== void 0 && value > schema.maximum) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must be <= ${String(schema.maximum)}`
       });
     }
     if (schema.exclusiveMinimum !== void 0 && value <= schema.exclusiveMinimum) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must be > ${String(schema.exclusiveMinimum)}`
       });
     }
     if (schema.exclusiveMaximum !== void 0 && value >= schema.exclusiveMaximum) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must be < ${String(schema.exclusiveMaximum)}`
       });
     }
@@ -684,13 +690,13 @@ function validateSchemaNode(schema, value, path13) {
   if (Array.isArray(value)) {
     if (schema.minItems !== void 0 && value.length < schema.minItems) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must have at least ${String(schema.minItems)} items`
       });
     }
     if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
       issues.push({
-        path: path13,
+        path: path15,
         message: `must have at most ${String(schema.maxItems)} items`
       });
     }
@@ -700,7 +706,7 @@ function validateSchemaNode(schema, value, path13) {
         const key = JSON.stringify(item);
         if (seen.has(key)) {
           issues.push({
-            path: path13,
+            path: path15,
             message: "must not contain duplicate items"
           });
           break;
@@ -710,7 +716,7 @@ function validateSchemaNode(schema, value, path13) {
     }
     if (schema.items !== void 0) {
       for (let index = 0; index < value.length; index += 1) {
-        issues.push(...validateSchemaNode(schema.items, value[index], `${path13}[${String(index)}]`));
+        issues.push(...validateSchemaNode(schema.items, value[index], `${path15}[${String(index)}]`));
       }
     }
     return issues;
@@ -720,7 +726,7 @@ function validateSchemaNode(schema, value, path13) {
     for (const requiredKey of schema.required ?? []) {
       if (!(requiredKey in value)) {
         issues.push({
-          path: joinObjectPath(path13, requiredKey),
+          path: joinObjectPath(path15, requiredKey),
           message: "is required"
         });
       }
@@ -729,13 +735,13 @@ function validateSchemaNode(schema, value, path13) {
       const propertySchema = properties[key];
       if (propertySchema !== void 0) {
         issues.push(
-          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path13, key))
+          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path15, key))
         );
         continue;
       }
       if (schema.additionalProperties === false) {
         issues.push({
-          path: joinObjectPath(path13, key),
+          path: joinObjectPath(path15, key),
           message: "is not allowed"
         });
         continue;
@@ -745,7 +751,7 @@ function validateSchemaNode(schema, value, path13) {
           ...validateSchemaNode(
             schema.additionalProperties,
             propertyValue,
-            joinObjectPath(path13, key)
+            joinObjectPath(path15, key)
           )
         );
       }
@@ -989,8 +995,8 @@ function matchesNetworkRecordFilters(record, filters) {
     }
   }
   if (filters.path !== void 0) {
-    const path13 = getParsedUrl().pathname;
-    if (!includesCaseInsensitive(path13, filters.path)) {
+    const path15 = getParsedUrl().pathname;
+    if (!includesCaseInsensitive(path15, filters.path)) {
       return false;
     }
   }
@@ -7080,9 +7086,9 @@ function compareByCreatedAtAndId(left, right) {
 var FilesystemRegistryStore = class {
   constructor(rootPath, registryRelativePath) {
     this.registryRelativePath = registryRelativePath;
-    const basePath = path6__default.default.join(rootPath, ...registryRelativePath);
-    this.recordsDirectory = path6__default.default.join(basePath, "records");
-    this.indexesDirectory = path6__default.default.join(basePath, "indexes", "by-key");
+    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");
   }
   recordsDirectory;
   indexesDirectory;
@@ -7151,7 +7157,7 @@ var FilesystemRegistryStore = class {
   async readRecordsFromDirectory() {
     const files = await listJsonFiles(this.recordsDirectory);
     const records = await Promise.all(
-      files.map((fileName) => readJsonFile(path6__default.default.join(this.recordsDirectory, fileName)))
+      files.map((fileName) => readJsonFile(path7__default.default.join(this.recordsDirectory, fileName)))
     );
     records.sort(compareByCreatedAtAndId);
     return records;
@@ -7183,17 +7189,17 @@ var FilesystemRegistryStore = class {
     return record;
   }
   recordPath(id) {
-    return path6__default.default.join(this.recordsDirectory, `${encodePathSegment(id)}.json`);
+    return path7__default.default.join(this.recordsDirectory, `${encodePathSegment(id)}.json`);
   }
   indexPath(key, version) {
-    return path6__default.default.join(
+    return path7__default.default.join(
       this.indexesDirectory,
       encodePathSegment(key),
       `${encodePathSegment(version)}.json`
     );
   }
   writeLockPath() {
-    return path6__default.default.join(path6__default.default.dirname(this.recordsDirectory), ".write.lock");
+    return path7__default.default.join(path7__default.default.dirname(this.recordsDirectory), ".write.lock");
   }
 };
 var FilesystemDescriptorRegistry = class extends FilesystemRegistryStore {
@@ -7563,7 +7569,7 @@ var SqliteSavedNetworkStore = class {
   directoryInitialization;
   databaseInitialization;
   constructor(rootPath) {
-    this.databasePath = path6__default.default.join(rootPath, "registry", "saved-network.sqlite");
+    this.databasePath = path7__default.default.join(rootPath, "registry", "saved-network.sqlite");
   }
   async initialize() {
     await this.ensureDatabaseDirectory();
@@ -7773,7 +7779,7 @@ var SqliteSavedNetworkStore = class {
     }
   }
   async ensureDatabaseDirectory() {
-    this.directoryInitialization ??= ensureDirectory(path6__default.default.dirname(this.databasePath)).catch(
+    this.directoryInitialization ??= ensureDirectory(path7__default.default.dirname(this.databasePath)).catch(
       (error) => {
         this.directoryInitialization = void 0;
         throw error;
@@ -8163,6 +8169,546 @@ function withSqliteTransaction(database, task) {
 function createSavedNetworkStore(rootPath) {
   return new SqliteSavedNetworkStore(rootPath);
 }
+
+// ../runtime-core/src/observation-utils.ts
+var REDACTED = "[REDACTED]";
+var SENSITIVE_KEY_PATTERN = /(authorization|proxy[_-]?authorization|cookie|set-cookie|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token|token|secret|password|passwd|private[_-]?key|database[_-]?url|db[_-]?url|session(?:id)?|csrf(?:token)?)/i;
+var SENSITIVE_VALUE_PATTERNS = [
+  /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+  /\bAIza[0-9A-Za-z_-]{20,}\b/g,
+  /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g,
+  /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+  /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}\b/gi
+];
+function normalizeObservationContext(context) {
+  if (context === void 0) {
+    return void 0;
+  }
+  const normalized = {
+    ...context.sessionRef === void 0 ? {} : { sessionRef: context.sessionRef },
+    ...context.pageRef === void 0 ? {} : { pageRef: context.pageRef },
+    ...context.frameRef === void 0 ? {} : { frameRef: context.frameRef },
+    ...context.documentRef === void 0 ? {} : { documentRef: context.documentRef },
+    ...context.documentEpoch === void 0 ? {} : { documentEpoch: context.documentEpoch }
+  };
+  return Object.keys(normalized).length === 0 ? void 0 : normalized;
+}
+function createObservationRedactor(config) {
+  const state = createRedactionState(config);
+  return {
+    redactText(value) {
+      return redactString(value, state);
+    },
+    redactJson(value) {
+      return value === void 0 ? void 0 : redactUnknown(value, state, /* @__PURE__ */ new WeakSet());
+    },
+    redactError(error) {
+      if (error === void 0) {
+        return void 0;
+      }
+      return {
+        ...error.code === void 0 ? {} : { code: redactString(error.code, state) },
+        message: redactString(error.message, state),
+        ...error.retriable === void 0 ? {} : { retriable: error.retriable },
+        ...error.details === void 0 ? {} : { details: toCanonicalJsonValue(redactUnknown(error.details, state, /* @__PURE__ */ new WeakSet())) }
+      };
+    },
+    redactLabels(labels) {
+      if (labels === void 0) {
+        return void 0;
+      }
+      const next = Object.entries(labels).reduce(
+        (accumulator, [key, value]) => {
+          accumulator[key] = isSensitiveKey(key, state) ? REDACTED : redactString(value, state);
+          return accumulator;
+        },
+        {}
+      );
+      return Object.keys(next).length === 0 ? void 0 : next;
+    },
+    redactTraceContext(traceContext) {
+      if (traceContext === void 0) {
+        return void 0;
+      }
+      const next = {
+        ...traceContext.traceparent === void 0 ? {} : { traceparent: redactString(traceContext.traceparent, state) },
+        ...traceContext.baggage === void 0 ? {} : { baggage: redactString(traceContext.baggage, state) }
+      };
+      return Object.keys(next).length === 0 ? void 0 : next;
+    }
+  };
+}
+function createRedactionState(config) {
+  return {
+    sensitiveKeys: new Set(
+      (config?.redaction?.sensitiveKeys ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0)
+    ),
+    sensitiveValues: [
+      ...new Set(
+        (config?.redaction?.sensitiveValues ?? []).map((value) => value.trim()).filter((value) => value.length > 0)
+      )
+    ]
+  };
+}
+function redactUnknown(value, state, seen) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return redactString(value, state);
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (seen.has(value)) {
+    return REDACTED;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactUnknown(entry, state, seen));
+  }
+  const next = {};
+  for (const [key, nestedValue] of Object.entries(value)) {
+    next[key] = isSensitiveKey(key, state) ? REDACTED : redactUnknown(nestedValue, state, seen);
+  }
+  return next;
+}
+function redactString(value, state) {
+  let next = value;
+  for (const secret of state.sensitiveValues) {
+    next = next.split(secret).join(REDACTED);
+  }
+  for (const pattern of SENSITIVE_VALUE_PATTERNS) {
+    next = next.replace(pattern, REDACTED);
+  }
+  return redactUrlString(next, state);
+}
+function redactUrlString(value, state) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return value;
+  }
+  let changed = false;
+  if (parsed.username) {
+    parsed.username = REDACTED;
+    changed = true;
+  }
+  if (parsed.password) {
+    parsed.password = REDACTED;
+    changed = true;
+  }
+  for (const [key] of parsed.searchParams) {
+    if (!isSensitiveKey(key, state)) {
+      continue;
+    }
+    parsed.searchParams.set(key, REDACTED);
+    changed = true;
+  }
+  return changed ? parsed.toString() : value;
+}
+function isSensitiveKey(key, state) {
+  return state.sensitiveKeys.has(key.trim().toLowerCase()) || SENSITIVE_KEY_PATTERN.test(key);
+}
+
+// ../runtime-core/src/observations.ts
+function normalizeObservabilityConfig(input) {
+  const profile = input?.profile ?? "diagnostic";
+  const labels = input?.labels === void 0 ? void 0 : Object.entries(input.labels).reduce((accumulator, [key, value]) => {
+    const normalizedKey = key.trim();
+    const normalizedValue = value.trim();
+    if (normalizedKey.length === 0 || normalizedValue.length === 0) {
+      return accumulator;
+    }
+    if (Object.keys(accumulator).length >= 20) {
+      return accumulator;
+    }
+    accumulator[normalizedKey] = normalizedValue;
+    return accumulator;
+  }, {});
+  const redaction = input?.redaction === void 0 ? void 0 : {
+    ...input.redaction.sensitiveKeys === void 0 ? {} : {
+      sensitiveKeys: input.redaction.sensitiveKeys.map((value) => value.trim()).filter((value) => value.length > 0)
+    },
+    ...input.redaction.sensitiveValues === void 0 ? {} : {
+      sensitiveValues: input.redaction.sensitiveValues.map((value) => value.trim()).filter((value) => value.length > 0)
+    }
+  };
+  return {
+    profile,
+    ...labels === void 0 || Object.keys(labels).length === 0 ? {} : { labels },
+    ...input?.traceContext === void 0 ? {} : {
+      traceContext: {
+        ...input.traceContext.traceparent === void 0 ? {} : { traceparent: input.traceContext.traceparent.trim() },
+        ...input.traceContext.baggage === void 0 ? {} : { baggage: input.traceContext.baggage.trim() }
+      }
+    },
+    ...redaction === void 0 ? {} : { redaction }
+  };
+}
+function eventFileName(sequence) {
+  return `${String(sequence).padStart(12, "0")}.json`;
+}
+var FilesystemSessionSink = class {
+  constructor(store, sessionId) {
+    this.store = store;
+    this.sessionId = sessionId;
+  }
+  append(input) {
+    return this.store.appendEvent(this.sessionId, input);
+  }
+  appendBatch(input) {
+    return this.store.appendEvents(this.sessionId, input);
+  }
+  writeArtifact(input) {
+    return this.store.writeArtifact(this.sessionId, input);
+  }
+  async flush() {
+  }
+  close(reason) {
+    return this.store.closeSession(this.sessionId, reason);
+  }
+};
+var FilesystemObservationStoreImpl = class {
+  constructor(rootPath, artifacts) {
+    this.rootPath = rootPath;
+    this.artifacts = artifacts;
+    this.sessionsDirectory = path7__default.default.join(this.rootPath, "observations", "sessions");
+  }
+  sessionsDirectory;
+  redactors = /* @__PURE__ */ new Map();
+  async initialize() {
+    await ensureDirectory(this.sessionsDirectory);
+  }
+  async openSession(input) {
+    const sessionId = normalizeNonEmptyString("sessionId", input.sessionId);
+    const openedAt = normalizeTimestamp("openedAt", input.openedAt ?? Date.now());
+    const config = normalizeObservabilityConfig(input.config);
+    const redactor = createObservationRedactor(config);
+    this.redactors.set(sessionId, redactor);
+    const redactedLabels = redactor.redactLabels(config.labels);
+    const redactedTraceContext = redactor.redactTraceContext(config.traceContext);
+    await withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const existing = await this.reconcileSessionManifest(sessionId);
+      if (existing === void 0) {
+        await ensureDirectory(this.sessionEventsDirectory(sessionId));
+        await ensureDirectory(this.sessionArtifactsDirectory(sessionId));
+        const session = {
+          sessionId,
+          profile: config.profile,
+          ...redactedLabels === void 0 ? {} : { labels: redactedLabels },
+          ...redactedTraceContext === void 0 ? {} : { traceContext: redactedTraceContext },
+          openedAt,
+          updatedAt: openedAt,
+          currentSequence: 0,
+          eventCount: 0,
+          artifactCount: 0
+        };
+        await writeJsonFileExclusive(this.sessionManifestPath(sessionId), session);
+        return;
+      }
+      const patched = {
+        ...existing,
+        profile: config.profile,
+        ...redactedLabels === void 0 ? {} : { labels: redactedLabels },
+        ...redactedTraceContext === void 0 ? {} : { traceContext: redactedTraceContext },
+        updatedAt: Math.max(existing.updatedAt, openedAt)
+      };
+      await writeJsonFileAtomic(this.sessionManifestPath(sessionId), patched);
+    });
+    return new FilesystemSessionSink(this, sessionId);
+  }
+  async getSession(sessionId) {
+    const manifestPath = this.sessionManifestPath(sessionId);
+    if (!await pathExists(manifestPath)) {
+      return void 0;
+    }
+    return readJsonFile(manifestPath);
+  }
+  async appendEvent(sessionId, input) {
+    const [event] = await this.appendEvents(sessionId, [input]);
+    if (event === void 0) {
+      throw new Error(`failed to append observation event for session ${sessionId}`);
+    }
+    return event;
+  }
+  async appendEvents(sessionId, input) {
+    if (input.length === 0) {
+      return [];
+    }
+    return withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const session = await this.reconcileSessionManifest(sessionId);
+      if (session === void 0) {
+        throw new Error(`observation session ${sessionId} was not found`);
+      }
+      const redactor = this.redactors.get(sessionId) ?? createObservationRedactor(void 0);
+      const events = [];
+      let sequence = session.currentSequence;
+      let updatedAt = session.updatedAt;
+      for (const raw of input) {
+        sequence += 1;
+        const createdAt = normalizeTimestamp("createdAt", raw.createdAt);
+        const context = normalizeObservationContext(raw.context);
+        const redactedData = raw.data === void 0 ? void 0 : redactor.redactJson(toCanonicalJsonValue(raw.data));
+        const redactedError = redactor.redactError(raw.error);
+        const event = {
+          eventId: normalizeNonEmptyString(
+            "eventId",
+            raw.eventId ?? `observation:${sessionId}:${String(sequence).padStart(12, "0")}`
+          ),
+          sessionId,
+          sequence,
+          kind: raw.kind,
+          phase: raw.phase,
+          createdAt,
+          correlationId: normalizeNonEmptyString("correlationId", raw.correlationId),
+          ...raw.spanId === void 0 ? {} : { spanId: normalizeNonEmptyString("spanId", raw.spanId) },
+          ...raw.parentSpanId === void 0 ? {} : { parentSpanId: normalizeNonEmptyString("parentSpanId", raw.parentSpanId) },
+          ...context === void 0 ? {} : { context },
+          ...redactedData === void 0 ? {} : { data: redactedData },
+          ...redactedError === void 0 ? {} : { error: redactedError },
+          ...raw.artifactIds === void 0 || raw.artifactIds.length === 0 ? {} : { artifactIds: [...raw.artifactIds] }
+        };
+        await writeJsonFileExclusive(
+          path7__default.default.join(this.sessionEventsDirectory(sessionId), eventFileName(sequence)),
+          event
+        );
+        updatedAt = Math.max(updatedAt, createdAt);
+        events.push(event);
+      }
+      await writeJsonFileAtomic(this.sessionManifestPath(sessionId), {
+        ...session,
+        currentSequence: sequence,
+        eventCount: session.eventCount + events.length,
+        updatedAt
+      });
+      return events;
+    });
+  }
+  async writeArtifact(sessionId, input) {
+    return withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const session = await this.reconcileSessionManifest(sessionId);
+      if (session === void 0) {
+        throw new Error(`observation session ${sessionId} was not found`);
+      }
+      const redactor = this.redactors.get(sessionId) ?? createObservationRedactor(void 0);
+      const createdAt = normalizeTimestamp("createdAt", input.createdAt);
+      const context = normalizeObservationContext(input.context);
+      const redactedStorageKey = input.storageKey === void 0 ? void 0 : redactor.redactText(input.storageKey);
+      const redactedMetadata = input.metadata === void 0 ? void 0 : redactor.redactJson(toCanonicalJsonValue(input.metadata));
+      const artifact = {
+        artifactId: normalizeNonEmptyString("artifactId", input.artifactId),
+        sessionId,
+        kind: input.kind,
+        createdAt,
+        ...context === void 0 ? {} : { context },
+        ...input.mediaType === void 0 ? {} : { mediaType: input.mediaType },
+        ...input.byteLength === void 0 ? {} : { byteLength: input.byteLength },
+        ...input.sha256 === void 0 ? {} : { sha256: input.sha256 },
+        ...input.opensteerArtifactId === void 0 ? {} : { opensteerArtifactId: input.opensteerArtifactId },
+        ...redactedStorageKey === void 0 ? {} : { storageKey: redactedStorageKey },
+        ...redactedMetadata === void 0 ? {} : { metadata: redactedMetadata }
+      };
+      const artifactPath = this.sessionArtifactPath(sessionId, artifact.artifactId);
+      if (!await pathExists(artifactPath)) {
+        await writeJsonFileExclusive(artifactPath, artifact);
+        await writeJsonFileAtomic(this.sessionManifestPath(sessionId), {
+          ...session,
+          artifactCount: session.artifactCount + 1,
+          updatedAt: Math.max(session.updatedAt, createdAt)
+        });
+      }
+      return artifact;
+    });
+  }
+  async listEvents(sessionId, input = {}) {
+    const directoryPath = this.sessionEventsDirectory(sessionId);
+    if (!await pathExists(directoryPath)) {
+      return [];
+    }
+    const files = await listJsonFiles(directoryPath);
+    const events = await Promise.all(
+      files.map((fileName) => readJsonFile(path7__default.default.join(directoryPath, fileName)))
+    );
+    const filtered = events.filter((event) => {
+      if (input.kind !== void 0 && event.kind !== input.kind) return false;
+      if (input.phase !== void 0 && event.phase !== input.phase) return false;
+      if (input.correlationId !== void 0 && event.correlationId !== input.correlationId) {
+        return false;
+      }
+      if (input.pageRef !== void 0 && event.context?.pageRef !== input.pageRef) return false;
+      if (input.afterSequence !== void 0 && event.sequence <= input.afterSequence) return false;
+      if (input.from !== void 0 && event.createdAt < input.from) return false;
+      if (input.to !== void 0 && event.createdAt > input.to) return false;
+      return true;
+    });
+    if (input.limit === void 0 || filtered.length <= input.limit) {
+      return filtered;
+    }
+    return filtered.slice(-input.limit);
+  }
+  async listArtifacts(sessionId, input = {}) {
+    const directoryPath = this.sessionArtifactsDirectory(sessionId);
+    if (!await pathExists(directoryPath)) {
+      return [];
+    }
+    const files = await listJsonFiles(directoryPath);
+    const artifacts = await Promise.all(
+      files.map(
+        (fileName) => readJsonFile(path7__default.default.join(directoryPath, fileName))
+      )
+    );
+    const filtered = artifacts.filter((artifact) => {
+      if (input.kind !== void 0 && artifact.kind !== input.kind) return false;
+      if (input.pageRef !== void 0 && artifact.context?.pageRef !== input.pageRef) return false;
+      return true;
+    });
+    if (input.limit === void 0 || filtered.length <= input.limit) {
+      return filtered;
+    }
+    return filtered.slice(-input.limit);
+  }
+  async getArtifact(sessionId, artifactId) {
+    const artifactPath = this.sessionArtifactPath(sessionId, artifactId);
+    if (!await pathExists(artifactPath)) {
+      return void 0;
+    }
+    return readJsonFile(artifactPath);
+  }
+  async closeSession(sessionId, _reason) {
+    await withFilesystemLock(this.sessionLockPath(sessionId), async () => {
+      const session = await this.reconcileSessionManifest(sessionId);
+      if (session === void 0 || session.closedAt !== void 0) {
+        return;
+      }
+      const now = Date.now();
+      await writeJsonFileAtomic(this.sessionManifestPath(sessionId), {
+        ...session,
+        updatedAt: Math.max(session.updatedAt, now),
+        closedAt: now
+      });
+    });
+    this.redactors.delete(sessionId);
+  }
+  async writeArtifactFromManifest(sessionId, manifest, kind, metadata) {
+    return this.writeArtifact(sessionId, {
+      artifactId: manifest.artifactId,
+      kind,
+      createdAt: manifest.createdAt,
+      context: manifest.scope,
+      mediaType: manifest.mediaType,
+      byteLength: manifest.byteLength,
+      sha256: manifest.sha256,
+      opensteerArtifactId: manifest.artifactId,
+      storageKey: manifestToExternalBinaryLocation(this.rootPath, manifest).uri,
+      ...metadata === void 0 ? {} : { metadata }
+    });
+  }
+  async ensureArtifactLinked(sessionId, manifest) {
+    const existing = await this.getArtifact(sessionId, manifest.artifactId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const kind = toObservationArtifactKind(manifest.kind);
+    return this.writeArtifactFromManifest(sessionId, manifest, kind);
+  }
+  async hydrateArtifactManifests(artifactIds) {
+    return (await Promise.all(
+      artifactIds.map(async (artifactId) => this.artifacts.getManifest(artifactId))
+    )).filter((value) => value !== void 0);
+  }
+  sessionDirectory(sessionId) {
+    return path7__default.default.join(this.sessionsDirectory, encodePathSegment(sessionId));
+  }
+  sessionManifestPath(sessionId) {
+    return path7__default.default.join(this.sessionDirectory(sessionId), "session.json");
+  }
+  sessionEventsDirectory(sessionId) {
+    return path7__default.default.join(this.sessionDirectory(sessionId), "events");
+  }
+  sessionArtifactsDirectory(sessionId) {
+    return path7__default.default.join(this.sessionDirectory(sessionId), "artifacts");
+  }
+  sessionArtifactPath(sessionId, artifactId) {
+    return path7__default.default.join(
+      this.sessionArtifactsDirectory(sessionId),
+      `${encodePathSegment(artifactId)}.json`
+    );
+  }
+  sessionLockPath(sessionId) {
+    return path7__default.default.join(this.sessionDirectory(sessionId), ".lock");
+  }
+  async reconcileSessionManifest(sessionId) {
+    const session = await this.getSession(sessionId);
+    if (session === void 0) {
+      return void 0;
+    }
+    const [hasEventDirectory, hasArtifactDirectory] = await Promise.all([
+      pathExists(this.sessionEventsDirectory(sessionId)),
+      pathExists(this.sessionArtifactsDirectory(sessionId))
+    ]);
+    const [eventFiles, artifactFiles] = await Promise.all([
+      hasEventDirectory ? listJsonFiles(this.sessionEventsDirectory(sessionId)) : Promise.resolve([]),
+      hasArtifactDirectory ? listJsonFiles(this.sessionArtifactsDirectory(sessionId)) : Promise.resolve([])
+    ]);
+    const currentSequence = eventFiles.reduce((maxSequence, fileName) => {
+      const parsed = Number.parseInt(fileName.replace(/\.json$/u, ""), 10);
+      return Number.isFinite(parsed) ? Math.max(maxSequence, parsed) : maxSequence;
+    }, 0);
+    const eventCount = eventFiles.length;
+    const artifactCount = artifactFiles.length;
+    if (session.currentSequence === currentSequence && session.eventCount === eventCount && session.artifactCount === artifactCount) {
+      return session;
+    }
+    const [events, artifacts] = await Promise.all([
+      Promise.all(
+        eventFiles.map(
+          (fileName) => readJsonFile(
+            path7__default.default.join(this.sessionEventsDirectory(sessionId), fileName)
+          )
+        )
+      ),
+      Promise.all(
+        artifactFiles.map(
+          (fileName) => readJsonFile(
+            path7__default.default.join(this.sessionArtifactsDirectory(sessionId), fileName)
+          )
+        )
+      )
+    ]);
+    const updatedAt = Math.max(
+      session.openedAt,
+      session.closedAt ?? 0,
+      ...events.map((event) => event.createdAt),
+      ...artifacts.map((artifact) => artifact.createdAt)
+    );
+    const reconciled = {
+      ...session,
+      currentSequence,
+      eventCount,
+      artifactCount,
+      updatedAt
+    };
+    await writeJsonFileAtomic(this.sessionManifestPath(sessionId), reconciled);
+    return reconciled;
+  }
+};
+function toObservationArtifactKind(kind) {
+  switch (kind) {
+    case "screenshot":
+      return "screenshot";
+    case "dom-snapshot":
+      return "dom-snapshot";
+    case "html-snapshot":
+      return "html-snapshot";
+    default:
+      return "other";
+  }
+}
+function createObservationStore(rootPath, artifacts) {
+  return new FilesystemObservationStoreImpl(rootPath, artifacts);
+}
 function normalizeContext(context) {
   return {
     ...context?.sessionRef === void 0 ? {} : { sessionRef: context.sessionRef },
@@ -8179,7 +8725,7 @@ var FilesystemTraceStore = class {
   constructor(rootPath, artifacts) {
     this.rootPath = rootPath;
     this.artifacts = artifacts;
-    this.runsDirectory = path6__default.default.join(this.rootPath, "traces", "runs");
+    this.runsDirectory = path7__default.default.join(this.rootPath, "traces", "runs");
   }
   runsDirectory;
   async initialize() {
@@ -8256,7 +8802,7 @@ var FilesystemTraceStore = class {
         ...input.error === void 0 ? {} : { error: input.error }
       };
       await writeJsonFileExclusive(
-        path6__default.default.join(this.runEntriesDirectory(runId), sequenceFileName(sequence)),
+        path7__default.default.join(this.runEntriesDirectory(runId), sequenceFileName(sequence)),
         entry
       );
       await writeJsonFileAtomic(this.runManifestPath(runId), {
@@ -8275,7 +8821,7 @@ var FilesystemTraceStore = class {
     const files = await listJsonFiles(entriesDirectory);
     return Promise.all(
       files.map(
-        (fileName) => readJsonFile(path6__default.default.join(entriesDirectory, fileName))
+        (fileName) => readJsonFile(path7__default.default.join(entriesDirectory, fileName))
       )
     );
   }
@@ -8321,16 +8867,16 @@ var FilesystemTraceStore = class {
     return { trace, artifacts };
   }
   runDirectory(runId) {
-    return path6__default.default.join(this.runsDirectory, encodeURIComponent(runId));
+    return path7__default.default.join(this.runsDirectory, encodeURIComponent(runId));
   }
   runEntriesDirectory(runId) {
-    return path6__default.default.join(this.runDirectory(runId), "entries");
+    return path7__default.default.join(this.runDirectory(runId), "entries");
   }
   runManifestPath(runId) {
-    return path6__default.default.join(this.runDirectory(runId), "manifest.json");
+    return path7__default.default.join(this.runDirectory(runId), "manifest.json");
   }
   runWriteLockPath(runId) {
-    return path6__default.default.join(this.runDirectory(runId), ".append.lock");
+    return path7__default.default.join(this.runDirectory(runId), ".append.lock");
   }
 };
 function createTraceStore(rootPath, artifacts) {
@@ -8344,7 +8890,7 @@ function normalizeWorkspaceId(workspace) {
   return encodePathSegment(workspace);
 }
 function resolveFilesystemWorkspacePath(input) {
-  return path6__default.default.join(
+  return path7__default.default.join(
     input.rootDir,
     ".opensteer",
     "workspaces",
@@ -8353,17 +8899,18 @@ function resolveFilesystemWorkspacePath(input) {
 }
 async function createFilesystemOpensteerWorkspace(options) {
   await ensureDirectory(options.rootPath);
-  const manifestPath = path6__default.default.join(options.rootPath, "workspace.json");
-  const browserPath = path6__default.default.join(options.rootPath, "browser");
-  const browserManifestPath = path6__default.default.join(browserPath, "manifest.json");
-  const browserUserDataDir = path6__default.default.join(browserPath, "user-data");
-  const livePath = path6__default.default.join(options.rootPath, "live");
-  const liveLocalPath = path6__default.default.join(livePath, "local.json");
-  const liveCloudPath = path6__default.default.join(livePath, "cloud.json");
-  const artifactsPath = path6__default.default.join(options.rootPath, "artifacts");
-  const tracesPath = path6__default.default.join(options.rootPath, "traces");
-  const registryPath = path6__default.default.join(options.rootPath, "registry");
-  const lockPath = path6__default.default.join(options.rootPath, ".lock");
+  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");
   let manifest;
   if (await pathExists(manifestPath)) {
     manifest = await readJsonFile(manifestPath);
@@ -8377,6 +8924,17 @@ async function createFilesystemOpensteerWorkspace(options) {
         `workspace ${options.rootPath} uses unsupported version ${String(manifest.version)}`
       );
     }
+    if (manifest.paths.observations === void 0) {
+      manifest = {
+        ...manifest,
+        updatedAt: Date.now(),
+        paths: {
+          ...manifest.paths,
+          observations: "observations"
+        }
+      };
+      await writeJsonFileAtomic(manifestPath, manifest);
+    }
   } else {
     const createdAt = normalizeTimestamp("createdAt", options.createdAt ?? Date.now());
     manifest = {
@@ -8391,6 +8949,7 @@ async function createFilesystemOpensteerWorkspace(options) {
         live: "live",
         artifacts: "artifacts",
         traces: "traces",
+        observations: "observations",
         registry: "registry"
       }
     };
@@ -8402,6 +8961,7 @@ async function createFilesystemOpensteerWorkspace(options) {
     ensureDirectory(livePath),
     ensureDirectory(artifactsPath),
     ensureDirectory(tracesPath),
+    ensureDirectory(observationsPath),
     ensureDirectory(registryPath)
   ]);
   const artifacts = createArtifactStore(options.rootPath);
@@ -8426,6 +8986,8 @@ async function createFilesystemOpensteerWorkspace(options) {
   await reverseReports.initialize();
   const traces = createTraceStore(options.rootPath, artifacts);
   await traces.initialize();
+  const observations = createObservationStore(options.rootPath, artifacts);
+  await observations.initialize();
   return {
     rootPath: options.rootPath,
     manifestPath,
@@ -8438,10 +9000,12 @@ async function createFilesystemOpensteerWorkspace(options) {
     liveCloudPath,
     artifactsPath,
     tracesPath,
+    observationsPath,
     registryPath,
     lockPath,
     artifacts,
     traces,
+    observations,
     registry: {
       descriptors,
       requestPlans,
@@ -8628,10 +9192,10 @@ function delayWithSignal(delayMs, signal) {
   if (signal.aborted) {
     return Promise.reject(signal.reason ?? abortError());
   }
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve4, reject) => {
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve5();
+      resolve4();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -9096,9 +9660,9 @@ var IFRAME_URL_ATTRIBUTES = /* @__PURE__ */ new Set([
   "poster",
   "ping"
 ]);
-function buildArrayFieldPathCandidates(path13) {
-  const strict = path13.nodes.length ? buildPathCandidates(path13.nodes) : [];
-  const relaxedNodes = stripPositionClauses(path13.nodes);
+function buildArrayFieldPathCandidates(path15) {
+  const strict = path15.nodes.length ? buildPathCandidates(path15.nodes) : [];
+  const relaxedNodes = stripPositionClauses(path15.nodes);
   const relaxed = relaxedNodes.length ? buildPathCandidates(relaxedNodes) : [];
   return dedupeSelectors([...strict, ...relaxed]);
 }
@@ -9628,18 +10192,18 @@ function cloneStructuralElementAnchor(anchor) {
     nodes: anchor.nodes.map(clonePathNode)
   };
 }
-function cloneReplayElementPath(path13) {
+function cloneReplayElementPath(path15) {
   return {
     resolution: "deterministic",
-    context: cloneContext(path13.context),
-    nodes: path13.nodes.map(clonePathNode)
+    context: cloneContext(path15.context),
+    nodes: path15.nodes.map(clonePathNode)
   };
 }
-function cloneElementPath(path13) {
-  return cloneReplayElementPath(path13);
+function cloneElementPath(path15) {
+  return cloneReplayElementPath(path15);
 }
-function buildPathSelectorHint(path13) {
-  const nodes = path13?.nodes || [];
+function buildPathSelectorHint(path15) {
+  const nodes = path15?.nodes || [];
   const last = nodes[nodes.length - 1];
   if (!last) {
     return "*";
@@ -9688,15 +10252,15 @@ function sanitizeStructuralElementAnchor(anchor) {
     nodes: sanitizeNodes(anchor.nodes)
   };
 }
-function sanitizeReplayElementPath(path13) {
+function sanitizeReplayElementPath(path15) {
   return {
     resolution: "deterministic",
-    context: sanitizeContext(path13.context),
-    nodes: sanitizeNodes(path13.nodes)
+    context: sanitizeContext(path15.context),
+    nodes: sanitizeNodes(path15.nodes)
   };
 }
-function sanitizeElementPath(path13) {
-  return sanitizeReplayElementPath(path13);
+function sanitizeElementPath(path15) {
+  return sanitizeReplayElementPath(path15);
 }
 function buildLocalStructuralElementAnchor(index, rawTargetNode) {
   const targetNode = requireElementNode(index, rawTargetNode);
@@ -9819,8 +10383,8 @@ function buildTargetNotFoundMessage(domPath, diagnostics) {
   }
   return `${base} Target depth ${String(depth)}. Candidate counts: ${sample}.`;
 }
-function buildArrayFieldCandidates(path13) {
-  return buildArrayFieldPathCandidates(path13);
+function buildArrayFieldCandidates(path15) {
+  return buildArrayFieldPathCandidates(path15);
 }
 function firstDefinedAttribute(node, keys) {
   for (const key of keys) {
@@ -10329,14 +10893,16 @@ var DomActionExecutor = class {
         ...input.timeout === void 0 ? {} : { timeout: input.timeout }
       },
       async (pointerTarget, point, timeout) => {
-        await timeout.runStep(
+        const events = [];
+        const moved = await timeout.runStep(
           () => this.options.engine.mouseMove({
             pageRef: pointerTarget.resolved.pageRef,
             point,
             coordinateSpace: "document-css"
           })
         );
-        await timeout.runStep(
+        events.push(...moved.events);
+        const clicked = await timeout.runStep(
           () => this.options.engine.mouseClick({
             pageRef: pointerTarget.resolved.pageRef,
             point,
@@ -10346,7 +10912,12 @@ var DomActionExecutor = class {
             ...input.modifiers === void 0 ? {} : { modifiers: input.modifiers }
           })
         );
-        return { resolved: pointerTarget.original, point };
+        events.push(...clicked.events);
+        return {
+          resolved: pointerTarget.original,
+          point,
+          ...events.length === 0 ? {} : { events }
+        };
       }
     );
   }
@@ -10360,14 +10931,18 @@ var DomActionExecutor = class {
         ...input.timeout === void 0 ? {} : { timeout: input.timeout }
       },
       async (pointerTarget, point, timeout) => {
-        await timeout.runStep(
+        const moved = await timeout.runStep(
           () => this.options.engine.mouseMove({
             pageRef: pointerTarget.resolved.pageRef,
             point,
             coordinateSpace: "document-css"
           })
         );
-        return { resolved: pointerTarget.original, point };
+        return {
+          resolved: pointerTarget.original,
+          point,
+          ...moved.events.length === 0 ? {} : { events: moved.events }
+        };
       }
     );
   }
@@ -10381,14 +10956,16 @@ var DomActionExecutor = class {
         ...input.timeout === void 0 ? {} : { timeout: input.timeout }
       },
       async (pointerTarget, point, timeout) => {
-        await timeout.runStep(
+        const events = [];
+        const moved = await timeout.runStep(
           () => this.options.engine.mouseMove({
             pageRef: pointerTarget.resolved.pageRef,
             point,
             coordinateSpace: "document-css"
           })
         );
-        await timeout.runStep(
+        events.push(...moved.events);
+        const scrolled = await timeout.runStep(
           () => this.options.engine.mouseScroll({
             pageRef: pointerTarget.resolved.pageRef,
             point,
@@ -10396,7 +10973,12 @@ var DomActionExecutor = class {
             delta: input.delta
           })
         );
-        return { resolved: pointerTarget.original, point };
+        events.push(...scrolled.events);
+        return {
+          resolved: pointerTarget.original,
+          point,
+          ...events.length === 0 ? {} : { events }
+        };
       }
     );
   }
@@ -11322,21 +11904,21 @@ var DefaultDomRuntime = class {
     return match;
   }
   async resolvePathTarget(session, pageRef, rawPath, source, description, descriptor) {
-    const path13 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path13.context);
-    const target = resolveDomPathInScope(context.index, path13.nodes, context.scope);
+    const path15 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path15.context);
+    const target = resolveDomPathInScope(context.index, path15.nodes, context.scope);
     if (!target) {
-      throwTargetNotFound(context.index, path13.nodes, context.scope);
+      throwTargetNotFound(context.index, path15.nodes, context.scope);
     }
     if (target.node.nodeRef === void 0) {
       throw new Error(
-        `resolved path "${buildPathSelectorHint(path13)}" does not point to a live element`
+        `resolved path "${buildPathSelectorHint(path15)}" does not point to a live element`
       );
     }
     const anchor = await this.buildAnchorFromSnapshotNode(session, context.snapshot, target.node);
     return this.createResolvedTarget(source, context.snapshot, target.node, anchor, {
       ...description === void 0 ? {} : { description },
-      replayPath: path13,
+      replayPath: path15,
       ...source === "path" || source === "descriptor" ? { selectorUsed: target.selector } : {},
       ...descriptor === void 0 ? {} : { descriptor }
     });
@@ -11357,9 +11939,9 @@ var DefaultDomRuntime = class {
     });
   }
   async queryAllByElementPath(session, pageRef, rawPath) {
-    const path13 = sanitizeReplayElementPath(rawPath);
-    const context = await this.resolvePathContext(session, pageRef, path13.context);
-    return queryAllDomPathInScope(context.index, path13.nodes, context.scope).filter(
+    const path15 = sanitizeReplayElementPath(rawPath);
+    const context = await this.resolvePathContext(session, pageRef, path15.context);
+    return queryAllDomPathInScope(context.index, path15.nodes, context.scope).filter(
       (node) => node.nodeRef !== void 0
     ).map((node) => this.createSnapshotTarget(context.snapshot, node));
   }
@@ -11545,16 +12127,16 @@ var DefaultDomRuntime = class {
     const index = createSnapshotIndex(item.snapshot);
     return this.resolveFirstArrayFieldTargetInNode(index, item.node, field.path);
   }
-  resolveFirstArrayFieldTargetInNode(index, rootNode, path13) {
-    const normalizedPath = sanitizeElementPath(path13);
+  resolveFirstArrayFieldTargetInNode(index, rootNode, path15) {
+    const normalizedPath = sanitizeElementPath(path15);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
     }
     return resolveFirstWithinNodeBySelectors(index, rootNode, selectors);
   }
-  resolveUniqueArrayFieldTargetInNode(index, rootNode, path13) {
-    const normalizedPath = sanitizeElementPath(path13);
+  resolveUniqueArrayFieldTargetInNode(index, rootNode, path15) {
+    const normalizedPath = sanitizeElementPath(path15);
     const selectors = buildArrayFieldCandidates(normalizedPath);
     if (!selectors.length) {
       return rootNode;
@@ -11643,8 +12225,8 @@ function encodeDataPath(tokens) {
   }
   return out;
 }
-function parseDataPath(path13) {
-  const input = path13.trim();
+function parseDataPath(path15) {
+  const input = path15.trim();
   if (input.length === 0) {
     return [];
   }
@@ -11694,8 +12276,8 @@ function parseDataPath(path13) {
 function inflateDataPathObject(flat) {
   let root = {};
   let initialized = false;
-  for (const [path13, value] of Object.entries(flat)) {
-    const tokens = parseDataPath(path13);
+  for (const [path15, value] of Object.entries(flat)) {
+    const tokens = parseDataPath(path15);
     if (!tokens || tokens.length === 0) {
       continue;
     }
@@ -12027,8 +12609,8 @@ function buildVariantDescriptorFromCluster(descriptors) {
     fields: mergedFields
   };
 }
-function minimizePathMatchClauses(path13, mode) {
-  const normalized = sanitizeElementPath(path13);
+function minimizePathMatchClauses(path15, mode) {
+  const normalized = sanitizeElementPath(path15);
   const nodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = node.attrs || {};
@@ -12132,8 +12714,8 @@ function seedMinimalAttrClause(attrs) {
   }
   return null;
 }
-function relaxPathForSingleSample(path13, mode) {
-  const normalized = sanitizeElementPath(path13);
+function relaxPathForSingleSample(path15, mode) {
+  const normalized = sanitizeElementPath(path15);
   const relaxedNodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = normalizeAttrsForSingleSample(node.attrs || {});
@@ -12218,8 +12800,8 @@ function shouldKeepAttrForSingleSample(key) {
   }
   return true;
 }
-function buildPathStructureKey(path13) {
-  const normalized = sanitizeElementPath(path13);
+function buildPathStructureKey(path15) {
+  const normalized = sanitizeElementPath(path15);
   return canonicalJsonString({
     context: (normalized.context || []).map((hop) => ({
       kind: hop.kind,
@@ -12346,30 +12928,30 @@ function buildArrayItemNode(fields) {
   }
   return node;
 }
-function insertNodeAtPath(root, path13, node) {
-  const tokens = parseDataPath(path13);
+function insertNodeAtPath(root, path15, node) {
+  const tokens = parseDataPath(path15);
   if (!tokens || !tokens.length) {
     throw new Error(
-      `Invalid persisted extraction path "${path13}": expected a non-empty object path.`
+      `Invalid persisted extraction path "${path15}": expected a non-empty object path.`
     );
   }
   if (tokens.some((token) => token.kind === "index")) {
     throw new Error(
-      `Invalid persisted extraction path "${path13}": nested array indices are not supported in cached descriptors.`
+      `Invalid persisted extraction path "${path15}": 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 "${path13}": expected object segment.`);
+      throw new Error(`Invalid persisted extraction path "${path15}": 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 "${path13}" detected while building descriptor tree.`
+          `Conflicting persisted extraction path "${path15}" detected while building descriptor tree.`
         );
       }
       current[token.key] = node;
@@ -12384,7 +12966,7 @@ function insertNodeAtPath(root, path13, node) {
     }
     if (!isPersistedObjectNode(next)) {
       throw new Error(
-        `Conflicting persisted extraction path "${path13}" detected at "${token.key}".`
+        `Conflicting persisted extraction path "${path15}" detected at "${token.key}".`
       );
     }
     current = next;
@@ -12419,7 +13001,7 @@ function buildItemRootForArrayIndex(entries) {
   }
   const paths = entries.map(
     (entry) => isPersistablePathField(entry.source) ? sanitizeElementPath(entry.source.path) : null
-  ).filter((path13) => path13 !== null);
+  ).filter((path15) => path15 !== null);
   if (!paths.length) {
     return null;
   }
@@ -12440,7 +13022,7 @@ function getCommonPathPrefixLength(paths) {
   if (!paths.length) {
     return 0;
   }
-  const nodeChains = paths.map((path13) => path13.nodes);
+  const nodeChains = paths.map((path15) => path15.nodes);
   const minLength = Math.min(...nodeChains.map((nodes) => nodes.length));
   if (!Number.isFinite(minLength) || minLength <= 0) {
     return 0;
@@ -12509,30 +13091,30 @@ function mergeElementPathsByMajority(paths) {
   if (!paths.length) {
     return null;
   }
-  const normalized = paths.map((path13) => sanitizeElementPath(path13));
+  const normalized = paths.map((path15) => sanitizeElementPath(path15));
   const contextKey = pickModeString(
-    normalized.map((path13) => canonicalJsonString(path13.context)),
+    normalized.map((path15) => canonicalJsonString(path15.context)),
     1
   );
   if (!contextKey) {
     return null;
   }
-  const sameContext = normalized.filter((path13) => canonicalJsonString(path13.context) === contextKey);
+  const sameContext = normalized.filter((path15) => canonicalJsonString(path15.context) === contextKey);
   if (!sameContext.length) {
     return null;
   }
   const targetLength = pickModeNumber(
-    sameContext.map((path13) => path13.nodes.length),
+    sameContext.map((path15) => path15.nodes.length),
     1
   ) ?? sameContext[0]?.nodes.length ?? 0;
-  const aligned = sameContext.filter((path13) => path13.nodes.length === targetLength);
+  const aligned = sameContext.filter((path15) => path15.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((path13) => path13.nodes[index]).filter((node) => node !== void 0);
+    const nodesAtIndex = aligned.map((path15) => path15.nodes[index]).filter((node) => node !== void 0);
     if (!nodesAtIndex.length) {
       return null;
     }
@@ -12778,8 +13360,8 @@ function clonePathContext(context) {
 function clonePathNodes(nodes) {
   return JSON.parse(JSON.stringify(nodes || []));
 }
-function cloneElementPath2(path13) {
-  return JSON.parse(JSON.stringify(path13));
+function cloneElementPath2(path15) {
+  return JSON.parse(JSON.stringify(path15));
 }
 function clonePersistedOpensteerExtractionNode(node) {
   return JSON.parse(JSON.stringify(node));
@@ -13097,8 +13679,8 @@ function collectPersistedValueNodeRefs(node) {
     return [
       {
         path: sanitizeElementPath(node.$path),
-        replacePath: (path13) => {
-          node.$path = sanitizeElementPath(path13);
+        replacePath: (path15) => {
+          node.$path = sanitizeElementPath(path15);
         }
       }
     ];
@@ -13112,13 +13694,13 @@ function collectPersistedValueNodeRefs(node) {
   }
   return refs;
 }
-function hasPositionClause(path13) {
-  return path13.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
+function hasPositionClause(path15) {
+  return path15.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
 }
-function stripPositionClauses2(path13) {
+function stripPositionClauses2(path15) {
   return sanitizeElementPath({
-    context: path13.context,
-    nodes: path13.nodes.map((node) => ({
+    context: path15.context,
+    nodes: path15.nodes.map((node) => ({
       ...node,
       match: node.match.filter((clause) => clause.kind !== "position")
     }))
@@ -13528,8 +14110,8 @@ function normalizeNonEmptyString2(name, value) {
 function normalizeKey(value) {
   return String(value ?? "").trim();
 }
-function labelForPath(path13) {
-  return path13.trim().length === 0 ? "$" : path13;
+function labelForPath(path15) {
+  return path15.trim().length === 0 ? "$" : path15;
 }
 function sha256Hex3(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
@@ -13558,7 +14140,7 @@ var CHROME_SINGLETON_ARTIFACTS = [
 async function clearChromeSingletonEntries(userDataDir) {
   await Promise.all(
     CHROME_SINGLETON_ARTIFACTS.map(
-      (entry) => promises.rm(path6.join(userDataDir, entry), {
+      (entry) => promises.rm(path7.join(userDataDir, entry), {
         recursive: true,
         force: true
       }).catch(() => void 0)
@@ -13573,7 +14155,7 @@ async function sanitizeChromeProfile(userDataDir) {
   await Promise.all(profileDirs.map((dir) => sanitizeProfilePreferences(userDataDir, dir)));
 }
 async function sanitizeProfilePreferences(userDataDir, profileDir) {
-  const prefsPath = path6.join(userDataDir, profileDir, "Preferences");
+  const prefsPath = path7.join(userDataDir, profileDir, "Preferences");
   try {
     const raw = await promises.readFile(prefsPath, "utf8");
     const prefs = JSON.parse(raw);
@@ -13585,14 +14167,13 @@ async function sanitizeProfilePreferences(userDataDir, profileDir) {
     profile.exited_cleanly = true;
     prefs.profile = profile;
     await promises.writeFile(prefsPath, JSON.stringify(prefs), "utf8");
-    await promises.rm(path6.join(userDataDir, profileDir, "Secure Preferences"), { force: true }).catch(
+    await promises.rm(path7.join(userDataDir, profileDir, "Secure Preferences"), { force: true }).catch(
       () => void 0
     );
   } catch {
   }
 }
-var PROCESS_LIST_MAX_BUFFER_BYTES2 = 16 * 1024 * 1024;
-var PS_COMMAND_ENV2 = { ...process.env, LC_ALL: "C" };
+({ ...process.env});
 var WINDOWS_PROGRAM_FILES = process.env.PROGRAMFILES ?? "C:\\Program Files";
 var WINDOWS_PROGRAM_FILES_X86 = process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)";
 var BROWSER_BRANDS = [
@@ -13607,9 +14188,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path6.join(WINDOWS_PROGRAM_FILES, "Google", "Chrome", "Application", "chrome.exe"),
-        path6.join(WINDOWS_PROGRAM_FILES_X86, "Google", "Chrome", "Application", "chrome.exe"),
-        path6.join("~", "AppData", "Local", "Google", "Chrome", "Application", "chrome.exe")
+        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")
       ],
       userDataDir: "~/AppData/Local/Google/Chrome/User Data",
       processNames: ["/google/chrome/application/chrome.exe"]
@@ -13639,7 +14220,7 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path6.join("~", "AppData", "Local", "Google", "Chrome SxS", "Application", "chrome.exe")
+        path7.join("~", "AppData", "Local", "Google", "Chrome SxS", "Application", "chrome.exe")
       ],
       userDataDir: "~/AppData/Local/Google/Chrome SxS/User Data",
       processNames: ["/google/chrome sxs/application/chrome.exe"]
@@ -13656,9 +14237,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path6.join(WINDOWS_PROGRAM_FILES, "Chromium", "Application", "chrome.exe"),
-        path6.join(WINDOWS_PROGRAM_FILES_X86, "Chromium", "Application", "chrome.exe"),
-        path6.join("~", "AppData", "Local", "Chromium", "Application", "chrome.exe")
+        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")
       ],
       userDataDir: "~/AppData/Local/Chromium/User Data",
       processNames: ["/chromium/application/chrome.exe"]
@@ -13685,15 +14266,15 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path6.join(WINDOWS_PROGRAM_FILES, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
-        path6.join(
+        path7.join(WINDOWS_PROGRAM_FILES, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+        path7.join(
           WINDOWS_PROGRAM_FILES_X86,
           "BraveSoftware",
           "Brave-Browser",
           "Application",
           "brave.exe"
         ),
-        path6.join("~", "AppData", "Local", "BraveSoftware", "Brave-Browser", "Application", "brave.exe")
+        path7.join("~", "AppData", "Local", "BraveSoftware", "Brave-Browser", "Application", "brave.exe")
       ],
       userDataDir: "~/AppData/Local/BraveSoftware/Brave-Browser/User Data",
       processNames: ["/bravesoftware/brave-browser/application/brave.exe"]
@@ -13719,9 +14300,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path6.join(WINDOWS_PROGRAM_FILES, "Microsoft", "Edge", "Application", "msedge.exe"),
-        path6.join(WINDOWS_PROGRAM_FILES_X86, "Microsoft", "Edge", "Application", "msedge.exe"),
-        path6.join("~", "AppData", "Local", "Microsoft", "Edge", "Application", "msedge.exe")
+        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")
       ],
       userDataDir: "~/AppData/Local/Microsoft/Edge/User Data",
       processNames: ["/microsoft/edge/application/msedge.exe"]
@@ -13749,9 +14330,9 @@ var BROWSER_BRANDS = [
     },
     win32: {
       executableCandidates: [
-        path6.join(WINDOWS_PROGRAM_FILES, "Vivaldi", "Application", "vivaldi.exe"),
-        path6.join(WINDOWS_PROGRAM_FILES_X86, "Vivaldi", "Application", "vivaldi.exe"),
-        path6.join("~", "AppData", "Local", "Vivaldi", "Application", "vivaldi.exe")
+        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")
       ],
       userDataDir: "~/AppData/Local/Vivaldi/User Data",
       processNames: ["/vivaldi/application/vivaldi.exe"]
@@ -13778,9 +14359,6 @@ var BROWSER_BRANDS = [
     }
   }
 ];
-function getAllBrowserBrands() {
-  return BROWSER_BRANDS;
-}
 function getBrowserBrand(id) {
   const brand2 = BROWSER_BRANDS.find((candidate) => candidate.id === id);
   if (!brand2) {
@@ -13818,177 +14396,35 @@ function detectInstalledBrowserBrands() {
       brandId: brand2.id,
       displayName: brand2.displayName,
       executablePath,
-      userDataDir: path6.resolve(expandHome(platformConfig.userDataDir))
+      userDataDir: path7.resolve(expandHome(platformConfig.userDataDir))
     });
   }
   return installations;
 }
-function resolveBrandExecutablePath(brand2, explicitPath) {
-  if (explicitPath !== void 0) {
-    const resolvedPath2 = path6.resolve(expandHome(explicitPath));
-    if (!fs.existsSync(resolvedPath2)) {
-      throw new Error(`${brand2.displayName} executable was not found at "${resolvedPath2}".`);
-    }
-    return resolvedPath2;
-  }
-  const platformConfig = resolveBrandPlatformConfig(brand2);
-  if (!platformConfig) {
-    throw new Error(`${brand2.displayName} is not supported on ${process.platform}.`);
-  }
-  const resolvedPath = firstExistingPath(
-    resolveExecutableCandidates(platformConfig.executableCandidates)
-  );
-  if (!resolvedPath) {
-    throw new Error(
-      `Could not find a ${brand2.displayName} executable. Pass --executable-path or browser.executablePath.`
-    );
-  }
-  return resolvedPath;
-}
 function resolveBrandUserDataDir(brand2, explicitDir) {
   if (explicitDir !== void 0) {
-    return path6.resolve(expandHome(explicitDir));
+    return path7.resolve(expandHome(explicitDir));
   }
   const platformConfig = resolveBrandPlatformConfig(brand2);
   if (!platformConfig) {
     throw new Error(`${brand2.displayName} is not supported on ${process.platform}.`);
   }
-  return path6.resolve(expandHome(platformConfig.userDataDir));
-}
-function isBrandProcess(brand2, commandLine) {
-  const normalizedCommand = normalizeCommand(commandLine);
-  if (!normalizedCommand) {
-    return false;
-  }
-  if (normalizedCommand.includes("crashpad_handler")) {
-    return false;
-  }
-  if (/\s--type=/.test(normalizedCommand)) {
-    return false;
-  }
-  return getBrandProcessMarkers(brand2).some((marker) => normalizedCommand.includes(marker));
-}
-function findBrandProcess(brand2) {
-  for (const processEntry of listProcesses()) {
-    if (isBrandProcess(brand2, processEntry.commandLine)) {
-      return { pid: processEntry.pid };
-    }
-  }
-  return null;
-}
-function getBrandProcessMarkers(brand2) {
-  const markers = /* @__PURE__ */ new Set();
-  for (const config of [brand2.darwin, brand2.win32, brand2.linux]) {
-    if (!config) {
-      continue;
-    }
-    for (const processName of config.processNames) {
-      const normalized = normalizeCommand(processName);
-      if (normalized) {
-        markers.add(normalized);
-      }
-    }
-    for (const candidate of config.executableCandidates) {
-      if (!candidate) {
-        continue;
-      }
-      const normalized = normalizeCommand(path6.resolve(expandHome(candidate)));
-      if (normalized) {
-        markers.add(normalized);
-      }
-    }
-  }
-  return [...markers];
+  return path7.resolve(expandHome(platformConfig.userDataDir));
 }
 function resolveExecutableCandidates(candidates) {
-  return candidates.map((candidate) => candidate ? path6.resolve(expandHome(candidate)) : null);
-}
-function listProcesses() {
-  if (process.platform === "win32") {
-    return listWindowsProcesses();
-  }
-  return listUnixProcesses();
-}
-function listUnixProcesses() {
-  try {
-    const output = child_process.execFileSync("ps", ["-A", "-o", "pid=,command="], {
-      encoding: "utf8",
-      env: PS_COMMAND_ENV2,
-      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES2,
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    return output.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
-      const match = /^(\d+)\s+(.*)$/.exec(line);
-      if (!match) {
-        return null;
-      }
-      const pid = Number.parseInt(match[1] ?? "", 10);
-      const commandLine = match[2]?.trim() ?? "";
-      if (!Number.isInteger(pid) || pid <= 0 || commandLine.length === 0) {
-        return null;
-      }
-      return {
-        pid,
-        commandLine
-      };
-    }).filter(
-      (entry) => entry !== null
-    ).sort((left, right) => left.pid - right.pid);
-  } catch {
-    return [];
-  }
-}
-function listWindowsProcesses() {
-  try {
-    const output = child_process.execFileSync(
-      "powershell.exe",
-      [
-        "-NoProfile",
-        "-Command",
-        "Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress"
-      ],
-      {
-        encoding: "utf8",
-        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES2,
-        stdio: ["ignore", "pipe", "ignore"]
-      }
-    ).trim();
-    if (!output) {
-      return [];
-    }
-    const parsed = JSON.parse(output);
-    const records = Array.isArray(parsed) ? parsed : [parsed];
-    return records.map((record) => {
-      const pid = Number(record.ProcessId);
-      const commandLine = typeof record.CommandLine === "string" ? record.CommandLine.trim() : "";
-      if (!Number.isInteger(pid) || pid <= 0 || commandLine.length === 0) {
-        return null;
-      }
-      return {
-        pid,
-        commandLine
-      };
-    }).filter(
-      (entry) => entry !== null
-    ).sort((left, right) => left.pid - right.pid);
-  } catch {
-    return [];
-  }
-}
-function normalizeCommand(value) {
-  return value.trim().replaceAll("\\", "/").toLowerCase();
+  return candidates.map((candidate) => candidate ? path7.resolve(expandHome(candidate)) : null);
 }
 
 // src/local-browser/chrome-discovery.ts
 function expandHome(value) {
   if (value === "~" || value.startsWith("~/")) {
-    return path6.join(os.homedir(), value.slice(1));
+    return path7.join(os.homedir(), value.slice(1));
   }
   return value;
 }
 function resolveChromeUserDataDir(userDataDir) {
   const installation = detectLocalChromeInstallations().find(
-    (candidate) => fs.existsSync(path6.join(candidate.userDataDir, "Local State")) || candidate.executablePath !== null
+    (candidate) => fs.existsSync(path7.join(candidate.userDataDir, "Local State")) || candidate.executablePath !== null
   );
   if (!installation) {
     throw new Error("Could not find a local Chrome or Chromium profile directory.");
@@ -13997,7 +14433,7 @@ function resolveChromeUserDataDir(userDataDir) {
 }
 function resolveChromeExecutablePath(executablePath) {
   if (executablePath !== void 0) {
-    const resolvedPath = path6.resolve(expandHome(executablePath));
+    const resolvedPath = path7.resolve(expandHome(executablePath));
     if (!fs.existsSync(resolvedPath)) {
       throw new Error(`Chrome executable was not found at "${resolvedPath}".`);
     }
@@ -14021,37 +14457,37 @@ function detectLocalChromeInstallations() {
           "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
           "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"
         ]),
-        userDataDir: path6.join(os.homedir(), "Library", "Application Support", "Google", "Chrome")
+        userDataDir: path7.join(os.homedir(), "Library", "Application Support", "Google", "Chrome")
       },
       {
         brand: "chromium",
         executablePath: firstExistingPath(["/Applications/Chromium.app/Contents/MacOS/Chromium"]),
-        userDataDir: path6.join(os.homedir(), "Library", "Application Support", "Chromium")
+        userDataDir: path7.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 ?? path6.join(os.homedir(), "AppData", "Local");
+    const localAppData = process.env.LOCALAPPDATA ?? path7.join(os.homedir(), "AppData", "Local");
     return [
       {
         brand: "chrome",
         executablePath: firstExistingPath([
-          path6.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
-          path6.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
-          path6.join(localAppData, "Google", "Chrome", "Application", "chrome.exe")
+          path7.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
+          path7.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
+          path7.join(localAppData, "Google", "Chrome", "Application", "chrome.exe")
         ]),
-        userDataDir: path6.join(localAppData, "Google", "Chrome", "User Data")
+        userDataDir: path7.join(localAppData, "Google", "Chrome", "User Data")
       },
       {
         brand: "chromium",
         executablePath: firstExistingPath([
-          path6.join(programFiles, "Chromium", "Application", "chrome.exe"),
-          path6.join(programFilesX86, "Chromium", "Application", "chrome.exe"),
-          path6.join(localAppData, "Chromium", "Application", "chrome.exe")
+          path7.join(programFiles, "Chromium", "Application", "chrome.exe"),
+          path7.join(programFilesX86, "Chromium", "Application", "chrome.exe"),
+          path7.join(localAppData, "Chromium", "Application", "chrome.exe")
         ]),
-        userDataDir: path6.join(localAppData, "Chromium", "User Data")
+        userDataDir: path7.join(localAppData, "Chromium", "User Data")
       }
     ];
   }
@@ -14064,7 +14500,7 @@ function detectLocalChromeInstallations() {
         resolveBinaryFromPath("google-chrome"),
         resolveBinaryFromPath("google-chrome-stable")
       ]),
-      userDataDir: path6.join(os.homedir(), ".config", "google-chrome")
+      userDataDir: path7.join(os.homedir(), ".config", "google-chrome")
     },
     {
       brand: "chromium",
@@ -14074,7 +14510,7 @@ function detectLocalChromeInstallations() {
         resolveBinaryFromPath("chromium"),
         resolveBinaryFromPath("chromium-browser")
       ]),
-      userDataDir: path6.join(os.homedir(), ".config", "chromium")
+      userDataDir: path7.join(os.homedir(), ".config", "chromium")
     }
   ];
 }
@@ -14086,8 +14522,8 @@ function detectLocalBrowserInstallations() {
   }));
 }
 function listLocalChromeProfiles(userDataDir = resolveChromeUserDataDir()) {
-  const resolvedUserDataDir = path6.resolve(expandHome(userDataDir));
-  const localStatePath = path6.join(resolvedUserDataDir, "Local State");
+  const resolvedUserDataDir = path7.resolve(expandHome(userDataDir));
+  const localStatePath = path7.join(resolvedUserDataDir, "Local State");
   if (!fs.existsSync(localStatePath)) {
     return [];
   }
@@ -14099,7 +14535,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 || path6.basename(directory);
+      const name = typeof record.name === "string" && record.name.trim().length > 0 ? record.name.trim() : directory || path7.basename(directory);
       return {
         directory,
         name,
@@ -14111,7 +14547,7 @@ function listLocalChromeProfiles(userDataDir = resolveChromeUserDataDir()) {
   }
 }
 function readDevToolsActivePort(userDataDir) {
-  const devToolsPath = path6.join(userDataDir, "DevToolsActivePort");
+  const devToolsPath = path7.join(userDataDir, "DevToolsActivePort");
   if (!fs.existsSync(devToolsPath)) {
     return null;
   }
@@ -14344,8 +14780,8 @@ function buildBrowserWebSocketUrl(httpUrl, webSocketPath) {
   const protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
   return `${protocol}//${httpUrl.host}${normalizeWebSocketPath(webSocketPath)}`;
 }
-function normalizeWebSocketPath(path13) {
-  return path13.startsWith("/") ? path13 : `/${path13}`;
+function normalizeWebSocketPath(path15) {
+  return path15.startsWith("/") ? path15 : `/${path15}`;
 }
 function rewriteBrowserWebSocketHost(browserWsUrl, requestedUrl) {
   try {
@@ -14391,20 +14827,20 @@ var SESSION_SKIPPED_PROFILE_DIRECTORIES = /* @__PURE__ */ new Set([
   "Network"
 ]);
 async function createBrowserProfileSnapshot(input) {
-  const sourceUserDataDir = path6.resolve(expandHome(input.sourceUserDataDir));
-  const targetUserDataDir = path6.resolve(expandHome(input.targetUserDataDir));
+  const sourceUserDataDir = path7.resolve(expandHome(input.sourceUserDataDir));
+  const targetUserDataDir = path7.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 = path6.join(sourceUserDataDir, profileDirectory);
+    const sourceProfileDir = path7.join(sourceUserDataDir, profileDirectory);
     if (!fs.existsSync(sourceProfileDir)) {
       throw new Error(
         `Chrome profile "${profileDirectory}" was not found in "${sourceUserDataDir}".`
       );
     }
-    await promises.cp(sourceProfileDir, path6.join(targetUserDataDir, profileDirectory), {
+    await promises.cp(sourceProfileDir, path7.join(targetUserDataDir, profileDirectory), {
       recursive: true,
       filter: (candidate) => shouldCopyEntry({
         candidatePath: candidate,
@@ -14428,8 +14864,8 @@ async function copyRootLevelEntries(input) {
     if (CHROME_SINGLETON_ENTRIES.has(entry) || entry === input.selectedProfileDirectory) {
       continue;
     }
-    const sourcePath = path6.join(input.sourceUserDataDir, entry);
-    const targetPath = path6.join(input.targetUserDataDir, entry);
+    const sourcePath = path7.join(input.sourceUserDataDir, entry);
+    const targetPath = path7.join(input.targetUserDataDir, entry);
     const entryStat = await promises.stat(sourcePath).catch(() => null);
     if (!entryStat) {
       continue;
@@ -14461,7 +14897,7 @@ async function copyRootLevelEntries(input) {
   }
 }
 function isProfileDirectory(userDataDir, entry) {
-  return fs.existsSync(path6.join(userDataDir, entry, "Preferences"));
+  return fs.existsSync(path7.join(userDataDir, entry, "Preferences"));
 }
 function shouldCopyEntry(input) {
   const entryName = input.candidatePath.split("/").at(-1)?.split("\\").at(-1) ?? input.candidatePath;
@@ -14471,7 +14907,7 @@ function shouldCopyEntry(input) {
   if (input.copyMode !== "session") {
     return true;
   }
-  const relativePath = path6.relative(input.rootPath, input.candidatePath);
+  const relativePath = path7.relative(input.rootPath, input.candidatePath);
   if (relativePath.length === 0) {
     return true;
   }
@@ -14953,7 +15389,7 @@ function pickStealthProfilePreset(overrides) {
 var OPENSTEER_LIVE_SESSION_LAYOUT = "opensteer-session";
 var OPENSTEER_LIVE_SESSION_VERSION = 1;
 function resolveLiveSessionRecordPath(rootPath, provider) {
-  return path6__default.default.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
+  return path7__default.default.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
 }
 function resolveLocalSessionRecordPath(rootPath) {
   return resolveLiveSessionRecordPath(rootPath, "local");
@@ -15113,8 +15549,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 ? path6__default.default.join(os.tmpdir(), `${TEMPORARY_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
-      rootDir: path6__default.default.resolve(options.rootDir ?? process.cwd()),
+    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()),
       workspace: this.workspace
     }));
     this.cleanupRootOnDisconnect = this.workspace === void 0;
@@ -15184,7 +15620,7 @@ var OpensteerBrowserManager = class {
         userDataDir: "browser/user-data",
         bootstrap: {
           kind: "cloneLocalProfile",
-          sourceUserDataDir: path6__default.default.resolve(input.sourceUserDataDir),
+          sourceUserDataDir: path7__default.default.resolve(input.sourceUserDataDir),
           ...input.sourceProfileDirectory === void 0 ? {} : { sourceProfileDirectory: input.sourceProfileDirectory }
         }
       };
@@ -15311,7 +15747,7 @@ var OpensteerBrowserManager = class {
     });
   }
   async createTemporaryEngine() {
-    const userDataDir = await promises.mkdtemp(path6__default.default.join(os.tmpdir(), "opensteer-temporary-browser-"));
+    const userDataDir = await promises.mkdtemp(path7__default.default.join(os.tmpdir(), "opensteer-temporary-browser-"));
     await clearChromeSingletonEntries(userDataDir);
     const launched = await launchOwnedBrowser({
       userDataDir,
@@ -15758,7 +16194,7 @@ async function terminateProcess(pid) {
   }
 }
 async function requestBrowserClose(endpoint) {
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve4, reject) => {
     const socket = new WebSocket(endpoint);
     const timeout = setTimeout(() => {
       socket.close();
@@ -15775,7 +16211,7 @@ async function requestBrowserClose(endpoint) {
         reject(error);
         return;
       }
-      resolve5();
+      resolve4();
     };
     socket.addEventListener("open", () => {
       socket.send(JSON.stringify({ id: 1, method: "Browser.close" }));
@@ -15813,7 +16249,7 @@ async function waitForProcessExit(pid, timeoutMs) {
   return !isProcessRunning(pid);
 }
 function resolveAbpSessionDir(workspace) {
-  return path6__default.default.join(workspace.livePath, "abp-session");
+  return path7__default.default.join(workspace.livePath, "abp-session");
 }
 async function allocateEphemeralPort() {
   const { allocatePort } = await loadAbpModule();
@@ -15871,7 +16307,103 @@ 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) {
-  await new Promise((resolve5) => setTimeout(resolve5, 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 signature = buildEnvironmentSignature(baseEnv, isOpensteerEnvironmentKey);
+  const cached = opensteerEnvironmentCache.get(resolvedCwd);
+  if (cached && cached.signature === signature) {
+    return { ...cached.values };
+  }
+  const resolved = resolveEnvironmentFiles(resolvedCwd, baseEnv, isOpensteerEnvironmentKey);
+  opensteerEnvironmentCache.set(resolvedCwd, {
+    signature,
+    values: { ...resolved }
+  });
+  return { ...resolved };
+}
+function collectDirectories(cwd) {
+  const directories = [];
+  let current = path7__default.default.resolve(cwd);
+  for (; ; ) {
+    directories.unshift(current);
+    const parent = path7__default.default.dirname(current);
+    if (parent === current) {
+      return directories;
+    }
+    current = parent;
+  }
+}
+function parseEnvFile(contents) {
+  const parsed = {};
+  for (const rawLine of contents.split(/\r?\n/u)) {
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const line = trimmed.startsWith("export ") ? trimmed.slice("export ".length) : trimmed;
+    const separatorIndex = line.indexOf("=");
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key)) {
+      continue;
+    }
+    const rawValue = line.slice(separatorIndex + 1).trim();
+    parsed[key] = parseEnvValue(rawValue);
+  }
+  return parsed;
+}
+function parseEnvValue(rawValue) {
+  if (rawValue.length >= 2 && rawValue.startsWith('"') && rawValue.endsWith('"')) {
+    return rawValue.slice(1, -1).replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"');
+  }
+  if (rawValue.length >= 2 && rawValue.startsWith("'") && rawValue.endsWith("'")) {
+    return rawValue.slice(1, -1);
+  }
+  return rawValue.replace(/\s+#.*$/u, "").trimEnd();
+}
+function resolveEnvironmentFiles(cwd, baseEnv, predicate) {
+  const resolved = collectEnvironment(baseEnv, predicate);
+  const protectedKeys = new Set(Object.keys(resolved));
+  const directories = collectDirectories(cwd);
+  for (const directory of directories) {
+    for (const filename of ENV_FILENAMES) {
+      const filePath = path7__default.default.join(directory, filename);
+      if (!fs.existsSync(filePath)) {
+        continue;
+      }
+      const parsed = parseEnvFile(fs.readFileSync(filePath, "utf8"));
+      for (const [key, value] of Object.entries(parsed)) {
+        if (predicate && !predicate(key) || protectedKeys.has(key)) {
+          continue;
+        }
+        resolved[key] = value;
+      }
+    }
+  }
+  return resolved;
+}
+function collectEnvironment(baseEnv, predicate) {
+  const resolved = {};
+  for (const [key, value] of Object.entries(baseEnv)) {
+    if (predicate && !predicate(key) || value === void 0) {
+      continue;
+    }
+    resolved[key] = value;
+  }
+  return resolved;
+}
+function buildEnvironmentSignature(baseEnv, predicate) {
+  return Object.entries(baseEnv).filter(([key, value]) => predicate(key) && value !== void 0).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key, value]) => `${key}=${value}`).join("\n");
+}
+function isOpensteerEnvironmentKey(key) {
+  return key.startsWith(OPENSTEER_ENV_PREFIX);
 }
 
 // ../runtime-core/package.json
@@ -17485,7 +18017,7 @@ function diffStringMap(prefix, left, right, includeUnchanged, output) {
     diffScalarField(`${prefix}.${key}`, left[key], right[key], includeUnchanged, output);
   }
 }
-function diffScalarField(path13, left, right, includeUnchanged, output) {
+function diffScalarField(path15, left, right, includeUnchanged, output) {
   const leftValue = stringifyFieldValue(left);
   const rightValue = stringifyFieldValue(right);
   const kind = leftValue === void 0 ? rightValue === void 0 ? "unchanged" : "added" : rightValue === void 0 ? "removed" : leftValue === rightValue ? "unchanged" : "changed";
@@ -17493,7 +18025,7 @@ function diffScalarField(path13, left, right, includeUnchanged, output) {
     return;
   }
   output.push({
-    path: path13,
+    path: path15,
     kind,
     ...leftValue === void 0 ? {} : { leftValue },
     ...rightValue === void 0 ? {} : { rightValue },
@@ -18499,9 +19031,9 @@ function matchReverseTargetHints(channel, codec, targetHints) {
       matches.add(`host:${host}`);
     }
   }
-  for (const path13 of targetHints.paths ?? []) {
-    if (url.pathname.includes(path13)) {
-      matches.add(`path:${path13}`);
+  for (const path15 of targetHints.paths ?? []) {
+    if (url.pathname.includes(path15)) {
+      matches.add(`path:${path15}`);
     }
   }
   for (const operationName of targetHints.operationNames ?? []) {
@@ -19462,11 +19994,11 @@ function inferClusterRelationship(seed, record) {
 var MATCHED_TLS_BINARY_NAMES = ["curl-impersonate-chrome", "curl_chrome"];
 async function executeMatchedTlsTransportRequest(input) {
   const binary = await resolveMatchedTlsBinary();
-  const workingDirectory = await promises.mkdtemp(path6__default.default.join(os.tmpdir(), "opensteer-matched-tls-"));
-  const headersPath = path6__default.default.join(workingDirectory, "headers.txt");
-  const bodyPath = path6__default.default.join(workingDirectory, "body.bin");
-  const cookiesPath = path6__default.default.join(workingDirectory, "cookies.txt");
-  const requestBodyPath = path6__default.default.join(workingDirectory, "request-body.bin");
+  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");
   try {
     await promises.writeFile(cookiesPath, toNetscapeCookieJar(input.cookies ?? []), "utf8");
     if (input.request.body !== void 0) {
@@ -19523,10 +20055,10 @@ async function executeMatchedTlsTransportRequest(input) {
   }
 }
 async function resolveMatchedTlsBinary() {
-  const pathEntries = (process.env.PATH ?? "").split(path6__default.default.delimiter).filter((entry) => entry.length > 0);
+  const pathEntries = (process.env.PATH ?? "").split(path7__default.default.delimiter).filter((entry) => entry.length > 0);
   for (const directory of pathEntries) {
     for (const name of MATCHED_TLS_BINARY_NAMES) {
-      const candidate = path6__default.default.join(directory, name);
+      const candidate = path7__default.default.join(directory, name);
       if (await isExecutable(candidate)) {
         return candidate;
       }
@@ -19534,7 +20066,7 @@ async function resolveMatchedTlsBinary() {
     const files = await readDirSafe(directory);
     const discovered = files.find((file) => file.startsWith("curl_chrome"));
     if (discovered !== void 0) {
-      const candidate = path6__default.default.join(directory, discovered);
+      const candidate = path7__default.default.join(directory, discovered);
       if (await isExecutable(candidate)) {
         return candidate;
       }
@@ -19545,7 +20077,7 @@ async function resolveMatchedTlsBinary() {
   );
 }
 async function spawnAndCollect(command, args, signal) {
-  return await new Promise((resolve5, reject) => {
+  return await new Promise((resolve4, reject) => {
     const child = child_process.spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -19578,7 +20110,7 @@ async function spawnAndCollect(command, args, signal) {
         );
         return;
       }
-      resolve5({ stdout, stderr });
+      resolve4({ stdout, stderr });
     });
   });
 }
@@ -22240,8 +22772,8 @@ function readString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function sleep2(ms, signal) {
-  return new Promise((resolve5, reject) => {
-    const timeout = setTimeout(resolve5, ms);
+  return new Promise((resolve4, reject) => {
+    const timeout = setTimeout(resolve4, ms);
     const abort = () => {
       clearTimeout(timeout);
       reject(new Error("captcha solve aborted"));
@@ -22338,8 +22870,8 @@ function readString2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function sleep3(ms, signal) {
-  return new Promise((resolve5, reject) => {
-    const timeout = setTimeout(resolve5, ms);
+  return new Promise((resolve4, reject) => {
+    const timeout = setTimeout(resolve4, ms);
     const abort = () => {
       clearTimeout(timeout);
       reject(new Error("captcha solve aborted"));
@@ -22538,6 +23070,8 @@ function diffInteractionTraces(left, right) {
 // ../runtime-core/src/sdk/runtime.ts
 var requireForAuthRecipeHook = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 var MUTATION_CAPTURE_FINALIZE_TIMEOUT_MS = 5e3;
+var PENDING_OPERATION_EVENT_CAPTURE_LIMIT = 64;
+var PENDING_OPERATION_EVENT_CAPTURE_SKEW_MS = 1e3;
 var OpensteerSessionRuntime = class {
   workspace;
   rootPath;
@@ -22550,6 +23084,9 @@ var OpensteerSessionRuntime = class {
   registryOverrides;
   cleanupRootOnClose;
   sessionInfoBase;
+  observationConfig;
+  observationSessionId;
+  injectedObservationSink;
   root;
   engine;
   dom;
@@ -22559,6 +23096,9 @@ var OpensteerSessionRuntime = class {
   sessionRef;
   pageRef;
   runId;
+  observations;
+  operationEventStorage = new async_hooks.AsyncLocalStorage();
+  pendingOperationEventCaptures = [];
   cookieJars = /* @__PURE__ */ new Map();
   recipeCache = /* @__PURE__ */ new Map();
   ownsEngine = false;
@@ -22566,7 +23106,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 ?? path6__default.default.resolve(process.cwd(), ".opensteer", "temporary", crypto.randomUUID());
+    this.rootPath = options.workspace?.rootPath ?? options.rootPath ?? path7__default.default.resolve(process.cwd(), ".opensteer", "temporary", crypto.randomUUID());
     this.injectedEngine = options.engine;
     this.engineFactory = options.engineFactory;
     this.policy = options.policy ?? defaultPolicy();
@@ -22575,6 +23115,9 @@ var OpensteerSessionRuntime = class {
     this.registryOverrides = options.registryOverrides;
     this.cleanupRootOnClose = options.cleanupRootOnClose ?? options.workspace === void 0;
     this.sessionInfoBase = options.sessionInfo ?? {};
+    this.observationConfig = normalizeObservabilityConfig(options.observability);
+    this.observationSessionId = options.observationSessionId;
+    this.injectedObservationSink = options.observationSink;
     if (this.injectedEngine === void 0 && this.engineFactory === void 0) {
       throw new Error("OpensteerSessionRuntime requires an engine or engineFactory.");
     }
@@ -22606,6 +23149,20 @@ var OpensteerSessionRuntime = class {
       }
     };
   }
+  async setObservabilityConfig(input) {
+    this.observationConfig = normalizeObservabilityConfig(input);
+    const observationSessionId = this.resolveObservationSessionId();
+    if (observationSessionId === void 0) {
+      return this.observationConfig;
+    }
+    const sink = this.injectedObservationSink ?? (await this.ensureRoot()).observations;
+    this.observations = await sink.openSession({
+      sessionId: observationSessionId,
+      openedAt: Date.now(),
+      config: this.observationConfig
+    });
+    return this.observationConfig;
+  }
   async open(input = {}, options = {}) {
     assertValidSemanticOperationInput("session.open", input);
     if (input.workspace !== void 0 && normalizeNamespace2(input.workspace) !== this.workspace) {
@@ -22704,6 +23261,10 @@ var OpensteerSessionRuntime = class {
       return { pages: [] };
     }
     const startedAt = Date.now();
+    const context = buildRuntimeTraceContext({
+      sessionRef: this.sessionRef,
+      pageRef: this.pageRef
+    });
     try {
       const output = await this.runWithOperationTimeout(
         "page.list",
@@ -22718,19 +23279,18 @@ var OpensteerSessionRuntime = class {
         },
         options
       );
+      const events = await this.drainPendingEngineEvents(context);
       await this.appendTrace({
         operation: "page.list",
         startedAt,
         completedAt: Date.now(),
         outcome: "ok",
+        ...events === void 0 ? {} : { events },
         data: {
           count: output.pages.length,
           ...output.activePageRef === void 0 ? {} : { activePageRef: output.activePageRef }
         },
-        context: buildRuntimeTraceContext({
-          sessionRef: this.sessionRef,
-          pageRef: this.pageRef
-        })
+        context
       });
       return output;
     } catch (error) {
@@ -22740,10 +23300,7 @@ var OpensteerSessionRuntime = class {
         completedAt: Date.now(),
         outcome: "error",
         error,
-        context: buildRuntimeTraceContext({
-          sessionRef: this.sessionRef,
-          pageRef: this.pageRef
-        })
+        context
       });
       throw error;
     }
@@ -23131,22 +23688,25 @@ var OpensteerSessionRuntime = class {
         },
         options
       );
+      const context = buildRuntimeTraceContext({
+        sessionRef: this.sessionRef,
+        pageRef
+      });
+      const events = await this.drainPendingEngineEvents(context);
       await this.appendTrace({
         operation: "page.snapshot",
         startedAt,
         completedAt: Date.now(),
         outcome: "ok",
         artifacts,
+        ...events === void 0 ? {} : { events },
         data: {
           mode,
           url: output.url,
           title: output.title,
           counterCount: output.counters.length
         },
-        context: buildRuntimeTraceContext({
-          sessionRef: this.sessionRef,
-          pageRef
-        })
+        context
       });
       return output;
     } catch (error) {
@@ -26571,11 +27131,13 @@ var OpensteerSessionRuntime = class {
         }
       );
       const output = toOpensteerActionResult(executed.result, preparedTarget.persistedDescription);
+      const actionEvents = "events" in executed.result ? executed.result.events : void 0;
       await this.appendTrace({
         operation,
         startedAt,
         completedAt: Date.now(),
         outcome: "ok",
+        ...actionEvents === void 0 ? {} : { events: actionEvents },
         data: {
           target: output.target,
           ...output.point === void 0 ? {} : { point: output.point },
@@ -28325,7 +28887,7 @@ var OpensteerSessionRuntime = class {
   }
   async executeAuthRecipeHook(step, variables) {
     const resolved = requireForAuthRecipeHook.resolve(step.hook.specifier, {
-      paths: [path6__default.default.dirname(this.rootPath)]
+      paths: [path7__default.default.dirname(this.rootPath)]
     });
     const module = await import(url.pathToFileURL(resolved).href);
     const handler = module[step.hook.export];
@@ -28697,14 +29259,18 @@ var OpensteerSessionRuntime = class {
       return this.engine;
     }
     if (this.injectedEngine) {
-      this.engine = this.injectedEngine;
+      this.engine = this.wrapEngineWithObservationCapture(
+        this.injectedEngine
+      );
       this.ownsEngine = false;
       return this.engine;
     }
     if (this.engineFactory === void 0) {
       throw new Error("Opensteer engine factory is not initialized");
     }
-    this.engine = await this.engineFactory(overrides);
+    this.engine = this.wrapEngineWithObservationCapture(
+      await this.engineFactory(overrides)
+    );
     this.ownsEngine = true;
     return this.engine;
   }
@@ -28904,6 +29470,15 @@ var OpensteerSessionRuntime = class {
       return;
     }
     const root = await this.ensureRoot();
+    const capturedStepEvents = input.events ?? this.consumePendingOperationEventCapture(
+      input.operation,
+      input.startedAt,
+      input.completedAt
+    );
+    const drainedStepEvents = input.events === void 0 ? await this.drainPendingEngineEvents(input.context) : void 0;
+    const stepEvents = mergeObservedStepEvents(capturedStepEvents, drainedStepEvents);
+    const normalizedData = input.data === void 0 ? void 0 : toCanonicalJsonValue(input.data);
+    const normalizedError = input.error === void 0 ? void 0 : normalizeOpensteerError(input.error);
     const artifacts = input.artifacts === void 0 ? void 0 : await Promise.all(
       input.artifacts.manifests.map(async (manifest) => {
         const reference = await root.artifacts.toProtocolArtifactReference(
@@ -28916,19 +29491,56 @@ var OpensteerSessionRuntime = class {
         return reference;
       })
     );
-    await root.traces.append(runId, {
+    const traceEntry = await root.traces.append(runId, {
       operation: input.operation,
       outcome: input.outcome,
       startedAt: input.startedAt,
       completedAt: input.completedAt,
       ...input.context === void 0 ? {} : { context: input.context },
-      ...input.events === void 0 ? {} : { events: input.events },
+      ...stepEvents === void 0 ? {} : { events: stepEvents },
       ...artifacts === void 0 ? {} : { artifacts },
-      ...input.data === void 0 ? {} : { data: toCanonicalJsonValue(input.data) },
-      ...input.error === void 0 ? {} : {
-        error: normalizeOpensteerError(input.error)
+      ...normalizedData === void 0 ? {} : { data: normalizedData },
+      ...normalizedError === void 0 ? {} : {
+        error: normalizedError
       }
     });
+    const observationSession = await this.ensureObservationSession().catch(() => void 0);
+    if (observationSession === void 0 || this.observationConfig.profile === "off") {
+      return;
+    }
+    const observationArtifactIds = input.artifacts === void 0 ? void 0 : (await Promise.allSettled(
+      input.artifacts.manifests.map(async (manifest) => {
+        const artifact = await observationSession.writeArtifact({
+          artifactId: manifest.artifactId,
+          kind: observationArtifactKindFromManifest(manifest.kind),
+          createdAt: manifest.createdAt,
+          context: manifest.scope,
+          mediaType: manifest.mediaType,
+          byteLength: manifest.byteLength,
+          sha256: manifest.sha256,
+          opensteerArtifactId: manifest.artifactId,
+          storageKey: manifestToExternalBinaryLocation(root.rootPath, manifest).uri
+        });
+        return artifact.artifactId;
+      })
+    )).flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
+    const observationEvents = buildObservationEventsFromTrace({
+      traceId: traceEntry.traceId,
+      stepId: traceEntry.stepId,
+      operation: input.operation,
+      outcome: input.outcome,
+      startedAt: input.startedAt,
+      completedAt: input.completedAt,
+      ...input.context === void 0 ? {} : { context: input.context },
+      ...stepEvents === void 0 ? {} : { events: stepEvents },
+      ...normalizedData === void 0 ? {} : { data: normalizedData },
+      ...normalizedError === void 0 ? {} : { error: normalizedError },
+      ...observationArtifactIds === void 0 ? {} : { artifactIds: observationArtifactIds },
+      profile: this.observationConfig.profile
+    });
+    if (observationEvents.length > 0) {
+      await observationSession.appendBatch(observationEvents).catch(() => void 0);
+    }
   }
   async cleanupSessionResources(engine, pageRef, sessionRef) {
     if (pageRef !== void 0) {
@@ -28940,6 +29552,7 @@ var OpensteerSessionRuntime = class {
   }
   async resetRuntimeState(options) {
     const engine = this.engine;
+    const observations = this.observations;
     this.networkHistory.clear();
     this.sessionRef = void 0;
     this.pageRef = void 0;
@@ -28948,20 +29561,140 @@ var OpensteerSessionRuntime = class {
     this.computer = void 0;
     this.extractionDescriptors = void 0;
     this.engine = void 0;
+    this.observations = void 0;
+    this.pendingOperationEventCaptures.length = 0;
+    await observations?.close("runtime_reset").catch(() => void 0);
     if (options.disposeEngine && this.ownsEngine && engine?.dispose) {
       await engine.dispose();
     }
     this.ownsEngine = false;
   }
+  async ensureObservationSession() {
+    if (this.observationConfig.profile === "off") {
+      return void 0;
+    }
+    if (this.observations !== void 0) {
+      return this.observations;
+    }
+    const observationSessionId = this.resolveObservationSessionId();
+    if (observationSessionId === void 0) {
+      return void 0;
+    }
+    const sink = this.injectedObservationSink ?? (await this.ensureRoot()).observations;
+    this.observations = await sink.openSession({
+      sessionId: observationSessionId,
+      openedAt: Date.now(),
+      config: this.observationConfig
+    });
+    return this.observations;
+  }
+  resolveObservationSessionId() {
+    return this.observationSessionId ?? this.sessionRef;
+  }
   runWithOperationTimeout(operation, callback, options = {}) {
-    return runWithPolicyTimeout(
-      this.policy.timeout,
-      {
-        operation,
-        ...options.signal === void 0 ? {} : { signal: options.signal }
-      },
-      callback
-    );
+    const existingCollector = this.operationEventStorage.getStore();
+    if (existingCollector !== void 0) {
+      return runWithPolicyTimeout(
+        this.policy.timeout,
+        {
+          operation,
+          ...options.signal === void 0 ? {} : { signal: options.signal }
+        },
+        callback
+      );
+    }
+    const collector = [];
+    const startedAt = Date.now();
+    return this.operationEventStorage.run(collector, async () => {
+      try {
+        return await runWithPolicyTimeout(
+          this.policy.timeout,
+          {
+            operation,
+            ...options.signal === void 0 ? {} : { signal: options.signal }
+          },
+          callback
+        );
+      } finally {
+        this.recordPendingOperationEventCapture({
+          operation,
+          startedAt,
+          completedAt: Date.now(),
+          events: collector
+        });
+      }
+    });
+  }
+  wrapEngineWithObservationCapture(engine) {
+    return new Proxy(engine, {
+      get: (target, property, receiver) => {
+        const value = Reflect.get(target, property, receiver);
+        if (typeof value !== "function") {
+          return value;
+        }
+        return (...args) => {
+          const result = Reflect.apply(value, target, args);
+          if (!(result instanceof Promise)) {
+            return result;
+          }
+          return result.then((resolved) => {
+            this.captureObservedStepEvents(resolved);
+            return resolved;
+          });
+        };
+      }
+    });
+  }
+  captureObservedStepEvents(value) {
+    const collector = this.operationEventStorage.getStore();
+    if (collector === void 0) {
+      return;
+    }
+    const events = readStepResultEvents(value);
+    if (events === void 0 || events.length === 0) {
+      return;
+    }
+    collector.push(...events);
+  }
+  recordPendingOperationEventCapture(capture) {
+    if (capture.events.length === 0) {
+      return;
+    }
+    this.pendingOperationEventCaptures.push({
+      ...capture,
+      events: [...capture.events]
+    });
+    if (this.pendingOperationEventCaptures.length > PENDING_OPERATION_EVENT_CAPTURE_LIMIT) {
+      this.pendingOperationEventCaptures.splice(
+        0,
+        this.pendingOperationEventCaptures.length - PENDING_OPERATION_EVENT_CAPTURE_LIMIT
+      );
+    }
+  }
+  consumePendingOperationEventCapture(operation, startedAt, completedAt) {
+    for (let index = this.pendingOperationEventCaptures.length - 1; index >= 0; index -= 1) {
+      const capture = this.pendingOperationEventCaptures[index];
+      if (capture === void 0) {
+        continue;
+      }
+      if (capture.operation !== operation) {
+        continue;
+      }
+      if (capture.startedAt < startedAt - PENDING_OPERATION_EVENT_CAPTURE_SKEW_MS || capture.completedAt > completedAt + PENDING_OPERATION_EVENT_CAPTURE_SKEW_MS) {
+        continue;
+      }
+      this.pendingOperationEventCaptures.splice(index, 1);
+      return capture.events;
+    }
+    return void 0;
+  }
+  async drainPendingEngineEvents(context) {
+    const pageRef = context?.pageRef ?? this.pageRef;
+    if (pageRef === void 0 || this.engine === void 0) {
+      return void 0;
+    }
+    const events = await this.engine.drainEvents({ pageRef }).catch(() => []);
+    return events.length > 0 ? events : void 0;
   }
   async navigatePage(input, timeout) {
     const remainingMs = timeout.remainingMs();
@@ -28997,6 +29730,34 @@ function buildRuntimeTraceContext(input) {
 function buildArtifactScope(input) {
   return buildRuntimeTraceContext(input);
 }
+function readStepResultEvents(value) {
+  if (value === null || typeof value !== "object") {
+    return void 0;
+  }
+  if (!("events" in value)) {
+    return void 0;
+  }
+  const events = value.events;
+  return Array.isArray(events) ? events : void 0;
+}
+function mergeObservedStepEvents(primary, secondary) {
+  if (primary === void 0 || primary.length === 0) {
+    return secondary === void 0 || secondary.length === 0 ? void 0 : secondary;
+  }
+  if (secondary === void 0 || secondary.length === 0) {
+    return primary;
+  }
+  const merged = /* @__PURE__ */ new Map();
+  for (const event of primary) {
+    merged.set(event.eventId, event);
+  }
+  for (const event of secondary) {
+    merged.set(event.eventId, event);
+  }
+  return [...merged.values()].sort(
+    (left, right) => (left.timestamp ?? 0) - (right.timestamp ?? 0)
+  );
+}
 function selectLiveQueryPageRef(input, currentPageRef) {
   if (input.pageRef !== void 0) {
     return input.pageRef;
@@ -29959,12 +30720,12 @@ function extractReverseRuntimeValue(value, pointer) {
   }
   return readDotPath(value, pointer);
 }
-function readDotPath(value, path13) {
-  if (path13.length === 0) {
+function readDotPath(value, path15) {
+  if (path15.length === 0) {
     return value;
   }
   let current = value;
-  for (const segment of path13.split(".").filter((entry) => entry.length > 0)) {
+  for (const segment of path15.split(".").filter((entry) => entry.length > 0)) {
     if (current === null || current === void 0) {
       return void 0;
     }
@@ -30333,7 +31094,7 @@ function normalizeRuntimeErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function runtimeDelay(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function applyBrowserCookiesToTransportRequest(request, cookies) {
   if (cookies.length === 0) {
@@ -30437,7 +31198,7 @@ function parseSetCookieHeader(value, requestUrl) {
   }
   const url = new URL(requestUrl);
   let domain = url.hostname;
-  let path13 = defaultCookiePath(url.pathname);
+  let path15 = defaultCookiePath(url.pathname);
   let secure = url.protocol === "https:";
   let expiresAt;
   const cookieValue = rawValueParts.join("=").trim();
@@ -30450,7 +31211,7 @@ function parseSetCookieHeader(value, requestUrl) {
       continue;
     }
     if (key === "path" && attributeValue.length > 0) {
-      path13 = attributeValue;
+      path15 = attributeValue;
       continue;
     }
     if (key === "secure") {
@@ -30476,7 +31237,7 @@ function parseSetCookieHeader(value, requestUrl) {
       name,
       value: cookieValue,
       domain,
-      path: path13,
+      path: path15,
       secure,
       ...expiresAt === void 0 ? {} : { expiresAt }
     }
@@ -31428,7 +32189,7 @@ async function pollUntilResult(timeout, producer) {
     if (produced !== void 0) {
       return produced;
     }
-    await new Promise((resolve5) => setTimeout(resolve5, 100));
+    await new Promise((resolve4) => setTimeout(resolve4, 100));
   }
 }
 async function getMainFrame(engine, pageRef) {
@@ -31486,6 +32247,133 @@ function toOpensteerResolvedTarget2(target) {
 function normalizeOpensteerError(error) {
   return normalizeThrownOpensteerError(error, "Unknown Opensteer runtime failure");
 }
+function observationArtifactKindFromManifest(kind) {
+  switch (kind) {
+    case "screenshot":
+      return "screenshot";
+    case "dom-snapshot":
+      return "dom-snapshot";
+    case "html-snapshot":
+      return "html-snapshot";
+    default:
+      return "other";
+  }
+}
+function buildObservationEventsFromTrace(input) {
+  const context = normalizeObservationContext(input.context);
+  const baseCorrelationId = input.traceId;
+  const startedEvent = {
+    kind: input.operation === "session.open" || input.operation === "session.close" ? "session" : "operation",
+    phase: "started",
+    createdAt: input.startedAt,
+    correlationId: baseCorrelationId,
+    spanId: input.stepId,
+    ...context === void 0 ? {} : { context },
+    data: {
+      operation: input.operation
+    }
+  };
+  const stepEvents = (input.events ?? []).filter((event) => shouldCaptureObservationStepEvent(event, input.profile)).map((event) => {
+    const eventContext = buildObservationContextFromEvent(event);
+    return {
+      kind: observationKindForStepEvent(event),
+      phase: "occurred",
+      createdAt: event.timestamp,
+      correlationId: baseCorrelationId,
+      parentSpanId: input.stepId,
+      ...eventContext === void 0 ? {} : { context: eventContext },
+      data: stripObservationStepEvent(event),
+      ...event.kind === "page-error" ? {
+        error: {
+          message: event.message,
+          ...event.stack === void 0 ? {} : { details: { stack: event.stack } }
+        }
+      } : {}
+    };
+  });
+  const completedEvent = {
+    kind: input.operation === "session.open" || input.operation === "session.close" ? "session" : "operation",
+    phase: input.outcome === "ok" ? "completed" : "failed",
+    createdAt: input.completedAt,
+    correlationId: baseCorrelationId,
+    spanId: input.stepId,
+    ...context === void 0 ? {} : { context },
+    data: {
+      operation: input.operation,
+      startedAt: input.startedAt,
+      completedAt: input.completedAt,
+      durationMs: input.completedAt - input.startedAt,
+      ...input.data === void 0 ? {} : { output: input.data }
+    },
+    ...input.error === void 0 ? {} : {
+      error: {
+        ...input.error.code === void 0 ? {} : { code: input.error.code },
+        message: input.error.message,
+        ...input.error.retriable === void 0 ? {} : { retriable: input.error.retriable },
+        ...input.error.details === void 0 ? {} : { details: toCanonicalJsonValue(input.error.details) }
+      }
+    },
+    ...input.artifactIds === void 0 || input.artifactIds.length === 0 ? {} : { artifactIds: input.artifactIds }
+  };
+  return [startedEvent, ...stepEvents, completedEvent];
+}
+function buildObservationContextFromEvent(event) {
+  return normalizeObservationContext({
+    sessionRef: event.sessionRef,
+    ...event.pageRef === void 0 ? {} : { pageRef: event.pageRef },
+    ...event.frameRef === void 0 ? {} : { frameRef: event.frameRef },
+    ...event.documentRef === void 0 ? {} : { documentRef: event.documentRef },
+    ...event.documentEpoch === void 0 ? {} : { documentEpoch: event.documentEpoch }
+  });
+}
+function shouldCaptureObservationStepEvent(event, profile) {
+  if (profile === "diagnostic") {
+    return true;
+  }
+  switch (event.kind) {
+    case "page-created":
+    case "popup-opened":
+    case "page-closed":
+    case "page-error":
+      return true;
+    case "console":
+      return event.level === "warn" || event.level === "error";
+    default:
+      return false;
+  }
+}
+function observationKindForStepEvent(event) {
+  switch (event.kind) {
+    case "console":
+      return "console";
+    case "page-error":
+      return "error";
+    case "paused":
+    case "resumed":
+    case "frozen":
+      return "runtime";
+    default:
+      return "page";
+  }
+}
+function stripObservationStepEvent(event) {
+  const {
+    eventId: _eventId,
+    kind,
+    timestamp,
+    sessionRef: _sessionRef,
+    pageRef: _pageRef,
+    frameRef: _frameRef,
+    documentRef: _documentRef,
+    documentEpoch: _documentEpoch,
+    ...rest
+  } = event;
+  return toCanonicalJsonValue({
+    eventKind: kind,
+    timestamp,
+    ...rest
+  });
+}
 function buildMutationCaptureTraceData(diagnostics) {
   if (diagnostics?.finalizeError === void 0) {
     return {};
@@ -31535,8 +32423,8 @@ function screenshotMediaType(format2) {
 var OpensteerRuntime = class extends OpensteerSessionRuntime {
   constructor(options = {}) {
     const publicWorkspace = normalizeWorkspace2(options.workspace);
-    const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path6__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : resolveFilesystemWorkspacePath({
-      rootDir: path6__default.default.resolve(options.rootDir ?? process.cwd()),
+    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()),
       workspace: publicWorkspace
     }));
     const cleanupRootOnClose = options.cleanupRootOnClose ?? publicWorkspace === void 0;
@@ -31561,14 +32449,17 @@ var OpensteerRuntime = class extends OpensteerSessionRuntime {
         ...options.descriptorStore === void 0 ? {} : { descriptorStore: options.descriptorStore },
         ...options.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: options.extractionDescriptorStore },
         ...options.registryOverrides === void 0 ? {} : { registryOverrides: options.registryOverrides },
-        cleanupRootOnClose
+        cleanupRootOnClose,
+        ...options.observability === void 0 ? {} : { observability: options.observability },
+        ...options.observationSessionId === void 0 ? {} : { observationSessionId: options.observationSessionId },
+        ...options.observationSink === void 0 ? {} : { observationSink: options.observationSink }
       })
     );
   }
 };
 var OpensteerSessionRuntime2 = class extends OpensteerSessionRuntime {
   constructor(options) {
-    const rootPath = options.rootPath ?? path6__default.default.resolve(options.rootDir ?? process.cwd());
+    const rootPath = options.rootPath ?? path7__default.default.resolve(options.rootDir ?? process.cwd());
     const cleanupRootOnClose = options.cleanupRootOnClose ?? false;
     const engineName = options.engineName ?? DEFAULT_OPENSTEER_ENGINE;
     assertSupportedEngineOptions({
@@ -31590,7 +32481,10 @@ var OpensteerSessionRuntime2 = class extends OpensteerSessionRuntime {
         ...options.descriptorStore === void 0 ? {} : { descriptorStore: options.descriptorStore },
         ...options.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: options.extractionDescriptorStore },
         ...options.registryOverrides === void 0 ? {} : { registryOverrides: options.registryOverrides },
-        cleanupRootOnClose
+        cleanupRootOnClose,
+        ...options.observability === void 0 ? {} : { observability: options.observability },
+        ...options.observationSessionId === void 0 ? {} : { observationSessionId: options.observationSessionId },
+        ...options.observationSink === void 0 ? {} : { observationSink: options.observationSink }
       })
     );
   }
@@ -31616,6 +32510,9 @@ function buildSharedRuntimeOptions(input) {
     ...input.extractionDescriptorStore === void 0 ? {} : { extractionDescriptorStore: input.extractionDescriptorStore },
     ...input.registryOverrides === void 0 ? {} : { registryOverrides: input.registryOverrides },
     cleanupRootOnClose: input.cleanupRootOnClose,
+    ...input.observability === void 0 ? {} : { observability: input.observability },
+    ...input.observationSessionId === void 0 ? {} : { observationSessionId: input.observationSessionId },
+    ...input.observationSink === void 0 ? {} : { observationSink: input.observationSink },
     sessionInfo: {
       provider: {
         mode: "local",
@@ -31678,345 +32575,267 @@ function resolveOpensteerProvider(input = {}) {
   };
 }
 var execFile2 = util.promisify(child_process.execFile);
-var DEFAULT_CAPTURE_TIMEOUT_MS = 3e4;
-var DEFAULT_STOP_TIMEOUT_MS = 15e3;
-var DEVTOOLS_POLL_INTERVAL_MS2 = 50;
-var PROCESS_LIST_MAX_BUFFER_BYTES3 = 16 * 1024 * 1024;
-async function resolveCookieCaptureStrategy(input = {}) {
-  const timeoutMs = input.timeoutMs ?? DEFAULT_CAPTURE_TIMEOUT_MS;
-  if (input.attachEndpoint !== void 0) {
-    if (input.strategy !== void 0 && input.strategy !== "attach") {
-      throw new Error(
-        `Strategy "${input.strategy}" is incompatible with an explicit attach endpoint.`
-      );
-    }
-    return {
-      strategy: "attach",
-      attachEndpoint: input.attachEndpoint,
-      ...input.profileDirectory === void 0 ? {} : { profileDirectory: input.profileDirectory },
-      timeoutMs
-    };
-  }
+var NODE_SQLITE_SPECIFIER2 = `node:${"sqlite"}`;
+var CHROME_EPOCH_OFFSET = 11644473600000000n;
+var CHROME_HMAC_PREFIX_LENGTH = 32;
+async function readBrowserCookies(input = {}) {
   const brand2 = resolveRequestedBrand(input);
-  const executablePath = resolveBrandExecutablePath(brand2, input.executablePath);
   const userDataDir = resolveBrandUserDataDir(brand2, input.userDataDir);
-  const profileDirectory = input.profileDirectory;
-  const attachEndpoint = await resolveReachableAttachEndpoint(userDataDir, timeoutMs);
-  const runningProcess = findBrandProcess(brand2);
-  const autoStrategy = attachEndpoint !== void 0 ? "attach" : runningProcess !== null ? "managed-relaunch" : "headless";
-  const strategy = input.strategy ?? autoStrategy;
-  validateRequestedStrategy({
-    strategy,
-    brand: brand2,
-    ...attachEndpoint === void 0 ? {} : { attachEndpoint },
-    ...runningProcess?.pid === void 0 ? {} : { runningPid: runningProcess.pid }
-  });
-  return {
-    strategy,
-    brandId: brand2.id,
-    brandDisplayName: brand2.displayName,
-    executablePath,
-    userDataDir,
-    ...profileDirectory === void 0 ? {} : { profileDirectory },
-    ...attachEndpoint === void 0 ? {} : { attachEndpoint },
-    ...runningProcess === null ? {} : { runningPid: runningProcess.pid },
-    timeoutMs
-  };
-}
-async function acquireCdpEndpoint(resolved) {
-  if (resolved.strategy === "attach") {
-    if (!resolved.attachEndpoint) {
-      throw new Error("Attach capture requires a debuggable browser endpoint.");
-    }
-    const inspected = await inspectCdpEndpoint({
-      endpoint: resolved.attachEndpoint,
-      timeoutMs: Math.min(2e3, resolved.timeoutMs)
-    });
-    return {
-      strategy: "attach",
-      cdpEndpoint: inspected.endpoint,
-      ...resolved.brandId === void 0 ? {} : { brandId: resolved.brandId },
-      ...resolved.brandDisplayName === void 0 ? {} : { brandDisplayName: resolved.brandDisplayName },
-      ...resolved.userDataDir === void 0 ? {} : { userDataDir: resolved.userDataDir },
-      ...resolved.profileDirectory === void 0 ? {} : { profileDirectory: resolved.profileDirectory },
-      cleanup: async () => void 0
-    };
-  }
-  if (!resolved.brandId || !resolved.brandDisplayName || !resolved.executablePath || !resolved.userDataDir) {
+  const profileDirectory = input.profileDirectory ?? "Default";
+  const cookiesPath = path7.join(userDataDir, profileDirectory, "Cookies");
+  if (!fs.existsSync(cookiesPath)) {
     throw new Error(
-      "Headless cookie capture requires a resolved browser brand, executable, and user-data-dir."
-    );
-  }
-  const userDataDir = resolved.userDataDir;
-  if (resolved.strategy === "managed-relaunch") {
-    if (resolved.runningPid === void 0) {
-      throw new Error("Managed relaunch requires a running browser process.");
-    }
-    await gracefullyStopBrowser(
-      getBrowserBrand(resolved.brandId),
-      resolved.runningPid,
-      resolved.timeoutMs
+      `Cookies database not found at "${cookiesPath}". Verify the browser brand, user-data-dir, and profile-directory are correct.`
     );
   }
-  await clearChromeSingletonEntries(userDataDir);
-  try {
-    const capture = await launchCaptureChrome({
-      brandDisplayName: resolved.brandDisplayName,
-      executablePath: resolved.executablePath,
-      userDataDir,
-      ...resolved.profileDirectory === void 0 ? {} : { profileDirectory: resolved.profileDirectory },
-      timeoutMs: resolved.timeoutMs
-    });
-    return {
-      strategy: resolved.strategy,
-      cdpEndpoint: capture.endpoint,
-      brandId: resolved.brandId,
-      brandDisplayName: resolved.brandDisplayName,
-      userDataDir: resolved.userDataDir,
-      ...resolved.profileDirectory === void 0 ? {} : { profileDirectory: resolved.profileDirectory },
-      cleanup: async () => {
-        await capture.kill().catch(() => void 0);
-        await clearChromeSingletonEntries(userDataDir).catch(() => void 0);
-      }
-    };
-  } catch (error) {
-    await clearChromeSingletonEntries(userDataDir).catch(() => void 0);
-    throw error;
-  }
-}
-async function gracefullyStopBrowser(brand2, pid, timeoutMs = DEFAULT_STOP_TIMEOUT_MS) {
-  if (pid <= 0) {
-    return;
-  }
-  const platformConfig = resolveBrandPlatformConfig(brand2);
-  if (process.platform === "darwin" && platformConfig?.bundleId) {
-    await execFile2(
-      "osascript",
-      ["-e", `tell application id "${platformConfig.bundleId}" to quit`],
-      {
-        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES3
-      }
-    ).catch(() => void 0);
-  } else if (process.platform === "win32") {
-    await execFile2("taskkill", ["/PID", String(pid)], {
-      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES3
-    }).catch(() => void 0);
-  } else {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
-    }
-  }
-  if (await waitForProcessExit2(pid, timeoutMs)) {
-    return;
-  }
-  if (process.platform === "win32") {
-    await execFile2("taskkill", ["/F", "/PID", String(pid)], {
-      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES3
-    }).catch(() => void 0);
-  } else {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
-    }
-  }
-  await waitForProcessExit2(pid, Math.min(5e3, timeoutMs));
-}
-async function launchCaptureChrome(input) {
-  const stderrLines = [];
-  const child = child_process.spawn(input.executablePath, buildCaptureChromeArgs(input), {
-    detached: process.platform !== "win32",
-    stdio: ["ignore", "ignore", "pipe"]
-  });
-  child.unref();
-  child.stderr?.setEncoding("utf8");
-  child.stderr?.on("data", (chunk) => {
-    stderrLines.push(String(chunk));
-  });
+  const tempDir = await promises.mkdtemp(path7.join(os.tmpdir(), "opensteer-cookies-"));
   try {
-    const endpoint = await waitForCaptureEndpoint({
-      brandDisplayName: input.brandDisplayName,
-      child,
-      stderrLines,
-      timeoutMs: input.timeoutMs,
-      userDataDir: input.userDataDir
-    });
+    await copyCookiesDatabase(cookiesPath, tempDir);
+    const decryptionKey = await resolveDecryptionKey(brand2.id, userDataDir);
+    const rows = queryAllCookies(path7.join(tempDir, "Cookies"));
+    const cookies = decryptCookieRows(rows, decryptionKey);
     return {
-      endpoint,
-      kill: async () => {
-        await terminateChild(child);
-      }
+      cookies,
+      brandId: brand2.id,
+      brandDisplayName: brand2.displayName,
+      userDataDir,
+      profileDirectory
     };
-  } catch (error) {
-    await terminateChild(child).catch(() => void 0);
-    throw error;
+  } finally {
+    await promises.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
   }
 }
-function relaunchBrowserNormally(executablePath) {
-  const child = child_process.spawn(executablePath, [], {
-    detached: true,
-    stdio: "ignore"
-  });
-  child.unref();
-}
 function resolveRequestedBrand(input) {
   if (input.brandId !== void 0) {
     return getBrowserBrand(input.brandId);
   }
-  if (input.userDataDir !== void 0) {
-    const inferred = inferBrandFromUserDataDir(input.userDataDir);
-    if (!inferred) {
-      throw new Error(
-        `Could not infer a browser brand from user-data-dir "${input.userDataDir}". Pass --browser explicitly.`
-      );
-    }
-    return inferred;
-  }
-  if (input.executablePath !== void 0) {
-    const inferred = inferBrandFromExecutablePath(input.executablePath);
-    if (!inferred) {
-      throw new Error(
-        `Could not infer a browser brand from executable path "${input.executablePath}". Pass --browser explicitly.`
-      );
-    }
-    return inferred;
-  }
   const installed = detectInstalledBrowserBrands()[0];
   if (!installed) {
     throw new Error(
-      "No Chromium browser found. Install a supported browser or pass --browser explicitly."
+      "No Chromium browser found. Install a supported browser or pass brandId explicitly."
     );
   }
   return installed.brand;
 }
-async function resolveReachableAttachEndpoint(userDataDir, timeoutMs) {
-  const activePort = readDevToolsActivePort(userDataDir);
-  if (!activePort) {
-    return void 0;
+async function copyCookiesDatabase(cookiesPath, destDir) {
+  await promises.copyFile(cookiesPath, path7.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);
+    }
   }
+}
+function queryAllCookies(dbPath) {
+  let DatabaseSync;
   try {
-    return (await inspectCdpEndpoint({
-      endpoint: `http://127.0.0.1:${String(activePort.port)}`,
-      timeoutMs: Math.min(2e3, timeoutMs)
-    })).endpoint;
+    ({ DatabaseSync } = __require(NODE_SQLITE_SPECIFIER2));
   } catch {
-    return void 0;
+    throw new Error(
+      "Reading browser cookies requires Node's built-in SQLite support. Use Node 22.5+ or a build with node:sqlite enabled."
+    );
+  }
+  const database = new DatabaseSync(dbPath, { readOnly: true });
+  try {
+    const stmt = database.prepare(
+      `SELECT host_key, name, value, encrypted_value, path,
+              expires_utc, is_secure, is_httponly, samesite, is_persistent
+       FROM cookies`
+    );
+    stmt.setReadBigInts(true);
+    return stmt.all();
+  } finally {
+    database.close();
   }
 }
-function validateRequestedStrategy(input) {
-  if (input.strategy === "attach" && input.attachEndpoint === void 0) {
+async function resolveDecryptionKey(brandId, userDataDir) {
+  if (process.platform === "darwin") {
+    const password = await resolveKeychainPassword(brandId);
+    const key = crypto.pbkdf2Sync(password, "saltysalt", 1003, 16, "sha1");
+    return { platform: "darwin", key, algorithm: "aes-128-cbc" };
+  }
+  if (process.platform === "linux") {
+    const key = crypto.pbkdf2Sync("peanuts", "saltysalt", 1, 16, "sha1");
+    return { platform: "linux", key, algorithm: "aes-128-cbc" };
+  }
+  if (process.platform === "win32") {
+    const key = await resolveWindowsMasterKey(userDataDir);
+    return { platform: "win32", key, algorithm: "aes-256-gcm" };
+  }
+  throw new Error(`Unsupported platform "${process.platform}" for cookie decryption.`);
+}
+var BRAND_KEYCHAIN_SERVICE = {
+  chrome: "Chrome Safe Storage",
+  "chrome-canary": "Chrome Safe Storage",
+  chromium: "Chromium Safe Storage",
+  brave: "Brave Safe Storage",
+  edge: "Microsoft Edge Safe Storage",
+  vivaldi: "Chrome Safe Storage",
+  helium: "Chrome Safe Storage"
+};
+async function resolveKeychainPassword(brandId) {
+  const service = BRAND_KEYCHAIN_SERVICE[brandId];
+  try {
+    const { stdout } = await execFile2("security", [
+      "find-generic-password",
+      "-s",
+      service,
+      "-w"
+    ]);
+    return stdout.trim();
+  } catch {
     throw new Error(
-      `${input.brand.displayName} is not currently exposing a debuggable CDP endpoint for attach mode.`
+      `Failed to retrieve "${service}" from macOS Keychain. Ensure the browser has been opened at least once and Keychain access is allowed.`
     );
   }
-  if (input.strategy === "headless" && input.runningPid !== void 0) {
+}
+async function resolveWindowsMasterKey(userDataDir) {
+  const localStatePath = path7.join(userDataDir, "Local State");
+  let localState;
+  try {
+    localState = JSON.parse(await promises.readFile(localStatePath, "utf8"));
+  } catch {
     throw new Error(
-      `${input.brand.displayName} is already running. Close it first or use managed-relaunch.`
+      `Failed to read "${localStatePath}". Ensure the browser has been opened at least once.`
     );
   }
-  if (input.strategy === "managed-relaunch" && input.runningPid === void 0) {
+  const encodedKey = localState.os_crypt?.encrypted_key;
+  if (!encodedKey) {
+    throw new Error(`No encrypted key found in "${localStatePath}".`);
+  }
+  const rawKey = Buffer.from(encodedKey, "base64").subarray(5);
+  const psScript = `
+    Add-Type -AssemblyName System.Security
+    $bytes = [byte[]]@(${Array.from(rawKey).join(",")})
+    $decrypted = [System.Security.Cryptography.ProtectedData]::Unprotect($bytes, $null, 'CurrentUser')
+    [Convert]::ToBase64String($decrypted)
+  `;
+  try {
+    const { stdout } = await execFile2("powershell", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      psScript
+    ]);
+    return Buffer.from(stdout.trim(), "base64");
+  } catch {
     throw new Error(
-      `${input.brand.displayName} is not currently running, so managed-relaunch is not available.`
+      "Failed to decrypt browser master key via Windows DPAPI. Ensure you are running as the same user who owns the browser profile."
     );
   }
 }
-function inferBrandFromUserDataDir(userDataDir) {
-  const normalized = normalizePath(userDataDir);
-  return getAllBrowserBrands().find((brand2) => {
-    const config = resolveBrandPlatformConfig(brand2);
-    if (!config) {
-      return false;
+function decryptCookieRows(rows, decryptionKey) {
+  const cookies = [];
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  for (const row of rows) {
+    const name = row.name.trim();
+    const domain = row.host_key.trim();
+    if (!name || !domain) {
+      continue;
     }
-    const defaultDir = normalizePath(config.userDataDir);
-    return normalized === defaultDir || normalized.startsWith(`${defaultDir}/`);
-  });
-}
-function inferBrandFromExecutablePath(executablePath) {
-  const normalized = normalizePath(executablePath);
-  return getAllBrowserBrands().find((brand2) => {
-    const config = resolveBrandPlatformConfig(brand2);
-    if (!config) {
-      return false;
+    const value = decryptCookieValue(row, decryptionKey);
+    if (value === null) {
+      continue;
     }
-    return config.executableCandidates.some(
-      (candidate) => candidate !== null && normalizePath(candidate) === normalized
-    );
-  });
-}
-function buildCaptureChromeArgs(input) {
-  const args = [
-    "--remote-debugging-port=0",
-    "--headless=new",
-    "--no-first-run",
-    "--no-default-browser-check",
-    "--disable-background-networking",
-    "--disable-sync",
-    "--disable-component-update",
-    `--user-data-dir=${input.userDataDir}`
-  ];
-  if (input.profileDirectory !== void 0) {
-    args.push(`--profile-directory=${input.profileDirectory}`);
-  }
-  return args;
-}
-async function waitForCaptureEndpoint(input) {
-  const deadline = Date.now() + input.timeoutMs;
-  while (Date.now() < deadline) {
-    const activePort = readDevToolsActivePort(input.userDataDir);
-    if (activePort) {
-      try {
-        return (await inspectCdpEndpoint({
-          endpoint: `http://127.0.0.1:${String(activePort.port)}`,
-          timeoutMs: Math.min(2e3, input.timeoutMs)
-        })).endpoint;
-      } catch {
-        return `ws://127.0.0.1:${String(activePort.port)}${activePort.webSocketPath}`;
-      }
+    const expiresSeconds = chromeDateToUnixSeconds(row.expires_utc);
+    const isSession = expiresSeconds <= 0;
+    if (!isSession && expiresSeconds < nowSeconds) {
+      continue;
     }
-    if (input.child.exitCode !== null) {
-      break;
+    const sameSite = chromeSameSiteToString(row.samesite);
+    let secure = Number(row.is_secure) === 1;
+    if (sameSite === "None") {
+      secure = true;
     }
-    await sleep4(DEVTOOLS_POLL_INTERVAL_MS2);
+    cookies.push({
+      name,
+      value,
+      domain,
+      path: row.path || "/",
+      secure,
+      httpOnly: Number(row.is_httponly) === 1,
+      ...isSession ? {} : { expires: expiresSeconds },
+      ...sameSite !== void 0 ? { sameSite } : {}
+    });
   }
-  throw new Error(formatCaptureLaunchError(input.brandDisplayName, input.stderrLines));
+  return cookies;
 }
-function formatCaptureLaunchError(brandDisplayName, stderrLines) {
-  const relevantLines = stderrLines.join("").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-  if (relevantLines.length === 0) {
-    return `${brandDisplayName} failed to launch before exposing a DevTools endpoint.`;
+function decryptCookieValue(row, decryptionKey) {
+  if (row.value && row.value.length > 0) {
+    return row.value;
   }
-  const focusedLines = relevantLines.filter(
-    (line) => /(error|fatal|sandbox|namespace|permission|cannot|failed|abort)/i.test(line)
-  );
-  return `${brandDisplayName} failed to launch before exposing a DevTools endpoint.
-${(focusedLines.length > 0 ? focusedLines : relevantLines).slice(-5).join("\n")}`;
+  const encrypted = Buffer.isBuffer(row.encrypted_value) ? row.encrypted_value : Buffer.from(row.encrypted_value);
+  if (encrypted.length === 0) {
+    return "";
+  }
+  const prefix = encrypted.subarray(0, 3).toString("ascii");
+  if (prefix !== "v10" && prefix !== "v11") {
+    return encrypted.toString("utf8");
+  }
+  const ciphertext = encrypted.subarray(3);
+  if (decryptionKey.algorithm === "aes-128-cbc") {
+    return decryptAes128Cbc(ciphertext, decryptionKey.key);
+  }
+  if (decryptionKey.algorithm === "aes-256-gcm") {
+    return decryptAes256Gcm(ciphertext, decryptionKey.key);
+  }
+  return null;
 }
-async function terminateChild(child) {
-  if (child.exitCode !== null) {
-    return;
+function decryptAes128Cbc(ciphertext, key) {
+  try {
+    const iv = Buffer.alloc(16, 32);
+    const decipher = crypto.createDecipheriv("aes-128-cbc", key, iv);
+    let decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    if (decrypted.length > CHROME_HMAC_PREFIX_LENGTH && containsNonPrintableAscii(decrypted, CHROME_HMAC_PREFIX_LENGTH)) {
+      decrypted = decrypted.subarray(CHROME_HMAC_PREFIX_LENGTH);
+    }
+    if (containsNonPrintableAscii(decrypted, decrypted.length)) {
+      return null;
+    }
+    return decrypted.toString("utf8");
+  } catch {
+    return null;
   }
+}
+function decryptAes256Gcm(ciphertext, key) {
   try {
-    child.kill("SIGKILL");
+    const nonce = ciphertext.subarray(0, 12);
+    const authTag = ciphertext.subarray(ciphertext.length - 16);
+    const encrypted = ciphertext.subarray(12, ciphertext.length - 16);
+    const decipher = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+    if (containsNonPrintableAscii(decrypted, decrypted.length)) {
+      return null;
+    }
+    return decrypted.toString("utf8");
   } catch {
-    return;
+    return null;
   }
-  await sleep4(50);
 }
-async function waitForProcessExit2(pid, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!isProcessRunning(pid)) {
+function containsNonPrintableAscii(buffer, length) {
+  const end = Math.min(length, buffer.length);
+  for (let i = 0; i < end; i++) {
+    const byte = buffer[i];
+    if (byte < 32 || byte > 126) {
       return true;
     }
-    await sleep4(50);
   }
-  return !isProcessRunning(pid);
+  return false;
 }
-function normalizePath(value) {
-  return path6.resolve(expandHome(value)).replaceAll("\\", "/").toLowerCase();
+function chromeDateToUnixSeconds(chromeTimestamp) {
+  const ts = BigInt(chromeTimestamp);
+  if (ts <= 0n) {
+    return -1;
+  }
+  return Number((ts - CHROME_EPOCH_OFFSET) / 1000000n);
 }
-async function sleep4(ms) {
-  await new Promise((resolve5) => setTimeout(resolve5, ms));
+function chromeSameSiteToString(value) {
+  const v = Number(value);
+  if (v === 0) return "None";
+  if (v === 1) return "Lax";
+  if (v === 2) return "Strict";
+  return void 0;
 }
 
 // src/cloud/cookie-sync.ts
@@ -32072,14 +32891,14 @@ function toPortableBrowserProfileCookieRecord(cookie) {
   if (!name || !domain) {
     return null;
   }
-  const path13 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
+  const path15 = 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: path13,
+    path: path15,
     secure: cookie.secure,
     httpOnly: cookie.httpOnly,
     ...sameSite === void 0 ? {} : { sameSite },
@@ -32095,114 +32914,48 @@ function normalizeSameSite(value) {
   return void 0;
 }
 
-// src/cloud/portable-cookie-snapshot.ts
-var gzip = util.promisify(zlib.gzip);
-async function capturePortableBrowserProfileSnapshot(input = {}) {
-  const attached = input.attachEndpoint ? await inspectCdpEndpoint({
-    endpoint: input.attachEndpoint,
-    ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
-  }) : await selectAttachBrowserCandidate({
-    ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
-  });
-  const browser = await enginePlaywright.connectPlaywrightChromiumBrowser({
-    url: attached.endpoint
-  });
-  try {
-    const context = browser.contexts()[0];
-    if (!context) {
-      throw new Error("Attached browser did not expose a default browser context.");
-    }
-    const prepared = prepareBrowserProfileSyncCookies({
-      cookies: await context.cookies(),
-      ...input.domains === void 0 ? {} : { domains: input.domains }
-    });
-    if (prepared.cookies.length === 0) {
-      throw new Error("No syncable cookies found for the selected browser and scope.");
-    }
-    const browserVersion = browser.version();
-    const source = parseSnapshotSource(attached.browser ?? browserVersion);
-    return {
-      version: "portable-cookies-v1",
-      source: {
-        browserFamily: "chromium",
-        ...source.browserName === void 0 ? {} : { browserName: source.browserName },
-        ...source.browserMajor === void 0 ? {} : { browserMajor: source.browserMajor },
-        ...input.browserBrand === void 0 ? {} : { browserBrand: input.browserBrand },
-        ...input.captureMethod === void 0 ? {} : { captureMethod: input.captureMethod },
-        platform: normalizePlatform(process.platform),
-        capturedAt: Date.now()
-      },
-      cookies: prepared.cookies
-    };
-  } finally {
-    await browser.close().catch(() => void 0);
-  }
-}
-async function encodePortableBrowserProfileSnapshot(snapshot) {
-  return gzip(Buffer.from(JSON.stringify(snapshot), "utf8"));
-}
-function parseSnapshotSource(value) {
-  if (!value) {
-    return {};
-  }
-  const trimmed = value.trim();
-  const browserName = trimmed.split("/")[0]?.trim() || void 0;
-  const majorMatch = trimmed.match(/(\d+)/);
-  return {
-    ...browserName === void 0 ? {} : { browserName },
-    ...majorMatch?.[1] === void 0 ? {} : { browserMajor: majorMatch[1] }
-  };
-}
-function normalizePlatform(platform) {
-  if (platform === "darwin") return "macos";
-  if (platform === "win32") return "windows";
-  return platform;
-}
-
 // src/cloud/profile-sync.ts
+var gzip = util.promisify(zlib.gzip);
 var DEFAULT_POLL_INTERVAL_MS = 1e3;
 var DEFAULT_POLL_TIMEOUT_MS = 5 * 6e4;
 async function syncBrowserProfileCookies(client, input) {
-  const resolved = await resolveCookieCaptureStrategy({
-    ...input.attachEndpoint === void 0 ? {} : { attachEndpoint: input.attachEndpoint },
+  const result = await readBrowserCookies({
     ...input.brandId === void 0 ? {} : { brandId: input.brandId },
     ...input.userDataDir === void 0 ? {} : { userDataDir: input.userDataDir },
-    ...input.profileDirectory === void 0 ? {} : { profileDirectory: input.profileDirectory },
-    ...input.executablePath === void 0 ? {} : { executablePath: input.executablePath },
-    ...input.strategy === void 0 ? {} : { strategy: input.strategy },
-    ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
+    ...input.profileDirectory === void 0 ? {} : { profileDirectory: input.profileDirectory }
   });
-  const shouldRestoreBrowser = (input.restoreBrowser ?? true) && resolved.strategy === "managed-relaunch";
-  let captureSource;
-  try {
-    captureSource = await acquireCdpEndpoint(resolved);
-    const snapshot = await capturePortableBrowserProfileSnapshot({
-      attachEndpoint: captureSource.cdpEndpoint,
-      ...captureSource.brandId === void 0 ? {} : { browserBrand: captureSource.brandId },
-      captureMethod: captureSource.strategy,
-      ...input.domains === void 0 ? {} : { domains: input.domains },
-      ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
-    });
-    const payload = await encodePortableBrowserProfileSnapshot(snapshot);
-    const created = await client.createBrowserProfileImport({
-      profileId: input.profileId
-    });
-    if (payload.length > created.maxUploadBytes) {
-      throw new Error(
-        `Compressed cookie snapshot is ${String(payload.length)} bytes, exceeding the ${String(created.maxUploadBytes)} byte upload limit.`
-      );
-    }
-    const uploaded = await client.uploadBrowserProfileImportPayload({
-      uploadUrl: created.uploadUrl,
-      payload
-    });
-    return uploaded.status === "ready" ? uploaded : waitForBrowserProfileImport(client, created.importId);
-  } finally {
-    await captureSource?.cleanup().catch(() => void 0);
-    if (shouldRestoreBrowser && resolved.executablePath !== void 0) {
-      relaunchBrowserNormally(resolved.executablePath);
-    }
+  const prepared = prepareBrowserProfileSyncCookies({
+    cookies: result.cookies,
+    ...input.domains === void 0 ? {} : { domains: input.domains }
+  });
+  if (prepared.cookies.length === 0) {
+    throw new Error("No syncable cookies found for the selected browser and scope.");
+  }
+  const snapshot = {
+    version: "portable-cookies-v1",
+    source: {
+      browserFamily: "chromium",
+      browserBrand: result.brandId,
+      captureMethod: "sqlite",
+      platform: normalizePlatform(process.platform),
+      capturedAt: Date.now()
+    },
+    cookies: prepared.cookies
+  };
+  const payload = await gzip(Buffer.from(JSON.stringify(snapshot), "utf8"));
+  const created = await client.createBrowserProfileImport({
+    profileId: input.profileId
+  });
+  if (payload.length > created.maxUploadBytes) {
+    throw new Error(
+      `Compressed cookie snapshot is ${String(payload.length)} bytes, exceeding the ${String(created.maxUploadBytes)} byte upload limit.`
+    );
   }
+  const uploaded = await client.uploadBrowserProfileImportPayload({
+    uploadUrl: created.uploadUrl,
+    payload
+  });
+  return uploaded.status === "ready" ? uploaded : waitForBrowserProfileImport(client, created.importId);
 }
 async function waitForBrowserProfileImport(client, importId) {
   const deadline = Date.now() + DEFAULT_POLL_TIMEOUT_MS;
@@ -32214,12 +32967,17 @@ async function waitForBrowserProfileImport(client, importId) {
     if (current.status === "failed") {
       throw new Error(current.error ?? "Browser profile sync failed.");
     }
-    await sleep5(DEFAULT_POLL_INTERVAL_MS);
+    await sleep4(DEFAULT_POLL_INTERVAL_MS);
   }
   throw new Error(`Timed out waiting for browser profile sync "${importId}" to finish.`);
 }
-async function sleep5(ms) {
-  await new Promise((resolve5) => setTimeout(resolve5, ms));
+function normalizePlatform(platform) {
+  if (platform === "darwin") return "macos";
+  if (platform === "win32") return "windows";
+  return platform;
+}
+async function sleep4(ms) {
+  await new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
 // src/cloud/client.ts
@@ -32239,7 +32997,8 @@ var OpensteerCloudClient = class {
         ...input.name === void 0 ? {} : { name: input.name },
         ...input.browser === void 0 ? {} : { browser: input.browser },
         ...input.context === void 0 ? {} : { context: input.context },
-        ...input.browserProfile === void 0 ? {} : { browserProfile: input.browserProfile }
+        ...input.browserProfile === void 0 ? {} : { browserProfile: input.browserProfile },
+        ...input.observability === void 0 ? {} : { observability: input.observability }
       }
     });
     return await response.json();
@@ -32417,8 +33176,8 @@ var OpensteerCloudClient = class {
   }
 };
 function delay(ms) {
-  return new Promise((resolve5) => {
-    setTimeout(resolve5, ms);
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
   });
 }
 function wrapCloudFetchError(error, input) {
@@ -32441,17 +33200,17 @@ function wrapCloudFetchError(error, input) {
 function resolveCloudConfig(input = {}) {
   const provider = resolveOpensteerProvider({
     ...input.provider === void 0 ? {} : { provider: input.provider },
-    ...input.environmentProvider === void 0 ? {} : { environmentProvider: input.environmentProvider }
+    ...input.environment?.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: input.environment.OPENSTEER_PROVIDER }
   });
   if (provider.mode !== "cloud") {
     return void 0;
   }
   const cloudProvider = input.provider?.mode === "cloud" ? input.provider : void 0;
-  const apiKey = cloudProvider?.apiKey ?? process.env.OPENSTEER_API_KEY;
+  const apiKey = cloudProvider?.apiKey ?? input.environment?.OPENSTEER_API_KEY;
   if (!apiKey || apiKey.trim().length === 0) {
     throw new Error("provider=cloud requires OPENSTEER_API_KEY or provider.apiKey.");
   }
-  const baseUrl = cloudProvider?.baseUrl ?? process.env.OPENSTEER_BASE_URL;
+  const baseUrl = cloudProvider?.baseUrl ?? input.environment?.OPENSTEER_BASE_URL;
   if (!baseUrl || baseUrl.trim().length === 0) {
     throw new Error("provider=cloud requires OPENSTEER_BASE_URL or provider.baseUrl.");
   }
@@ -32553,9 +33312,9 @@ var OpensteerCloudAutomationClient = class {
       sentAt: Date.now(),
       ...input === void 0 ? {} : { input }
     };
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve4, reject) => {
       this.pending.set(requestId, {
-        resolve: (value) => resolve5(value),
+        resolve: (value) => resolve4(value),
         reject
       });
       try {
@@ -32618,8 +33377,8 @@ var OpensteerCloudAutomationClient = class {
       pending.reject(new Error(`automation connection closed before ${requestId} completed`));
     }
     this.pending.clear();
-    await new Promise((resolve5) => {
-      socket.once("close", () => resolve5());
+    await new Promise((resolve4) => {
+      socket.once("close", () => resolve4());
       socket.close();
     }).catch(() => void 0);
   }
@@ -32661,8 +33420,8 @@ var OpensteerCloudAutomationClient = class {
       }
       this.pending.clear();
     });
-    await new Promise((resolve5, reject) => {
-      socket.once("open", () => resolve5());
+    await new Promise((resolve4, reject) => {
+      socket.once("open", () => resolve4());
       socket.once("error", reject);
     });
     this.send({
@@ -33003,6 +33762,7 @@ var CloudSessionProxy = class {
   workspace;
   cleanupRootOnClose;
   cloud;
+  observability;
   sessionId;
   sessionBaseUrl;
   client;
@@ -33011,8 +33771,9 @@ var CloudSessionProxy = class {
   constructor(cloud, options = {}) {
     this.cloud = cloud;
     this.workspace = options.workspace;
-    this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path6__default.default.join(os.tmpdir(), `${TEMPORARY_CLOUD_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
-      rootDir: path6__default.default.resolve(options.rootDir ?? process.cwd()),
+    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()),
       workspace: this.workspace
     }));
     this.cleanupRootOnClose = options.cleanupRootOnClose ?? this.workspace === void 0;
@@ -33355,6 +34116,7 @@ var CloudSessionProxy = class {
       ...this.workspace === void 0 ? {} : { name: this.workspace },
       ...input.launch === void 0 ? {} : { browser: input.launch },
       ...input.context === void 0 ? {} : { context: input.context },
+      ...this.observability === void 0 ? {} : { observability: this.observability },
       ...resolveCloudBrowserProfile(this.cloud, input) === void 0 ? {} : { browserProfile: resolveCloudBrowserProfile(this.cloud, input) }
     });
     const record = {
@@ -33452,16 +34214,17 @@ function isMissingCloudSessionError(error) {
 
 // src/sdk/runtime-resolution.ts
 function resolveOpensteerRuntimeConfig(input = {}) {
+  const environment = input.environment ?? process.env;
   const provider = resolveOpensteerProvider({
     ...input.provider === void 0 ? {} : { provider: input.provider },
-    ...input.environmentProvider === void 0 ? {} : { environmentProvider: input.environmentProvider }
+    ...environment.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: environment.OPENSTEER_PROVIDER }
   });
   if (provider.mode === "cloud") {
     return {
       provider,
       cloud: resolveCloudConfig({
         ...input.provider === void 0 ? {} : { provider: input.provider },
-        ...input.environmentProvider === void 0 ? {} : { environmentProvider: input.environmentProvider }
+        environment
       })
     };
   }
@@ -33472,7 +34235,7 @@ function createOpensteerSemanticRuntime(input = {}) {
   const engine = input.engine ?? runtimeOptions.engineName ?? DEFAULT_OPENSTEER_ENGINE;
   const config = resolveOpensteerRuntimeConfig({
     ...input.provider === void 0 ? {} : { provider: input.provider },
-    ...process.env.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: process.env.OPENSTEER_PROVIDER }
+    ...input.environment === void 0 ? {} : { environment: input.environment }
   });
   assertProviderSupportsEngine(config.provider.mode, engine);
   if (config.provider.mode === "cloud") {
@@ -33480,7 +34243,8 @@ function createOpensteerSemanticRuntime(input = {}) {
       ...runtimeOptions.rootDir === void 0 ? {} : { rootDir: runtimeOptions.rootDir },
       ...runtimeOptions.rootPath === void 0 ? {} : { rootPath: runtimeOptions.rootPath },
       ...runtimeOptions.workspace === void 0 ? {} : { workspace: runtimeOptions.workspace },
-      ...runtimeOptions.cleanupRootOnClose === void 0 ? {} : { cleanupRootOnClose: runtimeOptions.cleanupRootOnClose }
+      ...runtimeOptions.cleanupRootOnClose === void 0 ? {} : { cleanupRootOnClose: runtimeOptions.cleanupRootOnClose },
+      ...runtimeOptions.observability === void 0 ? {} : { observability: runtimeOptions.observability }
     });
   }
   return new OpensteerRuntime({
@@ -33495,16 +34259,18 @@ var Opensteer = class {
   browserManager;
   browser;
   constructor(options = {}) {
+    const environment = resolveOpensteerEnvironment(options.rootDir);
     const { provider, engineName, ...runtimeOptions } = options;
     const runtimeConfig = resolveOpensteerRuntimeConfig({
       ...provider === void 0 ? {} : { provider },
-      ...process.env.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: process.env.OPENSTEER_PROVIDER }
+      environment
     });
     if (runtimeConfig.provider.mode === "cloud") {
       this.browserManager = void 0;
       this.runtime = createOpensteerSemanticRuntime({
         ...provider === void 0 ? {} : { provider },
         ...engineName === void 0 ? {} : { engine: engineName },
+        environment,
         runtimeOptions: {
           ...runtimeOptions
         }
@@ -33524,6 +34290,7 @@ var Opensteer = class {
     this.runtime = createOpensteerSemanticRuntime({
       ...provider === void 0 ? {} : { provider },
       ...engineName === void 0 ? {} : { engine: engineName },
+      environment,
       runtimeOptions: {
         ...runtimeOptions,
         rootPath: this.browserManager.rootPath,
@@ -33865,7 +34632,7 @@ function normalizeTargetOptions(input) {
   };
 }
 function delay2(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
 exports.CloudSessionProxy = CloudSessionProxy;
@@ -33896,8 +34663,10 @@ exports.clearPersistedSessionRecord = clearPersistedSessionRecord;
 exports.cloneElementPath = cloneElementPath;
 exports.cloneReplayElementPath = cloneReplayElementPath;
 exports.cloneStructuralElementAnchor = cloneStructuralElementAnchor;
+exports.createArtifactStore = createArtifactStore;
 exports.createDomRuntime = createDomRuntime;
 exports.createFilesystemOpensteerWorkspace = createFilesystemOpensteerWorkspace;
+exports.createObservationStore = createObservationStore;
 exports.createOpensteerExtractionDescriptorStore = createOpensteerExtractionDescriptorStore;
 exports.createOpensteerSemanticRuntime = createOpensteerSemanticRuntime;
 exports.defaultFallbackPolicy = defaultFallbackPolicy;
@@ -33913,7 +34682,9 @@ exports.inspectCdpEndpoint = inspectCdpEndpoint;
 exports.isCurrentUrlField = isCurrentUrlField;
 exports.isValidCssAttributeKey = isValidCssAttributeKey;
 exports.listLocalChromeProfiles = listLocalChromeProfiles;
+exports.manifestToExternalBinaryLocation = manifestToExternalBinaryLocation;
 exports.normalizeExtractedValue = normalizeExtractedValue;
+exports.normalizeObservabilityConfig = normalizeObservabilityConfig;
 exports.normalizeOpensteerEngineName = normalizeOpensteerEngineName;
 exports.normalizeOpensteerProviderMode = normalizeOpensteerProviderMode;
 exports.normalizeWorkspaceId = normalizeWorkspaceId;