@nextclaw/x-harness 0.0.0-stage → 0.1.1

package/dist/browser-dom-capabilities.js

@@ -0,0 +1,110 @@
+import { missingMethods } from "./browser-common.js";
+export function createDOMCapabilities(dependencies) {
+    const { tab, nativeSubmit } = dependencies;
+    return {
+        capabilities(operation) {
+            const base = missingMethods(tab?.playwright, ["evaluate"]);
+            if (operation === "readCreator") {
+                base.push(...missingMethods(tab, [
+                    "url",
+                    "goto",
+                    "reload",
+                    "getAXState",
+                    "scroll",
+                ]));
+                base.push(...missingMethods(tab.playwright, ["locator"]));
+                if (typeof tab.playwright?.locator === "function") {
+                    const article = tab.playwright.locator("article");
+                    base.push(...missingMethods(article, ["first", "getByRole"]));
+                    if (typeof article.first === "function")
+                        base.push(...missingMethods(article.first(), ["waitFor"]));
+                    if (typeof article.getByRole === "function")
+                        base.push(...missingMethods(article.getByRole("button", { name: "显示更多", exact: true }), ["all"]));
+                }
+                return base;
+            }
+            if (["readBookmarks", "searchSources", "readFeedback"].includes(operation)) {
+                base.push(...missingMethods(tab, ["goto"]));
+                base.push(...missingMethods(tab?.playwright, ["getByRole", "waitForURL"]));
+                if (typeof tab?.playwright?.getByRole === "function")
+                    base.push(...missingMethods(tab.playwright.getByRole("article"), [
+                        "first",
+                        "waitFor",
+                    ]));
+                if (operation !== "readFeedback") {
+                    base.push(...missingMethods(tab?.playwright, [
+                        "getByRole",
+                        "getByText",
+                        "locator",
+                        "waitForURL",
+                    ]));
+                    if (typeof tab?.playwright?.getByRole === "function")
+                        base.push(...missingMethods(tab.playwright.getByRole("main"), [
+                            "count",
+                            "click",
+                            "first",
+                            "waitFor",
+                        ]));
+                    if (typeof tab?.playwright?.locator === "function")
+                        base.push(...missingMethods(tab.playwright.locator("a"), [
+                            "count",
+                            "filter",
+                            "press",
+                        ]));
+                    if (typeof tab?.playwright?.getByText === "function")
+                        base.push(...missingMethods(tab.playwright.getByText(""), ["waitFor"]));
+                }
+                return base;
+            }
+            if (operation !== "read")
+                base.push(...missingMethods(tab?.playwright, ["getByRole"]), ...missingMethods(tab, ["goto"]));
+            if (operation !== "read" &&
+                typeof tab?.playwright?.getByRole === "function") {
+                base.push(...missingMethods(tab.playwright.getByRole("button"), [
+                    "count",
+                    "click",
+                ]));
+                if (operation !== "submitFollow")
+                    base.push(...missingMethods(tab.playwright.getByRole("textbox"), [
+                        "count",
+                        "fill",
+                    ]));
+                if (["submitPost", "submitReply"].includes(operation)) {
+                    base.push(...missingMethods(tab.playwright, ["locator", "waitForLoadState"]));
+                    base.push(...missingMethods(tab.playwright.getByRole("button"), [
+                        "and",
+                        "waitFor",
+                    ]));
+                }
+            }
+            if (operation === "refreshPerson" || operation === "refreshPosts") {
+                base.push(...missingMethods(tab, ["reload"]));
+                base.push(...missingMethods(tab?.playwright, ["waitForLoadState"]));
+                if (typeof tab?.playwright?.getByRole === "function")
+                    base.push(...missingMethods(tab.playwright.getByRole("button"), ["waitFor"]));
+            }
+            if (operation === "openOwnPostMenu") {
+                base.push(...missingMethods(tab?.playwright, ["locator"]));
+                if (typeof tab?.playwright?.getByRole === "function")
+                    base.push(...missingMethods(tab.playwright.getByRole("article"), [
+                        "filter",
+                        "getByRole",
+                    ]));
+            }
+            if (operation === "submitEditedPost") {
+                base.push(...missingMethods(tab?.playwright, ["waitForLoadState"]));
+                if (typeof tab?.playwright?.getByRole === "function")
+                    base.push(...missingMethods(tab.playwright.getByRole("button"), ["press"]));
+            }
+            if (operation === "attachAssets")
+                base.push(...missingMethods(tab?.playwright, [
+                    "waitForEvent",
+                    "getByLabel",
+                    "getByPlaceholder",
+                ]));
+            if (nativeSubmit && ["submitPost", "submitReply"].includes(operation))
+                base.push(...missingMethods(tab, ["getAXState", "click"]));
+            return base;
+        },
+    };
+}

package/dist/browser-dom-dependencies.d.ts

@@ -0,0 +1,16 @@
+export interface DOMSession {
+    current?: any;
+    replyBinding?: any;
+    refreshNotice?: any;
+    editBinding?: any;
+}
+export interface DOMDependencies {
+    tab: any;
+    nativeSubmit: boolean;
+    readDOM: any;
+    session: DOMSession;
+    submitAX: any;
+    observe: (query: any) => Promise<any>;
+    locator: (role: any, name?: any) => any;
+    unique: (loc: any) => Promise<any>;
+}

package/dist/browser-dom-editing.d.ts

@@ -0,0 +1,148 @@
+import type { DOMDependencies } from "./browser-dom-dependencies.js";
+export declare function createDOMEditing(dependencies: Pick<DOMDependencies, "session" | "unique" | "locator" | "tab" | "observe">): {
+    dismissMenu: (command: any) => Promise<{
+        completed: boolean;
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+    }>;
+    openControl: (command: any) => Promise<{
+        completed: boolean;
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+    }>;
+    openOwnPostMenu: (command: any) => Promise<{
+        completed: boolean;
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+    }>;
+    submitEditedPost: (command: any) => Promise<{
+        completed: boolean;
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+    }>;
+    expandPost: (command: any) => Promise<{
+        completed: boolean;
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+    }>;
+    nextPosts: (command: any) => Promise<{
+        completed: boolean;
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+    }>;
+    clearPreparedText: (command: any) => Promise<{
+        completed: boolean;
+        value: Promise<any>;
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+        value?: undefined;
+    }>;
+    closePreparedReply: (command: any) => Promise<{
+        completed: boolean;
+        value: Promise<any>;
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+        value?: undefined;
+    }>;
+    closePreparedMedia: (command: any) => Promise<{
+        completed: boolean;
+        value: Promise<any>;
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+        value?: undefined;
+    }>;
+    removePreparedMedia: (command: any) => Promise<{
+        completed: boolean;
+        value: Promise<any>;
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+        value?: undefined;
+    }>;
+    attachAssets: (command: any) => Promise<{
+        completed: boolean;
+        value: {
+            assets: {
+                path: any;
+                alt: any;
+            }[];
+            mediaEvidence: any;
+            composer: any;
+        };
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+        value?: undefined;
+    }>;
+    follow: (command: any) => Promise<{
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+    }>;
+    openReply: (command: any) => Promise<{
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+    }>;
+    fillComposer: (command: any) => Promise<{
+        completed: boolean;
+        loc?: undefined;
+        submittedEditor?: undefined;
+    } | {
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+    }>;
+    submitPost: (command: any) => Promise<{
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+    }>;
+    submitReply: (command: any) => Promise<{
+        completed: boolean;
+        loc: any;
+        submittedEditor: any;
+    }>;
+};

package/dist/browser-dom-editing.js

@@ -0,0 +1,386 @@
+import { attachImage } from "./readers-actions.js";
+export function createDOMEditing(dependencies) {
+    const { session, unique, locator, tab, observe } = dependencies;
+    async function dismissMenu(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "menu" ||
+            result.needsStateCheck ||
+            !result.items?.length)
+            throw new Error("关闭菜单需已有菜单证据");
+        const item = result.items[0];
+        session.current = null;
+        await (await unique(locator(item.role, item.label))).press("Escape");
+        return { completed: true };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function openControl(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (!["navigation", "menu"].includes(query.view) || result.needsStateCheck)
+            throw new Error("导航控件须先唯一观察");
+        const matches = (result.controls ?? result.items ?? []).filter((c) => c.role === command.role &&
+            c.label === command.label &&
+            c.href === command.href &&
+            !c.disabled);
+        if (matches.length !== 1)
+            throw new Error("导航控件未唯一观察");
+        session.current = null;
+        await (await unique(command.role === "text"
+            ? tab.playwright.getByText(command.label, { exact: true })
+            : locator(command.role, command.label))).click();
+        if (command.href?.startsWith("/"))
+            await tab.playwright.waitForURL(`https://x.com${command.href}`, {
+                timeoutMs: 5000,
+            });
+        return { completed: true };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function openOwnPostMenu(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        const post = result.posts?.[0];
+        if (query.view !== "posts" ||
+            result.needsStateCheck ||
+            result.posts?.length !== 1 ||
+            post.id !== command.postId ||
+            post.author?.toLowerCase() !== result.accountHandle?.toLowerCase() ||
+            post.primary?.match(/\/status\/(\d+)$/)?.[1] !== command.postId)
+            throw new Error("编辑需唯一本人原帖");
+        const more = post.buttons.filter((b) => /^(更多|More)$/.test(b.label) && !b.disabled);
+        if (more.length !== 1)
+            throw new Error("原帖更多按钮未唯一观察");
+        const article = locator("article").filter({
+            has: tab.playwright.locator(`a[href=${JSON.stringify(post.primary)}]`),
+            visible: true,
+        });
+        session.editBinding = {
+            postId: post.id,
+            accountHandle: result.accountHandle,
+            body: post.body,
+        };
+        session.current = null;
+        await (await unique((await unique(article)).getByRole("button", {
+            name: more[0].label,
+            exact: true,
+        }))).click();
+        return { completed: true };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function submitEditedPost(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "composer" ||
+            result.needsStateCheck ||
+            result.alerts?.length ||
+            !session.editBinding ||
+            session.editBinding.postId !== command.postId ||
+            result.accountHandle !== session.editBinding.accountHandle ||
+            !command.evidenceRef ||
+            !command.approvedText?.trim() ||
+            result.editorText !== command.approvedText ||
+            result.editors?.length !== 1)
+            throw new Error("编辑提交缺本人原帖绑定或精确审稿证据");
+        const updates = result.buttons.filter((b) => /^(更新|Update)$/.test(b.label) && !b.disabled);
+        if (updates.length !== 1)
+            throw new Error("编辑更新按钮未唯一观察");
+        const update = await unique(locator("button", updates[0].label));
+        await command.beforeSubmit?.();
+        session.current = null;
+        session.editBinding = null;
+        if (command.activation === "keyboard")
+            await update.press("Enter");
+        else
+            await update.click();
+        await tab.playwright.waitForLoadState({
+            state: "networkidle",
+            timeoutMs: 8000,
+        });
+        return { completed: true };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function expandPost(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "posts" ||
+            result.posts?.length !== 1 ||
+            result.posts[0].id !== command.postId)
+            throw new Error("展开需唯一原帖");
+        const primary = result.posts[0].primary;
+        const article = locator("article").filter({
+            has: tab.playwright.locator(`a[href=${JSON.stringify(primary)}]`),
+            visible: true,
+        });
+        const control = (await unique(article)).getByText(/^(显示更多|Show more)$/i);
+        session.current = null;
+        await (await unique(control)).click();
+        return { completed: true };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function nextPosts(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "posts" || result.needsStateCheck)
+            throw new Error("翻页须先观察原列表");
+        const primary = result.posts?.at(-1)?.primary;
+        if (!primary)
+            throw new Error("翻页须有已观察原帖链接");
+        const anchor = await unique(tab.playwright
+            .locator(`a[href=${JSON.stringify(primary)}]`)
+            .filter({ visible: true }));
+        session.current = null;
+        await anchor.press("PageDown");
+        return { completed: true };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function clearPreparedText(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "composer" ||
+            result.needsStateCheck ||
+            !command.evidenceRef ||
+            typeof command.text !== "string" ||
+            result.editorText?.replace(/\n{3,}/g, "\n\n") !==
+                command.text.replace(/\n{3,}/g, "\n\n") ||
+            result.editors?.length !== 1)
+            throw new Error("仅恢复本次已知稿件准备");
+        const editor = await unique(locator("textbox", result.editors[0].label));
+        await editor.press("Meta+A");
+        await editor.press("Backspace");
+        return { completed: true, value: observe({ view: "composer" }) };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function closePreparedReply(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "composer" ||
+            result.needsStateCheck ||
+            result.editorText?.trim() !== "" ||
+            !command.evidenceRef)
+            throw new Error("仅关闭有准备失败证据的空回复");
+        await (await unique(locator("button", "关闭"))).click();
+        session.replyBinding = null;
+        return { completed: true, value: observe({ view: "posts", limit: 5 }) };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function closePreparedMedia(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "media" ||
+            result.needsStateCheck ||
+            !command.evidenceRef)
+            throw new Error("媒体恢复须有准备失败证据");
+        const backs = result.controls.filter((b) => b.role === "button" && /^(返回|Back)$/i.test(b.label) && !b.disabled);
+        if (backs.length !== 1)
+            throw new Error("媒体返回入口不唯一");
+        await (await unique(locator("button", backs[0].label))).click();
+        await tab.playwright
+            .getByRole("textbox", { name: /^(帖子文本|Post text)$/i })
+            .waitFor({ state: "visible", timeoutMs: 5000 });
+        return { completed: true, value: observe({ view: "composer" }) };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function removePreparedMedia(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "composer" ||
+            result.needsStateCheck ||
+            result.editorText?.trim() !== "" ||
+            !command.evidenceRef)
+            throw new Error("仅恢复有来源证据的空正文媒体准备");
+        const removes = result.buttons.filter((b) => /^(移除媒体|Remove media)$/i.test(b.label) && !b.disabled);
+        if (removes.length !== 1)
+            throw new Error("待恢复媒体不唯一");
+        await (await unique(locator("button", removes[0].label))).click();
+        return { completed: true, value: observe({ view: "composer" }) };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function attachAssets(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "composer" ||
+            result.needsStateCheck ||
+            command.assets?.length !== 1)
+            throw new Error("仅上传已观察编辑器的一张带ALT图片");
+        const asset = command.assets[0];
+        if (!asset.alt?.trim())
+            throw new Error("图片须有完整ALT");
+        session.current = null;
+        await attachImage(tab, { path: asset.path });
+        await tab.playwright
+            .getByRole("button", {
+            name: /^(?:编辑|Edit)(?:图片|照片|媒体| image| photo| media)?(?: \d+)?$/i,
+        })
+            .waitFor({ state: "visible", timeoutMs: 5000 });
+        const composer = await observe({ view: "composer" });
+        const edits = composer.buttons.filter((b) => /^(?:编辑|Edit)(?:图片|照片|媒体| image| photo| media)?(?: \d+)?$/i.test(b.label) && !b.disabled);
+        if (edits.length !== 1)
+            throw new Error("图片编辑入口未唯一观察");
+        await (await unique(locator("button", edits[0].label))).click();
+        await tab.playwright
+            .getByRole("tab", {
+            name: /^(编辑图片描述|Edit image description)$/i,
+        })
+            .waitFor({ state: "visible", timeoutMs: 5000 });
+        let media = await observe({ view: "media" });
+        const tabControl = media.controls.find((c) => c.role === "tab" &&
+            /^(编辑图片描述|Edit image description)$/i.test(c.label));
+        if (!tabControl)
+            throw new Error("ALT页签未观察");
+        await (await unique(locator("tab", tabControl.label))).click();
+        media = await observe({ view: "media" });
+        if (media.needsStateCheck || media.fields.length !== 1)
+            throw new Error("ALT输入未唯一观察");
+        const field = media.fields[0];
+        const input = field.label
+            ? tab.playwright.getByLabel(field.label, { exact: true })
+            : field.placeholder
+                ? tab.playwright.getByPlaceholder(field.placeholder, {
+                    exact: true,
+                })
+                : locator("textbox");
+        await (await unique(input)).fill(asset.alt);
+        media = await observe({ view: "media" });
+        if (media.fields[0]?.value !== asset.alt)
+            throw new Error("ALT全文不匹配");
+        const save = media.controls.filter((c) => c.role === "button" && /^(保存|Save)$/i.test(c.label) && !c.disabled);
+        if (save.length !== 1)
+            throw new Error("ALT保存入口不唯一");
+        await (await unique(locator("button", save[0].label))).click();
+        const after = await observe({ view: "composer" });
+        if (after.needsStateCheck || !after.images?.length)
+            throw new Error("上传图片未回到编辑器");
+        return {
+            completed: true,
+            value: {
+                assets: [{ path: asset.path, alt: asset.alt }],
+                mediaEvidence: media,
+                composer: after,
+            },
+        };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function follow(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "person" ||
+            query.handle !== command.handle ||
+            result.needsStateCheck)
+            throw new Error("人物身份未绑定");
+        const name = result.relationship === "follows-you"
+            ? `回关 @${command.handle}`
+            : `关注 @${command.handle}`;
+        loc = await unique(locator("button", name));
+        return { completed: false, loc, submittedEditor };
+    }
+    async function openReply(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        session.replyBinding = null;
+        if (query.targetId !== command.postId || result.posts?.length !== 1)
+            throw new Error("回复主帖未唯一绑定");
+        const names = result.posts[0].buttons.filter((b) => /回复|Reply/i.test(b.label));
+        if (names.length !== 1)
+            throw new Error("回复按钮未唯一观察");
+        const primary = result.posts[0].primary;
+        if (!primary || primary.match(/\/status\/(\d+)$/)?.[1] !== command.postId)
+            throw new Error("回复主帖永久链接未绑定");
+        const article = locator("article").filter({
+            has: tab.playwright.locator(`a[href=${JSON.stringify(primary)}]`),
+            visible: true,
+        });
+        loc = await unique((await unique(article)).getByRole("button", {
+            name: names[0].label,
+            exact: true,
+        }));
+        return { completed: false, loc, submittedEditor };
+    }
+    async function fillComposer(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "composer" || result.editors?.length !== 1)
+            throw new Error("编辑器未唯一观察");
+        loc = await unique(locator("textbox", result.editors[0].label));
+        session.current = null;
+        await loc.fill(command.text);
+        const submits = result.buttons.filter((b) => /^(回复|Reply|发帖|发布|Post|更新|Update)$/i.test(b.label));
+        if (submits.length !== 1)
+            throw new Error("编辑后提交入口不唯一");
+        await locator("button", submits[0].label)
+            .and(tab.playwright.locator(':not([disabled]):not([aria-disabled="true"])'))
+            .waitFor({ state: "visible", timeoutMs: 5000 });
+        return { completed: true };
+        return { completed: false, loc, submittedEditor };
+    }
+    async function submitPost(command) {
+        const { query, result } = session.current;
+        let loc, submittedEditor;
+        if (query.view !== "composer")
+            throw new Error("未观察编辑器");
+        const pattern = command.operation === "submitReply"
+            ? /^(回复|Reply)$/i
+            : /^(发帖|发布|Post)$/i;
+        const buttons = result.buttons?.filter((b) => pattern.test(b.label) && !b.disabled) ?? [];
+        if (buttons.length !== 1)
+            throw new Error("提交按钮未唯一观察");
+        loc = await unique(locator("button", buttons[0].label));
+        if (command.activation !== undefined &&
+            !["click", "keyboard"].includes(command.activation))
+            throw new Error("提交激活方式无效");
+        if (command.activation === "keyboard" && typeof loc.press !== "function")
+            throw new Error("缺语义按钮键盘提交能力");
+        if (command.operation === "submitReply") {
+            if (result.editors?.length !== 1 || !result.editorText?.trim())
+                throw new Error("回复提交缺唯一完整编辑器");
+            submittedEditor = locator("textbox", result.editors[0].label).filter({
+                hasText: new RegExp(
+                // Full text and actor are checked by platform.compose before this act.
+                // Use a short observed anchor for the retained-text wait: host locator
+                // bridges can reject a multi-kilobyte hasText regex on long posts.
+                result.editorText
+                    .trim()
+                    .split(/\r?\n/)[0]
+                    .slice(0, 64)
+                    .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")),
+            });
+            await unique(submittedEditor);
+        }
+        else {
+            if (result.editors?.length !== 1 || !result.editorText?.trim())
+                throw new Error("发帖提交缺唯一完整编辑器");
+            // Publication with media may stay pending after the click. Do not let
+            // receipt navigation interrupt it while the submitted text is retained.
+            submittedEditor = locator("textbox", result.editors[0].label).filter({
+                hasText: new RegExp(
+                // Full text and actor are checked by platform.compose before this act.
+                // Use a short observed anchor for the retained-text wait: host locator
+                // bridges can reject a multi-kilobyte hasText regex on long posts.
+                result.editorText
+                    .trim()
+                    .split(/\r?\n/)[0]
+                    .slice(0, 64)
+                    .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")),
+            });
+            await unique(submittedEditor);
+        }
+        return { completed: false, loc, submittedEditor };
+    }
+    return {
+        dismissMenu,
+        openControl,
+        openOwnPostMenu,
+        submitEditedPost,
+        expandPost,
+        nextPosts,
+        clearPreparedText,
+        closePreparedReply,
+        closePreparedMedia,
+        removePreparedMedia,
+        attachAssets,
+        follow,
+        openReply,
+        fillComposer,
+        submitPost,
+        submitReply: submitPost,
+    };
+}

package/dist/browser-dom-navigation.d.ts

@@ -0,0 +1,9 @@
+import type { DOMDependencies } from "./browser-dom-dependencies.js";
+export declare function createDOMNavigation(dependencies: Pick<DOMDependencies, "session" | "tab" | "observe">): {
+    searchSources: (command: any) => Promise<void>;
+    waitForFolder: (command: any) => Promise<void>;
+    waitForPosts: (command: any) => Promise<void>;
+    openObserved: (command: any) => Promise<void>;
+    refreshPerson: (command: any) => Promise<void>;
+    refreshPosts: (command: any) => Promise<void>;
+};