@nextclaw/x-harness 0.1.1 → 0.2.1

package/dist/growth-recovery.js

@@ -1,158 +1,187 @@
 import { xURL } from "./platform-rules.js";
 import { same } from "./growth-constants.js";
-export function createGrowthRecovery(dependencies) {
-    const { capability, platform, load, evidenceExists, clock, store, settleProof, executor, parallelRound, round, readTask, } = dependencies;
-    return {
-        async verifyPublishedPost({ taskId, draftPath, publicURL, evidenceRef, sourceLink, }) {
-            // Read-only recovery of a single submitted original; never opens a composer.
-            const caps = capability("read");
-            if (!caps.covered || typeof platform.readPost !== "function")
-                return {
-                    status: "needsCapability",
-                    missing: ["platform.readPost", ...caps.missing],
-                };
-            const initial = await load(taskId);
-            const action = initial.state.actions.find((a) => a.kind === "original" && a.draftPath === draftPath);
-            if (!action ||
-                !["intent", "unknown"].includes(action.status) ||
-                !evidenceExists(evidenceRef))
-                throw new Error("submitted-original-and-public-proof-required");
-            const url = xURL(publicURL), postId = url.pathname.match(/\/status\/(\d+)$/)?.[1];
-            if (!postId ||
-                url.pathname.toLowerCase() !==
-                    `/${action.accountHandle}/status/${postId}`.toLowerCase())
-                throw new Error("public-account-mismatch");
-            const observation = await platform.readPost({
-                postId,
-                url: publicURL,
-                evidenceRef,
-            });
-            const trailing = action.text.match(/\n\n(https:\/\/\S+)$/);
-            const matches = (observation.posts ?? []).filter((p) => {
-                const exact = p.body === action.text;
-                const card = trailing &&
-                    sourceLink &&
-                    evidenceExists(sourceLink.evidenceRef) &&
-                    sourceLink.resolvedURL === trailing[1] &&
-                    p.links?.includes(sourceLink.href) &&
-                    p.body === action.text.slice(0, -trailing[0].length);
-                let renderedSource = false;
-                if (trailing &&
-                    sourceLink?.renderedText &&
-                    evidenceExists(sourceLink.evidenceRef) &&
-                    sourceLink.resolvedURL === trailing[1] &&
-                    p.links?.includes(sourceLink.href)) {
-                    try {
-                        renderedSource =
-                            new URL(sourceLink.renderedText.replace(/\s/g, "")).href ===
-                                sourceLink.resolvedURL &&
-                                p.body?.endsWith(sourceLink.renderedText) &&
-                                p.body.slice(0, -sourceLink.renderedText.length).trimEnd() ===
-                                    action.text.slice(0, -trailing[0].length);
-                    }
-                    catch {
-                        /* Invalid rendered URL cannot verify publication. */
-                    }
+export class GrowthRecovery {
+    #capability;
+    #platform;
+    #load;
+    #evidenceExists;
+    #clock;
+    #store;
+    #settleProof;
+    #executor;
+    #parallelRound;
+    #round;
+    #readTask;
+    constructor(dependencies) {
+        this.verifyFollow = this.verifyFollow.bind(this);
+        this.verifySubmission = this.verifySubmission.bind(this);
+        this.verifyPublishedPost = this.verifyPublishedPost.bind(this);
+        const { capability, platform, load, evidenceExists, clock, store, settleProof, executor, parallelRound, round, readTask, } = dependencies;
+        this.#capability = capability;
+        this.#platform = platform;
+        this.#load = load;
+        this.#evidenceExists = evidenceExists;
+        this.#clock = clock;
+        this.#store = store;
+        this.#settleProof = settleProof;
+        this.#executor = executor;
+        this.#parallelRound = parallelRound;
+        this.#round = round;
+        this.#readTask = readTask;
+    }
+    async verifyPublishedPost({ taskId, draftPath, publicURL, evidenceRef, sourceLink, }) {
+        // Read-only recovery of a single submitted original; never opens a composer.
+        const caps = this.#capability("read");
+        if (!caps.covered || typeof this.#platform.readPost !== "function")
+            return {
+                status: "needsCapability",
+                missing: ["platform.readPost", ...caps.missing],
+            };
+        const initial = await this.#load(taskId);
+        const action = initial.state.actions.find((a) => a.kind === "original" && a.draftPath === draftPath);
+        if (!action ||
+            !["intent", "unknown"].includes(action.status) ||
+            !this.#evidenceExists(evidenceRef))
+            throw new Error("submitted-original-and-public-proof-required");
+        const url = xURL(publicURL), postId = url.pathname.match(/\/status\/(\d+)$/)?.[1];
+        if (!postId ||
+            url.pathname.toLowerCase() !==
+                `/${action.accountHandle}/status/${postId}`.toLowerCase())
+            throw new Error("public-account-mismatch");
+        const observation = await this.#platform.readPost({
+            postId,
+            url: publicURL,
+            evidenceRef,
+        });
+        const trailing = action.text.match(/\n\n(https:\/\/\S+)$/);
+        const matches = (observation.posts ?? []).filter((p) => {
+            const exact = p.body === action.text;
+            const card = trailing &&
+                sourceLink &&
+                this.#evidenceExists(sourceLink.evidenceRef) &&
+                sourceLink.resolvedURL === trailing[1] &&
+                p.links?.includes(sourceLink.href) &&
+                p.body === action.text.slice(0, -trailing[0].length);
+            let renderedSource = false;
+            if (trailing &&
+                sourceLink?.renderedText &&
+                this.#evidenceExists(sourceLink.evidenceRef) &&
+                sourceLink.resolvedURL === trailing[1] &&
+                p.links?.includes(sourceLink.href)) {
+                try {
+                    renderedSource =
+                        new URL(sourceLink.renderedText.replace(/\s/g, "")).href ===
+                            sourceLink.resolvedURL &&
+                            p.body?.endsWith(sourceLink.renderedText) &&
+                            p.body.slice(0, -sourceLink.renderedText.length).trimEnd() ===
+                                action.text.slice(0, -trailing[0].length);
                 }
-                return (p.id === postId &&
-                    same(p.author, action.accountHandle) &&
-                    (exact || card || renderedSource) &&
-                    !p.needsExpansion &&
-                    !(action.beforeIds ?? []).includes(p.id) &&
-                    Date.parse(p.datetime) >= Date.parse(action.intentAt) &&
-                    Date.parse(p.datetime) <= clock() + 5000 &&
-                    (!action.assets?.length ||
-                        action.assets.every((a) => p.images?.some((i) => i.alt === a.alt))));
-            });
-            Object.assign(observation, {
-                verified: !observation.needsStateCheck &&
-                    !observation.alerts?.length &&
-                    matches.length === 1,
-                publicId: matches.length === 1 ? postId : null,
-                sourceLink,
-            });
-            return store.withLock(async () => {
-                const latest = await load(taskId), target = latest.state.actions.find((a) => a.id === action.id);
-                if (!["intent", "unknown"].includes(target?.status) ||
-                    target.intentAt !== action.intentAt ||
-                    target.text !== action.text)
-                    throw new Error("recovery-action-changed");
-                await settleProof(latest, target, observation, {
-                    preserveStatus: true,
-                });
-                return {
-                    status: observation.verified ? "verified" : "unknown",
-                    publicId: observation.publicId,
-                    taskId,
-                    actionId: action.id,
-                    mayEnd: false,
-                };
+                catch {
+                    /* Invalid rendered URL cannot verify publication. */
+                }
+            }
+            return (p.id === postId &&
+                same(p.author, action.accountHandle) &&
+                (exact || card || renderedSource) &&
+                !p.needsExpansion &&
+                !(action.beforeIds ?? []).includes(p.id) &&
+                Date.parse(p.datetime) >= Date.parse(action.intentAt) &&
+                Date.parse(p.datetime) <= this.#clock() + 5000 &&
+                (!action.assets?.length ||
+                    action.assets.every((a) => p.images?.some((i) => i.alt === a.alt))));
+        });
+        Object.assign(observation, {
+            verified: !observation.needsStateCheck &&
+                !observation.alerts?.length &&
+                matches.length === 1,
+            publicId: matches.length === 1 ? postId : null,
+            sourceLink,
+        });
+        return this.#store.withLock(async () => {
+            const latest = await this.#load(taskId), target = latest.state.actions.find((a) => a.id === action.id);
+            if (!["intent", "unknown"].includes(target?.status) ||
+                target.intentAt !== action.intentAt ||
+                target.text !== action.text)
+                throw new Error("recovery-action-changed");
+            await this.#settleProof(latest, target, observation, {
+                preserveStatus: true,
             });
-        },
-        verifySubmission: async ({ taskId, actionId }) => {
-            const snapshot = await load(taskId), action = snapshot.state.actions?.find((a) => a.id === actionId);
-            if (!action || !["intent", "unknown"].includes(action.status))
-                return {
-                    status: "needsDecision",
-                    reason: "verification-requires-original-unknown-or-intent",
-                    mayEnd: false,
-                };
-            return (executor ? parallelRound : round)({
+            return {
+                status: observation.verified ? "verified" : "unknown",
+                publicId: observation.publicId,
                 taskId,
-                requestedKind: action.kind,
-                selector: (a) => a.id === actionId,
-            });
-        },
-        verifyFollow: async (target) => {
-            const mode = target.mode ?? "receipt";
-            if (!["receipt", "decision"].includes(mode))
-                throw new Error("关注核验模式须为receipt/decision");
-            const caps = platform.preflight({ operation: "read" });
-            if (!caps.covered)
+                actionId: action.id,
+                mayEnd: false,
+            };
+        });
+    }
+    async verifySubmission({ taskId, actionId }) {
+        const executor = this.#executor;
+        const snapshot = await this.#load(taskId), action = snapshot.state.actions?.find((a) => a.id === actionId);
+        if (!action || !["intent", "unknown"].includes(action.status))
+            return {
+                status: "needsDecision",
+                reason: "verification-requires-original-unknown-or-intent",
+                mayEnd: false,
+            };
+        return (executor ? this.#parallelRound : this.#round)({
+            taskId,
+            requestedKind: action.kind,
+            selector: (a) => a.id === actionId,
+        });
+    }
+    async verifyFollow(target) {
+        const mode = target.mode ?? "receipt";
+        if (!["receipt", "decision"].includes(mode))
+            throw new Error("关注核验模式须为receipt/decision");
+        const caps = this.#platform.preflight({ operation: "read" });
+        if (!caps.covered)
+            return {
+                handle: target.handle,
+                verified: false,
+                status: "needsCapability",
+                ...caps,
+            };
+        if (!target.url || !target.evidenceRef) {
+            const original = (await this.#store.load()).state.actions?.find((a) => a.kind === "follow" && same(a.handle, target.handle));
+            if (!original)
                 return {
                     handle: target.handle,
                     verified: false,
-                    status: "needsCapability",
-                    ...caps,
+                    status: "needsDecision",
+                    reason: "original-person-observation-required",
                 };
-            if (!target.url || !target.evidenceRef) {
-                const original = (await store.load()).state.actions?.find((a) => a.kind === "follow" && same(a.handle, target.handle));
-                if (!original)
-                    return {
-                        handle: target.handle,
-                        verified: false,
-                        status: "needsDecision",
-                        reason: "original-person-observation-required",
-                    };
-                target = original;
-            }
-            const value = await readTask("readPerson", {
-                ...target,
-                mode: "decision",
-            });
-            return {
-                handle: target.handle,
-                status: value.status,
-                fresh: value.fresh,
-                verified: value.status === "observed" &&
-                    !value.needsStateCheck &&
-                    !value.alerts?.length &&
-                    value.relationship === "following" &&
-                    (!target.accountHandle ||
-                        same(value.accountHandle, target.accountHandle)),
-                ...(value.evidenceRef ? { evidenceRef: value.evidenceRef } : {}),
-                ...(value.missing?.length ? { missing: value.missing } : {}),
-                ...(value.diagnostic
-                    ? {
-                        diagnostic: {
-                            operation: value.diagnostic.operation,
-                            category: value.diagnostic.category,
-                            code: value.diagnostic.code,
-                        },
-                    }
-                    : {}),
-                ...(mode === "decision" ? { observation: value } : {}),
-            };
-        },
-    };
+            target = original;
+        }
+        const value = await this.#readTask("readPerson", {
+            ...target,
+            mode: "decision",
+        });
+        return {
+            handle: target.handle,
+            status: value.status,
+            fresh: value.fresh,
+            verified: value.status === "observed" &&
+                !value.needsStateCheck &&
+                !value.alerts?.length &&
+                value.relationship === "following" &&
+                (!target.accountHandle ||
+                    same(value.accountHandle, target.accountHandle)),
+            ...(value.evidenceRef ? { evidenceRef: value.evidenceRef } : {}),
+            ...(value.missing?.length ? { missing: value.missing } : {}),
+            ...(value.diagnostic
+                ? {
+                    diagnostic: {
+                        operation: value.diagnostic.operation,
+                        category: value.diagnostic.category,
+                        code: value.diagnostic.code,
+                    },
+                }
+                : {}),
+            ...(mode === "decision" ? { observation: value } : {}),
+        };
+    }
+}
+export function createGrowthRecovery(...args) {
+    return new GrowthRecovery(...args);
 }

package/dist/growth-state.d.ts

@@ -1,8 +1,16 @@
 import type { GrowthDependencies } from "./growth-dependencies.js";
-export declare function createGrowthState(dependencies: Pick<GrowthDependencies, "store" | "project" | "clock" | "evidenceExists" | "stamp" | "executor" | "waitBudget" | "platform" | "runtimeId" | "session">): {
+export declare class GrowthState {
+    #private;
     load: (taskId: any) => Promise<any>;
     save: (snapshot: any, state: any) => Promise<any>;
     result: (snapshot: any, needs?: any) => any;
     settleProof: (snapshot: any, action: any, observation: any, { preserveStatus }?: any) => Promise<any>;
     releaseSession: (taskId?: any) => Promise<any>;
-};
+    constructor(dependencies: Pick<GrowthDependencies, "store" | "project" | "clock" | "evidenceExists" | "stamp" | "executor" | "waitBudget" | "platform" | "runtimeId" | "session">);
+    private handleLoad;
+    private handleSave;
+    private handleResult;
+    private handleSettleProof;
+    private handleReleaseSession;
+}
+export declare function createGrowthState(...args: ConstructorParameters<typeof GrowthState>): GrowthState;

package/dist/growth-state.js

@@ -1,13 +1,45 @@
 import { checkRound } from "./round-state.js";
 import { kinds } from "./growth-constants.js";
-export function createGrowthState(dependencies) {
-    const { store, project, clock, evidenceExists, stamp, executor, waitBudget, platform, runtimeId, session, } = dependencies;
-    async function load(taskId) {
-        const snapshot = await store.load();
+export class GrowthState {
+    #store;
+    #project;
+    #clock;
+    #evidenceExists;
+    #stamp;
+    #executor;
+    #waitBudget;
+    #platform;
+    #runtimeId;
+    #session;
+    load;
+    save;
+    result;
+    settleProof;
+    releaseSession;
+    constructor(dependencies) {
+        const { store, project, clock, evidenceExists, stamp, executor, waitBudget, platform, runtimeId, session, } = dependencies;
+        this.#store = store;
+        this.#project = project;
+        this.#clock = clock;
+        this.#evidenceExists = evidenceExists;
+        this.#stamp = stamp;
+        this.#executor = executor;
+        this.#waitBudget = waitBudget;
+        this.#platform = platform;
+        this.#runtimeId = runtimeId;
+        this.#session = session;
+        this.load = this.handleLoad.bind(this);
+        this.save = this.handleSave.bind(this);
+        this.result = this.handleResult.bind(this);
+        this.settleProof = this.handleSettleProof.bind(this);
+        this.releaseSession = this.handleReleaseSession.bind(this);
+    }
+    async handleLoad(taskId) {
+        const snapshot = await this.#store.load();
         if (snapshot.state.batchId !== taskId)
             throw new Error("任务ID不是原台账当前批次");
         // Expired WAITING is actionable, not a malformed ledger. Validate structure separately from stopping.
-        const gate = checkRound({ ...project(snapshot.state), status: "RUNNING" }, { now: clock(), evidenceExists });
+        const gate = checkRound({ ...this.#project(snapshot.state), status: "RUNNING" }, { now: this.#clock(), evidenceExists: this.#evidenceExists });
         if (!gate.valid)
             throw new Error(`原轮次标记无效：${gate.errors.join("；")}`);
         const actions = snapshot.state.actions ?? [];
@@ -28,18 +60,19 @@ export function createGrowthState(dependencies) {
         }
         return snapshot;
     }
-    async function save(snapshot, state) {
-        state.updatedAt = stamp();
+    async handleSave(snapshot, state) {
+        const executor = this.#executor;
+        state.updatedAt = this.#stamp();
         if (!executor)
-            return store.save(snapshot, state);
+            return this.#store.save(snapshot, state);
         // Batch metadata still uses a short withLock transaction; it never contains browser I/O.
-        if (!session.claim)
-            return store.save(snapshot, state);
-        return store.transaction((latest) => {
-            const next = structuredClone(latest.state), before = snapshot.state.actions.find((a) => a.id === session.claim.actionId);
-            const entry = next.actions.find((a) => a.id === session.claim.actionId), after = state.actions.find((a) => a.id === session.claim.actionId);
+        if (!this.#session.claim)
+            return this.#store.save(snapshot, state);
+        return this.#store.transaction((latest) => {
+            const next = structuredClone(latest.state), before = snapshot.state.actions.find((a) => a.id === this.#session.claim.actionId);
+            const entry = next.actions.find((a) => a.id === this.#session.claim.actionId), after = state.actions.find((a) => a.id === this.#session.claim.actionId);
             if (next.batchId !== snapshot.state.batchId ||
-                entry?.claim?.token !== session.claim.token ||
+                entry?.claim?.token !== this.#session.claim.token ||
                 JSON.stringify({ ...entry, claim: undefined }) !==
                     JSON.stringify({ ...before, claim: undefined }))
                 throw new Error("action-claim-or-version-conflict");
@@ -49,7 +82,7 @@ export function createGrowthState(dependencies) {
             if (reservation) {
                 if (!item.actionable || item.verified + item.unknown >= item.planned)
                     throw new Error("shared-target-capacity-exhausted");
-                if (entry.kind === "follow" && waitBudget(next))
+                if (entry.kind === "follow" && this.#waitBudget(next))
                     throw new Error("shared-follow-budget-exhausted");
             }
             if (after.status === "verified" &&
@@ -91,7 +124,8 @@ export function createGrowthState(dependencies) {
                     next.execution ??= {};
                     const old = next.execution.followGroup;
                     next.execution.followGroup = {
-                        attempts: old?.attempts < 10 && clock() < Date.parse(old.lastAt) + 180000
+                        attempts: old?.attempts < 10 &&
+                            this.#clock() < Date.parse(old.lastAt) + 180000
                             ? old.attempts + 1
                             : 1,
                         lastAt: attempt.at,
@@ -99,14 +133,14 @@ export function createGrowthState(dependencies) {
                 }
             }
             next.status = "RUNNING";
-            next.updatedAt = stamp();
+            next.updatedAt = this.#stamp();
             return next;
         });
     }
-    function result(snapshot, needs = []) {
-        const gate = checkRound(project(snapshot.state), {
-            now: clock(),
-            evidenceExists,
+    handleResult(snapshot, needs = []) {
+        const gate = checkRound(this.#project(snapshot.state), {
+            now: this.#clock(),
+            evidenceExists: this.#evidenceExists,
         });
         return {
             status: gate.mayEnd
@@ -125,12 +159,12 @@ export function createGrowthState(dependencies) {
             ])),
             gaps: gate.pending,
             ...(needs.length ? { decision: needs } : {}),
-            evidenceRef: snapshot.path ?? store.path,
+            evidenceRef: snapshot.path ?? this.#store.path,
             ...(gate.errors.length ? { settlementErrors: gate.errors } : {}),
         };
     }
-    async function settleProof(snapshot, action, observation, { preserveStatus = false } = {}) {
-        const proof = await store.recordProof(await platform.captureProof({ observation }));
+    async handleSettleProof(snapshot, action, observation, { preserveStatus = false } = {}) {
+        const proof = await this.#store.recordProof(await this.#platform.captureProof({ observation }));
         const state = structuredClone(snapshot.state);
         const entry = state.actions.find((a) => a.id === action.id);
         const item = state.items.find((i) => i.kind === action.kind);
@@ -162,22 +196,25 @@ export function createGrowthState(dependencies) {
             throw new Error("结算越界：不覆盖原目标或重复计数");
         if (!preserveStatus)
             state.status = "RUNNING";
-        return save(snapshot, state);
+        return this.handleSave(snapshot, state);
     }
-    async function releaseSession(taskId = undefined) {
+    async handleReleaseSession(taskId = undefined) {
+        const executor = this.#executor;
         if (!executor)
             return;
-        await store.transaction((latest) => {
+        await this.#store.transaction((latest) => {
             const own = latest.state.executions?.[executor.id];
             if ((taskId && latest.state.batchId !== taskId) ||
-                own?.runtimeId !== runtimeId ||
+                own?.runtimeId !== this.#runtimeId ||
                 !own.activity)
                 return null;
             const next = structuredClone(latest.state);
             delete next.executions[executor.id].activity;
-            next.updatedAt = stamp();
+            next.updatedAt = this.#stamp();
             return next;
         });
     }
-    return { load, save, result, settleProof, releaseSession };
+}
+export function createGrowthState(...args) {
+    return new GrowthState(...args);
 }

package/dist/growth-tasks.d.ts

@@ -1,17 +1,20 @@
 import type { GrowthDependencies } from "./growth-dependencies.js";
-export declare function createGrowthTasks(dependencies: Pick<GrowthDependencies, "platform" | "capability" | "executor" | "readTask" | "parallelRound" | "round" | "load" | "result" | "publishIndependent" | "prepareActionsForCall">): {
-    preflight: ({ operation, input }: any) => any;
-    readCreator: (args: any) => Promise<any>;
-    inspectAccount: (args: any) => Promise<any>;
-    readPost: (args: any) => Promise<any>;
-    readPerson: (args: any) => Promise<any>;
-    readBookmarks: (args: any) => Promise<any>;
-    searchSources: (args: any) => Promise<any>;
-    readFeedback: (args: any) => Promise<any>;
-    runGrowthRound: (args: any) => Promise<any>;
-    resumeGrowthRound: (args: any) => Promise<any>;
-    inspectRound: ({ taskId }: any) => Promise<any>;
-    followOne: ({ taskId, handle }: any) => Promise<any>;
-    publishPost: (input: any) => Promise<any>;
-    replyToPost: ({ taskId, postId, text, preparedAction }: any) => Promise<any>;
-};
+export declare class GrowthTasks {
+    #private;
+    constructor(dependencies: Pick<GrowthDependencies, "platform" | "capability" | "executor" | "readTask" | "parallelRound" | "round" | "load" | "result" | "publishIndependent" | "prepareActionsForCall">);
+    preflight({ operation, input }: any): any;
+    readCreator(args: any): Promise<any>;
+    inspectAccount(args: any): Promise<any>;
+    readPost(args: any): Promise<any>;
+    readPerson(args: any): Promise<any>;
+    readBookmarks(args: any): Promise<any>;
+    searchSources(args: any): Promise<any>;
+    readFeedback(args: any): Promise<any>;
+    runGrowthRound(args: any): Promise<any>;
+    resumeGrowthRound(args: any): Promise<any>;
+    inspectRound({ taskId }: any): Promise<any>;
+    followOne({ taskId, handle }: any): Promise<any>;
+    publishPost(input: any): Promise<any>;
+    replyToPost({ taskId, postId, text, preparedAction }: any): Promise<any>;
+}
+export declare function createGrowthTasks(...args: ConstructorParameters<typeof GrowthTasks>): GrowthTasks;