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

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

@@ -0,0 +1,885 @@
+import { canonicalizePlanningJsonV1, digestPlanningJsonV1, } from "@agentplat/collective-planning";
+import { validateCollectiveEvaluationCampaignManifestV1, validateCollectiveEvaluationCampaignRegistrationV1, } from "@agentplat/collective-planning/evaluation";
+export const COLLECTIVE_STATISTICAL_CAMPAIGN_MAXIMUM_ARTIFACT_BYTES_V1 = 16 * 1024 * 1024;
+export const COLLECTIVE_STATISTICAL_CAMPAIGN_MAXIMUM_BUNDLE_BYTES_V1 = 256 * 1024 * 1024;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true });
+const MAXIMUM_SNAPSHOT_DEPTH = 64;
+const MAXIMUM_SNAPSHOT_NODES = 1_000_000;
+const MAXIMUM_SNAPSHOT_FIELDS = 16_384;
+const ARTIFACT_JSON_LIMITS = Object.freeze({
+    maximumBytes: COLLECTIVE_STATISTICAL_CAMPAIGN_MAXIMUM_ARTIFACT_BYTES_V1,
+    maximumDepth: MAXIMUM_SNAPSHOT_DEPTH,
+    maximumNodes: MAXIMUM_SNAPSHOT_NODES,
+    maximumKeysPerObject: 4_096,
+    maximumItemsPerArray: MAXIMUM_SNAPSHOT_FIELDS,
+});
+const digestPattern = /^sha256:[0-9a-f]{64}$/u;
+const hexPattern = /^[0-9a-f]{64}$/u;
+const artifactKinds = new Set([
+    "source-lock",
+    "package-lock",
+    "fixture",
+    "policy",
+    "environment",
+    "observation-policy",
+    "monitor",
+    "hidden-canary",
+    "registration",
+    "manifest",
+    "sample",
+    "trace",
+    "ledger",
+    "metric-projection",
+    "evidence",
+    "comparison",
+    "summary",
+]);
+export function digestCollectiveStatisticalCampaignArtifactV1(kind, value) {
+    kindValue(kind);
+    return digestArtifact({ schemaVersion: 1, kind, value });
+}
+export function digestCollectiveStatisticalCampaignSampleV1(value) {
+    const snapshot = snapshotJson(value, "sample digest input");
+    const { attempt: _attempt, traceArtifactId: _trace, ledgerArtifactId: _ledger, evidenceArtifactId: _evidence, ...replayStable } = snapshot;
+    return digestArtifact({
+        schemaVersion: 1,
+        kind: "sample-result",
+        value: replayStable,
+    });
+}
+export function digestCollectiveStatisticalCampaignTraceV1(value) {
+    return digestArtifact({ schemaVersion: 1, kind: "trace", value });
+}
+export function digestCollectiveStatisticalCampaignLedgerV1(value) {
+    return digestArtifact({ schemaVersion: 1, kind: "ledger", value });
+}
+export function digestCollectiveStatisticalCampaignEvidenceV1(value) {
+    return digestArtifact({ schemaVersion: 1, kind: "evidence", value });
+}
+export function digestCollectiveStatisticalCampaignComparisonInputV1(input) {
+    return digestArtifact({
+        schemaVersion: 1,
+        kind: "comparison-input",
+        value: input,
+    });
+}
+export function digestCollectiveStatisticalCampaignComparisonV1(value) {
+    return digestArtifact({ schemaVersion: 1, kind: "comparison", value });
+}
+export function digestCollectiveStatisticalCampaignSummaryV1(value) {
+    return digestArtifact({ schemaVersion: 1, kind: "summary", value });
+}
+export function digestCollectiveStatisticalCampaignBundleV1(value) {
+    const snapshot = snapshotJson(value, "bundle digest input");
+    return digestPlanningJsonV1("evaluation-campaign-bundle-v1", snapshot);
+}
+/**
+ * Verifies a fully supplied in-memory bundle. Paths remain logical: this
+ * function performs no file-system or network access and trusts no summary.
+ */
+export async function verifyCollectiveStatisticalCampaignBundleV1(bundleInput, suppliedBytesInput, hooksInput) {
+    const parsedBundle = validateBundle(snapshotJson(bundleInput, "bundle"));
+    const byteMap = snapshotByteMap(suppliedBytesInput);
+    const hooks = snapshotHooks(hooksInput);
+    const expected = new Map(parsedBundle.expectedArtifacts.map((value) => [value.artifactId, value]));
+    const indexed = new Map(parsedBundle.artifacts.map((value) => [value.artifactId, value]));
+    if (expected.size !== indexed.size ||
+        [...expected.keys()].some((id) => !indexed.has(id)))
+        fail("artifact index is not an exact closure of expected artifacts");
+    for (const [artifactId, expectation] of expected) {
+        if (indexed.get(artifactId).kind !== expectation.kind)
+            fail(`artifact kind does not match expectation: ${artifactId}`);
+        assertExpectedArtifactScope(expectation);
+    }
+    if (Object.keys(byteMap).length !== indexed.size ||
+        [...indexed.keys()].some((id) => !(id in byteMap)))
+        fail("supplied artifact bytes are not an exact closure of the index");
+    const values = new Map();
+    for (const [artifactId, entry] of indexed) {
+        const raw = byteMap[artifactId];
+        if (raw.byteLength !== entry.byteLength ||
+            (await sha256(raw)) !== entry.sha256)
+            fail(`artifact bytes do not match index: ${artifactId}`);
+        const value = parseJson(raw, artifactId);
+        if (digestCollectiveStatisticalCampaignArtifactV1(entry.kind, value) !==
+            entry.canonicalDigest)
+            fail(`artifact canonical digest is invalid: ${artifactId}`);
+        hooks.validateArtifact?.(entry.kind, value, {
+            artifactId,
+            path: entry.path,
+        });
+        values.set(artifactId, value);
+    }
+    assertGlobalArtifact(parsedBundle.sourceLockArtifactId, "source-lock", expected);
+    assertGlobalArtifact(parsedBundle.registrationArtifactId, "registration", expected);
+    assertGlobalArtifact(parsedBundle.manifestArtifactId, "manifest", expected);
+    assertGlobalArtifact(parsedBundle.summaryArtifactId, "summary", expected);
+    const sourceLock = validateSourceLock(values.get(parsedBundle.sourceLockArtifactId));
+    if (sourceLock.sourceCommit !== hooks.expectedSourceLock.sourceCommit ||
+        sourceLock.sourceTreeDigest !== hooks.expectedSourceLock.sourceTreeDigest)
+        fail("source lock does not match trusted provenance");
+    const registration = validateRegistration(values.get(parsedBundle.registrationArtifactId));
+    const manifest = validateManifest(values.get(parsedBundle.manifestArtifactId), registration);
+    if (registration.campaignId !== parsedBundle.campaignId)
+        fail("bundle campaignId does not match registration");
+    assertRegistrationProvenance(registration, indexed);
+    const registeredCells = new Map(registration.cells.map((cell) => [cell.cellId, cell]));
+    if (parsedBundle.cells.length !== registration.cells.length ||
+        parsedBundle.cells.some((cell, index) => cell.cellId !== registration.cells[index].cellId))
+        fail("bundle cells do not exactly match the registered schedule");
+    const manifestEntries = new Map(manifest.entries.map((entry) => [entry.cellId, entry]));
+    const comparisons = new Map();
+    const samples = new Map();
+    const traces = new Map();
+    const ledgers = new Map();
+    const evidence = new Map();
+    for (const [artifactId, entry] of indexed) {
+        const value = values.get(artifactId);
+        if (entry.kind === "sample")
+            samples.set(artifactId, validateSample(value));
+        if (entry.kind === "trace")
+            traces.set(artifactId, validateTrace(value));
+        if (entry.kind === "ledger")
+            ledgers.set(artifactId, validateLedger(value));
+        if (entry.kind === "evidence")
+            evidence.set(artifactId, validateEvidence(value));
+        if (entry.kind === "comparison")
+            comparisons.set(artifactId, validateComparison(value));
+    }
+    const summary = validateSummary(values.get(parsedBundle.summaryArtifactId));
+    assertArtifactReferenceClosure(samples, traces, ledgers, evidence);
+    for (const [artifactId, sample] of samples) {
+        const expectation = expected.get(artifactId);
+        const registeredCell = registeredCells.get(sample.cellId);
+        if (!expectation ||
+            expectation.kind !== "sample" ||
+            !registeredCell ||
+            sample.seed !== registeredCell.seed ||
+            expectation.cellId !== sample.cellId ||
+            expectation.seed !== sample.seed ||
+            expectation.runner !== sample.runner ||
+            expectation.attempt !== sample.attempt)
+            fail(`sample is not registered: ${artifactId}`);
+        assertExecutionArtifactBinding(artifactId, sample, expectation, expected, traces, ledgers, evidence);
+    }
+    for (const expectation of expected.values()) {
+        if (expectation.kind === "sample" && !samples.has(expectation.artifactId))
+            fail(`expected sample is absent: ${expectation.artifactId}`);
+    }
+    assertExactAttempts(registration, samples, traces, ledgers, evidence, expected);
+    const orderedComparisons = [];
+    for (const cell of parsedBundle.cells) {
+        const registeredCell = registeredCells.get(cell.cellId);
+        const manifestEntry = manifestEntries.get(cell.cellId);
+        const comparisonExpectation = expected.get(cell.comparisonArtifactId);
+        const comparison = comparisons.get(cell.comparisonArtifactId);
+        if (comparisonExpectation?.kind !== "comparison" ||
+            comparisonExpectation.cellId !== cell.cellId ||
+            !comparison ||
+            comparison.cellId !== cell.cellId)
+            fail(`comparison is missing or substituted: ${cell.cellId}`);
+        const adaptive = comparison.adaptiveSampleArtifactIds.map((id) => sampleFor(id, samples, registeredCell.seed, cell.cellId, "adaptive_collective"));
+        const centralized = comparison.centralizedSampleArtifactIds.map((id) => sampleFor(id, samples, registeredCell.seed, cell.cellId, "centralized_planner"));
+        if (adaptive.length !== 1 || centralized.length !== 1)
+            fail(`comparison is not an exact paired cell: ${cell.cellId}`);
+        const inputDigest = digestCollectiveStatisticalCampaignComparisonInputV1({
+            cellId: comparison.cellId,
+            adaptiveSampleDigests: adaptive.map((sample) => sample.sampleDigest),
+            centralizedSampleDigests: centralized.map((sample) => sample.sampleDigest),
+            bootstrap: comparison.bootstrap,
+        });
+        if (comparison.inputDigest !== inputDigest)
+            fail(`comparison input digest is invalid: ${cell.cellId}`);
+        if (!sameJson(hooks.recomputeComparisonStatistics(comparison, adaptive, centralized), comparison.statistics))
+            fail(`comparison statistics are not independently recomputable: ${cell.cellId}`);
+        assertManifestEntry(manifestEntry, comparison, adaptive[0], centralized[0], samples, traces, ledgers, evidence, expected);
+        orderedComparisons.push(comparison);
+    }
+    if (comparisons.size !== parsedBundle.cells.length)
+        fail("comparison artifacts are not an exact closure of cells");
+    if (!sameStrings(summary.comparisonArtifactIds, parsedBundle.cells.map((cell) => cell.comparisonArtifactId)))
+        fail("summary does not close over all comparisons");
+    if (!sameJson(hooks.recomputeSummaryStatistics(summary, orderedComparisons), summary.statistics))
+        fail("summary statistics are not independently recomputable");
+    const anyFailure = manifest.entries.some((entry) => entry.status === "failure") ||
+        [...samples.values()].some((sample) => sample.status === "failed");
+    if ((summary.status === "passed") === anyFailure)
+        fail("summary status does not reflect retained campaign failures");
+    return Object.freeze({
+        schemaVersion: 1,
+        campaignId: parsedBundle.campaignId,
+        registrationDigest: registration.registrationDigest,
+        manifestDigest: manifest.manifestDigest,
+        artifactCount: indexed.size,
+        sampleCount: samples.size,
+        comparisonCount: comparisons.size,
+        status: summary.status,
+    });
+}
+function validateBundle(value) {
+    exact(value, [
+        "schemaVersion",
+        "campaignId",
+        "sourceLockArtifactId",
+        "registrationArtifactId",
+        "manifestArtifactId",
+        "cells",
+        "expectedArtifacts",
+        "artifacts",
+        "summaryArtifactId",
+        "bundleDigest",
+    ], "bundle");
+    const body = value;
+    if (body.schemaVersion !== 1)
+        fail("bundle schema is invalid");
+    token(body.campaignId, "campaignId");
+    for (const name of [
+        "sourceLockArtifactId",
+        "registrationArtifactId",
+        "manifestArtifactId",
+        "summaryArtifactId",
+    ])
+        token(body[name], name);
+    digestValue(body.bundleDigest, "bundleDigest");
+    const cells = dense(body.cells, "cells", 1, 240).map(validateCell);
+    unique(cells.map((cell) => cell.cellId), "cell ids");
+    unique(cells.map((cell) => cell.comparisonArtifactId), "comparison ids");
+    const expectedArtifacts = dense(body.expectedArtifacts, "expectedArtifacts", 1, 16_384).map(validateExpectedArtifact);
+    unique(expectedArtifacts.map((item) => item.artifactId), "expected artifact ids");
+    unique(expectedArtifacts.map((item) => [item.kind, item.cellId, item.seed, item.runner, item.attempt].join("\u0000")), "expected artifact scopes");
+    const artifacts = dense(body.artifacts, "artifacts", 1, 16_384).map(validateIndexEntry);
+    unique(artifacts.map((item) => item.artifactId), "artifact ids");
+    unique(artifacts.map((item) => item.path), "artifact paths");
+    const totalBytes = artifacts.reduce((total, item) => total + item.byteLength, 0);
+    if (totalBytes > COLLECTIVE_STATISTICAL_CAMPAIGN_MAXIMUM_BUNDLE_BYTES_V1)
+        fail("bundle byte limit is exceeded");
+    const { bundleDigest: _digest, ...digestBody } = body;
+    if (digestCollectiveStatisticalCampaignBundleV1(digestBody) !== body.bundleDigest)
+        fail("bundle digest is invalid");
+    return body;
+}
+function validateCell(value) {
+    exact(value, ["schemaVersion", "cellId", "comparisonArtifactId"], "cell");
+    const body = value;
+    if (body.schemaVersion !== 1)
+        fail("cell schema is invalid");
+    token(body.cellId, "cellId");
+    token(body.comparisonArtifactId, "comparisonArtifactId");
+    return body;
+}
+function validateExpectedArtifact(value) {
+    exact(value, [
+        "schemaVersion",
+        "artifactId",
+        "kind",
+        "cellId",
+        "seed",
+        "runner",
+        "attempt",
+    ], "expected artifact");
+    const body = value;
+    if (body.schemaVersion !== 1)
+        fail("expected artifact schema is invalid");
+    token(body.artifactId, "expected artifactId");
+    kindValue(body.kind);
+    nullableToken(body.cellId, "expected cellId");
+    nullableInteger(body.seed, "expected seed");
+    nullableRunner(body.runner);
+    nullableAttempt(body.attempt);
+    return body;
+}
+function validateIndexEntry(value) {
+    exact(value, [
+        "schemaVersion",
+        "artifactId",
+        "kind",
+        "path",
+        "byteLength",
+        "sha256",
+        "canonicalDigest",
+    ], "artifact index entry");
+    const body = value;
+    if (body.schemaVersion !== 1)
+        fail("index schema is invalid");
+    token(body.artifactId, "artifactId");
+    kindValue(body.kind);
+    safePath(body.path);
+    integer(body.byteLength, "byteLength", 0);
+    if (body.byteLength >
+        COLLECTIVE_STATISTICAL_CAMPAIGN_MAXIMUM_ARTIFACT_BYTES_V1)
+        fail("artifact byte limit is exceeded");
+    hex(body.sha256, "sha256");
+    digestValue(body.canonicalDigest, "canonicalDigest");
+    return body;
+}
+function validateSourceLock(value) {
+    exact(value, ["schemaVersion", "sourceCommit", "sourceTreeDigest", "dirtyWorktree"], "source lock");
+    const body = value;
+    if (body.schemaVersion !== 1 ||
+        typeof body.sourceCommit !== "string" ||
+        !/^[0-9a-f]{40}$/u.test(body.sourceCommit) ||
+        body.dirtyWorktree !== false)
+        fail("source lock is invalid");
+    digestValue(body.sourceTreeDigest, "sourceTreeDigest");
+    return body;
+}
+function validateRegistration(value) {
+    try {
+        return validateCollectiveEvaluationCampaignRegistrationV1(value);
+    }
+    catch (error) {
+        fail(`registration contract is invalid: ${errorMessage(error)}`);
+    }
+}
+function validateManifest(value, registration) {
+    try {
+        return validateCollectiveEvaluationCampaignManifestV1(value, registration);
+    }
+    catch (error) {
+        fail(`manifest contract is invalid: ${errorMessage(error)}`);
+    }
+}
+function validateSample(value) {
+    exact(value, [
+        "schemaVersion", "cellId", "seed", "runner", "attempt", "status",
+        "traceArtifactId", "ledgerArtifactId", "evidenceArtifactId", "outcome",
+        "sampleDigest",
+    ], "sample");
+    const body = value;
+    if (body.schemaVersion !== 1)
+        fail("sample schema is invalid");
+    token(body.cellId, "sample cellId");
+    integer(body.seed, "sample seed", 0);
+    runner(body.runner);
+    attempt(body.attempt);
+    if (body.status !== "passed" && body.status !== "failed")
+        fail("sample status is invalid");
+    token(body.traceArtifactId, "traceArtifactId");
+    token(body.ledgerArtifactId, "ledgerArtifactId");
+    token(body.evidenceArtifactId, "evidenceArtifactId");
+    safeJson(body.outcome);
+    digestValue(body.sampleDigest, "sampleDigest");
+    const { sampleDigest: _digest, ...digestBody } = body;
+    if (digestCollectiveStatisticalCampaignSampleV1(digestBody) !== body.sampleDigest)
+        fail("sample digest is invalid");
+    return body;
+}
+function validateTrace(value) {
+    exact(value, ["schemaVersion", "sampleArtifactId", "records", "traceDigest"], "trace");
+    const body = value;
+    if (body.schemaVersion !== 1)
+        fail("trace schema is invalid");
+    token(body.sampleArtifactId, "trace sampleArtifactId");
+    dense(body.records, "trace records", 0, 16_384).forEach(safeJson);
+    digestValue(body.traceDigest, "traceDigest");
+    const { traceDigest: _digest, ...digestBody } = body;
+    if (digestCollectiveStatisticalCampaignTraceV1(digestBody) !== body.traceDigest)
+        fail("trace digest is invalid");
+    return body;
+}
+function validateLedger(value) {
+    exact(value, ["schemaVersion", "sampleArtifactId", "records", "ledgerDigest"], "ledger");
+    const body = value;
+    if (body.schemaVersion !== 1)
+        fail("ledger schema is invalid");
+    token(body.sampleArtifactId, "ledger sampleArtifactId");
+    dense(body.records, "ledger records", 0, 16_384).forEach(safeJson);
+    digestValue(body.ledgerDigest, "ledgerDigest");
+    const { ledgerDigest: _digest, ...digestBody } = body;
+    if (digestCollectiveStatisticalCampaignLedgerV1(digestBody) !== body.ledgerDigest)
+        fail("ledger digest is invalid");
+    return body;
+}
+function validateEvidence(value) {
+    exact(value, ["schemaVersion", "sampleArtifactId", "sampleDigest", "observations", "evidenceDigest"], "evidence");
+    const body = value;
+    if (body.schemaVersion !== 1)
+        fail("evidence schema is invalid");
+    token(body.sampleArtifactId, "evidence sampleArtifactId");
+    digestValue(body.sampleDigest, "evidence sampleDigest");
+    dense(body.observations, "evidence observations", 0, 16_384).forEach(safeJson);
+    digestValue(body.evidenceDigest, "evidenceDigest");
+    const { evidenceDigest: _digest, ...digestBody } = body;
+    if (digestCollectiveStatisticalCampaignEvidenceV1(digestBody) !== body.evidenceDigest)
+        fail("evidence digest is invalid");
+    return body;
+}
+function validateComparison(value) {
+    exact(value, [
+        "schemaVersion", "cellId", "adaptiveSampleArtifactIds",
+        "centralizedSampleArtifactIds", "bootstrap", "statistics", "inputDigest",
+        "comparisonDigest",
+    ], "comparison");
+    const body = value;
+    if (body.schemaVersion !== 1)
+        fail("comparison schema is invalid");
+    token(body.cellId, "comparison cellId");
+    const adaptive = strings(body.adaptiveSampleArtifactIds, "adaptive samples", 1);
+    const centralized = strings(body.centralizedSampleArtifactIds, "centralized samples", 1);
+    unique(adaptive, "adaptive samples");
+    unique(centralized, "centralized samples");
+    exact(body.bootstrap, ["schemaVersion", "seed", "resamples"], "bootstrap");
+    const bootstrap = body.bootstrap;
+    if (bootstrap.schemaVersion !== 1)
+        fail("bootstrap schema is invalid");
+    integer(bootstrap.seed, "bootstrap seed", 0);
+    integer(bootstrap.resamples, "bootstrap resamples", 10_000);
+    safeJson(body.statistics);
+    digestValue(body.inputDigest, "inputDigest");
+    digestValue(body.comparisonDigest, "comparisonDigest");
+    const { comparisonDigest: _digest, ...digestBody } = body;
+    if (digestCollectiveStatisticalCampaignComparisonV1(digestBody) !== body.comparisonDigest)
+        fail("comparison digest is invalid");
+    return body;
+}
+function validateSummary(value) {
+    exact(value, ["schemaVersion", "comparisonArtifactIds", "status", "statistics", "summaryDigest"], "summary");
+    const body = value;
+    if (body.schemaVersion !== 1)
+        fail("summary schema is invalid");
+    const comparisons = strings(body.comparisonArtifactIds, "summary comparisons", 1);
+    unique(comparisons, "summary comparisons");
+    if (body.status !== "passed" && body.status !== "failed")
+        fail("summary status is invalid");
+    safeJson(body.statistics);
+    digestValue(body.summaryDigest, "summaryDigest");
+    const { summaryDigest: _digest, ...digestBody } = body;
+    if (digestCollectiveStatisticalCampaignSummaryV1(digestBody) !== body.summaryDigest)
+        fail("summary digest is invalid");
+    return body;
+}
+function assertRegistrationProvenance(registration, indexed) {
+    const bindings = [
+        ["source-lock", registration.sourceDigest],
+        ["package-lock", registration.packageDigest],
+        ["fixture", registration.fixtureManifestDigest],
+        ["policy", registration.policyDigest],
+        ["environment", registration.environmentDigest],
+        ["observation-policy", registration.observationPolicyDigest],
+        ["monitor", registration.monitorDigest],
+        ["hidden-canary", registration.hiddenCanaryDigest],
+    ];
+    for (const [kind, digest] of bindings) {
+        const artifact = singleArtifactOfKind(indexed, kind);
+        if (artifact.canonicalDigest !== digest)
+            fail(`registration provenance does not bind ${kind}`);
+    }
+    singleArtifactOfKind(indexed, "registration");
+    singleArtifactOfKind(indexed, "manifest");
+    singleArtifactOfKind(indexed, "summary");
+}
+function assertArtifactReferenceClosure(samples, traces, ledgers, evidence) {
+    const closures = [
+        [new Set([...samples.values()].map((item) => item.traceArtifactId)), traces, "trace"],
+        [new Set([...samples.values()].map((item) => item.ledgerArtifactId)), ledgers, "ledger"],
+        [new Set([...samples.values()].map((item) => item.evidenceArtifactId)), evidence, "evidence"],
+    ];
+    for (const [references, artifacts, label] of closures) {
+        if (references.size !== artifacts.size ||
+            [...artifacts.keys()].some((id) => !references.has(id)))
+            fail(`${label} artifacts are not an exact closure of samples`);
+    }
+}
+function assertExecutionArtifactBinding(sampleArtifactId, sample, sampleExpectation, expected, traces, ledgers, evidence) {
+    const bindings = [
+        [sample.traceArtifactId, "trace", traces.get(sample.traceArtifactId)],
+        [sample.ledgerArtifactId, "ledger", ledgers.get(sample.ledgerArtifactId)],
+        [sample.evidenceArtifactId, "evidence", evidence.get(sample.evidenceArtifactId)],
+    ];
+    for (const [artifactId, kind, artifact] of bindings) {
+        const expectation = expected.get(artifactId);
+        if (!expectation || !sameExecutionScope(expectation, sampleExpectation, kind))
+            fail(`sample ${kind} expectation is not bound: ${sampleArtifactId}`);
+        if (!artifact || artifact.sampleArtifactId !== sampleArtifactId)
+            fail(`sample ${kind} is not bound: ${sampleArtifactId}`);
+    }
+    const evidenceValue = evidence.get(sample.evidenceArtifactId);
+    if (evidenceValue.sampleDigest !== sample.sampleDigest)
+        fail(`sample evidence digest is not bound: ${sampleArtifactId}`);
+}
+function assertExactAttempts(registration, samples, traces, ledgers, evidence, expected) {
+    for (const cell of registration.cells) {
+        for (const runnerValue of ["adaptive_collective", "centralized_planner"]) {
+            const firstExpectation = findSampleExpectation(expected, cell.cellId, cell.seed, runnerValue, "first");
+            const replayExpectation = findSampleExpectation(expected, cell.cellId, cell.seed, runnerValue, "replay");
+            if (!firstExpectation || !replayExpectation)
+                fail(`expected replay pair is absent: ${cell.cellId}/${runnerValue}`);
+            const first = samples.get(firstExpectation.artifactId);
+            const replay = samples.get(replayExpectation.artifactId);
+            if (!first || !replay || first.sampleDigest !== replay.sampleDigest)
+                fail(`sample replay diverged: ${cell.cellId}/${runnerValue}`);
+            if (!sameJson(traces.get(first.traceArtifactId).records, traces.get(replay.traceArtifactId).records) ||
+                !sameJson(ledgers.get(first.ledgerArtifactId).records, ledgers.get(replay.ledgerArtifactId).records) ||
+                !sameJson(evidence.get(first.evidenceArtifactId).observations, evidence.get(replay.evidenceArtifactId).observations))
+                fail(`replay artifacts diverged: ${cell.cellId}/${runnerValue}`);
+        }
+    }
+}
+function assertManifestEntry(entry, comparison, adaptive, centralized, samples, traces, ledgers, evidence, expected) {
+    const executions = [...expected.values()]
+        .filter((item) => item.kind === "sample" && item.cellId === entry.cellId)
+        .map((item) => samples.get(item.artifactId));
+    if (entry.status === "failure") {
+        if (!executions.some((sample) => sample.status === "failed"))
+            fail(`failed manifest entry omits a failed execution: ${entry.cellId}`);
+        return;
+    }
+    if (executions.some((sample) => sample.status !== "passed"))
+        fail(`successful manifest entry contains a failed execution: ${entry.cellId}`);
+    const expectedBindings = {
+        adaptiveResultDigest: adaptive.sampleDigest,
+        centralizedResultDigest: centralized.sampleDigest,
+        adaptiveTraceDigest: traces.get(adaptive.traceArtifactId).traceDigest,
+        centralizedTraceDigest: traces.get(centralized.traceArtifactId).traceDigest,
+        adaptiveLedgerDigest: ledgers.get(adaptive.ledgerArtifactId).ledgerDigest,
+        centralizedLedgerDigest: ledgers.get(centralized.ledgerArtifactId).ledgerDigest,
+        fairnessDigest: comparison.comparisonDigest,
+        adaptiveCampaignEvidenceDigest: evidence.get(adaptive.evidenceArtifactId).evidenceDigest,
+        centralizedCampaignEvidenceDigest: evidence.get(centralized.evidenceArtifactId).evidenceDigest,
+    };
+    for (const [name, digest] of Object.entries(expectedBindings)) {
+        if (entry[name] !== digest)
+            fail(`manifest ${name} does not bind cell: ${entry.cellId}`);
+    }
+}
+function sampleFor(id, samples, seed, cellId, runnerValue) {
+    const sample = samples.get(id);
+    if (!sample ||
+        sample.cellId !== cellId ||
+        sample.seed !== seed ||
+        sample.runner !== runnerValue ||
+        sample.attempt !== "first")
+        fail(`comparison sample is invalid: ${id}`);
+    return sample;
+}
+function snapshotByteMap(value) {
+    const descriptors = dataRecordDescriptors(value, "artifact bytes");
+    const result = Object.create(null);
+    let total = 0;
+    for (const [id, descriptor] of descriptors) {
+        token(id, "artifact bytes id");
+        const raw = descriptor.value;
+        let bytes;
+        if (typeof raw === "string") {
+            if (raw.length > COLLECTIVE_STATISTICAL_CAMPAIGN_MAXIMUM_ARTIFACT_BYTES_V1)
+                fail(`artifact byte limit is exceeded: ${id}`);
+            bytes = encoder.encode(raw);
+        }
+        else if (raw instanceof Uint8Array) {
+            if (raw.byteLength > COLLECTIVE_STATISTICAL_CAMPAIGN_MAXIMUM_ARTIFACT_BYTES_V1)
+                fail(`artifact byte limit is exceeded: ${id}`);
+            bytes = new Uint8Array(raw);
+        }
+        else {
+            fail(`artifact bytes are invalid: ${id}`);
+        }
+        if (bytes.byteLength > COLLECTIVE_STATISTICAL_CAMPAIGN_MAXIMUM_ARTIFACT_BYTES_V1)
+            fail(`artifact byte limit is exceeded: ${id}`);
+        total += bytes.byteLength;
+        if (total > COLLECTIVE_STATISTICAL_CAMPAIGN_MAXIMUM_BUNDLE_BYTES_V1)
+            fail("bundle byte limit is exceeded");
+        result[id] = bytes;
+    }
+    return Object.freeze(result);
+}
+function snapshotHooks(value) {
+    const descriptors = dataRecordDescriptors(value, "verification hooks");
+    const permitted = new Set([
+        "expectedSourceLock",
+        "validateArtifact",
+        "recomputeComparisonStatistics",
+        "recomputeSummaryStatistics",
+    ]);
+    const fields = Object.fromEntries(descriptors.map(([name, descriptor]) => {
+        if (!permitted.has(name))
+            fail(`hook is invalid: ${name}`);
+        return [name, descriptor.value];
+    }));
+    for (const name of [
+        "recomputeComparisonStatistics",
+        "recomputeSummaryStatistics",
+    ])
+        if (typeof fields[name] !== "function")
+            fail(`required hook is invalid: ${name}`);
+    if (fields.validateArtifact !== undefined && typeof fields.validateArtifact !== "function")
+        fail("hook is invalid: validateArtifact");
+    exact(fields.expectedSourceLock, ["sourceCommit", "sourceTreeDigest"], "expected source lock");
+    const source = fields.expectedSourceLock;
+    if (typeof source.sourceCommit !== "string" || !/^[0-9a-f]{40}$/u.test(source.sourceCommit))
+        fail("expected source commit is invalid");
+    digestValue(source.sourceTreeDigest, "expected sourceTreeDigest");
+    return Object.freeze({
+        expectedSourceLock: Object.freeze({
+            sourceCommit: source.sourceCommit,
+            sourceTreeDigest: source.sourceTreeDigest,
+        }),
+        ...(fields.validateArtifact === undefined
+            ? {}
+            : { validateArtifact: fields.validateArtifact }),
+        recomputeComparisonStatistics: fields.recomputeComparisonStatistics,
+        recomputeSummaryStatistics: fields.recomputeSummaryStatistics,
+    });
+}
+function snapshotJson(value, label, budget = {
+    nodes: 0,
+    stringCodeUnits: 0,
+}, depth = 0, active = new WeakSet()) {
+    if (depth > MAXIMUM_SNAPSHOT_DEPTH)
+        fail(`${label} exceeds snapshot depth`);
+    budget.nodes += 1;
+    if (budget.nodes > MAXIMUM_SNAPSHOT_NODES)
+        fail(`${label} exceeds snapshot node limit`);
+    if (value === null ||
+        typeof value === "boolean")
+        return value;
+    if (typeof value === "string") {
+        budget.stringCodeUnits += value.length;
+        if (budget.stringCodeUnits >
+            COLLECTIVE_STATISTICAL_CAMPAIGN_MAXIMUM_BUNDLE_BYTES_V1)
+            fail(`${label} exceeds snapshot string limit`);
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value) || Object.is(value, -0))
+            fail(`${label} is not canonical JSON`);
+        return value;
+    }
+    if (typeof value !== "object")
+        fail(`${label} is not JSON data`);
+    if (active.has(value))
+        fail(`${label} is cyclic`);
+    active.add(value);
+    try {
+        if (Array.isArray(value)) {
+            if (Object.getPrototypeOf(value) !== Array.prototype ||
+                Object.getOwnPropertySymbols(value).length !== 0)
+                fail(`${label} array is invalid`);
+            const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+            if (!lengthDescriptor || !("value" in lengthDescriptor))
+                fail(`${label} array length is invalid`);
+            const length = lengthDescriptor.value;
+            if (!Number.isSafeInteger(length) ||
+                length < 0 ||
+                length > MAXIMUM_SNAPSHOT_FIELDS)
+                fail(`${label} array exceeds snapshot item limit`);
+            const names = Object.getOwnPropertyNames(value);
+            if (names.length !== length + 1)
+                fail(`${label} array has holes or properties`);
+            const result = [];
+            for (let index = 0; index < length; index += 1) {
+                const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+                if (!descriptor || !descriptor.enumerable || !("value" in descriptor))
+                    fail(`${label} array has accessor or hole`);
+                result.push(snapshotJson(descriptor.value, `${label}[${index}]`, budget, depth + 1, active));
+            }
+            return Object.freeze(result);
+        }
+        const descriptors = dataRecordDescriptors(value, label);
+        const result = Object.create(null);
+        for (const [name, descriptor] of descriptors)
+            result[name] = snapshotJson(descriptor.value, `${label}.${name}`, budget, depth + 1, active);
+        return Object.freeze(result);
+    }
+    finally {
+        active.delete(value);
+    }
+}
+function dataRecordDescriptors(value, label, maximumFields = MAXIMUM_SNAPSHOT_FIELDS) {
+    if (value === null ||
+        typeof value !== "object" ||
+        Array.isArray(value) ||
+        (Object.getPrototypeOf(value) !== Object.prototype &&
+            Object.getPrototypeOf(value) !== null) ||
+        Object.getOwnPropertySymbols(value).length !== 0)
+        fail(`${label} must be a plain data object`);
+    const names = Object.getOwnPropertyNames(value);
+    if (names.length > maximumFields)
+        fail(`${label} exceeds snapshot field limit`);
+    return Object.freeze(names.map((name) => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, name);
+        if (!descriptor || !descriptor.enumerable || !("value" in descriptor))
+            fail(`${label} must not have accessors`);
+        return Object.freeze([name, descriptor]);
+    }));
+}
+function parseJson(bytes, artifactId) {
+    try {
+        return snapshotJson(JSON.parse(decoder.decode(bytes)), `artifact ${artifactId}`);
+    }
+    catch (error) {
+        if (error instanceof TypeError && error.message.startsWith("collective_statistical"))
+            throw error;
+        fail(`artifact is not valid UTF-8 JSON: ${artifactId}`);
+    }
+}
+async function sha256(bytes) {
+    const result = await crypto.subtle.digest("SHA-256", bytes);
+    return [...new Uint8Array(result)]
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+}
+function digestArtifact(value) {
+    const snapshot = snapshotJson(value, "artifact digest input");
+    return digestPlanningJsonV1("evaluation-campaign-artifact-v1", snapshot, ARTIFACT_JSON_LIMITS);
+}
+function exact(value, keys, label) {
+    const descriptors = dataRecordDescriptors(value, label);
+    const names = descriptors.map(([name]) => name).sort(compareAscii);
+    const expected = [...keys].sort(compareAscii);
+    if (names.length !== expected.length ||
+        names.some((name, index) => name !== expected[index]))
+        fail(`${label} has an invalid shape`);
+    if (descriptors.some(([, descriptor]) => descriptor.value === undefined))
+        fail(`${label} has undefined property`);
+}
+function dense(value, label, minimum, maximum) {
+    if (!Array.isArray(value) ||
+        Object.getPrototypeOf(value) !== Array.prototype ||
+        Object.getOwnPropertySymbols(value).length !== 0 ||
+        value.length < minimum ||
+        value.length > maximum ||
+        Object.getOwnPropertyNames(value).length !== value.length + 1)
+        fail(`${label} is invalid`);
+    const result = [];
+    for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor || !descriptor.enumerable || !("value" in descriptor))
+            fail(`${label} has accessor or hole`);
+        result.push(descriptor.value);
+    }
+    return result;
+}
+function safeJson(value) {
+    canonicalizePlanningJsonV1(value, ARTIFACT_JSON_LIMITS);
+}
+function assertGlobalArtifact(artifactId, kind, expected) {
+    const value = expected.get(artifactId);
+    if (!value || value.kind !== kind || !isGlobalScope(value))
+        fail(`${kind} expectation is invalid`);
+}
+function assertExpectedArtifactScope(value) {
+    const execution = ["sample", "trace", "ledger", "evidence"].includes(value.kind);
+    const cellOnly = value.kind === "comparison";
+    if (execution) {
+        if (value.cellId === null ||
+            value.seed === null ||
+            value.runner === null ||
+            value.attempt === null)
+            fail(`execution artifact expectation is incomplete: ${value.artifactId}`);
+    }
+    else if (cellOnly) {
+        if (value.cellId === null ||
+            value.seed !== null ||
+            value.runner !== null ||
+            value.attempt !== null)
+            fail(`cell artifact expectation is invalid: ${value.artifactId}`);
+    }
+    else if (!isGlobalScope(value)) {
+        fail(`global artifact expectation is invalid: ${value.artifactId}`);
+    }
+}
+function isGlobalScope(value) {
+    return value.cellId === null && value.seed === null && value.runner === null && value.attempt === null;
+}
+function sameExecutionScope(value, sample, kind) {
+    return (value.kind === kind &&
+        value.cellId === sample.cellId &&
+        value.seed === sample.seed &&
+        value.runner === sample.runner &&
+        value.attempt === sample.attempt);
+}
+function findSampleExpectation(expected, cellId, seed, runnerValue, attemptValue) {
+    return [...expected.values()].find((item) => item.kind === "sample" &&
+        item.cellId === cellId &&
+        item.seed === seed &&
+        item.runner === runnerValue &&
+        item.attempt === attemptValue);
+}
+function singleArtifactOfKind(indexed, kind) {
+    const values = [...indexed.values()].filter((value) => value.kind === kind);
+    if (values.length !== 1)
+        fail(`bundle must contain exactly one ${kind} artifact`);
+    return values[0];
+}
+function token(value, label) {
+    if (typeof value !== "string" ||
+        !/^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/u.test(value))
+        fail(`${label} is invalid`);
+}
+function nullableToken(value, label) {
+    if (value !== null)
+        token(value, label);
+}
+function integer(value, label, minimum) {
+    if (!Number.isSafeInteger(value) || value < minimum)
+        fail(`${label} is invalid`);
+}
+function nullableInteger(value, label) {
+    if (value !== null)
+        integer(value, label, 0);
+}
+function strings(value, label, minimum) {
+    return dense(value, label, minimum, 256).map((item) => {
+        token(item, label);
+        return item;
+    });
+}
+function runner(value) {
+    if (value !== "adaptive_collective" && value !== "centralized_planner")
+        fail("runner is invalid");
+}
+function nullableRunner(value) {
+    if (value !== null)
+        runner(value);
+}
+function attempt(value) {
+    if (value !== "first" && value !== "replay")
+        fail("attempt is invalid");
+}
+function nullableAttempt(value) {
+    if (value !== null)
+        attempt(value);
+}
+function kindValue(value) {
+    if (typeof value !== "string" ||
+        !artifactKinds.has(value))
+        fail("artifact kind is invalid");
+}
+function digestValue(value, label) {
+    if (typeof value !== "string" || !digestPattern.test(value))
+        fail(`${label} is invalid`);
+}
+function hex(value, label) {
+    if (typeof value !== "string" || !hexPattern.test(value))
+        fail(`${label} is invalid`);
+}
+function safePath(value) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.startsWith("/") ||
+        value.includes("\\") ||
+        value.split("/").some((part) => part === "" || part === "." || part === ".."))
+        fail("artifact path is not a safe relative path");
+}
+function unique(values, label) {
+    if (new Set(values).size !== values.length)
+        fail(`${label} are not unique`);
+}
+function sameStrings(actual, expected) {
+    return actual.length === expected.length && actual.every((value, index) => value === expected[index]);
+}
+function sameJson(left, right) {
+    return (canonicalizePlanningJsonV1(left, ARTIFACT_JSON_LIMITS) ===
+        canonicalizePlanningJsonV1(right, ARTIFACT_JSON_LIMITS));
+}
+function compareAscii(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : "unknown error";
+}
+function fail(message) {
+    throw new TypeError(`collective_statistical_campaign_bundle_invalid: ${message}`);
+}
+//# sourceMappingURL=collective-statistical-campaign-bundle.js.map