maka-agent 0.2.0-dev.6.20260830 → 0.2.0-dev.64.20260929

package/node_modules/@maka/eval/dist/fleet-store.js

@@ -0,0 +1,243 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { stableJsonStringify } from '@maka/core/canonical-json';
+import { createFleetState, transitionFleet, } from './fleet.js';
+export class FleetCoordinator {
+    persistence;
+    now;
+    static #owners = new WeakSet();
+    #tail = Promise.resolve();
+    #closed = false;
+    constructor(persistence, now) {
+        this.persistence = persistence;
+        this.now = now;
+    }
+    static async open(input) {
+        if (FleetCoordinator.#owners.has(input.persistence))
+            throw new Error('fleet persistence already has a coordinator');
+        FleetCoordinator.#owners.add(input.persistence);
+        try {
+            const initial = createFleetState(input.spec, input.policy);
+            const existing = await input.persistence.load();
+            if (existing &&
+                (existing.version !== initial.version ||
+                    stableJsonStringify(existing.spec) !== stableJsonStringify(initial.spec) ||
+                    stableJsonStringify(existing.policy) !== stableJsonStringify(initial.policy))) {
+                throw new Error('fleet run identity differs');
+            }
+            if (!existing)
+                await input.persistence.save(initial);
+            const coordinator = new FleetCoordinator(input.persistence, input.now);
+            await coordinator.command({ kind: 'recover' });
+            return coordinator;
+        }
+        catch (error) {
+            FleetCoordinator.#owners.delete(input.persistence);
+            throw error;
+        }
+    }
+    command(command) {
+        if (this.#closed)
+            return Promise.reject(new Error('coordinator closed'));
+        const captured = structuredClone(command);
+        const operation = this.#tail.then(async () => {
+            const state = await this.persistence.load();
+            if (!state)
+                throw new Error('fleet state missing');
+            if (captured.kind === 'report') {
+                for (const artifact of captured.report.artifacts)
+                    await this.persistence.getArtifact(artifact);
+            }
+            const next = transitionFleet(state, captured, this.now());
+            await this.persistence.save(next.state);
+            return next.reply;
+        });
+        this.#tail = operation.catch(() => undefined);
+        return operation;
+    }
+    async snapshot() {
+        await this.#tail;
+        const state = await this.persistence.load();
+        if (!state)
+            throw new Error('fleet state missing');
+        return state;
+    }
+    putArtifact(bytes) {
+        if (this.#closed)
+            return Promise.reject(new Error('coordinator closed'));
+        return this.persistence.putArtifact(bytes);
+    }
+    /** Stop accepting commands and drain commits before closing persistence or replacing this owner. */
+    async close() {
+        if (this.#closed) {
+            await this.#tail;
+            return;
+        }
+        this.#closed = true;
+        await this.#tail;
+        FleetCoordinator.#owners.delete(this.persistence);
+    }
+}
+export class MemoryFleetPersistence {
+    #state = null;
+    #artifacts = new Map();
+    async load() {
+        return structuredClone(this.#state);
+    }
+    async save(state) {
+        this.#state = structuredClone(state);
+    }
+    async putArtifact(bytes) {
+        const ref = reference(bytes);
+        this.#artifacts.set(ref.sha256, Uint8Array.from(bytes));
+        return ref;
+    }
+    async getArtifact(ref) {
+        validateReference(ref);
+        const bytes = this.#artifacts.get(ref.sha256);
+        if (!bytes)
+            throw new Error('artifact missing');
+        verifyArtifact(ref, bytes);
+        return Uint8Array.from(bytes);
+    }
+}
+/** Local coordinator storage. A stale writer lock requires explicit operator recovery. */
+export class FileFleetPersistence {
+    root;
+    release;
+    #tail = Promise.resolve();
+    #closing;
+    constructor(root, release) {
+        this.root = root;
+        this.release = release;
+    }
+    static async open(root) {
+        await mkdir(root, { recursive: true });
+        const lockPath = join(root, '.writer.lock');
+        const lock = await open(lockPath, 'wx', 0o600);
+        let closed = false;
+        return new FileFleetPersistence(root, async () => {
+            if (closed)
+                return;
+            closed = true;
+            await lock.close();
+            await unlink(lockPath);
+        });
+    }
+    async close() {
+        this.#closing ??= this.#tail.then(() => this.release());
+        await this.#closing;
+    }
+    #operation(operation) {
+        if (this.#closing)
+            return Promise.reject(new Error('fleet persistence closed'));
+        const running = this.#tail.then(operation);
+        this.#tail = running.catch(() => undefined);
+        return running;
+    }
+    load() {
+        return this.#operation(() => this.#load());
+    }
+    async #load() {
+        let raw;
+        try {
+            raw = await readFile(join(this.root, 'state.json'), 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+        const envelope = JSON.parse(raw);
+        if (digest(Buffer.from(stableJsonStringify(envelope.state))) !== envelope.sha256) {
+            throw new Error('fleet state checksum mismatch');
+        }
+        if (envelope.state.version !== 'maka.eval.fleet.v1')
+            throw new Error('unsupported fleet state');
+        return envelope.state;
+    }
+    async save(state) {
+        const canonical = stableJsonStringify(state);
+        const bytes = Buffer.from(JSON.stringify({ sha256: digest(Buffer.from(canonical)), state }));
+        await this.#operation(() => atomicWrite(this.root, 'state.json', bytes));
+    }
+    async putArtifact(bytes) {
+        const captured = Uint8Array.from(bytes);
+        return this.#operation(async () => {
+            const ref = reference(captured);
+            const directory = join(this.root, 'artifacts');
+            await mkdir(directory, { recursive: true });
+            await atomicWrite(directory, ref.sha256, captured);
+            return ref;
+        });
+    }
+    async getArtifact(ref) {
+        validateReference(ref);
+        const captured = { ...ref };
+        return this.#operation(async () => {
+            const bytes = await readFile(join(this.root, 'artifacts', captured.sha256));
+            verifyArtifact(captured, bytes);
+            return bytes;
+        });
+    }
+}
+async function atomicWrite(directory, name, bytes) {
+    const temporary = join(directory, `.${name}.${randomUUID()}.tmp`);
+    const file = await open(temporary, 'wx', 0o600);
+    try {
+        await file.writeFile(bytes);
+        await file.sync();
+        await file.close();
+        await rename(temporary, join(directory, name));
+        if (process.platform !== 'win32') {
+            const parent = await open(directory, 'r');
+            try {
+                await parent.sync();
+            }
+            finally {
+                await parent.close();
+            }
+        }
+    }
+    finally {
+        await file.close().catch(() => undefined);
+        await unlink(temporary).catch((error) => {
+            if (error.code !== 'ENOENT')
+                throw error;
+        });
+    }
+}
+function digest(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+function reference(bytes) {
+    return { sha256: digest(bytes), bytes: bytes.byteLength };
+}
+function validateReference(ref) {
+    if (!/^[a-f0-9]{64}$/.test(ref.sha256) || !Number.isSafeInteger(ref.bytes) || ref.bytes < 0) {
+        throw new Error('invalid artifact reference');
+    }
+}
+function verifyArtifact(ref, bytes) {
+    if (bytes.byteLength !== ref.bytes || digest(bytes) !== ref.sha256)
+        throw new Error('artifact checksum mismatch');
+}

package/node_modules/@maka/eval/dist/fleet-worker.js

@@ -0,0 +1,125 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Transport-independent worker loop. Its outbox survives disconnection, not process death.
+ * The caller drives polling; no wall clock, timers, networking or cloud SDK is hidden here.
+ */
+export class FleetWorker {
+    description;
+    transport;
+    execute;
+    #runs = new Map();
+    #outbox = new Map();
+    #polling;
+    constructor(description, transport, execute) {
+        this.description = description;
+        this.transport = transport;
+        this.execute = execute;
+    }
+    poll() {
+        this.#polling ??= this.#poll().finally(() => {
+            this.#polling = undefined;
+        });
+        return this.#polling;
+    }
+    get bufferedReports() {
+        return this.#outbox.size;
+    }
+    get activeGroups() {
+        return this.#runs.size;
+    }
+    async #poll() {
+        await this.transport.command({ kind: 'register', worker: this.description });
+        const heartbeat = await this.transport.command({
+            kind: 'heartbeat',
+            workerId: this.description.id,
+            assignmentIds: [...this.#runs.keys()],
+        });
+        for (const work of heartbeat.work ?? [])
+            this.#adopt(work);
+        for (const [attemptId, output] of this.#outbox) {
+            const artifacts = [];
+            for (const bytes of output.artifacts)
+                artifacts.push(await this.transport.putArtifact(bytes));
+            await this.transport.command({
+                kind: 'report',
+                workerId: this.description.id,
+                attemptId,
+                report: { ...output.report, artifacts },
+            });
+            this.#outbox.delete(attemptId);
+        }
+        for (const [assignmentId, run] of this.#runs) {
+            if (!run.settled || run.work.cells.some((cell) => this.#outbox.has(cell.attemptId)))
+                continue;
+            await this.transport.command({ kind: 'finish', workerId: this.description.id, assignmentId });
+            this.#runs.delete(assignmentId);
+        }
+        while (this.#runs.size < this.description.groupSlots) {
+            const reply = await this.transport.command({ kind: 'claim', workerId: this.description.id });
+            if (!reply.assignment)
+                break;
+            for (const work of reply.work ?? [])
+                this.#adopt(work);
+        }
+    }
+    #adopt(work) {
+        if (this.#runs.has(work.assignment.id))
+            return;
+        const run = { work, settled: false, emitted: new Set() };
+        this.#runs.set(work.assignment.id, run);
+        const emit = (attemptId, output) => {
+            if (!work.cells.some((cell) => cell.attemptId === attemptId) || run.emitted.has(attemptId)) {
+                throw new Error('executor emitted an unknown or duplicate attempt');
+            }
+            run.emitted.add(attemptId);
+            this.#outbox.set(attemptId, structuredClone(output));
+        };
+        // A failed local operation is an execution uncertainty, not a provider classification.
+        void Promise.resolve()
+            .then(() => this.execute(work, emit))
+            .catch(() => undefined)
+            .finally(() => {
+            for (const cell of work.cells) {
+                if (run.emitted.has(cell.attemptId))
+                    continue;
+                emit(cell.attemptId, {
+                    report: {
+                        result: {
+                            status: 'infra_failed',
+                            score: null,
+                            usage: null,
+                            costUsd: null,
+                            durationMs: 0,
+                            failureReason: 'worker execution ended without a cell report',
+                            artifacts: [],
+                        },
+                        execution: 'unknown',
+                        verification: 'not_run',
+                        usage: 'missing',
+                        cleanup: 'unknown',
+                        environmentFailure: null,
+                    },
+                    artifacts: [],
+                });
+            }
+            run.settled = true;
+        });
+    }
+}

package/node_modules/@maka/eval/dist/fleet.js

@@ -0,0 +1,329 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { stableJsonStringify } from '@maka/core/canonical-json';
+import { expandExperiment } from './experiment.js';
+import { decodeEvalResult } from './result.js';
+import { parseExperimentSpec } from './spec.js';
+export function createFleetState(spec, policy) {
+    const frozenSpec = parseExperimentSpec(spec);
+    for (const key of ['runId', 'environmentId'])
+        nonempty(policy[key], key);
+    for (const key of [
+        'groupCpus',
+        'groupMemoryMb',
+        'leaseMs',
+        'recoveryGraceMs',
+        'maxAttemptsPerCell',
+    ])
+        positive(policy[key], key);
+    if (!Number.isSafeInteger(policy.retryBackoffMs) || policy.retryBackoffMs < 0) {
+        throw new Error('invalid retryBackoffMs');
+    }
+    const groups = new Map();
+    const ids = new Set();
+    for (const cell of expandExperiment(frozenSpec)) {
+        if (ids.has(cell.id))
+            throw new Error('ambiguous experiment cell identity');
+        ids.add(cell.id);
+        const id = JSON.stringify([cell.task.id, cell.repetition]);
+        const group = groups.get(id) ?? [];
+        group.push(cell.id);
+        groups.set(id, group);
+    }
+    return {
+        version: 'maka.eval.fleet.v1',
+        spec: frozenSpec,
+        policy: structuredClone(policy),
+        clock: 0,
+        nextAssignment: 1,
+        workers: [],
+        assignments: [],
+        attempts: [],
+        blocked: [],
+        paused: false,
+        groups: [...groups].map(([id, cellIds]) => ({ id, cellIds, generation: 0, readyAt: 0 })),
+    };
+}
+/** Pure deterministic transition. Persist the returned state before delivering its reply. */
+export function transitionFleet(previous, command, now) {
+    if (!Number.isSafeInteger(now) || now < 0)
+        throw new Error('invalid fleet clock');
+    const state = structuredClone(previous);
+    state.clock = Math.max(state.clock, now);
+    if (command.kind === 'pause') {
+        state.paused = true;
+        return { state, reply: {} };
+    }
+    // Recovery must run BEFORE expiry: a coordinator outage is not evidence of VM loss.
+    if (command.kind === 'recover') {
+        state.paused = false;
+        for (const worker of state.workers)
+            worker.reconciled = false;
+        for (const assignment of active(state)) {
+            assignment.expiresAt = Math.max(assignment.expiresAt, state.clock + state.policy.recoveryGraceMs);
+        }
+        return { state, reply: {} };
+    }
+    for (const assignment of active(state)) {
+        if (!state.paused && assignment.expiresAt <= state.clock)
+            settle(state, assignment, 'expired');
+    }
+    const reply = {};
+    switch (command.kind) {
+        case 'register': {
+            const description = command.worker;
+            nonempty(description.id, 'worker id');
+            positive(description.groupSlots, 'groupSlots');
+            positive(description.cpus, 'cpus');
+            positive(description.memoryMb, 'memoryMb');
+            if (description.environmentId !== state.policy.environmentId ||
+                description.cpus < description.groupSlots * state.policy.groupCpus ||
+                description.memoryMb < description.groupSlots * state.policy.groupMemoryMb) {
+                throw new Error('worker does not satisfy execution and verifier admission');
+            }
+            const existing = state.workers.find((w) => w.description.id === description.id);
+            if (existing &&
+                stableJsonStringify(existing.description) !== stableJsonStringify(description)) {
+                throw new Error('worker incarnation changed description');
+            }
+            if (!existing)
+                state.workers.push({ description: structuredClone(description), reconciled: false });
+            break;
+        }
+        case 'heartbeat': {
+            const worker = requireWorker(state, command.workerId);
+            if (new Set(command.assignmentIds).size !== command.assignmentIds.length) {
+                throw new Error('duplicate heartbeat assignment');
+            }
+            for (const id of command.assignmentIds) {
+                const assignment = requireAssignment(state, command.workerId, id);
+                if (assignment.status === 'active')
+                    assignment.expiresAt = state.clock + state.policy.leaseMs;
+            }
+            // Omitted assignments are allowed to expire; they are not silently renewed.
+            worker.reconciled = true;
+            reply.activeAssignmentIds = active(state)
+                .filter((a) => a.workerId === command.workerId)
+                .map((a) => a.id);
+            // Includes a claim whose reply was lost. The worker can adopt it rather than leak a slot.
+            reply.work = active(state)
+                .filter((a) => a.workerId === command.workerId)
+                .map((a) => workFor(state, a));
+            break;
+        }
+        case 'claim': {
+            const worker = requireWorker(state, command.workerId);
+            const running = active(state);
+            if (state.paused ||
+                !worker.reconciled ||
+                state.blocked.length ||
+                running.length >= state.spec.execution.maxConcurrentTaskGroups ||
+                running.filter((a) => a.workerId === command.workerId).length >=
+                    worker.description.groupSlots)
+                break;
+            const group = state.groups.find((g) => g.readyAt <= state.clock &&
+                !running.some((a) => a.groupId === g.id) &&
+                pendingCells(state, g.cellIds).length > 0);
+            if (!group)
+                break;
+            const id = `${state.policy.runId}/assignment-${state.nextAssignment++}`;
+            const attempts = pendingCells(state, group.cellIds).map((cellId, index) => ({
+                id: `${id}/attempt-${index + 1}`,
+                cellId,
+                sequence: state.attempts.filter((a) => a.cellId === cellId).length + 1,
+                assignmentId: id,
+                report: null,
+                disposition: 'pending',
+            }));
+            const assignment = {
+                id,
+                groupId: group.id,
+                workerId: command.workerId,
+                generation: ++group.generation,
+                attemptIds: attempts.map((a) => a.id),
+                status: 'active',
+                expiresAt: state.clock + state.policy.leaseMs,
+            };
+            state.attempts.push(...attempts);
+            state.assignments.push(assignment);
+            reply.assignment = structuredClone(assignment);
+            reply.work = [workFor(state, assignment)];
+            break;
+        }
+        case 'report': {
+            const attempt = state.attempts.find((a) => a.id === command.attemptId);
+            if (!attempt)
+                throw new Error('unknown attempt');
+            const assignment = requireAssignment(state, command.workerId, attempt.assignmentId);
+            const report = validateFleetReport(command.report);
+            if (attempt.report) {
+                if (stableJsonStringify(attempt.report) !== stableJsonStringify(report)) {
+                    throw new Error('conflicting attempt report');
+                }
+            }
+            else {
+                attempt.report = report;
+                attempt.disposition =
+                    assignment.status !== 'active' ? 'late' : selectable(report) ? 'selected' : 'retryable';
+                if (attempt.disposition !== 'late' &&
+                    report.environmentFailure &&
+                    !state.blocked.includes(report.environmentFailure))
+                    state.blocked.push(report.environmentFailure);
+            }
+            reply.disposition = attempt.disposition;
+            break;
+        }
+        case 'finish': {
+            const assignment = requireAssignment(state, command.workerId, command.assignmentId);
+            if (assignment.status !== 'active')
+                break;
+            if (assignment.attemptIds.some((id) => !state.attempts.find((a) => a.id === id)?.report)) {
+                throw new Error('cannot finish before all cell reports are committed');
+            }
+            settle(state, assignment, 'finished');
+            break;
+        }
+        case 'repair':
+            state.blocked = state.blocked.filter((reason) => reason !== command.reason);
+            break;
+        case 'tick':
+            break;
+    }
+    return { state, reply };
+}
+export function summarizeFleet(state) {
+    const selected = state.attempts.filter((a) => a.disposition === 'selected');
+    const cells = state.groups.flatMap((g) => g.cellIds);
+    const running = active(state);
+    const exhausted = cells.filter((id) => !selected.some((a) => a.cellId === id) &&
+        !running.some((a) => a.attemptIds.some((attemptId) => state.attempts.some((attempt) => attempt.id === attemptId && attempt.cellId === id))) &&
+        state.attempts.filter((a) => a.cellId === id).length >= state.policy.maxAttemptsPerCell);
+    const reported = state.attempts.filter((a) => a.report);
+    return {
+        runId: state.policy.runId,
+        totalCells: cells.length,
+        completedCells: selected.length,
+        incompleteCells: cells.length - selected.length,
+        exhaustedCells: exhausted.length,
+        activeGroups: running.length,
+        blocked: [...state.blocked],
+        paused: state.paused,
+        settled: running.length === 0 && cells.length === selected.length + exhausted.length,
+        observedCostUsd: reported.reduce((sum, a) => sum + (a.report.result.costUsd ?? 0), 0),
+        usageComplete: state.attempts.every((a) => a.report?.usage === 'complete'),
+        results: selected.map((a) => ({
+            cellId: a.cellId,
+            attemptId: a.id,
+            result: selectedResult(a.report),
+            artifacts: structuredClone(a.report.artifacts),
+        })),
+    };
+}
+export function validateFleetReport(value) {
+    const report = structuredClone(value);
+    report.result = decodeEvalResult(value.result);
+    member(report.execution, ['completed', 'subject_failed', 'not_started', 'unknown'], 'execution');
+    member(report.verification, ['valid', 'invalid', 'not_run'], 'verification');
+    member(report.usage, ['complete', 'partial', 'missing'], 'usage');
+    member(report.cleanup, ['confirmed', 'unknown'], 'cleanup');
+    if (report.environmentFailure !== null)
+        nonempty(report.environmentFailure, 'environmentFailure');
+    if (!Array.isArray(report.artifacts))
+        throw new Error('invalid artifacts');
+    for (const artifact of report.artifacts) {
+        if (!/^[a-f0-9]{64}$/.test(artifact.sha256) ||
+            !Number.isSafeInteger(artifact.bytes) ||
+            artifact.bytes < 0) {
+            throw new Error('invalid artifact reference');
+        }
+    }
+    if (report.usage === 'missing' && report.result.usage !== null)
+        throw new Error('missing usage has tokens');
+    if (report.usage === 'complete' && report.result.usage === null)
+        throw new Error('complete usage lacks tokens');
+    if (report.usage !== 'complete' && report.result.costUsd !== null)
+        throw new Error('incomplete usage has settled cost');
+    if (report.verification === 'valid' &&
+        (report.result.score === null || !['completed', 'subject_failed'].includes(report.execution)))
+        throw new Error('invalid verification evidence');
+    return report;
+}
+function selectedResult(report) {
+    // Keep raw execution evidence in the attempt; project settled status only in selected results.
+    return {
+        ...report.result,
+        status: report.execution === 'subject_failed' || report.result.status === 'subject_failed'
+            ? 'subject_failed'
+            : 'completed',
+    };
+}
+function selectable(report) {
+    return (['completed', 'subject_failed'].includes(report.execution) &&
+        report.verification === 'valid' &&
+        report.cleanup === 'confirmed' &&
+        report.environmentFailure === null);
+}
+function active(state) {
+    return state.assignments.filter((a) => a.status === 'active');
+}
+function workFor(state, assignment) {
+    const cells = expandExperiment(state.spec);
+    return {
+        assignment: structuredClone(assignment),
+        cells: assignment.attemptIds.flatMap((id) => {
+            const attempt = state.attempts.find((a) => a.id === id);
+            return attempt.report
+                ? []
+                : [{ attemptId: id, cell: cells.find((c) => c.id === attempt.cellId) }];
+        }),
+    };
+}
+function pendingCells(state, ids) {
+    return ids.filter((id) => !state.attempts.some((a) => a.cellId === id && a.disposition === 'selected') &&
+        state.attempts.filter((a) => a.cellId === id).length < state.policy.maxAttemptsPerCell);
+}
+function requireWorker(state, id) {
+    const worker = state.workers.find((w) => w.description.id === id);
+    if (!worker)
+        throw new Error('unknown worker incarnation');
+    return worker;
+}
+function requireAssignment(state, workerId, id) {
+    const assignment = state.assignments.find((a) => a.id === id);
+    if (!assignment || assignment.workerId !== workerId)
+        throw new Error('unknown or foreign assignment');
+    return assignment;
+}
+function settle(state, assignment, status) {
+    assignment.status = status;
+    state.groups.find((g) => g.id === assignment.groupId).readyAt =
+        state.clock + state.policy.retryBackoffMs;
+}
+function positive(value, name) {
+    if (!Number.isSafeInteger(value) || value < 1)
+        throw new Error(`invalid ${name}`);
+}
+function nonempty(value, name) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new Error(`invalid ${name}`);
+}
+function member(value, values, name) {
+    if (!values.includes(value))
+        throw new Error(`invalid ${name}`);
+}