@agentplat/mesh 0.3.0-alpha.3 → 0.3.0-alpha.5

package/dist/trust.js

@@ -0,0 +1,934 @@
+import { verifyMeshEnvelope } from "@agentplat/mesh-crypto";
+import { canonicalizeMeshJson, validateMeshEnvelopeContext, } from "@agentplat/mesh-protocol";
+import { normalizeMeshEvidenceAttestationV1, normalizeMeshEvidenceChallengeV1, normalizeMeshEvidenceClaimV1, normalizeMeshEvidenceRetractionV1, normalizeMeshTrustObservationV1, } from "@agentplat/trust/mesh-records";
+import { assertExactKeys, assertIdentifier, assertSafeInteger, assertTrustDigest, createTrustEligibilityRequestV1, deepFreeze, digestScopeV1, digestSubjectV1, digestTrustProfileKeyV1, digestTrustJsonV1, evaluateTrustEligibilityV1, reduceEvidenceTrustStateV1, restoreEvidenceTrustSnapshotV1, sha256TrustBytesV1, validateEvidenceScopeV1, validateEvidenceTrustStateV1, } from "@agentplat/trust";
+const trustDigestPattern = /^[0-9a-f]{64}$/;
+const maximumOriginProofs = 4_096;
+const maximumRemoteObservations = 4_096;
+const maximumAuthorityDigests = 32;
+const maximumEligibilityStateIdentities = 4_096;
+/** Unforgeable, adapter-bound handoff from the verified processor. */
+const concreteAdapterCapabilities = new WeakMap();
+const authorizedAdapterInvocations = new WeakMap();
+const verifiedEligibilityRuntimeStates = new WeakMap();
+const latestEligibilitySnapshotByStateId = new Map();
+/** Creates the Trust reducer adapter; no direct payload route exists. */
+export function createMeshEvidenceTrustAdapterV1(bindingDigest, originVerifierBindingDigest, authorization) {
+    if (!trustDigestPattern.test(bindingDigest) ||
+        !trustDigestPattern.test(originVerifierBindingDigest) ||
+        !authorization ||
+        typeof authorization !== "object" ||
+        typeof authorization.prepare !== "function") {
+        throw new TypeError("Mesh Evidence Trust adapter bindings are invalid");
+    }
+    const prepare = authorization.prepare.bind(authorization);
+    const adapterCapability = Object.freeze({});
+    const adapter = {
+        bindingDigest,
+        prepare: (input) => {
+            const result = prepare({
+                authorizationState: input.state.authorizationState,
+                envelope: input.envelope,
+                receivedAt: input.receivedAt,
+            });
+            if (!result || typeof result !== "object" || result.accepted !== true)
+                return result;
+            return Object.freeze({
+                accepted: true,
+                nextAuthorizationState: result.nextAuthorizationState,
+                admissionStateDigest: result.admissionStateDigest,
+                coordinationAuthorityDigests: Object.freeze([
+                    ...result.coordinationAuthorityDigests,
+                ]),
+                replayStateDigest: result.replayStateDigest,
+                observationCorrelated: result.observationCorrelated,
+                effectiveAtLogicalMs: result.effectiveAtLogicalMs,
+            });
+        },
+        process: (input) => {
+            if (!input ||
+                typeof input !== "object" ||
+                authorizedAdapterInvocations.get(input) !== adapterCapability) {
+                return {
+                    accepted: false,
+                    code: "trust_transition_rejected",
+                    state: input?.state,
+                };
+            }
+            authorizedAdapterInvocations.delete(input);
+            let originEntry;
+            try {
+                originEntry = createOriginJournalEntry(input.origin, input.envelope);
+            }
+            catch {
+                return {
+                    accepted: false,
+                    code: "trust_transition_rejected",
+                    state: input.state,
+                };
+            }
+            if (!Object.hasOwn(input.state.originProofs, input.origin.originProofDigest) &&
+                Object.keys(input.state.originProofs).length >= maximumOriginProofs) {
+                return {
+                    accepted: false,
+                    code: "trust_transition_rejected",
+                    state: input.state,
+                };
+            }
+            const originProofs = {
+                ...input.state.originProofs,
+                [input.origin.originProofDigest]: originEntry,
+            };
+            if (input.observation !== undefined) {
+                if (!Object.hasOwn(input.state.remoteObservations, input.observation.observationId) &&
+                    Object.keys(input.state.remoteObservations).length >=
+                        maximumRemoteObservations) {
+                    return {
+                        accepted: false,
+                        code: "trust_transition_rejected",
+                        state: input.state,
+                    };
+                }
+                const remoteObservations = {
+                    ...input.state.remoteObservations,
+                    [input.observation.observationId]: Object.freeze({
+                        observation: input.observation,
+                        correlated: input.observationCorrelated === true,
+                    }),
+                };
+                return {
+                    accepted: true,
+                    duplicate: Object.hasOwn(input.state.remoteObservations, input.observation.observationId),
+                    state: Object.freeze({
+                        ...input.state,
+                        authorizationState: input.preparation.nextAuthorizationState,
+                        originProofs: Object.freeze(originProofs),
+                        remoteObservations: Object.freeze(remoteObservations),
+                    }),
+                };
+            }
+            try {
+                const record = input.record;
+                const recordId = evidenceRecordId(record);
+                const recordDigest = recordId.slice(recordId.indexOf(":") + 1);
+                const reduced = reduceEvidenceTrustStateV1(input.state.trust, {
+                    schemaVersion: 1,
+                    kind: "record_admitted",
+                    record,
+                    origin: "verified_mesh",
+                    originBindingDigest: input.originBindingDigest,
+                    originVerifierBindingDigest: input.originVerifierBindingDigest,
+                    originProofDigest: input.origin.originProofDigest,
+                    effectiveAtLogicalMs: input.preparation.effectiveAtLogicalMs,
+                    logicalTimeMs: input.receivedAt,
+                }, {
+                    verifiedMeshAdmissionVerifierRegistry: {
+                        resolve: (binding) => binding !== originVerifierBindingDigest
+                            ? null
+                            : {
+                                verifierBindingDigest: originVerifierBindingDigest,
+                                upstreamBindingDigest: input.originBindingDigest,
+                                verify: (candidate) => {
+                                    const proofEntry = originProofs[candidate.originProofDigest];
+                                    const proof = proofEntry?.descriptor;
+                                    return (proof !== undefined &&
+                                        validateOriginJournalEntry(proofEntry) &&
+                                        candidate.originBindingDigest ===
+                                            input.originBindingDigest &&
+                                        candidate.originVerifierBindingDigest ===
+                                            originVerifierBindingDigest &&
+                                        candidate.recordId === recordId &&
+                                        candidate.recordDigest === recordDigest &&
+                                        candidate.effectiveAtLogicalMs ===
+                                            input.preparation.effectiveAtLogicalMs &&
+                                        proof.normalizedRecordId === recordId &&
+                                        proof.normalizedRecordDigest === recordDigest);
+                                },
+                            },
+                    },
+                });
+                const duplicate = reduced.effects.some((effect) => effect.reasonCode === "duplicate");
+                return {
+                    accepted: true,
+                    duplicate,
+                    state: Object.freeze({
+                        ...input.state,
+                        authorizationState: input.preparation.nextAuthorizationState,
+                        trust: reduced.state,
+                        originProofs: Object.freeze(originProofs),
+                    }),
+                };
+            }
+            catch {
+                return {
+                    accepted: false,
+                    code: "trust_transition_rejected",
+                    state: input.state,
+                };
+            }
+        },
+    };
+    const frozenAdapter = Object.freeze(adapter);
+    concreteAdapterCapabilities.set(frozenAdapter, adapterCapability);
+    return frozenAdapter;
+}
+/** Creates the only Mesh route allowed to create a `verified_mesh` record. */
+export function createMeshEvidenceInboundProcessorV1(options) {
+    if (!options ||
+        typeof options !== "object" ||
+        !options.adapter ||
+        !options.resolver ||
+        typeof options.resolver.resolve !== "function" ||
+        !options.cryptoPolicy ||
+        !Array.isArray(options.cryptoPolicy.allowedAlgorithms) ||
+        options.cryptoPolicy.allowedAlgorithms.length === 0 ||
+        typeof options.adapter.prepare !== "function" ||
+        typeof options.adapter.process !== "function" ||
+        !trustDigestPattern.test(options.adapter.bindingDigest) ||
+        !trustDigestPattern.test(options.originVerifierBindingDigest)) {
+        throw new TypeError("Mesh Evidence inbound dependencies are required");
+    }
+    const adapterCapability = concreteAdapterCapabilities.get(options.adapter);
+    const resolver = Object.freeze({
+        resolve: options.resolver.resolve.bind(options.resolver),
+    });
+    const policy = Object.freeze({
+        allowedAlgorithms: Object.freeze([
+            ...options.cryptoPolicy.allowedAlgorithms,
+        ]),
+    });
+    const configuration = Object.freeze({
+        resolver,
+        policy,
+        adapter: Object.freeze({
+            bindingDigest: options.adapter.bindingDigest,
+            prepare: options.adapter.prepare.bind(options.adapter),
+            process: options.adapter.process.bind(options.adapter),
+        }),
+        originVerifierBindingDigest: options.originVerifierBindingDigest,
+        crypto: options.crypto,
+        protocolOptions: options.protocolOptions,
+        supportedCriticalExtensions: options.supportedCriticalExtensions === undefined
+            ? undefined
+            : Object.freeze([...options.supportedCriticalExtensions]),
+        adapterCapability,
+    });
+    const processor = {
+        async process(state, request) {
+            if (!state ||
+                !request ||
+                typeof request !== "object" ||
+                !Number.isSafeInteger(request.receivedAt) ||
+                request.receivedAt < 0)
+                return reject(state, "invalid_request");
+            if (!isRuntimeState(state))
+                return reject(state, "invalid_request");
+            const contextual = validateMeshEnvelopeContext(request.envelope, {
+                tenantId: state.identity.tenantId,
+                meshId: state.identity.meshId,
+                peerId: state.identity.peerId,
+                receivedAt: request.verifiedAt,
+                ...(configuration.supportedCriticalExtensions === undefined
+                    ? {}
+                    : {
+                        supportedCriticalExtensions: configuration.supportedCriticalExtensions,
+                    }),
+            }, configuration.protocolOptions);
+            if (!contextual.ok)
+                return reject(state, contextual.issues[0]?.code === "invalid_audience"
+                    ? "audience_mismatch"
+                    : "scope_mismatch");
+            if (!isTrustPayload(contextual.value.payload))
+                return reject(state, "unsupported_message_type");
+            let verification;
+            try {
+                verification = await verifyMeshEnvelope({
+                    envelope: request.envelope,
+                    resolver: configuration.resolver,
+                    policy: configuration.policy,
+                    verifiedAt: request.verifiedAt,
+                    crypto: configuration.crypto,
+                    protocolOptions: configuration.protocolOptions,
+                });
+            }
+            catch {
+                return reject(state, "crypto_rejected");
+            }
+            if (!verification.verified)
+                return reject(state, "crypto_rejected");
+            const envelope = verification.envelope;
+            const normalized = normalize(envelope);
+            if (!normalized)
+                return reject(state, "normalization_failed");
+            let prepared;
+            try {
+                prepared = configuration.adapter.prepare({
+                    state: state.state,
+                    envelope,
+                    receivedAt: request.receivedAt,
+                });
+            }
+            catch {
+                return reject(state, "authorization_rejected");
+            }
+            let acceptedPreparation;
+            let preparationSecurity;
+            try {
+                if (!prepared || typeof prepared !== "object")
+                    return reject(state, "authorization_rejected");
+                const accepted = prepared.accepted;
+                if (accepted !== true) {
+                    const code = prepared.code;
+                    if (accepted === false &&
+                        (code === "authorization_rejected" || code === "replay_rejected"))
+                        return Object.freeze({ accepted: false, code, state });
+                    return reject(state, "authorization_rejected");
+                }
+                preparationSecurity = Object.freeze({
+                    accepted: true,
+                    admissionStateDigest: prepared.admissionStateDigest,
+                    coordinationAuthorityDigests: Object.freeze([
+                        ...prepared.coordinationAuthorityDigests,
+                    ]),
+                    replayStateDigest: prepared.replayStateDigest,
+                    observationCorrelated: prepared.observationCorrelated,
+                    effectiveAtLogicalMs: prepared.effectiveAtLogicalMs,
+                });
+                if (!isValidPreparation(preparationSecurity, envelope, request.receivedAt))
+                    return reject(state, "authorization_rejected");
+                acceptedPreparation = prepared;
+            }
+            catch {
+                return reject(state, "authorization_rejected");
+            }
+            let origin;
+            try {
+                origin = createOriginProof(envelope, verification.key.keyId, normalized.record === undefined
+                    ? normalized.observation.observationId
+                    : evidenceRecordId(normalized.record), preparationSecurity);
+            }
+            catch {
+                return reject(state, "normalization_failed");
+            }
+            const adapterInput = Object.freeze({
+                state: state.state,
+                envelope,
+                verifiedKeyId: verification.key.keyId,
+                receivedAt: request.receivedAt,
+                ...(normalized.record === undefined
+                    ? { observation: normalized.observation }
+                    : { record: normalized.record }),
+                ...(normalized.observation === undefined
+                    ? {}
+                    : {
+                        observationCorrelated: preparationSecurity.observationCorrelated,
+                    }),
+                origin,
+                originBindingDigest: configuration.adapter.bindingDigest,
+                originVerifierBindingDigest: configuration.originVerifierBindingDigest,
+                preparation: acceptedPreparation,
+            });
+            let transition;
+            if (configuration.adapterCapability !== undefined)
+                authorizedAdapterInvocations.set(adapterInput, configuration.adapterCapability);
+            try {
+                transition = configuration.adapter.process(adapterInput);
+            }
+            catch {
+                return reject(state, "trust_transition_rejected");
+            }
+            finally {
+                authorizedAdapterInvocations.delete(adapterInput);
+            }
+            if (!transition || typeof transition !== "object")
+                return reject(state, "trust_transition_rejected");
+            if (!isValidAdapterTransition(transition, state.state))
+                return reject(state, "trust_transition_rejected");
+            if (!transition.accepted)
+                return Object.freeze({
+                    accepted: false,
+                    code: transition.code,
+                    state,
+                });
+            return Object.freeze({
+                accepted: true,
+                duplicate: transition.duplicate,
+                observation: normalized.observation !== undefined,
+                state: freezeState(state, transition.state),
+            });
+        },
+    };
+    return Object.freeze(processor);
+}
+function normalize(envelope) {
+    const material = {
+        schemaVersion: 1,
+        tenantId: envelope.tenantId,
+        meshId: envelope.meshId,
+        objectiveId: envelope.objectiveId ?? null,
+        senderPeerId: envelope.sender.peerId,
+        causationId: envelope.causationId ?? null,
+    };
+    try {
+        switch (envelope.payload.type) {
+            case "evidence.claim": {
+                const record = normalizeMeshEvidenceClaimV1(material, omit(envelope.payload, ["type", "claimId", "assertionDigest"]));
+                return record.claimId === envelope.payload.claimId &&
+                    record.assertionDigest === envelope.payload.assertionDigest
+                    ? { record }
+                    : undefined;
+            }
+            case "evidence.attest": {
+                const record = normalizeMeshEvidenceAttestationV1(material, omit(envelope.payload, ["type", "attestationId"]));
+                return record.attestationId === envelope.payload.attestationId
+                    ? { record }
+                    : undefined;
+            }
+            case "evidence.challenge": {
+                const record = normalizeMeshEvidenceChallengeV1(material, omit(envelope.payload, ["type", "challengeId"]));
+                return record.challengeId === envelope.payload.challengeId
+                    ? { record }
+                    : undefined;
+            }
+            case "evidence.retract": {
+                const record = normalizeMeshEvidenceRetractionV1(material, omit(envelope.payload, ["type", "retractionId"]));
+                return record.retractionId === envelope.payload.retractionId
+                    ? { record }
+                    : undefined;
+            }
+            case "trust.observation": {
+                const observation = normalizeMeshTrustObservationV1(material, omit(envelope.payload, ["type", "observationId"]));
+                return observation.observationId === envelope.payload.observationId
+                    ? { observation }
+                    : undefined;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+function omit(value, keys) {
+    const result = { ...value };
+    for (const key of keys)
+        delete result[key];
+    return result;
+}
+function createOriginProof(envelope, keyId, recordId, security) {
+    const canonical = canonicalizeMeshJson(envelope);
+    if (!canonical.ok)
+        throw new TypeError("verified Mesh envelope is not canonical");
+    const signedEnvelopeDigest = sha256TrustBytesV1(new TextEncoder().encode(canonical.value));
+    const recordDigest = recordId.slice(recordId.indexOf(":") + 1);
+    const descriptor = {
+        schemaVersion: 1,
+        messageId: envelope.messageId,
+        payloadHash: envelope.payloadHash,
+        signedEnvelopeDigest,
+        senderPeerId: envelope.sender.peerId,
+        senderKeyId: keyId,
+        admissionStateDigest: security.admissionStateDigest,
+        coordinationAuthorityDigests: Object.freeze([...security.coordinationAuthorityDigests].sort()),
+        replayStateDigest: security.replayStateDigest,
+        normalizedRecordId: recordId,
+        normalizedRecordDigest: recordDigest,
+    };
+    return Object.freeze({
+        ...descriptor,
+        originProofDigest: digestTrustJsonV1("origin-proof", descriptor),
+    });
+}
+function createOriginJournalEntry(descriptor, envelope) {
+    const canonical = canonicalizeMeshJson(envelope);
+    if (!canonical.ok)
+        throw new TypeError("verified Mesh envelope is not canonical");
+    const entry = Object.freeze({
+        schemaVersion: 1,
+        descriptor,
+        canonicalSignedEnvelope: canonical.value,
+    });
+    if (!validateMeshEvidenceOriginJournalEntryV1(entry))
+        throw new TypeError("Mesh Evidence origin journal entry is invalid");
+    return entry;
+}
+/** Validates retained descriptor + exact canonical signed-envelope bytes. */
+export function validateMeshEvidenceOriginJournalEntryV1(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const entry = value;
+    if (entry.schemaVersion !== 1 ||
+        typeof entry.canonicalSignedEnvelope !== "string" ||
+        !entry.descriptor ||
+        typeof entry.descriptor !== "object" ||
+        Array.isArray(entry.descriptor) ||
+        !hasExactKeys(entry, [
+            "schemaVersion",
+            "descriptor",
+            "canonicalSignedEnvelope",
+        ]))
+        return false;
+    const descriptor = entry.descriptor;
+    if (!hasExactKeys(descriptor, [
+        "schemaVersion",
+        "messageId",
+        "payloadHash",
+        "signedEnvelopeDigest",
+        "senderPeerId",
+        "senderKeyId",
+        "admissionStateDigest",
+        "coordinationAuthorityDigests",
+        "replayStateDigest",
+        "normalizedRecordId",
+        "normalizedRecordDigest",
+        "originProofDigest",
+    ]) ||
+        descriptor.schemaVersion !== 1 ||
+        !trustDigestPattern.test(String(descriptor.signedEnvelopeDigest)) ||
+        !trustDigestPattern.test(String(descriptor.admissionStateDigest)) ||
+        !trustDigestPattern.test(String(descriptor.replayStateDigest)) ||
+        !trustDigestPattern.test(String(descriptor.normalizedRecordDigest)) ||
+        !trustDigestPattern.test(String(descriptor.originProofDigest)) ||
+        !Array.isArray(descriptor.coordinationAuthorityDigests) ||
+        descriptor.coordinationAuthorityDigests.length > maximumAuthorityDigests ||
+        !descriptor.coordinationAuthorityDigests.every((digest) => typeof digest === "string" && trustDigestPattern.test(digest)) ||
+        !descriptor.coordinationAuthorityDigests.every((digest, index, values) => index === 0 || values[index - 1] < digest))
+        return false;
+    for (const key of [
+        "messageId",
+        "payloadHash",
+        "senderPeerId",
+        "senderKeyId",
+        "normalizedRecordId",
+    ])
+        if (typeof descriptor[key] !== "string" || descriptor[key].length === 0)
+            return false;
+    const { originProofDigest: _originProofDigest, ...descriptorBody } = descriptor;
+    if (digestTrustJsonV1("origin-proof", descriptorBody) !== descriptor.originProofDigest)
+        return false;
+    let parsed;
+    try {
+        parsed = JSON.parse(entry.canonicalSignedEnvelope);
+    }
+    catch {
+        return false;
+    }
+    const canonical = canonicalizeMeshJson(parsed);
+    if (!canonical.ok || canonical.value !== entry.canonicalSignedEnvelope)
+        return false;
+    const envelope = parsed;
+    const sender = envelope.sender;
+    const proof = envelope.proof;
+    return (envelope.messageId === descriptor.messageId &&
+        envelope.payloadHash === descriptor.payloadHash &&
+        sender?.peerId === descriptor.senderPeerId &&
+        proof?.keyId === descriptor.senderKeyId &&
+        sha256TrustBytesV1(new TextEncoder().encode(entry.canonicalSignedEnvelope)) === descriptor.signedEnvelopeDigest &&
+        String(descriptor.normalizedRecordId).endsWith(`:${descriptor.normalizedRecordDigest}`));
+}
+function validateOriginJournalEntry(entry) {
+    return validateMeshEvidenceOriginJournalEntryV1(entry);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return (actual.length === expected.length &&
+        actual.every((key, index) => key === expected[index]));
+}
+function isValidAdapterTransition(value, previousState) {
+    const transition = value;
+    if (transition.accepted === true)
+        return (hasExactKeys(transition, ["accepted", "duplicate", "state"]) &&
+            typeof transition.duplicate === "boolean");
+    return (transition.accepted === false &&
+        hasExactKeys(transition, ["accepted", "code", "state"]) &&
+        [
+            "authorization_rejected",
+            "replay_rejected",
+            "trust_transition_rejected",
+        ].includes(String(transition.code)) &&
+        transition.state === previousState);
+}
+function evidenceRecordId(record) {
+    if ("claimId" in record && "outcome" in record)
+        return record.claimId;
+    if ("attestationId" in record)
+        return record.attestationId;
+    if ("challengeId" in record)
+        return record.challengeId;
+    return record.retractionId;
+}
+function isTrustPayload(payload) {
+    return (payload.type === "evidence.claim" ||
+        payload.type === "evidence.attest" ||
+        payload.type === "evidence.challenge" ||
+        payload.type === "evidence.retract" ||
+        payload.type === "trust.observation");
+}
+function freezeState(state, next) {
+    return Object.freeze({
+        schemaVersion: 1,
+        identity: Object.freeze({ ...state.identity }),
+        state: next,
+    });
+}
+function reject(state, code) {
+    return Object.freeze({ accepted: false, code, state });
+}
+function isRuntimeState(state) {
+    return (state.schemaVersion === 1 &&
+        state.identity !== null &&
+        typeof state.identity === "object" &&
+        typeof state.identity.tenantId === "string" &&
+        typeof state.identity.meshId === "string" &&
+        typeof state.identity.peerId === "string");
+}
+function isValidPreparation(preparation, envelope, receivedAt) {
+    const authorities = preparation.coordinationAuthorityDigests;
+    return (preparation.accepted === true &&
+        trustDigestPattern.test(preparation.admissionStateDigest) &&
+        trustDigestPattern.test(preparation.replayStateDigest) &&
+        Array.isArray(authorities) &&
+        authorities.length <= maximumAuthorityDigests &&
+        authorities.every((digest) => trustDigestPattern.test(digest)) &&
+        authorities.every((digest, index) => index === 0 || authorities[index - 1] < digest) &&
+        typeof preparation.observationCorrelated === "boolean" &&
+        Number.isSafeInteger(preparation.effectiveAtLogicalMs) &&
+        preparation.effectiveAtLogicalMs >= 0 &&
+        preparation.effectiveAtLogicalMs <= receivedAt &&
+        (envelope.payload.scope.kind === "work" ||
+            preparation.effectiveAtLogicalMs === receivedAt));
+}
+export function filterMeshCapabilityMatchesWithTrustV1(candidates, mode, resolver) {
+    if (mode !== "observe" && mode !== "restrict") {
+        throw new TypeError("Mesh Trust eligibility mode is invalid");
+    }
+    if (new Set(candidates.map((candidate) => candidate.peerId)).size !==
+        candidates.length) {
+        throw new TypeError("Mesh Trust candidates must be unique");
+    }
+    const evaluate = resolver.evaluate.bind(resolver);
+    const diagnostics = candidates.map((candidate) => {
+        let status = "unavailable";
+        try {
+            status = evaluate(candidate);
+        }
+        catch {
+            status = "unavailable";
+        }
+        if (!["eligible", "restricted", "quarantined", "unavailable"].includes(status)) {
+            status = "unavailable";
+        }
+        return Object.freeze({ peerId: candidate.peerId, status });
+    });
+    const unavailable = diagnostics.some((item) => item.status === "unavailable");
+    const matches = mode === "observe"
+        ? candidates
+        : unavailable
+            ? []
+            : candidates.filter((_, index) => diagnostics[index].status === "eligible");
+    return Object.freeze({
+        matches: Object.freeze([...matches]),
+        diagnostics: Object.freeze(diagnostics),
+        unavailable,
+    });
+}
+export const MESH_PEER_SUBJECT_MAPPING_DIGEST_V1 = digestTrustJsonV1("mesh-subject-mapping", {
+    schemaVersion: 1,
+    candidateField: "peerId",
+    subjectKind: "peer",
+});
+/**
+ * Reconstructs the Trust member of a Mesh transaction only through the strict
+ * authenticated snapshot boundary. The caller must supply its current trusted
+ * external rollback anchor; structural Trust validation alone is insufficient.
+ */
+export function restoreMeshTrustEligibilityRuntimeStateV1(current, snapshot, anchor, protector, options = {}) {
+    if (!isRuntimeState(current) ||
+        !current.state ||
+        typeof current.state !== "object" ||
+        !Object.hasOwn(current.state, "authorizationState") ||
+        !Object.hasOwn(current.state, "originProofs") ||
+        !Object.hasOwn(current.state, "remoteObservations"))
+        throw new TypeError("Mesh Trust current transaction is invalid");
+    const trust = restoreEvidenceTrustSnapshotV1(snapshot, anchor, protector, options);
+    const prior = latestEligibilitySnapshotByStateId.get(snapshot.stateId);
+    if (!prior &&
+        latestEligibilitySnapshotByStateId.size >= maximumEligibilityStateIdentities)
+        throw new TypeError("Mesh Trust eligibility state capacity exceeded");
+    if (prior &&
+        (snapshot.generation < prior.generation ||
+            (snapshot.generation === prior.generation &&
+                snapshot.snapshotDigest !== prior.digest)))
+        throw new TypeError("Mesh Trust snapshot anchor is not current");
+    latestEligibilitySnapshotByStateId.set(snapshot.stateId, {
+        generation: snapshot.generation,
+        digest: snapshot.snapshotDigest,
+    });
+    const restored = Object.freeze({
+        schemaVersion: 1,
+        identity: Object.freeze({ ...current.identity }),
+        state: Object.freeze({
+            ...current.state,
+            trust,
+        }),
+    });
+    verifiedEligibilityRuntimeStates.set(restored, {
+        stateId: snapshot.stateId,
+        generation: snapshot.generation,
+        digest: snapshot.snapshotDigest,
+        logicalTimeMs: snapshot.createdAtLogicalMs,
+    });
+    return restored;
+}
+const stateEligibilityConfigKeys = [
+    "schemaVersion",
+    "mode",
+    "logicalTimeMs",
+    "scope",
+    "policyId",
+    "policyVersion",
+    "policyDigest",
+    "maximumProfileAgeMs",
+    "requirements",
+    "subjectMappingDigest",
+    "meshEligibilityBindingDigest",
+    "profileResolverBindingDigest",
+];
+export function createMeshTrustStateEligibilityConfigV1(value) {
+    try {
+        assertExactKeys(value, stateEligibilityConfigKeys, "Mesh Trust config");
+        if (value.schemaVersion !== 1 ||
+            (value.mode !== "observe" && value.mode !== "restrict"))
+            throw new TypeError("Mesh Trust config is invalid");
+        assertSafeInteger(value.logicalTimeMs, "logicalTimeMs");
+        assertIdentifier(value.policyId, "policyId");
+        assertSafeInteger(value.policyVersion, "policyVersion", 1);
+        assertTrustDigest(value.policyDigest, "policyDigest");
+        assertTrustDigest(value.subjectMappingDigest, "subjectMappingDigest");
+        assertTrustDigest(value.meshEligibilityBindingDigest, "meshEligibilityBindingDigest");
+        assertTrustDigest(value.profileResolverBindingDigest, "profileResolverBindingDigest");
+        if (value.subjectMappingDigest !== MESH_PEER_SUBJECT_MAPPING_DIGEST_V1 ||
+            value.meshEligibilityBindingDigest === value.profileResolverBindingDigest)
+            throw new TypeError("Mesh Trust config binding is invalid");
+        const scope = validateEvidenceScopeV1(value.scope);
+        if (scope.kind !== "mesh" &&
+            scope.kind !== "objective" &&
+            scope.kind !== "work")
+            throw new TypeError("Mesh Trust scope is invalid");
+        const validationSubject = {
+            schemaVersion: 1,
+            kind: "peer",
+            peerId: "mesh-subject-validation",
+        };
+        const validationProfileDigest = "0".repeat(64);
+        const request = createTrustEligibilityRequestV1({
+            schemaVersion: 1,
+            tenantId: scope.tenantId,
+            subject: validationSubject,
+            subjectDigest: digestSubjectV1(validationSubject),
+            scope,
+            scopeDigest: digestScopeV1(scope),
+            policyId: value.policyId,
+            policyVersion: value.policyVersion,
+            policyDigest: value.policyDigest,
+            profileId: `profile:${validationProfileDigest}`,
+            profileDigest: validationProfileDigest,
+            maximumProfileAgeMs: value.maximumProfileAgeMs,
+            requirements: value.requirements,
+        });
+        return deepFreeze({
+            ...value,
+            scope,
+            requirements: request.requirements,
+        });
+    }
+    catch (error) {
+        if (error instanceof TypeError && error.message.startsWith("Mesh Trust"))
+            throw error;
+        throw new TypeError("Mesh Trust state eligibility config is invalid", {
+            cause: error,
+        });
+    }
+}
+export function digestMeshTrustStateEligibilityConfigV1(value) {
+    const config = createMeshTrustStateEligibilityConfigV1(value);
+    return digestTrustJsonV1("mesh-eligibility-config", {
+        schemaVersion: config.schemaVersion,
+        mode: config.mode,
+        scope: config.scope,
+        policyId: config.policyId,
+        policyVersion: config.policyVersion,
+        policyDigest: config.policyDigest,
+        maximumProfileAgeMs: config.maximumProfileAgeMs,
+        requirements: config.requirements,
+        subjectMappingDigest: config.subjectMappingDigest,
+    });
+}
+function meshTrustBindingsAreCurrent(state, config) {
+    const resolver = state.dependencyBindings.find((binding) => binding.bindingDigest === config.profileResolverBindingDigest);
+    const integration = state.dependencyBindings.find((binding) => binding.bindingDigest === config.meshEligibilityBindingDigest);
+    const isCurrent = (binding) => binding !== undefined &&
+        binding.registeredAtLogicalMs <= config.logicalTimeMs &&
+        binding.validFromLogicalMs <= config.logicalTimeMs &&
+        (binding.validUntilLogicalMs === null ||
+            config.logicalTimeMs < binding.validUntilLogicalMs) &&
+        state.dependencyBindingHeads.some((head) => head.bindingKind === binding.bindingKind &&
+            head.bindingName === binding.bindingName &&
+            head.bindingVersion === binding.bindingVersion &&
+            head.bindingDigest === binding.bindingDigest);
+    return (isCurrent(resolver) &&
+        resolver.bindingKind === "profile_resolver" &&
+        resolver.policyDigest === config.policyDigest &&
+        resolver.subjectMappingDigest === config.subjectMappingDigest &&
+        isCurrent(integration) &&
+        integration.bindingKind === "mesh_eligibility" &&
+        integration.policyDigest === config.policyDigest &&
+        integration.subjectMappingDigest === config.subjectMappingDigest &&
+        integration.upstreamBindingDigest === resolver.bindingDigest &&
+        integration.configurationDigest ===
+            digestMeshTrustStateEligibilityConfigV1(config));
+}
+const unavailableMeshTrustDiagnostic = (peerId, reasonCode) => deepFreeze({
+    peerId,
+    disposition: "unavailable",
+    eligibilityDecisionId: null,
+    reasonCodes: [reasonCode],
+});
+const decisionDiagnostic = (peerId, decision) => deepFreeze({
+    peerId,
+    disposition: decision.disposition,
+    eligibilityDecisionId: decision.eligibilityDecisionId,
+    reasonCodes: decision.reasonCodes,
+});
+export function filterMeshCapabilityMatchesWithTrustStateV1(candidates, current, configValue) {
+    const config = createMeshTrustStateEligibilityConfigV1(configValue);
+    if (!Array.isArray(candidates))
+        throw new TypeError("Mesh Trust candidates are invalid");
+    for (const candidate of candidates)
+        try {
+            assertIdentifier(candidate?.peerId, "candidate.peerId");
+        }
+        catch (error) {
+            throw new TypeError("Mesh Trust candidates are invalid", {
+                cause: error,
+            });
+        }
+    if (new Set(candidates.map((candidate) => candidate.peerId)).size !==
+        candidates.length)
+        throw new TypeError("Mesh Trust candidates must be unique");
+    let state = null;
+    let sharedFailure = null;
+    try {
+        const scopeMeshId = "meshId" in config.scope ? config.scope.meshId : undefined;
+        const verifiedRuntime = verifiedEligibilityRuntimeStates.get(current);
+        const currentSnapshot = verifiedRuntime
+            ? latestEligibilitySnapshotByStateId.get(verifiedRuntime.stateId)
+            : null;
+        if (!verifiedRuntime ||
+            !currentSnapshot ||
+            verifiedRuntime.generation !== currentSnapshot.generation ||
+            verifiedRuntime.digest !== currentSnapshot.digest ||
+            config.logicalTimeMs !== verifiedRuntime.logicalTimeMs ||
+            !isRuntimeState(current) ||
+            !current.state ||
+            typeof current.state !== "object" ||
+            current.identity.tenantId !== config.scope.tenantId ||
+            current.identity.meshId !== scopeMeshId)
+            throw new TypeError("Mesh Trust current transaction is invalid");
+        state = validateEvidenceTrustStateV1(current.state.trust);
+        if (config.logicalTimeMs < state.logicalTimeHighWaterMs)
+            sharedFailure = "logical_time_rollback";
+        else if (!meshTrustBindingsAreCurrent(state, config))
+            sharedFailure = "dependency_binding_invalid";
+    }
+    catch {
+        sharedFailure = "state_conflict";
+    }
+    const diagnostics = candidates.map((candidate) => {
+        if (!state || sharedFailure)
+            return unavailableMeshTrustDiagnostic(candidate.peerId, sharedFailure ?? "state_conflict");
+        try {
+            const subject = {
+                schemaVersion: 1,
+                kind: "peer",
+                peerId: candidate.peerId,
+            };
+            const subjectDigest = digestSubjectV1(subject);
+            const scopeDigest = digestScopeV1(config.scope);
+            const profileKey = digestTrustProfileKeyV1({
+                tenantId: config.scope.tenantId,
+                subjectDigest,
+                scopeDigest,
+                policyDigest: config.policyDigest,
+            });
+            const profileHead = state.profileHeads.find((head) => head.profileKey === profileKey);
+            if (!profileHead)
+                return unavailableMeshTrustDiagnostic(candidate.peerId, "profile_unavailable");
+            const decision = evaluateTrustEligibilityV1(state, createTrustEligibilityRequestV1({
+                schemaVersion: 1,
+                tenantId: config.scope.tenantId,
+                subject,
+                subjectDigest,
+                scope: config.scope,
+                scopeDigest,
+                policyId: config.policyId,
+                policyVersion: config.policyVersion,
+                policyDigest: config.policyDigest,
+                profileId: profileHead.profileId,
+                profileDigest: profileHead.profileDigest,
+                maximumProfileAgeMs: config.maximumProfileAgeMs,
+                requirements: config.requirements,
+            }), config.logicalTimeMs);
+            return decisionDiagnostic(candidate.peerId, decision);
+        }
+        catch {
+            return unavailableMeshTrustDiagnostic(candidate.peerId, "profile_unavailable");
+        }
+    });
+    const unavailable = diagnostics.some((diagnostic) => diagnostic.disposition === "unavailable");
+    const matches = config.mode === "observe"
+        ? candidates
+        : unavailable
+            ? []
+            : candidates.filter((_, index) => diagnostics[index].disposition === "eligible");
+    return Object.freeze({
+        matches: Object.freeze([...matches]),
+        diagnostics: Object.freeze(diagnostics),
+        unavailable,
+    });
+}
+/** Encodes only the already-redacted projection; it never exports a profile or Fusion input. */
+export function encodeMeshTrustObservationV1(observation) {
+    const { schemaVersion: _schemaVersion, observerId: _observerId, observerKind: _observerKind, causationId: _causationId, scope, ...payload } = observation;
+    return Object.freeze({
+        type: "trust.observation",
+        ...payload,
+        subject: stripMeshSubject(observation.subject),
+        scope: stripMeshScope(scope),
+    });
+}
+function stripMeshSubject(subject) {
+    const { schemaVersion: _schemaVersion, ...wireSubject } = subject;
+    return Object.freeze(wireSubject);
+}
+function stripMeshScope(scope) {
+    if (scope.kind === "mesh")
+        return Object.freeze({ kind: "mesh" });
+    if (scope.kind === "objective")
+        return Object.freeze({
+            kind: "objective",
+            objectiveRevision: scope.objectiveRevision,
+        });
+    if (scope.kind === "work")
+        return Object.freeze({
+            kind: "work",
+            objectiveRevision: scope.objectiveRevision,
+            workItemId: scope.workItemId,
+            workItemRevision: scope.workItemRevision,
+            assignmentEpoch: scope.assignmentEpoch,
+            assignmentAuthorityId: scope.assignmentAuthorityId,
+            fencingToken: scope.fencingToken,
+        });
+    throw new TypeError("Trust observation scope is not Mesh-compatible");
+}
+//# sourceMappingURL=trust.js.map