@nextclaw/x-harness 0.1.1 → 0.2.1

package/dist/platform-capabilities.js

@@ -1,19 +1,29 @@
-export function createPlatformCapabilities(dependencies) {
-    const { missing, browser } = dependencies;
-    function preflight({ operation, input = {} }) {
-        const absent = missing(operation);
+export class PlatformCapabilities {
+    #missing;
+    #browser;
+    preflight;
+    constructor(dependencies) {
+        const { missing, browser } = dependencies;
+        this.#missing = missing;
+        this.#browser = browser;
+        this.preflight = this.handlePreflight.bind(this);
+    }
+    handlePreflight({ operation, input = {} }) {
+        const absent = this.#missing(operation);
         if (operation === "readCreator" &&
-            typeof browser.collectCreator !== "function")
+            typeof this.#browser.collectCreator !== "function")
             absent.push("browser.collectCreator");
         if (input.kind === "follow" || operation === "submitFollow")
-            absent.push(...(browser.capabilities?.("refreshPerson") ?? ["refreshPerson"]));
+            absent.push(...(this.#browser.capabilities?.("refreshPerson") ?? ["refreshPerson"]));
         if (operation !== "read" && input.assets?.length)
-            absent.push(...(browser.capabilities?.("attachAssets") ?? ["attachAssets"]));
+            absent.push(...(this.#browser.capabilities?.("attachAssets") ?? ["attachAssets"]));
         return {
             covered: absent.length === 0,
             missing: [...new Set(absent)],
             owner: "scripts/x-harness-browser.mjs",
         };
     }
-    return { preflight };
+}
+export function createPlatformCapabilities(...args) {
+    return new PlatformCapabilities(...args);
 }

package/dist/platform-collections.d.ts

@@ -1,7 +1,14 @@
 import type { PlatformDependencies } from "./platform-dependencies.js";
-export declare function createPlatformCollections(dependencies: Pick<PlatformDependencies, "ready" | "observed" | "browser" | "choose">): {
-    collectSources: ({ processedIds, maxPages, limit, }?: any) => Promise<any>;
+export declare class PlatformCollections {
+    #private;
+    collectSources: ({ processedIds, maxPages, limit }?: any) => Promise<any>;
     readCreator: (args: import("./types.js").CreatorOptions) => Promise<any>;
     readBookmarks: ({ folder, ...window }?: any) => Promise<any>;
     searchSources: ({ query, limit, maxPages, processedIds, }?: any) => Promise<any>;
-};
+    constructor(dependencies: Pick<PlatformDependencies, "ready" | "observed" | "browser" | "choose">);
+    private handleCollectSources;
+    private handleReadCreator;
+    private handleReadBookmarks;
+    private handleSearchSources;
+}
+export declare function createPlatformCollections(...args: ConstructorParameters<typeof PlatformCollections>): PlatformCollections;

package/dist/platform-collections.js

@@ -1,7 +1,25 @@
 import { xURL, source } from "./platform-rules.js";
-export function createPlatformCollections(dependencies) {
-    const { ready, observed, browser, choose } = dependencies;
-    async function collectSources({ processedIds = [], maxPages = 3, limit = 1, } = {}) {
+export class PlatformCollections {
+    #ready;
+    #observed;
+    #browser;
+    #choose;
+    collectSources;
+    readCreator;
+    readBookmarks;
+    searchSources;
+    constructor(dependencies) {
+        const { ready, observed, browser, choose } = dependencies;
+        this.#ready = ready;
+        this.#observed = observed;
+        this.#browser = browser;
+        this.#choose = choose;
+        this.collectSources = this.handleCollectSources.bind(this);
+        this.readCreator = this.handleReadCreator.bind(this);
+        this.readBookmarks = this.handleReadBookmarks.bind(this);
+        this.searchSources = this.handleSearchSources.bind(this);
+    }
+    async handleCollectSources({ processedIds = [], maxPages = 3, limit = 1, } = {}) {
         if (!Array.isArray(processedIds) ||
             !Number.isInteger(maxPages) ||
             maxPages < 1 ||
@@ -13,7 +31,7 @@ export function createPlatformCollections(dependencies) {
         const seen = new Set(processedIds), sources = [], missing = [];
         let last, previousIds = "", offset = 0, firstDOMId;
         for (let page = 0; page < maxPages && sources.length < limit; page++) {
-            last = await ready({ view: "posts", offset, limit: 5 });
+            last = await this.#ready({ view: "posts", offset, limit: 5 });
             if (page === 0)
                 firstDOMId = last.posts?.[0]?.id;
             if (last.needsStateCheck || last.alerts?.length)
@@ -39,7 +57,7 @@ export function createPlatformCollections(dependencies) {
                 seen.add(candidate.id);
                 let post = candidate;
                 if (candidate.needsExpansion) {
-                    const target = await observed({
+                    const target = await this.#observed({
                         view: "posts",
                         targetId: candidate.id,
                         limit: 1,
@@ -48,8 +66,11 @@ export function createPlatformCollections(dependencies) {
                         missing.push("expansion-target-unconfirmed");
                         continue;
                     }
-                    await browser.act({ operation: "expandPost", postId: candidate.id });
-                    const expanded = await ready({
+                    await this.#browser.act({
+                        operation: "expandPost",
+                        postId: candidate.id,
+                    });
+                    const expanded = await this.#ready({
                         view: "posts",
                         targetId: candidate.id,
                         limit: 1,
@@ -77,12 +98,12 @@ export function createPlatformCollections(dependencies) {
             }
             if (sources.length < limit && page + 1 < maxPages) {
                 // Expansion narrowed the semantic window; restore the list before scrolling.
-                last = await observed({ view: "posts", offset, limit: 5 });
+                last = await this.#observed({ view: "posts", offset, limit: 5 });
                 if (last.moreInDOM)
                     offset += 5;
                 else {
-                    await browser.act({ operation: "nextPosts" });
-                    const advanced = await ready({ view: "posts", limit: 5 });
+                    await this.#browser.act({ operation: "nextPosts" });
+                    const advanced = await this.#ready({ view: "posts", limit: 5 });
                     // Retained DOM prefixes include a partial final window too; skip
                     // exactly the consumed cards, while virtualized replacements restart.
                     offset =
@@ -106,14 +127,14 @@ export function createPlatformCollections(dependencies) {
                 : [...new Set([...missing, "bounded-source-window-exhausted"])],
         };
     }
-    async function readCreator(args) {
-        if (typeof browser.collectCreator !== "function")
+    async handleReadCreator(args) {
+        if (typeof this.#browser.collectCreator !== "function")
             return {
                 status: "needsCapability",
                 complete: false,
                 missing: ["browser.collectCreator"],
             };
-        const value = await browser.collectCreator(args);
+        const value = await this.#browser.collectCreator(args);
         const absent = [
             ...new Set([
                 ...(value.missing ?? []),
@@ -130,19 +151,19 @@ export function createPlatformCollections(dependencies) {
             missing: absent,
         };
     }
-    async function readBookmarks({ folder, ...window } = {}) {
+    async handleReadBookmarks({ folder, ...window } = {}) {
         if (typeof folder !== "string" || !folder.trim())
             throw new Error("需指定收藏文件夹；不以全部书签冒充命名文件夹");
-        let nav = await ready({ view: "navigation", targetLabel: folder });
+        let nav = await this.#ready({ view: "navigation", targetLabel: folder });
         const bookmark = (c) => /^(书签|收藏|Bookmarks)$/i.test(c.label);
-        if (!(await choose(nav, bookmark, { activateSelected: true }))) {
-            if (await choose(nav, (c) => /^(更多菜单项|More menu items)$/i.test(c.label))) {
-                nav = await ready({ view: "menu" });
-                if (!(await choose(nav, bookmark))) {
+        if (!(await this.#choose(nav, bookmark, { activateSelected: true }))) {
+            if (await this.#choose(nav, (c) => /^(更多菜单项|More menu items)$/i.test(c.label))) {
+                nav = await this.#ready({ view: "menu" });
+                if (!(await this.#choose(nav, bookmark))) {
                     if (nav.items?.length)
-                        await browser.act({ operation: "dismissMenu" });
-                    nav = await ready({ view: "navigation", targetLabel: folder });
-                    if (!(await choose(nav, (c) => /^(历史|History)$/i.test(c.label))))
+                        await this.#browser.act({ operation: "dismissMenu" });
+                    nav = await this.#ready({ view: "navigation", targetLabel: folder });
+                    if (!(await this.#choose(nav, (c) => /^(历史|History)$/i.test(c.label))))
                         return {
                             status: "needsCapability",
                             owner: "scripts/x-harness-browser.mjs",
@@ -150,34 +171,34 @@ export function createPlatformCollections(dependencies) {
                         };
                 }
             }
-            else if (!(await choose(nav, (c) => /^(历史|History)$/i.test(c.label))))
+            else if (!(await this.#choose(nav, (c) => /^(历史|History)$/i.test(c.label))))
                 return {
                     status: "needsCapability",
                     owner: "scripts/x-harness-browser.mjs",
                     missing: ["bookmarks-entry-not-observed"],
                 };
         }
-        nav = await ready({ view: "navigation", targetLabel: folder });
+        nav = await this.#ready({ view: "navigation", targetLabel: folder });
         const tabs = (nav.controls ?? []).filter((c) => c.role === "tab" && bookmark(c));
         if (tabs.length === 1 &&
             (!tabs[0].selected ||
                 !(nav.controls ?? []).some((c) => c.label.split("\n")[0] === folder))) {
-            await choose(nav, (c) => c === tabs[0], {
+            await this.#choose(nav, (c) => c === tabs[0], {
                 activateSelected: true,
             });
-            nav = await ready({ view: "navigation", targetLabel: folder });
+            nav = await this.#ready({ view: "navigation", targetLabel: folder });
         }
         if (!(nav.controls ?? []).some((c) => c.label.split("\n")[0] === folder)) {
             try {
-                await browser.act({ operation: "waitForFolder", folder });
+                await this.#browser.act({ operation: "waitForFolder", folder });
             }
             catch (error) {
                 if (!/timed out|timeout/i.test(error.message))
                     throw error;
             }
-            nav = await ready({ view: "navigation", targetLabel: folder });
+            nav = await this.#ready({ view: "navigation", targetLabel: folder });
         }
-        if (!(await choose(nav, (c) => c.label.split("\n")[0] === folder)))
+        if (!(await this.#choose(nav, (c) => c.label.split("\n")[0] === folder)))
             return {
                 status: "needsCapability",
                 owner: "scripts/x-harness-browser.mjs",
@@ -186,7 +207,7 @@ export function createPlatformCollections(dependencies) {
                 folder,
                 controls: nav.controls,
             };
-        const selected = await ready({ view: "navigation" });
+        const selected = await this.#ready({ view: "navigation" });
         if (selected.page === nav.page && !selected.headings?.includes(folder))
             return {
                 status: "needsDecision",
@@ -195,7 +216,7 @@ export function createPlatformCollections(dependencies) {
                 folder,
                 page: selected.page,
             };
-        const value = await collectSources(window);
+        const value = await this.handleCollectSources(window);
         return {
             ...value,
             folder,
@@ -206,9 +227,13 @@ export function createPlatformCollections(dependencies) {
             },
         };
     }
-    async function searchSources({ query, limit = 3, maxPages = 1, processedIds = [], } = {}) {
-        await browser.act({ operation: "searchSources", query });
-        const value = await collectSources({ limit, maxPages, processedIds });
+    async handleSearchSources({ query, limit = 3, maxPages = 1, processedIds = [], } = {}) {
+        await this.#browser.act({ operation: "searchSources", query });
+        const value = await this.handleCollectSources({
+            limit,
+            maxPages,
+            processedIds,
+        });
         if (!value.page ||
             xURL(value.page).pathname !== "/search" ||
             xURL(value.page).searchParams.get("q") !== query)
@@ -219,5 +244,7 @@ export function createPlatformCollections(dependencies) {
             };
         return { ...value, query };
     }
-    return { collectSources, readCreator, readBookmarks, searchSources };
+}
+export function createPlatformCollections(...args) {
+    return new PlatformCollections(...args);
 }

package/dist/platform-dependencies.js

@@ -0,0 +1 @@
+export {};

package/dist/platform-diagnostics.d.ts

@@ -1,9 +1,14 @@
 import type { PlatformDependencies } from "./platform-dependencies.js";
-export declare function createPlatformDiagnostics(dependencies: Pick<PlatformDependencies, "clock">): {
+export declare class PlatformDiagnostics {
+    #private;
     followStage: (action: any, stage: any, run: any) => Promise<any>;
     captureProof: ({ observation }: any) => {
         followDiagnostics?: any[] | undefined;
         capturedAt: string;
         observation: any;
     };
-};
+    constructor(dependencies: Pick<PlatformDependencies, "clock">);
+    private handleFollowStage;
+    private handleCaptureProof;
+}
+export declare function createPlatformDiagnostics(...args: ConstructorParameters<typeof PlatformDiagnostics>): PlatformDiagnostics;

package/dist/platform-diagnostics.js

@@ -1,23 +1,31 @@
-export function createPlatformDiagnostics(dependencies) {
-    const { clock } = dependencies;
-    // Bounded semantic diagnostics travel with existing proof captures; no page dump or second state store.
-    const followDiagnostics = [];
-    async function followStage(action, stage, run) {
-        const started = clock();
+export class PlatformDiagnostics {
+    #clock;
+    #followDiagnostics;
+    followStage;
+    captureProof;
+    constructor(dependencies) {
+        const { clock } = dependencies;
+        this.#clock = clock;
+        this.#followDiagnostics = [];
+        this.followStage = this.handleFollowStage.bind(this);
+        this.captureProof = this.handleCaptureProof.bind(this);
+    }
+    async handleFollowStage(action, stage, run) {
+        const started = this.#clock();
         const event = {
             actionId: action.id ?? null,
             handle: action.handle,
             stage,
             startedAt: new Date(started).toISOString(),
         };
-        followDiagnostics.push(event);
-        if (followDiagnostics.length > 40)
-            followDiagnostics.shift();
+        this.#followDiagnostics.push(event);
+        if (this.#followDiagnostics.length > 40)
+            this.#followDiagnostics.shift();
         try {
             const value = await run();
             Object.assign(event, {
                 status: "returned",
-                durationMs: clock() - started,
+                durationMs: this.#clock() - started,
             });
             if (value && typeof value === "object")
                 Object.assign(event, {
@@ -34,18 +42,22 @@ export function createPlatformDiagnostics(dependencies) {
         catch (error) {
             Object.assign(event, {
                 status: "error",
-                durationMs: clock() - started,
+                durationMs: this.#clock() - started,
                 error: String(error.message ?? error).slice(0, 500),
             });
             throw error;
         }
     }
-    const captureProof = ({ observation }) => ({
-        capturedAt: new Date(clock()).toISOString(),
-        observation,
-        ...(followDiagnostics.length
-            ? { followDiagnostics: structuredClone(followDiagnostics) }
-            : {}),
-    });
-    return { followStage, captureProof };
+    handleCaptureProof({ observation }) {
+        return {
+            capturedAt: new Date(this.#clock()).toISOString(),
+            observation,
+            ...(this.#followDiagnostics.length
+                ? { followDiagnostics: structuredClone(this.#followDiagnostics) }
+                : {}),
+        };
+    }
+}
+export function createPlatformDiagnostics(...args) {
+    return new PlatformDiagnostics(...args);
 }

package/dist/platform-observation.d.ts

@@ -1,8 +1,16 @@
 import type { PlatformDependencies } from "./platform-dependencies.js";
-export declare function createPlatformObservation(dependencies: Pick<PlatformDependencies, "browser" | "clock">): {
+export declare class PlatformObservation {
+    #private;
     missing: (operation: any) => any[];
     observed: (query: any) => Promise<any>;
     open: (target: any, query: any) => Promise<any>;
     ready: (query: any) => Promise<any>;
     choose: (value: any, pattern: any, { activateSelected }?: any) => Promise<any>;
-};
+    constructor(dependencies: Pick<PlatformDependencies, "browser" | "clock">);
+    private handleObserved;
+    private handleOpen;
+    private handleReady;
+    private handleChoose;
+    private handleMissing;
+}
+export declare function createPlatformObservation(...args: ConstructorParameters<typeof PlatformObservation>): PlatformObservation;

package/dist/platform-observation.js

@@ -1,26 +1,37 @@
 import { xURL } from "./platform-rules.js";
-export function createPlatformObservation(dependencies) {
-    const { browser, clock } = dependencies;
-    const methods = ["observe", "act"];
-    const missing = (operation) => [
-        ...methods.filter((name) => typeof browser?.[name] !== "function"),
-        ...(typeof browser?.capabilities === "function"
-            ? browser.capabilities(operation)
-            : ["capabilities"]),
-    ];
-    async function observed(query) {
-        const value = await browser.observe(query);
+export class PlatformObservation {
+    #browser;
+    #clock;
+    #methods;
+    missing;
+    observed;
+    open;
+    ready;
+    choose;
+    constructor(dependencies) {
+        const { browser, clock } = dependencies;
+        this.#browser = browser;
+        this.#clock = clock;
+        this.#methods = ["observe", "act"];
+        this.missing = this.handleMissing.bind(this);
+        this.observed = this.handleObserved.bind(this);
+        this.open = this.handleOpen.bind(this);
+        this.ready = this.handleReady.bind(this);
+        this.choose = this.handleChoose.bind(this);
+    }
+    async handleObserved(query) {
+        const value = await this.#browser.observe(query);
         return {
             ...value,
-            observedAt: new Date(clock()).toISOString(),
+            observedAt: new Date(this.#clock()).toISOString(),
             fresh: true,
         };
     }
-    async function open(target, query) {
+    async handleOpen(target, query) {
         const url = xURL(target.url);
         if (!target.evidenceRef)
             throw new Error("目标URL缺已观察证据");
-        let value = await observed(query);
+        let value = await this.handleObserved(query);
         let atTarget = false;
         try {
             atTarget = xURL(value.page).href === url.href;
@@ -29,14 +40,14 @@ export function createPlatformObservation(dependencies) {
             /* Blank/non-X pages require observed navigation. */
         }
         if (!atTarget) {
-            await browser.act({
+            await this.#browser.act({
                 operation: "openObserved",
                 url: url.href,
                 evidenceRef: target.evidenceRef,
                 view: query.view,
                 handle: query.handle,
             });
-            value = await ready(query);
+            value = await this.handleReady(query);
         }
         if (!value.page || xURL(value.page).href !== url.href)
             return {
@@ -46,30 +57,40 @@ export function createPlatformObservation(dependencies) {
             };
         return value;
     }
-    async function ready(query) {
-        let value = await observed(query);
+    async handleReady(query) {
+        let value = await this.handleObserved(query);
         if (value.needsStateCheck &&
             !value.alerts?.length &&
             query.view === "posts") {
             try {
-                await browser.act({ operation: "waitForPosts" });
+                await this.#browser.act({ operation: "waitForPosts" });
             }
             catch (error) {
                 if (!/timed out|timeout/i.test(error.message))
                     throw error;
             }
-            value = await observed(query);
+            value = await this.handleObserved(query);
         }
         return value;
     }
-    async function choose(value, pattern, { activateSelected = false } = {}) {
+    async handleChoose(value, pattern, { activateSelected = false } = {}) {
         const controls = (value.controls ?? value.items ?? []).filter((c) => !c.disabled && pattern(c));
         if (controls.length !== 1)
             return false;
         if (controls[0].selected && !activateSelected)
             return true;
-        await browser.act({ operation: "openControl", ...controls[0] });
+        await this.#browser.act({ operation: "openControl", ...controls[0] });
         return true;
     }
-    return { missing, observed, open, ready, choose };
+    handleMissing(operation) {
+        return [
+            ...this.#methods.filter((name) => typeof this.#browser?.[name] !== "function"),
+            ...(typeof this.#browser?.capabilities === "function"
+                ? this.#browser.capabilities(operation)
+                : ["capabilities"]),
+        ];
+    }
+}
+export function createPlatformObservation(...args) {
+    return new PlatformObservation(...args);
 }

package/dist/platform-targets.d.ts

@@ -1,7 +1,14 @@
 import type { PlatformDependencies } from "./platform-dependencies.js";
-export declare function createPlatformTargets(dependencies: Pick<PlatformDependencies, "observed" | "open" | "browser" | "ready">): {
+export declare class PlatformTargets {
+    #private;
     readAccount: () => Promise<any>;
-    readFeedback: ({ targets, replyLimit, }?: any) => Promise<any>;
+    readFeedback: ({ targets, replyLimit }?: any) => Promise<any>;
     readPerson: (target: any) => Promise<any>;
     readPost: (target: any) => Promise<any>;
-};
+    constructor(dependencies: Pick<PlatformDependencies, "observed" | "open" | "browser" | "ready">);
+    private handleReadFeedback;
+    private handleReadPerson;
+    private handleReadPost;
+    private handleReadAccount;
+}
+export declare function createPlatformTargets(...args: ConstructorParameters<typeof PlatformTargets>): PlatformTargets;

package/dist/platform-targets.js

@@ -1,15 +1,32 @@
 import { xURL, sameHandle, handlePattern, source } from "./platform-rules.js";
-export function createPlatformTargets(dependencies) {
-    const { observed, open, browser, ready } = dependencies;
-    const readAccount = () => observed({ view: "account" });
-    async function readFeedback({ targets, replyLimit = 3, } = {}) {
+export class PlatformTargets {
+    #observed;
+    #open;
+    #browser;
+    #ready;
+    readAccount;
+    readFeedback;
+    readPerson;
+    readPost;
+    constructor(dependencies) {
+        const { observed, open, browser, ready } = dependencies;
+        this.#observed = observed;
+        this.#open = open;
+        this.#browser = browser;
+        this.#ready = ready;
+        this.readAccount = this.handleReadAccount.bind(this);
+        this.readFeedback = this.handleReadFeedback.bind(this);
+        this.readPerson = this.handleReadPerson.bind(this);
+        this.readPost = this.handleReadPost.bind(this);
+    }
+    async handleReadFeedback({ targets, replyLimit = 3, } = {}) {
         if (!Array.isArray(targets) || targets.length < 1 || targets.length > 5)
             throw new Error("反馈窗口须为1–5个已发布ID");
         if (!Number.isInteger(replyLimit) || replyLimit < 0 || replyLimit > 3)
             throw new Error("回复核验窗口须为0–3");
         const feedback = [];
         for (const target of targets) {
-            const value = await readPost(target), post = value.posts?.find((p) => p.id === target.postId);
+            const value = await this.handleReadPost(target), post = value.posts?.find((p) => p.id === target.postId);
             if (value.needsStateCheck || value.alerts?.length || !post) {
                 feedback.push({
                     id: target.postId,
@@ -17,7 +34,7 @@ export function createPlatformTargets(dependencies) {
                 });
                 continue;
             }
-            const thread = await observed({ view: "posts", limit: 5 });
+            const thread = await this.#observed({ view: "posts", limit: 5 });
             const replies = [], unconfirmedReplyIds = [];
             const targetIndex = (thread.posts ?? []).findIndex((p) => p.id === post.id);
             const candidates = targetIndex < 0
@@ -27,7 +44,7 @@ export function createPlatformTargets(dependencies) {
                 if (!candidate.primary || !candidate.id)
                     continue;
                 const url = new URL(candidate.primary, thread.page).href;
-                const detail = await open({
+                const detail = await this.#open({
                     url,
                     evidenceRef: {
                         page: thread.page,
@@ -68,13 +85,13 @@ export function createPlatformTargets(dependencies) {
             pageComplete: false,
         };
     }
-    async function readPerson(target) {
+    async handleReadPerson(target) {
         if (!handlePattern.test(target.handle ?? ""))
             throw new Error("无效已观察handle");
         if (xURL(target.url).pathname.toLowerCase() !==
             `/${target.handle}`.toLowerCase())
             throw new Error("人物URL与handle不一致");
-        const value = await open(target, {
+        const value = await this.#open(target, {
             view: "person",
             handle: target.handle,
         });
@@ -86,11 +103,11 @@ export function createPlatformTargets(dependencies) {
                 missing: ["person-identity-mismatch"],
             };
     }
-    async function readPost(target) {
+    async handleReadPost(target) {
         if (!/^\d+$/.test(target.postId ?? "") ||
             xURL(target.url).pathname.match(/\/status\/(\d+)$/)?.[1] !== target.postId)
             throw new Error("帖子URL与公开ID不一致");
-        let value = await open(target, {
+        let value = await this.#open(target, {
             view: "posts",
             targetId: target.postId,
         });
@@ -101,8 +118,11 @@ export function createPlatformTargets(dependencies) {
             !value.alerts?.length &&
             posts.length === 1 &&
             posts[0].needsExpansion) {
-            await browser.act({ operation: "expandPost", postId: target.postId });
-            value = await ready({ view: "posts", targetId: target.postId });
+            await this.#browser.act({
+                operation: "expandPost",
+                postId: target.postId,
+            });
+            value = await this.#ready({ view: "posts", targetId: target.postId });
             posts = (value.posts ?? []).filter((p) => p.id === target.postId);
         }
         const missing = [...(value.missing ?? [])];
@@ -125,5 +145,10 @@ export function createPlatformTargets(dependencies) {
             missing,
         };
     }
-    return { readAccount, readFeedback, readPerson, readPost };
+    handleReadAccount() {
+        return this.#observed({ view: "account" });
+    }
+}
+export function createPlatformTargets(...args) {
+    return new PlatformTargets(...args);
 }

package/dist/platform-writing.d.ts

@@ -1,8 +1,16 @@
 import type { PlatformDependencies } from "./platform-dependencies.js";
-export declare function createPlatformWriting(dependencies: Pick<PlatformDependencies, "observed" | "browser" | "followStage" | "readPerson" | "open" | "clock" | "readPost">): {
+export declare class PlatformWriting {
+    #private;
     compose: (action: any) => Promise<any>;
     findSubmission: (action: any) => Promise<any>;
     submitFollow: (action: any) => Promise<any>;
     submitPost: (action: any) => Promise<any>;
     submitReply: (action: any) => Promise<any>;
-};
+    constructor(dependencies: Pick<PlatformDependencies, "observed" | "browser" | "followStage" | "readPerson" | "open" | "clock" | "readPost">);
+    private handleCompose;
+    private handleFindSubmission;
+    private handleSubmitFollow;
+    private handleSubmitPost;
+    private handleSubmitReply;
+}
+export declare function createPlatformWriting(...args: ConstructorParameters<typeof PlatformWriting>): PlatformWriting;