@nextclaw/x-harness 0.1.1 → 0.2.0

package/dist/growth-policy.js

@@ -1,30 +1,32 @@
 import { xURL } from "./platform-rules.js";
 import { kinds, followWindows, operations, same } from "./growth-constants.js";
-export function createGrowthPolicy(dependencies) {
-    const { executor, clock, evidenceExists, platform, store } = dependencies;
-    // Manual user authorization applies only to the named executor and action kind.
-    const authorizedWindow = (state, kind) => {
-        const permit = state.executions?.[executor?.id]?.windowAuthorization;
-        const now = clock();
-        return Boolean(permit &&
-            permit.kind === kind &&
-            permit.executorId === executor?.id &&
-            permit.userAuthorized === true &&
-            evidenceExists(permit.evidenceRef) &&
-            Date.parse(permit.startsAt) <= now &&
-            now < Date.parse(permit.expiresAt));
-    };
-    const scope = (state) => executor?.scopeKinds ?? state.scopeKinds ?? kinds;
-    const project = (state) => executor
-        ? {
-            ...state,
-            scopeKinds: executor.scopeKinds,
-            scopeEvidenceRef: executor.evidenceRef,
-            status: state.executions?.[executor.id]?.status ?? "RUNNING",
-            stop: state.executions?.[executor.id]?.stop,
-        }
-        : state;
-    function capability(operation, input = {}) {
+export class GrowthPolicy {
+    #executor;
+    #clock;
+    #evidenceExists;
+    #platform;
+    #store;
+    authorizedWindow;
+    scope;
+    project;
+    capability;
+    waitBudget;
+    guardInput;
+    constructor(dependencies) {
+        const { executor, clock, evidenceExists, platform, store } = dependencies;
+        this.#executor = executor;
+        this.#clock = clock;
+        this.#evidenceExists = evidenceExists;
+        this.#platform = platform;
+        this.#store = store;
+        this.authorizedWindow = this.handleAuthorizedWindow.bind(this);
+        this.scope = this.handleScope.bind(this);
+        this.project = this.handleProject.bind(this);
+        this.capability = this.handleCapability.bind(this);
+        this.waitBudget = this.handleWaitBudget.bind(this);
+        this.guardInput = this.handleGuardInput.bind(this);
+    }
+    handleCapability(operation, input = {}) {
         const kind = input.kind ??
             {
                 followOne: "follow",
@@ -44,17 +46,18 @@ export function createGrowthPolicy(dependencies) {
         ];
         if (kind === "follow")
             required.push("readPerson");
-        const missing = required.filter((name) => typeof platform?.[name] !== "function");
-        const storage = ["load", "save", "withLock", "recordProof"].filter((name) => typeof store?.[name] !==
+        const missing = required.filter((name) => typeof this.#platform?.[name] !== "function");
+        const storage = ["load", "save", "withLock", "recordProof"].filter((name) => typeof this.#store?.[name] !==
             "function");
-        if (operation === "followBatch" && typeof store?.transaction !== "function")
+        if (operation === "followBatch" &&
+            typeof this.#store?.transaction !== "function")
             storage.push("transaction");
         if (kind === "original" &&
             operation !== "read" &&
-            typeof store?.fingerprint !== "function")
+            typeof this.#store?.fingerprint !== "function")
             storage.push("fingerprint");
-        const lower = typeof platform?.preflight === "function"
-            ? platform.preflight({
+        const lower = typeof this.#platform?.preflight === "function"
+            ? this.#platform.preflight({
                 operation: operation === "read" ? "read" : operations[kind],
                 input,
             })
@@ -73,8 +76,8 @@ export function createGrowthPolicy(dependencies) {
                     : lower.owner,
         };
     }
-    function waitBudget(state) {
-        const now = clock();
+    handleWaitBudget(state) {
+        const now = this.#clock();
         const hour = Number(new Intl.DateTimeFormat("en-GB", {
             timeZone: "Asia/Shanghai",
             hour: "2-digit",
@@ -89,7 +92,7 @@ export function createGrowthPolicy(dependencies) {
         if (!coverage?.complete ||
             !Number.isFinite(Date.parse(coverage.since)) ||
             Date.parse(coverage.since) > now - 3600000 ||
-            !evidenceExists(coverage.evidenceRef))
+            !this.#evidenceExists(coverage.evidenceRef))
             return {
                 status: "needsDecision",
                 reason: "shared-attempt-history-incomplete",
@@ -118,14 +121,15 @@ export function createGrowthPolicy(dependencies) {
             };
         return null;
     }
-    function guardInput(state, action, independentExecution = undefined) {
-        if (!independentExecution && !scope(state).includes(action.kind))
+    handleGuardInput(state, action, independentExecution = undefined) {
+        const executor = this.#executor;
+        if (!independentExecution && !this.handleScope(state).includes(action.kind))
             return "kind-outside-round-scope";
         if (independentExecution) {
             if (action.kind !== "original" ||
                 !independentExecution.tabId ||
-                !evidenceExists(independentExecution.evidenceRef) ||
-                !evidenceExists(independentExecution.scopeEvidenceRef))
+                !this.#evidenceExists(independentExecution.evidenceRef) ||
+                !this.#evidenceExists(independentExecution.scopeEvidenceRef))
                 return "independent-execution-proof-missing";
         }
         else if (!executor &&
@@ -133,49 +137,72 @@ export function createGrowthPolicy(dependencies) {
             return "exclusive-account-execution-unconfirmed";
         if (!same(state.accountHandle, action.accountHandle))
             return "account-identity-mismatch";
-        if (!evidenceExists(action.accountEvidenceRef) ||
+        if (!this.#evidenceExists(action.accountEvidenceRef) ||
             xURL(action.accountURL).pathname.toLowerCase() !==
                 `/${state.accountHandle}`.toLowerCase())
             return "own-profile-proof-missing";
         if (!action.quality?.approved ||
-            !evidenceExists(action.quality.evidenceRef))
+            !this.#evidenceExists(action.quality.evidenceRef))
             return "quality-review-required";
         if (action.kind === "follow") {
             if (!same(action.quality.handle, action.handle) ||
                 action.quality.blue !== true ||
                 action.quality.chinese !== true)
                 return "follow-qualification-required";
-            if (!evidenceExists(action.evidenceRef))
+            if (!this.#evidenceExists(action.evidenceRef))
                 return "person-observation-proof-missing";
         }
         else {
             if (!action.text || action.quality.approvedText !== action.text)
                 return "exact-text-quality-review-required";
             if (action.kind === "original" &&
-                (!action.draftPath || !evidenceExists(action.draftPath)))
+                (!action.draftPath || !this.#evidenceExists(action.draftPath)))
                 return "draft-source-missing";
             if (action.kind === "original" &&
                 (!action.draftPath.endsWith(".post.md") ||
                     action.quality.draftFingerprint !==
-                        store.fingerprint(action.draftPath)))
+                        this.#store.fingerprint(action.draftPath)))
                 return "draft-changed-since-quality-review";
             if (action.kind === "original" &&
-                (!evidenceExists(action.composeEvidenceRef) ||
+                (!this.#evidenceExists(action.composeEvidenceRef) ||
                     xURL(action.composeURL).pathname !== "/compose/post"))
                 return "observed-composer-proof-missing";
             if (action.kind === "reply" &&
                 (!/^\d+$/.test(action.postId ?? "") ||
-                    !evidenceExists(action.evidenceRef)))
+                    !this.#evidenceExists(action.evidenceRef)))
                 return "reply-target-proof-missing";
         }
         return null;
     }
-    return {
-        authorizedWindow,
-        scope,
-        project,
-        capability,
-        waitBudget,
-        guardInput,
-    };
+    handleAuthorizedWindow(state, kind) {
+        const executor = this.#executor;
+        const permit = state.executions?.[executor?.id]?.windowAuthorization;
+        const now = this.#clock();
+        return Boolean(permit &&
+            permit.kind === kind &&
+            permit.executorId === executor?.id &&
+            permit.userAuthorized === true &&
+            this.#evidenceExists(permit.evidenceRef) &&
+            Date.parse(permit.startsAt) <= now &&
+            now < Date.parse(permit.expiresAt));
+    }
+    handleScope(state) {
+        const executor = this.#executor;
+        return executor?.scopeKinds ?? state.scopeKinds ?? kinds;
+    }
+    handleProject(state) {
+        const executor = this.#executor;
+        return executor
+            ? {
+                ...state,
+                scopeKinds: executor.scopeKinds,
+                scopeEvidenceRef: executor.evidenceRef,
+                status: state.executions?.[executor.id]?.status ?? "RUNNING",
+                stop: state.executions?.[executor.id]?.stop,
+            }
+            : state;
+    }
+}
+export function createGrowthPolicy(...args) {
+    return new GrowthPolicy(...args);
 }

package/dist/growth-publishing.d.ts

@@ -1,5 +1,10 @@
 import type { GrowthDependencies } from "./growth-dependencies.js";
-export declare function createIndependentPublishing(dependencies: Pick<GrowthDependencies, "clock" | "evidenceExists" | "capability" | "store" | "load" | "guardInput" | "save" | "platform" | "stamp" | "settleProof">): {
+export declare class IndependentPublishing {
+    #private;
     publishIndependent: ({ taskId, draftPath, preparedAction, independentExecution, }: any) => Promise<any>;
     prepareActionsForCall: (taskId: string, actions?: any[]) => Promise<void>;
-};
+    constructor(dependencies: Pick<GrowthDependencies, "clock" | "evidenceExists" | "capability" | "store" | "load" | "guardInput" | "save" | "platform" | "stamp" | "settleProof">);
+    private handlePublishIndependent;
+    private handlePrepareActionsForCall;
+}
+export declare function createIndependentPublishing(...args: ConstructorParameters<typeof IndependentPublishing>): IndependentPublishing;

package/dist/growth-publishing.js

@@ -1,30 +1,55 @@
 import { kinds, same } from "./growth-constants.js";
-export function createIndependentPublishing(dependencies) {
-    const { clock, evidenceExists, capability, store, load, guardInput, save, platform, stamp, settleProof, } = dependencies;
-    // Independent tabs share only short ledger transactions, never a browser-operation lock.
-    async function publishIndependent({ taskId, draftPath, preparedAction, independentExecution, }) {
+export class IndependentPublishing {
+    #clock;
+    #evidenceExists;
+    #capability;
+    #store;
+    #load;
+    #guardInput;
+    #save;
+    #platform;
+    #stamp;
+    #settleProof;
+    publishIndependent;
+    prepareActionsForCall;
+    constructor(dependencies) {
+        const { clock, evidenceExists, capability, store, load, guardInput, save, platform, stamp, settleProof, } = dependencies;
+        this.#clock = clock;
+        this.#evidenceExists = evidenceExists;
+        this.#capability = capability;
+        this.#store = store;
+        this.#load = load;
+        this.#guardInput = guardInput;
+        this.#save = save;
+        this.#platform = platform;
+        this.#stamp = stamp;
+        this.#settleProof = settleProof;
+        this.publishIndependent = this.handlePublishIndependent.bind(this);
+        this.prepareActionsForCall = this.handlePrepareActionsForCall.bind(this);
+    }
+    async handlePublishIndependent({ taskId, draftPath, preparedAction, independentExecution, }) {
         let action, token, submissionStarted = false;
         const inWindow = () => {
             const hour = Number(new Intl.DateTimeFormat("en-GB", {
                 timeZone: "Asia/Shanghai",
                 hour: "2-digit",
                 hourCycle: "h23",
-            }).format(clock()));
+            }).format(this.#clock()));
             const permit = independentExecution?.windowAuthorization;
             return ((hour >= 7 && hour < 22) ||
                 Boolean(permit?.userAuthorized === true &&
                     permit.actionId === (action?.id ?? preparedAction?.id) &&
-                    evidenceExists(permit.evidenceRef) &&
-                    clock() < Date.parse(permit.expiresAt)));
+                    this.#evidenceExists(permit.evidenceRef) &&
+                    this.#clock() < Date.parse(permit.expiresAt)));
         };
         try {
-            const caps = capability("submitPost", preparedAction ?? {});
+            const caps = this.#capability("submitPost", preparedAction ?? {});
             if (!caps.covered)
                 return { status: "needsCapability", ...caps };
             if (!inWindow())
                 throw new Error("outside-contract-write-window");
-            await store.withLock(async () => {
-                const snapshot = await load(taskId), state = structuredClone(snapshot.state);
+            await this.#store.withLock(async () => {
+                const snapshot = await this.#load(taskId), state = structuredClone(snapshot.state);
                 state.actions ??= [];
                 action = state.actions.find((a) => a.kind === "original" && a.draftPath === draftPath);
                 if (!action) {
@@ -34,47 +59,47 @@ export function createIndependentPublishing(dependencies) {
                         preparedAction.draftPath !== draftPath ||
                         state.actions.some((a) => a.id === preparedAction.id))
                         throw new Error("unique-prepared-original-required");
-                    const error = guardInput(state, preparedAction, independentExecution);
+                    const error = this.#guardInput(state, preparedAction, independentExecution);
                     if (error)
                         throw new Error(error);
                     action = structuredClone(preparedAction);
                     state.actions.push(action);
-                    await save(snapshot, state);
+                    await this.#save(snapshot, state);
                 }
                 if (action.status !== "prepared")
                     throw new Error("existing-submission-do-not-resubmit");
-                if (action.claim && store.ownerAlive(action.claim.pid))
+                if (action.claim && this.#store.ownerAlive(action.claim.pid))
                     throw new Error("same-action-claimed");
-                const error = guardInput(state, action, independentExecution);
+                const error = this.#guardInput(state, action, independentExecution);
                 if (error)
                     throw new Error(error);
             });
-            const own = await platform.readAccount();
+            const own = await this.#platform.readAccount();
             if (own.needsStateCheck ||
                 own.alerts?.length ||
                 !same(own.accountHandle, action.accountHandle))
                 throw new Error("fresh-account-unconfirmed");
-            const baseline = await platform.findSubmission({
+            const baseline = await this.#platform.findSubmission({
                 ...action,
-                intentAt: stamp(),
+                intentAt: this.#stamp(),
             });
             if (baseline.needsStateCheck || baseline.alerts?.length)
                 throw new Error("publication-baseline-unconfirmed");
-            token = `${action.id}:${stamp()}:${Math.random()}`;
-            await store.withLock(async () => {
-                const snapshot = await load(taskId), state = structuredClone(snapshot.state);
+            token = `${action.id}:${this.#stamp()}:${Math.random()}`;
+            await this.#store.withLock(async () => {
+                const snapshot = await this.#load(taskId), state = structuredClone(snapshot.state);
                 const target = state.actions.find((a) => a.id === action.id), item = state.items.find((i) => i.kind === "original");
                 if (target?.status !== "prepared" ||
-                    (target.claim && store.ownerAlive(target.claim.pid)))
+                    (target.claim && this.#store.ownerAlive(target.claim.pid)))
                     throw new Error("action-already-claimed-do-not-resubmit");
-                const error = guardInput(state, target, independentExecution);
+                const error = this.#guardInput(state, target, independentExecution);
                 if (error)
                     throw new Error(error);
                 if (!inWindow() || item.verified + item.unknown >= item.planned)
                     throw new Error("window-or-original-capacity-unavailable");
                 Object.assign(target, {
                     status: "intent",
-                    intentAt: stamp(),
+                    intentAt: this.#stamp(),
                     beforeIds: (baseline.posts ?? [])
                         .map((p) => p.id)
                         .filter(Boolean),
@@ -83,9 +108,9 @@ export function createIndependentPublishing(dependencies) {
                     claim: {
                         actionId: target.id,
                         token,
-                        pid: store.processId,
+                        pid: this.#store.processId,
                         tabId: independentExecution.tabId,
-                        acquiredAt: stamp(),
+                        acquiredAt: this.#stamp(),
                     },
                 });
                 item.unknown += 1;
@@ -95,26 +120,26 @@ export function createIndependentPublishing(dependencies) {
                     kind: "original",
                     at: target.intentAt,
                 });
-                await save(snapshot, state);
+                await this.#save(snapshot, state);
                 action = structuredClone(target);
             });
             let observation;
             try {
-                await platform.submitPost({
+                await this.#platform.submitPost({
                     ...action,
                     beforeSubmit: async () => {
-                        const latest = await load(taskId), target = latest.state.actions.find((a) => a.id === action.id);
+                        const latest = await this.#load(taskId), target = latest.state.actions.find((a) => a.id === action.id);
                         if (target?.status !== "intent" ||
                             target.claimToken !== token ||
                             !inWindow())
                             throw new Error("action-claim-or-window-changed");
-                        const error = guardInput(latest.state, target, independentExecution);
+                        const error = this.#guardInput(latest.state, target, independentExecution);
                         if (error)
                             throw new Error(error);
                         submissionStarted = true;
                     },
                 });
-                observation = await platform.findSubmission(action);
+                observation = await this.#platform.findSubmission(action);
             }
             catch (error) {
                 if (!submissionStarted)
@@ -125,11 +150,11 @@ export function createIndependentPublishing(dependencies) {
                     error: error.message.slice(0, 240),
                 };
             }
-            return await store.withLock(async () => {
-                const snapshot = await load(taskId), target = snapshot.state.actions.find((a) => a.id === action.id);
+            return await this.#store.withLock(async () => {
+                const snapshot = await this.#load(taskId), target = snapshot.state.actions.find((a) => a.id === action.id);
                 if (target?.claimToken !== token || target.status !== "intent")
                     throw new Error("action-settlement-conflict");
-                await settleProof(snapshot, target, observation, {
+                await this.#settleProof(snapshot, target, observation, {
                     preserveStatus: true,
                 });
                 return {
@@ -137,25 +162,25 @@ export function createIndependentPublishing(dependencies) {
                     taskId,
                     actionId: action.id,
                     publicId: observation.publicId,
-                    evidenceRef: store.path,
+                    evidenceRef: this.#store.path,
                     mayEnd: false,
                 };
             });
         }
         catch (error) {
             if (token && !submissionStarted)
-                await store.withLock(async () => {
-                    const snapshot = await load(taskId), state = structuredClone(snapshot.state), target = state.actions.find((a) => a.id === action.id);
+                await this.#store.withLock(async () => {
+                    const snapshot = await this.#load(taskId), state = structuredClone(snapshot.state), target = state.actions.find((a) => a.id === action.id);
                     if (target?.claimToken !== token || target.status !== "intent")
                         return;
                     target.status = "prepared";
-                    target.preparationEvidence = await store.recordProof({
-                        observedAt: stamp(),
+                    target.preparationEvidence = await this.#store.recordProof({
+                        observedAt: this.#stamp(),
                         submissionStarted: false,
                         error: error.message.slice(0, 240),
                     });
                     state.items.find((i) => i.kind === "original").unknown -= 1;
-                    await save(snapshot, state);
+                    await this.#save(snapshot, state);
                 });
             return {
                 status: "needsDecision",
@@ -172,7 +197,7 @@ export function createIndependentPublishing(dependencies) {
         }
         finally {
             if (token)
-                await store.transaction((snapshot) => {
+                await this.#store.transaction((snapshot) => {
                     if (snapshot.state.batchId !== taskId)
                         return null;
                     const next = structuredClone(snapshot.state), target = next.actions.find((a) => a.id === action.id);
@@ -183,11 +208,10 @@ export function createIndependentPublishing(dependencies) {
                 });
         }
     }
-    // Stable prepared actions are adopted in the original ledger, never in a second queue.
-    async function prepareActionsForCall(taskId, actions = []) {
+    async handlePrepareActionsForCall(taskId, actions = []) {
         if (!actions.length)
             return;
-        await store.transaction(async (snapshot) => {
+        await this.#store.transaction(async (snapshot) => {
             if (snapshot.state.batchId !== taskId)
                 throw new Error("original-task-id-required");
             const next = structuredClone(snapshot.state);
@@ -200,7 +224,7 @@ export function createIndependentPublishing(dependencies) {
                     !kinds.includes(action.kind))
                     throw new Error("unique-prepared-action-required");
                 ids.add(action.id);
-                const inputError = guardInput(next, action);
+                const inputError = this.#guardInput(next, action);
                 if (inputError)
                     throw new Error(inputError);
                 const existing = next.actions.find((a) => a.id === action.id);
@@ -232,9 +256,11 @@ export function createIndependentPublishing(dependencies) {
                     throw new Error("prepared-actions-exceed-original-target");
                 next.actions.push(structuredClone(action));
             }
-            next.updatedAt = stamp();
+            next.updatedAt = this.#stamp();
             return next;
         });
     }
-    return { publishIndependent, prepareActionsForCall };
+}
+export function createIndependentPublishing(...args) {
+    return new IndependentPublishing(...args);
 }

package/dist/growth-reading.d.ts

@@ -1,4 +1,8 @@
 import type { GrowthDependencies } from "./growth-dependencies.js";
-export declare function createGrowthReading(dependencies: Pick<GrowthDependencies, "platform" | "executor" | "store" | "runtimeId" | "stamp" | "releaseSession" | "session">): {
+export declare class GrowthReading {
+    #private;
     readTask: (operation: any, { mode, ...input }?: any) => Promise<any>;
-};
+    constructor(dependencies: Pick<GrowthDependencies, "platform" | "executor" | "store" | "runtimeId" | "stamp" | "releaseSession" | "session">);
+    private handleReadTask;
+}
+export declare function createGrowthReading(...args: ConstructorParameters<typeof GrowthReading>): GrowthReading;

package/dist/growth-reading.js

@@ -1,57 +1,77 @@
-export function createGrowthReading(dependencies) {
-    const { platform, executor, store, runtimeId, stamp, releaseSession, session, } = dependencies;
-    const readCache = new Map();
-    async function readTask(operation, { mode = "receipt", ...input } = {}) {
+export class GrowthReading {
+    #platform;
+    #executor;
+    #store;
+    #runtimeId;
+    #stamp;
+    #releaseSession;
+    #session;
+    #readCache;
+    readTask;
+    constructor(dependencies) {
+        const { platform, executor, store, runtimeId, stamp, releaseSession, session, } = dependencies;
+        this.#platform = platform;
+        this.#executor = executor;
+        this.#store = store;
+        this.#runtimeId = runtimeId;
+        this.#stamp = stamp;
+        this.#releaseSession = releaseSession;
+        this.#session = session;
+        this.#readCache = new Map();
+        this.readTask = this.handleReadTask.bind(this);
+    }
+    async handleReadTask(operation, { mode = "receipt", ...input } = {}) {
+        const executor = this.#executor;
         if (!["decision", "receipt", "delta"].includes(mode))
             throw new Error("读取模式须为decision/receipt/delta");
-        if (session.running)
+        if (this.#session.running)
             return {
                 status: "needsDecision",
                 complete: false,
                 reason: "same-tab-operation-running",
             };
-        const caps = platform.preflight({
+        const caps = this.#platform.preflight({
             operation: ["readAccount", "readPerson", "readPost"].includes(operation)
                 ? "read"
                 : operation,
             input,
         });
-        if (!caps.covered || typeof platform[operation] !== "function")
+        if (!caps.covered || typeof this.#platform[operation] !== "function")
             return {
                 status: "needsCapability",
                 ...caps,
                 missing: [
                     ...(caps.missing ?? []),
-                    ...(typeof platform[operation] === "function"
+                    ...(typeof this.#platform[operation] === "function"
                         ? []
                         : [`platform.${operation}`]),
                 ],
             };
-        session.running = true;
+        this.#session.running = true;
         try {
             if (executor)
-                await store.transaction((latest) => {
+                await this.#store.transaction((latest) => {
                     const next = structuredClone(latest.state);
                     next.executions ??= {};
                     if (Object.values(next.executions).some((e) => (e.tabId === executor.tabId || e.id === executor.id) &&
-                        e.runtimeId !== runtimeId &&
+                        e.runtimeId !== this.#runtimeId &&
                         (e.activity || e.actionId) &&
-                        store.ownerAlive(e.pid)))
+                        this.#store.ownerAlive(e.pid)))
                         throw new Error("same-tab-or-executor-claimed");
                     next.executions[executor.id] = {
                         ...next.executions[executor.id],
                         ...executor,
-                        runtimeId,
-                        pid: store.processId,
+                        runtimeId: this.#runtimeId,
+                        pid: this.#store.processId,
                         activity: operation,
                         status: next.executions[executor.id]?.status ?? "RUNNING",
-                        updatedAt: stamp(),
+                        updatedAt: this.#stamp(),
                     };
-                    next.updatedAt = stamp();
+                    next.updatedAt = this.#stamp();
                     return next;
                 });
-            const value = await platform[operation](input);
-            const evidenceRef = await store.recordProof(await platform.captureProof({ observation: value }));
+            const value = await this.#platform[operation](input);
+            const evidenceRef = await this.#store.recordProof(await this.#platform.captureProof({ observation: value }));
             const status = value.status ??
                 (value.complete === false ||
                     value.needsStateCheck ||
@@ -86,11 +106,11 @@ export function createGrowthReading(dependencies) {
                 for (const entry of value[collection]) {
                     const key = JSON.stringify([operation, input, entry.id]);
                     const normalized = JSON.stringify(entry, (name, val) => name === "observedAt" ? undefined : val);
-                    if (readCache.get(key) === normalized)
+                    if (this.#readCache.get(key) === normalized)
                         unchangedIds.push(entry.id);
                     else
                         changed.push(entry);
-                    readCache.set(key, normalized);
+                    this.#readCache.set(key, normalized);
                 }
                 return { ...receipt, [collection]: changed, unchangedIds };
             }
@@ -108,8 +128,8 @@ export function createGrowthReading(dependencies) {
                         ? "connection-failed"
                         : "observation-unconfirmed";
             const diagnostic = { operation, category, code };
-            const evidenceRef = await store.recordProof({
-                capturedAt: stamp(),
+            const evidenceRef = await this.#store.recordProof({
+                capturedAt: this.#stamp(),
                 diagnostic: { ...diagnostic, error: error.message },
             });
             return {
@@ -124,12 +144,14 @@ export function createGrowthReading(dependencies) {
         }
         finally {
             try {
-                await releaseSession();
+                await this.#releaseSession();
             }
             finally {
-                session.running = false;
+                this.#session.running = false;
             }
         }
     }
-    return { readTask };
+}
+export function createGrowthReading(...args) {
+    return new GrowthReading(...args);
 }

package/dist/growth-recovery.d.ts

@@ -1,6 +1,9 @@
 import type { GrowthDependencies } from "./growth-dependencies.js";
-export declare function createGrowthRecovery(dependencies: Pick<GrowthDependencies, "capability" | "platform" | "load" | "evidenceExists" | "clock" | "store" | "settleProof" | "executor" | "parallelRound" | "round" | "readTask">): {
+export declare class GrowthRecovery {
+    #private;
+    constructor(dependencies: Pick<GrowthDependencies, "capability" | "platform" | "load" | "evidenceExists" | "clock" | "store" | "settleProof" | "executor" | "parallelRound" | "round" | "readTask">);
     verifyPublishedPost({ taskId, draftPath, publicURL, evidenceRef, sourceLink, }: any): Promise<any>;
-    verifySubmission: ({ taskId, actionId }: any) => Promise<any>;
-    verifyFollow: (target: any) => Promise<any>;
-};
+    verifySubmission({ taskId, actionId }: any): Promise<any>;
+    verifyFollow(target: any): Promise<any>;
+}
+export declare function createGrowthRecovery(...args: ConstructorParameters<typeof GrowthRecovery>): GrowthRecovery;