@nextclaw/x-harness 0.1.1 → 0.2.1

package/dist/growth-tasks.js

@@ -1,101 +1,164 @@
 import { kinds, operations, same } from "./growth-constants.js";
-export function createGrowthTasks(dependencies) {
-    const { platform, capability, executor, readTask, parallelRound, round, load, result, publishIndependent, prepareActionsForCall, } = dependencies;
-    return {
-        preflight: ({ operation, input = {} }) => {
-            if (["readBookmarks", "searchSources", "readFeedback"].includes(operation))
-                return platform.preflight({ operation, input });
-            if (["inspectRound", "verifySubmission"].includes(operation))
-                return capability("read", input);
-            if (["inspectAccount", "verifyFollow"].includes(operation)) {
-                const name = operation === "verifyFollow" ? "readPerson" : "readAccount";
-                if (typeof platform?.preflight !== "function" ||
-                    typeof platform?.[name] !== "function")
-                    return {
-                        covered: false,
-                        missing: [name],
-                        owner: "scripts/x-harness-platform.mjs",
-                    };
-                return platform.preflight({ operation: "read", input });
-            }
-            if (["runGrowthRound", "resumeGrowthRound"].includes(operation)) {
-                const scoped = executor?.scopeKinds ?? input.scopeKinds ?? kinds;
-                if (!Array.isArray(scoped) ||
-                    !scoped.length ||
-                    scoped.some((k) => !kinds.includes(k)))
-                    return {
-                        covered: false,
-                        missing: ["scopeKinds"],
-                        owner: "scripts/x-growth-harness.mjs",
-                    };
-                const all = scoped.map((kind) => capability(operations[kind], { ...input, kind }));
+export class GrowthTasks {
+    #platform;
+    #capability;
+    #executor;
+    #readTask;
+    #parallelRound;
+    #round;
+    #load;
+    #result;
+    #publishIndependent;
+    #prepareActionsForCall;
+    constructor(dependencies) {
+        this.replyToPost = this.replyToPost.bind(this);
+        this.publishPost = this.publishPost.bind(this);
+        this.followOne = this.followOne.bind(this);
+        this.inspectRound = this.inspectRound.bind(this);
+        this.resumeGrowthRound = this.resumeGrowthRound.bind(this);
+        this.runGrowthRound = this.runGrowthRound.bind(this);
+        this.readFeedback = this.readFeedback.bind(this);
+        this.searchSources = this.searchSources.bind(this);
+        this.readBookmarks = this.readBookmarks.bind(this);
+        this.readPerson = this.readPerson.bind(this);
+        this.readPost = this.readPost.bind(this);
+        this.inspectAccount = this.inspectAccount.bind(this);
+        this.readCreator = this.readCreator.bind(this);
+        this.preflight = this.preflight.bind(this);
+        const { platform, capability, executor, readTask, parallelRound, round, load, result, publishIndependent, prepareActionsForCall, } = dependencies;
+        this.#platform = platform;
+        this.#capability = capability;
+        this.#executor = executor;
+        this.#readTask = readTask;
+        this.#parallelRound = parallelRound;
+        this.#round = round;
+        this.#load = load;
+        this.#result = result;
+        this.#publishIndependent = publishIndependent;
+        this.#prepareActionsForCall = prepareActionsForCall;
+    }
+    preflight({ operation, input = {} }) {
+        const executor = this.#executor;
+        if (["readBookmarks", "searchSources", "readFeedback"].includes(operation))
+            return this.#platform.preflight({ operation, input });
+        if (["inspectRound", "verifySubmission"].includes(operation))
+            return this.#capability("read", input);
+        if (["inspectAccount", "verifyFollow"].includes(operation)) {
+            const name = operation === "verifyFollow" ? "readPerson" : "readAccount";
+            if (typeof this.#platform?.preflight !== "function" ||
+                typeof this.#platform?.[name] !== "function")
                 return {
-                    covered: all.every((c) => c.covered),
-                    missing: [...new Set(all.flatMap((c) => c.missing))],
-                    owners: [
-                        ...new Set(all.filter((c) => !c.covered).map((c) => c.owner)),
-                    ],
+                    covered: false,
+                    missing: [name],
+                    owner: "scripts/x-harness-platform.mjs",
                 };
-            }
-            if (![
-                "read",
-                "followOne",
-                "followBatch",
-                "publishPost",
-                "replyToPost",
-                ...Object.values(operations),
-            ].includes(operation))
+            return this.#platform.preflight({ operation: "read", input });
+        }
+        if (["runGrowthRound", "resumeGrowthRound"].includes(operation)) {
+            const scoped = executor?.scopeKinds ?? input.scopeKinds ?? kinds;
+            if (!Array.isArray(scoped) ||
+                !scoped.length ||
+                scoped.some((k) => !kinds.includes(k)))
                 return {
                     covered: false,
-                    missing: [`operation.${operation}`],
+                    missing: ["scopeKinds"],
                     owner: "scripts/x-growth-harness.mjs",
                 };
-            return capability(operation, input);
-        },
-        readCreator: (args) => readTask("readCreator", args),
-        inspectAccount: (args) => readTask("readAccount", args),
-        readPost: (args) => readTask("readPost", { ...args, expand: true }),
-        readPerson: (args) => readTask("readPerson", args),
-        readBookmarks: (args) => readTask("readBookmarks", args),
-        searchSources: (args) => readTask("searchSources", args),
-        readFeedback: (args) => readTask("readFeedback", args),
-        runGrowthRound: (args) => executor ? parallelRound(args) : round(args),
-        resumeGrowthRound: (args) => executor ? parallelRound(args) : round(args),
-        inspectRound: async ({ taskId }) => {
-            const snapshot = await load(taskId);
-            return result(snapshot);
-        },
-        followOne: ({ taskId, handle }) => (executor ? parallelRound : round)({
+            const all = scoped.map((kind) => this.#capability(operations[kind], { ...input, kind }));
+            return {
+                covered: all.every((c) => c.covered),
+                missing: [...new Set(all.flatMap((c) => c.missing))],
+                owners: [
+                    ...new Set(all.filter((c) => !c.covered).map((c) => c.owner)),
+                ],
+            };
+        }
+        if (![
+            "read",
+            "followOne",
+            "followBatch",
+            "publishPost",
+            "replyToPost",
+            ...Object.values(operations),
+        ].includes(operation))
+            return {
+                covered: false,
+                missing: [`operation.${operation}`],
+                owner: "scripts/x-growth-harness.mjs",
+            };
+        return this.#capability(operation, input);
+    }
+    readCreator(args) {
+        return this.#readTask("readCreator", args);
+    }
+    inspectAccount(args) {
+        return this.#readTask("readAccount", args);
+    }
+    readPost(args) {
+        return this.#readTask("readPost", { ...args, expand: true });
+    }
+    readPerson(args) {
+        return this.#readTask("readPerson", args);
+    }
+    readBookmarks(args) {
+        return this.#readTask("readBookmarks", args);
+    }
+    searchSources(args) {
+        return this.#readTask("searchSources", args);
+    }
+    readFeedback(args) {
+        return this.#readTask("readFeedback", args);
+    }
+    runGrowthRound(args) {
+        const executor = this.#executor;
+        return executor ? this.#parallelRound(args) : this.#round(args);
+    }
+    resumeGrowthRound(args) {
+        const executor = this.#executor;
+        return executor ? this.#parallelRound(args) : this.#round(args);
+    }
+    async inspectRound({ taskId }) {
+        const snapshot = await this.#load(taskId);
+        return this.#result(snapshot);
+    }
+    followOne({ taskId, handle }) {
+        const executor = this.#executor;
+        return (executor ? this.#parallelRound : this.#round)({
             taskId,
             requestedKind: "follow",
             selector: (a) => a.kind === "follow" && same(a.handle, handle),
-        }),
-        publishPost: async (input) => {
-            if (!executor && input.independentExecution)
-                return publishIndependent(input);
-            if (input.preparedAction &&
-                (input.preparedAction.kind !== "original" ||
-                    input.preparedAction.draftPath !== input.draftPath))
-                throw new Error("prepared-original-target-mismatch");
-            await prepareActionsForCall(input.taskId, input.preparedAction ? [input.preparedAction] : []);
-            return (executor ? parallelRound : round)({
-                taskId: input.taskId,
-                requestedKind: "original",
-                selector: (a) => a.kind === "original" && a.draftPath === input.draftPath,
-            });
-        },
-        replyToPost: async ({ taskId, postId, text, preparedAction }) => {
-            if (preparedAction &&
-                (preparedAction.kind !== "reply" ||
-                    preparedAction.postId !== postId ||
-                    preparedAction.text !== text))
-                throw new Error("prepared-reply-target-mismatch");
-            await prepareActionsForCall(taskId, preparedAction ? [preparedAction] : []);
-            return (executor ? parallelRound : round)({
-                taskId,
-                requestedKind: "reply",
-                selector: (a) => a.kind === "reply" && a.postId === postId && a.text === text,
-            });
-        },
-    };
+        });
+    }
+    async publishPost(input) {
+        const executor = this.#executor;
+        if (!executor && input.independentExecution)
+            return this.#publishIndependent(input);
+        if (input.preparedAction &&
+            (input.preparedAction.kind !== "original" ||
+                input.preparedAction.draftPath !== input.draftPath))
+            throw new Error("prepared-original-target-mismatch");
+        await this.#prepareActionsForCall(input.taskId, input.preparedAction ? [input.preparedAction] : []);
+        return (executor ? this.#parallelRound : this.#round)({
+            taskId: input.taskId,
+            requestedKind: "original",
+            selector: (a) => a.kind === "original" && a.draftPath === input.draftPath,
+        });
+    }
+    async replyToPost({ taskId, postId, text, preparedAction }) {
+        const executor = this.#executor;
+        if (preparedAction &&
+            (preparedAction.kind !== "reply" ||
+                preparedAction.postId !== postId ||
+                preparedAction.text !== text))
+            throw new Error("prepared-reply-target-mismatch");
+        await this.#prepareActionsForCall(taskId, preparedAction ? [preparedAction] : []);
+        return (executor ? this.#parallelRound : this.#round)({
+            taskId,
+            requestedKind: "reply",
+            selector: (a) => a.kind === "reply" && a.postId === postId && a.text === text,
+        });
+    }
+}
+export function createGrowthTasks(...args) {
+    return new GrowthTasks(...args);
 }

package/dist/growth.d.ts

@@ -1,2 +1,26 @@
 /** Synchronous composition only; owners retain one original ledger and settlement path. */
-export declare function createGrowthHarness({ platform, store, clock, executor, }?: any): any;
+export declare class GrowthHarness {
+    #private;
+    verifyPublishedPost: ({ taskId, draftPath, publicURL, evidenceRef, sourceLink, }: any) => Promise<any>;
+    verifySubmission: ({ taskId, actionId }: any) => Promise<any>;
+    verifyFollow: (target: any) => Promise<any>;
+    followBatch: ({ taskId, handles, preparedActions, }?: any) => Promise<import("./boundary.js").BoundaryRecord>;
+    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>;
+    constructor({ platform, store, clock, executor, }?: any);
+    private composeTasks;
+    private stamp;
+}
+export declare function createGrowthHarness(...args: ConstructorParameters<typeof GrowthHarness>): any;

package/dist/growth.js

@@ -11,128 +11,211 @@ import { createGrowthRecovery } from "./growth-recovery.js";
 import { createFollowBatch } from "./growth-batch.js";
 import { createGrowthTasks } from "./growth-tasks.js";
 /** Synchronous composition only; owners retain one original ledger and settlement path. */
-export function createGrowthHarness({ platform, store, clock = () => Date.now(), executor, } = {}) {
-    const session = { claim: undefined, running: false };
-    const stamp = () => new Date(clock()).toISOString();
-    const evidenceExists = store.evidenceExists ?? (() => false);
-    const runtimeId = randomUUID();
-    if (executor &&
-        (!executor.id ||
-            !executor.tabId ||
-            !Array.isArray(executor.scopeKinds) ||
-            !executor.scopeKinds.length ||
-            new Set(executor.scopeKinds).size !== executor.scopeKinds.length ||
-            executor.scopeKinds.some((k) => !kinds.includes(k)) ||
-            !evidenceExists(executor.evidenceRef) ||
-            typeof store.transaction !== "function"))
-        throw new Error("并行执行者需ID、独立tab、有效职责及原合同证据与transaction");
-    const { authorizedWindow, scope, project, capability, waitBudget, guardInput, } = createGrowthPolicy({ executor, clock, evidenceExists, platform, store });
-    const { load, save, result, settleProof, releaseSession } = createGrowthState({
-        store,
-        project,
-        clock,
-        evidenceExists,
-        stamp,
-        executor,
-        waitBudget,
-        platform,
-        runtimeId,
-        session,
-    });
-    const { execute } = createGrowthExecution({
-        capability,
-        platform,
-        settleProof,
-        clock,
-        save,
-        guardInput,
-        waitBudget,
-        authorizedWindow,
-        stamp,
-        store,
-        executor,
-        session,
-    });
-    const { parallelRound } = createParallelRound({
-        load,
-        scope,
-        result,
-        store,
-        executor,
-        runtimeId,
-        stamp,
-        evidenceExists,
-        execute,
-        clock,
-        releaseSession,
-        session,
-    });
-    const { round } = createPlannedRound({
-        store,
-        load,
-        result,
-        evidenceExists,
-        save,
-        execute,
-        clock,
-        stamp,
-    });
-    const { publishIndependent, prepareActionsForCall } = createIndependentPublishing({
-        clock,
-        evidenceExists,
-        capability,
-        store,
-        load,
-        guardInput,
-        save,
-        platform,
-        stamp,
-        settleProof,
-    });
-    const { readTask } = createGrowthReading({
-        platform,
-        executor,
-        store,
-        runtimeId,
-        stamp,
-        releaseSession,
-        session,
-    });
-    const createGrowthRecoveryResult = createGrowthRecovery({
-        capability,
-        platform,
-        load,
-        evidenceExists,
-        clock,
-        store,
-        settleProof,
-        executor,
-        parallelRound,
-        round,
-        readTask,
-    });
-    const createFollowBatchResult = createFollowBatch({
-        prepareActionsForCall,
-        store,
-        scope,
-        stamp,
-        clock,
-        evidenceExists,
-        executor,
-        parallelRound,
-        round,
-    });
-    const createGrowthTasksResult = createGrowthTasks({
-        platform,
-        capability,
-        executor,
-        readTask,
-        parallelRound,
-        round,
-        load,
-        result,
-        publishIndependent,
-        prepareActionsForCall,
-    });
-    return Object.assign({}, createGrowthRecoveryResult, createFollowBatchResult, createGrowthTasksResult);
+export class GrowthHarness {
+    #platform;
+    #store;
+    #clock;
+    #executor;
+    #session;
+    #evidenceExists;
+    #runtimeId;
+    #authorizedWindow;
+    #scope;
+    #project;
+    #capability;
+    #waitBudget;
+    #guardInput;
+    #load;
+    #save;
+    #result;
+    #settleProof;
+    #releaseSession;
+    #execute;
+    #parallelRound;
+    #round;
+    #publishIndependent;
+    #prepareActionsForCall;
+    #readTask;
+    #createGrowthRecoveryResult;
+    #createFollowBatchResult;
+    #createGrowthTasksResult;
+    verifyPublishedPost;
+    verifySubmission;
+    verifyFollow;
+    followBatch;
+    preflight;
+    readCreator;
+    inspectAccount;
+    readPost;
+    readPerson;
+    readBookmarks;
+    searchSources;
+    readFeedback;
+    runGrowthRound;
+    resumeGrowthRound;
+    inspectRound;
+    followOne;
+    publishPost;
+    replyToPost;
+    constructor({ platform, store, clock = () => Date.now(), executor, } = {}) {
+        this.#platform = platform;
+        this.#store = store;
+        this.#clock = clock;
+        this.#executor = executor;
+        this.#session = { claim: undefined, running: false };
+        this.#evidenceExists = this.#store.evidenceExists ?? (() => false);
+        this.#runtimeId = randomUUID();
+        if (this.#executor &&
+            (!this.#executor.id ||
+                !this.#executor.tabId ||
+                !Array.isArray(this.#executor.scopeKinds) ||
+                !this.#executor.scopeKinds.length ||
+                new Set(this.#executor.scopeKinds).size !==
+                    this.#executor.scopeKinds.length ||
+                this.#executor.scopeKinds.some((k) => !kinds.includes(k)) ||
+                !this.#evidenceExists(this.#executor.evidenceRef) ||
+                typeof this.#store.transaction !== "function"))
+            throw new Error("并行执行者需ID、独立tab、有效职责及原合同证据与transaction");
+        const { authorizedWindow, scope, project, capability, waitBudget, guardInput, } = createGrowthPolicy({
+            executor: this.#executor,
+            clock: this.#clock,
+            evidenceExists: this.#evidenceExists,
+            platform: this.#platform,
+            store: this.#store,
+        });
+        this.#authorizedWindow = authorizedWindow;
+        this.#scope = scope;
+        this.#project = project;
+        this.#capability = capability;
+        this.#waitBudget = waitBudget;
+        this.#guardInput = guardInput;
+        const { load, save, result, settleProof, releaseSession } = createGrowthState({
+            store: this.#store,
+            project: this.#project,
+            clock: this.#clock,
+            evidenceExists: this.#evidenceExists,
+            stamp: this.stamp.bind(this),
+            executor: this.#executor,
+            waitBudget: this.#waitBudget,
+            platform: this.#platform,
+            runtimeId: this.#runtimeId,
+            session: this.#session,
+        });
+        this.#load = load;
+        this.#save = save;
+        this.#result = result;
+        this.#settleProof = settleProof;
+        this.#releaseSession = releaseSession;
+        const { execute } = createGrowthExecution({
+            capability: this.#capability,
+            platform: this.#platform,
+            settleProof: this.#settleProof,
+            clock: this.#clock,
+            save: this.#save,
+            guardInput: this.#guardInput,
+            waitBudget: this.#waitBudget,
+            authorizedWindow: this.#authorizedWindow,
+            stamp: this.stamp.bind(this),
+            store: this.#store,
+            executor: this.#executor,
+            session: this.#session,
+        });
+        this.#execute = execute;
+        const { parallelRound } = createParallelRound({
+            load: this.#load,
+            scope: this.#scope,
+            result: this.#result,
+            store: this.#store,
+            executor: this.#executor,
+            runtimeId: this.#runtimeId,
+            stamp: this.stamp.bind(this),
+            evidenceExists: this.#evidenceExists,
+            execute: this.#execute,
+            clock: this.#clock,
+            releaseSession: this.#releaseSession,
+            session: this.#session,
+        });
+        this.#parallelRound = parallelRound;
+        const { round } = createPlannedRound({
+            store: this.#store,
+            load: this.#load,
+            result: this.#result,
+            evidenceExists: this.#evidenceExists,
+            save: this.#save,
+            execute: this.#execute,
+            clock: this.#clock,
+            stamp: this.stamp.bind(this),
+        });
+        this.#round = round;
+        const { publishIndependent, prepareActionsForCall } = createIndependentPublishing({
+            clock: this.#clock,
+            evidenceExists: this.#evidenceExists,
+            capability: this.#capability,
+            store: this.#store,
+            load: this.#load,
+            guardInput: this.#guardInput,
+            save: this.#save,
+            platform: this.#platform,
+            stamp: this.stamp.bind(this),
+            settleProof: this.#settleProof,
+        });
+        this.#publishIndependent = publishIndependent;
+        this.#prepareActionsForCall = prepareActionsForCall;
+        const { readTask } = createGrowthReading({
+            platform: this.#platform,
+            executor: this.#executor,
+            store: this.#store,
+            runtimeId: this.#runtimeId,
+            stamp: this.stamp.bind(this),
+            releaseSession: this.#releaseSession,
+            session: this.#session,
+        });
+        this.#readTask = readTask;
+        this.composeTasks();
+    }
+    composeTasks() {
+        this.#createGrowthRecoveryResult = createGrowthRecovery({
+            capability: this.#capability,
+            platform: this.#platform,
+            load: this.#load,
+            evidenceExists: this.#evidenceExists,
+            clock: this.#clock,
+            store: this.#store,
+            settleProof: this.#settleProof,
+            executor: this.#executor,
+            parallelRound: this.#parallelRound,
+            round: this.#round,
+            readTask: this.#readTask,
+        });
+        this.#createFollowBatchResult = createFollowBatch({
+            prepareActionsForCall: this.#prepareActionsForCall,
+            store: this.#store,
+            scope: this.#scope,
+            stamp: this.stamp.bind(this),
+            clock: this.#clock,
+            evidenceExists: this.#evidenceExists,
+            executor: this.#executor,
+            parallelRound: this.#parallelRound,
+            round: this.#round,
+        });
+        this.#createGrowthTasksResult = createGrowthTasks({
+            platform: this.#platform,
+            capability: this.#capability,
+            executor: this.#executor,
+            readTask: this.#readTask,
+            parallelRound: this.#parallelRound,
+            round: this.#round,
+            load: this.#load,
+            result: this.#result,
+            publishIndependent: this.#publishIndependent,
+            prepareActionsForCall: this.#prepareActionsForCall,
+        });
+        Object.assign(this, Object.assign({}, this.#createGrowthRecoveryResult, this.#createFollowBatchResult, this.#createGrowthTasksResult));
+    }
+    stamp() {
+        return new Date(this.#clock()).toISOString();
+    }
+}
+export function createGrowthHarness(...args) {
+    return new GrowthHarness(...args);
 }

package/dist/platform-capabilities.d.ts

@@ -1,4 +1,8 @@
 import type { PlatformDependencies } from "./platform-dependencies.js";
-export declare function createPlatformCapabilities(dependencies: Pick<PlatformDependencies, "missing" | "browser">): {
+export declare class PlatformCapabilities {
+    #private;
     preflight: ({ operation, input }: any) => any;
-};
+    constructor(dependencies: Pick<PlatformDependencies, "missing" | "browser">);
+    private handlePreflight;
+}
+export declare function createPlatformCapabilities(...args: ConstructorParameters<typeof PlatformCapabilities>): PlatformCapabilities;