@nextclaw/x-harness 0.1.1 → 0.2.1

package/dist/growth-batch.js

@@ -1,144 +1,166 @@
 import { followWindows, same } from "./growth-constants.js";
-export function createFollowBatch(dependencies) {
-    const { prepareActionsForCall, store, scope, stamp, clock, evidenceExists, executor, parallelRound, round, } = dependencies;
-    return {
-        followBatch: async ({ taskId, handles, preparedActions } = {}) => {
-            if (!Array.isArray(handles) ||
-                handles.length < 5 ||
-                handles.length > 10 ||
-                handles.some((h) => !/^[A-Za-z0-9_]{1,15}$/.test(h)) ||
-                new Set(handles.map((h) => h.toLowerCase())).size !==
-                    handles.length)
-                throw new Error("正常关注子批需5～10位不同的已准备对象");
-            if (preparedActions?.some((a) => a.kind !== "follow" ||
-                !handles.some((h) => same(h, a.handle))))
-                throw new Error("batch-action-target-mismatch");
-            await prepareActionsForCall(taskId, preparedActions);
-            let batchId, resumedBatch = false;
-            const original = await store.transaction(async (snapshot) => {
-                if (!scope(snapshot.state).includes("follow"))
-                    throw new Error("kind-outside-round-scope");
-                if (snapshot.state.batchId !== taskId ||
-                    handles.some((h) => !snapshot.state.actions?.some((a) => a.kind === "follow" && same(a.handle, h))))
-                    throw new Error("子批名单必须归原任务队列");
-                const next = structuredClone(snapshot.state);
-                next.followBatches ??= [];
-                const previous = next.followBatches.findLast((b) => b.status !== "SETTLED" &&
-                    b.handles.length === handles.length &&
-                    b.handles.every((h, i) => same(h, handles[i])));
-                resumedBatch = Boolean(previous);
-                batchId = previous?.id ?? `${taskId}-FOLLOW-${stamp()}`;
-                if (previous)
-                    Object.assign(previous, {
-                        status: "RUNNING",
-                        lastResumedAt: stamp(),
-                    });
-                else
-                    next.followBatches.push({
-                        id: batchId,
-                        handles,
-                        planned: handles.length,
-                        startedAt: stamp(),
-                        status: "RUNNING",
-                    });
-                next.updatedAt = stamp();
-                return next;
-            });
-            const preparedCount = original.state.actions.filter((a) => a.kind === "follow" &&
-                a.status === "prepared" &&
-                handles.some((h) => same(h, a.handle))).length;
-            let eligibleAt = clock();
-            const previousGroup = original.state.execution?.followGroup;
-            const lastAttempt = (original.state.attempts ?? [])
-                .filter((a) => a.kind === "follow")
-                .sort((a, b) => Date.parse(a.at) - Date.parse(b.at))
-                .at(-1);
-            const lastAction = original.state.actions.find((a) => a.id === lastAttempt?.actionId);
-            const sameBatchRecovery = resumedBatch &&
-                lastAction?.status === "verified" &&
-                evidenceExists(lastAction.resultEvidence) &&
-                handles.some((h) => same(h, lastAction.handle));
-            if (preparedCount && previousGroup?.attempts && !sameBatchRecovery)
-                eligibleAt = Math.max(eligibleAt, Date.parse(previousGroup.lastAt) + 180000);
-            for (const [duration, limit] of followWindows) {
-                const recent = (original.state.attempts ?? [])
-                    .filter((a) => a.kind === "follow" && Date.parse(a.at) > clock() - duration)
-                    .sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
-                if (preparedCount > limit - recent.length)
-                    eligibleAt = Math.max(eligibleAt, Date.parse(recent[recent.length - limit + preparedCount - 1].at) +
-                        duration);
-            }
-            if (eligibleAt > clock()) {
-                const resumeAt = new Date(eligibleAt).toISOString();
-                await store.transaction((snapshot) => {
-                    const next = structuredClone(snapshot.state);
-                    Object.assign(next.followBatches.find((b) => b.id === batchId), { status: "WAITING", remaining: preparedCount, resumeAt });
-                    next.updatedAt = stamp();
-                    return next;
+export class FollowBatch {
+    #prepareActionsForCall;
+    #store;
+    #scope;
+    #stamp;
+    #clock;
+    #evidenceExists;
+    #executor;
+    #parallelRound;
+    #round;
+    constructor(dependencies) {
+        this.followBatch = this.followBatch.bind(this);
+        const { prepareActionsForCall, store, scope, stamp, clock, evidenceExists, executor, parallelRound, round, } = dependencies;
+        this.#prepareActionsForCall = prepareActionsForCall;
+        this.#store = store;
+        this.#scope = scope;
+        this.#stamp = stamp;
+        this.#clock = clock;
+        this.#evidenceExists = evidenceExists;
+        this.#executor = executor;
+        this.#parallelRound = parallelRound;
+        this.#round = round;
+    }
+    async followBatch({ taskId, handles, preparedActions } = {}) {
+        const executor = this.#executor;
+        if (!Array.isArray(handles) ||
+            handles.length < 5 ||
+            handles.length > 10 ||
+            handles.some((h) => !/^[A-Za-z0-9_]{1,15}$/.test(h)) ||
+            new Set(handles.map((h) => h.toLowerCase())).size !== handles.length)
+            throw new Error("正常关注子批需5～10位不同的已准备对象");
+        if (preparedActions?.some((a) => a.kind !== "follow" ||
+            !handles.some((h) => same(h, a.handle))))
+            throw new Error("batch-action-target-mismatch");
+        await this.#prepareActionsForCall(taskId, preparedActions);
+        let batchId, resumedBatch = false;
+        const original = await this.#store.transaction(async (snapshot) => {
+            if (!this.#scope(snapshot.state).includes("follow"))
+                throw new Error("kind-outside-round-scope");
+            if (snapshot.state.batchId !== taskId ||
+                handles.some((h) => !snapshot.state.actions?.some((a) => a.kind === "follow" && same(a.handle, h))))
+                throw new Error("子批名单必须归原任务队列");
+            const next = structuredClone(snapshot.state);
+            next.followBatches ??= [];
+            const previous = next.followBatches.findLast((b) => b.status !== "SETTLED" &&
+                b.handles.length === handles.length &&
+                b.handles.every((h, i) => same(h, handles[i])));
+            resumedBatch = Boolean(previous);
+            batchId = previous?.id ?? `${taskId}-FOLLOW-${this.#stamp()}`;
+            if (previous)
+                Object.assign(previous, {
+                    status: "RUNNING",
+                    lastResumedAt: this.#stamp(),
                 });
-                return {
-                    taskId,
-                    batchId,
+            else
+                next.followBatches.push({
+                    id: batchId,
+                    handles,
                     planned: handles.length,
-                    attempted: 0,
-                    verifiedThisCall: 0,
-                    unknownInBatch: original.state.actions.filter((a) => handles.some((h) => same(h, a.handle)) &&
-                        ["unknown", "intent"].includes(a.status)).length,
-                    remaining: preparedCount,
-                    mayEnd: false,
-                    decision: [
-                        {
-                            kind: "follow",
-                            status: "waiting",
-                            reason: "normal-batch-capacity-or-cooldown",
-                            resumeAt,
-                        },
-                    ],
-                    evidenceRef: store.path,
-                };
-            }
-            let result;
-            const exceptional = [];
-            for (const handle of handles) {
-                // A resumed batch submits only its remaining prepared members. Recovery
-                // stays in the read-only API; a frozen member must not disturb that path.
-                if (!original.state.actions.some((a) => a.kind === "follow" &&
-                    same(a.handle, handle) &&
-                    a.status === "prepared"))
-                    continue;
-                result = await (executor ? parallelRound : round)({
-                    taskId,
-                    requestedKind: "follow",
-                    selector: (a) => a.kind === "follow" && same(a.handle, handle),
-                });
-                const relevant = (result.decision ?? []).filter((d) => d.kind === "follow" ||
-                    ["harness-boundary-error", "original-ledger-conflict"].includes(d.reason) ||
-                    original.state.actions.some((a) => a.id === d.actionId && a.kind === "follow"));
-                exceptional.push(...relevant);
-                // A new unconfirmed submission is a diagnostic boundary, not permission
-                // to consume the rest of the batch on the same failing write path.
-                if (relevant.length)
-                    break;
-            }
-            const after = await store.load();
-            const summary = summarizeFollowBatch(taskId, batchId, handles, after, original, result, exceptional, store.path);
-            await store.transaction((snapshot) => {
-                const next = structuredClone(snapshot.state), batch = next.followBatches.find((b) => b.id === batchId);
-                Object.assign(batch, {
-                    attempted: (batch.attempted ?? 0) + summary.attempted,
-                    verifiedTotal: (batch.verifiedTotal ?? 0) + summary.verifiedThisCall,
-                    verifiedThisCall: summary.verifiedThisCall,
-                    unknown: summary.unknownInBatch,
-                    remaining: summary.remaining,
-                    finishedAt: stamp(),
-                    status: summary.remaining || summary.unknownInBatch ? "PARTIAL" : "SETTLED",
+                    startedAt: this.#stamp(),
+                    status: "RUNNING",
                 });
-                next.updatedAt = stamp();
+            next.updatedAt = this.#stamp();
+            return next;
+        });
+        const preparedCount = original.state.actions.filter((a) => a.kind === "follow" &&
+            a.status === "prepared" &&
+            handles.some((h) => same(h, a.handle))).length;
+        let eligibleAt = this.#clock();
+        const previousGroup = original.state.execution?.followGroup;
+        const lastAttempt = (original.state.attempts ?? [])
+            .filter((a) => a.kind === "follow")
+            .sort((a, b) => Date.parse(a.at) - Date.parse(b.at))
+            .at(-1);
+        const lastAction = original.state.actions.find((a) => a.id === lastAttempt?.actionId);
+        const sameBatchRecovery = resumedBatch &&
+            lastAction?.status === "verified" &&
+            this.#evidenceExists(lastAction.resultEvidence) &&
+            handles.some((h) => same(h, lastAction.handle));
+        if (preparedCount && previousGroup?.attempts && !sameBatchRecovery)
+            eligibleAt = Math.max(eligibleAt, Date.parse(previousGroup.lastAt) + 180000);
+        for (const [duration, limit] of followWindows) {
+            const recent = (original.state.attempts ?? [])
+                .filter((a) => a.kind === "follow" && Date.parse(a.at) > this.#clock() - duration)
+                .sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+            if (preparedCount > limit - recent.length)
+                eligibleAt = Math.max(eligibleAt, Date.parse(recent[recent.length - limit + preparedCount - 1].at) +
+                    duration);
+        }
+        if (eligibleAt > this.#clock()) {
+            const resumeAt = new Date(eligibleAt).toISOString();
+            await this.#store.transaction((snapshot) => {
+                const next = structuredClone(snapshot.state);
+                Object.assign(next.followBatches.find((b) => b.id === batchId), { status: "WAITING", remaining: preparedCount, resumeAt });
+                next.updatedAt = this.#stamp();
                 return next;
             });
-            return summary;
-        },
-    };
+            return {
+                taskId,
+                batchId,
+                planned: handles.length,
+                attempted: 0,
+                verifiedThisCall: 0,
+                unknownInBatch: original.state.actions.filter((a) => handles.some((h) => same(h, a.handle)) &&
+                    ["unknown", "intent"].includes(a.status)).length,
+                remaining: preparedCount,
+                mayEnd: false,
+                decision: [
+                    {
+                        kind: "follow",
+                        status: "waiting",
+                        reason: "normal-batch-capacity-or-cooldown",
+                        resumeAt,
+                    },
+                ],
+                evidenceRef: this.#store.path,
+            };
+        }
+        let result;
+        const exceptional = [];
+        for (const handle of handles) {
+            // A resumed batch submits only its remaining prepared members. Recovery
+            // stays in the read-only API; a frozen member must not disturb that path.
+            if (!original.state.actions.some((a) => a.kind === "follow" &&
+                same(a.handle, handle) &&
+                a.status === "prepared"))
+                continue;
+            result = await (executor ? this.#parallelRound : this.#round)({
+                taskId,
+                requestedKind: "follow",
+                selector: (a) => a.kind === "follow" && same(a.handle, handle),
+            });
+            const relevant = (result.decision ?? []).filter((d) => d.kind === "follow" ||
+                ["harness-boundary-error", "original-ledger-conflict"].includes(d.reason) ||
+                original.state.actions.some((a) => a.id === d.actionId && a.kind === "follow"));
+            exceptional.push(...relevant);
+            // A new unconfirmed submission is a diagnostic boundary, not permission
+            // to consume the rest of the batch on the same failing write path.
+            if (relevant.length)
+                break;
+        }
+        const after = await this.#store.load();
+        const summary = summarizeFollowBatch(taskId, batchId, handles, after, original, result, exceptional, this.#store.path);
+        await this.#store.transaction((snapshot) => {
+            const next = structuredClone(snapshot.state), batch = next.followBatches.find((b) => b.id === batchId);
+            Object.assign(batch, {
+                attempted: (batch.attempted ?? 0) + summary.attempted,
+                verifiedTotal: (batch.verifiedTotal ?? 0) + summary.verifiedThisCall,
+                verifiedThisCall: summary.verifiedThisCall,
+                unknown: summary.unknownInBatch,
+                remaining: summary.remaining,
+                finishedAt: this.#stamp(),
+                status: summary.remaining || summary.unknownInBatch ? "PARTIAL" : "SETTLED",
+            });
+            next.updatedAt = this.#stamp();
+            return next;
+        });
+        return summary;
+    }
+}
+export function createFollowBatch(...args) {
+    return new FollowBatch(...args);
 }
 function summarizeFollowBatch(taskId, batchId, handles, after, original, result, exceptional, evidenceRef) {
     return {

package/dist/growth-dependencies.js

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

package/dist/growth-execution.d.ts

@@ -5,7 +5,13 @@ interface ExecutionStep {
     need: BoundaryRecord | null;
 }
 import type { GrowthDependencies } from "./growth-dependencies.js";
-export declare function createGrowthExecution(dependencies: Pick<GrowthDependencies, "capability" | "platform" | "settleProof" | "clock" | "save" | "guardInput" | "waitBudget" | "authorizedWindow" | "stamp" | "store" | "executor" | "session">): {
+export declare class GrowthExecution {
+    #private;
     execute: (snapshot: any, action: any) => Promise<ExecutionStep>;
-};
+    constructor(dependencies: Pick<GrowthDependencies, "capability" | "platform" | "settleProof" | "clock" | "save" | "guardInput" | "waitBudget" | "authorizedWindow" | "stamp" | "store" | "executor" | "session">);
+    private checkExecutionIdentity;
+    private admitAction;
+    private handleExecute;
+}
+export declare function createGrowthExecution(...args: ConstructorParameters<typeof GrowthExecution>): GrowthExecution;
 export {};

package/dist/growth-execution.js

@@ -1,11 +1,39 @@
 import { operations, same } from "./growth-constants.js";
-export function createGrowthExecution(dependencies) {
-    const { capability, platform, settleProof, clock, save, guardInput, waitBudget, authorizedWindow, stamp, store, executor, session, } = dependencies;
-    async function checkExecutionIdentity(snapshot, action) {
+export class GrowthExecution {
+    #capability;
+    #platform;
+    #settleProof;
+    #clock;
+    #save;
+    #guardInput;
+    #waitBudget;
+    #authorizedWindow;
+    #stamp;
+    #store;
+    #executor;
+    #session;
+    execute;
+    constructor(dependencies) {
+        const { capability, platform, settleProof, clock, save, guardInput, waitBudget, authorizedWindow, stamp, store, executor, session, } = dependencies;
+        this.#capability = capability;
+        this.#platform = platform;
+        this.#settleProof = settleProof;
+        this.#clock = clock;
+        this.#save = save;
+        this.#guardInput = guardInput;
+        this.#waitBudget = waitBudget;
+        this.#authorizedWindow = authorizedWindow;
+        this.#stamp = stamp;
+        this.#store = store;
+        this.#executor = executor;
+        this.#session = session;
+        this.execute = this.handleExecute.bind(this);
+    }
+    async checkExecutionIdentity(snapshot, action) {
         const state = snapshot.state;
         let own;
         try {
-            own = await platform.readAccount();
+            own = await this.#platform.readAccount();
         }
         catch (error) {
             return {
@@ -31,7 +59,7 @@ export function createGrowthExecution(dependencies) {
             };
         return null;
     }
-    async function admitAction(snapshot, action) {
+    async admitAction(snapshot, action) {
         const state = snapshot.state;
         const item = state.items.find((i) => i.kind === action.kind);
         if (!item.actionable)
@@ -43,7 +71,7 @@ export function createGrowthExecution(dependencies) {
                     reason: item.reason ?? "original-kind-not-actionable",
                 },
             };
-        const inputError = guardInput(state, action);
+        const inputError = this.#guardInput(state, action);
         if (inputError)
             return {
                 snapshot,
@@ -53,16 +81,16 @@ export function createGrowthExecution(dependencies) {
                     reason: inputError,
                 },
             };
-        const identity = await checkExecutionIdentity(snapshot, action);
+        const identity = await this.checkExecutionIdentity(snapshot, action);
         if (identity)
             return identity;
         if (action.kind === "follow") {
-            const budget = waitBudget(state);
+            const budget = this.#waitBudget(state);
             if (budget)
                 return { snapshot, need: { ...budget, actionId: action.id } };
             let value;
             try {
-                value = await platform.readPerson(action);
+                value = await this.#platform.readPerson(action);
             }
             catch (error) {
                 return {
@@ -100,7 +128,7 @@ export function createGrowthExecution(dependencies) {
                 const next = structuredClone(state);
                 next.actions.find((a) => a.id === action.id).status =
                     "preexisting";
-                return { snapshot: await save(snapshot, next), need: null };
+                return { snapshot: await this.#save(snapshot, next), need: null };
             }
         }
         else {
@@ -108,9 +136,9 @@ export function createGrowthExecution(dependencies) {
                 timeZone: "Asia/Shanghai",
                 hour: "2-digit",
                 hourCycle: "h23",
-            }).format(clock()));
+            }).format(this.#clock()));
             if ((hour < 7 || hour >= (action.kind === "reply" ? 24 : 22)) &&
-                !authorizedWindow(state, action.kind))
+                !this.#authorizedWindow(state, action.kind))
                 return {
                     snapshot,
                     need: {
@@ -124,9 +152,9 @@ export function createGrowthExecution(dependencies) {
         if (action.kind !== "follow") {
             let baseline;
             try {
-                baseline = await platform.findSubmission({
+                baseline = await this.#platform.findSubmission({
                     ...action,
-                    intentAt: stamp(),
+                    intentAt: this.#stamp(),
                 });
             }
             catch (error) {
@@ -153,9 +181,10 @@ export function createGrowthExecution(dependencies) {
         }
         return { beforeIds };
     }
-    async function execute(snapshot, action) {
+    async handleExecute(snapshot, action) {
+        const executor = this.#executor;
         const recovering = ["intent", "unknown"].includes(action.status);
-        const caps = capability(recovering ? "read" : operations[action.kind], action);
+        const caps = this.#capability(recovering ? "read" : operations[action.kind], action);
         if (!caps.covered)
             return {
                 snapshot,
@@ -165,7 +194,7 @@ export function createGrowthExecution(dependencies) {
         if (recovering) {
             let observation;
             try {
-                observation = await platform.findSubmission(action);
+                observation = await this.#platform.findSubmission(action);
             }
             catch (error) {
                 observation = {
@@ -174,7 +203,7 @@ export function createGrowthExecution(dependencies) {
                     error: error.message.slice(0, 240),
                 };
             }
-            snapshot = await settleProof(snapshot, action, observation);
+            snapshot = await this.#settleProof(snapshot, action, observation);
             return {
                 snapshot,
                 need: observation.verified
@@ -190,7 +219,7 @@ export function createGrowthExecution(dependencies) {
         if (snapshot.state.items
             .find((i) => i.kind === action.kind)
             .reason?.startsWith("harness:") &&
-            Date.parse(snapshot.state.items.find((i) => i.kind === action.kind).resumeAt) <= clock()) {
+            Date.parse(snapshot.state.items.find((i) => i.kind === action.kind).resumeAt) <= this.#clock()) {
             const next = structuredClone(snapshot.state), pending = next.items.find((i) => i.kind === action.kind);
             pending.actionable = true;
             delete pending.reason;
@@ -198,9 +227,9 @@ export function createGrowthExecution(dependencies) {
             delete pending.resumeWhen;
             delete pending.blockEvidence;
             next.status = "RUNNING";
-            snapshot = await save(snapshot, next);
+            snapshot = await this.#save(snapshot, next);
         }
-        const admission = await admitAction(snapshot, action);
+        const admission = await this.admitAction(snapshot, action);
         if ("snapshot" in admission)
             return admission;
         const { beforeIds } = admission;
@@ -209,7 +238,7 @@ export function createGrowthExecution(dependencies) {
         const next = structuredClone(state);
         const entry = next.actions.find((a) => a.id === action.id);
         entry.status = "intent";
-        entry.intentAt = stamp();
+        entry.intentAt = this.#stamp();
         entry.beforeIds = beforeIds;
         next.items.find((i) => i.kind === action.kind).unknown += 1;
         next.attempts ??= [];
@@ -222,57 +251,57 @@ export function createGrowthExecution(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: entry.intentAt,
             };
         }
-        snapshot = await save(snapshot, next);
+        snapshot = await this.#save(snapshot, next);
         let observation, submissionMayHaveStarted = false;
         try {
-            await platform[operations[action.kind]]({
+            await this.#platform[operations[action.kind]]({
                 ...entry,
                 beforeSubmit: async () => {
-                    const latest = await store.load();
+                    const latest = await this.#store.load();
                     if (executor) {
                         const current = latest.state.actions.find((a) => a.id === entry.id);
                         if (latest.state.batchId !== snapshot.state.batchId ||
-                            current?.claim?.token !== session.claim.token ||
+                            current?.claim?.token !== this.#session.claim.token ||
                             JSON.stringify(current) !==
                                 JSON.stringify(snapshot.state.actions.find((a) => a.id === entry.id)))
                             throw new Error("提交前本动作或claim变化");
                     }
                     else if (latest.revision !== snapshot.revision)
                         throw new Error("提交前原台账变化，保留intent并重核执行权");
-                    const inputError = guardInput(latest.state, latest.state.actions.find((a) => a.id === entry.id));
+                    const inputError = this.#guardInput(latest.state, latest.state.actions.find((a) => a.id === entry.id));
                     if (inputError)
                         throw new Error(inputError);
                     const hour = Number(new Intl.DateTimeFormat("en-GB", {
                         timeZone: "Asia/Shanghai",
                         hour: "2-digit",
                         hourCycle: "h23",
-                    }).format(clock()));
+                    }).format(this.#clock()));
                     if ((hour < 7 || hour >= (action.kind === "reply" ? 24 : 22)) &&
-                        !authorizedWindow(latest.state, action.kind))
+                        !this.#authorizedWindow(latest.state, action.kind))
                         throw new Error("实际提交时已越过运营窗口");
                     if (action.kind === "follow") {
                         const check = structuredClone(latest.state);
                         check.attempts = check.attempts.filter((a) => a.actionId !== entry.id);
                         if (check.execution.followGroup)
                             check.execution.followGroup.attempts -= 1;
-                        if (waitBudget(check))
+                        if (this.#waitBudget(check))
                             throw new Error("实际提交前关注预算不再可用");
                     }
                     submissionMayHaveStarted = true;
                 },
             });
-            observation = await platform.findSubmission(entry);
+            observation = await this.#platform.findSubmission(entry);
         }
         catch (error) {
             if (!submissionMayHaveStarted) {
-                const proof = await store.recordProof({
-                    capturedAt: stamp(),
+                const proof = await this.#store.recordProof({
+                    capturedAt: this.#stamp(),
                     submissionStarted: false,
                     error: error.message.slice(0, 240),
                 });
@@ -280,7 +309,7 @@ export function createGrowthExecution(dependencies) {
                 target.status = "prepared";
                 target.preparationEvidence = proof;
                 unsubmitted.items.find((i) => i.kind === action.kind).unknown -= 1;
-                snapshot = await save(snapshot, unsubmitted);
+                snapshot = await this.#save(snapshot, unsubmitted);
                 return {
                     snapshot,
                     need: {
@@ -298,7 +327,7 @@ export function createGrowthExecution(dependencies) {
                 error: error.message.slice(0, 240),
             };
         }
-        snapshot = await settleProof(snapshot, entry, observation);
+        snapshot = await this.#settleProof(snapshot, entry, observation);
         return {
             snapshot,
             need: observation.verified
@@ -311,5 +340,7 @@ export function createGrowthExecution(dependencies) {
                 },
         };
     }
-    return { execute };
+}
+export function createGrowthExecution(...args) {
+    return new GrowthExecution(...args);
 }

package/dist/growth-parallel.d.ts

@@ -1,4 +1,8 @@
 import type { GrowthDependencies } from "./growth-dependencies.js";
-export declare function createParallelRound(dependencies: Pick<GrowthDependencies, "load" | "scope" | "result" | "store" | "executor" | "runtimeId" | "stamp" | "evidenceExists" | "execute" | "clock" | "releaseSession" | "session">): {
+export declare class ParallelRound {
+    #private;
     parallelRound: ({ taskId, decision, selector, requestedKind, maxActions, }?: any) => Promise<any>;
-};
+    constructor(dependencies: Pick<GrowthDependencies, "load" | "scope" | "result" | "store" | "executor" | "runtimeId" | "stamp" | "evidenceExists" | "execute" | "clock" | "releaseSession" | "session">);
+    private handleParallelRound;
+}
+export declare function createParallelRound(...args: ConstructorParameters<typeof ParallelRound>): ParallelRound;