@nextclaw/x-harness 0.0.0-stage → 0.1.1

package/dist/platform-writing.js

@@ -0,0 +1,171 @@
+import { xURL, sameHandle, sameText, samePublishedText, } from "./platform-rules.js";
+export function createPlatformWriting(dependencies) {
+    const { observed, browser, followStage, readPerson, open, clock, readPost } = dependencies;
+    async function compose(action) {
+        let value = await observed({ view: "composer" });
+        if (value.needsStateCheck ||
+            value.alerts?.length ||
+            typeof value.editorText !== "string" ||
+            value.editorText.trim() !== "" ||
+            (action.kind === "reply" && value.replyToId !== action.postId))
+            throw new Error("编辑器不为空或回复上下文未绑定");
+        if (action.assets?.length)
+            await browser.act({ operation: "attachAssets", assets: action.assets });
+        await browser.act({ operation: "fillComposer", text: action.text });
+        value = await observed({ view: "composer" });
+        if (!sameText(value.editorText, action.text) ||
+            value.needsStateCheck ||
+            value.alerts?.length ||
+            (action.kind === "reply" && value.replyToId !== action.postId) ||
+            (action.accountHandle &&
+                !sameHandle(value.accountHandle, action.accountHandle)))
+            throw new Error(`提交前账号/正文/目标未核实 ${JSON.stringify({ textMatches: sameText(value.editorText, action.text), needsStateCheck: value.needsStateCheck, alerts: value.alerts, accountHandle: value.accountHandle, replyToId: value.replyToId })}`);
+        return browser.act({
+            operation: action.kind === "reply" ? "submitReply" : "submitPost",
+            beforeSubmit: action.beforeSubmit,
+            ...(action.activation ? { activation: action.activation } : {}),
+        });
+    }
+    async function findSubmission(action) {
+        if (action.kind === "follow") {
+            let value = await followStage(action, "verify-read", () => readPerson(action));
+            if (!value.needsStateCheck) {
+                const absent = browser.capabilities?.("refreshPerson") ?? [
+                    "refreshPerson",
+                ];
+                if (absent.length)
+                    return {
+                        ...value,
+                        verified: false,
+                        missing: absent,
+                        needsStateCheck: true,
+                    };
+                await followStage(action, "verify-refresh", () => browser.act({
+                    operation: "refreshPerson",
+                    handle: action.handle,
+                    url: action.url,
+                    evidenceRef: action.evidenceRef,
+                }));
+                value = await followStage(action, "verify-after-refresh", () => readPerson(action));
+            }
+            return {
+                ...value,
+                verified: !value.needsStateCheck &&
+                    !value.alerts?.length &&
+                    value.relationship === "following" &&
+                    (!action.accountHandle ||
+                        sameHandle(value.accountHandle, action.accountHandle)),
+                publicId: null,
+            };
+        }
+        // A bounded window cannot prove absence. Reply receipts use the observed target conversation.
+        const observedReceipt = ["reply", "original"].includes(action.kind) &&
+            action.observedPublicURL &&
+            action.observedPublicEvidenceRef;
+        const receiptPath = observedReceipt
+            ? xURL(action.observedPublicURL).pathname.split("/")
+            : [];
+        if (observedReceipt &&
+            (receiptPath.length !== 4 ||
+                !sameHandle(receiptPath[1], action.accountHandle) ||
+                receiptPath[2] !== "status" ||
+                !/^[0-9]+$/.test(receiptPath[3])))
+            throw new Error("已观察回复回执须属于原账号");
+        const receiptTarget = observedReceipt
+            ? {
+                url: action.observedPublicURL,
+                evidenceRef: action.observedPublicEvidenceRef,
+            }
+            : action.kind === "reply" && action.url && action.evidenceRef
+                ? { url: action.url, evidenceRef: action.evidenceRef }
+                : { url: action.accountURL, evidenceRef: action.accountEvidenceRef };
+        let value = await open(receiptTarget, { view: "posts", limit: 5 });
+        if (!(action.kind === "original" && observedReceipt) &&
+            !value.needsStateCheck &&
+            !(browser.capabilities?.("refreshPosts") ?? ["refreshPosts"]).length) {
+            await browser.act({
+                operation: "refreshPosts",
+                url: receiptTarget.url,
+                evidenceRef: receiptTarget.evidenceRef,
+            });
+            value = await observed({ view: "posts", limit: 5 });
+        }
+        const matchesContent = (post) => sameHandle(post.author, action.accountHandle) &&
+            samePublishedText(post.body, action.text) &&
+            /^\d+$/.test(post.id ?? "") &&
+            (!action.assets?.length ||
+                action.assets.every((asset) => post.images?.some((image) => image.alt === asset.alt))) &&
+            !(action.beforeIds ?? []).includes(post.id) &&
+            Number.isFinite(Date.parse(post.datetime)) &&
+            Date.parse(post.datetime) >= Date.parse(action.intentAt) &&
+            Date.parse(post.datetime) <= clock() + 5000 &&
+            !post.needsExpansion;
+        let matches = (value.posts ?? []).filter(matchesContent);
+        if (action.kind === "reply" &&
+            matches.length === 1 &&
+            matches[0].replyToId == null &&
+            matches[0].primary) {
+            // The candidate URL comes from this fresh public observation, not from a guessed ID path.
+            const candidate = matches[0];
+            const url = xURL(new URL(candidate.primary, xURL(value.page).origin).href);
+            if (url.pathname.toLowerCase() ===
+                `/${action.accountHandle}/status/${candidate.id}`.toLowerCase()) {
+                value = await open({
+                    url: url.href,
+                    evidenceRef: {
+                        page: value.page,
+                        observedAt: value.observedAt,
+                        publicId: candidate.id,
+                        primary: candidate.primary,
+                    },
+                }, {
+                    view: "posts",
+                    targetId: candidate.id,
+                    replyTargetId: action.postId,
+                });
+                matches = (value.posts ?? []).filter(matchesContent);
+            }
+        }
+        if (action.kind === "reply")
+            matches = matches.filter((post) => post.replyToId === action.postId);
+        return {
+            ...value,
+            verified: !value.needsStateCheck && !value.alerts?.length && matches.length === 1,
+            publicId: matches.length === 1 ? matches[0].id : null,
+            missing: matches.length === 1 ? [] : ["unique-public-submission-unconfirmed"],
+        };
+    }
+    async function submitFollow(action) {
+        const value = await followStage(action, "submit-preflight-read", () => readPerson(action));
+        if (value.needsStateCheck ||
+            value.alerts?.length ||
+            !["not-following", "follows-you"].includes(value.relationship) ||
+            (action.accountHandle &&
+                !sameHandle(value.accountHandle, action.accountHandle)))
+            throw new Error("fresh账号/人物关系不允许关注");
+        await followStage(action, "submit-guard", () => action.beforeSubmit?.());
+        // A returned click is not a receipt from X; durable success still requires fresh verification.
+        const clicked = await followStage(action, "click", () => browser.act({ operation: "follow", handle: action.handle }));
+        try {
+            await followStage(action, "click-ui-observation", () => observed({ view: "person", handle: action.handle }));
+        }
+        catch {
+            /* The click may have committed; retain diagnostic failure and use the original fresh receipt path. */
+        }
+        return clicked;
+    }
+    async function submitPost(action) {
+        await open({ url: action.composeURL, evidenceRef: action.composeEvidenceRef }, { view: "composer" });
+        return compose(action);
+    }
+    async function submitReply(action) {
+        const value = await readPost(action);
+        if (value.needsStateCheck ||
+            value.alerts?.length ||
+            !(value.posts ?? []).some((p) => p.id === action.postId))
+            throw new Error("回复主帖身份未核实");
+        await browser.act({ operation: "openReply", postId: action.postId });
+        return compose(action);
+    }
+    return { compose, findSubmission, submitFollow, submitPost, submitReply };
+}

package/dist/platform.d.ts

@@ -0,0 +1,2 @@
+export { xURL } from "./platform-rules.js";
+export declare function createXPlatform(browser: any, { clock }?: any): any;

package/dist/platform.js

@@ -0,0 +1,60 @@
+import { createPlatformObservation } from "./platform-observation.js";
+import { createPlatformTargets } from "./platform-targets.js";
+import { createPlatformCollections } from "./platform-collections.js";
+import { createPlatformDiagnostics } from "./platform-diagnostics.js";
+import { createPlatformWriting } from "./platform-writing.js";
+import { createPlatformCapabilities } from "./platform-capabilities.js";
+export { xURL } from "./platform-rules.js";
+export function createXPlatform(browser, { clock = () => Date.now() } = {}) {
+    const createPlatformObservationResult = createPlatformObservation({
+        browser,
+        clock,
+    });
+    const { missing, observed, open, ready, choose } = createPlatformObservationResult;
+    const createPlatformTargetsResult = createPlatformTargets({
+        observed,
+        open,
+        browser,
+        ready,
+    });
+    const { readAccount, readFeedback, readPerson, readPost } = createPlatformTargetsResult;
+    const createPlatformCollectionsResult = createPlatformCollections({
+        ready,
+        observed,
+        browser,
+        choose,
+    });
+    const { collectSources, readCreator, readBookmarks, searchSources } = createPlatformCollectionsResult;
+    const createPlatformDiagnosticsResult = createPlatformDiagnostics({ clock });
+    const { followStage, captureProof } = createPlatformDiagnosticsResult;
+    const createPlatformWritingResult = createPlatformWriting({
+        observed,
+        browser,
+        followStage,
+        readPerson,
+        open,
+        clock,
+        readPost,
+    });
+    const { compose, findSubmission, submitFollow, submitPost, submitReply } = createPlatformWritingResult;
+    const createPlatformCapabilitiesResult = createPlatformCapabilities({
+        missing,
+        browser,
+    });
+    const { preflight } = createPlatformCapabilitiesResult;
+    return {
+        preflight,
+        readCreator,
+        readAccount,
+        readBookmarks,
+        searchSources,
+        readFeedback,
+        readPerson,
+        readPost,
+        findSubmission,
+        submitFollow,
+        submitPost,
+        submitReply,
+        captureProof,
+    };
+}

package/dist/readers-actions.d.ts

@@ -0,0 +1,2 @@
+export declare function attachImage(tab: any, { path }?: any): Promise<any>;
+export declare function openReply(tab: any, { postId }?: any): Promise<any>;

package/dist/readers-actions.js

@@ -0,0 +1,66 @@
+import { readComposer } from "./readers-composer.js";
+import { readPosts } from "./readers-posts.js";
+// Upload only through the observed image button and browser file chooser.
+export async function attachImage(tab, { path } = {}) {
+    if (!/^\/.*\.(?:png|jpe?g|webp)$/i.test(path ?? ""))
+        throw new Error("需要绝对图片路径");
+    if (typeof tab?.playwright?.evaluate !== "function" ||
+        typeof tab?.playwright?.getByRole !== "function" ||
+        typeof tab?.playwright?.waitForEvent !== "function")
+        throw new Error("harness能力不足：DOM图片选择器");
+    const before = await tab.playwright.evaluate(readComposer);
+    if (before.needsStateCheck || before.alerts?.length)
+        throw new Error("图片上传前编辑器未确认");
+    const buttons = before.buttons.filter((b) => /^(添加照片或视频|Add photos or video)$/i.test(b.label) && !b.disabled);
+    if (buttons.length !== 1)
+        throw new Error("图片按钮未唯一观察");
+    const button = tab.playwright.getByRole("button", {
+        name: buttons[0].label,
+        exact: true,
+    });
+    if ((await button.count()) !== 1 || typeof button.click !== "function")
+        throw new Error("图片按钮未唯一定位");
+    const chooserPromise = tab.playwright.waitForEvent("filechooser", {
+        timeoutMs: 10000,
+    });
+    await button.click();
+    const chooser = await chooserPromise;
+    if (typeof chooser?.setFiles !== "function")
+        throw new Error("harness能力不足：setFiles");
+    await chooser.setFiles([path]);
+    return tab.playwright.evaluate(readComposer);
+}
+export async function openReply(tab, { postId } = {}) {
+    if (!/^\d+$/.test(postId ?? ""))
+        throw new Error("需要已观察公开ID");
+    if (typeof tab?.playwright?.evaluate !== "function" ||
+        typeof tab?.playwright?.locator !== "function")
+        throw new Error("harness能力不足：精准回复范围");
+    const state = await tab.playwright.evaluate(readPosts, {
+        targetId: postId,
+        limit: 1,
+    });
+    const post = state.posts[0];
+    if (state.needsStateCheck ||
+        state.alerts.length ||
+        state.posts.length !== 1 ||
+        post.missing.length ||
+        post.needsExpansion)
+        throw new Error("回复根帖证据未完整");
+    const buttons = post.buttons.filter((b) => /回复|Reply/i.test(b.label) && !b.disabled);
+    if (buttons.length !== 1)
+        throw new Error("回复按钮未唯一观察");
+    const article = tab.playwright
+        .locator("article")
+        .filter({ has: tab.playwright.locator(`a[href="${post.primary}"]`) });
+    if ((await article.count()) !== 1)
+        throw new Error("回复文章范围不唯一");
+    const button = article.getByRole("button", {
+        name: buttons[0].label,
+        exact: true,
+    });
+    if ((await button.count()) !== 1)
+        throw new Error("回复控件不唯一");
+    await button.click();
+    return tab.playwright.evaluate(readComposer);
+}

package/dist/readers-ax-host.d.ts

@@ -0,0 +1,2 @@
+export declare function createAXTabHarness(tab: any): any;
+export declare function createAXHarness(app: any): any;

package/dist/readers-ax-host.js

@@ -0,0 +1,125 @@
+import { readAX } from "./readers-ax-parser.js";
+// Native operations share one observation boundary. No raw AX leaves this session.
+// Browser Tab input takes (index, value), while native App input takes (value).
+export function createAXTabHarness(tab) {
+    return createAXHarness({
+        getAXState: (options) => tab.getAXState(options),
+        click: (index) => tab.click(index),
+        pressKey: (key) => tab.pressKey(null, key),
+        paste: (value) => tab.paste(null, value),
+        scroll: (...args) => tab.scroll(...args),
+        getScreenshot: (options) => tab.getScreenshot(options),
+    });
+}
+export function createAXHarness(app) {
+    let controls = new Map(), readable = false, busy = false;
+    const requireMethods = (methods) => {
+        const missing = methods.filter((name) => typeof app?.[name] !== "function");
+        if (missing.length) {
+            controls.clear();
+            readable = false;
+            throw new Error(`harness能力不足：${missing.join("/")}；先补原入口并验证，未执行操作`);
+        }
+    };
+    const indexes = (value) => {
+        if (!value || typeof value !== "object")
+            return;
+        if (Number.isInteger(value.index) && typeof value.label === "string")
+            controls.set(value.index, value.label);
+        for (const child of Object.values(value))
+            indexes(child);
+    };
+    const observe = async (options = {}) => {
+        controls.clear();
+        readable = false;
+        readAX("", options);
+        requireMethods(["getAXState"]);
+        const result = readAX(await app.getAXState({ emit: false, disableDiffing: true }), options);
+        indexes(result);
+        readable = true;
+        return result;
+    };
+    return {
+        async observe(options = {}) {
+            if (busy)
+                throw new Error("AX操作进行中，禁止并发读取");
+            busy = true;
+            try {
+                return await observe(options);
+            }
+            finally {
+                busy = false;
+            }
+        },
+        async act({ index, operation = "click", value, read = {}, } = {}) {
+            if (busy)
+                throw new Error("AX操作进行中，禁止并发写入");
+            if (!readable || !controls.has(index))
+                throw new Error("必须先observe；index须来自最新定向证据");
+            if (!["click", "fill", "paste", "pressKey", "scroll", "secondary"].includes(operation))
+                throw new Error("未封装的AX操作，先补能力并验证");
+            // Validate before any side effect; a malformed follow-up read must never submit.
+            readAX("", read);
+            if (["fill", "paste", "pressKey", "secondary"].includes(operation) &&
+                typeof value !== "string")
+                throw new Error("AX操作value须为字符串");
+            if (["fill", "paste", "pressKey"].includes(operation) &&
+                !/^(?:文本输入区(?:域)?|文本区域|文本栏|组合框) /.test(controls.get(index)))
+                throw new Error("键盘操作须定位最新证据中的编辑控件");
+            if (operation === "secondary" &&
+                !controls.get(index).includes(`Secondary Actions: ${value}`))
+                throw new Error("未观察到该辅助动作");
+            if (operation === "scroll" &&
+                !["up", "down", "left", "right"].includes(value))
+                throw new Error("无效滚动方向");
+            const methods = operation === "fill"
+                ? ["click", "pressKey", "paste"]
+                : ["paste", "pressKey"].includes(operation)
+                    ? ["click", operation]
+                    : [
+                        operation === "secondary"
+                            ? "performSecondaryAction"
+                            : operation,
+                    ];
+            requireMethods([...methods, "getAXState"]);
+            busy = true;
+            controls.clear();
+            readable = false;
+            try {
+                if (operation === "click")
+                    await app.click(index);
+                else if (["fill", "paste", "pressKey"].includes(operation)) {
+                    await app.click(index);
+                    if (operation === "fill") {
+                        await app.pressKey("super+a");
+                        await app.paste(value);
+                    }
+                    else
+                        await app[operation](value);
+                }
+                else if (operation === "scroll")
+                    await app.scroll(index, value, 1);
+                else
+                    await app.performSecondaryAction(index, value);
+                return await observe(read);
+            }
+            finally {
+                busy = false;
+            }
+        },
+        async screenshot() {
+            if (busy)
+                throw new Error("AX操作进行中，禁止并发截图");
+            requireMethods(["getScreenshot"]);
+            busy = true;
+            controls.clear();
+            readable = false;
+            try {
+                return await app.getScreenshot({ emit: false });
+            }
+            finally {
+                busy = false;
+            }
+        },
+    };
+}

package/dist/readers-ax-parser.d.ts

@@ -0,0 +1 @@
+export declare function readAX(state: any, { mode, offset, limit, targetId, targetHandle, }?: any): any;

package/dist/readers-ax-parser.js

@@ -0,0 +1,69 @@
+// Native Chrome fallback: process a suppressed full AX observation in the REPL.
+// Keeps visible leaf evidence and action indexes; never reconstructs a diff as a full page.
+import { parseAXNodes, createAXTree } from "./readers-ax-tree.js";
+import { projectAXFilepicker, projectAXMedia, projectAXNavigation, projectAXPeople, projectAXPosts, projectAXProfile, projectAXComposer, } from "./readers-ax-views.js";
+export function readAX(state, { mode = "posts", offset = 0, limit = 1, targetId = "", targetHandle = "", } = {}) {
+    if (![
+        "posts",
+        "composer",
+        "profile",
+        "people",
+        "navigation",
+        "filepicker",
+        "media",
+    ].includes(mode))
+        throw new Error("AX mode必须为posts/composer/profile/people/navigation");
+    if (typeof state !== "string")
+        throw new Error("AX state必须为完整字符串");
+    if (!Number.isInteger(offset) ||
+        offset < 0 ||
+        !Number.isInteger(limit) ||
+        limit < 1 ||
+        limit > 5 ||
+        (targetId && !/^\d+$/.test(targetId)))
+        throw new Error("无效AX读取窗口或ID");
+    if (targetHandle && (mode !== "people" || !/^\w{1,15}$/.test(targetHandle)))
+        throw new Error("targetHandle必须为people模式已观察的handle");
+    const alertLines = state
+        .split("\n")
+        .filter((line) => /抱歉.*限制|速度限制|请求异常|访问受限|验证码|验证挑战|登录以继续|captcha|rate limit/i.test(line));
+    const unknown = (reason) => ({
+        mode,
+        posts: [],
+        evidence: [],
+        alerts: alertLines,
+        missing: [reason],
+        needsStateCheck: true,
+        pageComplete: false,
+    });
+    if (/following is a diff|Removed element IDs:|no change in the accessibility tree/i.test(state))
+        return unknown("full-ax-required");
+    const page = state.match(/URL:\s*((?:https?:\/\/)?x\.com\/[^\s,]*)/)?.[1];
+    if (!page && !["navigation", "filepicker"].includes(mode))
+        return unknown("x-page-unconfirmed");
+    const nodes = parseAXNodes(state);
+    const tree = createAXTree(nodes);
+    const context = {
+        mode,
+        page,
+        offset,
+        limit,
+        targetId,
+        targetHandle,
+        unknown,
+        alertLines,
+    };
+    if (mode === "filepicker")
+        return projectAXFilepicker(tree, context);
+    if (mode === "media")
+        return projectAXMedia(tree, context);
+    if (mode === "navigation")
+        return projectAXNavigation(tree, context);
+    if (mode === "people")
+        return projectAXPeople(tree, context);
+    if (mode === "posts")
+        return projectAXPosts(tree, context);
+    if (mode === "profile")
+        return projectAXProfile(tree, context);
+    return projectAXComposer(tree, context);
+}

package/dist/readers-ax-program.d.ts

@@ -0,0 +1 @@
+export declare const axParserCode: string;

package/dist/readers-ax-tree.d.ts

@@ -0,0 +1,19 @@
+export declare function parseAXNodes(state: string): any[];
+export declare function createAXTree(nodes: any[]): {
+    nodes: any[];
+    descendants: (i: any) => any[];
+    evidence: (ns: any) => any;
+    navigation: {
+        index: any;
+        label: any;
+    }[];
+    roots: any[];
+    peopleRoots: any[];
+    peopleTimeline: number;
+    within: (node: any, root: any) => boolean;
+    alerts: {
+        index: any;
+        label: any;
+    }[];
+};
+export type AXTree = ReturnType<typeof createAXTree>;

package/dist/readers-ax-tree.js

@@ -0,0 +1,110 @@
+export function parseAXNodes(state) {
+    const nodes = [], stack = [];
+    for (const line of state.split("\n")) {
+        const match = line.match(/^(\s*)(\d+) (.*)$/);
+        // Multiline post text such as "37 位中文主样本" is not an AX node.
+        if (!match ||
+            (!match[1] &&
+                !/^(?:标准窗口|表单|对话框|sheet|dialog|window|menu bar)(?: |$)/i.test(match[3]))) {
+            if (nodes.length &&
+                line.trim() &&
+                !/^The focused UI|Window:|Wall time:|Output:/.test(line))
+                nodes.at(-1).label += "\n" + line;
+            continue;
+        }
+        const depth = match[1].replace(/\t/g, "    ").length;
+        while (stack.length && nodes[stack.at(-1)].depth >= depth)
+            stack.pop();
+        // Chrome tab AX uses English role names; native app AX uses the canonical labels below.
+        const label = match[3]
+            .replace(/^link Description: /, "link ")
+            .replace(/^combo box(?: \([^)]*\))? (?:Description: )?/, "组合框 ")
+            .replace(/^button(?: \((?![^)]*disabled)[^)]*\))? /, "按钮 ")
+            .replace(/^text entry area(?: \(settable\))? Description: /, "文本输入区域 ");
+        const node = {
+            index: Number(match[2]),
+            label,
+            depth,
+            parent: stack.at(-1) ?? null,
+        };
+        nodes.push(node);
+        stack.push(nodes.length - 1);
+    }
+    return nodes;
+}
+export function createAXTree(nodes) {
+    const descendants = (i) => {
+        let end = i + 1;
+        while (end < nodes.length && nodes[end].depth > nodes[i].depth)
+            end++;
+        return nodes.slice(i + 1, end);
+    };
+    const leaf = (n) => /^(?:文本(?: |$)|text |link |按钮 |弹出式按钮 |切换按钮 |标签 |tab |图像 |文本输入区(?:域)? |文本区域 |文本栏 |组合框 |单选按钮 |复选框 )/.test(n.label) || /^container [\d,.万亿KMB]+ 次(?:观看|查看)$/.test(n.label);
+    const evidence = (ns) => ns.filter(leaf).map(({ index, label }) => ({ index, label }));
+    const navigation = nodes
+        .filter((n) => /^(?:标准窗口|window|HTML 内容) .*URL:/.test(n.label) ||
+        /^文本栏 .*地址和搜索栏/.test(n.label) ||
+        /^按钮 (?:重新加载|新标签页)$/.test(n.label) ||
+        n.label === "窗口" ||
+        /^标签 \((?:selected|settable)/.test(n.label) ||
+        /^(?:tab|标签)(?: \([^)]*\))? (?:帖子|回复|转帖|媒体|文章|Posts|Replies|Reposts|Media|Articles)(?:,|$)/.test(n.label) ||
+        /^组合框 (?:查询词条|Search)(?:,|$)/.test(n.label) ||
+        /^link (?:主页|搜索和发现|通知|个人资料), Value: x\.com\//.test(n.label))
+        .map(({ index, label }) => ({ index, label }));
+    const roots = [];
+    const within = (node, root) => {
+        let p = node.parent;
+        while (p !== null) {
+            if (p === root)
+                return true;
+            p = nodes[p].parent;
+        }
+        return false;
+    };
+    nodes.forEach((n, i) => {
+        // Chrome's window container also contains @handle and every post link.
+        if (!/^(?:container |article ).*@\w+/.test(n.label) ||
+            /\bURL:/.test(n.label))
+            return;
+        if (roots.some((root) => within(n, root)))
+            return;
+        if (descendants(i).some((d) => /^link /.test(d.label) && /x\.com\/\w+\/status\/\d+/.test(d.label)))
+            roots.push(i);
+    });
+    const peopleTimeline = nodes.findIndex((n) => /^container 时间线：(认证关注者|关注者|正在关注)$/.test(n.label));
+    const peopleRoots = peopleTimeline < 0
+        ? []
+        : nodes
+            .map((n, i) => ({ n, i }))
+            .filter(({ n, i }) => within(n, peopleTimeline) &&
+            /^按钮 .*@\w+(?: |$)/.test(n.label) &&
+            descendants(i).some((d) => /^link @\w+, Value: x\.com\/\w+(?:,|$)/.test(d.label)))
+            .map(({ i }) => i);
+    const warning = /抱歉.*限制|速度限制|请求异常|访问受限|验证码|验证挑战|登录以继续|captcha|rate limit/i;
+    const explicitAlert = (n) => {
+        let current = n;
+        while (current) {
+            if (/^(?:alert|警告|对话框|dialog|status|状态)(?: |$)/i.test(current.label))
+                return true;
+            current = current.parent === null ? null : nodes[current.parent];
+        }
+        return /^(?:文本输入区(?:域)?|文本区域|文本栏|按钮) /i.test(n.label);
+    };
+    const alerts = nodes
+        .filter((n, i) => warning.test(n.label) &&
+        (![...roots, ...peopleRoots].some((root) => i === root || within(n, root)) ||
+            explicitAlert(n)) &&
+        !descendants(i).some((d) => warning.test(d.label)))
+        .map((n) => ({ index: n.index, label: n.label }));
+    return {
+        nodes,
+        descendants,
+        evidence,
+        navigation,
+        roots,
+        peopleRoots,
+        peopleTimeline,
+        within,
+        alerts,
+    };
+}