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

package/dist/collective-closed-loop-resilience-contracts.js

@@ -0,0 +1,677 @@
+import { deepFreezePlanning, digestPlanningJsonV1, } from "@agentplat/collective-planning";
+import { validateCollectiveClosedLoopDefinitionV1, validateCollectiveClosedLoopRunResultV1, } from "./collective-closed-loop-contracts.js";
+/** The closed-loop reference surface deliberately bounds one compact fault plan. */
+export const COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1 = Object.freeze({
+    maximumFaults: 8,
+    minimumEpochs: 2,
+    maximumEpochs: 3,
+    maximumLinksPerFault: 49,
+    maximumTargetsPerFault: 50,
+    maximumCausalPredecessorsPerFault: 7,
+    maximumStaleResultRejections: 8,
+});
+const digestPattern = /^sha256:[0-9a-f]{64}$/u;
+const tokenPattern = /^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/u;
+const faultFamilies = new Set([
+    "capability.withdraw",
+    "assignment.decline",
+    "peer.crash",
+    "peer.restart",
+    "network.partition",
+    "network.heal",
+]);
+const faultPlanBodyKeys = [
+    "schemaVersion",
+    "nominalDefinitionDigest",
+    "faults",
+];
+const faultPlanKeys = [...faultPlanBodyKeys, "faultPlanDigest"];
+const resilienceDefinitionBodyKeys = [
+    "schemaVersion",
+    "nominalDefinition",
+    "faultPlan",
+    "maximumEpochs",
+];
+const resilienceDefinitionKeys = [
+    ...resilienceDefinitionBodyKeys,
+    "resilienceDefinitionDigest",
+];
+const resilienceResultBodyKeys = [
+    "schemaVersion",
+    "resilienceDefinitionDigest",
+    "run",
+    "epochs",
+    "faultObservations",
+    "staleResultRejections",
+];
+const resilienceResultKeys = [
+    ...resilienceResultBodyKeys,
+    "resilienceResultDigest",
+];
+const campaignEvidenceBodyKeys = [
+    "schemaVersion",
+    "resilienceDefinitionDigest",
+    "resilienceResultDigest",
+    "runner",
+    "seed",
+    "limits",
+    "scheduledFaultIds",
+    "injectedFaultIds",
+    "observedFaultIds",
+    "staleResultRejectionIds",
+];
+const campaignEvidenceKeys = [
+    ...campaignEvidenceBodyKeys,
+    "campaignEvidenceDigest",
+];
+function exact(value, keys, label) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError(`${label} must be a plain object`);
+    const names = Object.getOwnPropertyNames(value).sort();
+    const expected = [...keys].sort();
+    const prototype = Object.getPrototypeOf(value);
+    if ((prototype !== Object.prototype && prototype !== null) ||
+        Object.getOwnPropertySymbols(value).length !== 0 ||
+        names.length !== expected.length ||
+        names.some((name, index) => name !== expected[index]))
+        throw new TypeError(`${label} has an invalid shape`);
+    for (const name of names) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, name);
+        if (!descriptor || !descriptor.enumerable || !("value" in descriptor))
+            throw new TypeError(`${label} must contain enumerable data properties`);
+    }
+}
+function denseArray(value, label) {
+    if (!Array.isArray(value) ||
+        Object.getPrototypeOf(value) !== Array.prototype ||
+        Object.getOwnPropertySymbols(value).length !== 0 ||
+        Object.getOwnPropertyNames(value).length !== value.length + 1)
+        throw new TypeError(`${label} must be a dense array`);
+    for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor || !descriptor.enumerable || !("value" in descriptor))
+            throw new TypeError(`${label} must contain enumerable data properties`);
+    }
+}
+function token(value, label) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > 128 ||
+        !tokenPattern.test(value))
+        throw new TypeError(`${label} must be a bounded token`);
+}
+function digest(value, label) {
+    if (typeof value !== "string" || !digestPattern.test(value))
+        throw new TypeError(`${label} must be a digest`);
+}
+function safeInteger(value, label, minimum = 0) {
+    if (!Number.isSafeInteger(value) ||
+        value < minimum ||
+        Object.is(value, -0))
+        throw new TypeError(`${label} must be a safe integer`);
+}
+function sortedTokens(value, label, maximum) {
+    denseArray(value, label);
+    if (value.length > maximum)
+        throw new TypeError(`${label} is too large`);
+    const result = [];
+    let previous = null;
+    for (const item of value) {
+        token(item, label);
+        if (previous !== null && previous >= item)
+            throw new TypeError(`${label} must be sorted and unique`);
+        previous = item;
+        result.push(item);
+    }
+    return Object.freeze(result);
+}
+function digestBody(domain, value) {
+    return digestPlanningJsonV1("environment-state-v1", { domain, value }, {
+        maximumBytes: 1_048_576,
+        maximumDepth: 32,
+        maximumNodes: 32_768,
+        maximumKeysPerObject: 256,
+        maximumItemsPerArray: 4_096,
+    });
+}
+function validateTrigger(value) {
+    exact(value, ["schemaVersion", "kind", "logicalTimeMs", "causalEventDigest"], "closed-loop fault trigger");
+    if (value.schemaVersion !== 1)
+        throw new TypeError("closed-loop fault trigger schema is invalid");
+    safeInteger(value.logicalTimeMs, "fault trigger logicalTimeMs");
+    if (value.kind === "logical_time" && value.causalEventDigest === null)
+        return deepFreezePlanning({
+            schemaVersion: 1,
+            kind: "logical_time",
+            logicalTimeMs: value.logicalTimeMs,
+            causalEventDigest: null,
+        });
+    if (value.kind === "trace_event") {
+        digest(value.causalEventDigest, "fault trigger causalEventDigest");
+        return deepFreezePlanning({
+            schemaVersion: 1,
+            kind: "trace_event",
+            logicalTimeMs: value.logicalTimeMs,
+            causalEventDigest: value.causalEventDigest,
+        });
+    }
+    throw new TypeError("closed-loop fault trigger is invalid");
+}
+function validateLink(value) {
+    exact(value, ["schemaVersion", "fromPeerId", "toPeerId"], "closed-loop fault link");
+    if (value.schemaVersion !== 1)
+        throw new TypeError("closed-loop fault link schema is invalid");
+    token(value.fromPeerId, "fault link fromPeerId");
+    token(value.toPeerId, "fault link toPeerId");
+    if (value.fromPeerId === value.toPeerId)
+        throw new TypeError("closed-loop fault link may not be reflexive");
+    return deepFreezePlanning({
+        schemaVersion: 1,
+        fromPeerId: value.fromPeerId,
+        toPeerId: value.toPeerId,
+    });
+}
+function validateTarget(value) {
+    exact(value, ["schemaVersion", "peerId"], "closed-loop fault target");
+    if (value.schemaVersion !== 1)
+        throw new TypeError("closed-loop fault target schema is invalid");
+    token(value.peerId, "fault target peerId");
+    return deepFreezePlanning({ schemaVersion: 1, peerId: value.peerId });
+}
+function compareLink(left, right) {
+    const leftKey = `${left.fromPeerId}\u0000${left.toPeerId}`;
+    const rightKey = `${right.fromPeerId}\u0000${right.toPeerId}`;
+    return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+}
+function sortedLinks(value) {
+    denseArray(value, "fault links");
+    if (value.length >
+        COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.maximumLinksPerFault)
+        throw new TypeError("fault links are too large");
+    const links = value.map(validateLink);
+    for (let index = 1; index < links.length; index += 1)
+        if (compareLink(links[index - 1], links[index]) >= 0)
+            throw new TypeError("fault links must be sorted and unique");
+    return Object.freeze(links);
+}
+function sortedTargets(value) {
+    denseArray(value, "fault targets");
+    if (value.length >
+        COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.maximumTargetsPerFault)
+        throw new TypeError("fault targets are too large");
+    const targets = value.map(validateTarget);
+    for (let index = 1; index < targets.length; index += 1)
+        if (targets[index - 1].peerId >= targets[index].peerId)
+            throw new TypeError("fault targets must be sorted and unique");
+    return Object.freeze(targets);
+}
+function validateFault(value) {
+    exact(value, [
+        "schemaVersion",
+        "faultId",
+        "family",
+        "trigger",
+        "causalPredecessorFaultIds",
+        "links",
+        "targets",
+    ], "closed-loop fault");
+    if (value.schemaVersion !== 1 ||
+        !faultFamilies.has(value.family))
+        throw new TypeError("closed-loop fault family is invalid");
+    token(value.faultId, "faultId");
+    const trigger = validateTrigger(value.trigger);
+    const causalPredecessorFaultIds = sortedTokens(value.causalPredecessorFaultIds, "causalPredecessorFaultIds", COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.maximumCausalPredecessorsPerFault);
+    if (causalPredecessorFaultIds.includes(value.faultId))
+        throw new TypeError("closed-loop fault may not causally depend on itself");
+    const links = sortedLinks(value.links);
+    const targets = sortedTargets(value.targets);
+    const networkFault = value.family === "network.partition" || value.family === "network.heal";
+    if ((networkFault && (links.length === 0 || targets.length !== 0)) ||
+        (!networkFault && (links.length !== 0 || targets.length === 0)))
+        throw new TypeError("closed-loop fault family has invalid links or targets");
+    return deepFreezePlanning({
+        schemaVersion: 1,
+        faultId: value.faultId,
+        family: value.family,
+        trigger,
+        causalPredecessorFaultIds,
+        links,
+        targets,
+    });
+}
+function normalizedFaultPlanBody(value) {
+    if (value.schemaVersion !== 1)
+        throw new TypeError("closed-loop fault plan schema is invalid");
+    digest(value.nominalDefinitionDigest, "nominalDefinitionDigest");
+    denseArray(value.faults, "faults");
+    if (value.faults.length === 0 ||
+        value.faults.length >
+            COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.maximumFaults)
+        throw new TypeError("closed-loop fault count is invalid");
+    const faults = value.faults.map(validateFault);
+    const faultsById = new Map();
+    let previousId = null;
+    let previousLogicalTime = -1;
+    for (const fault of faults) {
+        if (previousId !== null && previousId >= fault.faultId)
+            throw new TypeError("closed-loop faults must be sorted and unique");
+        if (fault.trigger.logicalTimeMs < previousLogicalTime)
+            throw new TypeError("closed-loop faults must be ordered by trigger time");
+        previousId = fault.faultId;
+        previousLogicalTime = fault.trigger.logicalTimeMs;
+        faultsById.set(fault.faultId, fault);
+    }
+    for (const fault of faults) {
+        for (const predecessorId of fault.causalPredecessorFaultIds) {
+            const predecessor = faultsById.get(predecessorId);
+            if (!predecessor ||
+                predecessor.trigger.logicalTimeMs >= fault.trigger.logicalTimeMs)
+                throw new TypeError("closed-loop fault causal predecessor is invalid");
+        }
+        if (fault.family === "peer.restart" &&
+            !fault.causalPredecessorFaultIds.some((id) => {
+                const predecessor = faultsById.get(id);
+                return (predecessor?.family === "peer.crash" &&
+                    predecessor.targets.some((target) => fault.targets.some((restart) => restart.peerId === target.peerId)));
+            }))
+            throw new TypeError("closed-loop peer restart requires a causal crash");
+        if (fault.family === "network.heal" &&
+            !fault.causalPredecessorFaultIds.some((id) => {
+                const predecessor = faultsById.get(id);
+                return (predecessor?.family === "network.partition" &&
+                    predecessor.links.length === fault.links.length &&
+                    predecessor.links.every((link, index) => compareLink(link, fault.links[index]) === 0));
+            }))
+            throw new TypeError("closed-loop network heal requires its causal partition");
+    }
+    return deepFreezePlanning({
+        schemaVersion: 1,
+        nominalDefinitionDigest: value.nominalDefinitionDigest,
+        faults,
+    });
+}
+export function collectiveClosedLoopFaultPlanDigestV1(value) {
+    exact(value, faultPlanBodyKeys, "closed-loop fault plan body");
+    const body = normalizedFaultPlanBody(value);
+    return digestBody("collective-closed-loop-fault-plan-v1", body);
+}
+export function createCollectiveClosedLoopFaultPlanV1(input) {
+    exact(input, faultPlanBodyKeys, "closed-loop fault plan input");
+    const body = normalizedFaultPlanBody(input);
+    return deepFreezePlanning({
+        ...body,
+        faultPlanDigest: collectiveClosedLoopFaultPlanDigestV1(body),
+    });
+}
+export function validateCollectiveClosedLoopFaultPlanV1(value) {
+    exact(value, faultPlanKeys, "closed-loop fault plan");
+    digest(value.faultPlanDigest, "faultPlanDigest");
+    const body = normalizedFaultPlanBody(value);
+    const faultPlanDigest = collectiveClosedLoopFaultPlanDigestV1(body);
+    if (value.faultPlanDigest !== faultPlanDigest)
+        throw new TypeError("closed-loop fault plan digest is invalid");
+    return deepFreezePlanning({ ...body, faultPlanDigest });
+}
+function assertFaultPlanTargetsBound(plan, definition) {
+    const peers = new Map(definition.peers.map((peer) => [peer.peerId, peer]));
+    for (const fault of plan.faults) {
+        if (fault.trigger.logicalTimeMs > definition.maximumLogicalTimeMs)
+            throw new TypeError("closed-loop fault trigger exceeds the nominal logical-time bound");
+        for (const target of fault.targets)
+            if (!peers.has(target.peerId))
+                throw new TypeError("closed-loop fault target is outside the nominal definition");
+        for (const link of fault.links) {
+            const fromPeer = peers.get(link.fromPeerId);
+            if (!fromPeer || !peers.has(link.toPeerId))
+                throw new TypeError("closed-loop fault link is outside the nominal definition");
+            if (!fromPeer.neighborPeerIds.includes(link.toPeerId))
+                throw new TypeError("closed-loop fault link is outside the nominal topology");
+        }
+    }
+}
+function normalizedResilienceDefinitionBody(value) {
+    if (value.schemaVersion !== 1)
+        throw new TypeError("closed-loop resilience definition schema is invalid");
+    const nominalDefinition = validateCollectiveClosedLoopDefinitionV1(value.nominalDefinition);
+    const faultPlan = validateCollectiveClosedLoopFaultPlanV1(value.faultPlan);
+    safeInteger(value.maximumEpochs, "maximumEpochs", COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.minimumEpochs);
+    if (value.maximumEpochs >
+        COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.maximumEpochs)
+        throw new TypeError("maximumEpochs exceeds the resilience limit");
+    if (faultPlan.nominalDefinitionDigest !== nominalDefinition.definitionDigest)
+        throw new TypeError("closed-loop resilience fault plan is not bound to its nominal definition");
+    assertFaultPlanTargetsBound(faultPlan, nominalDefinition);
+    return deepFreezePlanning({
+        schemaVersion: 1,
+        nominalDefinition,
+        faultPlan,
+        maximumEpochs: value.maximumEpochs,
+    });
+}
+export function collectiveClosedLoopResilienceDefinitionDigestV1(value) {
+    exact(value, resilienceDefinitionBodyKeys, "closed-loop resilience definition body");
+    const body = normalizedResilienceDefinitionBody(value);
+    return digestBody("collective-closed-loop-resilience-definition-v1", body);
+}
+export function createCollectiveClosedLoopResilienceDefinitionV1(input) {
+    exact(input, resilienceDefinitionBodyKeys, "closed-loop resilience definition input");
+    const body = normalizedResilienceDefinitionBody(input);
+    return deepFreezePlanning({
+        ...body,
+        resilienceDefinitionDigest: collectiveClosedLoopResilienceDefinitionDigestV1(body),
+    });
+}
+export function validateCollectiveClosedLoopResilienceDefinitionV1(value) {
+    exact(value, resilienceDefinitionKeys, "closed-loop resilience definition");
+    digest(value.resilienceDefinitionDigest, "resilienceDefinitionDigest");
+    const body = normalizedResilienceDefinitionBody(value);
+    const resilienceDefinitionDigest = collectiveClosedLoopResilienceDefinitionDigestV1(body);
+    if (value.resilienceDefinitionDigest !== resilienceDefinitionDigest)
+        throw new TypeError("closed-loop resilience definition digest is invalid");
+    return deepFreezePlanning({ ...body, resilienceDefinitionDigest });
+}
+function validateEpoch(value) {
+    exact(value, [
+        "schemaVersion",
+        "epoch",
+        "startedAtLogicalMs",
+        "endedAtLogicalMs",
+        "planningStateRoot",
+        "meshStateRoot",
+        "governanceStateRoot",
+    ], "closed-loop resilience epoch");
+    if (value.schemaVersion !== 1)
+        throw new TypeError("closed-loop resilience epoch schema is invalid");
+    safeInteger(value.epoch, "epoch", 1);
+    safeInteger(value.startedAtLogicalMs, "startedAtLogicalMs");
+    safeInteger(value.endedAtLogicalMs, "endedAtLogicalMs");
+    if (value.endedAtLogicalMs < value.startedAtLogicalMs)
+        throw new TypeError("closed-loop resilience epoch ends before it starts");
+    digest(value.planningStateRoot, "planningStateRoot");
+    digest(value.meshStateRoot, "meshStateRoot");
+    digest(value.governanceStateRoot, "governanceStateRoot");
+    return deepFreezePlanning({
+        schemaVersion: 1,
+        epoch: value.epoch,
+        startedAtLogicalMs: value.startedAtLogicalMs,
+        endedAtLogicalMs: value.endedAtLogicalMs,
+        planningStateRoot: value.planningStateRoot,
+        meshStateRoot: value.meshStateRoot,
+        governanceStateRoot: value.governanceStateRoot,
+    });
+}
+function validateFaultObservation(value) {
+    exact(value, [
+        "schemaVersion",
+        "faultId",
+        "scheduledEventDigest",
+        "injectedEventDigest",
+        "observedEventDigest",
+    ], "closed-loop fault observation");
+    if (value.schemaVersion !== 1)
+        throw new TypeError("closed-loop fault observation schema is invalid");
+    token(value.faultId, "fault observation faultId");
+    digest(value.scheduledEventDigest, "scheduledEventDigest");
+    digest(value.injectedEventDigest, "injectedEventDigest");
+    digest(value.observedEventDigest, "observedEventDigest");
+    return deepFreezePlanning({
+        schemaVersion: 1,
+        faultId: value.faultId,
+        scheduledEventDigest: value.scheduledEventDigest,
+        injectedEventDigest: value.injectedEventDigest,
+        observedEventDigest: value.observedEventDigest,
+    });
+}
+function validateStaleResultRejection(value) {
+    exact(value, [
+        "schemaVersion",
+        "rejectionId",
+        "faultId",
+        "rejectedAtLogicalMs",
+        "staleFenceDigest",
+        "currentFenceDigest",
+        "rejectionEventDigest",
+    ], "closed-loop stale result rejection");
+    if (value.schemaVersion !== 1)
+        throw new TypeError("closed-loop stale result rejection schema is invalid");
+    token(value.rejectionId, "stale result rejectionId");
+    token(value.faultId, "stale result faultId");
+    safeInteger(value.rejectedAtLogicalMs, "stale result rejectedAtLogicalMs");
+    digest(value.staleFenceDigest, "staleFenceDigest");
+    digest(value.currentFenceDigest, "currentFenceDigest");
+    digest(value.rejectionEventDigest, "rejectionEventDigest");
+    if (value.staleFenceDigest === value.currentFenceDigest)
+        throw new TypeError("stale result rejection must bind distinct fences");
+    return deepFreezePlanning({
+        schemaVersion: 1,
+        rejectionId: value.rejectionId,
+        faultId: value.faultId,
+        rejectedAtLogicalMs: value.rejectedAtLogicalMs,
+        staleFenceDigest: value.staleFenceDigest,
+        currentFenceDigest: value.currentFenceDigest,
+        rejectionEventDigest: value.rejectionEventDigest,
+    });
+}
+function normalizedResilienceResultBody(value) {
+    if (value.schemaVersion !== 1)
+        throw new TypeError("closed-loop resilience result schema is invalid");
+    digest(value.resilienceDefinitionDigest, "resilienceDefinitionDigest");
+    const run = validateCollectiveClosedLoopRunResultV1(value.run);
+    denseArray(value.epochs, "epochs");
+    if (value.epochs.length <
+        COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.minimumEpochs ||
+        value.epochs.length >
+            COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.maximumEpochs)
+        throw new TypeError("closed-loop resilience epoch count is invalid");
+    const epochs = value.epochs.map(validateEpoch);
+    for (let index = 0; index < epochs.length; index += 1) {
+        const epoch = epochs[index];
+        if (epoch.epoch !== index + 1 ||
+            (index === 0 && epoch.startedAtLogicalMs !== 0) ||
+            (index > 0 &&
+                epoch.startedAtLogicalMs !== epochs[index - 1].endedAtLogicalMs))
+            throw new TypeError("closed-loop resilience epochs are not ordered");
+    }
+    if (epochs[epochs.length - 1].endedAtLogicalMs !== run.finalLogicalTimeMs)
+        throw new TypeError("closed-loop resilience epochs do not close the run");
+    denseArray(value.faultObservations, "faultObservations");
+    const faultObservations = value.faultObservations.map(validateFaultObservation);
+    let previousFaultId = null;
+    const retainedEventDigests = new Set();
+    for (const observation of faultObservations) {
+        if (previousFaultId !== null && previousFaultId >= observation.faultId)
+            throw new TypeError("closed-loop fault observations must be sorted and unique");
+        for (const eventDigest of [
+            observation.scheduledEventDigest,
+            observation.injectedEventDigest,
+            observation.observedEventDigest,
+        ]) {
+            if (retainedEventDigests.has(eventDigest))
+                throw new TypeError("closed-loop fault evidence digest is reused");
+            retainedEventDigests.add(eventDigest);
+        }
+        previousFaultId = observation.faultId;
+    }
+    denseArray(value.staleResultRejections, "staleResultRejections");
+    if (value.staleResultRejections.length >
+        COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.maximumStaleResultRejections)
+        throw new TypeError("closed-loop stale result rejections are too large");
+    const staleResultRejections = value.staleResultRejections.map(validateStaleResultRejection);
+    let previousRejectionId = null;
+    for (const rejection of staleResultRejections) {
+        if (previousRejectionId !== null &&
+            previousRejectionId >= rejection.rejectionId)
+            throw new TypeError("closed-loop stale result rejections must be sorted and unique");
+        if (rejection.rejectedAtLogicalMs > run.finalLogicalTimeMs)
+            throw new TypeError("closed-loop stale result rejection is outside the run");
+        if (rejection.rejectionEventDigest === rejection.staleFenceDigest ||
+            rejection.rejectionEventDigest === rejection.currentFenceDigest ||
+            retainedEventDigests.has(rejection.rejectionEventDigest))
+            throw new TypeError("closed-loop stale result evidence digest is reused");
+        retainedEventDigests.add(rejection.rejectionEventDigest);
+        previousRejectionId = rejection.rejectionId;
+    }
+    return deepFreezePlanning({
+        schemaVersion: 1,
+        resilienceDefinitionDigest: value.resilienceDefinitionDigest,
+        run,
+        epochs,
+        faultObservations,
+        staleResultRejections,
+    });
+}
+export function collectiveClosedLoopResilienceResultDigestV1(value) {
+    exact(value, resilienceResultBodyKeys, "closed-loop resilience result body");
+    const body = normalizedResilienceResultBody(value);
+    return digestBody("collective-closed-loop-resilience-result-v1", body);
+}
+export function createCollectiveClosedLoopResilienceResultV1(input) {
+    exact(input, resilienceResultBodyKeys, "closed-loop resilience result input");
+    const body = normalizedResilienceResultBody(input);
+    return deepFreezePlanning({
+        ...body,
+        resilienceResultDigest: collectiveClosedLoopResilienceResultDigestV1(body),
+    });
+}
+export function validateCollectiveClosedLoopResilienceResultV1(value) {
+    exact(value, resilienceResultKeys, "closed-loop resilience result");
+    digest(value.resilienceResultDigest, "resilienceResultDigest");
+    const body = normalizedResilienceResultBody(value);
+    const resilienceResultDigest = collectiveClosedLoopResilienceResultDigestV1(body);
+    if (value.resilienceResultDigest !== resilienceResultDigest)
+        throw new TypeError("closed-loop resilience result digest is invalid");
+    return deepFreezePlanning({ ...body, resilienceResultDigest });
+}
+/**
+ * Performs the cross-record checks deliberately kept out of the result digest
+ * constructor. Runners call this at finalization, after they hold the exact
+ * registered resilience definition.
+ */
+export function validateCollectiveClosedLoopResilienceResultForDefinitionV1(value, resilienceDefinitionInput) {
+    const result = validateCollectiveClosedLoopResilienceResultV1(value);
+    const definition = validateCollectiveClosedLoopResilienceDefinitionV1(resilienceDefinitionInput);
+    if (result.resilienceDefinitionDigest !==
+        definition.resilienceDefinitionDigest ||
+        result.run.registrationBindingDigest !==
+            definition.nominalDefinition.registration.bindingDigest ||
+        result.run.runner !== definition.nominalDefinition.registration.runner ||
+        result.run.finalLogicalTimeMs >
+            definition.nominalDefinition.maximumLogicalTimeMs ||
+        result.epochs.length > definition.maximumEpochs)
+        throw new TypeError("closed-loop resilience result is not bound to its definition");
+    const expectedFaultIds = definition.faultPlan.faults.map((fault) => fault.faultId);
+    const observedFaultIds = result.faultObservations.map((observation) => observation.faultId);
+    if (!sameStrings(expectedFaultIds, observedFaultIds))
+        throw new TypeError("closed-loop resilience result fault coverage is incomplete");
+    const faultsById = new Map(definition.faultPlan.faults.map((fault) => [fault.faultId, fault]));
+    for (const fault of definition.faultPlan.faults)
+        if (fault.trigger.logicalTimeMs > result.run.finalLogicalTimeMs)
+            throw new TypeError("closed-loop fault trigger is outside the run");
+    for (const rejection of result.staleResultRejections) {
+        const fault = faultsById.get(rejection.faultId);
+        if (fault === undefined ||
+            rejection.rejectedAtLogicalMs < fault.trigger.logicalTimeMs)
+            throw new TypeError("closed-loop stale result rejection is outside the fault plan");
+    }
+    return result;
+}
+function validateCampaignLimits(value) {
+    exact(value, ["schemaVersion", "maximumFaults", "maximumEpochs", "maximumInteractions"], "closed-loop resilience campaign limits");
+    if (value.schemaVersion !== 1)
+        throw new TypeError("closed-loop resilience campaign limits schema is invalid");
+    safeInteger(value.maximumFaults, "maximumFaults", 1);
+    safeInteger(value.maximumEpochs, "maximumEpochs", COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.minimumEpochs);
+    safeInteger(value.maximumInteractions, "maximumInteractions", 1);
+    if (value.maximumFaults >
+        COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.maximumFaults ||
+        value.maximumEpochs >
+            COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.maximumEpochs)
+        throw new TypeError("closed-loop resilience campaign limits exceed contract limits");
+    return deepFreezePlanning({
+        schemaVersion: 1,
+        maximumFaults: value.maximumFaults,
+        maximumEpochs: value.maximumEpochs,
+        maximumInteractions: value.maximumInteractions,
+    });
+}
+function normalizedCampaignEvidenceBody(value) {
+    if (value.schemaVersion !== 1)
+        throw new TypeError("closed-loop resilience campaign evidence schema is invalid");
+    digest(value.resilienceDefinitionDigest, "resilienceDefinitionDigest");
+    digest(value.resilienceResultDigest, "resilienceResultDigest");
+    if (value.runner !== "adaptive_collective" &&
+        value.runner !== "centralized_planner")
+        throw new TypeError("closed-loop resilience campaign runner is invalid");
+    safeInteger(value.seed, "seed");
+    const limits = validateCampaignLimits(value.limits);
+    const scheduledFaultIds = sortedTokens(value.scheduledFaultIds, "scheduledFaultIds", limits.maximumFaults);
+    const injectedFaultIds = sortedTokens(value.injectedFaultIds, "injectedFaultIds", limits.maximumFaults);
+    const observedFaultIds = sortedTokens(value.observedFaultIds, "observedFaultIds", limits.maximumFaults);
+    const staleResultRejectionIds = sortedTokens(value.staleResultRejectionIds, "staleResultRejectionIds", COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.maximumStaleResultRejections);
+    if (!sameStrings(scheduledFaultIds, injectedFaultIds) ||
+        !sameStrings(scheduledFaultIds, observedFaultIds))
+        throw new TypeError("closed-loop resilience campaign fault coverage is incomplete");
+    return deepFreezePlanning({
+        schemaVersion: 1,
+        resilienceDefinitionDigest: value.resilienceDefinitionDigest,
+        resilienceResultDigest: value.resilienceResultDigest,
+        runner: value.runner,
+        seed: value.seed,
+        limits,
+        scheduledFaultIds,
+        injectedFaultIds,
+        observedFaultIds,
+        staleResultRejectionIds,
+    });
+}
+function sameStrings(left, right) {
+    return (left.length === right.length &&
+        left.every((item, index) => item === right[index]));
+}
+export function collectiveClosedLoopResilienceCampaignEvidenceDigestV1(value) {
+    exact(value, campaignEvidenceBodyKeys, "closed-loop resilience campaign evidence body");
+    const body = normalizedCampaignEvidenceBody(value);
+    return digestBody("collective-closed-loop-resilience-campaign-evidence-v1", body);
+}
+export function createCollectiveClosedLoopResilienceCampaignEvidenceV1(input) {
+    exact(input, campaignEvidenceBodyKeys, "closed-loop resilience campaign evidence input");
+    const body = normalizedCampaignEvidenceBody(input);
+    return deepFreezePlanning({
+        ...body,
+        campaignEvidenceDigest: collectiveClosedLoopResilienceCampaignEvidenceDigestV1(body),
+    });
+}
+export function validateCollectiveClosedLoopResilienceCampaignEvidenceV1(value) {
+    exact(value, campaignEvidenceKeys, "closed-loop resilience campaign evidence");
+    digest(value.campaignEvidenceDigest, "campaignEvidenceDigest");
+    const body = normalizedCampaignEvidenceBody(value);
+    const campaignEvidenceDigest = collectiveClosedLoopResilienceCampaignEvidenceDigestV1(body);
+    if (value.campaignEvidenceDigest !== campaignEvidenceDigest)
+        throw new TypeError("closed-loop resilience campaign evidence digest is invalid");
+    return deepFreezePlanning({ ...body, campaignEvidenceDigest });
+}
+/** Binds campaign counters to one finalized result and its registered plan. */
+export function validateCollectiveClosedLoopResilienceCampaignEvidenceForResultV1(value, resilienceDefinitionInput, resilienceResultInput) {
+    const evidence = validateCollectiveClosedLoopResilienceCampaignEvidenceV1(value);
+    const definition = validateCollectiveClosedLoopResilienceDefinitionV1(resilienceDefinitionInput);
+    const result = validateCollectiveClosedLoopResilienceResultForDefinitionV1(resilienceResultInput, definition);
+    const expectedFaultIds = definition.faultPlan.faults.map((fault) => fault.faultId);
+    const expectedRejectionIds = result.staleResultRejections.map((rejection) => rejection.rejectionId);
+    if (evidence.resilienceDefinitionDigest !==
+        definition.resilienceDefinitionDigest ||
+        evidence.resilienceResultDigest !== result.resilienceResultDigest ||
+        evidence.runner !== result.run.runner ||
+        evidence.seed !== definition.nominalDefinition.registration.seed ||
+        evidence.limits.maximumFaults !==
+            COLLECTIVE_CLOSED_LOOP_RESILIENCE_LIMITS_V1.maximumFaults ||
+        evidence.limits.maximumEpochs !== definition.maximumEpochs ||
+        evidence.limits.maximumInteractions !==
+            definition.nominalDefinition.registration.limits.maximumInteractions ||
+        !sameStrings(evidence.scheduledFaultIds, expectedFaultIds) ||
+        !sameStrings(evidence.injectedFaultIds, expectedFaultIds) ||
+        !sameStrings(evidence.observedFaultIds, expectedFaultIds) ||
+        !sameStrings(evidence.staleResultRejectionIds, expectedRejectionIds))
+        throw new TypeError("closed-loop resilience campaign evidence is not bound to its result");
+    return evidence;
+}
+//# sourceMappingURL=collective-closed-loop-resilience-contracts.js.map