@mlola/backend-playwright 0.1.0

package/dist/snapshot-script.js

@@ -0,0 +1,723 @@
+/**
+ * Atomic in-page observation (PRD §12).
+ *
+ * One page-side pass collects URL, title, visible text, controls, roles,
+ * labels, values, state, options, geometry, hit-testing, blocking UI, scroll
+ * and structural fingerprint — instead of a protocol conversation per element.
+ *
+ * The function below is serialized by Playwright and runs in the page, so it
+ * must be entirely self-contained.
+ */
+/** Serialized and executed inside the page. Must stay self-contained. */
+export function collectSnapshot(args) {
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    const w = window;
+    const BRIDGE_KEY = "__mlola_bridge_v1";
+    if (!w[BRIDGE_KEY]) {
+        const bridge = {
+            ids: new WeakMap(),
+            byId: new Map(),
+            nextId: 1,
+            mutations: 0,
+        };
+        Object.defineProperty(w, BRIDGE_KEY, { value: bridge, enumerable: false, configurable: true });
+        try {
+            const observer = new MutationObserver((records) => {
+                bridge.mutations += records.length;
+            });
+            observer.observe(document.documentElement, {
+                childList: true,
+                subtree: true,
+                attributes: true,
+                characterData: false,
+            });
+        }
+        catch {
+            /* observation is best-effort */
+        }
+    }
+    const bridge = w[BRIDGE_KEY];
+    const nodeIdOf = (el) => {
+        let id = bridge.ids.get(el);
+        if (typeof id !== "number") {
+            id = bridge.nextId++;
+            bridge.ids.set(el, id);
+            try {
+                bridge.byId.set(id, new WeakRef(el));
+            }
+            catch {
+                bridge.byId.set(id, el);
+            }
+        }
+        return id;
+    };
+    const hash = (input) => {
+        let h = 2166136261;
+        for (let i = 0; i < input.length; i += 1) {
+            h ^= input.charCodeAt(i);
+            h = Math.imul(h, 16777619);
+        }
+        return (h >>> 0).toString(16).padStart(8, "0");
+    };
+    const collapse = (s) => s.replace(/\s+/g, " ").trim();
+    const isVisible = (el) => {
+        const style = getComputedStyle(el);
+        if (style.visibility === "hidden" || style.display === "none" || style.opacity === "0")
+            return false;
+        if (el.getClientRects().length === 0)
+            return false;
+        if (el.closest('[aria-hidden="true"]') && !el.closest('[role="dialog"], [role="alertdialog"]'))
+            return false;
+        return true;
+    };
+    const rectOf = (el) => {
+        const r = el.getBoundingClientRect();
+        return { x: Math.round(r.left), y: Math.round(r.top), width: Math.round(r.width), height: Math.round(r.height) };
+    };
+    const docRectOf = (el) => {
+        const r = el.getBoundingClientRect();
+        return {
+            x: Math.round(r.left + scrollX),
+            y: Math.round(r.top + scrollY),
+            width: Math.round(r.width),
+            height: Math.round(r.height),
+        };
+    };
+    const hitTarget = (el, r) => {
+        if (r.width < 2 || r.height < 2)
+            return false;
+        const x = Math.min(Math.max(r.x + r.width / 2, 1), innerWidth - 2);
+        const y = Math.min(Math.max(r.y + r.height / 2, 1), innerHeight - 2);
+        const top = document.elementFromPoint(x, y);
+        if (!top)
+            return false;
+        return top === el || el.contains(top) || top.contains(el);
+    };
+    const nameOf = (el) => {
+        const aria = el.getAttribute("aria-label");
+        if (aria && collapse(aria).length > 0)
+            return collapse(aria);
+        const labelledBy = el.getAttribute("aria-labelledby");
+        if (labelledBy) {
+            const parts = labelledBy
+                .split(/\s+/)
+                .map((id) => document.getElementById(id))
+                .filter((n) => n !== null)
+                .map((n) => collapse(n.innerText || n.textContent || ""));
+            const joined = collapse(parts.join(" "));
+            if (joined.length > 0)
+                return joined;
+        }
+        const id = el.getAttribute("id");
+        if (id) {
+            const explicit = document.querySelector(`label[for="${CSS.escape(id)}"]`);
+            if (explicit) {
+                const text = collapse(explicit.innerText || explicit.textContent || "");
+                if (text.length > 0)
+                    return text;
+            }
+        }
+        const ancestorLabel = el.closest("label");
+        if (ancestorLabel) {
+            const text = collapse(ancestorLabel.innerText || ancestorLabel.textContent || "");
+            const own = el.getAttribute("placeholder") ?? "";
+            const cleaned = collapse(text.replace(own, ""));
+            if (cleaned.length > 0 && cleaned.length < 120)
+                return cleaned;
+        }
+        const tag = el.tagName.toLowerCase();
+        const type = (el.getAttribute("type") ?? "").toLowerCase();
+        if (tag === "input" && (type === "submit" || type === "button" || type === "reset")) {
+            const v = el.value;
+            if (v && v.length > 0)
+                return collapse(v);
+        }
+        if (tag === "img") {
+            const alt = el.getAttribute("alt");
+            if (alt)
+                return collapse(alt);
+        }
+        const title = el.getAttribute("title");
+        if (title && collapse(title).length > 0)
+            return collapse(title);
+        const placeholder = el.getAttribute("placeholder");
+        if (placeholder && collapse(placeholder).length > 0)
+            return collapse(placeholder);
+        const text = collapse(el.innerText || el.textContent || "");
+        if (text.length > 0)
+            return text.slice(0, 140);
+        if (tag === "a") {
+            const href = el.getAttribute("href") ?? "";
+            if (href.length > 0 && href !== "#")
+                return href.slice(0, 100);
+        }
+        return "";
+    };
+    const roleOf = (el) => {
+        const explicit = (el.getAttribute("role") ?? "").toLowerCase();
+        if (explicit.length > 0) {
+            const known = [
+                "button",
+                "link",
+                "textbox",
+                "searchbox",
+                "combobox",
+                "listbox",
+                "option",
+                "checkbox",
+                "radio",
+                "switch",
+                "slider",
+                "spinbutton",
+                "menuitem",
+                "menuitemcheckbox",
+                "menuitemradio",
+                "tab",
+                "dialog",
+                "alertdialog",
+                "alert",
+                "heading",
+            ];
+            if (known.indexOf(explicit) >= 0)
+                return explicit;
+        }
+        const tag = el.tagName.toLowerCase();
+        if (tag === "a")
+            return "link";
+        if (tag === "button")
+            return "button";
+        if (tag === "select")
+            return el.multiple ? "listbox" : "combobox";
+        if (tag === "textarea")
+            return "textbox";
+        if (tag === "dialog")
+            return "dialog";
+        if (el.hasAttribute("contenteditable") && el.getAttribute("contenteditable") !== "false")
+            return "contenteditable";
+        if (tag === "input") {
+            const type = (el.getAttribute("type") ?? "text").toLowerCase();
+            if (type === "checkbox")
+                return "checkbox";
+            if (type === "radio")
+                return "radio";
+            if (type === "file")
+                return "fileinput";
+            if (type === "search")
+                return "searchbox";
+            if (type === "submit" || type === "button" || type === "reset" || type === "image")
+                return "button";
+            if (type === "range")
+                return "slider";
+            if (type === "number")
+                return "spinbutton";
+            if (type === "hidden")
+                return "other";
+            return "textbox";
+        }
+        return "other";
+    };
+    const DOWNLOAD_EXT = /\.(pdf|csv|xlsx|xls|docx|doc|zip|png|jpe?g|txt|json|xml|epub|srt)$/i;
+    const DOWNLOAD_LABEL = /\b(download|unduh|export|save\s+as|simpan|ekspor|\(pdf\)|\(csv\))\b/i;
+    const UPLOAD_LABEL = /\b(upload|unggah|choose\s+file|select\s+file|add\s+file|attach|lampirkan|pilih\s+file)\b/i;
+    const selector = [
+        "a[href]",
+        "button",
+        "input:not([type=hidden])",
+        "select",
+        "textarea",
+        "summary",
+        "[role=button]",
+        "[role=link]",
+        "[role=textbox]",
+        "[role=searchbox]",
+        "[role=combobox]",
+        "[role=listbox]",
+        "[role=checkbox]",
+        "[role=radio]",
+        "[role=switch]",
+        "[role=tab]",
+        "[role=menuitem]",
+        "[role=menuitemcheckbox]",
+        "[role=menuitemradio]",
+        "[role=slider]",
+        "[role=spinbutton]",
+        "[role=option]",
+        "[contenteditable=true]",
+        "[contenteditable='']",
+        "[tabindex]",
+        "[ondrop]",
+        "[onclick]",
+        "label[for]",
+    ].join(",");
+    const all = Array.from(document.querySelectorAll(selector));
+    const seen = new Set();
+    const nodes = [];
+    const elements = [];
+    const nodeIndexByElement = new Map();
+    /**
+     * Agent-directed instruction text next to a control (PRD §22.4). Deterministic
+     * and structural: preceding sibling text within three ancestor levels.
+     */
+    const AGENT_DIRECTED = [
+        /\bignore\s+(all\s+|any\s+|the\s+)?(previous|prior|above|earlier)\b/i,
+        /<\s*\/?\s*(system|assistant)\s*>/i,
+        /\b(?:hey|dear)\s+(ai|agent|assistant|bot|claude|gpt)\b/i,
+        /\b(ai|agent|assistant|bot)[^.]{0,30}\b(click|press|select|open|go\s+to|navigate|send|upload|pay)\b/i,
+        /\b(do\s+not|don'?t|never)\s+(tell|inform|notify|mention|show)\b/i,
+        /\b(send|share|paste|upload|email|forward)\b[^.]{0,40}\b(password|passcode|api[\s_-]?key|secret|token|otp|credentials?)\b/i,
+        /\bimportant\s*:?\s*(agent|ai|assistant)\b/i,
+        /\bnew\s+instructions?\s*:/i,
+    ];
+    const nearbyInstruction = (el) => {
+        // Only the element's own preceding siblings count: instruction text in a
+        // different container must not quarantine an unrelated control.
+        let sibling = el.previousElementSibling;
+        let hops = 0;
+        while (sibling && hops < 4) {
+            const snippet = (sibling.textContent ?? "").replace(/\s+/g, " ").trim();
+            if (snippet.length > 0) {
+                for (const pattern of AGENT_DIRECTED) {
+                    if (pattern.test(snippet))
+                        return true;
+                }
+            }
+            sibling = sibling.previousElementSibling;
+            hops += 1;
+        }
+        return false;
+    };
+    for (const el of all) {
+        if (seen.has(el))
+            continue;
+        seen.add(el);
+        // Collect up to three times the budget, then prioritise (PRD §12).
+        if (nodes.length >= args.maxNodes * 3)
+            break;
+        const role = roleOf(el);
+        const tag = el.tagName.toLowerCase();
+        const inputType = tag === "input" ? (el.getAttribute("type") ?? "text").toLowerCase() : undefined;
+        const isFile = role === "fileinput";
+        const visible = isVisible(el);
+        if (!visible && !isFile)
+            continue;
+        const r = rectOf(el);
+        const offscreen = r.y + r.height < 0 || r.y > innerHeight || r.x + r.width < 0 || r.x > innerWidth;
+        const enabled = !el.disabled &&
+            el.getAttribute("aria-disabled") !== "true" &&
+            !el.hasAttribute("inert");
+        const label = nameOf(el);
+        const flags = {
+            visible,
+            hitTarget: isFile ? true : visible ? hitTarget(el, r) : false,
+            enabled,
+            editable: false,
+            readonly: el.readOnly === true || el.getAttribute("aria-readonly") === "true",
+            required: el.required === true || el.getAttribute("aria-required") === "true",
+            disabled: !enabled,
+            inert: el.hasAttribute("inert"),
+            offscreen,
+        };
+        const isChoice = role === "checkbox" || role === "radio" || role === "switch";
+        if (isChoice) {
+            const checked = el.checked;
+            flags.checked = typeof checked === "boolean" ? checked : el.getAttribute("aria-checked") === "true";
+        }
+        const selected = el.getAttribute("aria-selected");
+        if (selected !== null)
+            flags.selected = selected === "true";
+        const expanded = el.getAttribute("aria-expanded");
+        if (expanded !== null)
+            flags.expanded = expanded === "true";
+        const isTextish = role === "textbox" || role === "searchbox" || role === "contenteditable" || role === "spinbutton";
+        const isEditableSelect = role === "combobox" && tag !== "select";
+        flags.editable =
+            enabled &&
+                !flags.readonly &&
+                !el.hasAttribute("inert") &&
+                (isTextish || isEditableSelect) &&
+                inputType !== "password";
+        // Values: never read secrets. Password and one-time-code fields stay opaque.
+        let value;
+        const autocomplete = (el.getAttribute("autocomplete") ?? "").toLowerCase();
+        const isPassword = inputType === "password" || autocomplete === "one-time-code" || autocomplete === "current-password" || autocomplete === "new-password";
+        if (isFile) {
+            // File inputs expose only the selected file names, never contents.
+            const files = el.files;
+            if (files && files.length > 0) {
+                value = Array.from(files).map((file) => file.name).join(", ").slice(0, 200);
+            }
+        }
+        else if (!isPassword) {
+            if (tag === "select") {
+                const sel = el;
+                value = sel.options[sel.selectedIndex]?.text ?? "";
+            }
+            else if (isTextish && tag !== "textarea") {
+                const raw = el.value;
+                if (typeof raw === "string" && raw.length > 0)
+                    value = raw.slice(0, 120);
+            }
+            else if (tag === "textarea") {
+                const raw = el.value;
+                if (typeof raw === "string" && raw.length > 0)
+                    value = raw.slice(0, 120);
+            }
+            else if (isChoice) {
+                value = undefined;
+            }
+        }
+        const options = tag === "select"
+            ? Array.from(el.options)
+                .slice(0, 80)
+                .map((o, i) => ({
+                index: i + 1,
+                label: collapse(o.text || o.value),
+                value: o.value,
+                disabled: o.disabled,
+                selected: o.selected,
+            }))
+            : undefined;
+        const href = tag === "a" ? el.href : undefined;
+        const downloadAttr = el.hasAttribute("download");
+        const kindParts = [];
+        const targetAttr = el.getAttribute("target");
+        if (targetAttr)
+            kindParts.push(targetAttr);
+        if (downloadAttr)
+            kindParts.push("download");
+        if (isFile)
+            kindParts.push("file-input");
+        if (el.hasAttribute("ondrop"))
+            kindParts.push("drop-zone");
+        const kind = kindParts.length > 0 ? kindParts.join(" ") : undefined;
+        const operations = [];
+        const isNativeSelect = tag === "select";
+        const isOption = role === "option";
+        if (!isNativeSelect &&
+            !isOption &&
+            (role === "button" ||
+                role === "link" ||
+                role === "checkbox" ||
+                role === "radio" ||
+                role === "switch" ||
+                role === "tab" ||
+                role === "menuitem" ||
+                role === "menuitemcheckbox" ||
+                role === "menuitemradio" ||
+                tag === "summary" ||
+                tag === "label" ||
+                el.hasAttribute("onclick") ||
+                inputType === "submit" ||
+                inputType === "button" ||
+                inputType === "reset")) {
+            operations.push("CLICK");
+        }
+        // Custom combobox/listbox options are clickable controls; native <option>
+        // elements are not collected as elements at all (they are driven by SELECT).
+        if (isOption)
+            operations.push("CLICK");
+        if (isTextish || isEditableSelect)
+            operations.push("TYPE_TEXT");
+        if (isNativeSelect)
+            operations.push("SELECT");
+        if (isFile)
+            operations.push("UPLOAD");
+        if ((role === "button" || role === "link" || tag === "label") &&
+            UPLOAD_LABEL.test(label) &&
+            !isFile) {
+            operations.push("UPLOAD");
+        }
+        if ((role === "link" || role === "button") &&
+            ((href !== undefined && DOWNLOAD_EXT.test(href)) || downloadAttr || DOWNLOAD_LABEL.test(label))) {
+            operations.push("DOWNLOAD");
+        }
+        if (operations.length === 0 && role !== "tab")
+            continue;
+        const index = nodes.length + 1;
+        nodeIndexByElement.set(el, index);
+        const formOwner = el.form;
+        nodes.push({
+            index,
+            nodeId: nodeIdOf(el),
+            role,
+            label,
+            labelHash: hash(`${role}|${label}|${tag}`),
+            tag,
+            ...(kind !== undefined ? { kind } : {}),
+            ...(inputType !== undefined ? { inputType } : {}),
+            ...(value !== undefined && value.length > 0 ? { value } : {}),
+            ...(el.getAttribute("placeholder") ? { placeholder: collapse(el.getAttribute("placeholder") ?? "") } : {}),
+            ...(el.getAttribute("title") ? { title: collapse(el.getAttribute("title") ?? "") } : {}),
+            ...(href !== undefined ? { href } : {}),
+            ...(el.getAttribute("accept") ? { accept: el.getAttribute("accept") ?? "" } : {}),
+            ...(el.hasAttribute("multiple") ? { multiple: true } : {}),
+            ...(options ? { options } : {}),
+            flags: { ...flags, suspicious: nearbyInstruction(el) },
+            operations,
+            ...(r.width > 0 || r.height > 0 ? { geometry: r, documentRect: docRectOf(el) } : {}),
+            ...(formOwner ? { formNodeId: nodeIdOf(formOwner) } : {}),
+        });
+        elements.push(el);
+    }
+    /* ── Prioritise and bound the element table (PRD §12) ───────────────────── */
+    const order = nodes.map((_node, i) => i);
+    order.sort((a, b) => {
+        const na = nodes[a];
+        const nb = nodes[b];
+        if (na.flags.visible !== nb.flags.visible)
+            return na.flags.visible ? -1 : 1;
+        if (na.operations.length !== nb.operations.length)
+            return nb.operations.length - na.operations.length;
+        return a - b;
+    });
+    const kept = order.slice(0, args.maxNodes);
+    const keptNodes = kept.map((i) => nodes[i]);
+    keptNodes.forEach((node, index) => {
+        node.index = index + 1;
+    });
+    nodes.length = 0;
+    nodes.push(...keptNodes);
+    nodeIndexByElement.clear();
+    kept.forEach((originalIndex, position) => {
+        const el = elements[originalIndex];
+        if (el)
+            nodeIndexByElement.set(el, position + 1);
+    });
+    /* ── Blocking UI (PRD §37) ─────────────────────────────────────────────── */
+    let blockingUi;
+    const modalSelectors = ['[role="dialog"]', '[role="alertdialog"]', "dialog[open]", '[aria-modal="true"]'];
+    let modal;
+    for (const sel of modalSelectors) {
+        const found = Array.from(document.querySelectorAll(sel)).filter(isVisible);
+        if (found.length > 0) {
+            modal = found[0];
+            break;
+        }
+    }
+    if (!modal) {
+        const cookie = Array.from(document.querySelectorAll('[id*="cookie" i],[class*="cookie" i],[id*="consent" i],[class*="consent" i],[aria-label*="cookie" i],[id*="gdpr" i]')).filter(isVisible);
+        if (cookie.length > 0)
+            modal = cookie[0];
+    }
+    if (modal) {
+        const modalNodes = [];
+        for (const el of Array.from(modal.querySelectorAll(selector))) {
+            const idx = nodeIndexByElement.get(el);
+            if (idx !== undefined)
+                modalNodes.push(idx);
+            if (modalNodes.length >= 10)
+                break;
+        }
+        const isCookie = /cookie|consent|gdpr/i.test(`${modal.id} ${modal.className}`);
+        blockingUi = {
+            kind: isCookie ? "cookie_consent" : modal.getAttribute("role") === "alertdialog" ? "confirm" : "dialog",
+            ...(modal.getAttribute("aria-label") ? { title: collapse(modal.getAttribute("aria-label") ?? "") } : {}),
+            ...(collapse(modal.innerText || "").length > 0
+                ? { text: collapse(modal.innerText || "").slice(0, 300) }
+                : {}),
+            nodeIndexes: modalNodes,
+        };
+    }
+    /* ── Visible text + injection signals ──────────────────────────────────── */
+    const bodyText = collapse(document.body ? document.body.innerText || "" : "");
+    const textSummary = bodyText.slice(0, args.maxText);
+    const INJECTION_PATTERNS = [
+        { re: /\bignore\s+(all\s+|any\s+|the\s+)?(previous|prior|above)\b/i, severity: "high" },
+        { re: /\b(system|assistant)\s*:/i, severity: "high" },
+        { re: /\byou\s+(must|should|need\s+to|are\s+required\s+to)\b/i, severity: "high" },
+        { re: /\bdo\s+not\s+(tell|inform|notify)\b/i, severity: "high" },
+        { re: /\b(password|api[\s_-]?key|secret|token|otp)\b[^.]{0,40}\b(send|share|paste|enter|upload)\b/i, severity: "high" },
+    ];
+    const injectedTexts = [];
+    for (const line of bodyText.split(/(?<=[.!?])\s+/).slice(0, 400)) {
+        if (line.length < 8 || line.length > 400)
+            continue;
+        for (const p of INJECTION_PATTERNS) {
+            if (p.re.test(line)) {
+                injectedTexts.push({ text: line.slice(0, 200), provenance: "untrusted_page_content", suspicious: true });
+                break;
+            }
+        }
+        if (injectedTexts.length >= 8)
+            break;
+    }
+    /* ── Fingerprint ───────────────────────────────────────────────────────── */
+    const parts = [];
+    for (const n of nodes) {
+        parts.push(`${n.index}|${n.role}|${n.labelHash}|${n.value ?? ""}|${n.flags.checked ?? ""}|${n.flags.selected ?? ""}|${n.flags.expanded ?? ""}|${n.flags.disabled ? 1 : 0}`);
+    }
+    const fingerprint = hash(`${location.href}|${document.title}|${Math.round(scrollY)}|${blockingUi?.kind ?? "-"}|${parts.join(";")}`);
+    const canvasCount = document.querySelectorAll("canvas").length;
+    const visualOnly = canvasCount > 0 && nodes.length === 0;
+    return {
+        url: location.href,
+        title: document.title,
+        readyState: document.readyState,
+        textSummary,
+        injectedTexts,
+        nodes,
+        viewport: {
+            width: innerWidth,
+            height: innerHeight,
+            scrollX: Math.round(scrollX),
+            scrollY: Math.round(scrollY),
+            documentWidth: Math.max(document.documentElement.scrollWidth, innerWidth),
+            documentHeight: Math.max(document.documentElement.scrollHeight, innerHeight),
+        },
+        ...(blockingUi ? { blockingUi } : {}),
+        fingerprint,
+        mutationCount: bridge.mutations,
+        visualOnly,
+        frameCount: window.frames.length,
+        documentToken: args.token,
+    };
+}
+export function validateTarget(args) {
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    const w = window;
+    const bridge = w.__mlola_bridge_v1;
+    if (!bridge)
+        return { ok: false, code: "STALE_DECISION", detail: "page bridge is missing" };
+    if (args.pageToken !== args.expectedToken) {
+        return {
+            ok: false,
+            code: "STALE_DECISION",
+            detail: "document identity changed since the observation",
+            evidence: { pageToken: args.pageToken, expected: args.expectedToken },
+        };
+    }
+    const ref = bridge.byId.get(args.nodeId);
+    const el = ref && typeof ref.deref === "function" ? ref.deref() : ref;
+    if (!el || !el.isConnected) {
+        return {
+            ok: false,
+            code: "DETACHED_TARGET",
+            detail: "the element is no longer connected to the document",
+            evidence: { nodeId: args.nodeId },
+        };
+    }
+    const style = getComputedStyle(el);
+    const isFile = el.tagName.toLowerCase() === "input" && (el.getAttribute("type") ?? "").toLowerCase() === "file";
+    const visible = style.visibility !== "hidden" && style.display !== "none" && style.opacity !== "0" && el.getClientRects().length > 0;
+    if (!visible && !isFile) {
+        return { ok: false, code: "TARGET_INVALID", detail: "the target is not visible" };
+    }
+    if (isFile && !visible) {
+        // Hidden file inputs are the normal pattern: they are driven directly.
+        return { ok: true, evidence: { hiddenFileInput: true } };
+    }
+    const disabled = el.disabled === true ||
+        el.getAttribute("aria-disabled") === "true" ||
+        el.hasAttribute("inert");
+    if (disabled) {
+        return { ok: false, code: "TARGET_INVALID", detail: "the target is disabled or inert" };
+    }
+    // Structural identity: the element instance is already guaranteed by the
+    // node registry; this catches an in-place repurposing of the same node.
+    const tag = el.tagName.toLowerCase();
+    if (args.tag && tag !== args.tag) {
+        return {
+            ok: false,
+            code: "STALE_DECISION",
+            detail: `the node identity no longer describes a <${args.tag}>`,
+            evidence: { expected: args.tag, actual: tag },
+        };
+    }
+    if (args.role && args.role !== "other") {
+        const explicit = (el.getAttribute("role") ?? "").toLowerCase();
+        const isFileInput = tag === "input" && (el.getAttribute("type") ?? "").toLowerCase() === "file";
+        const irrelevant = explicit !== "" && explicit !== args.role;
+        if (irrelevant && !(isFileInput && args.role === "fileinput")) {
+            return {
+                ok: false,
+                code: "STALE_DECISION",
+                detail: `the node role changed since the observation`,
+                evidence: { expected: args.role, actual: explicit },
+            };
+        }
+    }
+    if (args.editableOnly) {
+        const readonly = el.readOnly === true || el.getAttribute("aria-readonly") === "true";
+        const isTextLike = el.hasAttribute("contenteditable") ||
+            el.tagName.toLowerCase() === "textarea" ||
+            el.tagName.toLowerCase() === "select" ||
+            typeof el.value === "string";
+        if (readonly || !isTextLike) {
+            return { ok: false, code: "TARGET_INVALID", detail: "the target is not editable" };
+        }
+    }
+    if (args.operation === "SELECT") {
+        const select = el;
+        if (select.tagName.toLowerCase() !== "select") {
+            return { ok: false, code: "TARGET_INVALID", detail: "the target is not a select control" };
+        }
+        const option = select.options[args.optionIndex !== undefined ? args.optionIndex - 1 : -1];
+        if (!option) {
+            return { ok: false, code: "STALE_DECISION", detail: "the option no longer exists" };
+        }
+        if (option.disabled) {
+            return { ok: false, code: "TARGET_INVALID", detail: "the option is disabled" };
+        }
+        if (args.optionValue !== undefined && option.value !== args.optionValue) {
+            return {
+                ok: false,
+                code: "STALE_DECISION",
+                detail: "the option value changed since the observation",
+                evidence: { expected: args.optionValue, actual: option.value },
+            };
+        }
+    }
+    // Geometry: bring the target into view when it is offscreen, then hit-test the
+    // point the runtime is about to act on (PRD §24).
+    let r = el.getBoundingClientRect();
+    if (r.width < 2 || r.height < 2) {
+        return { ok: false, code: "TARGET_INVALID", detail: "the target has no usable geometry" };
+    }
+    const wasOffscreen = r.bottom < 0 || r.top > innerHeight || r.right < 0 || r.left > innerWidth;
+    if (wasOffscreen) {
+        try {
+            el.scrollIntoView({ block: "center", inline: "nearest" });
+            r = el.getBoundingClientRect();
+        }
+        catch {
+            /* scrolling is best-effort; the hit test below decides */
+        }
+    }
+    if (args.requireHitTarget) {
+        const x = Math.min(Math.max(r.left + r.width / 2, 1), innerWidth - 2);
+        const y = Math.min(Math.max(r.top + r.height / 2, 1), innerHeight - 2);
+        const top = document.elementFromPoint(x, y);
+        if (!top) {
+            return {
+                ok: false,
+                code: "TARGET_COVERED",
+                detail: "nothing responds at the target point",
+                evidence: { point: { x, y } },
+            };
+        }
+        if (top !== el && !el.contains(top) && !top.contains(el)) {
+            const blocker = `${top.tagName.toLowerCase()}${top.id ? `#${top.id}` : ""}`;
+            return {
+                ok: false,
+                code: "TARGET_COVERED",
+                detail: `the target is covered by ${blocker}`,
+                evidence: { blocker, point: { x, y } },
+            };
+        }
+    }
+    return { ok: true, ...(wasOffscreen ? { evidence: { scrolledIntoView: true } } : {}) };
+}
+export function probeDocument() {
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    const w = window;
+    const bridge = w.__mlola_bridge_v1;
+    const out = {
+        url: location.href,
+        mutationCount: bridge ? bridge.mutations : 0,
+        scrollY: Math.round(scrollY),
+        dialogOpen: false,
+    };
+    out.dialogOpen = !!document.querySelector('[role="dialog"],[role="alertdialog"],dialog[open],[aria-modal="true"]');
+    return out;
+}
+//# sourceMappingURL=snapshot-script.js.map