pi-agent-browser-native 0.9.3 → 0.9.4

package/dist/extensions/agent-browser/lib/results/snapshot-compact.js

@@ -0,0 +1,266 @@
+import { getSnapshotOrigin, getSnapshotText } from "./snapshot-content.js";
+import { isHighValueControlEntry, selectHighValueControlEntries, } from "./snapshot-high-value-controls.js";
+import { enrichSnapshotRefEntries, getSnapshotRefEntries, } from "./snapshot-refs.js";
+import { buildFallbackSnapshotOutline, buildRefLineOrderMap, buildSegmentPreview, buildSnapshotSegments, canUseStructuredSnapshotPreview, chooseAdditionalSegments, choosePrimarySegment, getMeaningfulSegmentLines, getSnapshotRolePriority, isChromeSectionName, isNoiseName, parseSnapshotLines, } from "./snapshot-segments.js";
+import { compareRefIds, countLines, truncateText } from "./text.js";
+const PRIMARY_PREVIEW_LINES = 8;
+const SECTION_PREVIEW_LINES = 2;
+const KEY_REF_MAX_LINES = 8;
+const OTHER_REF_MAX_LINES = 4;
+const HIGH_VALUE_REF_MAX_LINES = 10;
+function getSnapshotRoleCounts(entries) {
+    const counts = {};
+    for (const entry of entries) {
+        counts[entry.role] = (counts[entry.role] ?? 0) + 1;
+    }
+    return counts;
+}
+function formatRoleCounts(counts) {
+    const entries = Object.entries(counts);
+    if (entries.length === 0) {
+        return undefined;
+    }
+    const ordered = entries.sort((left, right) => right[1] !== left[1]
+        ? right[1] - left[1]
+        : getSnapshotRolePriority(left[0]) - getSnapshotRolePriority(right[0]));
+    const visible = ordered.slice(0, 4).map(([role, count]) => `${role} ${count}`);
+    const omitted = Math.max(0, ordered.length - visible.length);
+    if (omitted > 0) {
+        visible.push(`+${omitted} more`);
+    }
+    return visible.join(", ");
+}
+function rankRefEntries(entries, preview, focus, lines) {
+    const previewIds = new Set(preview);
+    const focusIds = new Set(focus);
+    const order = buildRefLineOrderMap(lines);
+    const refBucket = (id) => {
+        if (previewIds.has(id)) {
+            return 0;
+        }
+        return focusIds.has(id) ? 1 : 2;
+    };
+    return [...entries].sort((left, right) => {
+        const bucketDifference = refBucket(left.id) - refBucket(right.id);
+        if (bucketDifference !== 0) {
+            return bucketDifference;
+        }
+        const roleDifference = getSnapshotRolePriority(left.role) - getSnapshotRolePriority(right.role);
+        if (roleDifference !== 0) {
+            return roleDifference;
+        }
+        const nameDifference = Number(left.name.length === 0) - Number(right.name.length === 0);
+        if (nameDifference !== 0) {
+            return nameDifference;
+        }
+        const lineDifference = (order.get(left.id) ?? Number.MAX_SAFE_INTEGER) -
+            (order.get(right.id) ?? Number.MAX_SAFE_INTEGER);
+        return lineDifference !== 0 ? lineDifference : compareRefIds(left.id, right.id);
+    });
+}
+function getFallbackPreview(lines, structured, primary) {
+    return !structured || !primary || primary.lines.length === 0
+        ? buildFallbackSnapshotOutline(lines)
+        : undefined;
+}
+function buildPagePreview(lines, entries) {
+    const useStructured = canUseStructuredSnapshotPreview(lines, entries);
+    const segments = useStructured ? buildSnapshotSegments(lines) : [];
+    const primarySegment = useStructured ? choosePrimarySegment(segments) : undefined;
+    const additionalSegments = useStructured
+        ? chooseAdditionalSegments(segments, primarySegment)
+        : [];
+    const additionalSegmentCount = primarySegment ? Math.max(0, segments.length - 1) : 0;
+    const primaryPreview = primarySegment
+        ? buildSegmentPreview(primarySegment, PRIMARY_PREVIEW_LINES)
+        : undefined;
+    return {
+        useStructured,
+        primarySegment,
+        primaryPreview,
+        additionalSegments,
+        additionalPreviews: additionalSegments
+            .map((segment) => ({ segment, preview: buildSegmentPreview(segment, SECTION_PREVIEW_LINES) }))
+            .filter(({ preview }) => preview.lines.length > 0),
+        fallbackPreview: getFallbackPreview(lines, useStructured, primaryPreview),
+        omittedAdditionalSectionCount: Math.max(0, additionalSegmentCount - additionalSegments.length),
+    };
+}
+function getPreviewRefIds(page) {
+    return [
+        ...new Set([
+            ...(page.primaryPreview?.refIds ?? []),
+            ...page.additionalPreviews.flatMap(({ preview }) => preview.refIds),
+            ...(page.fallbackPreview?.refIds ?? []),
+        ]),
+    ];
+}
+function getFocusRefIds(page) {
+    const primary = page.useStructured && page.primarySegment ? getMeaningfulSegmentLines(page.primarySegment) : [];
+    const additional = page.useStructured
+        ? page.additionalSegments.flatMap(getMeaningfulSegmentLines)
+        : [];
+    return [
+        ...new Set([...primary, ...additional]
+            .flatMap((line) => (line.ref !== undefined && line.ref.length > 0 ? [line.ref] : []))
+            .concat(page.fallbackPreview?.refIds ?? [])),
+    ];
+}
+function selectCompactRefs(entries) {
+    const visible = entries.filter((entry) => !isNoiseName(entry.name) &&
+        !isChromeSectionName(entry.name) &&
+        !(entry.role === "heading" && entry.name.length <= 2));
+    const key = visible.slice(0, KEY_REF_MAX_LINES);
+    const keyIds = new Set(key.map((entry) => entry.id));
+    const other = visible.filter((entry) => !keyIds.has(entry.id)).slice(0, OTHER_REF_MAX_LINES);
+    const displayedIds = new Set([...key, ...other].map((entry) => entry.id));
+    const omitted = visible.filter((entry) => !displayedIds.has(entry.id));
+    const highValueCandidates = omitted.filter((entry) => isHighValueControlEntry(entry) &&
+        !isNoiseName(entry.name) &&
+        !isChromeSectionName(entry.name));
+    const highValue = selectHighValueControlEntries(highValueCandidates, HIGH_VALUE_REF_MAX_LINES);
+    return {
+        key,
+        other,
+        highValue,
+        omittedHighValueControls: Math.max(0, highValueCandidates.length - highValue.length),
+        omittedNonHighlightedRefs: Math.max(0, omitted.length - highValueCandidates.length),
+    };
+}
+function formatCompactRef(entry) {
+    const suffix = entry.name.length > 0 ? ` "${truncateText(entry.name, 96)}"` : "";
+    return `- ${entry.id} ${entry.role}${suffix}`;
+}
+function formatAdditionalPreviews(page) {
+    if (page.additionalPreviews.length === 0) {
+        return [];
+    }
+    const lines = ["", "Additional sections:"];
+    page.additionalPreviews.forEach(({ preview }, index) => {
+        if (index > 0) {
+            lines.push("");
+        }
+        lines.push(...preview.lines);
+        if (preview.omittedCount > 0) {
+            lines.push(`- ... (${preview.omittedCount} more lines in this section)`);
+        }
+    });
+    if (page.omittedAdditionalSectionCount > 0) {
+        lines.push(`- ... (${page.omittedAdditionalSectionCount} more sections omitted)`);
+    }
+    return lines;
+}
+function formatFallbackPreview(preview, fullOutputPath) {
+    const lines = [
+        "",
+        "Compact outline:",
+        ...(preview.lines.length > 0 ? preview.lines : ["(no interactive elements)"]),
+    ];
+    if (preview.omittedCount > 0) {
+        const source = fullOutputPath !== undefined && fullOutputPath.length > 0
+            ? `full output path: ${fullOutputPath}`
+            : "the full redacted snapshot was omitted";
+        lines.push(`- ... (${preview.omittedCount} additional snapshot lines omitted; ${source})`);
+    }
+    return lines;
+}
+function formatPagePreview(page, fullOutputPath) {
+    if (page.fallbackPreview) {
+        return formatFallbackPreview(page.fallbackPreview, fullOutputPath);
+    }
+    const lines = [
+        "",
+        "Primary content:",
+        ...(page.primaryPreview?.lines ?? ["(no interactive elements)"]),
+    ];
+    if ((page.primaryPreview?.omittedCount ?? 0) > 0) {
+        lines.push(`- ... (${page.primaryPreview?.omittedCount ?? "undefined"} more lines in this section)`);
+    }
+    return [...lines, ...formatAdditionalPreviews(page)];
+}
+function formatRefSelection(selection) {
+    const lines = [
+        "",
+        "Key refs:",
+        ...(selection.key.length > 0 ? selection.key.map(formatCompactRef) : ["(no refs)"]),
+    ];
+    if (selection.other.length > 0) {
+        lines.push("", "Other refs:", ...selection.other.map(formatCompactRef));
+    }
+    if (selection.omittedNonHighlightedRefs > 0) {
+        lines.push(`- ... (${selection.omittedNonHighlightedRefs} additional refs omitted)`);
+    }
+    if (selection.highValue.length > 0) {
+        lines.push("", "Omitted high-value controls:", ...selection.highValue.map(formatCompactRef));
+        if (selection.omittedHighValueControls > 0) {
+            lines.push(`- ... (${selection.omittedHighValueControls} additional high-value controls omitted)`);
+        }
+    }
+    return lines;
+}
+function getPreviewSections(page) {
+    const primary = page.primarySegment
+        ? [
+            {
+                linesShown: page.primaryPreview?.lines.length ?? 0,
+                omittedLines: page.primaryPreview?.omittedCount ?? 0,
+                role: page.primarySegment.root.role,
+                title: page.primarySegment.root.name,
+            },
+        ]
+        : [];
+    return [
+        ...primary,
+        ...page.additionalPreviews.map(({ preview, segment }) => ({
+            linesShown: preview.lines.length,
+            omittedLines: preview.omittedCount,
+            role: segment.root.role,
+            title: segment.root.name,
+        })),
+    ];
+}
+export function buildCompactSnapshotView(data, fullOutputPath, spillErrorText) {
+    const snapshot = getSnapshotText(data) ?? "(no interactive elements)";
+    const snapshotLines = parseSnapshotLines(snapshot);
+    const refEntries = enrichSnapshotRefEntries(getSnapshotRefEntries(data), snapshotLines);
+    const roleCounts = getSnapshotRoleCounts(refEntries);
+    const roleCountsText = formatRoleCounts(roleCounts);
+    const page = buildPagePreview(snapshotLines, refEntries);
+    const previewRefIds = getPreviewRefIds(page);
+    const ranked = rankRefEntries(refEntries, previewRefIds, getFocusRefIds(page), page.useStructured ? snapshotLines : []);
+    const refs = selectCompactRefs(ranked);
+    const origin = getSnapshotOrigin(data);
+    const lines = [
+        `Origin: ${origin}`,
+        `Refs: ${refEntries.length}`,
+        ...(roleCountsText !== undefined ? [`Top roles: ${roleCountsText}`] : []),
+        "",
+        "Compact snapshot view.",
+        "Viewport note: compact snapshots are DOM/signal-prioritized, not guaranteed to start with the currently scrolled viewport; use the full redacted snapshot, a screenshot, or listed high-value refs when viewport context matters.",
+        ...formatPagePreview(page, fullOutputPath),
+        ...formatRefSelection(refs),
+        "",
+        fullOutputPath !== undefined && fullOutputPath.length > 0
+            ? `Full redacted snapshot path: ${fullOutputPath}`
+            : `Full redacted snapshot unavailable: ${spillErrorText ?? "temp spill file could not be created."}`,
+    ];
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        data: {
+            compacted: true,
+            fullOutputPath,
+            origin,
+            previewMode: page.fallbackPreview ? "outline" : "structured",
+            viewportOrdering: "dom-signal-prioritized",
+            spillError: spillErrorText,
+            previewRefIds,
+            highValueControlRefIds: refs.highValue.map((entry) => entry.id),
+            additionalSectionsOmitted: page.omittedAdditionalSectionCount,
+            previewSections: getPreviewSections(page),
+            refCount: refEntries.length,
+            roleCounts,
+            snapshotLineCount: countLines(snapshot),
+            structuredPreviewUsed: !page.fallbackPreview,
+        },
+    };
+}

package/dist/extensions/agent-browser/lib/results/snapshot-content.js

@@ -0,0 +1,32 @@
+import { isRecord } from "../parsing.js";
+import { getFullSnapshotData, getSnapshotRefEntries } from "./snapshot-refs.js";
+import { stringifyUnknown } from "./text.js";
+export function getSnapshotText(data) {
+    const full = getFullSnapshotData(data);
+    if (typeof full?.snapshot === "string") {
+        return full.snapshot;
+    }
+    return isRecord(data.snapshot) ? JSON.stringify(data.snapshot) : undefined;
+}
+export function getSnapshotOrigin(data) {
+    return typeof data.origin === "string" ? data.origin : "(unknown origin)";
+}
+export function formatSnapshotSummary(data) {
+    const origin = typeof data.origin === "string" ? data.origin : "page";
+    if (isRecord(data.snapshot) && data.snapshot.kind !== "full") {
+        return `Snapshot ${stringifyUnknown(data.snapshot.kind)}: revision ${stringifyUnknown(data.snapshot.revision)} on ${origin}`;
+    }
+    return `Snapshot: ${getSnapshotRefEntries(data).length} refs on ${origin}`;
+}
+export function formatRawSnapshotText(data) {
+    const origin = getSnapshotOrigin(data);
+    const refs = getSnapshotRefEntries(data).length;
+    const snapshot = getSnapshotText(data);
+    if (isRecord(data.snapshot) && data.snapshot.kind !== "full") {
+        return `Origin: ${origin}\n${formatSnapshotSummary(data)}\n\n${snapshot ?? "undefined"}`;
+    }
+    if (snapshot === undefined || snapshot.length === 0) {
+        return `Origin: ${origin}\nRefs: ${refs}\n\n(no interactive elements)`;
+    }
+    return `Origin: ${origin}\nRefs: ${refs}\n\n${snapshot}`;
+}

package/dist/extensions/agent-browser/lib/results/snapshot-high-value-controls.js

@@ -36,22 +36,28 @@ const SNAPSHOT_PRIMARY_ACTION_BUTTON_NAME_PATTERNS = [
     /^(?:add|apply|ask|confirm|connect|continue|create|launch|new|open|refresh|retry|run|save|search|send|start|submit)\b/i,
 ];
 function getHighValueControlRole(entry) {
-    return entry.isEditable === true && (entry.role === "unknown" || entry.role === "generic") ? "textbox" : entry.role;
+    return entry.isEditable === true && (entry.role === "unknown" || entry.role === "generic")
+        ? "textbox"
+        : entry.role;
 }
 function isEditableControlRef(entry) {
-    if (entry.isEditable === false)
+    if (entry.isEditable === false) {
         return false;
+    }
     const role = getHighValueControlRole(entry);
-    return entry.isEditable === true || role === "searchbox" || role === "textbox" || role === "combobox";
+    return (entry.isEditable === true || role === "searchbox" || role === "textbox" || role === "combobox");
 }
 function isNamedSurfaceControlRef(entry) {
-    if (entry.name.length === 0)
+    if (entry.name.length === 0) {
         return false;
+    }
     const role = getHighValueControlRole(entry);
-    if (role === "tab")
+    if (role === "tab") {
         return true;
-    if (role !== "button" && role !== "menuitem" && role !== "option")
+    }
+    if (role !== "button" && role !== "menuitem" && role !== "option") {
         return false;
+    }
     return SNAPSHOT_SURFACE_CONTROL_NAME_PATTERNS.some((pattern) => pattern.test(entry.name));
 }
 function isPrimaryActionButtonRef(entry) {
@@ -100,24 +106,30 @@ function isNamedActionLinkRef(entry) {
 }
 export function isHighValueControlEntry(entry) {
     const role = getHighValueControlRole(entry);
-    if (!SNAPSHOT_HIGH_VALUE_CONTROL_ROLES.has(role))
+    if (!SNAPSHOT_HIGH_VALUE_CONTROL_ROLES.has(role)) {
         return false;
-    if (role === "link")
+    }
+    if (role === "link") {
         return isNamedActionLinkRef(entry);
-    if (entry.isEditable === false && (role === "searchbox" || role === "textbox" || role === "combobox"))
+    }
+    if (entry.isEditable === false &&
+        (role === "searchbox" || role === "textbox" || role === "combobox")) {
         return false;
+    }
     return entry.name.length > 0 || isEditableControlRef(entry);
 }
 function getHighValueControlCategoryRule(entry, role) {
     return SNAPSHOT_HIGH_VALUE_CONTROL_CATEGORY_RULES.find((rule) => rule.matches(entry, role));
 }
 function classifyHighValueControlRef(entry) {
-    if (!isHighValueControlEntry(entry))
+    if (!isHighValueControlEntry(entry)) {
         return undefined;
+    }
     const role = getHighValueControlRole(entry);
     const rule = getHighValueControlCategoryRule(entry, role);
-    if (!rule)
+    if (!rule) {
         return undefined;
+    }
     return {
         entry,
         score: {
@@ -134,74 +146,95 @@ function classifyHighValueControlRef(entry) {
     };
 }
 function compareHighValueControlCandidates(left, right) {
-    return (left.score.categoryPriority - right.score.categoryPriority ||
-        left.score.rolePriority - right.score.rolePriority ||
-        left.score.namePriority - right.score.namePriority ||
-        left.score.lineIndex - right.score.lineIndex ||
+    const differences = [
+        left.score.categoryPriority - right.score.categoryPriority,
+        left.score.rolePriority - right.score.rolePriority,
+        left.score.namePriority - right.score.namePriority,
+        left.score.lineIndex - right.score.lineIndex,
+    ];
+    return (differences.find((difference) => difference !== 0 && !Number.isNaN(difference)) ??
         compareRefIds(left.score.refId, right.score.refId));
 }
-function takeHighValueCandidate(candidate, selected, selectedIds) {
-    selected.push(candidate);
-    selectedIds.add(candidate.entry.id);
-}
-function takeFirstPerDiversityBucket(candidates, selected, selectedIds, limit) {
-    const seenBuckets = new Set();
-    for (const candidate of candidates) {
-        if (selected.length >= limit)
-            break;
-        if (seenBuckets.has(candidate.score.diversityBucketKey))
-            continue;
-        seenBuckets.add(candidate.score.diversityBucketKey);
-        takeHighValueCandidate(candidate, selected, selectedIds);
+class HighValueSelection {
+    selected = [];
+    selectedIds = new Set();
+    candidates;
+    limit;
+    constructor(candidates, limit) {
+        this.candidates = candidates;
+        this.limit = limit;
     }
-}
-function topUpHighValueCategory(candidates, selected, selectedIds, category, target, limit) {
-    let count = selected.filter((candidate) => candidate.score.category === category).length;
-    for (const candidate of candidates) {
-        if (selected.length >= limit || count >= target)
-            break;
-        if (selectedIds.has(candidate.entry.id) || candidate.score.category !== category)
-            continue;
-        takeHighValueCandidate(candidate, selected, selectedIds);
-        count += 1;
+    take(candidate) {
+        this.selected.push(candidate);
+        this.selectedIds.add(candidate.entry.id);
     }
-}
-function buildRemainingHighValueBuckets(candidates, selectedIds) {
-    const buckets = new Map();
-    for (const candidate of candidates) {
-        if (selectedIds.has(candidate.entry.id))
-            continue;
-        const bucket = buckets.get(candidate.score.roundRobinBucketKey);
-        if (bucket)
-            bucket.push(candidate);
-        else
-            buckets.set(candidate.score.roundRobinBucketKey, [candidate]);
-    }
-    return [...buckets.values()].sort((left, right) => compareHighValueControlCandidates(left[0], right[0]));
-}
-function roundRobinHighValueBuckets(buckets, selected, selectedIds, limit) {
-    let bucketIndex = 0;
-    while (selected.length < limit && buckets.some((bucket) => bucket.length > 0)) {
-        const bucket = buckets[bucketIndex % buckets.length];
-        const candidate = bucket.shift();
-        if (candidate)
-            takeHighValueCandidate(candidate, selected, selectedIds);
-        bucketIndex += 1;
+    takeFirstPerDiversityBucket() {
+        const seenBuckets = new Set();
+        for (const candidate of this.candidates) {
+            if (this.selected.length >= this.limit) {
+                break;
+            }
+            if (!seenBuckets.has(candidate.score.diversityBucketKey)) {
+                seenBuckets.add(candidate.score.diversityBucketKey);
+                this.take(candidate);
+            }
+        }
+    }
+    topUp(category, target) {
+        let count = this.selected.filter((candidate) => candidate.score.category === category).length;
+        for (const candidate of this.candidates) {
+            if (this.selected.length >= this.limit || count >= target) {
+                break;
+            }
+            if (!this.selectedIds.has(candidate.entry.id) && candidate.score.category === category) {
+                this.take(candidate);
+                count += 1;
+            }
+        }
+    }
+    buildRemainingBuckets() {
+        const buckets = new Map();
+        for (const candidate of this.candidates) {
+            if (this.selectedIds.has(candidate.entry.id)) {
+                continue;
+            }
+            const key = candidate.score.roundRobinBucketKey;
+            const bucket = buckets.get(key);
+            if (bucket) {
+                bucket.push(candidate);
+            }
+            else {
+                buckets.set(key, [candidate]);
+            }
+        }
+        return [...buckets.values()].sort((left, right) => compareHighValueControlCandidates(left[0], right[0]));
+    }
+    fillRemaining() {
+        const buckets = this.buildRemainingBuckets();
+        let bucketIndex = 0;
+        while (this.selected.length < this.limit && buckets.some((bucket) => bucket.length > 0)) {
+            const candidate = buckets[bucketIndex % buckets.length].shift();
+            if (candidate) {
+                this.take(candidate);
+            }
+            bucketIndex += 1;
+        }
+    }
+    select() {
+        this.takeFirstPerDiversityBucket();
+        for (const rule of SNAPSHOT_HIGH_VALUE_CONTROL_CATEGORY_RULES) {
+            if (rule.fillTarget !== undefined) {
+                this.topUp(rule.id, rule.fillTarget);
+            }
+        }
+        this.fillRemaining();
+        return this.selected.map((candidate) => candidate.entry);
     }
 }
 export function selectHighValueControlEntries(entries, limit) {
     const candidates = entries
         .map(classifyHighValueControlRef)
-        .filter((candidate) => Boolean(candidate))
+        .filter((candidate) => candidate !== undefined)
         .sort(compareHighValueControlCandidates);
-    const selected = [];
-    const selectedIds = new Set();
-    takeFirstPerDiversityBucket(candidates, selected, selectedIds, limit);
-    for (const rule of SNAPSHOT_HIGH_VALUE_CONTROL_CATEGORY_RULES) {
-        if (rule.fillTarget === undefined)
-            continue;
-        topUpHighValueCategory(candidates, selected, selectedIds, rule.id, rule.fillTarget, limit);
-    }
-    roundRobinHighValueBuckets(buildRemainingHighValueBuckets(candidates, selectedIds), selected, selectedIds, limit);
-    return selected.map((candidate) => candidate.entry);
+    return new HighValueSelection(candidates, limit).select();
 }

package/dist/extensions/agent-browser/lib/results/snapshot-refs.js

@@ -3,10 +3,12 @@ import { getEditableRefEvidence } from "./editable-ref-evidence.js";
 import { compareRefIds, normalizeWhitespace } from "./text.js";
 /** Project native delta full responses onto the ordinary snapshot shape for local readers. */
 export function getFullSnapshotData(data) {
-    if (!isRecord(data))
+    if (!isRecord(data)) {
         return undefined;
-    if (!isRecord(data.snapshot))
+    }
+    if (!isRecord(data.snapshot)) {
         return data;
+    }
     return data.snapshot.kind === "full"
         ? { ...data, snapshot: data.snapshot.tree, refs: data.snapshot.refs }
         : undefined;
@@ -21,16 +23,18 @@ export function getSnapshotLineTextByRef(data) {
     const lineByRef = new Map();
     for (const line of snapshot.split("\n")) {
         const ref = line.match(/\bref=([^,\]\s]+)/)?.[1];
-        if (!ref || lineByRef.has(ref))
+        if (ref === undefined || ref.length === 0 || lineByRef.has(ref)) {
             continue;
+        }
         lineByRef.set(ref, line);
     }
     return lineByRef;
 }
 export function getSnapshotRefEntries(data) {
     const refs = getSnapshotRefRecord(data);
-    if (!refs)
+    if (!refs) {
         return [];
+    }
     return Object.entries(refs)
         .map(([id, value]) => {
         if (!isRecord(value)) {
@@ -45,9 +49,12 @@ export function getSnapshotRefEntries(data) {
 }
 function isEditableSnapshotLine(line) {
     const editableEvidence = getEditableRefEvidence({ text: line.raw });
-    if (editableEvidence !== undefined)
+    if (editableEvidence !== undefined) {
         return editableEvidence;
-    return line.role === "searchbox" || line.role === "textbox" || line.role === "combobox" ? true : undefined;
+    }
+    return line.role === "searchbox" || line.role === "textbox" || line.role === "combobox"
+        ? true
+        : undefined;
 }
 export function getSnapshotRefRole(entry, editableEvidence) {
     const rawRole = typeof entry.role === "string" && entry.role.length > 0 ? entry.role : "unknown";
@@ -57,20 +64,33 @@ export function getSnapshotRefRole(entry, editableEvidence) {
     }
     return rawRole;
 }
+function getSnapshotRefFallbackRole(role, line) {
+    if (role !== "unknown" && role !== "generic") {
+        return role;
+    }
+    return line && line.role !== "unknown" ? line.role : role;
+}
+function resolveSnapshotRefEditableEvidence(evidence, line) {
+    if (evidence !== undefined) {
+        return evidence;
+    }
+    return (line !== undefined &&
+        isEditableSnapshotLine(line) === true &&
+        !["unknown", "generic"].includes(line.role));
+}
 export function enrichSnapshotRefEntries(refEntries, snapshotLines) {
     const lineByRef = new Map();
     for (const line of snapshotLines) {
-        if (!line.ref || lineByRef.has(line.ref))
+        if (line.ref === undefined || line.ref.length === 0 || lineByRef.has(line.ref)) {
             continue;
+        }
         lineByRef.set(line.ref, line);
     }
     return refEntries.map((entry) => {
         const line = lineByRef.get(entry.id);
-        const lineRole = line && line.role !== "unknown" ? line.role : undefined;
         const editableEvidence = getEditableRefEvidence({ ref: entry.refData, text: line?.raw });
-        const hasEditableRole = line ? isEditableSnapshotLine(line) === true && !["unknown", "generic"].includes(line.role) : false;
-        const isEditable = editableEvidence === true || (editableEvidence !== false && hasEditableRole);
-        const roleFromRefOrLine = entry.role !== "unknown" && entry.role !== "generic" ? entry.role : lineRole ?? entry.role;
+        const isEditable = resolveSnapshotRefEditableEvidence(editableEvidence, line);
+        const roleFromRefOrLine = getSnapshotRefFallbackRole(entry.role, line);
         const role = getSnapshotRefRole({ role: roleFromRefOrLine }, isEditable);
         return {
             ...entry,