@agentplat/mesh-sim 0.3.0-beta.2 → 0.3.0-beta.4

package/dist/collective-statistical-campaign-executor.js

@@ -0,0 +1,856 @@
+import { canonicalizePlanningJsonV1, deepFreezePlanning, } from "@agentplat/collective-planning";
+import { claimCollectiveEvaluationCellV1, collectiveEvaluationRunKeyV1, createCollectiveEvaluationCampaignExecutionV1, finalizeCollectiveEvaluationCampaignExecutionV1, renewCollectiveEvaluationCellLeaseV1, reconcileCollectiveEvaluationRunV1, settleCollectiveEvaluationRunV1, startCollectiveEvaluationRunV1, validateCollectiveEvaluationCampaignExecutionV1, validateCollectiveEvaluationCampaignRegistrationV1, } from "@agentplat/collective-planning/evaluation";
+import { createCollectiveStatisticalCampaignExecutionArtifactsV1, } from "./collective-statistical-campaign-aggregation.js";
+const runners = Object.freeze([
+    "adaptive_collective",
+    "centralized_planner",
+]);
+const attempts = Object.freeze(["first", "replay"]);
+const MAXIMUM_EXECUTION_STATE_CAS_RETRIES = 256;
+/**
+ * Runs one deterministic shard. Disjoint workers converge through bounded
+ * revision-CAS retries; every logical run remains idempotent through runKey
+ * and an immutable commit.
+ * A crash after commit but before settlement is resumed from the stored commit.
+ */
+export async function runCollectiveStatisticalCampaignShardV1(input) {
+    validateExecutorInput(input);
+    const registration = validateCollectiveEvaluationCampaignRegistrationV1(input.registration);
+    let state = await loadOrCreateExecutionState(input, registration);
+    const transition = async (apply) => {
+        for (let retry = 0; retry < MAXIMUM_EXECUTION_STATE_CAS_RETRIES; retry += 1) {
+            const previous = state;
+            const next = apply(previous);
+            const status = await compareAndSwapExecutionState(input, {
+                executionId: input.executionId,
+                expectedExecutionDigest: previous.executionDigest,
+                state: next,
+            });
+            if (status === "expired")
+                throw new TypeError("collective_statistical_campaign_operation_authorization_expired");
+            if (status === "committed") {
+                state = next;
+                return Object.freeze({ state, outcome: "committed" });
+            }
+            const canonical = await readExecutionState(input, registration);
+            if (canonical === null)
+                throw new TypeError("collective_statistical_campaign_state_conflict_missing");
+            state = canonical;
+            if (status === "duplicate") {
+                // The store linearized an exact duplicate. The mandatory reread may
+                // already observe a later CAS committed by another shard.
+                return Object.freeze({ state, outcome: "duplicate" });
+            }
+        }
+        throw new TypeError("collective_statistical_campaign_state_retry_limit_exceeded");
+    };
+    const selected = input.cellIds === undefined
+        ? registration.cells.filter((_cell, index) => index % input.shard.count === input.shard.index)
+        : selectExplicitCells(registration, input.cellIds);
+    if (selected.length > input.maximumCells)
+        throw new RangeError("collective_statistical_campaign_shard_cell_limit_exceeded");
+    let executedSlotCount = 0;
+    let resumedSlotCount = 0;
+    const completed = [];
+    for (const cell of selected) {
+        const leaseToken = `lease:${input.workerId}:${input.shard.index}:${cell.peerCount}:${cell.stratum}:${cell.seed}`;
+        let ownedFence = null;
+        for (const runner of runners) {
+            for (const attempt of attempts) {
+                const runKey = runKeyFor(state, cell.cellId, runner, attempt);
+                let currentCell = cellFor(state, cell.cellId);
+                let currentSlot = runFor(currentCell, runner, attempt);
+                if (currentSlot.status === "succeeded" ||
+                    currentSlot.status === "failed") {
+                    if (currentSlot.settlementFence === null)
+                        throw new TypeError("collective_statistical_campaign_terminal_settlement_invalid");
+                    const durable = await readOne(input.store, runKey, {
+                        executionId: input.executionId,
+                        registrationDigest: registration.registrationDigest,
+                        cellId: cell.cellId,
+                        fence: currentSlot.settlementFence,
+                        operationExpiresAtMs: input.operationExpiresAtMs ?? null,
+                    });
+                    if (durable === null)
+                        throw new TypeError("collective_statistical_campaign_terminal_commit_missing");
+                    completed.push(validateStoredExecution(registration, input.executionId, cell, runner, attempt, runKey, durable));
+                    resumedSlotCount += 1;
+                    continue;
+                }
+                if (currentSlot.status === "running") {
+                    const activeFence = fenceFor(state, cell.cellId);
+                    let durable = await readOne(input.store, runKey, {
+                        executionId: input.executionId,
+                        registrationDigest: registration.registrationDigest,
+                        cellId: cell.cellId,
+                        fence: activeFence,
+                        operationExpiresAtMs: input.operationExpiresAtMs ?? null,
+                    });
+                    const inspectionNow = clock(input.now);
+                    if (durable === null && activeFence.expiresAtMs > inspectionNow)
+                        throw new TypeError("collective_statistical_campaign_running_lease_active");
+                    if (durable === null) {
+                        durable = createFailedExecution(input.executionId, registration.registrationDigest, runKey, cell, runner, attempt, "indeterminate_external_effect");
+                        const commit = await commitExecution(input, registration.registrationDigest, cell.cellId, runKey, activeFence, durable);
+                        if (commit === "committed")
+                            executedSlotCount += 1;
+                        else {
+                            const canonical = await readOne(input.store, runKey, {
+                                executionId: input.executionId,
+                                registrationDigest: registration.registrationDigest,
+                                cellId: cell.cellId,
+                                fence: activeFence,
+                                operationExpiresAtMs: input.operationExpiresAtMs ?? null,
+                            });
+                            if (canonical === null)
+                                throw new TypeError("collective_statistical_campaign_duplicate_commit_missing");
+                            durable = canonical;
+                            resumedSlotCount += 1;
+                        }
+                    }
+                    else {
+                        resumedSlotCount += 1;
+                    }
+                    const execution = validateStoredExecution(registration, input.executionId, cell, runner, attempt, runKey, durable);
+                    await transition((current) => settleStoredExecution(current, input.executionId, cell, runner, attempt, runKey, clock(input.now), execution));
+                    completed.push(execution);
+                    continue;
+                }
+                assertOperationActive(input, clock(input.now));
+                const claim = await transition((current) => {
+                    const candidate = cellFor(current, cell.cellId);
+                    const claimNow = clock(input.now);
+                    if (candidate.status === "pending" ||
+                        (candidate.status === "leased" &&
+                            candidate.lease !== null &&
+                            candidate.lease.expiresAtMs <= claimNow)) {
+                        return claimCollectiveEvaluationCellV1(current, {
+                            executionId: input.executionId,
+                            expectedRevision: current.revision,
+                            cellId: cell.cellId,
+                            nowMs: claimNow,
+                            lease: {
+                                workerId: input.workerId,
+                                leaseToken,
+                                expiresAtMs: boundedLeaseExpiry(input, claimNow),
+                            },
+                        });
+                    }
+                    if ((candidate.status === "leased" || candidate.status === "running") &&
+                        candidate.lease !== null &&
+                        candidate.lease.workerId === input.workerId &&
+                        candidate.lease.leaseToken === leaseToken)
+                        return current;
+                    throw new TypeError("collective_statistical_campaign_cell_lease_active");
+                });
+                if (claim.outcome === "duplicate") {
+                    if (ownedFence === null)
+                        throw new TypeError("collective_statistical_campaign_cell_lease_active");
+                    const canonicalFence = fenceFor(state, cell.cellId);
+                    if (!sameExecutionFence(ownedFence, canonicalFence))
+                        throw new TypeError("collective_statistical_campaign_cell_lease_active");
+                }
+                const acquiredFence = fenceFor(state, cell.cellId);
+                ownedFence = acquiredFence;
+                await transition((current) => {
+                    const startNow = clock(input.now);
+                    assertOperationActive(input, startNow);
+                    return startCollectiveEvaluationRunV1(current, {
+                        executionId: input.executionId,
+                        expectedRevision: current.revision,
+                        cellId: cell.cellId,
+                        runner,
+                        attempt,
+                        nowMs: startNow,
+                        fence: acquiredFence,
+                    });
+                });
+                const renewLeaseV1 = async (expiresAtMs) => {
+                    assertOperationActive(input, clock(input.now));
+                    if (input.operationExpiresAtMs !== undefined &&
+                        expiresAtMs > input.operationExpiresAtMs)
+                        throw new TypeError("collective_statistical_campaign_operation_expiry_exceeded");
+                    const renewalFence = ownedFence;
+                    if (renewalFence === null)
+                        throw new TypeError("collective_statistical_campaign_cell_lease_missing");
+                    await transition((current) => renewCollectiveEvaluationCellLeaseV1(current, {
+                        executionId: input.executionId,
+                        expectedRevision: current.revision,
+                        cellId: cell.cellId,
+                        nowMs: clock(input.now),
+                        fence: renewalFence,
+                        expiresAtMs,
+                    }));
+                    ownedFence = fenceFor(state, cell.cellId);
+                };
+                const stored = await readOne(input.store, runKey, {
+                    executionId: input.executionId,
+                    registrationDigest: registration.registrationDigest,
+                    cellId: cell.cellId,
+                    fence: acquiredFence,
+                    operationExpiresAtMs: input.operationExpiresAtMs ?? null,
+                });
+                let execution;
+                if (stored !== null) {
+                    execution = validateStoredExecution(registration, input.executionId, cell, runner, attempt, runKey, stored);
+                    resumedSlotCount += 1;
+                }
+                else {
+                    let output;
+                    // Runners are supplied by adapters and must not need to know the
+                    // storage lease duration.  Keep the fenced cell alive while an
+                    // otherwise healthy long-running execution is in progress.  The
+                    // renewal chain deliberately serializes CAS transitions so it cannot
+                    // race the runner's optional explicit renewal hook.
+                    let renewalChain = Promise.resolve();
+                    const renewalIntervalMs = Math.max(1_000, Math.floor(input.leaseDurationMs / 3));
+                    const renewalTimer = setInterval(() => {
+                        renewalChain = renewalChain.then(() => renewLeaseV1(safeAdd(clock(input.now), input.leaseDurationMs)));
+                    }, renewalIntervalMs);
+                    try {
+                        assertOperationActive(input, clock(input.now));
+                        output = await input.execute(deepFreezePlanning({
+                            schemaVersion: 1,
+                            executionId: input.executionId,
+                            registrationDigest: registration.registrationDigest,
+                            runKey,
+                            cell,
+                            runner,
+                            attempt,
+                            maximumInteractions: cell.maximumInteractions,
+                            renewLeaseV1,
+                        }));
+                    }
+                    catch (error) {
+                        // A runner exception is not an empirical outcome.  Persisting a
+                        // synthetic failed sample here used to hide the actual execution
+                        // fault until the evaluator rejected the projection.  Stop before
+                        // any durable sample is committed, retaining only a tokenized,
+                        // public-safe failure code for the supervisor.
+                        throw new Error(`collective_statistical_campaign_runner_execution_${publicRunnerErrorCode(error)}`);
+                    }
+                    finally {
+                        clearInterval(renewalTimer);
+                        await renewalChain;
+                    }
+                    execution = createCollectiveStatisticalCampaignExecutionArtifactsV1({
+                        schemaVersion: 1,
+                        executionId: input.executionId,
+                        runKey,
+                        registrationDigest: registration.registrationDigest,
+                        cell,
+                        runner,
+                        attempt,
+                        output,
+                    });
+                    const commit = await commitExecution(input, registration.registrationDigest, cell.cellId, runKey, ownedFence, execution);
+                    if (commit === "committed") {
+                        executedSlotCount += 1;
+                    }
+                    else {
+                        const durable = await readOne(input.store, runKey, {
+                            executionId: input.executionId,
+                            registrationDigest: registration.registrationDigest,
+                            cellId: cell.cellId,
+                            fence: ownedFence,
+                            operationExpiresAtMs: input.operationExpiresAtMs ?? null,
+                        });
+                        if (durable === null)
+                            throw new TypeError("collective_statistical_campaign_duplicate_commit_missing");
+                        execution = validateStoredExecution(registration, input.executionId, cell, runner, attempt, runKey, durable);
+                        resumedSlotCount += 1;
+                    }
+                }
+                await transition((current) => settleStoredExecution(current, input.executionId, cell, runner, attempt, runKey, clock(input.now), execution, ownedFence));
+                completed.push(execution);
+            }
+        }
+    }
+    const passedSlotCount = completed.filter((execution) => execution.sample.status === "passed").length;
+    return deepFreezePlanning({
+        schemaVersion: 1,
+        executionId: input.executionId,
+        registrationDigest: registration.registrationDigest,
+        shardIndex: input.shard.index,
+        shardCount: input.shard.count,
+        selectedCellCount: selected.length,
+        executedSlotCount,
+        resumedSlotCount,
+        passedSlotCount,
+        failedSlotCount: completed.length - passedSlotCount,
+        state,
+        executions: Object.freeze(completed),
+    });
+}
+async function loadOrCreateExecutionState(input, registration) {
+    const loaded = await readExecutionState(input, registration);
+    if (loaded !== null)
+        return loaded;
+    const created = createCollectiveEvaluationCampaignExecutionV1({
+        schemaVersion: 1,
+        executionId: input.executionId,
+        registration,
+    });
+    const status = await compareAndSwapExecutionState(input, {
+        executionId: input.executionId,
+        expectedExecutionDigest: null,
+        state: created,
+    });
+    if (status === "expired")
+        throw new TypeError("collective_statistical_campaign_operation_authorization_expired");
+    if (status === "committed")
+        return created;
+    const raced = await readExecutionState(input, registration);
+    if (raced === null)
+        throw new TypeError("collective_statistical_campaign_state_conflict");
+    return raced;
+}
+async function readExecutionState(input, registration) {
+    const state = await input.store.readExecutionStateV1({
+        executionId: input.executionId,
+        registrationDigest: registration.registrationDigest,
+    });
+    return state === null
+        ? null
+        : validatePersistedState(state, input.executionId, registration);
+}
+async function compareAndSwapExecutionState(input, mutation) {
+    if (input.operationExpiresAtMs === undefined)
+        return input.store.compareAndSwapExecutionStateV1(mutation);
+    const fenced = input.store;
+    if (typeof fenced.compareAndSwapExecutionStateWithDeadlineV1 !== "function")
+        throw new TypeError("collective_statistical_campaign_deadline_state_store_required");
+    return fenced.compareAndSwapExecutionStateWithDeadlineV1({
+        ...mutation,
+        operationExpiresAtMs: input.operationExpiresAtMs,
+    });
+}
+function validatePersistedState(state, executionId, registration) {
+    validateCollectiveEvaluationCampaignExecutionV1(state);
+    if (state.executionId !== executionId ||
+        state.registrationDigest !== registration.registrationDigest ||
+        state.cells.length !== registration.cells.length ||
+        state.cells.some((cell, index) => cell.cellId !== registration.cells[index]?.cellId ||
+            cell.runs.length !== 4))
+        throw new TypeError("collective_statistical_campaign_persisted_state_invalid");
+    for (const cell of registration.cells) {
+        for (const runner of runners) {
+            for (const attempt of attempts) {
+                const expected = collectiveEvaluationRunKeyV1({
+                    executionId: state.executionId,
+                    registrationDigest: registration.registrationDigest,
+                    cellId: cell.cellId,
+                    runner,
+                    attempt,
+                });
+                if (runKeyFor(state, cell.cellId, runner, attempt) !== expected)
+                    throw new TypeError("collective_statistical_campaign_persisted_state_run_key_invalid");
+            }
+        }
+    }
+    return state;
+}
+function settlementFields(execution, cell) {
+    return execution.sample.status === "passed"
+        ? {
+            result: {
+                resultDigest: execution.sample.sampleDigest,
+                traceDigest: execution.trace.traceDigest,
+                ledgerDigest: execution.ledger.ledgerDigest,
+                evidenceDigest: execution.evidence.evidenceDigest,
+                fairnessDigest: cell.scaleConfigurationDigest,
+            },
+            reasonCode: null,
+        }
+        : {
+            result: null,
+            reasonCode: execution.reasonCode ?? "runner_failed",
+        };
+}
+function settleStoredExecution(state, executionId, cell, runner, attempt, runKey, nowMs, execution, expectedFence = null) {
+    const currentCell = cellFor(state, cell.cellId);
+    const slot = runFor(currentCell, runner, attempt);
+    const fields = settlementFields(execution, cell);
+    if (slot.status === "succeeded" || slot.status === "failed") {
+        if (slot.settlementFence === null || slot.settledFromRevision === null)
+            throw new TypeError("collective_statistical_campaign_terminal_settlement_invalid");
+        return settleCollectiveEvaluationRunV1(state, {
+            executionId,
+            expectedRevision: slot.settledFromRevision,
+            cellId: cell.cellId,
+            runner,
+            attempt,
+            nowMs,
+            fence: slot.settlementFence,
+            ...fields,
+        }).state;
+    }
+    if (slot.status !== "running" || slot.runKey !== runKey)
+        throw new TypeError("collective_statistical_campaign_run_not_settleable");
+    const currentFence = fenceFor(state, cell.cellId);
+    if (expectedFence !== null &&
+        !sameExecutionFence(expectedFence, currentFence))
+        throw new TypeError("collective_statistical_campaign_run_fence_changed");
+    return currentFence.expiresAtMs <= nowMs
+        ? reconcileCollectiveEvaluationRunV1(state, {
+            executionId,
+            expectedRevision: state.revision,
+            cellId: cell.cellId,
+            runner,
+            attempt,
+            runKey: runKey,
+            nowMs,
+            ...fields,
+        }).state
+        : settleCollectiveEvaluationRunV1(state, {
+            executionId,
+            expectedRevision: state.revision,
+            cellId: cell.cellId,
+            runner,
+            attempt,
+            nowMs,
+            fence: currentFence,
+            ...fields,
+        }).state;
+}
+function sameExecutionFence(left, right) {
+    return (left.workerId === right.workerId &&
+        left.leaseToken === right.leaseToken &&
+        left.generation === right.generation &&
+        left.expiresAtMs === right.expiresAtMs);
+}
+function createFailedExecution(executionId, registrationDigest, runKey, cell, runner, attempt, reasonCode) {
+    return createCollectiveStatisticalCampaignExecutionArtifactsV1({
+        schemaVersion: 1,
+        executionId,
+        runKey,
+        registrationDigest,
+        cell,
+        runner,
+        attempt,
+        output: {
+            schemaVersion: 1,
+            status: "failed",
+            reasonCode,
+            outcome: { reasonCode },
+            traceRecords: [],
+            ledgerRecords: [],
+            observations: [],
+        },
+    });
+}
+function cellFor(state, cellId) {
+    const cell = state.cells.find((entry) => entry.cellId === cellId);
+    if (!cell)
+        throw new TypeError("collective_statistical_campaign_cell_missing");
+    return cell;
+}
+function runFor(cell, runner, attempt) {
+    const run = cell.runs.find((entry) => entry.runner === runner && entry.attempt === attempt);
+    if (!run)
+        throw new TypeError("collective_statistical_campaign_run_slot_missing");
+    return run;
+}
+/** Replays immutable commits into a fresh state and finalizes only a full closure. */
+export function reconstructCollectiveStatisticalCampaignExecutionV1(input) {
+    if (input.schemaVersion !== 1)
+        throw new TypeError("collective_statistical_campaign_reconstruction_invalid");
+    const registration = validateCollectiveEvaluationCampaignRegistrationV1(input.registration);
+    const expectedSlotCount = registration.cells.length * 4;
+    if (input.executions.length !== expectedSlotCount)
+        throw new TypeError("collective_statistical_campaign_reconstruction_incomplete");
+    const bySlot = new Map();
+    for (const execution of input.executions) {
+        const slotKey = `${execution.cellId}\0${execution.runner}\0${execution.attempt}`;
+        if (bySlot.has(slotKey))
+            throw new TypeError("collective_statistical_campaign_reconstruction_duplicate_slot");
+        bySlot.set(slotKey, execution);
+    }
+    if (bySlot.size !== expectedSlotCount)
+        throw new TypeError("collective_statistical_campaign_reconstruction_incomplete");
+    let state = createCollectiveEvaluationCampaignExecutionV1({
+        schemaVersion: 1,
+        executionId: input.executionId,
+        registration,
+    });
+    let logicalTimeMs = 1;
+    for (const cell of registration.cells) {
+        state = claimCollectiveEvaluationCellV1(state, {
+            executionId: input.executionId,
+            expectedRevision: state.revision,
+            cellId: cell.cellId,
+            nowMs: logicalTimeMs,
+            lease: {
+                workerId: "worker:reconstruction",
+                leaseToken: `lease:reconstruction:${cell.peerCount}:${cell.stratum}:${cell.seed}`,
+                expiresAtMs: logicalTimeMs + 10_000,
+            },
+        });
+        for (const runner of runners) {
+            for (const attempt of attempts) {
+                const execution = bySlot.get(`${cell.cellId}\0${runner}\0${attempt}`);
+                if (!execution)
+                    throw new TypeError("collective_statistical_campaign_reconstruction_missing_slot");
+                const runKey = runKeyFor(state, cell.cellId, runner, attempt);
+                const validatedExecution = validateStoredExecution(registration, input.executionId, cell, runner, attempt, runKey, execution);
+                const fence = fenceFor(state, cell.cellId);
+                state = startCollectiveEvaluationRunV1(state, {
+                    executionId: input.executionId,
+                    expectedRevision: state.revision,
+                    cellId: cell.cellId,
+                    runner,
+                    attempt,
+                    nowMs: logicalTimeMs,
+                    fence,
+                });
+                state = settleCollectiveEvaluationRunV1(state, {
+                    executionId: input.executionId,
+                    expectedRevision: state.revision,
+                    cellId: cell.cellId,
+                    runner,
+                    attempt,
+                    nowMs: logicalTimeMs,
+                    fence,
+                    result: validatedExecution.sample.status === "passed"
+                        ? {
+                            resultDigest: validatedExecution.sample.sampleDigest,
+                            traceDigest: validatedExecution.trace.traceDigest,
+                            ledgerDigest: validatedExecution.ledger.ledgerDigest,
+                            evidenceDigest: validatedExecution.evidence.evidenceDigest,
+                            fairnessDigest: cell.scaleConfigurationDigest,
+                        }
+                        : null,
+                    reasonCode: validatedExecution.sample.status === "failed"
+                        ? (validatedExecution.reasonCode ?? "runner_failed")
+                        : null,
+                }).state;
+                logicalTimeMs += 1;
+            }
+        }
+    }
+    return finalizeCollectiveEvaluationCampaignExecutionV1(state, registration, state.revision);
+}
+export function createMemoryCollectiveStatisticalCampaignExecutionStoreV1(clockSource = Date.now) {
+    if (typeof clockSource !== "function")
+        throw new TypeError("collective_statistical_campaign_store_clock_invalid");
+    const values = new Map();
+    const provenances = new Map();
+    const states = new Map();
+    const compareAndSwapState = (input) => {
+        if (input.state.executionId !== input.executionId)
+            throw new TypeError("collective_statistical_campaign_state_execution_conflict");
+        const existing = states.get(input.executionId);
+        if (existing === undefined) {
+            if (input.expectedExecutionDigest !== null)
+                return "conflict";
+        }
+        else {
+            const current = JSON.parse(existing);
+            if (current.executionDigest !== input.expectedExecutionDigest)
+                return "conflict";
+            const serialized = json(input.state);
+            if (serialized === existing)
+                return "duplicate";
+            states.set(input.executionId, serialized);
+            return "committed";
+        }
+        states.set(input.executionId, json(input.state));
+        return "committed";
+    };
+    return Object.freeze({
+        schemaVersion: 1,
+        async readExecutionStateV1({ executionId, registrationDigest, }) {
+            const serialized = states.get(executionId);
+            if (serialized === undefined)
+                return null;
+            const state = JSON.parse(serialized);
+            if (state.registrationDigest !== registrationDigest)
+                throw new TypeError("collective_statistical_campaign_state_registration_conflict");
+            return state;
+        },
+        async compareAndSwapExecutionStateV1(input) {
+            return compareAndSwapState(input);
+        },
+        async compareAndSwapExecutionStateWithDeadlineV1(input) {
+            if (!Number.isSafeInteger(input.operationExpiresAtMs) ||
+                clock(clockSource) >= input.operationExpiresAtMs)
+                return "expired";
+            return compareAndSwapState(input);
+        },
+        async readExecutionsV1(runKeys) {
+            if (!Array.isArray(runKeys) || runKeys.length > 4_096)
+                throw new RangeError("collective_statistical_campaign_store_read_limit_exceeded");
+            return Object.freeze(runKeys.map((runKey) => {
+                requireRunKey(runKey);
+                const serialized = values.get(runKey);
+                return Object.freeze({
+                    runKey,
+                    execution: serialized === undefined
+                        ? null
+                        : JSON.parse(serialized),
+                });
+            }));
+        },
+        async commitExecutionV1({ runKey, execution, }) {
+            requireRunKey(runKey);
+            const serialized = json(execution);
+            const existing = values.get(runKey);
+            if (existing !== undefined) {
+                if (existing !== serialized)
+                    throw new TypeError("collective_statistical_campaign_store_commit_conflict");
+                return "duplicate";
+            }
+            values.set(runKey, serialized);
+            return "committed";
+        },
+        async readExecutionWithFenceV1({ executionId, registrationDigest, cellId, runKey, fence, operationExpiresAtMs = null, }) {
+            requireRunKey(runKey);
+            const serialized = values.get(runKey);
+            if (serialized === undefined)
+                return null;
+            const provenance = provenances.get(runKey);
+            if (provenance === undefined ||
+                provenance.executionId !== executionId ||
+                provenance.registrationDigest !== registrationDigest ||
+                provenance.cellId !== cellId ||
+                provenance.operationExpiresAtMs !== operationExpiresAtMs ||
+                !sameExecutionFence(provenance.fence, fence))
+                throw new TypeError("collective_statistical_campaign_store_commit_provenance_invalid");
+            return JSON.parse(serialized);
+        },
+        async commitExecutionWithFenceV1({ executionId, registrationDigest, cellId, runKey, fence, operationExpiresAtMs, execution, }) {
+            requireRunKey(runKey);
+            if (execution.executionId !== executionId ||
+                execution.cellId !== cellId ||
+                execution.runKey !== runKey)
+                throw new TypeError("collective_statistical_campaign_store_commit_scope_invalid");
+            const serializedState = states.get(executionId);
+            const nowMs = clock(clockSource);
+            if (serializedState === undefined)
+                return "stale_fence";
+            const state = JSON.parse(serializedState);
+            if ((operationExpiresAtMs != null &&
+                (!Number.isSafeInteger(operationExpiresAtMs) ||
+                    nowMs >= operationExpiresAtMs)) ||
+                state.registrationDigest !== registrationDigest ||
+                !activeExecutionFence(state, cellId, runKey, fence, nowMs))
+                return "stale_fence";
+            const serialized = json(execution);
+            const existing = values.get(runKey);
+            if (existing !== undefined) {
+                if (existing !== serialized)
+                    throw new TypeError("collective_statistical_campaign_store_commit_conflict");
+                const provenance = provenances.get(runKey);
+                if (provenance === undefined ||
+                    provenance.executionId !== executionId ||
+                    provenance.registrationDigest !== registrationDigest ||
+                    provenance.cellId !== cellId ||
+                    provenance.operationExpiresAtMs !== (operationExpiresAtMs ?? null) ||
+                    !sameExecutionFence(provenance.fence, fence))
+                    throw new TypeError("collective_statistical_campaign_store_commit_provenance_invalid");
+                return "duplicate";
+            }
+            values.set(runKey, serialized);
+            provenances.set(runKey, Object.freeze({
+                executionId,
+                registrationDigest,
+                cellId,
+                operationExpiresAtMs: operationExpiresAtMs ?? null,
+                fence: Object.freeze({ ...fence }),
+            }));
+            return "committed";
+        },
+    });
+}
+async function commitExecution(input, registrationDigest, cellId, runKey, fence, execution) {
+    assertOperationActive(input, clock(input.now));
+    const store = input.store;
+    if (typeof store.commitExecutionWithFenceV1 !== "function")
+        return store.commitExecutionV1({ runKey, execution });
+    const status = await store.commitExecutionWithFenceV1({
+        executionId: input.executionId,
+        registrationDigest,
+        cellId,
+        runKey,
+        fence,
+        operationExpiresAtMs: input.operationExpiresAtMs ?? null,
+        execution,
+    });
+    if (status === "stale_fence")
+        throw new TypeError("collective_statistical_campaign_execution_commit_stale_fence");
+    if (status !== "committed" && status !== "duplicate")
+        throw new TypeError("collective_statistical_campaign_execution_commit_invalid");
+    return status;
+}
+function activeExecutionFence(state, cellId, runKey, fence, nowMs) {
+    const cell = state.cells.find((candidate) => candidate.cellId === cellId);
+    const current = cell?.lease;
+    const slot = cell?.runs.find((candidate) => candidate.runKey === runKey);
+    return (cell?.status === "running" &&
+        slot?.status === "running" &&
+        current !== null &&
+        current !== undefined &&
+        current.expiresAtMs > nowMs &&
+        sameExecutionFence(current, fence));
+}
+function validateExecutorInput(input) {
+    if (!input ||
+        input.schemaVersion !== 1 ||
+        typeof input.executionId !== "string" ||
+        !/^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/u.test(input.executionId) ||
+        typeof input.workerId !== "string" ||
+        !/^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/u.test(input.workerId) ||
+        !input.shard ||
+        input.shard.schemaVersion !== 1 ||
+        !Number.isSafeInteger(input.shard.index) ||
+        !Number.isSafeInteger(input.shard.count) ||
+        input.shard.count < 1 ||
+        input.shard.count > 256 ||
+        input.shard.index < 0 ||
+        input.shard.index >= input.shard.count ||
+        !Number.isSafeInteger(input.leaseDurationMs) ||
+        input.leaseDurationMs < 1_000 ||
+        input.leaseDurationMs > 86_400_000 ||
+        !Number.isSafeInteger(input.maximumCells) ||
+        input.maximumCells < 1 ||
+        input.maximumCells > 240 ||
+        (input.operationExpiresAtMs !== undefined &&
+            (!Number.isSafeInteger(input.operationExpiresAtMs) ||
+                input.operationExpiresAtMs < 0)) ||
+        !input.store ||
+        input.store.schemaVersion !== 1 ||
+        typeof input.store.readExecutionStateV1 !== "function" ||
+        typeof input.store.compareAndSwapExecutionStateV1 !== "function" ||
+        typeof input.store.readExecutionsV1 !== "function" ||
+        typeof input.store.commitExecutionV1 !== "function" ||
+        typeof input.now !== "function" ||
+        typeof input.execute !== "function")
+        throw new TypeError("collective_statistical_campaign_executor_input_invalid");
+}
+function selectExplicitCells(registration, cellIds) {
+    if (!Array.isArray(cellIds) || cellIds.length === 0 || cellIds.length > 240)
+        throw new TypeError("collective_statistical_campaign_executor_cell_ids_invalid");
+    const expected = new Set(registration.cells.map((cell) => cell.cellId));
+    const selected = [];
+    const seen = new Set();
+    for (const cellId of cellIds) {
+        if (typeof cellId !== "string" || !expected.has(cellId) || seen.has(cellId))
+            throw new TypeError("collective_statistical_campaign_executor_cell_ids_invalid");
+        seen.add(cellId);
+        const cell = registration.cells.find((entry) => entry.cellId === cellId);
+        if (!cell)
+            throw new TypeError("collective_statistical_campaign_executor_cell_ids_invalid");
+        selected.push(cell);
+    }
+    return Object.freeze(selected);
+}
+async function readOne(store, runKey, provenance) {
+    const fenced = store;
+    if (provenance !== undefined &&
+        typeof fenced.readExecutionWithFenceV1 === "function")
+        return fenced.readExecutionWithFenceV1({
+            ...provenance,
+            runKey,
+        });
+    const result = await store.readExecutionsV1([runKey]);
+    if (!Array.isArray(result) ||
+        result.length !== 1 ||
+        result[0]?.runKey !== runKey)
+        throw new TypeError("collective_statistical_campaign_store_read_invalid");
+    return result[0].execution;
+}
+function assertOperationActive(input, nowMs) {
+    if (input.operationExpiresAtMs !== undefined &&
+        nowMs >= input.operationExpiresAtMs)
+        throw new TypeError("collective_statistical_campaign_operation_authorization_expired");
+}
+function boundedLeaseExpiry(input, nowMs) {
+    const requested = safeAdd(nowMs, input.leaseDurationMs);
+    const expiresAtMs = input.operationExpiresAtMs === undefined
+        ? requested
+        : Math.min(requested, input.operationExpiresAtMs);
+    if (expiresAtMs <= nowMs)
+        throw new TypeError("collective_statistical_campaign_operation_authorization_expired");
+    return expiresAtMs;
+}
+function validateStoredExecution(registration, executionId, cell, runner, attempt, runKey, execution) {
+    if (runKey !==
+        collectiveEvaluationRunKeyV1({
+            executionId,
+            registrationDigest: registration.registrationDigest,
+            cellId: cell.cellId,
+            runner,
+            attempt,
+        }) ||
+        execution.executionId !== executionId ||
+        execution.runKey !== runKey ||
+        execution.cellId !== cell.cellId ||
+        execution.seed !== cell.seed ||
+        execution.runner !== runner ||
+        execution.attempt !== attempt)
+        throw new TypeError("collective_statistical_campaign_stored_execution_scope_invalid");
+    const validated = createCollectiveStatisticalCampaignExecutionArtifactsV1({
+        schemaVersion: 1,
+        executionId,
+        runKey,
+        registrationDigest: registration.registrationDigest,
+        cell,
+        runner,
+        attempt,
+        output: {
+            schemaVersion: 1,
+            status: execution.sample.status,
+            reasonCode: execution.reasonCode,
+            outcome: execution.sample.outcome,
+            traceRecords: execution.trace.records,
+            ledgerRecords: execution.ledger.records,
+            observations: execution.evidence.observations,
+        },
+    });
+    if (json(validated) !== json(execution))
+        throw new TypeError("collective_statistical_campaign_stored_execution_invalid");
+    return validated;
+}
+function runKeyFor(state, cellId, runner, attempt) {
+    const cell = state.cells.find((entry) => entry.cellId === cellId);
+    const slot = cell?.runs.find((entry) => entry.runner === runner && entry.attempt === attempt);
+    if (!slot)
+        throw new TypeError("collective_statistical_campaign_run_slot_missing");
+    return slot.runKey;
+}
+function fenceFor(state, cellId) {
+    const lease = state.cells.find((cell) => cell.cellId === cellId)?.lease;
+    if (!lease)
+        throw new TypeError("collective_statistical_campaign_cell_not_leased");
+    return lease;
+}
+function requireRunKey(value) {
+    if (typeof value !== "string" || !/^sha256:[0-9a-f]{64}$/u.test(value))
+        throw new TypeError("collective_statistical_campaign_run_key_invalid");
+}
+function clock(now) {
+    const value = now();
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new TypeError("collective_statistical_campaign_clock_invalid");
+    return value;
+}
+function safeAdd(left, right) {
+    const value = left + right;
+    if (!Number.isSafeInteger(value))
+        throw new RangeError("collective_statistical_campaign_time_overflow");
+    return value;
+}
+function publicRunnerErrorCode(error) {
+    const message = error instanceof Error ? error.message : "";
+    return /^[a-z0-9_]{1,120}$/u.test(message) ? message : "invalid";
+}
+function json(value) {
+    return canonicalizePlanningJsonV1(value, {
+        maximumBytes: 67_108_864,
+        maximumDepth: 64,
+        maximumNodes: 2_000_000,
+        maximumKeysPerObject: 4_096,
+        maximumItemsPerArray: 262_144,
+    });
+}
+//# sourceMappingURL=collective-statistical-campaign-executor.js.map