opensteer 0.9.6 → 0.9.8

package/dist/index.cjs

@@ -102,6 +102,11 @@ function stableJsonString(value) {
 
 // ../runtime-core/src/internal/filesystem.ts
 var LOCK_RETRY_DELAYS_MS = [1, 2, 5, 10, 20, 50];
+var LOCK_METADATA_FILENAME = "owner.json";
+var LOCK_METADATA_VERSION = 1;
+var LOCK_HEARTBEAT_INTERVAL_MS = 1e3;
+var LOCK_ORPHAN_GRACE_MS = 2e3;
+var LOCK_METADATALESS_STALE_MS = 3e4;
 function normalizeNonEmptyString(name, value) {
   const normalized = value.trim();
   if (normalized.length === 0) {
@@ -207,24 +212,119 @@ function isAlreadyExistsError(error) {
 }
 async function withFilesystemLock(lockPath, task) {
   await ensureDirectory(path10__default.default.dirname(lockPath));
+  const ownerToken = crypto.randomUUID();
   let attempt = 0;
   while (true) {
     try {
       await promises.mkdir(lockPath);
+      const acquiredAt = Date.now();
+      await writeLockMetadata(lockPath, {
+        version: LOCK_METADATA_VERSION,
+        ownerToken,
+        pid: process.pid,
+        acquiredAt,
+        heartbeatAt: acquiredAt
+      });
       break;
     } catch (error) {
       if (!isAlreadyExistsError(error)) {
         throw error;
       }
+      if (await tryRecoverFilesystemLock(lockPath)) {
+        attempt = 0;
+        continue;
+      }
       const delayMs = LOCK_RETRY_DELAYS_MS[Math.min(attempt, LOCK_RETRY_DELAYS_MS.length - 1)];
       attempt += 1;
       await new Promise((resolve4) => setTimeout(resolve4, delayMs));
     }
   }
+  const heartbeatTimer = setInterval(() => {
+    void touchLockMetadata(lockPath, ownerToken);
+  }, LOCK_HEARTBEAT_INTERVAL_MS);
+  heartbeatTimer.unref?.();
   try {
     return await task();
   } finally {
-    await promises.rm(lockPath, { recursive: true, force: true });
+    clearInterval(heartbeatTimer);
+    const metadata = await readLockMetadata(lockPath);
+    if (metadata?.ownerToken === ownerToken) {
+      await promises.rm(lockPath, { recursive: true, force: true });
+    }
+  }
+}
+async function tryRecoverFilesystemLock(lockPath) {
+  if (!await shouldRecoverFilesystemLock(lockPath)) {
+    return false;
+  }
+  await promises.rm(lockPath, { recursive: true, force: true });
+  return true;
+}
+async function shouldRecoverFilesystemLock(lockPath) {
+  const metadata = await readLockMetadata(lockPath);
+  if (metadata !== void 0) {
+    if (isProcessRunning(metadata.pid)) {
+      return false;
+    }
+    return Date.now() - metadata.heartbeatAt >= LOCK_ORPHAN_GRACE_MS;
+  }
+  const lockStat = await promises.stat(lockPath).catch(() => void 0);
+  if (lockStat === void 0) {
+    return false;
+  }
+  return Date.now() - lockStat.mtimeMs >= LOCK_METADATALESS_STALE_MS;
+}
+async function readLockMetadata(lockPath) {
+  const metadataPath = path10__default.default.join(lockPath, LOCK_METADATA_FILENAME);
+  if (!await pathExists(metadataPath)) {
+    return void 0;
+  }
+  try {
+    const parsed = await readJsonFile(metadataPath);
+    const pid = parsed.pid;
+    const acquiredAt = parsed.acquiredAt;
+    const heartbeatAt = parsed.heartbeatAt;
+    if (parsed.version !== LOCK_METADATA_VERSION || typeof parsed.ownerToken !== "string" || parsed.ownerToken.length === 0 || typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0 || typeof acquiredAt !== "number" || !Number.isFinite(acquiredAt) || typeof heartbeatAt !== "number" || !Number.isFinite(heartbeatAt)) {
+      return void 0;
+    }
+    return {
+      version: LOCK_METADATA_VERSION,
+      ownerToken: parsed.ownerToken,
+      pid,
+      acquiredAt,
+      heartbeatAt
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function writeLockMetadata(lockPath, metadata) {
+  try {
+    await writeJsonFileAtomic(path10__default.default.join(lockPath, LOCK_METADATA_FILENAME), metadata);
+  } catch (error) {
+    await promises.rm(lockPath, { recursive: true, force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function touchLockMetadata(lockPath, ownerToken) {
+  const metadata = await readLockMetadata(lockPath);
+  if (metadata === void 0 || metadata.ownerToken !== ownerToken) {
+    return;
+  }
+  await writeJsonFileAtomic(path10__default.default.join(lockPath, LOCK_METADATA_FILENAME), {
+    ...metadata,
+    heartbeatAt: Date.now()
+  }).catch(() => void 0);
+}
+function isProcessRunning(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
   }
 }
 
@@ -814,7 +914,7 @@ function isJsonValueEqual(expected, actual) {
 
 // ../protocol/src/version.ts
 var OPENSTEER_PROTOCOL_NAME = "opensteer";
-var OPENSTEER_PROTOCOL_COMPATIBILITY_REVISION = 2;
+var OPENSTEER_PROTOCOL_COMPATIBILITY_REVISION = 3;
 var OPENSTEER_PROTOCOL_VERSION = `0.${OPENSTEER_PROTOCOL_COMPATIBILITY_REVISION}.0`;
 var OPENSTEER_PROTOCOL_REST_BASE_PATH = `/api/v${OPENSTEER_PROTOCOL_COMPATIBILITY_REVISION}`;
 objectSchema(
@@ -1188,7 +1288,7 @@ var visualViewportSchema = objectSchema(
     required: ["origin", "offsetWithinLayoutViewport", "size"]
   }
 );
-var viewportMetricsSchema = objectSchema(
+objectSchema(
   {
     layoutViewport: layoutViewportSchema,
     visualViewport: visualViewportSchema,
@@ -1223,6 +1323,9 @@ var pageInfoSchema = objectSchema(
   {
     pageRef: pageRefSchema,
     sessionRef: sessionRefSchema,
+    targetId: stringSchema({
+      description: "Underlying browser target identifier when available."
+    }),
     openerPageRef: pageRefSchema,
     url: stringSchema({
       description: "Current main-frame URL."
@@ -2639,7 +2742,7 @@ var domSnapshotSchema = objectSchema(
     ]
   }
 );
-var hitTestResultSchema = objectSchema(
+objectSchema(
   {
     inputPoint: pointSchema,
     inputCoordinateSpace: coordinateSpaceSchema,
@@ -4092,39 +4195,14 @@ var opensteerTargetInputSchema = oneOfSchema(
     title: "OpensteerTargetInput"
   }
 );
-var opensteerResolvedTargetSchema = objectSchema(
-  {
-    pageRef: pageRefSchema,
-    frameRef: frameRefSchema,
-    documentRef: documentRefSchema,
-    documentEpoch: documentEpochSchema,
-    nodeRef: nodeRefSchema,
-    tagName: stringSchema(),
-    pathHint: stringSchema(),
-    persist: stringSchema(),
-    selectorUsed: stringSchema()
-  },
-  {
-    title: "OpensteerResolvedTarget",
-    required: [
-      "pageRef",
-      "frameRef",
-      "documentRef",
-      "documentEpoch",
-      "nodeRef",
-      "tagName",
-      "pathHint"
-    ]
-  }
-);
 var opensteerActionResultSchema = objectSchema(
   {
-    target: opensteerResolvedTargetSchema,
-    point: pointSchema
+    tagName: stringSchema({ minLength: 1 }),
+    persist: stringSchema({ minLength: 1 })
   },
   {
     title: "OpensteerActionResult",
-    required: ["target"]
+    required: ["tagName"]
   }
 );
 var opensteerSnapshotCounterSchema = objectSchema(
@@ -4170,16 +4248,14 @@ var opensteerSnapshotCounterSchema = objectSchema(
     ]
   }
 );
-var opensteerSessionStateSchema = objectSchema(
+var opensteerNavigationSummarySchema = objectSchema(
   {
-    sessionRef: sessionRefSchema,
-    pageRef: pageRefSchema,
     url: stringSchema(),
     title: stringSchema()
   },
   {
-    title: "OpensteerSessionState",
-    required: ["sessionRef", "pageRef", "url", "title"]
+    title: "OpensteerNavigationSummary",
+    required: ["url", "title"]
   }
 );
 var opensteerOpenInputSchema = objectSchema(
@@ -4247,6 +4323,17 @@ var opensteerPageCloseOutputSchema = objectSchema(
     required: ["closedPageRef", "pages"]
   }
 );
+var opensteerPageNewOutputSchema = objectSchema(
+  {
+    pageRef: pageRefSchema,
+    url: stringSchema(),
+    title: stringSchema()
+  },
+  {
+    title: "OpensteerPageNewOutput",
+    required: ["pageRef", "url", "title"]
+  }
+);
 var opensteerPageGotoInputSchema = objectSchema(
   {
     url: stringSchema(),
@@ -4633,72 +4720,28 @@ var opensteerComputerExecuteInputSchema = objectSchema(
     required: ["action"]
   }
 );
-var opensteerComputerTracePointSchema = objectSchema(
-  {
-    role: enumSchema(["point", "start", "end"]),
-    point: pointSchema,
-    hitTest: hitTestResultSchema,
-    target: opensteerResolvedTargetSchema
-  },
-  {
-    title: "OpensteerComputerTracePoint",
-    required: ["role", "point"]
-  }
-);
-var opensteerComputerTraceEnrichmentSchema = objectSchema(
-  {
-    points: arraySchema(opensteerComputerTracePointSchema)
-  },
-  {
-    title: "OpensteerComputerTraceEnrichment",
-    required: ["points"]
-  }
-);
-var opensteerComputerExecuteTimingSchema = objectSchema(
+var opensteerScreenshotSummarySchema = objectSchema(
   {
-    actionMs: integerSchema({ minimum: 0 }),
-    waitMs: integerSchema({ minimum: 0 }),
-    totalMs: integerSchema({ minimum: 0 })
-  },
-  {
-    title: "OpensteerComputerExecuteTiming",
-    required: ["actionMs", "waitMs", "totalMs"]
-  }
-);
-var opensteerComputerDisplayScaleSchema = objectSchema(
-  {
-    x: numberSchema({ exclusiveMinimum: 0 }),
-    y: numberSchema({ exclusiveMinimum: 0 })
+    payload: externalBinaryLocationSchema,
+    format: screenshotFormatSchema,
+    size: sizeSchema,
+    coordinateSpace: coordinateSpaceSchema,
+    clip: rectSchema
   },
   {
-    title: "OpensteerComputerDisplayScale",
-    required: ["x", "y"]
+    title: "OpensteerScreenshotSummary",
+    required: ["payload", "format", "size", "coordinateSpace"]
   }
 );
 var opensteerComputerExecuteOutputSchema = objectSchema(
   {
-    action: opensteerComputerActionSchema,
-    pageRef: pageRefSchema,
-    screenshot: screenshotArtifactSchema,
-    displayViewport: viewportMetricsSchema,
-    nativeViewport: viewportMetricsSchema,
-    displayScale: opensteerComputerDisplayScaleSchema,
-    events: arraySchema(opensteerEventSchema),
-    timing: opensteerComputerExecuteTimingSchema,
-    trace: opensteerComputerTraceEnrichmentSchema
+    url: stringSchema(),
+    title: stringSchema(),
+    screenshot: opensteerScreenshotSummarySchema
   },
   {
     title: "OpensteerComputerExecuteOutput",
-    required: [
-      "action",
-      "pageRef",
-      "screenshot",
-      "displayViewport",
-      "nativeViewport",
-      "displayScale",
-      "events",
-      "timing"
-    ]
+    required: ["url", "title", "screenshot"]
   }
 );
 function assertValidSemanticOperationInput(name, input) {
@@ -4724,7 +4767,7 @@ var opensteerSemanticOperationSpecificationsBase = [
     name: "session.open",
     description: "Open or resume the current Opensteer session and primary page.",
     inputSchema: opensteerOpenInputSchema,
-    outputSchema: opensteerSessionStateSchema,
+    outputSchema: opensteerNavigationSummarySchema,
     requiredCapabilities: ["sessions.manage", "pages.manage"],
     resolveRequiredCapabilities: (input) => input.url === void 0 ? ["sessions.manage", "pages.manage"] : ["sessions.manage", "pages.manage", "pages.navigate"]
   }),
@@ -4739,7 +4782,7 @@ var opensteerSemanticOperationSpecificationsBase = [
     name: "page.new",
     description: "Create and optionally navigate a new top-level page in the current session.",
     inputSchema: opensteerPageNewInputSchema,
-    outputSchema: opensteerSessionStateSchema,
+    outputSchema: opensteerPageNewOutputSchema,
     requiredCapabilities: ["pages.manage"],
     resolveRequiredCapabilities: (input) => input.url === void 0 ? ["pages.manage"] : ["pages.manage", "pages.navigate"]
   }),
@@ -4747,7 +4790,7 @@ var opensteerSemanticOperationSpecificationsBase = [
     name: "page.activate",
     description: "Activate an existing top-level page in the current session.",
     inputSchema: opensteerPageActivateInputSchema,
-    outputSchema: opensteerSessionStateSchema,
+    outputSchema: opensteerNavigationSummarySchema,
     requiredCapabilities: ["pages.manage", "inspect.pages"]
   }),
   defineSemanticOperationSpec({
@@ -4761,7 +4804,7 @@ var opensteerSemanticOperationSpecificationsBase = [
     name: "page.goto",
     description: "Navigate the current Opensteer page to a new URL.",
     inputSchema: opensteerPageGotoInputSchema,
-    outputSchema: opensteerSessionStateSchema,
+    outputSchema: opensteerNavigationSummarySchema,
     requiredCapabilities: ["pages.navigate"]
   }),
   defineSemanticOperationSpec({
@@ -6163,6 +6206,9 @@ var FilesystemSessionSink = class {
     this.store = store;
     this.sessionId = sessionId;
   }
+  configure(input) {
+    return this.store.configureSession(this.sessionId, input);
+  }
   append(input) {
     return this.store.appendEvent(this.sessionId, input);
   }
@@ -6193,40 +6239,14 @@ var FilesystemObservationStoreImpl = class {
     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);
-    });
+    await this.applySessionConfiguration(sessionId, config, openedAt);
     return new FilesystemSessionSink(this, sessionId);
   }
+  async configureSession(sessionId, input) {
+    const updatedAt = normalizeTimestamp("updatedAt", input.updatedAt ?? Date.now());
+    const config = normalizeObservabilityConfig(input.config);
+    await this.applySessionConfiguration(sessionId, config, updatedAt);
+  }
   async getSession(sessionId) {
     const manifestPath = this.sessionManifestPath(sessionId);
     if (!await pathExists(manifestPath)) {
@@ -6447,6 +6467,40 @@ var FilesystemObservationStoreImpl = class {
   sessionLockPath(sessionId) {
     return path10__default.default.join(this.sessionDirectory(sessionId), ".lock");
   }
+  async applySessionConfiguration(sessionId, config, timestamp) {
+    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: timestamp,
+          updatedAt: timestamp,
+          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, timestamp)
+      };
+      await writeJsonFileAtomic(this.sessionManifestPath(sessionId), patched);
+    });
+  }
   async reconcileSessionManifest(sessionId) {
     const session = await this.getSession(sessionId);
     if (session === void 0) {
@@ -6843,14 +6897,14 @@ var DEFAULT_SETTLE_DELAYS = {
   snapshot: 0
 };
 var DOM_ACTION_VISUAL_STABILITY_PROFILES = {
-  "dom.click": { settleMs: 750, scope: "visible-frames", timeoutMs: 7e3 },
-  "dom.input": { settleMs: 750, scope: "visible-frames", timeoutMs: 7e3 },
-  "dom.scroll": { settleMs: 600, scope: "visible-frames", timeoutMs: 7e3 },
+  "dom.click": { settleMs: 750, scope: "main-frame", timeoutMs: 7e3 },
+  "dom.input": { settleMs: 750, scope: "main-frame", timeoutMs: 7e3 },
+  "dom.scroll": { settleMs: 600, scope: "main-frame", timeoutMs: 7e3 },
   "dom.hover": { settleMs: 200, scope: "main-frame", timeoutMs: 2500 }
 };
 var DEFAULT_DOM_ACTION_VISUAL_STABILITY_PROFILE = {
   settleMs: 750,
-  scope: "visible-frames",
+  scope: "main-frame",
   timeoutMs: 7e3
 };
 var NAVIGATION_VISUAL_STABILITY_PROFILE = {
@@ -6874,6 +6928,7 @@ var defaultDomActionSettleObserver = {
         pageRef: input.pageRef,
         timeoutMs: effectiveTimeout,
         settleMs: profile.settleMs,
+        ...input.observedMutationQuietMs === void 0 ? {} : { initialQuietMs: input.observedMutationQuietMs },
         scope: profile.scope
       });
       return true;
@@ -6894,15 +6949,20 @@ var defaultNavigationSettleObserver = {
       return false;
     }
     try {
-      const startedAt = Date.now();
-      await input.engine.waitForPostLoadQuiet({
-        pageRef: input.pageRef,
-        timeoutMs: effectiveTimeout,
-        quietMs: DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS,
-        captureWindowMs: Math.min(NAVIGATION_POST_LOAD_CAPTURE_WINDOW_MS, effectiveTimeout),
-        signal: input.signal
-      });
-      const visualTimeout = Math.max(0, effectiveTimeout - (Date.now() - startedAt));
+      let visualTimeout = effectiveTimeout;
+      let initialQuietMs = input.observedMutationQuietMs ?? 0;
+      if (!input.postLoadHandled) {
+        const startedAt = Date.now();
+        await input.engine.waitForPostLoadQuiet({
+          pageRef: input.pageRef,
+          timeoutMs: effectiveTimeout,
+          quietMs: DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS,
+          captureWindowMs: Math.min(NAVIGATION_POST_LOAD_CAPTURE_WINDOW_MS, effectiveTimeout),
+          signal: input.signal
+        });
+        visualTimeout = Math.max(0, effectiveTimeout - (Date.now() - startedAt));
+        initialQuietMs = Math.max(initialQuietMs, DEFAULT_POST_LOAD_TRACKER_QUIET_WINDOW_MS);
+      }
       if (visualTimeout <= 0) {
         return true;
       }
@@ -6910,6 +6970,7 @@ var defaultNavigationSettleObserver = {
         pageRef: input.pageRef,
         timeoutMs: visualTimeout,
         settleMs: profile.settleMs,
+        ...initialQuietMs <= 0 ? {} : { initialQuietMs },
         scope: profile.scope
       });
       return true;
@@ -7499,7 +7560,9 @@ function resolveExtractedValueInContext(normalizedValue, options) {
 function stripPositionClauses(nodes) {
   return (nodes || []).map((node) => ({
     ...node,
-    match: (node.match || []).filter((clause) => clause.kind !== "position" && clause.kind !== "text")
+    match: (node.match || []).filter(
+      (clause) => clause.kind !== "position" && clause.kind !== "text"
+    )
   }));
 }
 function dedupeSelectors(selectors) {
@@ -8993,7 +9056,7 @@ var DomActionExecutor = class {
         ...snapshot === void 0 ? {} : { snapshot },
         signal: timeout.signal,
         remainingMs: () => timeout.remainingMs(),
-        policySettle: async (targetPageRef, trigger) => {
+        policySettle: async (targetPageRef, trigger, boundary2) => {
           try {
             await settleWithPolicy(this.options.policy.settle, {
               operation,
@@ -9001,7 +9064,9 @@ var DomActionExecutor = class {
               engine: this.options.engine,
               pageRef: targetPageRef,
               signal: timeout.signal,
-              remainingMs: timeout.remainingMs()
+              remainingMs: timeout.remainingMs(),
+              ...boundary2?.observedMutationQuietMs === void 0 ? {} : { observedMutationQuietMs: boundary2.observedMutationQuietMs },
+              ...boundary2?.postLoadHandled === true ? { postLoadHandled: true } : {}
             });
           } catch (error) {
             if (snapshot !== void 0 && isSoftSettleTimeoutError(error, timeout.signal)) {
@@ -9769,7 +9834,9 @@ var DefaultDomRuntime = class {
         `Unable to resolve structural anchor "${buildPathSelectorHint(anchor)}" in the current session`
       );
     }
-    const replayPath = await this.tryBuildPathFromNode(context.snapshot, target.node, { enableTextMatch: true });
+    const replayPath = await this.tryBuildPathFromNode(context.snapshot, target.node, {
+      enableTextMatch: true
+    });
     return this.createResolvedTarget(source, context.snapshot, target.node, anchor, {
       ...persist === void 0 ? {} : { persist },
       ...replayPath === void 0 ? {} : { replayPath }
@@ -10389,29 +10456,29 @@ function buildVariantDescriptorFromCluster(descriptors) {
   const keyStats = /* @__PURE__ */ new Map();
   for (const descriptor of descriptors) {
     for (const field of descriptor.fields) {
-      const stat2 = keyStats.get(field.path) ?? {
+      const stat3 = keyStats.get(field.path) ?? {
         indices: /* @__PURE__ */ new Set(),
         pathNodes: [],
         attributes: [],
         sources: []
       };
-      stat2.indices.add(descriptor.index);
+      stat3.indices.add(descriptor.index);
       if (isPersistedOpensteerExtractionValueNode(field.node)) {
-        stat2.pathNodes.push(field.node.$path);
-        stat2.attributes.push(field.node.attribute);
+        stat3.pathNodes.push(field.node.$path);
+        stat3.attributes.push(field.node.attribute);
       } else if (isPersistedOpensteerExtractionSourceNode(field.node)) {
-        stat2.sources.push("current_url");
+        stat3.sources.push("current_url");
       }
-      keyStats.set(field.path, stat2);
+      keyStats.set(field.path, stat3);
     }
   }
   const mergedFields = [];
-  for (const [fieldPath, stat2] of keyStats) {
-    if (stat2.indices.size < threshold) {
+  for (const [fieldPath, stat3] of keyStats) {
+    if (stat3.indices.size < threshold) {
       continue;
     }
-    if (stat2.pathNodes.length >= threshold) {
-      let mergedFieldPath = stat2.pathNodes.length === 1 ? sanitizeElementPath(stat2.pathNodes[0]) : mergeElementPathsByMajority(stat2.pathNodes);
+    if (stat3.pathNodes.length >= threshold) {
+      let mergedFieldPath = stat3.pathNodes.length === 1 ? sanitizeElementPath(stat3.pathNodes[0]) : mergeElementPathsByMajority(stat3.pathNodes);
       if (!mergedFieldPath) {
         continue;
       }
@@ -10419,8 +10486,8 @@ function buildVariantDescriptorFromCluster(descriptors) {
         mergedFieldPath = relaxPathForSingleSample(mergedFieldPath, "field");
       }
       mergedFieldPath = minimizePathMatchClauses(mergedFieldPath, "field");
-      const attrThreshold = stat2.pathNodes.length === 1 ? 1 : majorityThreshold(stat2.pathNodes.length);
-      const attribute = pickModeString(stat2.attributes, attrThreshold);
+      const attrThreshold = stat3.pathNodes.length === 1 ? 1 : majorityThreshold(stat3.pathNodes.length);
+      const attribute = pickModeString(stat3.attributes, attrThreshold);
       mergedFields.push({
         path: fieldPath,
         node: createValueNode({
@@ -10430,7 +10497,7 @@ function buildVariantDescriptorFromCluster(descriptors) {
       });
       continue;
     }
-    const dominantSource = pickModeString(stat2.sources, threshold);
+    const dominantSource = pickModeString(stat3.sources, threshold);
     if (dominantSource === "current_url") {
       mergedFields.push({
         path: fieldPath,
@@ -12013,9 +12080,9 @@ async function getProcessLiveness(owner) {
   if (typeof startedAtMs === "number") {
     return hasMatchingProcessStartTime(owner.processStartedAtMs, startedAtMs) ? "live" : "dead";
   }
-  return isProcessRunning(owner.pid) ? "unknown" : "dead";
+  return isProcessRunning2(owner.pid) ? "unknown" : "dead";
 }
-function isProcessRunning(pid) {
+function isProcessRunning2(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -13435,11 +13502,31 @@ async function writePersistedSessionRecord(rootPath, record) {
 async function clearPersistedSessionRecord(rootPath, provider) {
   await promises.rm(resolveLiveSessionRecordPath(rootPath, provider), { force: true });
 }
+function getPersistedLocalBrowserSessionOwnership(record) {
+  return record.ownership === "attached" ? "attached" : "owned";
+}
+async function isAttachedLocalBrowserSessionReachable(record) {
+  if (getPersistedLocalBrowserSessionOwnership(record) !== "attached") {
+    return false;
+  }
+  if (record.engine !== "playwright" || record.endpoint === void 0) {
+    return false;
+  }
+  try {
+    await inspectCdpEndpoint({
+      endpoint: record.endpoint,
+      timeoutMs: 1500
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function isPersistedCloudSessionRecord(value) {
-  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "cloud" && typeof value.sessionId === "string" && value.sessionId.length > 0 && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
+  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "cloud" && typeof value.sessionId === "string" && value.sessionId.length > 0 && (value.activePageUrl === void 0 || typeof value.activePageUrl === "string") && (value.activePageTitle === void 0 || typeof value.activePageTitle === "string") && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
 }
 function isPersistedLocalBrowserSessionRecord(value) {
-  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "local" && (value.engine === "playwright" || value.engine === "abp") && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt) && typeof value.userDataDir === "string" && value.userDataDir.length > 0;
+  return value.layout === OPENSTEER_LIVE_SESSION_LAYOUT && value.version === OPENSTEER_LIVE_SESSION_VERSION && value.provider === "local" && (value.engine === "playwright" || value.engine === "abp") && (value.ownership === void 0 || value.ownership === "owned" || value.ownership === "attached") && (value.activePageUrl === void 0 || typeof value.activePageUrl === "string") && (value.activePageTitle === void 0 || typeof value.activePageTitle === "string") && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt) && typeof value.userDataDir === "string" && value.userDataDir.length > 0;
 }
 function resolveOpensteerStateDir() {
   const explicit = process.env.OPENSTEER_HOME?.trim();
@@ -13828,19 +13915,40 @@ function delay(ms) {
 var OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT = "opensteer-local-view-session";
 var OPENSTEER_LOCAL_VIEW_SESSION_VERSION = 1;
 function buildLocalViewSessionId(input) {
+  const ownership = input.ownership ?? "owned";
+  const identity = ownership === "attached" ? input.endpoint ?? input.remoteDebuggingUrl ?? input.baseUrl ?? "attached" : `pid:${String(input.pid ?? 0)}`;
   const hash = crypto.createHash("sha256").update(`${input.rootPath}
-${String(input.pid)}
+${ownership}
+${identity}
 ${String(input.startedAt)}`).digest("hex");
   return `local_${hash.slice(0, 24)}`;
 }
+function buildLocalViewSessionIdForRecord(input) {
+  const ownership = getPersistedLocalBrowserSessionOwnership(input.live);
+  if (ownership === "attached") {
+    return buildLocalViewSessionId({
+      rootPath: input.rootPath,
+      ownership,
+      startedAt: input.live.startedAt,
+      ...input.live.endpoint === void 0 ? {} : { endpoint: input.live.endpoint },
+      ...input.live.baseUrl === void 0 ? {} : { baseUrl: input.live.baseUrl },
+      ...input.live.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: input.live.remoteDebuggingUrl }
+    });
+  }
+  return buildLocalViewSessionId({
+    rootPath: input.rootPath,
+    ownership,
+    startedAt: input.live.startedAt,
+    pid: input.live.pid
+  });
+}
 function createLocalViewSessionManifest(input) {
   return {
     layout: OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT,
     version: OPENSTEER_LOCAL_VIEW_SESSION_VERSION,
-    sessionId: buildLocalViewSessionId({
+    sessionId: buildLocalViewSessionIdForRecord({
       rootPath: input.rootPath,
-      pid: input.live.pid,
-      startedAt: input.live.startedAt
+      live: input.live
     }),
     rootPath: input.rootPath,
     ...input.workspace === void 0 ? {} : { workspace: input.workspace },
@@ -14041,7 +14149,7 @@ var OpensteerBrowserManager = class {
     }
     const liveRecord = await this.readLivePersistentBrowser(await this.ensureWorkspaceStore());
     return {
-      mode: this.mode,
+      mode: liveRecord?.ownership === "attached" ? "attach" : this.mode,
       engine: liveRecord?.engine ?? this.engineName,
       ...this.workspace === void 0 ? {} : { workspace: this.workspace },
       live: liveRecord !== void 0
@@ -14169,6 +14277,7 @@ var OpensteerBrowserManager = class {
       });
       const liveRecord = {
         mode: "persistent",
+        ownership: "owned",
         engine: "abp",
         baseUrl: launched.baseUrl,
         remoteDebuggingUrl: launched.remoteDebuggingUrl,
@@ -14255,11 +14364,78 @@ var OpensteerBrowserManager = class {
   }
   async createAttachEngine() {
     const endpoint = await resolveAttachEndpoint(this.browserOptions);
-    return this.createAttachedEngine({
-      endpoint,
-      ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
-      freshTab: this.browserOptions?.freshTab ?? true,
-      onDispose: async () => void 0
+    if (this.workspace === void 0) {
+      return this.createAttachedEngine({
+        endpoint,
+        ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
+        freshTab: this.browserOptions?.freshTab ?? true,
+        onDispose: async () => void 0
+      });
+    }
+    const workspace = await this.ensureWorkspaceStore();
+    return workspace.lock(async () => {
+      const live = await this.readLivePersistentBrowser(workspace);
+      if (live) {
+        if (live.engine !== "playwright") {
+          throw new Error(
+            `workspace "${this.workspace}" already has a live ${live.engine} browser. Close it before attaching a Playwright browser.`
+          );
+        }
+        if (live.ownership !== "attached") {
+          throw new Error(
+            `workspace "${this.workspace}" already has a live Opensteer-owned browser. Close it before attaching another browser.`
+          );
+        }
+        if (live.endpoint === void 0) {
+          throw new Error("workspace live browser record is missing a DevTools endpoint.");
+        }
+        if (live.endpoint !== endpoint) {
+          throw new Error(
+            `workspace "${this.workspace}" is already attached to a different browser endpoint. Close it before reattaching.`
+          );
+        }
+        await bestEffortRegisterLocalViewSession({
+          rootPath: workspace.rootPath,
+          ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+          live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
+          ownership: "attached"
+        });
+        return this.createAttachedEngine({
+          endpoint: live.endpoint,
+          ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
+          freshTab: this.browserOptions?.freshTab ?? true,
+          onDispose: async () => void 0
+        });
+      }
+      const liveRecord = {
+        mode: "persistent",
+        ownership: "attached",
+        engine: "playwright",
+        endpoint,
+        pid: 0,
+        startedAt: Date.now(),
+        userDataDir: workspace.browserUserDataDir
+      };
+      await this.writeLivePersistentBrowser(workspace, liveRecord);
+      const persistedLiveRecord = toPersistedLocalBrowserSessionRecord(this.workspace, liveRecord);
+      await bestEffortRegisterLocalViewSession({
+        rootPath: workspace.rootPath,
+        ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+        live: persistedLiveRecord,
+        ownership: "attached"
+      });
+      try {
+        return await this.createAttachedEngine({
+          endpoint,
+          ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
+          freshTab: this.browserOptions?.freshTab ?? true,
+          onDispose: async () => void 0
+        });
+      } catch (error) {
+        await this.unregisterLocalViewSessionForRecord(workspace.rootPath, persistedLiveRecord);
+        await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+        throw error;
+      }
     });
   }
   async createPersistentEngine() {
@@ -14279,7 +14455,7 @@ var OpensteerBrowserManager = class {
           rootPath: workspace.rootPath,
           ...this.workspace === void 0 ? {} : { workspace: this.workspace },
           live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
-          ownership: "owned"
+          ownership: live.ownership
         });
         return this.createAttachedEngine({
           endpoint: live.endpoint,
@@ -14295,6 +14471,7 @@ var OpensteerBrowserManager = class {
       });
       const liveRecord = {
         mode: "persistent",
+        ownership: "owned",
         engine: "playwright",
         endpoint: launched.endpoint,
         pid: launched.pid,
@@ -14424,7 +14601,20 @@ var OpensteerBrowserManager = class {
     if (live === void 0) {
       return void 0;
     }
-    if (!isProcessRunning(live.pid)) {
+    if (live.ownership === "attached") {
+      const attachedRecord = toPersistedLocalBrowserSessionRecord(this.workspace, live);
+      if (!await isAttachedLocalBrowserSessionReachable(attachedRecord)) {
+        await this.unregisterLocalViewSessionForRecord(workspace.rootPath, attachedRecord);
+        await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+        return void 0;
+      }
+      return live;
+    }
+    if (!isProcessRunning2(live.pid)) {
+      await this.unregisterLocalViewSessionForRecord(
+        workspace.rootPath,
+        toPersistedLocalBrowserSessionRecord(this.workspace, live)
+      );
       await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
       return void 0;
     }
@@ -14472,6 +14662,10 @@ var OpensteerBrowserManager = class {
       workspace.rootPath,
       toPersistedLocalBrowserSessionRecord(this.workspace, live)
     );
+    if (live.ownership === "attached") {
+      await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+      return;
+    }
     if (live.engine === "playwright") {
       if (live.endpoint !== void 0) {
         await requestBrowserClose(live.endpoint).catch(() => void 0);
@@ -14500,10 +14694,18 @@ var OpensteerBrowserManager = class {
   }
   async unregisterLocalViewSessionForRecord(rootPath, record) {
     await bestEffortUnregisterLocalViewSession(
-      buildLocalViewSessionId({
+      getPersistedLocalBrowserSessionOwnership(record) === "attached" ? buildLocalViewSessionId({
         rootPath,
-        pid: record.pid,
-        startedAt: record.startedAt
+        startedAt: record.startedAt,
+        ownership: "attached",
+        ...record.endpoint === void 0 ? {} : { endpoint: record.endpoint },
+        ...record.baseUrl === void 0 ? {} : { baseUrl: record.baseUrl },
+        ...record.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: record.remoteDebuggingUrl }
+      }) : buildLocalViewSessionId({
+        rootPath,
+        startedAt: record.startedAt,
+        ownership: "owned",
+        pid: record.pid
       })
     );
   }
@@ -14538,6 +14740,7 @@ function toPersistedLocalBrowserSessionRecord(workspace, live) {
     version: 1,
     provider: "local",
     ...workspace === void 0 ? {} : { workspace },
+    ownership: live.ownership,
     engine: live.engine,
     ...live.endpoint === void 0 ? {} : { endpoint: live.endpoint },
     ...live.baseUrl === void 0 ? {} : { baseUrl: live.baseUrl },
@@ -14553,6 +14756,7 @@ function toPersistedLocalBrowserSessionRecord(workspace, live) {
 function toWorkspaceLiveBrowserRecord(record) {
   return {
     mode: "persistent",
+    ownership: getPersistedLocalBrowserSessionOwnership(record),
     engine: record.engine,
     ...record.endpoint === void 0 ? {} : { endpoint: record.endpoint },
     ...record.baseUrl === void 0 ? {} : { baseUrl: record.baseUrl },
@@ -14579,7 +14783,12 @@ function isAttachBrowserOptions(browser) {
 async function resolveAttachEndpoint(browser) {
   const endpoint = browser?.endpoint?.trim();
   if (endpoint && endpoint.length > 0) {
-    return endpoint;
+    const inspected = await inspectCdpEndpoint({
+      endpoint,
+      ...browser?.headers === void 0 ? {} : { headers: browser.headers },
+      timeoutMs: DEFAULT_TIMEOUT_MS
+    });
+    return inspected.endpoint;
   }
   const selection = await selectAttachBrowserCandidate({
     timeoutMs: DEFAULT_TIMEOUT_MS
@@ -14843,12 +15052,12 @@ async function waitForProcessExit(pid, timeoutMs) {
   }
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
-    if (!isProcessRunning(pid)) {
+    if (!isProcessRunning2(pid)) {
       return true;
     }
     await sleep2(50);
   }
-  return !isProcessRunning(pid);
+  return !isProcessRunning2(pid);
 }
 function resolveAbpSessionDir(workspace) {
   return path10__default.default.join(workspace.livePath, "abp-session");
@@ -15755,11 +15964,11 @@ function delay2(ms) {
 function wrapCloudFetchError(error, input) {
   if (!(error instanceof Error)) {
     return new Error(
-      `Failed to reach Opensteer cloud endpoint ${input.method} ${input.url}. Check OPENSTEER_BASE_URL and network reachability from this environment.`
+      `Failed to reach Opensteer cloud endpoint ${input.method} ${input.url}. Check the configured Opensteer cloud base URL and network reachability from this environment.`
     );
   }
   const wrapped = new Error(
-    `Failed to reach Opensteer cloud endpoint ${input.method} ${input.url}. Check OPENSTEER_BASE_URL and network reachability from this environment.`,
+    `Failed to reach Opensteer cloud endpoint ${input.method} ${input.url}. Check the configured Opensteer cloud base URL and network reachability from this environment.`,
     {
       cause: error
     }
@@ -15799,6 +16008,7 @@ function asCloudErrorPayload(value) {
 }
 
 // src/cloud/config.ts
+var DEFAULT_OPENSTEER_CLOUD_BASE_URL = "https://api.opensteer.com";
 function resolveCloudConfig(input = {}) {
   const provider = resolveOpensteerProvider({
     ...input.provider === void 0 ? {} : { provider: input.provider },
@@ -15808,26 +16018,30 @@ function resolveCloudConfig(input = {}) {
     return void 0;
   }
   const cloudProvider = input.provider?.mode === "cloud" ? input.provider : void 0;
-  const apiKey = cloudProvider?.apiKey ?? input.environment?.OPENSTEER_API_KEY;
-  if (!apiKey || apiKey.trim().length === 0) {
+  const apiKey = normalizeOptionalCloudConfigValue(cloudProvider?.apiKey) ?? normalizeOptionalCloudConfigValue(input.environment?.OPENSTEER_API_KEY);
+  if (apiKey === void 0) {
     throw new Error("provider=cloud requires OPENSTEER_API_KEY or provider.apiKey.");
   }
-  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.");
-  }
-  const appBaseUrl = cloudProvider?.appBaseUrl ?? input.environment?.OPENSTEER_CLOUD_APP_BASE_URL;
+  const baseUrl = normalizeOptionalCloudConfigValue(cloudProvider?.baseUrl) ?? normalizeOptionalCloudConfigValue(input.environment?.OPENSTEER_BASE_URL) ?? DEFAULT_OPENSTEER_CLOUD_BASE_URL;
+  const appBaseUrl = normalizeOptionalCloudConfigValue(cloudProvider?.appBaseUrl) ?? normalizeOptionalCloudConfigValue(input.environment?.OPENSTEER_CLOUD_APP_BASE_URL);
   return {
-    apiKey: apiKey.trim(),
-    baseUrl: baseUrl.trim().replace(/\/+$/, ""),
-    ...appBaseUrl === void 0 || appBaseUrl.trim().length === 0 ? {} : { appBaseUrl: appBaseUrl.trim().replace(/\/+$/, "") },
+    apiKey,
+    baseUrl,
+    ...appBaseUrl === void 0 ? {} : { appBaseUrl },
     ...cloudProvider?.browserProfile === void 0 ? {} : { browserProfile: cloudProvider.browserProfile }
   };
 }
+function normalizeOptionalCloudConfigValue(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().replace(/\/+$/, "");
+  return normalized.length === 0 ? void 0 : normalized;
+}
 
 // ../runtime-core/package.json
 var package_default = {
-  version: "0.2.5"};
+  version: "0.2.7"};
 
 // ../runtime-core/src/version.ts
 var OPENSTEER_RUNTIME_CORE_VERSION = package_default.version;
@@ -16098,12 +16312,16 @@ function toOpensteerResolvedTarget(target) {
     documentRef: target.documentRef,
     documentEpoch: target.documentEpoch,
     nodeRef: target.nodeRef,
-    tagName: target.node.nodeName.toUpperCase(),
+    tagName: toOpensteerTagName(target.node.nodeName),
     pathHint: buildPathSelectorHint(target.replayPath ?? target.anchor),
     ...target.persist === void 0 ? {} : { persist: target.persist },
     ...target.selectorUsed === void 0 ? {} : { selectorUsed: target.selectorUsed }
   };
 }
+function toOpensteerTagName(nodeName) {
+  const tagName = String(nodeName).trim().toLowerCase();
+  return tagName.length === 0 ? "element" : tagName;
+}
 
 // ../runtime-core/src/runtimes/computer-use/runtime.ts
 function createComputerUseRuntime(options) {
@@ -16137,7 +16355,7 @@ var DefaultComputerUseRuntime = class {
         screenshot,
         signal: input.timeout.signal,
         remainingMs: () => input.timeout.remainingMs(),
-        policySettle: async (pageRef, trigger) => {
+        policySettle: async (pageRef, trigger, boundary) => {
           try {
             await settleWithPolicy(this.options.policy.settle, {
               operation: "computer.execute",
@@ -16145,7 +16363,9 @@ var DefaultComputerUseRuntime = class {
               engine: this.options.engine,
               pageRef,
               signal: input.timeout.signal,
-              remainingMs: input.timeout.remainingMs()
+              remainingMs: input.timeout.remainingMs(),
+              ...boundary?.observedMutationQuietMs === void 0 ? {} : { observedMutationQuietMs: boundary.observedMutationQuietMs },
+              ...boundary?.postLoadHandled === true ? { postLoadHandled: true } : {}
             });
           } catch (error) {
             if (pageRef === input.pageRef && isSoftSettleTimeoutError(error, input.timeout.signal)) {
@@ -17323,28 +17543,24 @@ function restoreBoundedAttr(el, attr, value) {
   }
   setBoundedAttr(el, attr, value);
 }
-function deduplicateImages(html) {
+function deduplicateImagesInDom($) {
   const seen = /* @__PURE__ */ new Set();
-  return html.replace(/<img\b([^>]*)>/gi, (full, attrContent) => {
-    if (/\bc\s*=/.test(attrContent)) {
-      return full;
-    }
-    const srcMatch = attrContent.match(/\bsrc\s*=\s*(["']?)(.*?)\1/);
-    const srcsetMatch = attrContent.match(/\bsrcset\s*=\s*(["'])(.*?)\1/);
-    let src = null;
-    if (srcMatch && srcMatch[2]) {
-      src = srcMatch[2].trim();
-    } else if (srcsetMatch && srcsetMatch[2]) {
-      src = srcsetMatch[2].split(",")[0]?.trim().split(" ")[0] ?? null;
+  $("img").each(function deduplicateDomImage() {
+    const el = $(this);
+    if (el.attr("c") !== void 0) {
+      return;
     }
+    const srcValue = el.attr("src")?.trim();
+    const srcsetValue = el.attr("srcset");
+    const src = srcValue && srcValue.length > 0 ? srcValue : srcsetValue?.split(",")[0]?.trim().split(/\s+/u)[0];
     if (!src) {
-      return full;
+      return;
     }
     if (seen.has(src)) {
-      return "";
+      el.remove();
+      return;
     }
     seen.add(src);
-    return full;
   });
 }
 function hasAttribute2(node, attr) {
@@ -17402,23 +17618,6 @@ function isPreservedImageElement(node) {
 function getElementsInReverseDocumentOrder($) {
   return $.root().find("*").toArray().reverse().filter((node) => node.type === "tag");
 }
-function getNodeDepth(node) {
-  let depth = 0;
-  let current = node.parent;
-  while (current) {
-    depth++;
-    current = current.parent;
-  }
-  return depth;
-}
-function getElementsByDepthDescending($) {
-  const elements = $.root().find("*").toArray().filter((node) => node.type === "tag");
-  const depths = /* @__PURE__ */ new Map();
-  for (const el of elements) {
-    depths.set(el, getNodeDepth(el));
-  }
-  return elements.sort((a, b) => (depths.get(b) ?? 0) - (depths.get(a) ?? 0));
-}
 function flattenExtractionTree($) {
   for (const node of getElementsInReverseDocumentOrder($)) {
     const el = $(node);
@@ -17436,19 +17635,6 @@ function flattenExtractionTree($) {
     el.replaceWith(el.contents());
   }
 }
-function hasMarkedAncestor(el, attr) {
-  let current = el[0]?.parent;
-  while (current) {
-    if (!isElementLikeNode(current)) {
-      return false;
-    }
-    if (current.attribs?.[attr] !== void 0) {
-      return true;
-    }
-    current = current.parent;
-  }
-  return false;
-}
 function isIndicatorImage(node) {
   return (node?.tagName || "").toLowerCase() === "img" && (hasAttribute2(node, "alt") || hasAttribute2(node, "src") || hasAttribute2(node, "srcset"));
 }
@@ -17566,7 +17752,7 @@ function serializeForExtraction($, root) {
   traverse(root, 0);
   return lines.map((l) => l.trim()).filter((l) => l.length > 0).join("");
 }
-function isClickable($, el, context) {
+function isClickable(el, context) {
   if (context.hasPreMarked) {
     return el.attr(OPENSTEER_INTERACTIVE_ATTR) !== void 0;
   }
@@ -17600,21 +17786,17 @@ function isClickable($, el, context) {
   }
   return false;
 }
-function cleanForExtraction(html) {
+function prepareExtractionSnapshotDom(html) {
   if (!html.trim()) {
-    return "";
+    return void 0;
   }
   const $ = cheerio__namespace.load(html, { xmlMode: false });
   removeNoise($);
   removeComments($);
   markInlineSelfHiddenFallback($);
   pruneSelfHiddenNodes($);
-  const $clean = cheerio__namespace.load(
-    $.html().replace(/\n{2,}/g, "\n").trim(),
-    { xmlMode: false }
-  );
-  $clean("*").each(function stripAndRestoreExtractionAttrs() {
-    const el = $clean(this);
+  $("*").each(function stripAndRestoreExtractionAttrs() {
+    const el = $(this);
     const node = el[0];
     if (!node) {
       return;
@@ -17655,16 +17837,20 @@ function cleanForExtraction(html) {
       restoreBoundedAttr(el, "href", hrefValue);
     }
   });
-  flattenExtractionTree($clean);
-  const root = $clean.root()[0];
+  flattenExtractionTree($);
+  deduplicateImagesInDom($);
+  return $;
+}
+function serializePreparedExtractionSnapshot($) {
+  const root = $.root()[0];
   if (root === void 0) {
     return "";
   }
-  return deduplicateImages(serializeForExtraction($clean, root));
+  return serializeForExtraction($, root);
 }
-function cleanForAction(html) {
+function prepareActionSnapshotDom(html) {
   if (!html.trim()) {
-    return "";
+    return void 0;
   }
   const $ = cheerio__namespace.load(html, { xmlMode: false });
   removeNoise($);
@@ -17673,13 +17859,12 @@ function cleanForAction(html) {
   pruneSelfHiddenNodes($);
   const clickableMark = "data-clickable-marker";
   const indicatorMark = "data-keep-indicator";
-  const branchMark = "data-keep-branch";
   const context = {
     hasPreMarked: $(`[${OPENSTEER_INTERACTIVE_ATTR}]`).length > 0
   };
   $("*").each(function markClickables() {
     const el = $(this);
-    if (isClickable($, el, context)) {
+    if (isClickable(el, context)) {
       el.attr(clickableMark, "1");
     }
   });
@@ -17709,25 +17894,7 @@ function cleanForAction(html) {
       el.remove();
     }
   });
-  $(`[${clickableMark}], [${indicatorMark}]`).each(function markBranches() {
-    let current = $(this).parent();
-    while (current.length > 0) {
-      const node = current[0];
-      if (!node || node.type !== "tag") {
-        break;
-      }
-      const ancestor = current;
-      const tag = (node.tagName || "").toLowerCase();
-      if (ROOT_TAGS.has(tag) || ancestor.attr(clickableMark) !== void 0) {
-        break;
-      }
-      if (!isBoundaryTag(tag)) {
-        ancestor.attr(branchMark, "1");
-      }
-      current = ancestor.parent();
-    }
-  });
-  for (const node of getElementsByDepthDescending($)) {
+  for (const node of getElementsInReverseDocumentOrder($)) {
     const el = $(node);
     const tag = (node.tagName || "").toLowerCase();
     if (ROOT_TAGS.has(tag) || isBoundaryTag(tag)) {
@@ -17736,17 +17903,7 @@ function cleanForAction(html) {
     if (el.attr(clickableMark) !== void 0 || el.attr(indicatorMark) !== void 0) {
       continue;
     }
-    const insideClickable = hasMarkedAncestor(el, clickableMark);
-    const preserveBranch = el.attr(branchMark) !== void 0;
     const hasContent = hasElementChildren(node) || hasDirectText(node);
-    if (insideClickable || preserveBranch) {
-      if (!hasContent) {
-        el.remove();
-      } else {
-        unwrapActionNode($, el);
-      }
-      continue;
-    }
     if (!hasContent) {
       el.remove();
       continue;
@@ -17847,13 +18004,20 @@ function cleanForAction(html) {
     }
     el.removeAttr(clickableMark);
     el.removeAttr(indicatorMark);
-    el.removeAttr(branchMark);
     el.removeAttr(OPENSTEER_INTERACTIVE_ATTR);
     el.removeAttr(OPENSTEER_HIDDEN_ATTR);
     el.removeAttr(OPENSTEER_SCROLLABLE_ATTR);
     el.removeAttr(OPENSTEER_SELF_HIDDEN_ATTR);
   });
-  return compactHtml(deduplicateImages($.html()));
+  deduplicateImagesInDom($);
+  return $;
+}
+function serializePreparedActionSnapshot($) {
+  const normalized = compactHtml($.html());
+  if (normalized.length === 0) {
+    return "";
+  }
+  return cheerio__namespace.load(normalized, { xmlMode: false }).html();
 }
 var VOID_TAGS2 = /* @__PURE__ */ new Set([
   "area",
@@ -18076,27 +18240,32 @@ async function markLiveSnapshotSemantics(options) {
   const frames = await options.engine.listFrames({
     pageRef: options.pageRef
   });
-  for (const frame of frames) {
-    await evaluateFrameBestEffort(
-      options.engine,
-      frame.frameRef,
-      MARK_SNAPSHOT_SEMANTICS_SCRIPT,
-      SNAPSHOT_SEMANTIC_ARGS
-    );
-  }
-  return async () => {
-    for (const frame of frames) {
-      await evaluateFrameBestEffort(
+  await Promise.all(
+    frames.map(
+      (frame) => evaluateFrameBestEffort(
         options.engine,
         frame.frameRef,
-        CLEAR_SNAPSHOT_SEMANTICS_SCRIPT,
-        CLEAR_SNAPSHOT_SEMANTIC_ARGS
-      );
-    }
+        MARK_SNAPSHOT_SEMANTICS_SCRIPT,
+        SNAPSHOT_SEMANTIC_ARGS
+      )
+    )
+  );
+  return async () => {
+    await Promise.all(
+      frames.map(
+        (frame) => evaluateFrameBestEffort(
+          options.engine,
+          frame.frameRef,
+          CLEAR_SNAPSHOT_SEMANTICS_SCRIPT,
+          CLEAR_SNAPSHOT_SEMANTIC_ARGS
+        )
+      )
+    );
   };
 }
 
 // ../runtime-core/src/sdk/snapshot/compiler.ts
+var EXTRACTION_SKIPPED_COUNTER_TAGS = /* @__PURE__ */ new Set(["html", "head", "body"]);
 var INTERNAL_SNAPSHOT_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set([
   "c",
   OPENSTEER_BOUNDARY_ATTR,
@@ -18111,7 +18280,7 @@ var INTERNAL_SNAPSHOT_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set([
 var MAX_LIVE_COUNTER_SYNC_ATTEMPTS = 4;
 var CLEAR_LIVE_COUNTERS_SCRIPT = `(({ sparseCounterAttr }) => {
   const walk = (root) => {
-    for (const child of root.children) {
+    for (const child of Array.from(root?.children || [])) {
       child.removeAttribute("c");
       child.removeAttribute(sparseCounterAttr);
       walk(child);
@@ -18127,7 +18296,7 @@ var CLEAR_LIVE_COUNTERS_SCRIPT = `(({ sparseCounterAttr }) => {
 var ASSIGN_SPARSE_COUNTERS_SCRIPT = `(({ sparseCounterAttr, startCounter }) => {
   let counter = startCounter;
   const walk = (root) => {
-    for (const child of root.children) {
+    for (const child of Array.from(root?.children || [])) {
       child.setAttribute(sparseCounterAttr, String(counter++));
       walk(child);
       if (child.shadowRoot) {
@@ -18141,7 +18310,7 @@ var ASSIGN_SPARSE_COUNTERS_SCRIPT = `(({ sparseCounterAttr, startCounter }) => {
 })`;
 var APPLY_DENSE_COUNTERS_SCRIPT = `(({ sparseCounterAttr, mapping }) => {
   const walk = (root) => {
-    for (const child of root.children) {
+    for (const child of Array.from(root?.children || [])) {
       child.removeAttribute("c");
       const sparse = child.getAttribute(sparseCounterAttr);
       if (sparse !== null) {
@@ -18204,20 +18373,22 @@ function ensureSparseCountersForAllRecords(counterRecords) {
 async function clearOpensteerLiveCounters(engine, pageRef) {
   const frames = await engine.listFrames({ pageRef });
   const failures = [];
-  for (const frame of frames) {
-    try {
-      await engine.evaluateFrame({
-        frameRef: frame.frameRef,
-        script: CLEAR_LIVE_COUNTERS_SCRIPT,
-        args: [{ sparseCounterAttr: OPENSTEER_SPARSE_COUNTER_ATTR }]
-      });
-    } catch (error) {
-      if (isDetachedFrameSyncError(error)) {
-        continue;
+  await Promise.all(
+    frames.map(async (frame) => {
+      try {
+        await engine.evaluateFrame({
+          frameRef: frame.frameRef,
+          script: CLEAR_LIVE_COUNTERS_SCRIPT,
+          args: [{ sparseCounterAttr: OPENSTEER_SPARSE_COUNTER_ATTR }]
+        });
+      } catch (error) {
+        if (isDetachedFrameSyncError(error)) {
+          return;
+        }
+        failures.push(`frame ${frame.frameRef} could not be cleared (${describeError(error)}).`);
       }
-      failures.push(`frame ${frame.frameRef} could not be cleared (${describeError(error)}).`);
-    }
-  }
+    })
+  );
   if (failures.length > 0) {
     throw buildLiveCounterSyncError("clear live counters", failures);
   }
@@ -18266,25 +18437,29 @@ async function syncDenseCountersToLiveDom(engine, pageRef, sparseToDirectMapping
       denseCounter
     ])
   );
-  for (const frame of frames) {
-    try {
-      await engine.evaluateFrame({
-        frameRef: frame.frameRef,
-        script: APPLY_DENSE_COUNTERS_SCRIPT,
-        args: [
-          {
-            sparseCounterAttr: OPENSTEER_SPARSE_COUNTER_ATTR,
-            mapping: mappingObj
-          }
-        ]
-      });
-    } catch (error) {
-      if (isDetachedFrameSyncError(error)) {
-        continue;
+  await Promise.all(
+    frames.map(async (frame) => {
+      try {
+        await engine.evaluateFrame({
+          frameRef: frame.frameRef,
+          script: APPLY_DENSE_COUNTERS_SCRIPT,
+          args: [
+            {
+              sparseCounterAttr: OPENSTEER_SPARSE_COUNTER_ATTR,
+              mapping: mappingObj
+            }
+          ]
+        });
+      } catch (error) {
+        if (isDetachedFrameSyncError(error)) {
+          return;
+        }
+        failures.push(
+          `frame ${frame.frameRef} could not be synchronized (${describeError(error)}).`
+        );
       }
-      failures.push(`frame ${frame.frameRef} could not be synchronized (${describeError(error)}).`);
-    }
-  }
+    })
+  );
   if (failures.length > 0) {
     throw buildLiveCounterSyncError("synchronize dense counters", failures);
   }
@@ -18302,26 +18477,26 @@ async function compileOpensteerSnapshot(options) {
       await clearOpensteerLiveCounters(options.engine, options.pageRef);
       await assignSparseCountersToLiveDom(options.engine, options.pageRef);
       const pageInfo = await options.engine.getPageInfo({ pageRef: options.pageRef });
-      const mainSnapshot = await getMainDocumentSnapshot(options.engine, options.pageRef);
-      const snapshotsByDocumentRef = await collectDocumentSnapshots(options.engine, mainSnapshot);
+      const { mainSnapshot, snapshotsByDocumentRef } = await getPageDocumentSnapshots(
+        options.engine,
+        options.pageRef
+      );
       await cleanupLiveSemantics();
       cleanupLiveSemantics = async () => {
       };
-      const snapshotIndices = /* @__PURE__ */ new Map();
       const renderedNodes = /* @__PURE__ */ new Map();
       const rawHtml = renderDocumentSnapshot(
         mainSnapshot.documentRef,
         snapshotsByDocumentRef,
-        snapshotIndices,
         renderedNodes,
         {
           iframeDepth: 0,
           shadowDepth: 0
         }
       );
-      const cleanedHtml = options.mode === "extraction" ? cleanForExtraction(rawHtml) : cleanForAction(rawHtml);
-      const compiledHtml = assignCounters(cleanedHtml, renderedNodes);
-      const finalHtml = options.mode === "extraction" ? unwrapExtractionHtml(compiledHtml.html) : compiledHtml.html;
+      const preparedSnapshotDom = options.mode === "extraction" ? prepareExtractionSnapshotDom(rawHtml) : prepareActionSnapshotDom(rawHtml);
+      const compiledHtml = assignCountersInDom(preparedSnapshotDom, renderedNodes, options.mode);
+      const finalHtml = preparedSnapshotDom === void 0 ? "" : options.mode === "extraction" ? serializePreparedExtractionSnapshot(preparedSnapshotDom) : serializePreparedActionSnapshot(preparedSnapshotDom);
       ensureSparseCountersForAllRecords(compiledHtml.counterRecords);
       await syncDenseCountersToLiveDom(
         options.engine,
@@ -18356,6 +18531,25 @@ async function getMainDocumentSnapshot(engine, pageRef) {
   }
   return engine.getDomSnapshot({ frameRef: mainFrame.frameRef });
 }
+async function getPageDocumentSnapshots(engine, pageRef) {
+  const bundleEngine = engine;
+  const bundledSnapshots = await bundleEngine.getPageDomSnapshots?.({ pageRef });
+  if (bundledSnapshots && bundledSnapshots.length > 0) {
+    const mainSnapshot2 = bundledSnapshots.find((snapshot) => snapshot.parentDocumentRef === void 0) ?? bundledSnapshots[0];
+    return {
+      mainSnapshot: mainSnapshot2,
+      snapshotsByDocumentRef: new Map(
+        bundledSnapshots.map((snapshot) => [snapshot.documentRef, snapshot])
+      )
+    };
+  }
+  const mainSnapshot = await getMainDocumentSnapshot(engine, pageRef);
+  const snapshotsByDocumentRef = await collectDocumentSnapshots(engine, mainSnapshot);
+  return {
+    mainSnapshot,
+    snapshotsByDocumentRef
+  };
+}
 async function collectDocumentSnapshots(engine, mainSnapshot) {
   const snapshotsByDocumentRef = /* @__PURE__ */ new Map([
     [mainSnapshot.documentRef, mainSnapshot]
@@ -18374,7 +18568,7 @@ async function collectDocumentSnapshots(engine, mainSnapshot) {
   }
   return snapshotsByDocumentRef;
 }
-function renderDocumentSnapshot(documentRef, snapshotsByDocumentRef, snapshotIndices, renderedNodes, depth) {
+function renderDocumentSnapshot(documentRef, snapshotsByDocumentRef, renderedNodes, depth) {
   const snapshot = snapshotsByDocumentRef.get(documentRef);
   if (!snapshot) {
     return "";
@@ -18386,17 +18580,9 @@ function renderDocumentSnapshot(documentRef, snapshotsByDocumentRef, snapshotInd
       `snapshot ${snapshot.documentRef} is missing root node ${String(snapshot.rootSnapshotNodeId)}`
     );
   }
-  return renderNode(
-    snapshot,
-    rootNode,
-    nodesById,
-    snapshotsByDocumentRef,
-    snapshotIndices,
-    renderedNodes,
-    depth
-  );
+  return renderNode(snapshot, rootNode, nodesById, snapshotsByDocumentRef, renderedNodes, depth);
 }
-function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotIndices, renderedNodes, depth) {
+function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth) {
   if (node.nodeType === 3) {
     return escapeHtml(node.nodeValue || node.textContent || "");
   }
@@ -18404,56 +18590,26 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
     return "";
   }
   if (node.nodeType === 9 || node.nodeType === 11) {
-    return renderChildren(
-      snapshot,
-      node,
-      nodesById,
-      snapshotsByDocumentRef,
-      snapshotIndices,
-      renderedNodes,
-      depth
-    );
+    return renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth);
   }
   if (node.nodeType !== 1) {
-    return renderChildren(
-      snapshot,
-      node,
-      nodesById,
-      snapshotsByDocumentRef,
-      snapshotIndices,
-      renderedNodes,
-      depth
-    );
+    return renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth);
   }
   const tagName = normalizeTagName(node.nodeName);
   if (isPseudoElementTagName(tagName)) {
-    return renderChildren(
-      snapshot,
-      node,
-      nodesById,
-      snapshotsByDocumentRef,
-      snapshotIndices,
-      renderedNodes,
-      depth
-    );
+    return renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth);
   }
   if ((depth.iframeDepth > 0 || depth.shadowDepth > 0) && (tagName === "html" || tagName === "head" || tagName === "body")) {
-    return renderChildren(
-      snapshot,
-      node,
-      nodesById,
-      snapshotsByDocumentRef,
-      snapshotIndices,
-      renderedNodes,
-      depth
-    );
+    return renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth);
   }
   const snapshotAttributes = normalizeNodeAttributes(node.attributes);
+  const snapshotAttributeIndex = indexNodeAttributes(snapshotAttributes);
   const authoredAttributes = stripInternalSnapshotAttributes(snapshotAttributes);
+  const authoredAttributeIndex = indexNodeAttributes(authoredAttributes);
   const attributes = [...authoredAttributes];
-  const subtreeHidden = hasAttribute3(snapshotAttributes, OPENSTEER_HIDDEN_ATTR) || isLikelySubtreeHidden(node);
-  const selfHidden = !subtreeHidden && (hasAttribute3(snapshotAttributes, OPENSTEER_SELF_HIDDEN_ATTR) || isLikelySelfHidden(node, nodesById));
-  const interactive = !subtreeHidden && !selfHidden && (hasAttribute3(snapshotAttributes, OPENSTEER_INTERACTIVE_ATTR) || isLikelyInteractive(tagName, node, authoredAttributes));
+  const subtreeHidden = snapshotAttributeIndex.has(OPENSTEER_HIDDEN_ATTR) || isLikelySubtreeHidden(node);
+  const selfHidden = !subtreeHidden && (snapshotAttributeIndex.has(OPENSTEER_SELF_HIDDEN_ATTR) || isLikelySelfHidden(node, nodesById));
+  const interactive = !subtreeHidden && !selfHidden && (snapshotAttributeIndex.has(OPENSTEER_INTERACTIVE_ATTR) || isLikelyInteractive(tagName, node, authoredAttributes, authoredAttributeIndex));
   if (interactive) {
     attributes.push({ name: OPENSTEER_INTERACTIVE_ATTR, value: "1" });
   }
@@ -18462,7 +18618,7 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
   } else if (selfHidden) {
     attributes.push({ name: OPENSTEER_SELF_HIDDEN_ATTR, value: "1" });
   }
-  const sparseCounter = findAttributeValue(snapshotAttributes, OPENSTEER_SPARSE_COUNTER_ATTR);
+  const sparseCounter = snapshotAttributeIndex.get(OPENSTEER_SPARSE_COUNTER_ATTR);
   if (sparseCounter !== void 0) {
     attributes.push({ name: OPENSTEER_SPARSE_COUNTER_ATTR, value: sparseCounter });
   }
@@ -18473,21 +18629,18 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
     const syntheticNodeId = buildSyntheticNodeId(snapshot, node);
     attributes.push({ name: OPENSTEER_NODE_ID_ATTR, value: syntheticNodeId });
     renderedNodes.set(syntheticNodeId, {
-      locator: createNodeLocator(snapshot.documentRef, snapshot.documentEpoch, node.nodeRef),
-      anchor: buildSnapshotElementAnchor(snapshot, node, snapshotsByDocumentRef, snapshotIndices),
       pageRef: snapshot.pageRef,
       frameRef: snapshot.frameRef,
       documentRef: snapshot.documentRef,
       documentEpoch: snapshot.documentEpoch,
       nodeRef: node.nodeRef,
       tagName: tagName.toUpperCase(),
-      pathHint: buildPathHint(tagName, authoredAttributes),
-      ...buildTextSnippet(node.textContent) === void 0 ? {} : { text: buildTextSnippet(node.textContent) },
       ...authoredAttributes.length === 0 ? {} : { attributes: authoredAttributes },
       iframeDepth: depth.iframeDepth,
       shadowDepth: depth.shadowDepth,
       interactive,
-      liveCounterSyncEligible: isLiveCounterSyncEligible(node, nodesById)
+      liveCounterSyncEligible: isLiveCounterSyncEligible(node, nodesById),
+      ...node.textContent === void 0 ? {} : { textContent: node.textContent }
     });
   }
   const attributeText = attributesToHtml(attributes);
@@ -18496,7 +18649,6 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
     node,
     nodesById,
     snapshotsByDocumentRef,
-    snapshotIndices,
     renderedNodes,
     depth
   );
@@ -18507,7 +18659,6 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
   const iframeHtml = renderDocumentSnapshot(
     node.contentDocumentRef,
     snapshotsByDocumentRef,
-    snapshotIndices,
     renderedNodes,
     {
       iframeDepth: depth.iframeDepth + 1,
@@ -18519,7 +18670,7 @@ function renderNode(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotI
   }
   return `${elementHtml}<${OPENSTEER_IFRAME_BOUNDARY_TAG} ${OPENSTEER_BOUNDARY_ATTR}="iframe">${iframeHtml}</${OPENSTEER_IFRAME_BOUNDARY_TAG}>`;
 }
-function renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, snapshotIndices, renderedNodes, depth) {
+function renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, renderedNodes, depth) {
   const regularChildren = [];
   const shadowChildren = [];
   for (const childSnapshotNodeId of node.childSnapshotNodeIds) {
@@ -18536,18 +18687,10 @@ function renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, snaps
   const chunks = [];
   if (shadowChildren.length > 0) {
     const shadowHtml = shadowChildren.map(
-      (child) => renderNode(
-        snapshot,
-        child,
-        nodesById,
-        snapshotsByDocumentRef,
-        snapshotIndices,
-        renderedNodes,
-        {
-          iframeDepth: depth.iframeDepth,
-          shadowDepth: depth.shadowDepth + 1
-        }
-      )
+      (child) => renderNode(snapshot, child, nodesById, snapshotsByDocumentRef, renderedNodes, {
+        iframeDepth: depth.iframeDepth,
+        shadowDepth: depth.shadowDepth + 1
+      })
     ).join("");
     chunks.push(
       `<${OPENSTEER_SHADOW_BOUNDARY_TAG} ${OPENSTEER_BOUNDARY_ATTR}="shadow">${shadowHtml}</${OPENSTEER_SHADOW_BOUNDARY_TAG}>`
@@ -18555,24 +18698,21 @@ function renderChildren(snapshot, node, nodesById, snapshotsByDocumentRef, snaps
   }
   for (const child of regularChildren) {
     chunks.push(
-      renderNode(
-        snapshot,
-        child,
-        nodesById,
-        snapshotsByDocumentRef,
-        snapshotIndices,
-        renderedNodes,
-        depth
-      )
+      renderNode(snapshot, child, nodesById, snapshotsByDocumentRef, renderedNodes, depth)
     );
   }
   return chunks.join("");
 }
-function assignCounters(cleanedHtml, renderedNodes) {
-  const $ = cheerio__namespace.load(cleanedHtml, { xmlMode: false });
+function assignCountersInDom($, renderedNodes, mode) {
   const counterRecords = /* @__PURE__ */ new Map();
   const sparseToDirectMapping = /* @__PURE__ */ new Map();
   let nextCounter = 1;
+  if (!$) {
+    return {
+      counterRecords,
+      sparseToDirectMapping
+    };
+  }
   $("*").each(function assignElementCounter() {
     const el = $(this);
     const syntheticNodeId = el.attr(OPENSTEER_NODE_ID_ATTR);
@@ -18584,14 +18724,24 @@ function assignCounters(cleanedHtml, renderedNodes) {
     if (!rendered) {
       return;
     }
+    if (mode === "extraction" && EXTRACTION_SKIPPED_COUNTER_TAGS.has(rendered.tagName.toLowerCase())) {
+      el.removeAttr(OPENSTEER_SPARSE_COUNTER_ATTR);
+      return;
+    }
     const rawSparseCounter = el.attr(OPENSTEER_SPARSE_COUNTER_ATTR);
     el.removeAttr(OPENSTEER_SPARSE_COUNTER_ATTR);
     const sparseCounter = rawSparseCounter ? Number.parseInt(rawSparseCounter, 10) : void 0;
+    const replayableSparseCounter = typeof sparseCounter === "number" && Number.isFinite(sparseCounter) ? sparseCounter : void 0;
+    if (rendered.liveCounterSyncEligible && replayableSparseCounter === void 0) {
+      return;
+    }
     const counter = nextCounter++;
     el.attr("c", String(counter));
-    if (sparseCounter !== void 0 && Number.isFinite(sparseCounter)) {
-      sparseToDirectMapping.set(sparseCounter, counter);
+    if (replayableSparseCounter !== void 0) {
+      sparseToDirectMapping.set(replayableSparseCounter, counter);
     }
+    const pathHint = buildPathHint(rendered.tagName.toLowerCase(), rendered.attributes ?? []);
+    const text = buildTextSnippet(rendered.textContent);
     counterRecords.set(counter, {
       element: counter,
       pageRef: rendered.pageRef,
@@ -18600,20 +18750,17 @@ function assignCounters(cleanedHtml, renderedNodes) {
       documentEpoch: rendered.documentEpoch,
       nodeRef: rendered.nodeRef,
       tagName: rendered.tagName,
-      pathHint: rendered.pathHint,
-      ...rendered.text === void 0 ? {} : { text: rendered.text },
+      pathHint,
+      ...text === void 0 ? {} : { text },
       ...rendered.attributes === void 0 ? {} : { attributes: rendered.attributes },
       iframeDepth: rendered.iframeDepth,
       shadowDepth: rendered.shadowDepth,
       interactive: rendered.interactive,
       liveCounterSyncEligible: rendered.liveCounterSyncEligible,
-      locator: rendered.locator,
-      anchor: rendered.anchor,
-      ...sparseCounter !== void 0 && Number.isFinite(sparseCounter) ? { sparseCounter } : {}
+      ...replayableSparseCounter === void 0 ? {} : { sparseCounter: replayableSparseCounter }
     });
   });
   return {
-    html: $.html(),
     counterRecords,
     sparseToDirectMapping
   };
@@ -18687,28 +18834,28 @@ function isLikelySelfHidden(node, nodesById) {
   }
   return !hasVisibleOutOfFlowChild(node, nodesById);
 }
-function isLikelyInteractive(tagName, node, attributes) {
+function isLikelyInteractive(tagName, node, attributes, attributeIndex) {
   if (NATIVE_INTERACTIVE_TAGS.has(tagName)) {
-    if (tagName === "input" && findAttributeValue(attributes, "type")?.toLowerCase() === "hidden") {
+    if (tagName === "input" && attributeIndex.get("type")?.toLowerCase() === "hidden") {
       return false;
     }
     if (tagName !== "a") {
       return true;
     }
   }
-  if (tagName === "a" && findAttributeValue(attributes, "href") !== void 0) {
+  if (tagName === "a" && attributeIndex.has("href")) {
     return true;
   }
-  if (findAttributeValue(attributes, "onclick") !== void 0 || findAttributeValue(attributes, "onmousedown") !== void 0 || findAttributeValue(attributes, "onmouseup") !== void 0 || findAttributeValue(attributes, "data-action") !== void 0 || findAttributeValue(attributes, "data-click") !== void 0 || findAttributeValue(attributes, "data-toggle") !== void 0) {
+  if (attributeIndex.has("onclick") || attributeIndex.has("onmousedown") || attributeIndex.has("onmouseup") || attributeIndex.has("data-action") || attributeIndex.has("data-click") || attributeIndex.has("data-toggle")) {
     return true;
   }
-  if (hasNonNegativeTabIndex(findAttributeValue(attributes, "tabindex"))) {
+  if (hasNonNegativeTabIndex(attributeIndex.get("tabindex"))) {
     return true;
   }
-  if (findAttributeValue(attributes, "contenteditable")?.toLowerCase() === "true") {
+  if (attributeIndex.get("contenteditable")?.toLowerCase() === "true") {
     return true;
   }
-  const role = findAttributeValue(attributes, "role")?.toLowerCase();
+  const role = attributeIndex.get("role")?.toLowerCase();
   return role !== void 0 && INTERACTIVE_ROLE_SET.has(role);
 }
 function hasVisibleOutOfFlowChild(node, nodesById) {
@@ -18771,14 +18918,6 @@ function parseOpacity(value) {
   const parsed = Number.parseFloat(value);
   return Number.isFinite(parsed) ? parsed : Number.NaN;
 }
-function hasAttribute3(attributes, name) {
-  const normalizedName = name.toLowerCase();
-  return attributes.some((attribute) => attribute.name.toLowerCase() === normalizedName);
-}
-function unwrapExtractionHtml(html) {
-  const $ = cheerio__namespace.load(html, { xmlMode: false });
-  return $("body").html()?.trim() || html;
-}
 function buildSyntheticNodeId(snapshot, node) {
   return `${snapshot.documentRef}:${String(snapshot.documentEpoch)}:${String(node.snapshotNodeId)}`;
 }
@@ -18825,6 +18964,13 @@ function findAttributeValue(attributes, name) {
   const normalizedName = name.toLowerCase();
   return attributes.find((attribute) => attribute.name.toLowerCase() === normalizedName)?.value;
 }
+function indexNodeAttributes(attributes) {
+  const indexed = /* @__PURE__ */ new Map();
+  for (const attribute of attributes) {
+    indexed.set(attribute.name.toLowerCase(), attribute.value);
+  }
+  return indexed;
+}
 function attributesToHtml(attributes) {
   if (attributes.length === 0) {
     return "";
@@ -18834,56 +18980,6 @@ function attributesToHtml(attributes) {
 function escapeAttribute(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-function buildSnapshotElementAnchor(snapshot, node, snapshotsByDocumentRef, snapshotIndices) {
-  const index = getSnapshotIndex(snapshot.documentRef, snapshotsByDocumentRef, snapshotIndices);
-  const localAnchor = buildLocalStructuralElementAnchor(index, node);
-  return prefixIframeContext(snapshot, localAnchor, snapshotsByDocumentRef, snapshotIndices);
-}
-function prefixIframeContext(snapshot, localPath, snapshotsByDocumentRef, snapshotIndices) {
-  if (snapshot.parentDocumentRef === void 0) {
-    return sanitizeStructuralElementAnchor(localPath);
-  }
-  const parentSnapshot = snapshotsByDocumentRef.get(snapshot.parentDocumentRef);
-  if (!parentSnapshot) {
-    throw new Error(
-      `document ${snapshot.documentRef} has parent ${snapshot.parentDocumentRef} but no parent snapshot`
-    );
-  }
-  const parentIndex = getSnapshotIndex(
-    parentSnapshot.documentRef,
-    snapshotsByDocumentRef,
-    snapshotIndices
-  );
-  const iframeHost = findIframeHostNode(parentIndex, snapshot.documentRef);
-  if (!iframeHost) {
-    throw new Error(
-      `document ${snapshot.documentRef} has parent ${snapshot.parentDocumentRef} but no iframe host`
-    );
-  }
-  const hostPath = buildSnapshotElementAnchor(
-    parentSnapshot,
-    iframeHost,
-    snapshotsByDocumentRef,
-    snapshotIndices
-  );
-  return sanitizeStructuralElementAnchor({
-    context: [...hostPath.context, { kind: "iframe", host: hostPath.nodes }, ...localPath.context],
-    nodes: localPath.nodes
-  });
-}
-function getSnapshotIndex(documentRef, snapshotsByDocumentRef, snapshotIndices) {
-  const existing = snapshotIndices.get(documentRef);
-  if (existing) {
-    return existing;
-  }
-  const snapshot = snapshotsByDocumentRef.get(documentRef);
-  if (!snapshot) {
-    throw new Error(`missing DOM snapshot for ${documentRef}`);
-  }
-  const index = createSnapshotIndex(snapshot);
-  snapshotIndices.set(documentRef, index);
-  return index;
-}
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -20016,7 +20112,10 @@ var OpensteerSessionRuntime = class {
   sessionRef;
   pageRef;
   runId;
-  observations;
+  observationSessions = /* @__PURE__ */ new Map();
+  openingObservationSessions = /* @__PURE__ */ new Map();
+  openedObservationSessions = /* @__PURE__ */ new Set();
+  observationSessionStorage = new async_hooks.AsyncLocalStorage();
   operationEventStorage = new async_hooks.AsyncLocalStorage();
   pendingOperationEventCaptures = [];
   ownsEngine = false;
@@ -20068,18 +20167,26 @@ 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
-    });
+    await this.ensureConfiguredObservationSession();
     return this.observationConfig;
   }
+  async withObservationSessionId(sessionId, task) {
+    return await this.observationSessionStorage.run(
+      {
+        mode: "session",
+        sessionId: normalizeNonEmptyString("sessionId", sessionId)
+      },
+      task
+    );
+  }
+  async withoutObservationSession(task) {
+    return await this.observationSessionStorage.run(
+      {
+        mode: "disabled"
+      },
+      task
+    );
+  }
   async open(input = {}, options = {}) {
     assertValidSemanticOperationInput("session.open", input);
     if (input.workspace !== void 0 && normalizeNamespace2(input.workspace) !== this.workspace) {
@@ -20096,7 +20203,7 @@ var OpensteerSessionRuntime = class {
           options
         );
       }
-      return this.readSessionState();
+      return this.readNavigationSummary();
     }
     const startedAt = Date.now();
     const root = await this.ensureRoot();
@@ -20117,7 +20224,8 @@ var OpensteerSessionRuntime = class {
           openedSessionRef = sessionRef;
           const createdPage = await timeout.runStep(
             () => engine.createPage({
-              sessionRef
+              sessionRef,
+              ...input.url === void 0 ? {} : { url: input.url }
             })
           );
           openedPageRef = createdPage.data.pageRef;
@@ -20127,18 +20235,19 @@ var OpensteerSessionRuntime = class {
           await timeout.runStep(() => this.ensureSemantics());
           let frameRef2 = createdPage.frameRef;
           if (input.url !== void 0) {
-            const navigation = await this.navigatePage(
-              {
+            await timeout.runStep(
+              () => settleWithPolicy(this.policy.settle, {
                 operation: "session.open",
+                trigger: "navigation",
+                engine: this.requireEngine(),
                 pageRef: createdPage.data.pageRef,
-                url: input.url
-              },
-              timeout
+                signal: timeout.signal,
+                remainingMs: timeout.remainingMs()
+              })
             );
-            frameRef2 = navigation.data.mainFrame.frameRef;
           }
           return {
-            state: await timeout.runStep(() => this.readSessionState()),
+            state: await timeout.runStep(() => this.readNavigationSummary()),
             frameRef: frameRef2
           };
         },
@@ -20231,7 +20340,11 @@ var OpensteerSessionRuntime = class {
           "page.new cannot use openerPageRef before a session exists"
         );
       }
-      return this.open(input.url === void 0 ? {} : { url: input.url }, options);
+      const summary = await this.open(input.url === void 0 ? {} : { url: input.url }, options);
+      return {
+        pageRef: await this.ensurePageRef(),
+        ...summary
+      };
     }
     const startedAt = Date.now();
     try {
@@ -20246,7 +20359,7 @@ var OpensteerSessionRuntime = class {
             })
           );
           this.pageRef = created.data.pageRef;
-          return this.readSessionState();
+          return this.readCreatedPageOutput(created.data.pageRef);
         },
         options
       );
@@ -20288,7 +20401,7 @@ var OpensteerSessionRuntime = class {
             () => this.requireEngine().activatePage({ pageRef: input.pageRef })
           );
           this.pageRef = input.pageRef;
-          return this.readSessionState();
+          return this.readNavigationSummary(input.pageRef);
         },
         options
       );
@@ -20414,7 +20527,7 @@ var OpensteerSessionRuntime = class {
           timeout.throwIfAborted();
           return {
             navigation: navigation2,
-            state: await timeout.runStep(() => this.readSessionState())
+            state: await timeout.runStep(() => this.readNavigationSummary(pageRef))
           };
         },
         (diagnostics) => {
@@ -21648,7 +21761,7 @@ var OpensteerSessionRuntime = class {
     let mutationCaptureDiagnostics;
     let boundaryDiagnostics;
     try {
-      const { artifacts, output } = await this.runMutationCapturedOperation(
+      const { artifacts, output, result } = await this.runMutationCapturedOperation(
         "computer.execute",
         {
           ...input.captureNetwork === void 0 ? {} : { captureNetwork: input.captureNetwork },
@@ -21666,9 +21779,14 @@ var OpensteerSessionRuntime = class {
             await this.invalidateLiveSnapshotCounters([pageRef, output2.pageRef], timeout);
             this.pageRef = output2.pageRef;
             const artifacts2 = await this.persistComputerArtifacts(output2, timeout);
+            const result2 = {
+              ...await timeout.runStep(() => this.readNavigationSummary(output2.pageRef)),
+              screenshot: artifacts2.screenshot
+            };
             return {
               artifacts: { manifests: artifacts2.manifests },
-              output: artifacts2.output
+              output: output2,
+              result: result2
             };
           } catch (error) {
             boundaryDiagnostics ??= takeActionBoundaryDiagnostics(timeout.signal);
@@ -21705,7 +21823,7 @@ var OpensteerSessionRuntime = class {
           documentEpoch: output.screenshot.documentEpoch
         })
       });
-      return output;
+      return result;
     } catch (error) {
       await this.appendTrace({
         operation: "computer.execute",
@@ -21853,8 +21971,9 @@ var OpensteerSessionRuntime = class {
           mutationCaptureDiagnostics = diagnostics;
         }
       );
-      const output = toOpensteerActionResult(executed.result);
+      const output = toOpensteerActionResult(executed.result.resolved);
       const actionEvents = "events" in executed.result ? executed.result.events : void 0;
+      const resolvedTarget = toOpensteerResolvedTarget2(executed.result.resolved);
       await this.appendTrace({
         operation,
         startedAt,
@@ -21862,8 +21981,13 @@ var OpensteerSessionRuntime = class {
         outcome: "ok",
         ...actionEvents === void 0 ? {} : { events: actionEvents },
         data: {
-          target: output.target,
-          ...output.point === void 0 ? {} : { point: output.point },
+          target: resolvedTarget,
+          ..."point" in executed.result && executed.result.point !== void 0 ? {
+            point: {
+              x: executed.result.point.x,
+              y: executed.result.point.y
+            }
+          } : {},
           ...boundaryDiagnostics === void 0 ? {} : { settle: boundaryDiagnostics },
           ...buildMutationCaptureTraceData(mutationCaptureDiagnostics)
         },
@@ -23328,20 +23452,20 @@ var OpensteerSessionRuntime = class {
       throw error;
     }
   }
-  async readSessionState() {
-    const pageRef = await this.ensurePageRef();
+  async readNavigationSummary(targetPageRef) {
+    const pageRef = targetPageRef ?? await this.ensurePageRef();
     const pageInfo = await this.requireEngine().getPageInfo({ pageRef });
-    const sessionRef = this.sessionRef;
-    if (!sessionRef) {
-      throw new Error("Opensteer session is not initialized");
-    }
     return {
-      sessionRef,
-      pageRef,
       url: pageInfo.url,
       title: pageInfo.title
     };
   }
+  async readCreatedPageOutput(pageRef) {
+    return {
+      pageRef,
+      ...await this.readNavigationSummary(pageRef)
+    };
+  }
   async captureSnapshotArtifacts(pageRef, options, timeout) {
     const root = this.requireRoot();
     const mainFrame = await timeout.runStep(() => getMainFrame(this.requireEngine(), pageRef));
@@ -23413,12 +23537,12 @@ var OpensteerSessionRuntime = class {
     const screenshotPayload = manifestToExternalBinaryLocation(root.rootPath, screenshotManifest);
     return {
       manifests,
-      output: {
-        ...output,
-        screenshot: {
-          ...output.screenshot,
-          payload: screenshotPayload
-        }
+      screenshot: {
+        payload: screenshotPayload,
+        format: output.screenshot.format,
+        size: output.screenshot.size,
+        coordinateSpace: output.screenshot.coordinateSpace,
+        ...output.screenshot.clip === void 0 ? {} : { clip: output.screenshot.clip }
       }
     };
   }
@@ -23506,7 +23630,7 @@ var OpensteerSessionRuntime = class {
   }
   async resetRuntimeState(options) {
     const engine = this.engine;
-    const observations = this.observations;
+    const observationSessions = [...this.openedObservationSessions];
     this.networkHistory.clear();
     this.sessionRef = void 0;
     this.pageRef = void 0;
@@ -23515,9 +23639,15 @@ var OpensteerSessionRuntime = class {
     this.computer = void 0;
     this.extractionDescriptors = void 0;
     this.engine = void 0;
-    this.observations = void 0;
+    this.observationSessions.clear();
+    this.openingObservationSessions.clear();
+    this.openedObservationSessions.clear();
     this.pendingOperationEventCaptures.length = 0;
-    await observations?.close("runtime_reset").catch(() => void 0);
+    await Promise.allSettled(
+      observationSessions.map(
+        (observationSession) => observationSession.close("runtime_reset").catch(() => void 0)
+      )
+    );
     if (options.disposeEngine && this.ownsEngine && engine?.dispose) {
       await engine.dispose();
     }
@@ -23527,23 +23657,64 @@ var OpensteerSessionRuntime = class {
     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 existingObservationSession = this.observationSessions.get(observationSessionId);
+    if (existingObservationSession !== void 0) {
+      return existingObservationSession;
+    }
+    const openingObservationSession = this.openingObservationSessions.get(observationSessionId);
+    if (openingObservationSession !== void 0) {
+      return await openingObservationSession;
+    }
+    const openObservationSessionTask = this.openObservationSession(observationSessionId).finally(
+      () => {
+        this.openingObservationSessions.delete(observationSessionId);
+      }
+    );
+    this.openingObservationSessions.set(observationSessionId, openObservationSessionTask);
+    return await openObservationSessionTask;
+  }
+  async ensureConfiguredObservationSession() {
+    if (this.observationConfig.profile === "off") {
+      return void 0;
     }
     const observationSessionId = this.resolveObservationSessionId();
     if (observationSessionId === void 0) {
       return void 0;
     }
+    const hadObservationSession = this.observationSessions.has(observationSessionId) || this.openingObservationSessions.has(observationSessionId);
+    const observationSession = await this.ensureObservationSession();
+    if (observationSession !== void 0 && hadObservationSession) {
+      await observationSession.configure?.({
+        config: this.observationConfig,
+        updatedAt: Date.now()
+      });
+    }
+    return observationSession;
+  }
+  resolveObservationSessionId() {
+    const scopedSession = this.observationSessionStorage.getStore();
+    if (scopedSession?.mode === "session") {
+      return scopedSession.sessionId;
+    }
+    if (scopedSession?.mode === "disabled") {
+      return void 0;
+    }
+    return this.observationSessionId ?? this.sessionRef;
+  }
+  async openObservationSession(sessionId) {
     const sink = this.injectedObservationSink ?? (await this.ensureRoot()).observations;
-    this.observations = await sink.openSession({
-      sessionId: observationSessionId,
+    const observationSession = await sink.openSession({
+      sessionId,
       openedAt: Date.now(),
       config: this.observationConfig
     });
-    return this.observations;
-  }
-  resolveObservationSessionId() {
-    return this.observationSessionId ?? this.sessionRef;
+    this.observationSessions.set(sessionId, observationSession);
+    this.openedObservationSessions.add(observationSession);
+    return observationSession;
   }
   runWithOperationTimeout(operation, callback, options = {}) {
     const timeoutPolicy = options.timeoutMs === void 0 ? this.policy.timeout : {
@@ -24941,15 +25112,10 @@ function normalizeNamespace2(value) {
   const normalized = String(value ?? "default").trim();
   return normalized.length === 0 ? "default" : normalized;
 }
-function toOpensteerActionResult(result) {
+function toOpensteerActionResult(target) {
   return {
-    target: toOpensteerResolvedTarget2(result.resolved),
-    ...result.point === void 0 ? {} : {
-      point: {
-        x: result.point.x,
-        y: result.point.y
-      }
-    }
+    tagName: toOpensteerTagName2(target.node.nodeName),
+    ...target.persist === void 0 ? {} : { persist: target.persist }
   };
 }
 function toOpensteerResolvedTarget2(target) {
@@ -24959,12 +25125,16 @@ function toOpensteerResolvedTarget2(target) {
     documentRef: target.documentRef,
     documentEpoch: target.documentEpoch,
     nodeRef: target.nodeRef,
-    tagName: target.node.nodeName.toUpperCase(),
+    tagName: toOpensteerTagName2(target.node.nodeName),
     pathHint: buildPathSelectorHint(target.replayPath ?? target.anchor),
     ...target.persist === void 0 ? {} : { persist: target.persist },
     ...target.selectorUsed === void 0 ? {} : { selectorUsed: target.selectorUsed }
   };
 }
+function toOpensteerTagName2(nodeName) {
+  const tagName = String(nodeName).trim().toLowerCase();
+  return tagName.length === 0 ? "element" : tagName;
+}
 function normalizeOpensteerError(error) {
   return normalizeThrownOpensteerError2(error, "Unknown Opensteer runtime failure");
 }
@@ -26220,7 +26390,29 @@ function isLoopbackBaseUrl(baseUrl) {
   }
   return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1" || url.hostname === "[::1]";
 }
-var OpensteerRuntime = class extends OpensteerSessionRuntime {
+var LocalActivePageHintRuntime = class extends OpensteerSessionRuntime {
+  async completeWithLocalActivePageHint(operation) {
+    const output = await operation();
+    await persistLocalActivePageHint(this, this.rootPath);
+    return output;
+  }
+  async open(input = {}, options = {}) {
+    return this.completeWithLocalActivePageHint(() => super.open(input, options));
+  }
+  async newPage(input = {}, options = {}) {
+    return this.completeWithLocalActivePageHint(() => super.newPage(input, options));
+  }
+  async activatePage(input, options = {}) {
+    return this.completeWithLocalActivePageHint(() => super.activatePage(input, options));
+  }
+  async closePage(input = {}, options = {}) {
+    return this.completeWithLocalActivePageHint(() => super.closePage(input, options));
+  }
+  async goto(input, options = {}) {
+    return this.completeWithLocalActivePageHint(() => super.goto(input, options));
+  }
+};
+var OpensteerRuntime = class extends LocalActivePageHintRuntime {
   constructor(options = {}) {
     const publicWorkspace = normalizeWorkspace2(options.workspace);
     const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path10__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : resolveFilesystemWorkspacePath({
@@ -26258,6 +26450,41 @@ var OpensteerRuntime = class extends OpensteerSessionRuntime {
     );
   }
 };
+async function persistLocalActivePageHint(runtime, rootPath) {
+  try {
+    await syncPersistedLocalActivePageHint(runtime, rootPath);
+  } catch {
+  }
+}
+async function syncPersistedLocalActivePageHint(runtime, rootPath) {
+  const record = await readPersistedLocalBrowserSessionRecord(rootPath);
+  if (!record) {
+    return;
+  }
+  const sessionInfo = await runtime.info();
+  const activePageRef = sessionInfo.activePageRef;
+  let activePageUrl;
+  let activePageTitle;
+  if (activePageRef !== void 0) {
+    const pages = await runtime.listPages();
+    const activePage = pages.pages.find((page) => page.pageRef === activePageRef);
+    activePageUrl = activePage?.url;
+    activePageTitle = activePage?.title;
+  }
+  const {
+    activePageRef: _previousActivePageRef,
+    activePageUrl: _previousActivePageUrl,
+    activePageTitle: _previousActivePageTitle,
+    ...restRecord
+  } = record;
+  await writePersistedSessionRecord(rootPath, {
+    ...restRecord,
+    updatedAt: Date.now(),
+    ...activePageRef === void 0 ? {} : { activePageRef },
+    ...activePageUrl === void 0 ? {} : { activePageUrl },
+    ...activePageTitle === void 0 ? {} : { activePageTitle }
+  });
+}
 function buildSharedRuntimeOptions(input) {
   const ownership = resolveOwnership(input.browser);
   const engineFactory = input.engineFactory ?? ((factoryOptions) => new OpensteerBrowserManager({
@@ -26758,6 +26985,7 @@ function delay3(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 
+exports.DEFAULT_OPENSTEER_CLOUD_BASE_URL = DEFAULT_OPENSTEER_CLOUD_BASE_URL;
 exports.DEFAULT_OPENSTEER_ENGINE = DEFAULT_OPENSTEER_ENGINE;
 exports.DEFERRED_MATCH_ATTR_KEYS = DEFERRED_MATCH_ATTR_KEYS;
 exports.ElementPathError = ElementPathError;