@oxvo/ai-live-assist 7.3.0

package/lib/context.js

@@ -0,0 +1,975 @@
+import { renderSanitizedLayout } from './visualContext.js';
+const MAX_TARGETS = 256;
+const MAX_TEXT_ITEMS = 256;
+const MAX_TOTAL_TEXT = 24000;
+const MAX_OPTIONS = 100;
+const MAX_SELECTED_TEXT = 2000;
+const SELECTION_RETENTION_MS = 120000;
+const PRIVATE_SELECTOR = [
+    '[data-oxvo-ai-live-assist-root]',
+    '[data-oxvo-private]',
+    '[data-openreplay-hidden]',
+    '[data-openreplay-obscured]',
+    '[contenteditable]:not([contenteditable="false"])',
+    '[aria-hidden="true"]',
+    '[inert]',
+    '[hidden]',
+].join(',');
+const SENSITIVE_PATTERNS = [
+    ['password', /password|passwd|passcode/i],
+    ['otp', /\botp\b|one.?time|verification.?code|security.?code|2fa|mfa/i],
+    ['payment', /card.?number|credit.?card|debit.?card|\bcvv\b|\bcvc\b|expiry/i],
+    ['banking', /bank|routing|iban|swift|account.?number/i],
+    ['recovery', /recovery.?code|backup.?code/i],
+    ['authentication_secret', /auth.*secret|private.?key|access.?token/i],
+    ['api_secret', /api.?key|client.?secret|secret.?key/i],
+];
+const id = (prefix) => `${prefix}_${crypto.randomUUID()}`;
+const normalize = (value, maximum) => value
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, maximum);
+const isHTMLElement = (value) => value instanceof HTMLElement;
+const isRendered = (element) => {
+    if (!isHTMLElement(element) || !element.isConnected || element.closest(PRIVATE_SELECTOR)) {
+        return false;
+    }
+    const style = window.getComputedStyle(element);
+    const opacity = Number.parseFloat(style.opacity);
+    if (style.display === 'none' ||
+        style.visibility === 'hidden' ||
+        (Number.isFinite(opacity) && opacity === 0) ||
+        style.pointerEvents === 'none') {
+        return false;
+    }
+    const rect = element.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0;
+};
+const isVisible = (element) => {
+    if (!isRendered(element))
+        return false;
+    const rect = element.getBoundingClientRect();
+    return (rect.bottom >= 0 &&
+        rect.right >= 0 &&
+        rect.top <= window.innerHeight &&
+        rect.left <= window.innerWidth);
+};
+const isCovered = (element) => {
+    const rect = element.getBoundingClientRect();
+    const x = Math.max(0, Math.min(window.innerWidth - 1, rect.left + rect.width / 2));
+    const y = Math.max(0, Math.min(window.innerHeight - 1, rect.top + rect.height / 2));
+    const top = document.elementFromPoint(x, y);
+    return Boolean(top && top !== element && !element.contains(top) && !top.contains(element));
+};
+const safePageUrl = () => `${window.location.origin}${window.location.pathname}`;
+const sensitivityFor = (element, name) => {
+    const input = element instanceof HTMLInputElement ? element : null;
+    const type = input?.type.toLowerCase() ?? '';
+    const autocomplete = input?.autocomplete.toLowerCase() ?? '';
+    if (type === 'password' || autocomplete.includes('password'))
+        return 'password';
+    if (autocomplete.includes('one-time-code'))
+        return 'otp';
+    if (/^cc-/.test(autocomplete))
+        return 'payment';
+    const descriptors = [
+        name,
+        element.getAttribute('name') ?? '',
+        element.id,
+        element.getAttribute('autocomplete') ?? '',
+        element.getAttribute('data-oxvo-sensitivity') ?? '',
+    ].join(' ');
+    for (const [sensitivity, pattern] of SENSITIVE_PATTERNS) {
+        if (pattern.test(descriptors))
+            return sensitivity;
+    }
+    if (element.closest('[data-oxvo-private]'))
+        return 'private';
+    return 'none';
+};
+const roleFor = (element) => {
+    const explicit = normalize(element.getAttribute('role') ?? '', 64);
+    if (explicit)
+        return explicit;
+    const tag = element.tagName.toLowerCase();
+    if (tag === 'a')
+        return 'link';
+    if (tag === 'button')
+        return 'button';
+    if (tag === 'select')
+        return 'combobox';
+    if (tag === 'textarea')
+        return 'textbox';
+    if (tag === 'form')
+        return 'form';
+    if (tag === 'summary')
+        return 'button';
+    if (element instanceof HTMLInputElement) {
+        if (['button', 'submit', 'reset'].includes(element.type))
+            return 'button';
+        if (['checkbox', 'radio'].includes(element.type))
+            return element.type;
+        if (element.type === 'number')
+            return 'spinbutton';
+        return 'textbox';
+    }
+    return tag.slice(0, 64);
+};
+const nameFor = (element) => {
+    const labelledBy = element.getAttribute('aria-labelledby');
+    const labelledText = labelledBy
+        ?.split(/\s+/)
+        .map((value) => document.getElementById(value)?.textContent ?? '')
+        .join(' ');
+    const input = element instanceof HTMLInputElement ? element : null;
+    const formControl = element instanceof HTMLInputElement ||
+        element instanceof HTMLSelectElement ||
+        element instanceof HTMLTextAreaElement
+        ? element
+        : null;
+    const associatedLabel = formControl
+        ? Array.from(formControl.labels ?? [])
+            .flatMap((label) => {
+            const walker = document.createTreeWalker(label, NodeFilter.SHOW_TEXT);
+            const text = [];
+            let node = walker.nextNode();
+            while (node) {
+                if (!node.parentElement?.closest('input,select,textarea,option,button')) {
+                    text.push(node.textContent ?? '');
+                }
+                node = walker.nextNode();
+            }
+            return text;
+        })
+            .join(' ')
+        : '';
+    const explicitName = element.getAttribute('aria-label') ??
+        labelledText ??
+        element.getAttribute('alt') ??
+        element.getAttribute('title') ??
+        element.getAttribute('placeholder');
+    if (element instanceof HTMLFormElement) {
+        return normalize(explicitName ??
+            element.getAttribute('data-oxvo-ai-region') ??
+            element.getAttribute('name') ??
+            'Form', 120);
+    }
+    return normalize(explicitName ??
+        (associatedLabel || null) ??
+        (input && ['button', 'submit', 'reset'].includes(input.type) ? input.value : null) ??
+        element.textContent ??
+        '', 300);
+};
+const isActionTarget = (element) => element.matches('a[href],button,input,select,textarea,summary,form,[contenteditable="true"],[role="button"],[role="link"],[role="checkbox"],[role="radio"],[role="combobox"],[role="textbox"],[tabindex]');
+const enabled = (element) => {
+    if (element.getAttribute('aria-disabled') === 'true')
+        return false;
+    if (element instanceof HTMLButtonElement ||
+        element instanceof HTMLInputElement ||
+        element instanceof HTMLSelectElement ||
+        element instanceof HTMLTextAreaElement) {
+        return !element.disabled;
+    }
+    return true;
+};
+const consequenceFor = (element, role, name) => {
+    const form = element instanceof HTMLFormElement ? element : element.closest('form');
+    const explicit = element
+        .closest('[data-oxvo-ai-consequence]')
+        ?.getAttribute('data-oxvo-ai-consequence');
+    const description = normalize([
+        role,
+        name,
+        element.getAttribute('aria-label'),
+        element.getAttribute('title'),
+        element.getAttribute('name'),
+        element.getAttribute('data-action'),
+        form?.getAttribute('aria-label'),
+        form?.getAttribute('name'),
+        form?.getAttribute('data-oxvo-ai-region'),
+    ]
+        .filter(Boolean)
+        .join(' '), 800).toLowerCase();
+    // High-impact labels cannot be downgraded by page-provided metadata.
+    if (/\b(?:delete|destroy|erase|close account|cancel account|remove (?:account|member|project|workspace)|archive (?:account|project|workspace)|supprimer|eliminar)\b/u.test(description)) {
+        return 'destructive';
+    }
+    if (/\b(?:pay|purchase|buy|place order|checkout|subscribe|upgrade plan|downgrade plan|renew subscription|acheter|comprar|pagar)\b/u.test(description)) {
+        return 'financial';
+    }
+    if (/\b(?:(?:manage|change|edit|update|grant|revoke|assign)\s+(?:member\s+|user\s+|workspace\s+|account\s+)?permissions?|permissions?\s+(?:settings?|access|polic(?:y|ies)|roles?)|member role|workspace owner|account access|api access|security settings?|authentication settings?|invite member)\b/u.test(description)) {
+        return 'account';
+    }
+    if (/\b(?:publish|send (?:message|email|invitation)|share publicly|post comment|register account)\b/u.test(description)) {
+        return 'submission';
+    }
+    if (explicit === 'none' ||
+        explicit === 'navigation' ||
+        explicit === 'state_change' ||
+        explicit === 'submission' ||
+        explicit === 'financial' ||
+        explicit === 'account' ||
+        explicit === 'destructive') {
+        return explicit;
+    }
+    if (element instanceof HTMLFormElement ||
+        (element instanceof HTMLInputElement && element.type === 'submit') ||
+        (element instanceof HTMLButtonElement && element.type === 'submit')) {
+        return 'submission';
+    }
+    if (element instanceof HTMLAnchorElement)
+        return 'navigation';
+    return role === 'button' || role === 'checkbox' || role === 'radio' ? 'state_change' : 'none';
+};
+export class PageContextCollector {
+    constructor(callbacks, selectorRegionRules = [], policyVersion = 1) {
+        this.callbacks = callbacks;
+        this.selectorRegionRules = selectorRegionRules;
+        this.policyVersion = policyVersion;
+        this.pageId = id('page');
+        this.revision = 0;
+        this.running = false;
+        this.mutationObserver = null;
+        this.captureTimer = null;
+        this.targetIds = new WeakMap();
+        this.textIds = new WeakMap();
+        this.optionIds = new WeakMap();
+        this.targets = new Map();
+        this.originalPushState = null;
+        this.originalReplaceState = null;
+        this.executingActionId = null;
+        this.pendingNavigation = null;
+        this.pendingCapture = false;
+        this.deferredNavigation = null;
+        this.recentSelection = null;
+        this.scheduleCapture = () => {
+            if (!this.running)
+                return;
+            if (this.executingActionId) {
+                this.pendingCapture = true;
+                return;
+            }
+            if (this.captureTimer)
+                return;
+            this.captureTimer = setTimeout(() => {
+                this.captureTimer = null;
+                void this.captureAndPublish();
+            }, 250);
+        };
+        this.handleSelectionChange = () => {
+            const selection = this.readSafeSelection();
+            if (selection)
+                this.recentSelection = selection;
+            this.scheduleCapture();
+        };
+        this.handleControlStateChange = () => {
+            this.scheduleCapture();
+        };
+        this.handleNavigation = () => {
+            if (!this.running)
+                return;
+            this.pageId = id('page');
+            this.revision += 1;
+            this.targets.clear();
+            this.recentSelection = null;
+            if (this.executingActionId) {
+                this.pendingNavigation = {
+                    pageId: this.pageId,
+                    revision: this.revision,
+                    url: safePageUrl(),
+                };
+                this.pendingCapture = true;
+                return;
+            }
+            void Promise.resolve(this.callbacks.onNavigation(this.pageId, this.revision, safePageUrl())).then(() => this.captureAndPublish());
+        };
+    }
+    get currentRevision() {
+        return this.revision;
+    }
+    get currentPageId() {
+        return this.pageId;
+    }
+    presentationTarget(targetId, revision) {
+        const handle = this.targets.get(targetId);
+        if (revision !== this.revision ||
+            !handle ||
+            handle.revision !== revision ||
+            !handle.element.isConnected) {
+            return null;
+        }
+        const rect = handle.element.getBoundingClientRect();
+        return {
+            targetId,
+            pageId: this.pageId,
+            revision,
+            rect,
+            safe: handle.target.sensitivity === 'none' &&
+                handle.target.protectedRegion === false &&
+                handle.target.frameOrigin === 'same_origin' &&
+                handle.target.state.visible &&
+                handle.target.state.enabled &&
+                handle.target.state.covered !== true,
+        };
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.installNavigationHooks();
+        this.mutationObserver = new MutationObserver(() => this.scheduleCapture());
+        if (document.body) {
+            this.mutationObserver.observe(document.body, {
+                subtree: true,
+                childList: true,
+                characterData: true,
+                attributes: true,
+                attributeFilter: [
+                    'aria-label',
+                    'aria-disabled',
+                    'aria-expanded',
+                    'aria-live',
+                    'class',
+                    'disabled',
+                    'hidden',
+                    'inert',
+                    'role',
+                    'style',
+                ],
+            });
+        }
+        window.addEventListener('resize', this.scheduleCapture, { passive: true });
+        document.addEventListener('scroll', this.scheduleCapture, {
+            capture: true,
+            passive: true,
+        });
+        window.visualViewport?.addEventListener('resize', this.scheduleCapture, {
+            passive: true,
+        });
+        window.visualViewport?.addEventListener('scroll', this.scheduleCapture, {
+            passive: true,
+        });
+        window.addEventListener('popstate', this.handleNavigation);
+        document.addEventListener('selectionchange', this.handleSelectionChange);
+        document.addEventListener('input', this.handleControlStateChange, true);
+        document.addEventListener('change', this.handleControlStateChange, true);
+        void this.captureAndPublish();
+    }
+    stop() {
+        this.running = false;
+        this.mutationObserver?.disconnect();
+        this.mutationObserver = null;
+        if (this.captureTimer)
+            clearTimeout(this.captureTimer);
+        this.captureTimer = null;
+        window.removeEventListener('resize', this.scheduleCapture);
+        document.removeEventListener('scroll', this.scheduleCapture, true);
+        window.visualViewport?.removeEventListener('resize', this.scheduleCapture);
+        window.visualViewport?.removeEventListener('scroll', this.scheduleCapture);
+        window.removeEventListener('popstate', this.handleNavigation);
+        document.removeEventListener('selectionchange', this.handleSelectionChange);
+        document.removeEventListener('input', this.handleControlStateChange, true);
+        document.removeEventListener('change', this.handleControlStateChange, true);
+        this.restoreNavigationHooks();
+        this.targets.clear();
+        this.executingActionId = null;
+        this.pendingNavigation = null;
+        this.pendingCapture = false;
+        this.deferredNavigation = null;
+        this.recentSelection = null;
+        this.callbacks.onHighlight(null, 'focus');
+    }
+    async captureAndPublish() {
+        const snapshot = this.capture();
+        if (this.running)
+            await this.callbacks.onSnapshot(snapshot);
+        return snapshot;
+    }
+    capture() {
+        this.revision += 1;
+        const revision = this.revision;
+        const nextTargets = new Map();
+        const targetValues = [];
+        const elements = document.querySelectorAll('a[href],button,input,select,textarea,summary,form,[contenteditable="true"],[role],[tabindex]');
+        let truncated = false;
+        for (const element of elements) {
+            if (targetValues.length >= MAX_TARGETS) {
+                truncated = true;
+                break;
+            }
+            if (!isActionTarget(element) || !isRendered(element))
+                continue;
+            const name = nameFor(element);
+            if (!name && !['form', 'textbox'].includes(roleFor(element)))
+                continue;
+            const targetId = this.targetIds.get(element) ?? id('target');
+            this.targetIds.set(element, targetId);
+            const optionMap = new Map();
+            let options;
+            if (element instanceof HTMLSelectElement) {
+                options = Array.from(element.options)
+                    .slice(0, MAX_OPTIONS)
+                    .map((option) => {
+                    const optionId = this.optionIds.get(option) ?? id('option');
+                    this.optionIds.set(option, optionId);
+                    optionMap.set(optionId, option);
+                    return {
+                        id: optionId,
+                        label: normalize(option.label || option.textContent || '', 300),
+                        disabled: option.disabled,
+                    };
+                });
+            }
+            const semanticRegion = normalize(element.closest('[data-oxvo-ai-region]')?.getAttribute('data-oxvo-ai-region') ?? '', 128);
+            const evaluatedRuleDigests = [];
+            const matchedRuleDigests = [];
+            for (const rule of this.selectorRegionRules.slice(0, 100)) {
+                if (!/^[0-9a-f]{64}$/.test(rule.digest) || rule.selector.length > 256) {
+                    continue;
+                }
+                try {
+                    const matched = element.matches(rule.selector) || Boolean(element.closest(rule.selector));
+                    evaluatedRuleDigests.push(rule.digest);
+                    if (matched)
+                        matchedRuleDigests.push(rule.digest);
+                }
+                catch {
+                    // Invalid tenant selectors remain unevaluated so server policy fails closed.
+                }
+            }
+            const role = roleFor(element);
+            const sensitivity = sensitivityFor(element, name);
+            const visible = isVisible(element);
+            const target = {
+                targetId,
+                revision,
+                role,
+                name,
+                ...(element instanceof HTMLInputElement || element instanceof HTMLButtonElement
+                    ? { inputType: normalize(element.type, 32) }
+                    : {}),
+                ...(element.getAttribute('autocomplete')
+                    ? { autocomplete: normalize(element.getAttribute('autocomplete') ?? '', 128) }
+                    : {}),
+                ...(semanticRegion ? { semanticRegion } : {}),
+                sensitivity,
+                protectedRegion: sensitivity !== 'none' || matchedRuleDigests.length > 0,
+                frameOrigin: 'same_origin',
+                consequence: consequenceFor(element, role, name),
+                regionAssessment: {
+                    policyVersion: this.policyVersion,
+                    evaluatedRuleDigests,
+                    matchedRuleDigests,
+                },
+                state: {
+                    visible,
+                    enabled: enabled(element),
+                    covered: visible ? isCovered(element) : false,
+                    ...(element instanceof HTMLInputElement && ['checkbox', 'radio'].includes(element.type)
+                        ? { checked: element.checked }
+                        : {}),
+                },
+                ...(options ? { options } : {}),
+            };
+            targetValues.push(target);
+            nextTargets.set(targetId, { element, revision, options: optionMap, target });
+        }
+        this.targets = nextTargets;
+        const visibleText = [];
+        let totalText = 0;
+        const walker = document.createTreeWalker(document.body ?? document.documentElement, NodeFilter.SHOW_TEXT);
+        let node = walker.nextNode();
+        while (node && visibleText.length < MAX_TEXT_ITEMS && totalText < MAX_TOTAL_TEXT) {
+            const parent = node.parentElement;
+            const text = normalize(node.textContent ?? '', 500);
+            if (parent &&
+                text &&
+                !parent.closest(PRIVATE_SELECTOR) &&
+                !parent.closest('script,style,noscript,template,svg') &&
+                !parent.closest('input,select,textarea,option') &&
+                isVisible(parent) &&
+                sensitivityFor(parent, nameFor(parent)) === 'none') {
+                const textId = this.textIds.get(node) ?? id('text');
+                this.textIds.set(node, textId);
+                visibleText.push({ id: textId, text, provenance: 'page' });
+                totalText += text.length;
+            }
+            node = walker.nextNode();
+        }
+        if (node)
+            truncated = true;
+        const landmarks = Array.from(document.querySelectorAll('main,nav,header,footer,aside,[role="main"],[role="navigation"]'))
+            .filter(isVisible)
+            .slice(0, 32)
+            .map((element) => ({ role: roleFor(element), label: nameFor(element) }));
+        const alerts = Array.from(document.querySelectorAll('[role="alert"],[aria-live]'))
+            .filter(isVisible)
+            .slice(0, 16)
+            .map((element) => normalize(element.textContent ?? '', 500))
+            .filter(Boolean);
+        const activeSelection = this.readSafeSelection();
+        if (activeSelection)
+            this.recentSelection = activeSelection;
+        if (this.recentSelection &&
+            Date.now() - Date.parse(this.recentSelection.capturedAt) > SELECTION_RETENTION_MS) {
+            this.recentSelection = null;
+        }
+        return {
+            schemaVersion: 1,
+            pageId: this.pageId,
+            revision,
+            url: safePageUrl(),
+            title: normalize(document.title, 512),
+            locale: normalize(document.documentElement.lang || navigator.language || 'en', 16),
+            viewport: {
+                width: Math.max(1, Math.round(window.innerWidth)),
+                height: Math.max(1, Math.round(window.innerHeight)),
+                scrollY: Math.max(0, Math.round(window.scrollY)),
+            },
+            landmarks,
+            visibleText,
+            ...(this.recentSelection ? { selection: this.recentSelection } : {}),
+            targets: targetValues,
+            alerts,
+            truncated,
+        };
+    }
+    captureVisualContext() {
+        if (this.revision < 1 || this.targets.size === 0)
+            return null;
+        const viewportWidth = Math.max(1, Math.round(window.innerWidth));
+        const viewportHeight = Math.max(1, Math.round(window.innerHeight));
+        const regions = [];
+        for (const handle of this.targets.values()) {
+            const rect = handle.element.getBoundingClientRect();
+            const geometry = this.clippedGeometry(rect, viewportWidth, viewportHeight);
+            if (!geometry)
+                continue;
+            const protectedTarget = handle.target.sensitivity !== 'none' || handle.target.protectedRegion !== false;
+            regions.push({
+                ...geometry,
+                kind: protectedTarget ? 'mask' : 'target',
+                role: protectedTarget ? 'protected' : handle.target.role,
+                label: protectedTarget ? '' : normalize(handle.target.name, 80),
+            });
+            if (regions.length >= 256)
+                break;
+        }
+        const protectedElements = document.querySelectorAll(`${PRIVATE_SELECTOR},iframe`);
+        for (const element of protectedElements) {
+            if (element.matches('[data-oxvo-ai-live-assist-root]'))
+                continue;
+            const geometry = this.clippedGeometry(element.getBoundingClientRect(), viewportWidth, viewportHeight);
+            if (!geometry)
+                continue;
+            regions.push({ ...geometry, kind: 'mask', role: 'protected', label: '' });
+            if (regions.length >= 320)
+                break;
+        }
+        return renderSanitizedLayout({
+            pageId: this.pageId,
+            revision: this.revision,
+            viewport: { width: viewportWidth, height: viewportHeight },
+            regions,
+        });
+    }
+    async execute(grant) {
+        const handle = this.targets.get(grant.targetId);
+        const base = {
+            grant: grant.grant,
+            actionId: grant.actionId,
+        };
+        if (Date.parse(grant.expiresAt) <= Date.now() ||
+            grant.domRevision !== this.revision ||
+            !handle ||
+            handle.revision !== this.revision ||
+            !handle.element.isConnected) {
+            return {
+                ...base,
+                status: 'stale',
+                observed: {
+                    url: safePageUrl(),
+                    revision: this.revision,
+                    targetState: 'detached',
+                    safeSummary: 'The requested target changed before execution.',
+                },
+            };
+        }
+        const element = handle.element;
+        const sensitivity = sensitivityFor(element, nameFor(element));
+        const canRevealDesiredStateTarget = grant.action === 'click' &&
+            grant.desiredChecked !== undefined &&
+            element instanceof HTMLInputElement &&
+            ['checkbox', 'radio'].includes(element.type);
+        if (sensitivity !== 'none' ||
+            handle.target.protectedRegion !== false ||
+            !isRendered(element) ||
+            (grant.action !== 'scroll' && !isVisible(element) && !canRevealDesiredStateTarget) ||
+            !enabled(element) ||
+            (grant.action !== 'scroll' && isVisible(element) && isCovered(element))) {
+            return {
+                ...base,
+                status: 'blocked',
+                observed: {
+                    url: safePageUrl(),
+                    revision: this.revision,
+                    targetState: 'unchanged',
+                    safeSummary: 'The target is unavailable or protected.',
+                },
+            };
+        }
+        if (!isVisible(element) && canRevealDesiredStateTarget) {
+            element.scrollIntoView({ behavior: 'auto', block: 'center' });
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            if (!isRendered(element) || !isVisible(element) || isCovered(element)) {
+                return {
+                    ...base,
+                    status: 'blocked',
+                    observed: {
+                        url: safePageUrl(),
+                        revision: this.revision,
+                        targetState: 'unchanged',
+                        safeSummary: 'The target could not be safely brought into view.',
+                    },
+                };
+            }
+        }
+        const before = this.safeState(element);
+        this.executingActionId = grant.actionId;
+        this.pendingCapture = false;
+        this.deferredNavigation = null;
+        this.callbacks.onHighlight(element, 'focus');
+        try {
+            switch (grant.action) {
+                case 'scroll':
+                    element.scrollIntoView({
+                        behavior: this.reducedMotion() ? 'auto' : 'smooth',
+                        block: 'center',
+                    });
+                    break;
+                case 'highlight':
+                    break;
+                case 'focus':
+                    if (!(element instanceof HTMLElement))
+                        throw new Error('Target cannot receive focus.');
+                    element.focus({ preventScroll: false });
+                    break;
+                case 'click':
+                    this.click(element, grant.actionId, grant.desiredChecked);
+                    break;
+                case 'type':
+                    this.type(element, grant.value ?? '');
+                    break;
+                case 'select':
+                    this.select(element, handle, grant.optionValueId);
+                    break;
+                case 'submit':
+                    this.submit(element);
+                    break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            if (!this.actionApplied(grant, element, handle)) {
+                throw new Error('The approved value was not applied.');
+            }
+            const snapshot = this.capture();
+            const attached = element.isConnected;
+            const after = attached ? this.safeState(element) : '';
+            this.callbacks.onHighlight(attached ? element : null, 'success');
+            return {
+                ...base,
+                status: 'executed',
+                observed: {
+                    url: safePageUrl(),
+                    revision: snapshot.revision,
+                    targetState: !attached
+                        ? 'detached'
+                        : grant.action === 'type' || grant.action === 'select' || before !== after
+                            ? 'changed'
+                            : 'unchanged',
+                    safeSummary: grant.action === 'type'
+                        ? 'The requested text was applied to the approved field.'
+                        : grant.action === 'select'
+                            ? 'The requested option was applied to the approved field.'
+                            : grant.desiredChecked !== undefined
+                                ? 'The requested checkbox state was applied.'
+                                : `${grant.action} executed on the approved ${roleFor(element)} target.`,
+                    ...(element instanceof HTMLInputElement && ['checkbox', 'radio'].includes(element.type)
+                        ? { checked: element.checked }
+                        : {}),
+                },
+            };
+        }
+        catch {
+            this.callbacks.onHighlight(element, 'failure');
+            return {
+                ...base,
+                status: 'failed',
+                observed: {
+                    url: safePageUrl(),
+                    revision: this.revision,
+                    targetState: element.isConnected ? 'unchanged' : 'detached',
+                    safeSummary: 'The approved page action failed safely.',
+                },
+            };
+        }
+    }
+    async completeActionExecution(actionId) {
+        if (this.executingActionId !== actionId)
+            return null;
+        this.executingActionId = null;
+        const navigation = this.pendingNavigation;
+        this.pendingNavigation = null;
+        const shouldCapture = this.pendingCapture || Boolean(navigation);
+        this.pendingCapture = false;
+        if (navigation && this.running) {
+            await this.callbacks.onNavigation(navigation.pageId, Math.max(navigation.revision, this.revision), navigation.url);
+        }
+        if (this.running && (shouldCapture || !navigation)) {
+            await this.captureAndPublish();
+        }
+        const deferred = this.deferredNavigation;
+        this.deferredNavigation = null;
+        return deferred?.actionId === actionId && window.location.href === deferred.fromUrl
+            ? deferred.toUrl
+            : null;
+    }
+    click(element, actionId, desiredChecked) {
+        if (!(element instanceof HTMLElement))
+            throw new Error('Target is not clickable.');
+        if (desiredChecked !== undefined) {
+            if (!(element instanceof HTMLInputElement) || !['checkbox', 'radio'].includes(element.type)) {
+                throw new Error('Desired checked state requires a checkbox or radio target.');
+            }
+            if (element.checked === desiredChecked)
+                return;
+            if (element.type === 'radio' && !desiredChecked) {
+                throw new Error('A radio target cannot be cleared by clicking it.');
+            }
+        }
+        if (element instanceof HTMLAnchorElement) {
+            const target = new URL(element.href, window.location.href);
+            if (target.origin !== window.location.origin) {
+                throw new Error('External navigation is blocked.');
+            }
+            if ((element.target && element.target.toLowerCase() !== '_self') ||
+                element.hasAttribute('download')) {
+                throw new Error('New-window and download navigation is blocked.');
+            }
+            const fromUrl = window.location.href;
+            const preventDocumentNavigation = (event) => {
+                if (event.composedPath().includes(element))
+                    event.preventDefault();
+            };
+            window.addEventListener('click', preventDocumentNavigation, { once: true });
+            try {
+                element.click();
+            }
+            finally {
+                window.removeEventListener('click', preventDocumentNavigation);
+            }
+            if (window.location.href === fromUrl && target.href !== fromUrl) {
+                this.deferredNavigation = {
+                    actionId,
+                    fromUrl,
+                    toUrl: target.href,
+                };
+            }
+            return;
+        }
+        element.click();
+    }
+    type(element, value) {
+        if (value.length > 2000)
+            throw new Error('Value is too long.');
+        if (element instanceof HTMLInputElement) {
+            if (!['text', 'search', 'email', 'tel', 'url', 'number'].includes(element.type)) {
+                throw new Error('Input type is not supported.');
+            }
+            const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
+            if (!setter)
+                throw new Error('Input value cannot be updated safely.');
+            const previousValue = element.value;
+            const nextValue = element.type === 'number' ? value.trim() : value;
+            if (element.type === 'number' && (!nextValue || !Number.isFinite(Number(nextValue)))) {
+                throw new Error('Numeric input requires a finite value.');
+            }
+            setter.call(element, nextValue);
+            if (element.type === 'number' &&
+                (element.value !== nextValue ||
+                    element.validity.badInput ||
+                    element.validity.rangeUnderflow ||
+                    element.validity.rangeOverflow ||
+                    element.validity.stepMismatch)) {
+                setter.call(element, previousValue);
+                throw new Error('Numeric input value is outside the allowed constraints.');
+            }
+        }
+        else if (element instanceof HTMLTextAreaElement) {
+            const setter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value')?.set;
+            setter?.call(element, value);
+        }
+        else if (element instanceof HTMLElement && element.isContentEditable) {
+            element.textContent = value;
+        }
+        else {
+            throw new Error('Target does not accept text.');
+        }
+        element.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertText', data: value }));
+        element.dispatchEvent(new Event('change', { bubbles: true }));
+    }
+    select(element, handle, optionValueId) {
+        if (!(element instanceof HTMLSelectElement) || !optionValueId) {
+            throw new Error('Select target is invalid.');
+        }
+        const option = handle.options.get(optionValueId);
+        if (!option || option.disabled || !option.isConnected) {
+            throw new Error('Select option is unavailable.');
+        }
+        element.value = option.value;
+        element.dispatchEvent(new Event('input', { bubbles: true }));
+        element.dispatchEvent(new Event('change', { bubbles: true }));
+    }
+    submit(element) {
+        const form = element instanceof HTMLFormElement ? element : element.closest('form');
+        if (!(form instanceof HTMLFormElement))
+            throw new Error('Form target is unavailable.');
+        const submitter = element instanceof HTMLButtonElement ||
+            (element instanceof HTMLInputElement && element.type === 'submit')
+            ? element
+            : undefined;
+        if (typeof form.requestSubmit !== 'function') {
+            throw new Error('Safe form submission is not supported.');
+        }
+        form.requestSubmit(submitter);
+    }
+    safeState(element) {
+        return JSON.stringify({
+            connected: element.isConnected,
+            disabled: !enabled(element),
+            expanded: element.getAttribute('aria-expanded'),
+            checked: element instanceof HTMLInputElement && ['checkbox', 'radio'].includes(element.type)
+                ? element.checked
+                : undefined,
+            selectedIndex: element instanceof HTMLSelectElement ? element.selectedIndex : undefined,
+            path: window.location.pathname,
+        });
+    }
+    actionApplied(grant, element, handle) {
+        if (grant.desiredChecked !== undefined) {
+            return (element instanceof HTMLInputElement &&
+                ['checkbox', 'radio'].includes(element.type) &&
+                element.checked === grant.desiredChecked);
+        }
+        if (grant.action === 'type') {
+            if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+                return element.value === (grant.value ?? '');
+            }
+            if (element instanceof HTMLElement && element.isContentEditable) {
+                return element.textContent === (grant.value ?? '');
+            }
+            return false;
+        }
+        if (grant.action === 'select') {
+            const option = grant.optionValueId ? handle.options.get(grant.optionValueId) : undefined;
+            return (element instanceof HTMLSelectElement && Boolean(option) && element.value === option?.value);
+        }
+        return true;
+    }
+    clippedGeometry(rect, viewportWidth, viewportHeight) {
+        const left = Math.max(0, Math.min(viewportWidth, rect.left));
+        const top = Math.max(0, Math.min(viewportHeight, rect.top));
+        const right = Math.max(0, Math.min(viewportWidth, rect.right));
+        const bottom = Math.max(0, Math.min(viewportHeight, rect.bottom));
+        const width = Math.round(right - left);
+        const height = Math.round(bottom - top);
+        if (width < 2 || height < 2)
+            return null;
+        return {
+            x: Math.round(left),
+            y: Math.round(top),
+            width,
+            height,
+        };
+    }
+    readSafeSelection() {
+        const selection = window.getSelection();
+        if (!selection || selection.isCollapsed || selection.rangeCount !== 1)
+            return null;
+        const range = selection.getRangeAt(0);
+        const root = range.commonAncestorContainer;
+        const nodes = [];
+        if (root.nodeType === Node.TEXT_NODE) {
+            nodes.push(root);
+        }
+        else {
+            const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+            let node = walker.nextNode();
+            while (node) {
+                nodes.push(node);
+                node = walker.nextNode();
+            }
+        }
+        const segments = [];
+        let total = 0;
+        for (const node of nodes) {
+            if (total >= MAX_SELECTED_TEXT)
+                break;
+            const parent = node.parentElement;
+            if (!parent ||
+                parent.closest(PRIVATE_SELECTOR) ||
+                !isVisible(parent) ||
+                sensitivityFor(parent, nameFor(parent)) !== 'none') {
+                continue;
+            }
+            try {
+                if (!range.intersectsNode(node))
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const start = node === range.startContainer ? range.startOffset : 0;
+            const end = node === range.endContainer ? range.endOffset : node.data.length;
+            const segment = node.data.slice(start, end);
+            if (!segment)
+                continue;
+            segments.push(segment);
+            total += segment.length;
+        }
+        const text = normalize(segments.join(' '), MAX_SELECTED_TEXT);
+        if (!text)
+            return null;
+        return {
+            text,
+            source: 'document',
+            capturedAt: new Date().toISOString(),
+        };
+    }
+    installNavigationHooks() {
+        this.originalPushState = history.pushState;
+        this.originalReplaceState = history.replaceState;
+        const notify = () => queueMicrotask(this.handleNavigation);
+        const push = this.originalPushState;
+        const replace = this.originalReplaceState;
+        history.pushState = function (...args) {
+            push.apply(this, args);
+            notify();
+        };
+        history.replaceState = function (...args) {
+            replace.apply(this, args);
+            notify();
+        };
+    }
+    restoreNavigationHooks() {
+        if (this.originalPushState)
+            history.pushState = this.originalPushState;
+        if (this.originalReplaceState)
+            history.replaceState = this.originalReplaceState;
+        this.originalPushState = null;
+        this.originalReplaceState = null;
+    }
+    reducedMotion() {
+        return window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+    }
+}