@mercuryo-ai/agentbrowse 0.2.61 → 0.2.63

package/dist/commands/observe-semantics.js

@@ -105,115 +105,501 @@ export function observedTargetKey(target) {
         target.domSignature ??
         `${target.formSelector ?? 'no-form'}|${target.ordinal ?? 'no-ordinal'}|${target.label ?? ''}`);
 }
-function normalizeEmbeddedSurfaceText(value) {
-    const normalized = value?.replace(/\s+/g, ' ').trim();
-    return normalized ? normalized : undefined;
+const EXPLICIT_BOUNDARY_OWNER_KINDS = new Set([
+    'dialog',
+    'listbox',
+    'menu',
+    'grid',
+    'tabpanel',
+    'popover',
+    'dropdown',
+    'datepicker',
+    'form',
+]);
+const SHELL_BOUNDARY_OWNER_KINDS = new Set([
+    'floating-panel',
+    'sticky-panel',
+    'section',
+    'aside',
+    'main',
+]);
+const ACTION_ONLY_OWNER_LABEL_RE = /^(?:select|book|buy|choose|continue|next|more|details|view|open|pay|submit|click)$/i;
+const PRIMARY_ACTION_OWNER_LABEL_RE = /^(?:select|book|buy|choose|continue|next|pay|submit)$/i;
+function normalizeOwnerText(value) {
+    const normalized = (value ?? '').replace(/\s+/g, ' ').trim();
+    return normalized || undefined;
 }
-function embeddedSurfaceFrameKeyOf(target) {
-    if (target.framePath?.length) {
-        return target.framePath.join('>');
-    }
-    const frameUrl = normalizeEmbeddedSurfaceText(target.frameUrl);
-    return frameUrl ? `url:${frameUrl}` : 'top';
+function ownerCandidateSurfaceLabelOf(candidate) {
+    return (normalizeOwnerText(candidate.label) ??
+        normalizeOwnerText(candidate.text) ??
+        normalizeOwnerText(candidate.fallbackLabel));
 }
-function compactEmbeddedSurfaceLabel(...values) {
-    for (const value of values) {
-        const normalized = normalizeEmbeddedSurfaceText(value);
-        if (normalized && normalized.length <= 80) {
-            return normalized;
-        }
+function ownerCandidateRefinesContext(candidate) {
+    const surfaceLabel = ownerCandidateSurfaceLabelOf(candidate);
+    if (!surfaceLabel) {
+        return false;
     }
-    return undefined;
+    return !ACTION_ONLY_OWNER_LABEL_RE.test(surfaceLabel);
 }
-function isEmbeddedInteractiveControl(target) {
-    if ((target.surfaceRef ?? '').trim().length > 0) {
-        return false;
+function ownerCandidateContextBlockCountOf(candidate) {
+    return Math.max(candidate.directTextBlockCount ?? 0, estimatedTextBlockCount(ownerCandidateSurfaceLabelOf(candidate)));
+}
+function targetSharedOwnerSupportLabelOf(target) {
+    return (normalizeOwnerText(target.displayLabel) ??
+        normalizeOwnerText(target.label) ??
+        normalizeOwnerText(target.currentValue));
+}
+function targetSupportsSharedOwnerPrimaryAction(target) {
+    const label = targetSharedOwnerSupportLabelOf(target);
+    return Boolean(label && PRIMARY_ACTION_OWNER_LABEL_RE.test(label));
+}
+function targetSupportsSharedOwnerIdentity(target) {
+    const label = targetSharedOwnerSupportLabelOf(target);
+    if (label && !ACTION_ONLY_OWNER_LABEL_RE.test(label)) {
+        return true;
     }
-    const allowedActions = target.allowedActions ?? [];
-    if (allowedActions.length === 0) {
-        return false;
+    return Boolean(target.selection?.items?.some((item) => {
+        const itemLabel = normalizeOwnerText(item.label);
+        return Boolean(itemLabel && !ACTION_ONLY_OWNER_LABEL_RE.test(itemLabel));
+    }));
+}
+function ownerCandidateKindHintOf(candidate) {
+    return normalizeOwnerText(candidate.surfaceKind)?.toLowerCase();
+}
+function ownerCandidateKindOf(candidate) {
+    return ownerCandidateKindHintOf(candidate) ?? normalizeOwnerText(candidate.kind)?.toLowerCase();
+}
+function defaultPriorityForOwnerKind(kind) {
+    switch (kind) {
+        case 'dialog':
+            return 100;
+        case 'listbox':
+        case 'menu':
+            return 95;
+        case 'floating-panel':
+            return 92;
+        case 'datepicker':
+            return 90;
+        case 'sticky-panel':
+            return 88;
+        case 'popover':
+        case 'dropdown':
+            return 85;
+        case 'grid':
+        case 'tabpanel':
+            return 80;
+        case 'form':
+            return 70;
+        case 'card':
+            return 58;
+        case 'group':
+            return 55;
+        case 'section':
+        case 'aside':
+            return 52;
+        case 'listitem':
+        case 'row':
+            return 48;
+        default:
+            return undefined;
     }
-    const kind = (target.kind ?? '').trim().toLowerCase();
-    const role = (target.role ?? '').trim().toLowerCase();
-    if (kind === 'link' || role === 'link') {
-        return false;
+}
+function estimatedTextBlockCount(value) {
+    const normalized = normalizeOwnerText(value);
+    if (!normalized) {
+        return 0;
     }
-    if (allowedActions.includes('fill') ||
-        allowedActions.includes('type') ||
-        allowedActions.includes('select')) {
-        return true;
+    const splitHints = normalized
+        .split(/(?: · | \| |, | {2,}| (?=\d{1,2}:\d{2}\b)| (?=\d+\s?[€$₽£]\b))/)
+        .map((part) => part.trim())
+        .filter(Boolean);
+    if (splitHints.length >= 2) {
+        return Math.min(splitHints.length, 4);
     }
-    return (kind === 'button' ||
-        kind === 'radio' ||
-        kind === 'checkbox' ||
-        kind === 'input' ||
-        kind === 'select' ||
-        kind === 'textarea' ||
-        role === 'button' ||
-        role === 'radio' ||
-        role === 'checkbox' ||
-        role === 'textbox' ||
-        role === 'combobox');
+    return normalized.length >= 28 ? 2 : 1;
+}
+function inferredFallbackOwnerCandidates(target) {
+    const candidates = [];
+    const appendCandidate = (node, defaults) => {
+        if (!node?.selector) {
+            return;
+        }
+        const kind = ownerCandidateKindOf(node);
+        candidates.push({
+            ...defaults,
+            ...node,
+            kind: kind ?? node.kind,
+            surfaceKind: node.surfaceKind ?? kind,
+            surfacePriority: node.surfacePriority ?? defaults.surfacePriority ?? defaultPriorityForOwnerKind(kind),
+        });
+    };
+    appendCandidate(target.context?.item, {
+        depth: 0,
+        directTextBlockCount: estimatedTextBlockCount(target.context?.item?.label ?? target.context?.item?.text),
+        descendantInteractiveCount: 1,
+        viewportCoverage: 0.12,
+        relativeAreaToTarget: 6,
+        peerCount: 1,
+    });
+    appendCandidate(target.context?.group, {
+        depth: 1,
+        directTextBlockCount: estimatedTextBlockCount(target.context?.group?.label ?? target.context?.group?.text),
+        descendantInteractiveCount: 2,
+        viewportCoverage: 0.2,
+        relativeAreaToTarget: 14,
+        peerCount: 1,
+    });
+    appendCandidate(target.context?.container, {
+        depth: 1,
+        directTextBlockCount: estimatedTextBlockCount(target.context?.container?.label ?? target.context?.container?.text),
+        descendantInteractiveCount: 2,
+        viewportCoverage: 0.22,
+        relativeAreaToTarget: 14,
+        peerCount: 1,
+        shell: SHELL_BOUNDARY_OWNER_KINDS.has(normalizeOwnerText(target.context?.container?.kind)?.toLowerCase() ?? ''),
+    });
+    appendCandidate(target.context?.landmark, {
+        depth: 2,
+        directTextBlockCount: estimatedTextBlockCount(target.context?.landmark?.label ?? target.context?.landmark?.text),
+        descendantInteractiveCount: 4,
+        viewportCoverage: 0.45,
+        relativeAreaToTarget: 24,
+        boundary: true,
+        shell: true,
+    });
+    return candidates;
+}
+function resolutionCandidatesFor(target) {
+    const explicitCandidates = target.context?.ownerCandidates?.filter((candidate) => Boolean(candidate.selector)) ?? [];
+    return explicitCandidates.length > 0
+        ? explicitCandidates
+        : inferredFallbackOwnerCandidates(target);
 }
-function embeddedSurfaceSeedOf(target) {
-    if (!isEmbeddedInteractiveControl(target)) {
+function canonicalStructuredGridSurfaceOf(target) {
+    if (target.structure?.family !== 'structured-grid') {
         return undefined;
     }
-    const selectorCandidates = [
-        {
-            selector: normalizeEmbeddedSurfaceText(target.context?.group?.selector),
-            kind: normalizeEmbeddedSurfaceText(target.context?.group?.kind)?.toLowerCase(),
-            label: compactEmbeddedSurfaceLabel(target.context?.group?.label, target.context?.landmark?.label, target.context?.container?.label, target.context?.hintText),
-        },
-        {
-            selector: normalizeEmbeddedSurfaceText(target.context?.container?.selector),
-            kind: normalizeEmbeddedSurfaceText(target.context?.container?.kind)?.toLowerCase(),
-            label: compactEmbeddedSurfaceLabel(target.context?.container?.label, target.context?.landmark?.label, target.context?.hintText),
-        },
-    ];
-    const surfaceSeed = selectorCandidates.find((candidate) => candidate.selector);
-    if (!surfaceSeed?.selector) {
+    const explicitSurfaceSelector = normalizeOwnerText(target.explicitSurfaceSelector) ??
+        normalizeOwnerText(target.surfaceSelector);
+    if (!explicitSurfaceSelector) {
         return undefined;
     }
-    const pageKey = normalizeEmbeddedSurfaceText(target.pageSignature) ?? 'unknown-page';
-    const frameKey = embeddedSurfaceFrameKeyOf(target);
-    const surfaceKind = surfaceSeed.kind && !['div', 'tbody', 'table', 'tr', 'td', 'span'].includes(surfaceSeed.kind)
-        ? surfaceSeed.kind
-        : 'group';
+    const explicitSurfaceKind = normalizeOwnerText(target.explicitSurfaceKind)?.toLowerCase() ??
+        normalizeOwnerText(target.surfaceKind)?.toLowerCase();
+    if (!explicitSurfaceKind) {
+        return undefined;
+    }
+    const surfaceLabel = normalizeOwnerText(target.explicitSurfaceLabel) ??
+        normalizeOwnerText(target.surfaceLabel) ??
+        normalizeOwnerText(target.fallbackSurfaceLabel);
+    const surfaceSelectors = mergeSurfaceSelectors(explicitSurfaceSelector, target.explicitSurfaceSelectors ?? target.surfaceSelectors);
+    const surfacePriority = target.explicitSurfacePriority ??
+        target.surfacePriority ??
+        defaultPriorityForOwnerKind(explicitSurfaceKind);
     return {
-        clusterKey: `${pageKey}|${frameKey}|${surfaceSeed.selector}`,
-        surfaceRef: `${pageKey}|${frameKey}|embedded|${surfaceSeed.selector}`,
-        surfaceKind,
-        surfaceLabel: surfaceSeed.label ?? 'Embedded controls',
-        surfaceSelector: surfaceSeed.selector,
-        surfacePriority: 56,
+        surfaceKind: explicitSurfaceKind,
+        surfaceLabel,
+        fallbackSurfaceLabel: surfaceLabel ?? target.fallbackSurfaceLabel,
+        surfaceSelector: explicitSurfaceSelector,
+        surfaceSelectors,
+        surfacePriority,
     };
 }
-function materializeEmbeddedControlSurfaces(targets) {
-    const clusterCounts = new Map();
-    const seedsByIndex = new Map();
+function ownerCandidateSelectorOf(candidate) {
+    return normalizeOwnerText(candidate.selector);
+}
+function ownerCandidateActsAsBoundary(candidate) {
+    const surfaceKind = ownerCandidateKindOf(candidate);
+    return (candidate.boundary === true ||
+        candidate.shell === true ||
+        (surfaceKind !== undefined &&
+            (EXPLICIT_BOUNDARY_OWNER_KINDS.has(surfaceKind) ||
+                SHELL_BOUNDARY_OWNER_KINDS.has(surfaceKind))));
+}
+function ownerBoundaryKeyOf(target, candidates) {
+    for (const candidate of candidates) {
+        const selector = ownerCandidateSelectorOf(candidate);
+        if (selector && ownerCandidateActsAsBoundary(candidate)) {
+            return `boundary:${selector}`;
+        }
+    }
+    const explicitSurfaceSelector = normalizeOwnerText(target.explicitSurfaceSelector);
+    if (explicitSurfaceSelector) {
+        return `explicit:${explicitSurfaceSelector}`;
+    }
+    const formKey = formGroupingKeyOf(target);
+    if (formKey) {
+        return `form:${formKey}`;
+    }
+    const landmarkSelector = normalizeOwnerText(target.context?.landmark?.selector);
+    if (landmarkSelector) {
+        return `landmark:${landmarkSelector}`;
+    }
+    const surfaceSelector = normalizeOwnerText(target.surfaceSelector);
+    if (surfaceSelector) {
+        return `surface:${surfaceSelector}`;
+    }
+    const pageKey = normalizeOwnerText(target.pageSignature) ?? 'unknown-page';
+    const frameKey = target.framePath?.join('>') ??
+        (normalizeOwnerText(target.frameUrl) ? `url:${normalizeOwnerText(target.frameUrl)}` : 'top');
+    return `page:${pageKey}|${frameKey}`;
+}
+function ownerCandidateEligibleForSharedResolution(candidate) {
+    const contextBlockCount = ownerCandidateContextBlockCountOf(candidate);
+    const descendantInteractiveCount = candidate.descendantInteractiveCount ?? 0;
+    const viewportCoverage = candidate.viewportCoverage ?? 1;
+    const relativeAreaToTarget = candidate.relativeAreaToTarget ?? 0;
+    return Boolean(ownerCandidateSelectorOf(candidate) &&
+        !ownerCandidateActsAsBoundary(candidate) &&
+        ownerCandidateRefinesContext(candidate) &&
+        contextBlockCount >= 2 &&
+        descendantInteractiveCount >= 1 &&
+        descendantInteractiveCount <= 8 &&
+        viewportCoverage <= 0.55 &&
+        relativeAreaToTarget >= 2);
+}
+function nearestLocalOwnerBranchKeyOf(target, candidates) {
+    for (const candidate of candidates) {
+        const selector = ownerCandidateSelectorOf(candidate);
+        if (!selector || ownerCandidateActsAsBoundary(candidate)) {
+            continue;
+        }
+        return selector;
+    }
+    return `target:${observedTargetKey(target)}`;
+}
+function inferSharedOwnerSelectors(targets) {
+    const supportByBoundary = new Map();
+    const candidatesByTarget = targets.map((target) => resolutionCandidatesFor(target));
     for (const [index, target] of targets.entries()) {
-        const seed = embeddedSurfaceSeedOf(target);
-        if (!seed) {
+        const candidates = candidatesByTarget[index] ?? [];
+        if (candidates.length === 0) {
             continue;
         }
-        seedsByIndex.set(index, seed);
-        clusterCounts.set(seed.clusterKey, (clusterCounts.get(seed.clusterKey) ?? 0) + 1);
+        const boundaryKey = ownerBoundaryKeyOf(target, candidates);
+        const branchKey = nearestLocalOwnerBranchKeyOf(target, candidates);
+        const supportBySelector = supportByBoundary.get(boundaryKey) ?? new Map();
+        for (const candidate of candidates) {
+            const selector = ownerCandidateSelectorOf(candidate);
+            if (!selector || !ownerCandidateEligibleForSharedResolution(candidate)) {
+                continue;
+            }
+            const existing = supportBySelector.get(selector) ?? {
+                branchRefs: new Set(),
+                targetIndexes: new Set(),
+                hasPrimaryActionSupport: false,
+                hasIdentitySupport: false,
+            };
+            existing.branchRefs.add(branchKey);
+            existing.targetIndexes.add(index);
+            existing.hasPrimaryActionSupport ||= targetSupportsSharedOwnerPrimaryAction(target);
+            existing.hasIdentitySupport ||= targetSupportsSharedOwnerIdentity(target);
+            supportBySelector.set(selector, existing);
+        }
+        supportByBoundary.set(boundaryKey, supportBySelector);
     }
-    return targets.map((target, index) => {
-        const seed = seedsByIndex.get(index);
-        if (!seed || (clusterCounts.get(seed.clusterKey) ?? 0) < 2) {
-            return target;
+    const preferredSelectors = new Map();
+    for (const [index, target] of targets.entries()) {
+        const candidates = candidatesByTarget[index] ?? [];
+        if (candidates.length === 0) {
+            continue;
         }
-        return {
-            ...target,
-            surfaceRef: target.surfaceRef ?? seed.surfaceRef,
-            surfaceKind: target.surfaceKind ?? seed.surfaceKind,
-            surfaceLabel: target.surfaceLabel ?? seed.surfaceLabel,
-            surfaceSelector: target.surfaceSelector ?? seed.surfaceSelector,
-            surfacePriority: target.surfacePriority ?? seed.surfacePriority,
-        };
-    });
+        const boundaryKey = ownerBoundaryKeyOf(target, candidates);
+        const supportBySelector = supportByBoundary.get(boundaryKey);
+        if (!supportBySelector) {
+            continue;
+        }
+        for (const candidate of candidates) {
+            const selector = ownerCandidateSelectorOf(candidate);
+            if (!selector || !ownerCandidateEligibleForSharedResolution(candidate)) {
+                continue;
+            }
+            const support = supportBySelector.get(selector);
+            if (!support) {
+                continue;
+            }
+            if (support.branchRefs.size >= 2 &&
+                support.targetIndexes.size >= 2 &&
+                support.hasPrimaryActionSupport &&
+                support.hasIdentitySupport) {
+                preferredSelectors.set(index, selector);
+                break;
+            }
+        }
+    }
+    return preferredSelectors;
+}
+function ownerCandidateTierOf(candidate) {
+    const surfaceKind = ownerCandidateKindOf(candidate);
+    if (surfaceKind === 'token' || surfaceKind === 'chip') {
+        return 0;
+    }
+    const explicitBoundary = surfaceKind ? EXPLICIT_BOUNDARY_OWNER_KINDS.has(surfaceKind) : false;
+    const shellLike = candidate.shell === true || (surfaceKind ? SHELL_BOUNDARY_OWNER_KINDS.has(surfaceKind) : false);
+    const boundary = candidate.boundary === true;
+    const directTextBlockCount = candidate.directTextBlockCount ?? 0;
+    const descendantInteractiveCount = candidate.descendantInteractiveCount ?? 0;
+    const viewportCoverage = candidate.viewportCoverage ?? 1;
+    const relativeAreaToTarget = candidate.relativeAreaToTarget ?? 0;
+    const peerCount = candidate.peerCount ?? 0;
+    if (relativeAreaToTarget < 1.5 ||
+        viewportCoverage > 0.8 ||
+        descendantInteractiveCount > 12 ||
+        !ownerCandidateRefinesContext(candidate)) {
+        return 0;
+    }
+    const richLocalOwner = directTextBlockCount >= 2 &&
+        descendantInteractiveCount >= 1 &&
+        descendantInteractiveCount <= 8 &&
+        viewportCoverage <= 0.45;
+    const repeatedItemLike = peerCount >= 2;
+    const itemLikeSurface = surfaceKind === 'card' || surfaceKind === 'listitem' || surfaceKind === 'row';
+    if (richLocalOwner && (repeatedItemLike || itemLikeSurface)) {
+        return 320;
+    }
+    if (richLocalOwner && !shellLike) {
+        return 280;
+    }
+    if (explicitBoundary &&
+        directTextBlockCount >= 1 &&
+        descendantInteractiveCount >= 1 &&
+        descendantInteractiveCount <= 8 &&
+        viewportCoverage <= 0.55) {
+        return 240;
+    }
+    if (directTextBlockCount >= 1 &&
+        repeatedItemLike &&
+        descendantInteractiveCount >= 1 &&
+        descendantInteractiveCount <= 4 &&
+        viewportCoverage <= 0.35) {
+        return 220;
+    }
+    if (shellLike &&
+        directTextBlockCount >= 1 &&
+        descendantInteractiveCount >= 1 &&
+        descendantInteractiveCount <= 8 &&
+        viewportCoverage <= 0.5) {
+        return 140;
+    }
+    if (boundary &&
+        directTextBlockCount >= 1 &&
+        descendantInteractiveCount >= 1 &&
+        descendantInteractiveCount <= 8 &&
+        viewportCoverage <= 0.5) {
+        return 180;
+    }
+    return 0;
+}
+function compareOwnerCandidates(left, right) {
+    const tierDelta = ownerCandidateTierOf(right) - ownerCandidateTierOf(left);
+    if (tierDelta !== 0) {
+        return tierDelta;
+    }
+    const leftDepth = left.depth ?? Number.MAX_SAFE_INTEGER;
+    const rightDepth = right.depth ?? Number.MAX_SAFE_INTEGER;
+    if (leftDepth !== rightDepth) {
+        return leftDepth - rightDepth;
+    }
+    const leftPriority = left.surfacePriority ?? 0;
+    const rightPriority = right.surfacePriority ?? 0;
+    if (leftPriority !== rightPriority) {
+        return rightPriority - leftPriority;
+    }
+    const leftTextBlocks = left.directTextBlockCount ?? 0;
+    const rightTextBlocks = right.directTextBlockCount ?? 0;
+    return rightTextBlocks - leftTextBlocks;
+}
+function mergeSurfaceSelectors(primary, additional) {
+    const selectors = new Set();
+    if (primary) {
+        selectors.add(primary);
+    }
+    for (const selector of additional ?? []) {
+        if (selector) {
+            selectors.add(selector);
+        }
+    }
+    return selectors.size > 0 ? [...selectors] : undefined;
+}
+function inferredOwnerSurfaceKindOf(candidate, options) {
+    const hintedKind = ownerCandidateKindHintOf(candidate) ?? normalizeOwnerText(candidate.kind)?.toLowerCase();
+    if (hintedKind && hintedKind !== 'div') {
+        return hintedKind;
+    }
+    const directTextBlockCount = candidate.directTextBlockCount ?? 0;
+    const contextBlockCount = options?.sharedOwner === true
+        ? ownerCandidateContextBlockCountOf(candidate)
+        : directTextBlockCount;
+    const descendantInteractiveCount = candidate.descendantInteractiveCount ?? 0;
+    const viewportCoverage = candidate.viewportCoverage ?? 1;
+    const relativeAreaToTarget = candidate.relativeAreaToTarget ?? 0;
+    const peerCount = candidate.peerCount ?? 0;
+    const shellLike = candidate.shell === true || (hintedKind ? SHELL_BOUNDARY_OWNER_KINDS.has(hintedKind) : false);
+    if (shellLike) {
+        return undefined;
+    }
+    const maxInteractiveCount = options?.sharedOwner === true ? 8 : 4;
+    const richLocalOwner = contextBlockCount >= 2 &&
+        descendantInteractiveCount >= 1 &&
+        descendantInteractiveCount <= maxInteractiveCount &&
+        viewportCoverage <= 0.45;
+    if (richLocalOwner &&
+        (peerCount >= 1 || relativeAreaToTarget >= 4 || options?.sharedOwner === true)) {
+        return 'card';
+    }
+    if (contextBlockCount >= 1 &&
+        descendantInteractiveCount >= 1 &&
+        descendantInteractiveCount <= 4 &&
+        viewportCoverage <= 0.35 &&
+        relativeAreaToTarget >= 2) {
+        return 'group';
+    }
+    return undefined;
+}
+function ownerCandidateReusesExistingSurface(target, candidate) {
+    const candidateSelector = normalizeOwnerText(candidate.selector);
+    const currentSurfaceSelector = normalizeOwnerText(target.surfaceSelector);
+    return Boolean(candidateSelector && currentSurfaceSelector && candidateSelector === currentSurfaceSelector);
+}
+function resolveTargetOwnedSurface(target, preferredSharedOwnerSelector) {
+    const canonicalStructuredGridSurface = canonicalStructuredGridSurfaceOf(target);
+    if (canonicalStructuredGridSurface) {
+        return canonicalStructuredGridSurface;
+    }
+    const candidates = resolutionCandidatesFor(target);
+    if (!candidates || candidates.length === 0) {
+        return undefined;
+    }
+    const scoredCandidates = candidates.filter((candidate) => ownerCandidateTierOf(candidate) > 0);
+    const preferredCandidate = preferredSharedOwnerSelector
+        ? candidates.find((candidate) => ownerCandidateSelectorOf(candidate) === preferredSharedOwnerSelector &&
+            ownerCandidateEligibleForSharedResolution(candidate))
+        : undefined;
+    const bestCandidate = preferredCandidate ?? [...scoredCandidates].sort(compareOwnerCandidates)[0];
+    if (!bestCandidate?.selector) {
+        return undefined;
+    }
+    const reusesExistingSurface = ownerCandidateReusesExistingSurface(target, bestCandidate);
+    const sharedOwnerSelected = preferredCandidate !== undefined && bestCandidate === preferredCandidate;
+    const surfaceKind = inferredOwnerSurfaceKindOf(bestCandidate, {
+        sharedOwner: sharedOwnerSelected,
+    }) ?? (reusesExistingSurface ? target.surfaceKind : undefined);
+    const surfaceLabel = ownerCandidateSurfaceLabelOf(bestCandidate) ??
+        (reusesExistingSurface
+            ? (normalizeOwnerText(target.surfaceLabel) ?? normalizeOwnerText(target.fallbackSurfaceLabel))
+            : undefined);
+    const surfaceSelectors = mergeSurfaceSelectors(bestCandidate.selector, reusesExistingSurface ? target.surfaceSelectors : undefined);
+    const surfacePriority = bestCandidate.surfacePriority ??
+        defaultPriorityForOwnerKind(surfaceKind) ??
+        (reusesExistingSurface ? target.surfacePriority : undefined);
+    return {
+        surfaceKind,
+        surfaceLabel,
+        fallbackSurfaceLabel: surfaceLabel ?? (reusesExistingSurface ? target.fallbackSurfaceLabel : undefined),
+        surfaceSelector: bestCandidate.selector,
+        surfaceSelectors,
+        surfacePriority,
+    };
 }
 function parseNumericAmount(value) {
     const normalized = value.replace(/,/g, '.').trim();
@@ -417,52 +803,63 @@ function inferCapability(target, allowedActions) {
     }
     return 'actionable';
 }
-export function annotateDomTargets(targets) {
-    const annotated = materializeEmbeddedControlSurfaces(targets.map((target) => {
-        const allowedActions = inferAllowedActions(target);
-        const controlFamily = inferControlFamilyFromFacts({
-            kind: target.kind,
-            role: target.role,
-            label: target.label,
-            displayLabel: target.displayLabel,
-            interactionHint: target.interactionHint,
-            text: target.text,
-            placeholder: target.placeholder,
-            inputName: target.inputName,
-            inputType: target.inputType,
-            autocomplete: target.autocomplete,
-            ariaAutocomplete: target.ariaAutocomplete,
-            surfaceKind: target.surfaceKind,
-            controlsSurfaceSelector: target.controlsSurfaceSelector,
-            states: target.states,
-            structure: target.structure,
-        }, allowedActions);
-        const availability = inferAvailability(target);
-        const capability = inferCapability(target, allowedActions);
-        const acceptancePolicy = inferAcceptancePolicy(target, allowedActions);
-        const explicitSurfaceRef = buildSurfaceRef(target);
-        const syntheticFormSurfaceRef = explicitSurfaceRef === undefined ? buildSyntheticFormSurfaceId(target) : undefined;
-        const surfaceRef = explicitSurfaceRef ?? syntheticFormSurfaceRef;
-        const surfaceKind = target.surfaceKind ?? (syntheticFormSurfaceRef ? 'form' : undefined);
-        const surfaceLabel = target.surfaceLabel ??
-            (syntheticFormSurfaceRef
-                ? (target.context?.landmark?.label ?? target.context?.group?.label ?? 'Form')
-                : undefined);
-        const surfacePriority = target.surfacePriority ?? (surfaceKind === 'form' ? 70 : undefined);
-        return {
-            ...target,
-            surfaceKind,
-            surfaceLabel,
-            surfacePriority,
-            capability,
-            availability,
-            allowedActions,
-            controlFamily,
-            acceptancePolicy,
-            surfaceRef,
-        };
-    }));
-    return annotated.map((target, index, current) => {
+function withAnnotatedSemantics(target) {
+    const allowedActions = inferAllowedActions(target);
+    const controlFamily = inferControlFamilyFromFacts({
+        kind: target.kind,
+        role: target.role,
+        label: target.label,
+        displayLabel: target.displayLabel,
+        interactionHint: target.interactionHint,
+        text: target.text,
+        placeholder: target.placeholder,
+        inputName: target.inputName,
+        inputType: target.inputType,
+        autocomplete: target.autocomplete,
+        ariaAutocomplete: target.ariaAutocomplete,
+        surfaceKind: target.surfaceKind,
+        controlsSurfaceSelector: target.controlsSurfaceSelector,
+        states: target.states,
+        structure: target.structure,
+    }, allowedActions);
+    const availability = inferAvailability(target);
+    const capability = inferCapability(target, allowedActions);
+    const acceptancePolicy = inferAcceptancePolicy(target, allowedActions);
+    return {
+        ...target,
+        capability,
+        availability,
+        allowedActions,
+        controlFamily,
+        acceptancePolicy,
+    };
+}
+function withResolvedSurface(target, preferredSharedOwnerSelector) {
+    const ownedSurface = resolveTargetOwnedSurface(target, preferredSharedOwnerSelector);
+    const surfaceResolvedTarget = ownedSurface ? { ...target, ...ownedSurface } : target;
+    const explicitSurfaceRef = buildSurfaceRef(surfaceResolvedTarget);
+    const syntheticFormSurfaceRef = explicitSurfaceRef === undefined
+        ? buildSyntheticFormSurfaceId(surfaceResolvedTarget)
+        : undefined;
+    const surfaceRef = explicitSurfaceRef ?? syntheticFormSurfaceRef;
+    const surfaceKind = surfaceResolvedTarget.surfaceKind ?? (syntheticFormSurfaceRef ? 'form' : undefined);
+    const surfaceLabel = surfaceResolvedTarget.surfaceLabel ??
+        (syntheticFormSurfaceRef
+            ? (surfaceResolvedTarget.context?.landmark?.label ??
+                surfaceResolvedTarget.context?.group?.label ??
+                'Form')
+            : undefined);
+    const surfacePriority = surfaceResolvedTarget.surfacePriority ?? (surfaceKind === 'form' ? 70 : undefined);
+    return {
+        ...surfaceResolvedTarget,
+        surfaceKind,
+        surfaceLabel,
+        surfacePriority,
+        surfaceRef,
+    };
+}
+function attachOwnerIndices(targets) {
+    return targets.map((target, index, current) => {
         const compactRemoveItemLabel = compactRemoveItemLabelOf(target);
         const compactRemoveOwnerIndex = isCompactRemoveActionTarget(target) && compactRemoveItemLabel
             ? current.findIndex((candidate, candidateIndex) => {
@@ -515,14 +912,20 @@ export function annotateDomTargets(targets) {
                 return true;
             if (candidate.structure?.family === 'structured-grid')
                 return false;
-            if (candidate.capability === 'informational' && !explicitController)
+            if (candidate.capability === 'informational' && !explicitController) {
                 return false;
+            }
             return (candidate.allowedActions?.includes('click') &&
                 ['input', 'select', 'button', 'combobox'].includes((candidate.kind || '').toLowerCase()));
         });
         return ownerIndex >= 0 ? { ...target, ownerIndex } : target;
     });
 }
+export function annotateDomTargets(targets) {
+    const semanticallyAnnotatedTargets = targets.map(withAnnotatedSemantics);
+    const preferredSharedOwnerSelectors = inferSharedOwnerSelectors(semanticallyAnnotatedTargets);
+    return attachOwnerIndices(semanticallyAnnotatedTargets.map((target, index) => withResolvedSurface(target, preferredSharedOwnerSelectors.get(index))));
+}
 export function orderBySurfaceCompetition(targets) {
     const iframeFieldLike = (target) => {
         const kind = (target.kind ?? '').toLowerCase();
@@ -603,3 +1006,6 @@ export function orderBySurfaceCompetition(targets) {
         return (left.ordinal ?? 0) - (right.ordinal ?? 0);
     });
 }
+export function normalizePostEnrichmentDomTargets(targets) {
+    return compressSemanticallyDuplicateTargets(orderBySurfaceCompetition(annotateDomTargets(targets)));
+}