@nextclaw/x-harness 0.1.1 → 0.2.1

package/dist/platform-writing.js

@@ -1,8 +1,34 @@
 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" });
+export class PlatformWriting {
+    #observed;
+    #browser;
+    #followStage;
+    #readPerson;
+    #open;
+    #clock;
+    #readPost;
+    compose;
+    findSubmission;
+    submitFollow;
+    submitPost;
+    submitReply;
+    constructor(dependencies) {
+        const { observed, browser, followStage, readPerson, open, clock, readPost, } = dependencies;
+        this.#observed = observed;
+        this.#browser = browser;
+        this.#followStage = followStage;
+        this.#readPerson = readPerson;
+        this.#open = open;
+        this.#clock = clock;
+        this.#readPost = readPost;
+        this.compose = this.handleCompose.bind(this);
+        this.findSubmission = this.handleFindSubmission.bind(this);
+        this.submitFollow = this.handleSubmitFollow.bind(this);
+        this.submitPost = this.handleSubmitPost.bind(this);
+        this.submitReply = this.handleSubmitReply.bind(this);
+    }
+    async handleCompose(action) {
+        let value = await this.#observed({ view: "composer" });
         if (value.needsStateCheck ||
             value.alerts?.length ||
             typeof value.editorText !== "string" ||
@@ -10,9 +36,12 @@ export function createPlatformWriting(dependencies) {
             (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" });
+            await this.#browser.act({
+                operation: "attachAssets",
+                assets: action.assets,
+            });
+        await this.#browser.act({ operation: "fillComposer", text: action.text });
+        value = await this.#observed({ view: "composer" });
         if (!sameText(value.editorText, action.text) ||
             value.needsStateCheck ||
             value.alerts?.length ||
@@ -20,17 +49,17 @@ export function createPlatformWriting(dependencies) {
             (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({
+        return this.#browser.act({
             operation: action.kind === "reply" ? "submitReply" : "submitPost",
             beforeSubmit: action.beforeSubmit,
             ...(action.activation ? { activation: action.activation } : {}),
         });
     }
-    async function findSubmission(action) {
+    async handleFindSubmission(action) {
         if (action.kind === "follow") {
-            let value = await followStage(action, "verify-read", () => readPerson(action));
+            let value = await this.#followStage(action, "verify-read", () => this.#readPerson(action));
             if (!value.needsStateCheck) {
-                const absent = browser.capabilities?.("refreshPerson") ?? [
+                const absent = this.#browser.capabilities?.("refreshPerson") ?? [
                     "refreshPerson",
                 ];
                 if (absent.length)
@@ -40,13 +69,13 @@ export function createPlatformWriting(dependencies) {
                         missing: absent,
                         needsStateCheck: true,
                     };
-                await followStage(action, "verify-refresh", () => browser.act({
+                await this.#followStage(action, "verify-refresh", () => this.#browser.act({
                     operation: "refreshPerson",
                     handle: action.handle,
                     url: action.url,
                     evidenceRef: action.evidenceRef,
                 }));
-                value = await followStage(action, "verify-after-refresh", () => readPerson(action));
+                value = await this.#followStage(action, "verify-after-refresh", () => this.#readPerson(action));
             }
             return {
                 ...value,
@@ -79,16 +108,16 @@ export function createPlatformWriting(dependencies) {
             : 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 });
+        let value = await this.#open(receiptTarget, { view: "posts", limit: 5 });
         if (!(action.kind === "original" && observedReceipt) &&
             !value.needsStateCheck &&
-            !(browser.capabilities?.("refreshPosts") ?? ["refreshPosts"]).length) {
-            await browser.act({
+            !(this.#browser.capabilities?.("refreshPosts") ?? ["refreshPosts"]).length) {
+            await this.#browser.act({
                 operation: "refreshPosts",
                 url: receiptTarget.url,
                 evidenceRef: receiptTarget.evidenceRef,
             });
-            value = await observed({ view: "posts", limit: 5 });
+            value = await this.#observed({ view: "posts", limit: 5 });
         }
         const matchesContent = (post) => sameHandle(post.author, action.accountHandle) &&
             samePublishedText(post.body, action.text) &&
@@ -98,7 +127,7 @@ export function createPlatformWriting(dependencies) {
             !(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 &&
+            Date.parse(post.datetime) <= this.#clock() + 5000 &&
             !post.needsExpansion;
         let matches = (value.posts ?? []).filter(matchesContent);
         if (action.kind === "reply" &&
@@ -110,7 +139,7 @@ export function createPlatformWriting(dependencies) {
             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({
+                value = await this.#open({
                     url: url.href,
                     evidenceRef: {
                         page: value.page,
@@ -135,37 +164,39 @@ export function createPlatformWriting(dependencies) {
             missing: matches.length === 1 ? [] : ["unique-public-submission-unconfirmed"],
         };
     }
-    async function submitFollow(action) {
-        const value = await followStage(action, "submit-preflight-read", () => readPerson(action));
+    async handleSubmitFollow(action) {
+        const value = await this.#followStage(action, "submit-preflight-read", () => this.#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?.());
+        await this.#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 }));
+        const clicked = await this.#followStage(action, "click", () => this.#browser.act({ operation: "follow", handle: action.handle }));
         try {
-            await followStage(action, "click-ui-observation", () => observed({ view: "person", handle: action.handle }));
+            await this.#followStage(action, "click-ui-observation", () => this.#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 handleSubmitPost(action) {
+        await this.#open({ url: action.composeURL, evidenceRef: action.composeEvidenceRef }, { view: "composer" });
+        return this.handleCompose(action);
     }
-    async function submitReply(action) {
-        const value = await readPost(action);
+    async handleSubmitReply(action) {
+        const value = await this.#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);
+        await this.#browser.act({ operation: "openReply", postId: action.postId });
+        return this.handleCompose(action);
     }
-    return { compose, findSubmission, submitFollow, submitPost, submitReply };
+}
+export function createPlatformWriting(...args) {
+    return new PlatformWriting(...args);
 }

package/dist/platform.d.ts

@@ -1,2 +1,23 @@
 export { xURL } from "./platform-rules.js";
-export declare function createXPlatform(browser: any, { clock }?: any): any;
+export declare class XPlatform {
+    #private;
+    preflight: ({ operation, input }: any) => any;
+    readCreator: (args: import("./types.js").CreatorOptions) => Promise<any>;
+    readAccount: () => Promise<any>;
+    readBookmarks: ({ folder, ...window }?: any) => Promise<any>;
+    searchSources: ({ query, limit, maxPages, processedIds, }?: any) => Promise<any>;
+    readFeedback: ({ targets, replyLimit }?: any) => Promise<any>;
+    readPerson: (target: any) => Promise<any>;
+    readPost: (target: any) => Promise<any>;
+    findSubmission: (action: any) => Promise<any>;
+    submitFollow: (action: any) => Promise<any>;
+    submitPost: (action: any) => Promise<any>;
+    submitReply: (action: any) => Promise<any>;
+    captureProof: ({ observation }: any) => {
+        followDiagnostics?: any[] | undefined;
+        capturedAt: string;
+        observation: any;
+    };
+    constructor(browser: any, { clock }?: any);
+}
+export declare function createXPlatform(...args: ConstructorParameters<typeof XPlatform>): any;

package/dist/platform.js

@@ -5,56 +5,124 @@ 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,
-    };
+export class XPlatform {
+    #clock;
+    #createPlatformObservationResult;
+    #missing;
+    #observed;
+    #open;
+    #ready;
+    #choose;
+    #createPlatformTargetsResult;
+    #readAccount;
+    #readFeedback;
+    #readPerson;
+    #readPost;
+    #createPlatformCollectionsResult;
+    #collectSources;
+    #readCreator;
+    #readBookmarks;
+    #searchSources;
+    #createPlatformDiagnosticsResult;
+    #followStage;
+    #captureProof;
+    #createPlatformWritingResult;
+    #compose;
+    #findSubmission;
+    #submitFollow;
+    #submitPost;
+    #submitReply;
+    #createPlatformCapabilitiesResult;
+    #preflight;
+    preflight;
+    readCreator;
+    readAccount;
+    readBookmarks;
+    searchSources;
+    readFeedback;
+    readPerson;
+    readPost;
+    findSubmission;
+    submitFollow;
+    submitPost;
+    submitReply;
+    captureProof;
+    constructor(browser, { clock = () => Date.now() } = {}) {
+        this.#clock = clock;
+        this.#createPlatformObservationResult = createPlatformObservation({
+            browser: browser,
+            clock: this.#clock,
+        });
+        const { missing, observed, open, ready, choose } = this.#createPlatformObservationResult;
+        this.#missing = missing;
+        this.#observed = observed;
+        this.#open = open;
+        this.#ready = ready;
+        this.#choose = choose;
+        this.#createPlatformTargetsResult = createPlatformTargets({
+            observed: this.#observed,
+            open: this.#open,
+            browser: browser,
+            ready: this.#ready,
+        });
+        const { readAccount, readFeedback, readPerson, readPost } = this.#createPlatformTargetsResult;
+        this.#readAccount = readAccount;
+        this.#readFeedback = readFeedback;
+        this.#readPerson = readPerson;
+        this.#readPost = readPost;
+        this.#createPlatformCollectionsResult = createPlatformCollections({
+            ready: this.#ready,
+            observed: this.#observed,
+            browser: browser,
+            choose: this.#choose,
+        });
+        const { collectSources, readCreator, readBookmarks, searchSources } = this.#createPlatformCollectionsResult;
+        this.#collectSources = collectSources;
+        this.#readCreator = readCreator;
+        this.#readBookmarks = readBookmarks;
+        this.#searchSources = searchSources;
+        this.#createPlatformDiagnosticsResult = createPlatformDiagnostics({
+            clock: this.#clock,
+        });
+        const { followStage, captureProof } = this.#createPlatformDiagnosticsResult;
+        this.#followStage = followStage;
+        this.#captureProof = captureProof;
+        this.#createPlatformWritingResult = createPlatformWriting({
+            observed: this.#observed,
+            browser: browser,
+            followStage: this.#followStage,
+            readPerson: this.#readPerson,
+            open: this.#open,
+            clock: this.#clock,
+            readPost: this.#readPost,
+        });
+        const { compose, findSubmission, submitFollow, submitPost, submitReply } = this.#createPlatformWritingResult;
+        this.#compose = compose;
+        this.#findSubmission = findSubmission;
+        this.#submitFollow = submitFollow;
+        this.#submitPost = submitPost;
+        this.#submitReply = submitReply;
+        this.#createPlatformCapabilitiesResult = createPlatformCapabilities({
+            missing: this.#missing,
+            browser: browser,
+        });
+        const { preflight } = this.#createPlatformCapabilitiesResult;
+        this.#preflight = preflight;
+        this.preflight = this.#preflight;
+        this.readCreator = this.#readCreator;
+        this.readAccount = this.#readAccount;
+        this.readBookmarks = this.#readBookmarks;
+        this.searchSources = this.#searchSources;
+        this.readFeedback = this.#readFeedback;
+        this.readPerson = this.#readPerson;
+        this.readPost = this.#readPost;
+        this.findSubmission = this.#findSubmission;
+        this.submitFollow = this.#submitFollow;
+        this.submitPost = this.#submitPost;
+        this.submitReply = this.#submitReply;
+        this.captureProof = this.#captureProof;
+    }
+}
+export function createXPlatform(...args) {
+    return new XPlatform(...args);
 }

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

@@ -1,2 +1,12 @@
 export declare function createAXTabHarness(tab: any): any;
-export declare function createAXHarness(app: any): any;
+export declare class AXHarness {
+    #private;
+    constructor(app: any);
+    private requireMethods;
+    private indexes;
+    private handleObserve;
+    observe(options?: any): Promise<any>;
+    act({ index, operation, value, read, }?: any): Promise<any>;
+    screenshot(): Promise<any>;
+}
+export declare function createAXHarness(...args: ConstructorParameters<typeof AXHarness>): any;

package/dist/readers-ax-host.js

@@ -11,115 +11,124 @@ export function createAXTabHarness(tab) {
         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");
+export class AXHarness {
+    #app;
+    #controls;
+    #readable;
+    #busy;
+    constructor(app) {
+        this.screenshot = this.screenshot.bind(this);
+        this.act = this.act.bind(this);
+        this.observe = this.observe.bind(this);
+        this.#app = app;
+        this.#controls = new Map();
+        this.#readable = false;
+        this.#busy = false;
+    }
+    requireMethods(methods) {
+        const missing = methods.filter((name) => typeof this.#app?.[name] !== "function");
         if (missing.length) {
-            controls.clear();
-            readable = false;
+            this.#controls.clear();
+            this.#readable = false;
             throw new Error(`harness能力不足：${missing.join("/")}；先补原入口并验证，未执行操作`);
         }
-    };
-    const indexes = (value) => {
+    }
+    indexes(value) {
         if (!value || typeof value !== "object")
             return;
         if (Number.isInteger(value.index) && typeof value.label === "string")
-            controls.set(value.index, value.label);
+            this.#controls.set(value.index, value.label);
         for (const child of Object.values(value))
-            indexes(child);
-    };
-    const observe = async (options = {}) => {
-        controls.clear();
-        readable = false;
+            this.indexes(child);
+    }
+    async handleObserve(options = {}) {
+        this.#controls.clear();
+        this.#readable = false;
         readAX("", options);
-        requireMethods(["getAXState"]);
-        const result = readAX(await app.getAXState({ emit: false, disableDiffing: true }), options);
-        indexes(result);
-        readable = true;
+        this.requireMethods(["getAXState"]);
+        const result = readAX(await this.#app.getAXState({ emit: false, disableDiffing: true }), options);
+        this.indexes(result);
+        this.#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);
+    }
+    async observe(options = {}) {
+        if (this.#busy)
+            throw new Error("AX操作进行中，禁止并发读取");
+        this.#busy = true;
+        try {
+            return await this.handleObserve(options);
+        }
+        finally {
+            this.#busy = false;
+        }
+    }
+    async act({ index, operation = "click", value, read = {}, } = {}) {
+        if (this.#busy)
+            throw new Error("AX操作进行中，禁止并发写入");
+        if (!this.#readable || !this.#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(this.#controls.get(index)))
+            throw new Error("键盘操作须定位最新证据中的编辑控件");
+        if (operation === "secondary" &&
+            !this.#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];
+        this.requireMethods([...methods, "getAXState"]);
+        this.#busy = true;
+        this.#controls.clear();
+        this.#readable = false;
+        try {
+            if (operation === "click")
+                await this.#app.click(index);
+            else if (["fill", "paste", "pressKey"].includes(operation)) {
+                await this.#app.click(index);
+                if (operation === "fill") {
+                    await this.#app.pressKey("super+a");
+                    await this.#app.paste(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 });
+                    await this.#app[operation](value);
             }
-            finally {
-                busy = false;
-            }
-        },
-    };
+            else if (operation === "scroll")
+                await this.#app.scroll(index, value, 1);
+            else
+                await this.#app.performSecondaryAction(index, value);
+            return await this.handleObserve(read);
+        }
+        finally {
+            this.#busy = false;
+        }
+    }
+    async screenshot() {
+        if (this.#busy)
+            throw new Error("AX操作进行中，禁止并发截图");
+        this.requireMethods(["getScreenshot"]);
+        this.#busy = true;
+        this.#controls.clear();
+        this.#readable = false;
+        try {
+            return await this.#app.getScreenshot({ emit: false });
+        }
+        finally {
+            this.#busy = false;
+        }
+    }
+}
+export function createAXHarness(...args) {
+    return new AXHarness(...args);
 }

package/dist/readers-ax-program.js

@@ -0,0 +1,5 @@
+import { readAX } from "./readers-ax-parser.js";
+import { parseAXNodes, createAXTree } from "./readers-ax-tree.js";
+import { projectAXFilepicker, projectAXMedia, projectAXNavigation, projectAXPeople, projectAXPosts, projectAXProfile, projectAXComposer, } from "./readers-ax-views.js";
+// Explicit serialization closure; the same parser runs in Node and the REPL.
+export const axParserCode = `(function(){const parseAXNodes=${parseAXNodes.toString()};const createAXTree=${createAXTree.toString()};const projectAXFilepicker=${projectAXFilepicker.toString()};const projectAXMedia=${projectAXMedia.toString()};const projectAXNavigation=${projectAXNavigation.toString()};const projectAXPeople=${projectAXPeople.toString()};const projectAXPosts=${projectAXPosts.toString()};const projectAXProfile=${projectAXProfile.toString()};const projectAXComposer=${projectAXComposer.toString()};return ${readAX.toString()};})()`;

package/dist/readers-ax-tree.js

@@ -46,6 +46,7 @@ export function createAXTree(nodes) {
         /^文本栏 .*地址和搜索栏/.test(n.label) ||
         /^按钮 (?:重新加载|新标签页)$/.test(n.label) ||
         n.label === "窗口" ||
+        /, ID: makeKeyAndOrderFront:$/.test(n.label) ||
         /^标签 \((?:selected|settable)/.test(n.label) ||
         /^(?:tab|标签)(?: \([^)]*\))? (?:帖子|回复|转帖|媒体|文章|Posts|Replies|Reposts|Media|Articles)(?:,|$)/.test(n.label) ||
         /^组合框 (?:查询词条|Search)(?:,|$)/.test(n.label) ||