opensteer 0.4.14 → 0.5.0

package/dist/{chunk-WXUXG76V.js → chunk-SXPIGCSD.js}

@@ -1192,9 +1192,6 @@ var ENSURE_NAME_SHIM_SCRIPT = `
 `;
 var OS_FRAME_TOKEN_KEY = "__opensteerFrameToken";
 var OS_INSTANCE_TOKEN_KEY = "__opensteerInstanceToken";
-var OS_COUNTER_OWNER_KEY = "__opensteerCounterOwner";
-var OS_COUNTER_VALUE_KEY = "__opensteerCounterValue";
-var OS_COUNTER_NEXT_KEY = "__opensteerCounterNext";
 
 // src/element-path/build.ts
 var MAX_ATTRIBUTE_VALUE_LENGTH = 300;
@@ -2985,567 +2982,179 @@ function cleanForAction(html) {
   return compactHtml(htmlOut);
 }
 
-// src/extract-value-normalization.ts
-var URL_LIST_ATTRIBUTES = /* @__PURE__ */ new Set(["srcset", "imagesrcset", "ping"]);
-function normalizeExtractedValue(raw, attribute) {
-  if (raw == null) return null;
-  const rawText = String(raw);
-  if (!rawText.trim()) return null;
-  const normalizedAttribute = String(attribute || "").trim().toLowerCase();
-  if (URL_LIST_ATTRIBUTES.has(normalizedAttribute)) {
-    const singleValue = pickSingleListAttributeValue(
-      normalizedAttribute,
-      rawText
-    ).trim();
-    return singleValue || null;
-  }
-  const text = rawText.replace(/\s+/g, " ").trim();
-  return text || null;
-}
-function pickSingleListAttributeValue(attribute, raw) {
-  if (attribute === "ping") {
-    const firstUrl = raw.trim().split(/\s+/)[0] || "";
-    return firstUrl.trim();
-  }
-  if (attribute === "srcset" || attribute === "imagesrcset") {
-    const picked = pickBestSrcsetCandidate(raw);
-    if (picked) return picked;
-    return pickFirstSrcsetToken(raw) || "";
-  }
-  return raw.trim();
-}
-function pickBestSrcsetCandidate(raw) {
-  const candidates = parseSrcsetCandidates(raw);
-  if (!candidates.length) return null;
-  const widthCandidates = candidates.filter(
-    (candidate) => typeof candidate.width === "number" && Number.isFinite(candidate.width) && candidate.width > 0
-  );
-  if (widthCandidates.length) {
-    return widthCandidates.reduce(
-      (best, candidate) => candidate.width > best.width ? candidate : best
-    ).url;
-  }
-  const densityCandidates = candidates.filter(
-    (candidate) => typeof candidate.density === "number" && Number.isFinite(candidate.density) && candidate.density > 0
-  );
-  if (densityCandidates.length) {
-    return densityCandidates.reduce(
-      (best, candidate) => candidate.density > best.density ? candidate : best
-    ).url;
-  }
-  return candidates[0]?.url || null;
-}
-function parseSrcsetCandidates(raw) {
-  const text = String(raw || "").trim();
-  if (!text) return [];
-  const out = [];
-  let index = 0;
-  while (index < text.length) {
-    index = skipSeparators(text, index);
-    if (index >= text.length) break;
-    const urlToken = readUrlToken(text, index);
-    index = urlToken.nextIndex;
-    const url = urlToken.value.trim();
-    if (!url) continue;
-    index = skipWhitespace(text, index);
-    const descriptors = [];
-    while (index < text.length && text[index] !== ",") {
-      const descriptorToken = readDescriptorToken(text, index);
-      if (!descriptorToken.value) {
-        index = descriptorToken.nextIndex;
-        continue;
-      }
-      descriptors.push(descriptorToken.value);
-      index = descriptorToken.nextIndex;
-      index = skipWhitespace(text, index);
-    }
-    if (index < text.length && text[index] === ",") {
-      index += 1;
-    }
-    let width = null;
-    let density = null;
-    for (const descriptor of descriptors) {
-      const token = descriptor.trim().toLowerCase();
-      if (!token) continue;
-      const widthMatch = token.match(/^(\d+)w$/);
-      if (widthMatch) {
-        const parsed = Number.parseInt(widthMatch[1], 10);
-        if (Number.isFinite(parsed)) {
-          width = parsed;
-        }
-        continue;
-      }
-      const densityMatch = token.match(/^(\d*\.?\d+)x$/);
-      if (densityMatch) {
-        const parsed = Number.parseFloat(densityMatch[1]);
-        if (Number.isFinite(parsed)) {
-          density = parsed;
-        }
-      }
-    }
-    out.push({
-      url,
-      width,
-      density
-    });
-  }
-  return out;
-}
-function pickFirstSrcsetToken(raw) {
-  const candidate = parseSrcsetCandidates(raw)[0];
-  if (candidate?.url) {
-    return candidate.url;
-  }
-  const text = String(raw || "");
-  const start = skipSeparators(text, 0);
-  if (start >= text.length) return null;
-  const firstToken = readUrlToken(text, start).value.trim();
-  return firstToken || null;
-}
-function skipWhitespace(value, index) {
-  let cursor = index;
-  while (cursor < value.length && /\s/.test(value[cursor])) {
-    cursor += 1;
-  }
-  return cursor;
-}
-function skipSeparators(value, index) {
-  let cursor = skipWhitespace(value, index);
-  while (cursor < value.length && value[cursor] === ",") {
-    cursor += 1;
-    cursor = skipWhitespace(value, cursor);
-  }
-  return cursor;
-}
-function readUrlToken(value, index) {
-  let cursor = index;
-  let out = "";
-  const isDataUrl = value.slice(index, index + 5).toLowerCase().startsWith("data:");
-  while (cursor < value.length) {
-    const char = value[cursor];
-    if (/\s/.test(char)) {
-      break;
-    }
-    if (char === "," && !isDataUrl) {
-      break;
-    }
-    out += char;
-    cursor += 1;
-  }
-  if (isDataUrl && out.endsWith(",") && cursor < value.length) {
-    out = out.slice(0, -1);
+// src/html/pipeline.ts
+import * as cheerio3 from "cheerio";
+function applyCleaner(mode, html) {
+  switch (mode) {
+    case "clickable":
+      return cleanForClickable(html);
+    case "scrollable":
+      return cleanForScrollable(html);
+    case "extraction":
+      return cleanForExtraction(html);
+    case "full":
+      return cleanForFull(html);
+    case "action":
+    default:
+      return cleanForAction(html);
   }
-  return {
-    value: out,
-    nextIndex: cursor
-  };
 }
-function readDescriptorToken(value, index) {
-  let cursor = skipWhitespace(value, index);
-  let out = "";
-  while (cursor < value.length) {
-    const char = value[cursor];
-    if (char === "," || /\s/.test(char)) {
-      break;
+async function assignCounters(page, html, nodePaths, nodeMeta) {
+  const $ = cheerio3.load(html, { xmlMode: false });
+  const counterIndex = /* @__PURE__ */ new Map();
+  let nextCounter = 1;
+  const assignedByNodeId = /* @__PURE__ */ new Map();
+  $("*").each(function() {
+    const el = $(this);
+    const nodeId = el.attr(OS_NODE_ID_ATTR);
+    if (!nodeId) return;
+    const counter = nextCounter++;
+    assignedByNodeId.set(nodeId, counter);
+    const path5 = nodePaths.get(nodeId);
+    el.attr("c", String(counter));
+    el.removeAttr(OS_NODE_ID_ATTR);
+    if (path5) {
+      counterIndex.set(counter, cloneElementPath(path5));
     }
-    out += char;
-    cursor += 1;
+  });
+  try {
+    await syncLiveCounters(page, nodeMeta, assignedByNodeId);
+  } catch (error) {
+    await clearLiveCounters(page);
+    throw error;
   }
+  $(`[${OS_NODE_ID_ATTR}]`).removeAttr(OS_NODE_ID_ATTR);
   return {
-    value: out.trim(),
-    nextIndex: cursor
+    html: $.html(),
+    counterIndex
   };
 }
-
-// src/html/counter-runtime.ts
-var CounterResolutionError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "CounterResolutionError";
-    this.code = code;
-  }
-};
-async function ensureLiveCounters(page, nodeMeta, nodeIds) {
-  const out = /* @__PURE__ */ new Map();
-  if (!nodeIds.length) return out;
-  const grouped = /* @__PURE__ */ new Map();
-  for (const nodeId of nodeIds) {
+async function syncLiveCounters(page, nodeMeta, assignedByNodeId) {
+  await clearLiveCounters(page);
+  if (!assignedByNodeId.size) return;
+  const groupedByFrame = /* @__PURE__ */ new Map();
+  for (const [nodeId, counter] of assignedByNodeId.entries()) {
     const meta = nodeMeta.get(nodeId);
-    if (!meta) {
-      throw new CounterResolutionError(
-        "ERR_COUNTER_STALE_OR_NOT_FOUND",
-        `Missing metadata for node ${nodeId}. Run snapshot() again.`
-      );
-    }
-    const list = grouped.get(meta.frameToken) || [];
+    if (!meta?.frameToken) continue;
+    const list = groupedByFrame.get(meta.frameToken) || [];
     list.push({
       nodeId,
-      instanceToken: meta.instanceToken
+      counter
     });
-    grouped.set(meta.frameToken, list);
+    groupedByFrame.set(meta.frameToken, list);
   }
+  if (!groupedByFrame.size) return;
+  const failures = [];
   const framesByToken = await mapFramesByToken(page);
-  let nextCounter = await readGlobalNextCounter(page);
-  const usedCounters = /* @__PURE__ */ new Map();
-  for (const [frameToken, entries] of grouped.entries()) {
+  for (const [frameToken, entries] of groupedByFrame.entries()) {
     const frame = framesByToken.get(frameToken);
     if (!frame) {
-      throw new CounterResolutionError(
-        "ERR_COUNTER_FRAME_UNAVAILABLE",
-        `Counter frame ${frameToken} is unavailable. Run snapshot() again.`
-      );
+      for (const entry of entries) {
+        failures.push({
+          nodeId: entry.nodeId,
+          counter: entry.counter,
+          frameToken,
+          reason: "frame_missing"
+        });
+      }
+      continue;
     }
-    const result = await frame.evaluate(
-      ({
-        entries: entries2,
-        nodeAttr,
-        instanceTokenKey,
-        counterOwnerKey,
-        counterValueKey,
-        startCounter
-      }) => {
-        const helpers = {
-          pushNode(map, node) {
-            const nodeId = node.getAttribute(nodeAttr);
-            if (!nodeId) return;
-            const list = map.get(nodeId) || [];
-            list.push(node);
-            map.set(nodeId, list);
-          },
-          walk(map, root) {
+    try {
+      const unresolved = await frame.evaluate(
+        ({ entries: entries2, nodeAttr }) => {
+          const index = /* @__PURE__ */ new Map();
+          const unresolved2 = [];
+          const walk = (root) => {
             const children = Array.from(root.children);
             for (const child of children) {
-              helpers.pushNode(map, child);
-              helpers.walk(map, child);
+              const nodeId = child.getAttribute(nodeAttr);
+              if (nodeId) {
+                const list = index.get(nodeId) || [];
+                list.push(child);
+                index.set(nodeId, list);
+              }
+              walk(child);
               if (child.shadowRoot) {
-                helpers.walk(map, child.shadowRoot);
+                walk(child.shadowRoot);
               }
             }
-          },
-          buildNodeIndex() {
-            const map = /* @__PURE__ */ new Map();
-            helpers.walk(map, document);
-            return map;
-          }
-        };
-        const index = helpers.buildNodeIndex();
-        const assigned = [];
-        const failures = [];
-        let next = Math.max(1, Number(startCounter || 1));
-        for (const entry of entries2) {
-          const matches = index.get(entry.nodeId) || [];
-          if (!matches.length) {
-            failures.push({
-              nodeId: entry.nodeId,
-              reason: "missing"
-            });
-            continue;
-          }
-          if (matches.length !== 1) {
-            failures.push({
-              nodeId: entry.nodeId,
-              reason: "ambiguous"
-            });
-            continue;
-          }
-          const target = matches[0];
-          if (target[instanceTokenKey] !== entry.instanceToken) {
-            failures.push({
-              nodeId: entry.nodeId,
-              reason: "instance_mismatch"
-            });
-            continue;
-          }
-          const owned = target[counterOwnerKey] === true;
-          const runtimeCounter = Number(target[counterValueKey] || 0);
-          if (owned && Number.isFinite(runtimeCounter) && runtimeCounter > 0) {
-            target.setAttribute("c", String(runtimeCounter));
-            assigned.push({
-              nodeId: entry.nodeId,
-              counter: runtimeCounter
-            });
-            continue;
+          };
+          walk(document);
+          for (const entry of entries2) {
+            const matches = index.get(entry.nodeId) || [];
+            if (matches.length !== 1) {
+              unresolved2.push({
+                nodeId: entry.nodeId,
+                counter: entry.counter,
+                matches: matches.length
+              });
+              continue;
+            }
+            matches[0].setAttribute("c", String(entry.counter));
           }
-          const counter = next++;
-          target.setAttribute("c", String(counter));
-          Object.defineProperty(target, counterOwnerKey, {
-            value: true,
-            writable: true,
-            configurable: true
-          });
-          Object.defineProperty(target, counterValueKey, {
-            value: counter,
-            writable: true,
-            configurable: true
-          });
-          assigned.push({ nodeId: entry.nodeId, counter });
+          return unresolved2;
+        },
+        {
+          entries,
+          nodeAttr: OS_NODE_ID_ATTR
         }
-        return {
-          assigned,
-          failures,
-          nextCounter: next
-        };
-      },
-      {
-        entries,
-        nodeAttr: OS_NODE_ID_ATTR,
-        instanceTokenKey: OS_INSTANCE_TOKEN_KEY,
-        counterOwnerKey: OS_COUNTER_OWNER_KEY,
-        counterValueKey: OS_COUNTER_VALUE_KEY,
-        startCounter: nextCounter
-      }
-    );
-    if (result.failures.length) {
-      const first = result.failures[0];
-      throw buildCounterFailureError(first.nodeId, first.reason);
-    }
-    nextCounter = result.nextCounter;
-    for (const item of result.assigned) {
-      const existingNode = usedCounters.get(item.counter);
-      if (existingNode && existingNode !== item.nodeId) {
-        throw new CounterResolutionError(
-          "ERR_COUNTER_AMBIGUOUS",
-          `Counter ${item.counter} is assigned to multiple nodes (${existingNode}, ${item.nodeId}). Run snapshot() again.`
-        );
+      );
+      for (const entry of unresolved) {
+        failures.push({
+          nodeId: entry.nodeId,
+          counter: entry.counter,
+          frameToken,
+          reason: "match_count",
+          matches: entry.matches
+        });
+      }
+    } catch {
+      for (const entry of entries) {
+        failures.push({
+          nodeId: entry.nodeId,
+          counter: entry.counter,
+          frameToken,
+          reason: "frame_unavailable"
+        });
       }
-      usedCounters.set(item.counter, item.nodeId);
-      out.set(item.nodeId, item.counter);
     }
   }
-  await writeGlobalNextCounter(page, nextCounter);
-  return out;
-}
-async function resolveCounterElement(page, snapshot, counter) {
-  const binding = readBinding(snapshot, counter);
-  const framesByToken = await mapFramesByToken(page);
-  const frame = framesByToken.get(binding.frameToken);
-  if (!frame) {
-    throw new CounterResolutionError(
-      "ERR_COUNTER_FRAME_UNAVAILABLE",
-      `Counter ${counter} frame is unavailable. Run snapshot() again.`
-    );
-  }
-  const status = await frame.evaluate(
-    ({
-      nodeId,
-      instanceToken,
-      counter: counter2,
-      nodeAttr,
-      instanceTokenKey,
-      counterOwnerKey,
-      counterValueKey
-    }) => {
-      const helpers = {
-        walk(map, root) {
-          const children = Array.from(root.children);
-          for (const child of children) {
-            const id = child.getAttribute(nodeAttr);
-            if (id) {
-              const list = map.get(id) || [];
-              list.push(child);
-              map.set(id, list);
-            }
-            helpers.walk(map, child);
-            if (child.shadowRoot) {
-              helpers.walk(map, child.shadowRoot);
-            }
-          }
-        },
-        buildNodeIndex() {
-          const map = /* @__PURE__ */ new Map();
-          helpers.walk(map, document);
-          return map;
-        }
-      };
-      const matches = helpers.buildNodeIndex().get(nodeId) || [];
-      if (!matches.length) return "missing";
-      if (matches.length !== 1) return "ambiguous";
-      const target = matches[0];
-      if (target[instanceTokenKey] !== instanceToken) {
-        return "instance_mismatch";
-      }
-      if (target[counterOwnerKey] !== true) {
-        return "instance_mismatch";
+  if (failures.length) {
+    const preview = failures.slice(0, 3).map((failure) => {
+      const base = `counter ${failure.counter} (nodeId "${failure.nodeId}") in frame "${failure.frameToken}"`;
+      if (failure.reason === "frame_missing") {
+        return `${base} could not be synchronized because the frame is missing.`;
       }
-      if (Number(target[counterValueKey] || 0) !== counter2) {
-        return "instance_mismatch";
+      if (failure.reason === "frame_unavailable") {
+        return `${base} could not be synchronized because frame evaluation failed.`;
       }
-      if (target.getAttribute("c") !== String(counter2)) {
-        return "instance_mismatch";
-      }
-      return "ok";
-    },
-    {
-      nodeId: binding.nodeId,
-      instanceToken: binding.instanceToken,
-      counter,
-      nodeAttr: OS_NODE_ID_ATTR,
-      instanceTokenKey: OS_INSTANCE_TOKEN_KEY,
-      counterOwnerKey: OS_COUNTER_OWNER_KEY,
-      counterValueKey: OS_COUNTER_VALUE_KEY
-    }
-  );
-  if (status !== "ok") {
-    throw buildCounterFailureError(binding.nodeId, status);
+      return `${base} expected exactly one live node but found ${failure.matches ?? 0}.`;
+    });
+    const remaining = failures.length > 3 ? ` (+${failures.length - 3} more)` : "";
+    throw new Error(
+      `Failed to synchronize snapshot counters with the live DOM: ${preview.join(" ")}${remaining}`
+    );
   }
-  const handle = await frame.evaluateHandle(
-    ({ nodeId, nodeAttr }) => {
-      const helpers = {
-        walk(matches, root) {
+}
+async function clearLiveCounters(page) {
+  for (const frame of page.frames()) {
+    try {
+      await frame.evaluate(() => {
+        const walk = (root) => {
           const children = Array.from(root.children);
           for (const child of children) {
-            if (child.getAttribute(nodeAttr) === nodeId) {
-              matches.push(child);
-            }
-            helpers.walk(matches, child);
+            child.removeAttribute("c");
+            walk(child);
             if (child.shadowRoot) {
-              helpers.walk(matches, child.shadowRoot);
+              walk(child.shadowRoot);
             }
           }
-        },
-        findUniqueNode() {
-          const matches = [];
-          helpers.walk(matches, document);
-          if (matches.length !== 1) return null;
-          return matches[0];
-        }
-      };
-      return helpers.findUniqueNode();
-    },
-    {
-      nodeId: binding.nodeId,
-      nodeAttr: OS_NODE_ID_ATTR
-    }
-  );
-  const element = handle.asElement();
-  if (!element) {
-    await handle.dispose();
-    throw new CounterResolutionError(
-      "ERR_COUNTER_STALE_OR_NOT_FOUND",
-      `Counter ${counter} became stale. Run snapshot() again.`
-    );
-  }
-  return element;
-}
-async function resolveCountersBatch(page, snapshot, requests) {
-  const out = {};
-  if (!requests.length) return out;
-  const grouped = /* @__PURE__ */ new Map();
-  for (const request of requests) {
-    const binding = readBinding(snapshot, request.counter);
-    const list = grouped.get(binding.frameToken) || [];
-    list.push({
-      ...request,
-      ...binding
-    });
-    grouped.set(binding.frameToken, list);
-  }
-  const framesByToken = await mapFramesByToken(page);
-  for (const [frameToken, entries] of grouped.entries()) {
-    const frame = framesByToken.get(frameToken);
-    if (!frame) {
-      throw new CounterResolutionError(
-        "ERR_COUNTER_FRAME_UNAVAILABLE",
-        `Counter frame ${frameToken} is unavailable. Run snapshot() again.`
-      );
-    }
-    const result = await frame.evaluate(
-      ({
-        entries: entries2,
-        nodeAttr,
-        instanceTokenKey,
-        counterOwnerKey,
-        counterValueKey
-      }) => {
-        const values = [];
-        const failures = [];
-        const helpers = {
-          walk(map, root) {
-            const children = Array.from(root.children);
-            for (const child of children) {
-              const id = child.getAttribute(nodeAttr);
-              if (id) {
-                const list = map.get(id) || [];
-                list.push(child);
-                map.set(id, list);
-              }
-              helpers.walk(map, child);
-              if (child.shadowRoot) {
-                helpers.walk(map, child.shadowRoot);
-              }
-            }
-          },
-          buildNodeIndex() {
-            const map = /* @__PURE__ */ new Map();
-            helpers.walk(map, document);
-            return map;
-          },
-          readRawValue(element, attribute) {
-            if (attribute) {
-              return element.getAttribute(attribute);
-            }
-            return element.textContent;
-          }
         };
-        const index = helpers.buildNodeIndex();
-        for (const entry of entries2) {
-          const matches = index.get(entry.nodeId) || [];
-          if (!matches.length) {
-            failures.push({
-              nodeId: entry.nodeId,
-              reason: "missing"
-            });
-            continue;
-          }
-          if (matches.length !== 1) {
-            failures.push({
-              nodeId: entry.nodeId,
-              reason: "ambiguous"
-            });
-            continue;
-          }
-          const target = matches[0];
-          if (target[instanceTokenKey] !== entry.instanceToken || target[counterOwnerKey] !== true || Number(target[counterValueKey] || 0) !== entry.counter || target.getAttribute("c") !== String(entry.counter)) {
-            failures.push({
-              nodeId: entry.nodeId,
-              reason: "instance_mismatch"
-            });
-            continue;
-          }
-          values.push({
-            key: entry.key,
-            value: helpers.readRawValue(target, entry.attribute)
-          });
-        }
-        return {
-          values,
-          failures
-        };
-      },
-      {
-        entries,
-        nodeAttr: OS_NODE_ID_ATTR,
-        instanceTokenKey: OS_INSTANCE_TOKEN_KEY,
-        counterOwnerKey: OS_COUNTER_OWNER_KEY,
-        counterValueKey: OS_COUNTER_VALUE_KEY
-      }
-    );
-    if (result.failures.length) {
-      const first = result.failures[0];
-      throw buildCounterFailureError(first.nodeId, first.reason);
-    }
-    const attributeByKey = new Map(
-      entries.map((entry) => [entry.key, entry.attribute])
-    );
-    for (const item of result.values) {
-      out[item.key] = normalizeExtractedValue(
-        item.value,
-        attributeByKey.get(item.key)
-      );
+        walk(document);
+      });
+    } catch {
     }
   }
-  return out;
 }
 async function mapFramesByToken(page) {
   const out = /* @__PURE__ */ new Map();
@@ -3567,182 +3176,6 @@ async function readFrameToken(frame) {
     return null;
   }
 }
-async function readGlobalNextCounter(page) {
-  const current = await page.mainFrame().evaluate((counterNextKey) => {
-    const win = window;
-    return Number(win[counterNextKey] || 0);
-  }, OS_COUNTER_NEXT_KEY).catch(() => 0);
-  if (Number.isFinite(current) && current > 0) {
-    return current;
-  }
-  let max = 0;
-  for (const frame of page.frames()) {
-    try {
-      const frameMax = await frame.evaluate(
-        ({ nodeAttr, counterOwnerKey, counterValueKey }) => {
-          let localMax = 0;
-          const helpers = {
-            walk(root) {
-              const children = Array.from(
-                root.children
-              );
-              for (const child of children) {
-                const candidate = child;
-                const hasNodeId = child.hasAttribute(nodeAttr);
-                const owned = candidate[counterOwnerKey] === true;
-                if (hasNodeId && owned) {
-                  const value = Number(
-                    candidate[counterValueKey] || 0
-                  );
-                  if (Number.isFinite(value) && value > localMax) {
-                    localMax = value;
-                  }
-                }
-                helpers.walk(child);
-                if (child.shadowRoot) {
-                  helpers.walk(child.shadowRoot);
-                }
-              }
-            }
-          };
-          helpers.walk(document);
-          return localMax;
-        },
-        {
-          nodeAttr: OS_NODE_ID_ATTR,
-          counterOwnerKey: OS_COUNTER_OWNER_KEY,
-          counterValueKey: OS_COUNTER_VALUE_KEY
-        }
-      );
-      if (frameMax > max) {
-        max = frameMax;
-      }
-    } catch {
-    }
-  }
-  const next = max + 1;
-  await writeGlobalNextCounter(page, next);
-  return next;
-}
-async function writeGlobalNextCounter(page, nextCounter) {
-  await page.mainFrame().evaluate(
-    ({ counterNextKey, nextCounter: nextCounter2 }) => {
-      const win = window;
-      win[counterNextKey] = nextCounter2;
-    },
-    {
-      counterNextKey: OS_COUNTER_NEXT_KEY,
-      nextCounter
-    }
-  ).catch(() => void 0);
-}
-function readBinding(snapshot, counter) {
-  if (!snapshot.counterBindings) {
-    throw new CounterResolutionError(
-      "ERR_COUNTER_NOT_FOUND",
-      `Counter ${counter} is unavailable because this snapshot has no counter bindings. Run snapshot() with counters first.`
-    );
-  }
-  const binding = snapshot.counterBindings.get(counter);
-  if (!binding) {
-    throw new CounterResolutionError(
-      "ERR_COUNTER_NOT_FOUND",
-      `Counter ${counter} was not found in the current snapshot. Run snapshot() again.`
-    );
-  }
-  if (binding.sessionId !== snapshot.snapshotSessionId) {
-    throw new CounterResolutionError(
-      "ERR_COUNTER_STALE_OR_NOT_FOUND",
-      `Counter ${counter} is stale for this snapshot session. Run snapshot() again.`
-    );
-  }
-  return binding;
-}
-function buildCounterFailureError(nodeId, reason) {
-  if (reason === "ambiguous") {
-    return new CounterResolutionError(
-      "ERR_COUNTER_AMBIGUOUS",
-      `Counter target is ambiguous for node ${nodeId}. Run snapshot() again.`
-    );
-  }
-  return new CounterResolutionError(
-    "ERR_COUNTER_STALE_OR_NOT_FOUND",
-    `Counter target is stale or missing for node ${nodeId}. Run snapshot() again.`
-  );
-}
-
-// src/html/pipeline.ts
-import * as cheerio3 from "cheerio";
-import { randomUUID } from "crypto";
-function applyCleaner(mode, html) {
-  switch (mode) {
-    case "clickable":
-      return cleanForClickable(html);
-    case "scrollable":
-      return cleanForScrollable(html);
-    case "extraction":
-      return cleanForExtraction(html);
-    case "full":
-      return cleanForFull(html);
-    case "action":
-    default:
-      return cleanForAction(html);
-  }
-}
-async function assignCounters(page, html, nodePaths, nodeMeta, snapshotSessionId) {
-  const $ = cheerio3.load(html, { xmlMode: false });
-  const counterIndex = /* @__PURE__ */ new Map();
-  const counterBindings = /* @__PURE__ */ new Map();
-  const orderedNodeIds = [];
-  $("*").each(function() {
-    const el = $(this);
-    const nodeId = el.attr(OS_NODE_ID_ATTR);
-    if (!nodeId) return;
-    orderedNodeIds.push(nodeId);
-  });
-  const countersByNodeId = await ensureLiveCounters(
-    page,
-    nodeMeta,
-    orderedNodeIds
-  );
-  $("*").each(function() {
-    const el = $(this);
-    const nodeId = el.attr(OS_NODE_ID_ATTR);
-    if (!nodeId) return;
-    const path5 = nodePaths.get(nodeId);
-    const meta = nodeMeta.get(nodeId);
-    const counter = countersByNodeId.get(nodeId);
-    if (counter == null || !Number.isFinite(counter)) {
-      throw new Error(
-        `Counter assignment failed for node ${nodeId}. Run snapshot() again.`
-      );
-    }
-    if (counterBindings.has(counter) && counterBindings.get(counter)?.nodeId !== nodeId) {
-      throw new Error(
-        `Counter ${counter} was assigned to multiple nodes. Run snapshot() again.`
-      );
-    }
-    el.attr("c", String(counter));
-    el.removeAttr(OS_NODE_ID_ATTR);
-    if (path5) {
-      counterIndex.set(counter, cloneElementPath(path5));
-    }
-    if (meta) {
-      counterBindings.set(counter, {
-        sessionId: snapshotSessionId,
-        frameToken: meta.frameToken,
-        nodeId,
-        instanceToken: meta.instanceToken
-      });
-    }
-  });
-  $(`[${OS_NODE_ID_ATTR}]`).removeAttr(OS_NODE_ID_ATTR);
-  return {
-    html: $.html(),
-    counterIndex,
-    counterBindings
-  };
-}
 function stripNodeIds(html) {
   if (!html.includes(OS_NODE_ID_ATTR)) return html;
   const $ = cheerio3.load(html, { xmlMode: false });
@@ -3750,7 +3183,6 @@ function stripNodeIds(html) {
   return $.html();
 }
 async function prepareSnapshot(page, options = {}) {
-  const snapshotSessionId = randomUUID();
   const mode = options.mode ?? "action";
   const withCounters = options.withCounters ?? true;
   const shouldMarkInteractive = options.markInteractive ?? true;
@@ -3763,18 +3195,15 @@ async function prepareSnapshot(page, options = {}) {
   const reducedHtml = applyCleaner(mode, processedHtml);
   let cleanedHtml = reducedHtml;
   let counterIndex = null;
-  let counterBindings = null;
   if (withCounters) {
     const counted = await assignCounters(
       page,
       reducedHtml,
       serialized.nodePaths,
-      serialized.nodeMeta,
-      snapshotSessionId
+      serialized.nodeMeta
     );
     cleanedHtml = counted.html;
     counterIndex = counted.counterIndex;
-    counterBindings = counted.counterBindings;
   } else {
     cleanedHtml = stripNodeIds(cleanedHtml);
   }
@@ -3783,15 +3212,13 @@ async function prepareSnapshot(page, options = {}) {
     cleanedHtml = $unwrap("body").html()?.trim() || cleanedHtml;
   }
   return {
-    snapshotSessionId,
     mode,
     url: page.url(),
     rawHtml,
     processedHtml,
     reducedHtml,
     cleanedHtml,
-    counterIndex,
-    counterBindings
+    counterIndex
   };
 }
 
@@ -3920,111 +3347,512 @@ function buildTargetNotFoundMessage(domPath, diagnostics) {
     return `${base} Tried ${Math.max(diagnostics.length, 0)} candidates.`;
   return `${base} Target depth ${depth}. Candidate counts: ${sample}.`;
 }
-function selectInDocument(selectors) {
-  let fallback = null;
-  for (const selector of selectors) {
-    if (!selector) continue;
-    let count = 0;
-    try {
-      count = document.querySelectorAll(selector).length;
-    } catch {
-      count = 0;
+function selectInDocument(selectors) {
+  let fallback = null;
+  for (const selector of selectors) {
+    if (!selector) continue;
+    let count = 0;
+    try {
+      count = document.querySelectorAll(selector).length;
+    } catch {
+      count = 0;
+    }
+    if (count === 1) {
+      return {
+        selector,
+        count,
+        mode: "unique"
+      };
+    }
+    if (count > 1 && !fallback) {
+      fallback = {
+        selector,
+        count,
+        mode: "fallback"
+      };
+    }
+  }
+  return fallback;
+}
+function selectInRoot(root, selectors) {
+  if (!(root instanceof ShadowRoot)) return null;
+  let fallback = null;
+  for (const selector of selectors) {
+    if (!selector) continue;
+    let count = 0;
+    try {
+      count = root.querySelectorAll(selector).length;
+    } catch {
+      count = 0;
+    }
+    if (count === 1) {
+      return {
+        selector,
+        count,
+        mode: "unique"
+      };
+    }
+    if (count > 1 && !fallback) {
+      fallback = {
+        selector,
+        count,
+        mode: "fallback"
+      };
+    }
+  }
+  return fallback;
+}
+function countInDocument(selectors) {
+  const out = [];
+  for (const selector of selectors) {
+    if (!selector) continue;
+    let count = 0;
+    try {
+      count = document.querySelectorAll(selector).length;
+    } catch {
+      count = 0;
+    }
+    out.push({ selector, count });
+  }
+  return out;
+}
+function countInRoot(root, selectors) {
+  if (!(root instanceof ShadowRoot)) return [];
+  const out = [];
+  for (const selector of selectors) {
+    if (!selector) continue;
+    let count = 0;
+    try {
+      count = root.querySelectorAll(selector).length;
+    } catch {
+      count = 0;
+    }
+    out.push({ selector, count });
+  }
+  return out;
+}
+function isPathDebugEnabled() {
+  const value = process.env.OPENSTEER_DEBUG_PATH || process.env.OPENSTEER_DEBUG || process.env.DEBUG_SELECTORS;
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true";
+}
+function debugPath(message, data) {
+  if (!isPathDebugEnabled()) return;
+  if (data !== void 0) {
+    console.log(`[opensteer:path] ${message}`, data);
+  } else {
+    console.log(`[opensteer:path] ${message}`);
+  }
+}
+async function disposeHandle(handle) {
+  if (!handle) return;
+  try {
+    await handle.dispose();
+  } catch {
+  }
+}
+
+// src/extract-value-normalization.ts
+var URL_LIST_ATTRIBUTES = /* @__PURE__ */ new Set(["srcset", "imagesrcset", "ping"]);
+function normalizeExtractedValue(raw, attribute) {
+  if (raw == null) return null;
+  const rawText = String(raw);
+  if (!rawText.trim()) return null;
+  const normalizedAttribute = String(attribute || "").trim().toLowerCase();
+  if (URL_LIST_ATTRIBUTES.has(normalizedAttribute)) {
+    const singleValue = pickSingleListAttributeValue(
+      normalizedAttribute,
+      rawText
+    ).trim();
+    return singleValue || null;
+  }
+  const text = rawText.replace(/\s+/g, " ").trim();
+  return text || null;
+}
+function pickSingleListAttributeValue(attribute, raw) {
+  if (attribute === "ping") {
+    const firstUrl = raw.trim().split(/\s+/)[0] || "";
+    return firstUrl.trim();
+  }
+  if (attribute === "srcset" || attribute === "imagesrcset") {
+    const picked = pickBestSrcsetCandidate(raw);
+    if (picked) return picked;
+    return pickFirstSrcsetToken(raw) || "";
+  }
+  return raw.trim();
+}
+function pickBestSrcsetCandidate(raw) {
+  const candidates = parseSrcsetCandidates(raw);
+  if (!candidates.length) return null;
+  const widthCandidates = candidates.filter(
+    (candidate) => typeof candidate.width === "number" && Number.isFinite(candidate.width) && candidate.width > 0
+  );
+  if (widthCandidates.length) {
+    return widthCandidates.reduce(
+      (best, candidate) => candidate.width > best.width ? candidate : best
+    ).url;
+  }
+  const densityCandidates = candidates.filter(
+    (candidate) => typeof candidate.density === "number" && Number.isFinite(candidate.density) && candidate.density > 0
+  );
+  if (densityCandidates.length) {
+    return densityCandidates.reduce(
+      (best, candidate) => candidate.density > best.density ? candidate : best
+    ).url;
+  }
+  return candidates[0]?.url || null;
+}
+function parseSrcsetCandidates(raw) {
+  const text = String(raw || "").trim();
+  if (!text) return [];
+  const out = [];
+  let index = 0;
+  while (index < text.length) {
+    index = skipSeparators(text, index);
+    if (index >= text.length) break;
+    const urlToken = readUrlToken(text, index);
+    index = urlToken.nextIndex;
+    const url = urlToken.value.trim();
+    if (!url) continue;
+    index = skipWhitespace(text, index);
+    const descriptors = [];
+    while (index < text.length && text[index] !== ",") {
+      const descriptorToken = readDescriptorToken(text, index);
+      if (!descriptorToken.value) {
+        index = descriptorToken.nextIndex;
+        continue;
+      }
+      descriptors.push(descriptorToken.value);
+      index = descriptorToken.nextIndex;
+      index = skipWhitespace(text, index);
+    }
+    if (index < text.length && text[index] === ",") {
+      index += 1;
+    }
+    let width = null;
+    let density = null;
+    for (const descriptor of descriptors) {
+      const token = descriptor.trim().toLowerCase();
+      if (!token) continue;
+      const widthMatch = token.match(/^(\d+)w$/);
+      if (widthMatch) {
+        const parsed = Number.parseInt(widthMatch[1], 10);
+        if (Number.isFinite(parsed)) {
+          width = parsed;
+        }
+        continue;
+      }
+      const densityMatch = token.match(/^(\d*\.?\d+)x$/);
+      if (densityMatch) {
+        const parsed = Number.parseFloat(densityMatch[1]);
+        if (Number.isFinite(parsed)) {
+          density = parsed;
+        }
+      }
+    }
+    out.push({
+      url,
+      width,
+      density
+    });
+  }
+  return out;
+}
+function pickFirstSrcsetToken(raw) {
+  const candidate = parseSrcsetCandidates(raw)[0];
+  if (candidate?.url) {
+    return candidate.url;
+  }
+  const text = String(raw || "");
+  const start = skipSeparators(text, 0);
+  if (start >= text.length) return null;
+  const firstToken = readUrlToken(text, start).value.trim();
+  return firstToken || null;
+}
+function skipWhitespace(value, index) {
+  let cursor = index;
+  while (cursor < value.length && /\s/.test(value[cursor])) {
+    cursor += 1;
+  }
+  return cursor;
+}
+function skipSeparators(value, index) {
+  let cursor = skipWhitespace(value, index);
+  while (cursor < value.length && value[cursor] === ",") {
+    cursor += 1;
+    cursor = skipWhitespace(value, cursor);
+  }
+  return cursor;
+}
+function readUrlToken(value, index) {
+  let cursor = index;
+  let out = "";
+  const isDataUrl = value.slice(index, index + 5).toLowerCase().startsWith("data:");
+  while (cursor < value.length) {
+    const char = value[cursor];
+    if (/\s/.test(char)) {
+      break;
+    }
+    if (char === "," && !isDataUrl) {
+      break;
+    }
+    out += char;
+    cursor += 1;
+  }
+  if (isDataUrl && out.endsWith(",") && cursor < value.length) {
+    out = out.slice(0, -1);
+  }
+  return {
+    value: out,
+    nextIndex: cursor
+  };
+}
+function readDescriptorToken(value, index) {
+  let cursor = skipWhitespace(value, index);
+  let out = "";
+  while (cursor < value.length) {
+    const char = value[cursor];
+    if (char === "," || /\s/.test(char)) {
+      break;
+    }
+    out += char;
+    cursor += 1;
+  }
+  return {
+    value: out.trim(),
+    nextIndex: cursor
+  };
+}
+
+// src/html/counter-runtime.ts
+var CounterResolutionError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "CounterResolutionError";
+    this.code = code;
+  }
+};
+async function resolveCounterElement(page, counter) {
+  const normalized = normalizeCounter(counter);
+  if (normalized == null) {
+    throw buildCounterNotFoundError(counter);
+  }
+  const scan = await scanCounterOccurrences(page, [normalized]);
+  const entry = scan.get(normalized);
+  if (!entry || entry.count <= 0 || !entry.frame) {
+    throw buildCounterNotFoundError(counter);
+  }
+  if (entry.count > 1) {
+    throw buildCounterAmbiguousError(counter);
+  }
+  const handle = await resolveUniqueHandleInFrame(entry.frame, normalized);
+  const element = handle.asElement();
+  if (!element) {
+    await handle.dispose();
+    throw buildCounterNotFoundError(counter);
+  }
+  return element;
+}
+async function resolveCountersBatch(page, requests) {
+  const out = {};
+  if (!requests.length) return out;
+  const counters = dedupeCounters(requests);
+  const scan = await scanCounterOccurrences(page, counters);
+  for (const counter of counters) {
+    const entry = scan.get(counter);
+    if (entry.count > 1) {
+      throw buildCounterAmbiguousError(counter);
     }
-    if (count === 1) {
-      return {
-        selector,
-        count,
-        mode: "unique"
-      };
+  }
+  const valueCache = /* @__PURE__ */ new Map();
+  for (const request of requests) {
+    const normalized = normalizeCounter(request.counter);
+    if (normalized == null) {
+      out[request.key] = null;
+      continue;
     }
-    if (count > 1 && !fallback) {
-      fallback = {
-        selector,
-        count,
-        mode: "fallback"
-      };
+    const entry = scan.get(normalized);
+    if (!entry || entry.count <= 0 || !entry.frame) {
+      out[request.key] = null;
+      continue;
     }
-  }
-  return fallback;
-}
-function selectInRoot(root, selectors) {
-  if (!(root instanceof ShadowRoot)) return null;
-  let fallback = null;
-  for (const selector of selectors) {
-    if (!selector) continue;
-    let count = 0;
-    try {
-      count = root.querySelectorAll(selector).length;
-    } catch {
-      count = 0;
+    const cacheKey = `${normalized}:${request.attribute || ""}`;
+    if (valueCache.has(cacheKey)) {
+      out[request.key] = valueCache.get(cacheKey);
+      continue;
     }
-    if (count === 1) {
-      return {
-        selector,
-        count,
-        mode: "unique"
-      };
+    const read = await readCounterValueInFrame(
+      entry.frame,
+      normalized,
+      request.attribute
+    );
+    if (read.status === "ambiguous") {
+      throw buildCounterAmbiguousError(normalized);
     }
-    if (count > 1 && !fallback) {
-      fallback = {
-        selector,
-        count,
-        mode: "fallback"
-      };
+    if (read.status === "missing") {
+      valueCache.set(cacheKey, null);
+      out[request.key] = null;
+      continue;
     }
+    const normalizedValue = normalizeExtractedValue(
+      read.value ?? null,
+      request.attribute
+    );
+    valueCache.set(cacheKey, normalizedValue);
+    out[request.key] = normalizedValue;
   }
-  return fallback;
+  return out;
 }
-function countInDocument(selectors) {
+function dedupeCounters(requests) {
+  const seen = /* @__PURE__ */ new Set();
   const out = [];
-  for (const selector of selectors) {
-    if (!selector) continue;
-    let count = 0;
-    try {
-      count = document.querySelectorAll(selector).length;
-    } catch {
-      count = 0;
-    }
-    out.push({ selector, count });
+  for (const request of requests) {
+    const normalized = normalizeCounter(request.counter);
+    if (normalized == null || seen.has(normalized)) continue;
+    seen.add(normalized);
+    out.push(normalized);
   }
   return out;
 }
-function countInRoot(root, selectors) {
-  if (!(root instanceof ShadowRoot)) return [];
-  const out = [];
-  for (const selector of selectors) {
-    if (!selector) continue;
-    let count = 0;
+function normalizeCounter(counter) {
+  if (!Number.isFinite(counter)) return null;
+  if (!Number.isInteger(counter)) return null;
+  if (counter <= 0) return null;
+  return counter;
+}
+async function scanCounterOccurrences(page, counters) {
+  const out = /* @__PURE__ */ new Map();
+  for (const counter of counters) {
+    out.set(counter, {
+      count: 0,
+      frame: null
+    });
+  }
+  if (!counters.length) return out;
+  for (const frame of page.frames()) {
+    let frameCounts;
     try {
-      count = root.querySelectorAll(selector).length;
+      frameCounts = await frame.evaluate((candidates) => {
+        const keys = new Set(candidates.map((value) => String(value)));
+        const counts = {};
+        for (const key of keys) {
+          counts[key] = 0;
+        }
+        const walk = (root) => {
+          const children = Array.from(root.children);
+          for (const child of children) {
+            const value = child.getAttribute("c");
+            if (value && keys.has(value)) {
+              counts[value] = (counts[value] || 0) + 1;
+            }
+            walk(child);
+            if (child.shadowRoot) {
+              walk(child.shadowRoot);
+            }
+          }
+        };
+        walk(document);
+        return counts;
+      }, counters);
     } catch {
-      count = 0;
+      continue;
+    }
+    for (const [rawCounter, rawCount] of Object.entries(frameCounts)) {
+      const counter = Number.parseInt(rawCounter, 10);
+      if (!Number.isFinite(counter)) continue;
+      const count = Number(rawCount || 0);
+      if (!Number.isFinite(count) || count <= 0) continue;
+      const entry = out.get(counter);
+      entry.count += count;
+      if (!entry.frame) {
+        entry.frame = frame;
+      }
     }
-    out.push({ selector, count });
   }
   return out;
 }
-function isPathDebugEnabled() {
-  const value = process.env.OPENSTEER_DEBUG_PATH || process.env.OPENSTEER_DEBUG || process.env.DEBUG_SELECTORS;
-  if (!value) return false;
-  const normalized = value.trim().toLowerCase();
-  return normalized === "1" || normalized === "true";
-}
-function debugPath(message, data) {
-  if (!isPathDebugEnabled()) return;
-  if (data !== void 0) {
-    console.log(`[opensteer:path] ${message}`, data);
-  } else {
-    console.log(`[opensteer:path] ${message}`);
-  }
+async function resolveUniqueHandleInFrame(frame, counter) {
+  return frame.evaluateHandle((targetCounter) => {
+    const matches = [];
+    const walk = (root) => {
+      const children = Array.from(root.children);
+      for (const child of children) {
+        if (child.getAttribute("c") === targetCounter) {
+          matches.push(child);
+        }
+        walk(child);
+        if (child.shadowRoot) {
+          walk(child.shadowRoot);
+        }
+      }
+    };
+    walk(document);
+    if (matches.length !== 1) {
+      return null;
+    }
+    return matches[0];
+  }, String(counter));
 }
-async function disposeHandle(handle) {
-  if (!handle) return;
+async function readCounterValueInFrame(frame, counter, attribute) {
   try {
-    await handle.dispose();
+    return await frame.evaluate(
+      ({ targetCounter, attribute: attribute2 }) => {
+        const matches = [];
+        const walk = (root) => {
+          const children = Array.from(root.children);
+          for (const child of children) {
+            if (child.getAttribute("c") === targetCounter) {
+              matches.push(child);
+            }
+            walk(child);
+            if (child.shadowRoot) {
+              walk(child.shadowRoot);
+            }
+          }
+        };
+        walk(document);
+        if (!matches.length) {
+          return {
+            status: "missing"
+          };
+        }
+        if (matches.length > 1) {
+          return {
+            status: "ambiguous"
+          };
+        }
+        const target = matches[0];
+        const value = attribute2 ? target.getAttribute(attribute2) : target.textContent;
+        return {
+          status: "ok",
+          value
+        };
+      },
+      {
+        targetCounter: String(counter),
+        attribute
+      }
+    );
   } catch {
+    return {
+      status: "missing"
+    };
   }
 }
+function buildCounterNotFoundError(counter) {
+  return new CounterResolutionError(
+    "ERR_COUNTER_NOT_FOUND",
+    `Counter ${counter} was not found in the live DOM.`
+  );
+}
+function buildCounterAmbiguousError(counter) {
+  return new CounterResolutionError(
+    "ERR_COUNTER_AMBIGUOUS",
+    `Counter ${counter} matches multiple live elements.`
+  );
+}
 
 // src/actions/actionability-probe.ts
 async function probeActionabilityState(element) {
@@ -4217,13 +4045,6 @@ function classifyTypedError(error) {
         classificationSource: "typed_error"
       });
     }
-    if (error.code === "ERR_COUNTER_FRAME_UNAVAILABLE") {
-      return buildFailure({
-        code: "TARGET_UNAVAILABLE",
-        message: error.message,
-        classificationSource: "typed_error"
-      });
-    }
     if (error.code === "ERR_COUNTER_AMBIGUOUS") {
       return buildFailure({
         code: "TARGET_AMBIGUOUS",
@@ -4231,13 +4052,6 @@ function classifyTypedError(error) {
         classificationSource: "typed_error"
       });
     }
-    if (error.code === "ERR_COUNTER_STALE_OR_NOT_FOUND") {
-      return buildFailure({
-        code: "TARGET_STALE",
-        message: error.message,
-        classificationSource: "typed_error"
-      });
-    }
   }
   return null;
 }
@@ -7588,7 +7402,7 @@ function sleep3(ms) {
 }
 
 // src/opensteer.ts
-import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { createHash, randomUUID } from "crypto";
 
 // src/browser/pool.ts
 import {
@@ -10368,7 +10182,7 @@ var Opensteer = class _Opensteer {
       let persistPath = null;
       try {
         if (storageKey && resolution.shouldPersist) {
-          persistPath = await this.buildPathFromResolvedHandle(
+          persistPath = await this.tryBuildPathFromResolvedHandle(
             handle,
             "hover",
             resolution.counter
@@ -10467,7 +10281,7 @@ var Opensteer = class _Opensteer {
       let persistPath = null;
       try {
         if (storageKey && resolution.shouldPersist) {
-          persistPath = await this.buildPathFromResolvedHandle(
+          persistPath = await this.tryBuildPathFromResolvedHandle(
             handle,
             "input",
             resolution.counter
@@ -10570,7 +10384,7 @@ var Opensteer = class _Opensteer {
       let persistPath = null;
       try {
         if (storageKey && resolution.shouldPersist) {
-          persistPath = await this.buildPathFromResolvedHandle(
+          persistPath = await this.tryBuildPathFromResolvedHandle(
             handle,
             "select",
             resolution.counter
@@ -10680,7 +10494,7 @@ var Opensteer = class _Opensteer {
       let persistPath = null;
       try {
         if (storageKey && resolution.shouldPersist) {
-          persistPath = await this.buildPathFromResolvedHandle(
+          persistPath = await this.tryBuildPathFromResolvedHandle(
             handle,
             "scroll",
             resolution.counter
@@ -10976,17 +10790,19 @@ var Opensteer = class _Opensteer {
       const handle = await this.resolveCounterHandle(resolution.counter);
       try {
         if (storageKey && resolution.shouldPersist) {
-          const persistPath = await this.buildPathFromResolvedHandle(
+          const persistPath = await this.tryBuildPathFromResolvedHandle(
             handle,
             method,
             resolution.counter
           );
-          this.persistPath(
-            storageKey,
-            method,
-            options.description,
-            persistPath
-          );
+          if (persistPath) {
+            this.persistPath(
+              storageKey,
+              method,
+              options.description,
+              persistPath
+            );
+          }
         }
         return await counterFn(handle);
       } catch (err) {
@@ -11024,7 +10840,7 @@ var Opensteer = class _Opensteer {
       let persistPath = null;
       try {
         if (storageKey && resolution.shouldPersist) {
-          persistPath = await this.buildPathFromResolvedHandle(
+          persistPath = await this.tryBuildPathFromResolvedHandle(
             handle,
             "uploadFile",
             resolution.counter
@@ -11300,7 +11116,7 @@ var Opensteer = class _Opensteer {
       let persistPath = null;
       try {
         if (storageKey && resolution.shouldPersist) {
-          persistPath = await this.buildPathFromResolvedHandle(
+          persistPath = await this.tryBuildPathFromResolvedHandle(
             handle,
             "click",
             resolution.counter
@@ -11396,17 +11212,6 @@ var Opensteer = class _Opensteer {
       }
     }
     if (options.element != null) {
-      const pathFromElement = await this.tryBuildPathFromCounter(
-        options.element
-      );
-      if (pathFromElement) {
-        return {
-          path: pathFromElement,
-          counter: null,
-          shouldPersist: Boolean(storageKey),
-          source: "element"
-        };
-      }
       return {
         path: null,
         counter: options.element,
@@ -11434,17 +11239,6 @@ var Opensteer = class _Opensteer {
         options.description
       );
       if (resolved?.counter != null) {
-        const pathFromAiCounter = await this.tryBuildPathFromCounter(
-          resolved.counter
-        );
-        if (pathFromAiCounter) {
-          return {
-            path: pathFromAiCounter,
-            counter: null,
-            shouldPersist: Boolean(storageKey),
-            source: "ai"
-          };
-        }
         return {
           path: null,
           counter: resolved.counter,
@@ -11526,23 +11320,22 @@ var Opensteer = class _Opensteer {
     try {
       const builtPath = await buildElementPathFromHandle(handle);
       if (builtPath) {
-        return this.withIndexedIframeContext(builtPath, indexedPath);
+        const withFrameContext = await this.withHandleIframeContext(
+          handle,
+          builtPath
+        );
+        return this.withIndexedIframeContext(
+          withFrameContext,
+          indexedPath
+        );
       }
       return indexedPath;
     } finally {
       await handle.dispose();
     }
   }
-  async tryBuildPathFromCounter(counter) {
-    try {
-      return await this.buildPathFromElement(counter);
-    } catch {
-      return null;
-    }
-  }
   async resolveCounterHandle(element) {
-    const snapshot = await this.ensureSnapshotWithCounters();
-    return resolveCounterElement(this.page, snapshot, element);
+    return resolveCounterElement(this.page, element);
   }
   async resolveCounterHandleForAction(action, description, element) {
     try {
@@ -11566,8 +11359,12 @@ var Opensteer = class _Opensteer {
     const indexedPath = await this.readPathFromCounterIndex(counter);
     const builtPath = await buildElementPathFromHandle(handle);
     if (builtPath) {
+      const withFrameContext = await this.withHandleIframeContext(
+        handle,
+        builtPath
+      );
       const normalized = this.withIndexedIframeContext(
-        builtPath,
+        withFrameContext,
         indexedPath
       );
       if (normalized.nodes.length) return normalized;
@@ -11577,15 +11374,34 @@ var Opensteer = class _Opensteer {
       `Unable to build element path from counter ${counter} during ${action}.`
     );
   }
+  async tryBuildPathFromResolvedHandle(handle, action, counter) {
+    try {
+      return await this.buildPathFromResolvedHandle(handle, action, counter);
+    } catch (error) {
+      this.logDebugError(
+        `path persistence skipped for ${action} counter ${counter}`,
+        error
+      );
+      return null;
+    }
+  }
   withIndexedIframeContext(builtPath, indexedPath) {
     const normalizedBuilt = this.normalizePath(builtPath);
     if (!indexedPath) return normalizedBuilt;
     const iframePrefix = collectIframeContextPrefix(indexedPath);
     if (!iframePrefix.length) return normalizedBuilt;
+    const builtContext = cloneContextHops(normalizedBuilt.context);
+    const overlap = measureContextOverlap(iframePrefix, builtContext);
+    const missingPrefix = cloneContextHops(
+      iframePrefix.slice(0, iframePrefix.length - overlap)
+    );
+    if (!missingPrefix.length) {
+      return normalizedBuilt;
+    }
     const merged = {
       context: [
-        ...cloneContextHops(iframePrefix),
-        ...cloneContextHops(normalizedBuilt.context)
+        ...missingPrefix,
+        ...builtContext
       ],
       nodes: cloneElementPath(normalizedBuilt).nodes
     };
@@ -11595,9 +11411,48 @@ var Opensteer = class _Opensteer {
     if (fallback.nodes.length) return fallback;
     return normalizedBuilt;
   }
+  async withHandleIframeContext(handle, path5) {
+    const ownFrame = await handle.ownerFrame();
+    if (!ownFrame) {
+      return this.normalizePath(path5);
+    }
+    let frame = ownFrame;
+    let prefix = [];
+    while (frame && frame !== this.page.mainFrame()) {
+      const parent = frame.parentFrame();
+      if (!parent) break;
+      const frameElement = await frame.frameElement().catch(() => null);
+      if (!frameElement) break;
+      try {
+        const frameElementPath = await buildElementPathFromHandle(frameElement);
+        if (frameElementPath?.nodes.length) {
+          const segment = [
+            ...cloneContextHops(frameElementPath.context),
+            {
+              kind: "iframe",
+              host: cloneElementPath(frameElementPath).nodes
+            }
+          ];
+          prefix = [...segment, ...prefix];
+        }
+      } finally {
+        await frameElement.dispose().catch(() => void 0);
+      }
+      frame = parent;
+    }
+    if (!prefix.length) {
+      return this.normalizePath(path5);
+    }
+    return this.normalizePath({
+      context: [...prefix, ...cloneContextHops(path5.context)],
+      nodes: cloneElementPath(path5).nodes
+    });
+  }
   async readPathFromCounterIndex(counter) {
-    const snapshot = await this.ensureSnapshotWithCounters();
-    const indexed = snapshot.counterIndex?.get(counter);
+    if (!this.snapshotCache || this.snapshotCache.url !== this.page.url() || !this.snapshotCache.counterIndex) {
+      return null;
+    }
+    const indexed = this.snapshotCache.counterIndex.get(counter);
     if (!indexed) return null;
     const normalized = this.normalizePath(indexed);
     if (!normalized.nodes.length) return null;
@@ -11608,15 +11463,6 @@ var Opensteer = class _Opensteer {
     if (!path5) return null;
     return this.normalizePath(path5);
   }
-  async ensureSnapshotWithCounters() {
-    if (!this.snapshotCache || !this.snapshotCache.counterBindings || this.snapshotCache.url !== this.page.url()) {
-      await this.snapshot({
-        mode: "full",
-        withCounters: true
-      });
-    }
-    return this.snapshotCache;
-  }
   persistPath(id, method, description, path5) {
     const now = Date.now();
     const safeFile = this.storage.getSelectorFileName(id);
@@ -11866,17 +11712,6 @@ var Opensteer = class _Opensteer {
         return;
       }
       if (normalized.element != null) {
-        const path5 = await this.tryBuildPathFromCounter(
-          normalized.element
-        );
-        if (path5) {
-          fields.push({
-            key: fieldKey,
-            path: path5,
-            attribute: normalized.attribute
-          });
-          return;
-        }
         fields.push({
           key: fieldKey,
           counter: normalized.element,
@@ -11921,15 +11756,6 @@ var Opensteer = class _Opensteer {
         continue;
       }
       if (fieldPlan.element != null) {
-        const path6 = await this.tryBuildPathFromCounter(fieldPlan.element);
-        if (path6) {
-          fields.push({
-            key,
-            path: path6,
-            attribute: fieldPlan.attribute
-          });
-          continue;
-        }
         fields.push({
           key,
           counter: fieldPlan.element,
@@ -11984,12 +11810,7 @@ var Opensteer = class _Opensteer {
       }
     }
     if (counterRequests.length) {
-      const snapshot = await this.ensureSnapshotWithCounters();
-      const counterValues = await resolveCountersBatch(
-        this.page,
-        snapshot,
-        counterRequests
-      );
+      const counterValues = await resolveCountersBatch(this.page, counterRequests);
       Object.assign(result, counterValues);
     }
     if (pathFields.length) {
@@ -12019,7 +11840,7 @@ var Opensteer = class _Opensteer {
       const path5 = await this.buildPathFromElement(field.counter);
       if (!path5) {
         throw new Error(
-          `Unable to build element path from counter ${field.counter} for extraction field "${field.key}".`
+          `Unable to persist extraction schema field "${field.key}": counter ${field.counter} could not be converted into a stable element path.`
         );
       }
       resolved.push({
@@ -12065,6 +11886,33 @@ function collectIframeContextPrefix(path5) {
   if (lastIframeIndex < 0) return [];
   return cloneContextHops(context.slice(0, lastIframeIndex + 1));
 }
+function measureContextOverlap(indexedPrefix, builtContext) {
+  const maxOverlap = Math.min(indexedPrefix.length, builtContext.length);
+  for (let size = maxOverlap; size > 0; size -= 1) {
+    if (matchesContextPrefix(indexedPrefix, builtContext, size, true)) {
+      return size;
+    }
+  }
+  for (let size = maxOverlap; size > 0; size -= 1) {
+    if (matchesContextPrefix(indexedPrefix, builtContext, size, false)) {
+      return size;
+    }
+  }
+  return 0;
+}
+function matchesContextPrefix(indexedPrefix, builtContext, size, strictHost) {
+  for (let idx = 0; idx < size; idx += 1) {
+    const left = indexedPrefix[indexedPrefix.length - size + idx];
+    const right = builtContext[idx];
+    if (left.kind !== right.kind) {
+      return false;
+    }
+    if (strictHost && JSON.stringify(left.host) !== JSON.stringify(right.host)) {
+      return false;
+    }
+  }
+  return true;
+}
 function normalizeSchemaValue(value) {
   if (!value) return null;
   if (typeof value !== "object" || Array.isArray(value)) {
@@ -12322,7 +12170,7 @@ function isInternalOrBlankPageUrl(url) {
 }
 function buildLocalRunId(namespace) {
   const normalized = namespace.trim() || "default";
-  return `${normalized}-${Date.now().toString(36)}-${randomUUID2().slice(0, 8)}`;
+  return `${normalized}-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
 }
 
 export {
@@ -12352,13 +12200,12 @@ export {
   cleanForClickable,
   cleanForScrollable,
   cleanForAction,
-  CounterResolutionError,
-  ensureLiveCounters,
-  resolveCounterElement,
-  resolveCountersBatch,
   prepareSnapshot,
   ElementPathError,
   resolveElementPath,
+  CounterResolutionError,
+  resolveCounterElement,
+  resolveCountersBatch,
   performClick,
   performHover,
   performInput,