@agentplat/mesh-protocol 0.3.0-alpha.1 → 0.3.0-alpha.2

package/dist/validation.js

@@ -6,6 +6,42 @@ const base64UrlPattern = /^[A-Za-z0-9_-]+$/;
 const rfc3339Pattern = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?(Z|([+-])(\d{2}):(\d{2}))$/;
 const base64UrlAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
 const maximumIssuePathLength = 256;
+const maximumDomainStringBytes = 4_096;
+const maximumProtocolVersions = 8;
+const maximumTransportHints = 8;
+const maximumTransportHintBytes = 2_048;
+const maximumTransportHintsBytes = 8_192;
+const maximumCapabilityIds = 32;
+const maximumMediaTypes = 16;
+const maximumMediaTypeBytes = 128;
+const maximumAttributes = 32;
+const maximumAttributeKeyBytes = 128;
+const maximumAttributeValueBytes = 1_024;
+const maximumAttributesBytes = 16_384;
+const maximumVersionBytes = 128;
+const maximumAdvertisementValidityMs = 24 * 60 * 60 * 1_000;
+const maximumObjectiveValidityMs = 30 * 24 * 60 * 60 * 1_000;
+const maximumObjectiveTextBytes = 4_096;
+const maximumSuccessCriteria = 32;
+const maximumSuccessCriteriaBytes = 16_384;
+const maximumPermittedCapabilityKeys = 32;
+const maximumRecoveryWitnesses = 32;
+const minimumRecoveryWitnesses = 3;
+const maximumAuthorizedObservers = 32;
+const maximumObjectiveWorkItems = 1_000_000;
+const maximumBidWindowMs = 60 * 60 * 1_000;
+const maximumAcceptanceWindowMs = 15 * 60 * 1_000;
+const maximumLeaseDurationMs = 24 * 60 * 60 * 1_000;
+const maximumRecoveryGraceMs = 60 * 60 * 1_000;
+const maximumLeaseRenewals = 100;
+const maximumWorkCapabilityKeys = 32;
+const maximumWorkTextBytes = 4_096;
+const maximumWorkListItems = 32;
+const maximumWorkListBytes = 16_384;
+const maximumCapacityReservationUnits = 1_000_000;
+const maximumWorkBidWindowMs = 60 * 60 * 1_000;
+const maximumWorkDeadlineMs = 30 * 24 * 60 * 60 * 1_000;
+const maximumWorkExecutionLifetimeMs = 5 * 60 * 1_000;
 const knownMessageTypes = new Set(MESH_MESSAGE_TYPES);
 const knownTopics = new Set(MESH_AUDIENCE_TOPICS);
 const utf8Encoder = new TextEncoder();
@@ -71,7 +107,7 @@ export function compareMeshTimestamps(left, right) {
     }
 }
 /**
- * Parses and statically validates one complete Alpha 1 envelope.
+ * Parses and statically validates one complete implemented Mesh envelope.
  * This stage does not verify the payload digest or proof.
  */
 export function parseSignedMeshEnvelope(input, options = {}) {
@@ -222,7 +258,7 @@ function validateEnvelope(input, limits) {
     if (!knownMessageTypes.has(type)) {
         fail('unsupported_message_type', '$["type"]');
     }
-    if (!isAlphaOneMessageType(type)) {
+    if (!isImplementedMessageType(type)) {
         fail('unsupported_message_type', '$["type"]');
     }
     const sender = validateSender(envelope.sender, limits);
@@ -251,7 +287,7 @@ function validateEnvelope(input, limits) {
     if (payload.type !== type) {
         fail('type_payload_mismatch', '$["payload"]["type"]');
     }
-    validateMessageSpecificEnvelope(type, audience, objectiveId, causationId);
+    validateMessageSpecificEnvelope(type, sender, audience, objectiveId, causationId, payload, sentAt, expiresAt);
     return {
         protocol: MESH_PROTOCOL,
         wireVersion: MESH_WIRE_VERSION,
@@ -310,6 +346,46 @@ function validatePayload(type, input, limits) {
         };
         return result;
     }
+    if (type === 'peer.card') {
+        const payload = assertClosedRecord(input, [
+            'capabilityIds',
+            'cardRevision',
+            'instanceId',
+            'peerCardId',
+            'protocolVersions',
+            'subjectPeerId',
+            'transportHints',
+            'type',
+            'validFrom',
+            'validUntil',
+        ], ['previousPeerCardId'], '$["payload"]', 'invalid_payload');
+        const peerCardId = assertIdentifier(payload.peerCardId, '$["payload"]["peerCardId"]', limits);
+        const cardRevision = assertPositiveSafeInteger(payload.cardRevision, '$["payload"]["cardRevision"]', 'invalid_payload');
+        const previousPeerCardId = payload.previousPeerCardId === undefined
+            ? undefined
+            : assertIdentifier(payload.previousPeerCardId, '$["payload"]["previousPeerCardId"]', limits);
+        validateRevisionPredecessor(cardRevision, previousPeerCardId, '$["payload"]["previousPeerCardId"]');
+        if (previousPeerCardId === peerCardId) {
+            fail('invalid_payload', '$["payload"]["previousPeerCardId"]');
+        }
+        const validFrom = assertRfc3339PayloadTimestamp(payload.validFrom, '$["payload"]["validFrom"]');
+        const validUntil = assertRfc3339PayloadTimestamp(payload.validUntil, '$["payload"]["validUntil"]');
+        assertBoundedValidity(validFrom.instant, validUntil.instant);
+        const result = {
+            type: assertPayloadType(payload.type, type),
+            peerCardId,
+            cardRevision,
+            subjectPeerId: assertIdentifier(payload.subjectPeerId, '$["payload"]["subjectPeerId"]', limits),
+            instanceId: assertIdentifier(payload.instanceId, '$["payload"]["instanceId"]', limits),
+            protocolVersions: validateProtocolVersions(payload.protocolVersions),
+            transportHints: validateBoundedStringArray(payload.transportHints, '$["payload"]["transportHints"]', maximumTransportHints, maximumTransportHintBytes, maximumTransportHintsBytes, true),
+            capabilityIds: validateIdentifierArray(payload.capabilityIds, '$["payload"]["capabilityIds"]', maximumCapabilityIds, limits),
+            validFrom: validFrom.text,
+            validUntil: validUntil.text,
+            ...(previousPeerCardId === undefined ? {} : { previousPeerCardId }),
+        };
+        return result;
+    }
     if (type === 'peer.ping') {
         const payload = assertClosedRecord(input, ['type'], [], '$["payload"]', 'invalid_payload');
         const result = {
@@ -317,11 +393,1040 @@ function validatePayload(type, input, limits) {
         };
         return result;
     }
-    const payload = assertClosedRecord(input, ['type'], [], '$["payload"]', 'invalid_payload');
-    const result = {
-        type: assertPayloadType(payload.type, 'peer.ping_ack'),
+    if (type === 'peer.ping_ack') {
+        const payload = assertClosedRecord(input, ['type'], [], '$["payload"]', 'invalid_payload');
+        const result = {
+            type: assertPayloadType(payload.type, type),
+        };
+        return result;
+    }
+    if (type === 'peer.goodbye') {
+        const payload = assertClosedRecord(input, ['cardRevision', 'instanceId', 'peerCardId', 'type'], [], '$["payload"]', 'invalid_payload');
+        const result = {
+            type: assertPayloadType(payload.type, type),
+            peerCardId: assertIdentifier(payload.peerCardId, '$["payload"]["peerCardId"]', limits),
+            cardRevision: assertPositiveSafeInteger(payload.cardRevision, '$["payload"]["cardRevision"]', 'invalid_payload'),
+            instanceId: assertIdentifier(payload.instanceId, '$["payload"]["instanceId"]', limits),
+        };
+        return result;
+    }
+    if (type === 'capability.advertise') {
+        const payload = assertClosedRecord(input, [
+            'advertisementId',
+            'attributes',
+            'capabilityId',
+            'capabilityKey',
+            'capabilityRevision',
+            'inputMediaTypes',
+            'outputMediaTypes',
+            'ownerPeerId',
+            'type',
+            'validFrom',
+            'validUntil',
+            'version',
+        ], [
+            'maximumConcurrency',
+            'maximumPayloadBytes',
+            'previousAdvertisementId',
+            'variant',
+        ], '$["payload"]', 'invalid_payload');
+        const advertisementId = assertIdentifier(payload.advertisementId, '$["payload"]["advertisementId"]', limits);
+        const capabilityRevision = assertPositiveSafeInteger(payload.capabilityRevision, '$["payload"]["capabilityRevision"]', 'invalid_payload');
+        const previousAdvertisementId = payload.previousAdvertisementId === undefined
+            ? undefined
+            : assertIdentifier(payload.previousAdvertisementId, '$["payload"]["previousAdvertisementId"]', limits);
+        validateRevisionPredecessor(capabilityRevision, previousAdvertisementId, '$["payload"]["previousAdvertisementId"]');
+        if (previousAdvertisementId === advertisementId) {
+            fail('invalid_payload', '$["payload"]["previousAdvertisementId"]');
+        }
+        const validFrom = assertRfc3339PayloadTimestamp(payload.validFrom, '$["payload"]["validFrom"]');
+        const validUntil = assertRfc3339PayloadTimestamp(payload.validUntil, '$["payload"]["validUntil"]');
+        assertBoundedValidity(validFrom.instant, validUntil.instant);
+        const result = {
+            type: assertPayloadType(payload.type, type),
+            advertisementId,
+            capabilityId: assertIdentifier(payload.capabilityId, '$["payload"]["capabilityId"]', limits),
+            capabilityRevision,
+            ownerPeerId: assertIdentifier(payload.ownerPeerId, '$["payload"]["ownerPeerId"]', limits),
+            capabilityKey: assertBoundedString(payload.capabilityKey, '$["payload"]["capabilityKey"]', maximumDomainStringBytes),
+            version: assertBoundedString(payload.version, '$["payload"]["version"]', maximumVersionBytes),
+            ...(payload.variant === undefined
+                ? {}
+                : {
+                    variant: assertBoundedString(payload.variant, '$["payload"]["variant"]', maximumVersionBytes),
+                }),
+            inputMediaTypes: validateBoundedStringArray(payload.inputMediaTypes, '$["payload"]["inputMediaTypes"]', maximumMediaTypes, maximumMediaTypeBytes, undefined, true),
+            outputMediaTypes: validateBoundedStringArray(payload.outputMediaTypes, '$["payload"]["outputMediaTypes"]', maximumMediaTypes, maximumMediaTypeBytes, undefined, true),
+            attributes: validateAttributes(payload.attributes),
+            validFrom: validFrom.text,
+            validUntil: validUntil.text,
+            ...(payload.maximumConcurrency === undefined
+                ? {}
+                : {
+                    maximumConcurrency: assertPositiveSafeInteger(payload.maximumConcurrency, '$["payload"]["maximumConcurrency"]', 'invalid_payload'),
+                }),
+            ...(payload.maximumPayloadBytes === undefined
+                ? {}
+                : {
+                    maximumPayloadBytes: assertPositiveSafeInteger(payload.maximumPayloadBytes, '$["payload"]["maximumPayloadBytes"]', 'invalid_payload'),
+                }),
+            ...(previousAdvertisementId === undefined
+                ? {}
+                : { previousAdvertisementId }),
+        };
+        return result;
+    }
+    if (type === 'capability.withdraw') {
+        const payload = assertClosedRecord(input, ['advertisementId', 'capabilityId', 'capabilityRevision', 'type'], [], '$["payload"]', 'invalid_payload');
+        const result = {
+            type: assertPayloadType(payload.type, type),
+            capabilityId: assertIdentifier(payload.capabilityId, '$["payload"]["capabilityId"]', limits),
+            capabilityRevision: assertPositiveSafeInteger(payload.capabilityRevision, '$["payload"]["capabilityRevision"]', 'invalid_payload'),
+            advertisementId: assertIdentifier(payload.advertisementId, '$["payload"]["advertisementId"]', limits),
+        };
+        return result;
+    }
+    if (type === 'objective.announce') {
+        const document = validateObjectiveDocument(input, type, limits);
+        if (document.objectiveRevision !== 1) {
+            fail('invalid_payload', '$["payload"]["objectiveRevision"]');
+        }
+        const result = {
+            type,
+            ...document,
+        };
+        return result;
+    }
+    if (type === 'objective.revise') {
+        const document = validateObjectiveDocument(input, type, limits);
+        if (document.objectiveRevision < 2) {
+            fail('invalid_payload', '$["payload"]["objectiveRevision"]');
+        }
+        const payload = input;
+        const previousObjectiveDocumentId = assertIdentifier(payload.previousObjectiveDocumentId, '$["payload"]["previousObjectiveDocumentId"]', limits);
+        if (previousObjectiveDocumentId === document.objectiveDocumentId) {
+            fail('invalid_payload', '$["payload"]["previousObjectiveDocumentId"]');
+        }
+        const result = {
+            type,
+            ...document,
+            previousObjectiveDocumentId,
+        };
+        return result;
+    }
+    if (type === 'objective.cancel') {
+        const payload = assertClosedRecord(input, [
+            'cancellationId',
+            'objectiveDocumentId',
+            'objectiveId',
+            'objectiveRevision',
+            'type',
+        ], [], '$["payload"]', 'invalid_payload');
+        const result = {
+            type: assertPayloadType(payload.type, type),
+            cancellationId: assertIdentifier(payload.cancellationId, '$["payload"]["cancellationId"]', limits),
+            objectiveId: assertIdentifier(payload.objectiveId, '$["payload"]["objectiveId"]', limits),
+            objectiveRevision: assertPositiveSafeInteger(payload.objectiveRevision, '$["payload"]["objectiveRevision"]', 'invalid_payload'),
+            objectiveDocumentId: assertIdentifier(payload.objectiveDocumentId, '$["payload"]["objectiveDocumentId"]', limits),
+        };
+        return result;
+    }
+    if (type === 'work.offer') {
+        return validateWorkOffer(input, limits);
+    }
+    if (type === 'work.bid') {
+        return validateWorkBid(input, limits);
+    }
+    if (type === 'work.award') {
+        return validateWorkAward(input, limits);
+    }
+    if (type === 'work.accept') {
+        return validateWorkAccept(input, limits);
+    }
+    if (type === 'work.decline') {
+        return validateWorkDecline(input, limits);
+    }
+    if (type === 'work.progress') {
+        return validateWorkProgress(input, limits);
+    }
+    if (type === 'work.checkpoint') {
+        return validateWorkCheckpoint(input, limits);
+    }
+    if (type === 'work.result') {
+        return validateWorkResult(input, limits);
+    }
+    if (type === 'work.release') {
+        return validateWorkRelease(input, limits);
+    }
+    if (type === 'work.cancel') {
+        return validateWorkCancel(input, limits);
+    }
+    if (type === 'lease.renew') {
+        return validateLeaseRenew(input, limits);
+    }
+    if (type === 'lease.takeover_proposal') {
+        return validateLeaseTakeoverProposal(input, limits);
+    }
+    if (type === 'lease.vote') {
+        return validateLeaseVote(input, limits);
+    }
+    if (type === 'lease.certificate') {
+        return validateLeaseCertificate(input, limits);
+    }
+    return fail('unsupported_message_type', '$["type"]');
+}
+function validateWorkOffer(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'bidDeadline',
+        'budgetReservationUnits',
+        'completionCriteria',
+        'matchingAttributes',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'offerAttempt',
+        'offerId',
+        'ownerEpoch',
+        'ownerPeerId',
+        'requiredCapabilityKeys',
+        'type',
+        'workDeadline',
+        'workItemId',
+        'workItemRevision',
+    ], ['inputReference', 'inputSummary', 'previousOfferId'], '$["payload"]', 'invalid_payload');
+    assertPayloadType(payload.type, 'work.offer');
+    const hasInputSummary = payload.inputSummary !== undefined;
+    const hasInputReference = payload.inputReference !== undefined;
+    if (hasInputSummary === hasInputReference) {
+        fail('invalid_payload', '$["payload"]');
+    }
+    const inputSummary = hasInputSummary
+        ? assertBoundedString(payload.inputSummary, '$["payload"]["inputSummary"]', maximumWorkTextBytes)
+        : undefined;
+    const inputReference = hasInputReference
+        ? assertBoundedString(payload.inputReference, '$["payload"]["inputReference"]', maximumWorkTextBytes)
+        : undefined;
+    const offerId = assertIdentifier(payload.offerId, '$["payload"]["offerId"]', limits);
+    const offerAttempt = assertPositiveSafeInteger(payload.offerAttempt, '$["payload"]["offerAttempt"]', 'invalid_payload');
+    const previousOfferId = payload.previousOfferId === undefined
+        ? undefined
+        : assertIdentifier(payload.previousOfferId, '$["payload"]["previousOfferId"]', limits);
+    validateRevisionPredecessor(offerAttempt, previousOfferId, '$["payload"]["previousOfferId"]');
+    if (previousOfferId === offerId) {
+        fail('invalid_payload', '$["payload"]["previousOfferId"]');
+    }
+    const requiredCapabilityKeys = validateBoundedStringArray(payload.requiredCapabilityKeys, '$["payload"]["requiredCapabilityKeys"]', maximumWorkCapabilityKeys, maximumWorkTextBytes, undefined, true);
+    if (requiredCapabilityKeys.length === 0) {
+        fail('invalid_payload', '$["payload"]["requiredCapabilityKeys"]');
+    }
+    const completionCriteria = validateBoundedStringArray(payload.completionCriteria, '$["payload"]["completionCriteria"]', maximumWorkListItems, maximumWorkTextBytes, maximumWorkListBytes);
+    if (completionCriteria.length === 0) {
+        fail('invalid_payload', '$["payload"]["completionCriteria"]');
+    }
+    const ownerEpoch = assertPositiveSafeInteger(payload.ownerEpoch, '$["payload"]["ownerEpoch"]', 'invalid_payload');
+    if (ownerEpoch !== 1) {
+        fail('invalid_payload', '$["payload"]["ownerEpoch"]');
+    }
+    const bidDeadline = assertRfc3339PayloadTimestamp(payload.bidDeadline, '$["payload"]["bidDeadline"]').text;
+    const workDeadline = assertRfc3339PayloadTimestamp(payload.workDeadline, '$["payload"]["workDeadline"]').text;
+    const fields = {
+        offerId,
+        objectiveId: assertIdentifier(payload.objectiveId, '$["payload"]["objectiveId"]', limits),
+        objectiveDocumentId: assertIdentifier(payload.objectiveDocumentId, '$["payload"]["objectiveDocumentId"]', limits),
+        objectiveRevision: assertPositiveSafeInteger(payload.objectiveRevision, '$["payload"]["objectiveRevision"]', 'invalid_payload'),
+        workItemId: assertIdentifier(payload.workItemId, '$["payload"]["workItemId"]', limits),
+        workItemRevision: assertPositiveSafeInteger(payload.workItemRevision, '$["payload"]["workItemRevision"]', 'invalid_payload'),
+        ownerPeerId: assertIdentifier(payload.ownerPeerId, '$["payload"]["ownerPeerId"]', limits),
+        ownerEpoch,
+        offerAttempt,
+        ...(previousOfferId === undefined ? {} : { previousOfferId }),
+        requiredCapabilityKeys,
+        matchingAttributes: validateAttributes(payload.matchingAttributes, '$["payload"]["matchingAttributes"]'),
+        completionCriteria,
+        budgetReservationUnits: assertNonnegativeSafeInteger(payload.budgetReservationUnits, '$["payload"]["budgetReservationUnits"]'),
+        bidDeadline,
+        workDeadline,
     };
-    return result;
+    if (inputSummary !== undefined) {
+        const offerInput = { inputSummary };
+        return { type: 'work.offer', ...fields, ...offerInput };
+    }
+    if (inputReference === undefined) {
+        return fail('invalid_payload', '$["payload"]');
+    }
+    const offerInput = { inputReference };
+    return { type: 'work.offer', ...fields, ...offerInput };
+}
+function validateWorkBid(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'advertisementId',
+        'assumptions',
+        'bidDeadline',
+        'bidExpiresAt',
+        'bidId',
+        'bidRevision',
+        'bidderPeerId',
+        'budgetUnits',
+        'capabilityId',
+        'capabilityRevision',
+        'capacityReservationUnits',
+        'expectedCompletionAt',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'offerAttempt',
+        'offerId',
+        'ownerEpoch',
+        'ownerPeerId',
+        'type',
+        'workDeadline',
+        'workItemId',
+        'workItemRevision',
+    ], ['previousBidId'], '$["payload"]', 'invalid_payload');
+    const bidId = assertIdentifier(payload.bidId, '$["payload"]["bidId"]', limits);
+    const bidRevision = assertPositiveSafeInteger(payload.bidRevision, '$["payload"]["bidRevision"]', 'invalid_payload');
+    const previousBidId = payload.previousBidId === undefined
+        ? undefined
+        : assertIdentifier(payload.previousBidId, '$["payload"]["previousBidId"]', limits);
+    validateRevisionPredecessor(bidRevision, previousBidId, '$["payload"]["previousBidId"]');
+    if (previousBidId === bidId) {
+        fail('invalid_payload', '$["payload"]["previousBidId"]');
+    }
+    const ownerEpoch = assertPositiveSafeInteger(payload.ownerEpoch, '$["payload"]["ownerEpoch"]', 'invalid_payload');
+    if (ownerEpoch !== 1) {
+        fail('invalid_payload', '$["payload"]["ownerEpoch"]');
+    }
+    return {
+        type: assertPayloadType(payload.type, 'work.bid'),
+        bidId,
+        bidRevision,
+        ...(previousBidId === undefined ? {} : { previousBidId }),
+        offerId: assertIdentifier(payload.offerId, '$["payload"]["offerId"]', limits),
+        objectiveId: assertIdentifier(payload.objectiveId, '$["payload"]["objectiveId"]', limits),
+        objectiveDocumentId: assertIdentifier(payload.objectiveDocumentId, '$["payload"]["objectiveDocumentId"]', limits),
+        objectiveRevision: assertPositiveSafeInteger(payload.objectiveRevision, '$["payload"]["objectiveRevision"]', 'invalid_payload'),
+        workItemId: assertIdentifier(payload.workItemId, '$["payload"]["workItemId"]', limits),
+        workItemRevision: assertPositiveSafeInteger(payload.workItemRevision, '$["payload"]["workItemRevision"]', 'invalid_payload'),
+        ownerPeerId: assertIdentifier(payload.ownerPeerId, '$["payload"]["ownerPeerId"]', limits),
+        ownerEpoch,
+        offerAttempt: assertPositiveSafeInteger(payload.offerAttempt, '$["payload"]["offerAttempt"]', 'invalid_payload'),
+        bidderPeerId: assertIdentifier(payload.bidderPeerId, '$["payload"]["bidderPeerId"]', limits),
+        advertisementId: assertIdentifier(payload.advertisementId, '$["payload"]["advertisementId"]', limits),
+        capabilityId: assertIdentifier(payload.capabilityId, '$["payload"]["capabilityId"]', limits),
+        capabilityRevision: assertPositiveSafeInteger(payload.capabilityRevision, '$["payload"]["capabilityRevision"]', 'invalid_payload'),
+        capacityReservationUnits: assertBoundedPositiveSafeInteger(payload.capacityReservationUnits, '$["payload"]["capacityReservationUnits"]', maximumCapacityReservationUnits),
+        budgetUnits: assertNonnegativeSafeInteger(payload.budgetUnits, '$["payload"]["budgetUnits"]'),
+        bidDeadline: assertRfc3339PayloadTimestamp(payload.bidDeadline, '$["payload"]["bidDeadline"]').text,
+        workDeadline: assertRfc3339PayloadTimestamp(payload.workDeadline, '$["payload"]["workDeadline"]').text,
+        expectedCompletionAt: assertRfc3339PayloadTimestamp(payload.expectedCompletionAt, '$["payload"]["expectedCompletionAt"]').text,
+        bidExpiresAt: assertRfc3339PayloadTimestamp(payload.bidExpiresAt, '$["payload"]["bidExpiresAt"]').text,
+        assumptions: validateBoundedStringArray(payload.assumptions, '$["payload"]["assumptions"]', maximumWorkListItems, maximumWorkTextBytes, maximumWorkListBytes),
+    };
+}
+function validateWorkAward(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'acceptanceDeadline',
+        'assigneePeerId',
+        'assignmentAuthorityId',
+        'assignmentEpoch',
+        'authorityKind',
+        'awardId',
+        'bidId',
+        'bidRevision',
+        'budgetReservationUnits',
+        'fencingToken',
+        'leaseExpiresAt',
+        'leaseStartsAt',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'offerAttempt',
+        'offerId',
+        'ownerEpoch',
+        'ownerPeerId',
+        'type',
+        'workDeadline',
+        'workItemId',
+        'workItemRevision',
+    ], ['recoveryCertificateId', 'resumeCheckpointId'], '$["payload"]', 'invalid_payload');
+    assertPayloadType(payload.type, 'work.award');
+    const authorityKind = assertString(payload.authorityKind, '$["payload"]["authorityKind"]', 'invalid_payload');
+    if (authorityKind !== 'award' && authorityKind !== 'recovery_certificate') {
+        fail('invalid_payload', '$["payload"]["authorityKind"]');
+    }
+    const awardId = assertIdentifier(payload.awardId, '$["payload"]["awardId"]', limits);
+    const assignmentEpoch = assertPositiveSafeInteger(payload.assignmentEpoch, '$["payload"]["assignmentEpoch"]', 'invalid_payload');
+    const assignmentAuthorityId = assertIdentifier(payload.assignmentAuthorityId, '$["payload"]["assignmentAuthorityId"]', limits);
+    const fencingToken = assertIdentifier(payload.fencingToken, '$["payload"]["fencingToken"]', limits);
+    if (assignmentAuthorityId !== fencingToken) {
+        fail('invalid_payload', '$["payload"]["fencingToken"]');
+    }
+    const ownerEpoch = assertPositiveSafeInteger(payload.ownerEpoch, '$["payload"]["ownerEpoch"]', 'invalid_payload');
+    if (ownerEpoch !== 1) {
+        fail('invalid_payload', '$["payload"]["ownerEpoch"]');
+    }
+    const fields = {
+        type: 'work.award',
+        awardId,
+        offerId: assertIdentifier(payload.offerId, '$["payload"]["offerId"]', limits),
+        bidId: assertIdentifier(payload.bidId, '$["payload"]["bidId"]', limits),
+        bidRevision: assertPositiveSafeInteger(payload.bidRevision, '$["payload"]["bidRevision"]', 'invalid_payload'),
+        objectiveId: assertIdentifier(payload.objectiveId, '$["payload"]["objectiveId"]', limits),
+        objectiveDocumentId: assertIdentifier(payload.objectiveDocumentId, '$["payload"]["objectiveDocumentId"]', limits),
+        objectiveRevision: assertPositiveSafeInteger(payload.objectiveRevision, '$["payload"]["objectiveRevision"]', 'invalid_payload'),
+        workItemId: assertIdentifier(payload.workItemId, '$["payload"]["workItemId"]', limits),
+        workItemRevision: assertPositiveSafeInteger(payload.workItemRevision, '$["payload"]["workItemRevision"]', 'invalid_payload'),
+        ownerPeerId: assertIdentifier(payload.ownerPeerId, '$["payload"]["ownerPeerId"]', limits),
+        ownerEpoch,
+        offerAttempt: assertPositiveSafeInteger(payload.offerAttempt, '$["payload"]["offerAttempt"]', 'invalid_payload'),
+        assigneePeerId: assertIdentifier(payload.assigneePeerId, '$["payload"]["assigneePeerId"]', limits),
+        assignmentEpoch,
+        assignmentAuthorityId,
+        fencingToken,
+        budgetReservationUnits: assertNonnegativeSafeInteger(payload.budgetReservationUnits, '$["payload"]["budgetReservationUnits"]'),
+        workDeadline: assertRfc3339PayloadTimestamp(payload.workDeadline, '$["payload"]["workDeadline"]').text,
+        leaseStartsAt: assertRfc3339PayloadTimestamp(payload.leaseStartsAt, '$["payload"]["leaseStartsAt"]').text,
+        leaseExpiresAt: assertRfc3339PayloadTimestamp(payload.leaseExpiresAt, '$["payload"]["leaseExpiresAt"]').text,
+        acceptanceDeadline: assertRfc3339PayloadTimestamp(payload.acceptanceDeadline, '$["payload"]["acceptanceDeadline"]').text,
+    };
+    if (authorityKind === 'award') {
+        if (payload.recoveryCertificateId !== undefined ||
+            payload.resumeCheckpointId !== undefined) {
+            fail('invalid_payload', '$["payload"]');
+        }
+        if (assignmentAuthorityId !== awardId) {
+            fail('invalid_payload', '$["payload"]["assignmentAuthorityId"]');
+        }
+        return { ...fields, authorityKind };
+    }
+    if (assignmentEpoch < 2) {
+        fail('invalid_payload', '$["payload"]["assignmentEpoch"]');
+    }
+    const recoveryCertificateId = assertIdentifier(payload.recoveryCertificateId, '$["payload"]["recoveryCertificateId"]', limits);
+    if (assignmentAuthorityId !== recoveryCertificateId) {
+        fail('invalid_payload', '$["payload"]["assignmentAuthorityId"]');
+    }
+    const resumeCheckpointId = payload.resumeCheckpointId === undefined
+        ? undefined
+        : assertIdentifier(payload.resumeCheckpointId, '$["payload"]["resumeCheckpointId"]', limits);
+    return {
+        ...fields,
+        authorityKind,
+        recoveryCertificateId,
+        ...(resumeCheckpointId === undefined ? {} : { resumeCheckpointId }),
+    };
+}
+function validateWorkAccept(input, limits) {
+    const payload = validateWorkAssignmentResponse(input, 'work.accept', 'acceptanceId', limits);
+    return {
+        type: 'work.accept',
+        acceptanceId: payload.responseId,
+        ...payload.fields,
+    };
+}
+function validateWorkDecline(input, limits) {
+    const payload = validateWorkAssignmentResponse(input, 'work.decline', 'declineId', limits);
+    return {
+        type: 'work.decline',
+        declineId: payload.responseId,
+        ...payload.fields,
+    };
+}
+function validateWorkProgress(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'acceptanceId',
+        'assigneePeerId',
+        'assignmentAuthorityId',
+        'assignmentEpoch',
+        'awardId',
+        'fencingToken',
+        'leaseExpiresAt',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'ownerEpoch',
+        'ownerPeerId',
+        'progressId',
+        'progressSequence',
+        'progressSummary',
+        'type',
+        'workItemId',
+        'workItemRevision',
+    ], ['checkpointId'], '$["payload"]', 'invalid_payload');
+    assertPayloadType(payload.type, 'work.progress');
+    const checkpointId = payload.checkpointId === undefined
+        ? undefined
+        : assertIdentifier(payload.checkpointId, '$["payload"]["checkpointId"]', limits);
+    return {
+        type: 'work.progress',
+        ...validateWorkExecutionAuthorityFields(payload, limits),
+        progressId: assertIdentifier(payload.progressId, '$["payload"]["progressId"]', limits),
+        progressSequence: assertPositiveSafeInteger(payload.progressSequence, '$["payload"]["progressSequence"]', 'invalid_payload'),
+        progressSummary: assertBoundedString(payload.progressSummary, '$["payload"]["progressSummary"]', maximumWorkTextBytes),
+        ...(checkpointId === undefined ? {} : { checkpointId }),
+    };
+}
+function validateWorkCheckpoint(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'acceptanceId',
+        'assigneePeerId',
+        'assignmentAuthorityId',
+        'assignmentEpoch',
+        'awardId',
+        'checkpointDigest',
+        'checkpointId',
+        'checkpointSequence',
+        'fencingToken',
+        'leaseExpiresAt',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'ownerEpoch',
+        'ownerPeerId',
+        'type',
+        'workItemId',
+        'workItemRevision',
+    ], ['checkpointReference', 'checkpointSummary', 'previousCheckpointId'], '$["payload"]', 'invalid_payload');
+    assertPayloadType(payload.type, 'work.checkpoint');
+    const checkpointId = assertIdentifier(payload.checkpointId, '$["payload"]["checkpointId"]', limits);
+    const checkpointSequence = assertPositiveSafeInteger(payload.checkpointSequence, '$["payload"]["checkpointSequence"]', 'invalid_payload');
+    const previousCheckpointId = payload.previousCheckpointId === undefined
+        ? undefined
+        : assertIdentifier(payload.previousCheckpointId, '$["payload"]["previousCheckpointId"]', limits);
+    validateRevisionPredecessor(checkpointSequence, previousCheckpointId, '$["payload"]["previousCheckpointId"]');
+    if (previousCheckpointId === checkpointId) {
+        fail('invalid_payload', '$["payload"]["previousCheckpointId"]');
+    }
+    return {
+        type: 'work.checkpoint',
+        ...validateWorkExecutionAuthorityFields(payload, limits),
+        ...validateWorkCheckpointContent(payload, limits),
+        checkpointId,
+        checkpointSequence,
+        ...(previousCheckpointId === undefined ? {} : { previousCheckpointId }),
+        checkpointDigest: assertContentDigest(payload.checkpointDigest, '$["payload"]["checkpointDigest"]'),
+    };
+}
+function validateWorkResult(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'acceptanceId',
+        'assigneePeerId',
+        'assignmentAuthorityId',
+        'assignmentEpoch',
+        'awardId',
+        'fencingToken',
+        'leaseExpiresAt',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'ownerEpoch',
+        'ownerPeerId',
+        'resultDigest',
+        'resultId',
+        'type',
+        'workItemId',
+        'workItemRevision',
+    ], ['checkpointId', 'resultReference', 'resultSummary'], '$["payload"]', 'invalid_payload');
+    assertPayloadType(payload.type, 'work.result');
+    const checkpointId = payload.checkpointId === undefined
+        ? undefined
+        : assertIdentifier(payload.checkpointId, '$["payload"]["checkpointId"]', limits);
+    return {
+        type: 'work.result',
+        ...validateWorkExecutionAuthorityFields(payload, limits),
+        ...validateWorkResultContent(payload, limits),
+        resultId: assertIdentifier(payload.resultId, '$["payload"]["resultId"]', limits),
+        resultDigest: assertContentDigest(payload.resultDigest, '$["payload"]["resultDigest"]'),
+        ...(checkpointId === undefined ? {} : { checkpointId }),
+    };
+}
+function validateWorkRelease(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'acceptanceId',
+        'assigneePeerId',
+        'assignmentAuthorityId',
+        'assignmentEpoch',
+        'awardId',
+        'fencingToken',
+        'leaseExpiresAt',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'ownerEpoch',
+        'ownerPeerId',
+        'releaseAuthority',
+        'releaseDisposition',
+        'releaseId',
+        'type',
+        'workItemId',
+        'workItemRevision',
+    ], [], '$["payload"]', 'invalid_payload');
+    assertPayloadType(payload.type, 'work.release');
+    const releaseAuthority = assertString(payload.releaseAuthority, '$["payload"]["releaseAuthority"]', 'invalid_payload');
+    if (releaseAuthority !== 'owner' && releaseAuthority !== 'assignee') {
+        fail('invalid_payload', '$["payload"]["releaseAuthority"]');
+    }
+    const releaseDisposition = assertString(payload.releaseDisposition, '$["payload"]["releaseDisposition"]', 'invalid_payload');
+    if (releaseDisposition !== 'reoffer' && releaseDisposition !== 'close') {
+        fail('invalid_payload', '$["payload"]["releaseDisposition"]');
+    }
+    return {
+        type: 'work.release',
+        ...validateWorkExecutionAuthorityFields(payload, limits),
+        releaseId: assertIdentifier(payload.releaseId, '$["payload"]["releaseId"]', limits),
+        releaseAuthority,
+        releaseDisposition,
+    };
+}
+function validateWorkCancel(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'assigneePeerId',
+        'assignmentAuthorityId',
+        'assignmentEpoch',
+        'assignmentState',
+        'awardId',
+        'cancellationId',
+        'fencingToken',
+        'leaseExpiresAt',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'ownerEpoch',
+        'ownerPeerId',
+        'type',
+        'workItemId',
+        'workItemRevision',
+    ], ['acceptanceId'], '$["payload"]', 'invalid_payload');
+    assertPayloadType(payload.type, 'work.cancel');
+    const fields = validateWorkAssignmentAuthorityFields(payload, limits);
+    const cancellationId = assertIdentifier(payload.cancellationId, '$["payload"]["cancellationId"]', limits);
+    const assignmentState = assertString(payload.assignmentState, '$["payload"]["assignmentState"]', 'invalid_payload');
+    if (assignmentState === 'award_pending') {
+        if (Object.hasOwn(payload, 'acceptanceId')) {
+            fail('invalid_payload', '$["payload"]["acceptanceId"]');
+        }
+        return {
+            type: 'work.cancel',
+            ...fields,
+            cancellationId,
+            assignmentState,
+        };
+    }
+    if (assignmentState === 'active') {
+        return {
+            type: 'work.cancel',
+            ...fields,
+            cancellationId,
+            assignmentState,
+            acceptanceId: assertIdentifier(payload.acceptanceId, '$["payload"]["acceptanceId"]', limits),
+        };
+    }
+    return fail('invalid_payload', '$["payload"]["assignmentState"]');
+}
+function validateLeaseRenew(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'acceptanceId',
+        'assigneePeerId',
+        'assignmentAuthorityId',
+        'assignmentEpoch',
+        'awardId',
+        'fencingToken',
+        'leaseExpiresAt',
+        'leaseRenewalId',
+        'leaseRenewalSequence',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'ownerEpoch',
+        'ownerPeerId',
+        'renewedLeaseExpiresAt',
+        'type',
+        'workItemId',
+        'workItemRevision',
+    ], ['previousLeaseRenewalId'], '$["payload"]', 'invalid_payload');
+    assertPayloadType(payload.type, 'lease.renew');
+    const fields = validateWorkExecutionAuthorityFields(payload, limits);
+    const leaseRenewalId = assertIdentifier(payload.leaseRenewalId, '$["payload"]["leaseRenewalId"]', limits);
+    const leaseRenewalSequence = assertPositiveSafeInteger(payload.leaseRenewalSequence, '$["payload"]["leaseRenewalSequence"]', 'invalid_payload');
+    if (leaseRenewalSequence > maximumLeaseRenewals) {
+        fail('invalid_payload', '$["payload"]["leaseRenewalSequence"]');
+    }
+    const previousLeaseRenewalId = payload.previousLeaseRenewalId === undefined
+        ? undefined
+        : assertIdentifier(payload.previousLeaseRenewalId, '$["payload"]["previousLeaseRenewalId"]', limits);
+    validateRevisionPredecessor(leaseRenewalSequence, previousLeaseRenewalId, '$["payload"]["previousLeaseRenewalId"]');
+    if (previousLeaseRenewalId === leaseRenewalId) {
+        fail('invalid_payload', '$["payload"]["previousLeaseRenewalId"]');
+    }
+    const renewedLeaseExpiresAt = assertRfc3339PayloadTimestamp(payload.renewedLeaseExpiresAt, '$["payload"]["renewedLeaseExpiresAt"]');
+    const currentLeaseExpiresAt = parseRfc3339(fields.leaseExpiresAt, '$["payload"]["leaseExpiresAt"]');
+    if (renewedLeaseExpiresAt.instant <= currentLeaseExpiresAt) {
+        fail('invalid_payload', '$["payload"]["renewedLeaseExpiresAt"]');
+    }
+    if (renewedLeaseExpiresAt.instant - currentLeaseExpiresAt >
+        BigInt(maximumLeaseDurationMs) * 1000000n) {
+        fail('invalid_payload', '$["payload"]["renewedLeaseExpiresAt"]');
+    }
+    return {
+        type: 'lease.renew',
+        ...fields,
+        leaseRenewalId,
+        leaseRenewalSequence,
+        ...(previousLeaseRenewalId === undefined ? {} : { previousLeaseRenewalId }),
+        renewedLeaseExpiresAt: renewedLeaseExpiresAt.text,
+    };
+}
+function validateLeaseTakeoverProposal(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'acceptanceId',
+        'assigneePeerId',
+        'assignmentAuthorityId',
+        'assignmentEpoch',
+        'awardId',
+        'fencingToken',
+        'leaseExpiresAt',
+        'leaseRenewalSequence',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'ownerEpoch',
+        'ownerPeerId',
+        'proposalAuthority',
+        'proposedAssigneePeerId',
+        'proposedAssignmentEpoch',
+        'proposerPeerId',
+        'takeoverProposalId',
+        'type',
+        'workItemId',
+        'workItemRevision',
+    ], ['candidateConsentProposalId', 'latestLeaseRenewalId'], '$["payload"]', 'invalid_payload');
+    assertPayloadType(payload.type, 'lease.takeover_proposal');
+    const fields = validateWorkExecutionAuthorityFields(payload, limits);
+    const takeoverProposalId = assertIdentifier(payload.takeoverProposalId, '$["payload"]["takeoverProposalId"]', limits);
+    const proposerPeerId = assertIdentifier(payload.proposerPeerId, '$["payload"]["proposerPeerId"]', limits);
+    const proposedAssigneePeerId = assertIdentifier(payload.proposedAssigneePeerId, '$["payload"]["proposedAssigneePeerId"]', limits);
+    if (proposedAssigneePeerId === fields.assigneePeerId) {
+        fail('invalid_payload', '$["payload"]["proposedAssigneePeerId"]');
+    }
+    const proposalAuthority = assertString(payload.proposalAuthority, '$["payload"]["proposalAuthority"]', 'invalid_payload');
+    if (proposalAuthority !== 'candidate' && proposalAuthority !== 'witness') {
+        fail('invalid_payload', '$["payload"]["proposalAuthority"]');
+    }
+    if (proposalAuthority === 'candidate' &&
+        proposerPeerId !== proposedAssigneePeerId) {
+        fail('invalid_payload', '$["payload"]["proposedAssigneePeerId"]');
+    }
+    if (proposalAuthority === 'witness' &&
+        proposerPeerId === proposedAssigneePeerId) {
+        fail('invalid_payload', '$["payload"]["proposalAuthority"]');
+    }
+    if (proposalAuthority === 'candidate' &&
+        Object.hasOwn(payload, 'candidateConsentProposalId')) {
+        fail('invalid_payload', '$["payload"]["candidateConsentProposalId"]');
+    }
+    const proposedAssignmentEpoch = assertPositiveSafeInteger(payload.proposedAssignmentEpoch, '$["payload"]["proposedAssignmentEpoch"]', 'invalid_payload');
+    if (proposedAssignmentEpoch !== fields.assignmentEpoch + 1) {
+        fail('invalid_payload', '$["payload"]["proposedAssignmentEpoch"]');
+    }
+    const leaseRenewalSequence = assertNonnegativeSafeInteger(payload.leaseRenewalSequence, '$["payload"]["leaseRenewalSequence"]');
+    if (leaseRenewalSequence > maximumLeaseRenewals) {
+        fail('invalid_payload', '$["payload"]["leaseRenewalSequence"]');
+    }
+    const latestLeaseRenewalId = leaseRenewalSequence === 0
+        ? undefined
+        : assertIdentifier(payload.latestLeaseRenewalId, '$["payload"]["latestLeaseRenewalId"]', limits);
+    if (leaseRenewalSequence === 0) {
+        if (Object.hasOwn(payload, 'latestLeaseRenewalId')) {
+            fail('invalid_payload', '$["payload"]["latestLeaseRenewalId"]');
+        }
+    }
+    const proposalFields = {
+        type: 'lease.takeover_proposal',
+        ...fields,
+        takeoverProposalId,
+        proposerPeerId,
+        proposedAssigneePeerId,
+        proposedAssignmentEpoch,
+        leaseRenewalSequence,
+        ...(latestLeaseRenewalId === undefined ? {} : { latestLeaseRenewalId }),
+    };
+    if (proposalAuthority === 'candidate') {
+        return {
+            ...proposalFields,
+            proposalAuthority,
+        };
+    }
+    return {
+        ...proposalFields,
+        proposalAuthority,
+        candidateConsentProposalId: assertIdentifier(payload.candidateConsentProposalId, '$["payload"]["candidateConsentProposalId"]', limits),
+    };
+}
+function validateLeaseVote(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'leaseVoteId',
+        'objectiveId',
+        'takeoverProposalId',
+        'type',
+        'witnessPeerId',
+    ], [], '$["payload"]', 'invalid_payload');
+    return {
+        type: assertPayloadType(payload.type, 'lease.vote'),
+        leaseVoteId: assertIdentifier(payload.leaseVoteId, '$["payload"]["leaseVoteId"]', limits),
+        takeoverProposalId: assertIdentifier(payload.takeoverProposalId, '$["payload"]["takeoverProposalId"]', limits),
+        witnessPeerId: assertIdentifier(payload.witnessPeerId, '$["payload"]["witnessPeerId"]', limits),
+        objectiveId: assertIdentifier(payload.objectiveId, '$["payload"]["objectiveId"]', limits),
+    };
+}
+function validateLeaseCertificate(input, limits) {
+    const payload = assertClosedRecord(input, [
+        'certificateAssemblerPeerId',
+        'certificateId',
+        'leaseVoteIds',
+        'objectiveId',
+        'takeoverProposalId',
+        'type',
+    ], [], '$["payload"]', 'invalid_payload');
+    const leaseVoteIds = validateIdentifierArray(payload.leaseVoteIds, '$["payload"]["leaseVoteIds"]', maximumRecoveryWitnesses, limits);
+    if (leaseVoteIds.length < 2) {
+        fail('invalid_payload', '$["payload"]["leaseVoteIds"]');
+    }
+    return {
+        type: assertPayloadType(payload.type, 'lease.certificate'),
+        certificateId: assertIdentifier(payload.certificateId, '$["payload"]["certificateId"]', limits),
+        certificateAssemblerPeerId: assertIdentifier(payload.certificateAssemblerPeerId, '$["payload"]["certificateAssemblerPeerId"]', limits),
+        takeoverProposalId: assertIdentifier(payload.takeoverProposalId, '$["payload"]["takeoverProposalId"]', limits),
+        leaseVoteIds,
+        objectiveId: assertIdentifier(payload.objectiveId, '$["payload"]["objectiveId"]', limits),
+    };
+}
+function validateWorkExecutionAuthorityFields(payload, limits) {
+    return {
+        ...validateWorkAssignmentAuthorityFields(payload, limits),
+        acceptanceId: assertIdentifier(payload.acceptanceId, '$["payload"]["acceptanceId"]', limits),
+    };
+}
+function validateWorkAssignmentAuthorityFields(payload, limits) {
+    const ownerEpoch = assertPositiveSafeInteger(payload.ownerEpoch, '$["payload"]["ownerEpoch"]', 'invalid_payload');
+    if (ownerEpoch !== 1) {
+        fail('invalid_payload', '$["payload"]["ownerEpoch"]');
+    }
+    const assignmentAuthorityId = assertIdentifier(payload.assignmentAuthorityId, '$["payload"]["assignmentAuthorityId"]', limits);
+    const fencingToken = assertIdentifier(payload.fencingToken, '$["payload"]["fencingToken"]', limits);
+    if (assignmentAuthorityId !== fencingToken) {
+        fail('invalid_payload', '$["payload"]["fencingToken"]');
+    }
+    return {
+        objectiveId: assertIdentifier(payload.objectiveId, '$["payload"]["objectiveId"]', limits),
+        objectiveDocumentId: assertIdentifier(payload.objectiveDocumentId, '$["payload"]["objectiveDocumentId"]', limits),
+        objectiveRevision: assertPositiveSafeInteger(payload.objectiveRevision, '$["payload"]["objectiveRevision"]', 'invalid_payload'),
+        workItemId: assertIdentifier(payload.workItemId, '$["payload"]["workItemId"]', limits),
+        workItemRevision: assertPositiveSafeInteger(payload.workItemRevision, '$["payload"]["workItemRevision"]', 'invalid_payload'),
+        ownerPeerId: assertIdentifier(payload.ownerPeerId, '$["payload"]["ownerPeerId"]', limits),
+        ownerEpoch,
+        assigneePeerId: assertIdentifier(payload.assigneePeerId, '$["payload"]["assigneePeerId"]', limits),
+        awardId: assertIdentifier(payload.awardId, '$["payload"]["awardId"]', limits),
+        assignmentEpoch: assertPositiveSafeInteger(payload.assignmentEpoch, '$["payload"]["assignmentEpoch"]', 'invalid_payload'),
+        assignmentAuthorityId,
+        fencingToken,
+        leaseExpiresAt: assertRfc3339PayloadTimestamp(payload.leaseExpiresAt, '$["payload"]["leaseExpiresAt"]').text,
+    };
+}
+function validateWorkCheckpointContent(payload, limits) {
+    const hasSummary = payload.checkpointSummary !== undefined;
+    const hasReference = payload.checkpointReference !== undefined;
+    if (hasSummary === hasReference) {
+        fail('invalid_payload', '$["payload"]');
+    }
+    if (hasSummary) {
+        return {
+            checkpointSummary: assertBoundedString(payload.checkpointSummary, '$["payload"]["checkpointSummary"]', maximumWorkTextBytes),
+        };
+    }
+    return {
+        checkpointReference: assertBoundedString(payload.checkpointReference, '$["payload"]["checkpointReference"]', maximumWorkTextBytes),
+    };
+}
+function validateWorkResultContent(payload, limits) {
+    const hasSummary = payload.resultSummary !== undefined;
+    const hasReference = payload.resultReference !== undefined;
+    if (hasSummary === hasReference) {
+        fail('invalid_payload', '$["payload"]');
+    }
+    if (hasSummary) {
+        return {
+            resultSummary: assertBoundedString(payload.resultSummary, '$["payload"]["resultSummary"]', maximumWorkTextBytes),
+        };
+    }
+    return {
+        resultReference: assertBoundedString(payload.resultReference, '$["payload"]["resultReference"]', maximumWorkTextBytes),
+    };
+}
+function validateWorkAssignmentResponse(input, type, responseIdKey, limits) {
+    const payload = assertClosedRecord(input, [
+        'acceptanceDeadline',
+        'assigneePeerId',
+        'assignmentAuthorityId',
+        'assignmentEpoch',
+        'awardId',
+        'fencingToken',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'ownerEpoch',
+        'ownerPeerId',
+        responseIdKey,
+        'type',
+        'workItemId',
+        'workItemRevision',
+    ], [], '$["payload"]', 'invalid_payload');
+    assertPayloadType(payload.type, type);
+    const assignmentAuthorityId = assertIdentifier(payload.assignmentAuthorityId, '$["payload"]["assignmentAuthorityId"]', limits);
+    const fencingToken = assertIdentifier(payload.fencingToken, '$["payload"]["fencingToken"]', limits);
+    if (assignmentAuthorityId !== fencingToken) {
+        fail('invalid_payload', '$["payload"]["fencingToken"]');
+    }
+    const ownerEpoch = assertPositiveSafeInteger(payload.ownerEpoch, '$["payload"]["ownerEpoch"]', 'invalid_payload');
+    if (ownerEpoch !== 1) {
+        fail('invalid_payload', '$["payload"]["ownerEpoch"]');
+    }
+    return {
+        responseId: assertIdentifier(payload[responseIdKey], `$["payload"]["${responseIdKey}"]`, limits),
+        fields: {
+            awardId: assertIdentifier(payload.awardId, '$["payload"]["awardId"]', limits),
+            objectiveId: assertIdentifier(payload.objectiveId, '$["payload"]["objectiveId"]', limits),
+            objectiveDocumentId: assertIdentifier(payload.objectiveDocumentId, '$["payload"]["objectiveDocumentId"]', limits),
+            objectiveRevision: assertPositiveSafeInteger(payload.objectiveRevision, '$["payload"]["objectiveRevision"]', 'invalid_payload'),
+            workItemId: assertIdentifier(payload.workItemId, '$["payload"]["workItemId"]', limits),
+            workItemRevision: assertPositiveSafeInteger(payload.workItemRevision, '$["payload"]["workItemRevision"]', 'invalid_payload'),
+            ownerPeerId: assertIdentifier(payload.ownerPeerId, '$["payload"]["ownerPeerId"]', limits),
+            ownerEpoch,
+            assigneePeerId: assertIdentifier(payload.assigneePeerId, '$["payload"]["assigneePeerId"]', limits),
+            assignmentEpoch: assertPositiveSafeInteger(payload.assignmentEpoch, '$["payload"]["assignmentEpoch"]', 'invalid_payload'),
+            assignmentAuthorityId,
+            fencingToken,
+            acceptanceDeadline: assertRfc3339PayloadTimestamp(payload.acceptanceDeadline, '$["payload"]["acceptanceDeadline"]').text,
+        },
+    };
+}
+function validateObjectiveDocument(input, type, limits) {
+    const requiredKeys = [
+        'acceptanceWindowMs',
+        'bidWindowMs',
+        'issuerPeerId',
+        'maximumBudgetUnits',
+        'maximumConcurrentAssignments',
+        'maximumLeaseDurationMs',
+        'maximumLeaseRenewals',
+        'maximumWorkItems',
+        'objectiveDocumentId',
+        'objectiveId',
+        'objectiveRevision',
+        'permittedCapabilityKeys',
+        'recoveryGraceMs',
+        'recoveryWitnessPeerIds',
+        'recoveryWitnessThreshold',
+        'successCriteria',
+        'type',
+        'validFrom',
+        'validUntil',
+    ];
+    if (type === 'objective.revise') {
+        requiredKeys.push('previousObjectiveDocumentId');
+    }
+    const payload = assertClosedRecord(input, requiredKeys, ['authorizedObserverPeerIds', 'contentReference', 'summary'], '$["payload"]', 'invalid_payload');
+    assertPayloadType(payload.type, type);
+    const hasSummary = payload.summary !== undefined;
+    const hasContentReference = payload.contentReference !== undefined;
+    if (hasSummary === hasContentReference) {
+        fail('invalid_payload', '$["payload"]');
+    }
+    const summary = hasSummary
+        ? assertBoundedString(payload.summary, '$["payload"]["summary"]', maximumObjectiveTextBytes)
+        : undefined;
+    const contentReference = hasContentReference
+        ? assertBoundedString(payload.contentReference, '$["payload"]["contentReference"]', maximumObjectiveTextBytes)
+        : undefined;
+    const successCriteria = validateBoundedStringArray(payload.successCriteria, '$["payload"]["successCriteria"]', maximumSuccessCriteria, maximumObjectiveTextBytes, maximumSuccessCriteriaBytes);
+    if (successCriteria.length === 0) {
+        fail('invalid_payload', '$["payload"]["successCriteria"]');
+    }
+    const permittedCapabilityKeys = validateBoundedStringArray(payload.permittedCapabilityKeys, '$["payload"]["permittedCapabilityKeys"]', maximumPermittedCapabilityKeys, maximumObjectiveTextBytes, undefined, true);
+    if (permittedCapabilityKeys.length === 0) {
+        fail('invalid_payload', '$["payload"]["permittedCapabilityKeys"]');
+    }
+    const recoveryWitnessPeerIds = validateIdentifierArray(payload.recoveryWitnessPeerIds, '$["payload"]["recoveryWitnessPeerIds"]', maximumRecoveryWitnesses, limits);
+    if (recoveryWitnessPeerIds.length < minimumRecoveryWitnesses) {
+        fail('invalid_payload', '$["payload"]["recoveryWitnessPeerIds"]');
+    }
+    const recoveryWitnessThreshold = assertPositiveSafeInteger(payload.recoveryWitnessThreshold, '$["payload"]["recoveryWitnessThreshold"]', 'invalid_payload');
+    if (recoveryWitnessThreshold > recoveryWitnessPeerIds.length ||
+        recoveryWitnessThreshold <= recoveryWitnessPeerIds.length / 2) {
+        fail('invalid_payload', '$["payload"]["recoveryWitnessThreshold"]');
+    }
+    const authorizedObserverPeerIds = payload.authorizedObserverPeerIds === undefined
+        ? undefined
+        : validateIdentifierArray(payload.authorizedObserverPeerIds, '$["payload"]["authorizedObserverPeerIds"]', maximumAuthorizedObservers, limits);
+    const maximumWorkItems = assertPositiveSafeInteger(payload.maximumWorkItems, '$["payload"]["maximumWorkItems"]', 'invalid_payload');
+    if (maximumWorkItems > maximumObjectiveWorkItems) {
+        fail('invalid_payload', '$["payload"]["maximumWorkItems"]');
+    }
+    const maximumConcurrentAssignments = assertPositiveSafeInteger(payload.maximumConcurrentAssignments, '$["payload"]["maximumConcurrentAssignments"]', 'invalid_payload');
+    if (maximumConcurrentAssignments > maximumWorkItems) {
+        fail('invalid_payload', '$["payload"]["maximumConcurrentAssignments"]');
+    }
+    const maximumBudgetUnits = assertNonnegativeSafeInteger(payload.maximumBudgetUnits, '$["payload"]["maximumBudgetUnits"]');
+    const bidWindowMs = assertBoundedPositiveSafeInteger(payload.bidWindowMs, '$["payload"]["bidWindowMs"]', maximumBidWindowMs);
+    const acceptanceWindowMs = assertBoundedPositiveSafeInteger(payload.acceptanceWindowMs, '$["payload"]["acceptanceWindowMs"]', maximumAcceptanceWindowMs);
+    const maximumLeaseDuration = assertBoundedPositiveSafeInteger(payload.maximumLeaseDurationMs, '$["payload"]["maximumLeaseDurationMs"]', maximumLeaseDurationMs);
+    const recoveryGraceMs = assertBoundedPositiveSafeInteger(payload.recoveryGraceMs, '$["payload"]["recoveryGraceMs"]', maximumRecoveryGraceMs);
+    const maximumLeaseRenewalsValue = assertNonnegativeSafeInteger(payload.maximumLeaseRenewals, '$["payload"]["maximumLeaseRenewals"]');
+    if (maximumLeaseRenewalsValue > maximumLeaseRenewals) {
+        fail('invalid_payload', '$["payload"]["maximumLeaseRenewals"]');
+    }
+    const validFrom = assertRfc3339PayloadTimestamp(payload.validFrom, '$["payload"]["validFrom"]');
+    const validUntil = assertRfc3339PayloadTimestamp(payload.validUntil, '$["payload"]["validUntil"]');
+    const validityDuration = assertObjectiveValidity(validFrom.instant, validUntil.instant);
+    for (const [path, timer] of [
+        ['$["payload"]["bidWindowMs"]', bidWindowMs],
+        ['$["payload"]["acceptanceWindowMs"]', acceptanceWindowMs],
+        ['$["payload"]["maximumLeaseDurationMs"]', maximumLeaseDuration],
+        ['$["payload"]["recoveryGraceMs"]', recoveryGraceMs],
+    ]) {
+        if (BigInt(timer) * 1000000n > validityDuration) {
+            fail('invalid_payload', path);
+        }
+    }
+    const fields = {
+        objectiveDocumentId: assertIdentifier(payload.objectiveDocumentId, '$["payload"]["objectiveDocumentId"]', limits),
+        objectiveId: assertIdentifier(payload.objectiveId, '$["payload"]["objectiveId"]', limits),
+        objectiveRevision: assertPositiveSafeInteger(payload.objectiveRevision, '$["payload"]["objectiveRevision"]', 'invalid_payload'),
+        issuerPeerId: assertIdentifier(payload.issuerPeerId, '$["payload"]["issuerPeerId"]', limits),
+        successCriteria,
+        permittedCapabilityKeys,
+        maximumWorkItems,
+        maximumConcurrentAssignments,
+        maximumBudgetUnits,
+        bidWindowMs,
+        acceptanceWindowMs,
+        maximumLeaseDurationMs: maximumLeaseDuration,
+        recoveryGraceMs,
+        maximumLeaseRenewals: maximumLeaseRenewalsValue,
+        recoveryWitnessPeerIds,
+        recoveryWitnessThreshold,
+        validFrom: validFrom.text,
+        validUntil: validUntil.text,
+        ...(authorizedObserverPeerIds === undefined
+            ? {}
+            : { authorizedObserverPeerIds }),
+    };
+    if (summary !== undefined) {
+        return { ...fields, summary };
+    }
+    if (contentReference === undefined) {
+        return fail('invalid_payload', '$["payload"]');
+    }
+    return { ...fields, contentReference };
 }
 function validateProof(input, limits) {
     const proof = assertClosedRecord(input, ['algorithm', 'keyId', 'value'], [], '$["proof"]', 'invalid_proof');
@@ -371,28 +1476,517 @@ function validateCriticalExtensions(input, extensions, limits) {
     }
     return result;
 }
-function validateMessageSpecificEnvelope(type, audience, objectiveId, causationId) {
-    if (type === 'peer.hello') {
+function validateMessageSpecificEnvelope(type, sender, audience, objectiveId, causationId, payload, sentAt, expiresAt) {
+    if (payload.type === 'peer.card') {
+        if (payload.subjectPeerId !== sender.peerId) {
+            fail('invalid_payload', '$["payload"]["subjectPeerId"]');
+        }
+        if (payload.instanceId !== sender.instanceId) {
+            fail('invalid_payload', '$["payload"]["instanceId"]');
+        }
+    }
+    else if (payload.type === 'peer.goodbye' &&
+        payload.instanceId !== sender.instanceId) {
+        fail('invalid_payload', '$["payload"]["instanceId"]');
+    }
+    else if (payload.type === 'capability.advertise' &&
+        payload.ownerPeerId !== sender.peerId) {
+        fail('invalid_payload', '$["payload"]["ownerPeerId"]');
+    }
+    else if ((payload.type === 'objective.announce' ||
+        payload.type === 'objective.revise') &&
+        payload.issuerPeerId !== sender.peerId) {
+        fail('invalid_payload', '$["payload"]["issuerPeerId"]');
+    }
+    else if (payload.type === 'work.offer' &&
+        payload.ownerPeerId !== sender.peerId) {
+        fail('invalid_payload', '$["payload"]["ownerPeerId"]');
+    }
+    else if (payload.type === 'work.bid' &&
+        payload.bidderPeerId !== sender.peerId) {
+        fail('invalid_payload', '$["payload"]["bidderPeerId"]');
+    }
+    else if (payload.type === 'work.award' &&
+        payload.ownerPeerId !== sender.peerId) {
+        fail('invalid_payload', '$["payload"]["ownerPeerId"]');
+    }
+    else if ((payload.type === 'work.accept' ||
+        payload.type === 'work.decline' ||
+        payload.type === 'work.progress' ||
+        payload.type === 'work.checkpoint' ||
+        payload.type === 'work.result' ||
+        payload.type === 'lease.renew') &&
+        payload.assigneePeerId !== sender.peerId) {
+        fail('invalid_payload', '$["payload"]["assigneePeerId"]');
+    }
+    else if (payload.type === 'work.release') {
+        if (payload.releaseAuthority === 'owner' &&
+            payload.ownerPeerId !== sender.peerId) {
+            fail('invalid_payload', '$["payload"]["ownerPeerId"]');
+        }
+        if (payload.releaseAuthority === 'assignee' &&
+            payload.assigneePeerId !== sender.peerId) {
+            fail('invalid_payload', '$["payload"]["assigneePeerId"]');
+        }
+    }
+    else if (payload.type === 'work.cancel' &&
+        payload.ownerPeerId !== sender.peerId) {
+        fail('invalid_payload', '$["payload"]["ownerPeerId"]');
+    }
+    else if (payload.type === 'lease.takeover_proposal' &&
+        payload.proposerPeerId !== sender.peerId) {
+        fail('invalid_payload', '$["payload"]["proposerPeerId"]');
+    }
+    else if (payload.type === 'lease.vote' &&
+        payload.witnessPeerId !== sender.peerId) {
+        fail('invalid_payload', '$["payload"]["witnessPeerId"]');
+    }
+    else if (payload.type === 'lease.certificate' &&
+        payload.certificateAssemblerPeerId !== sender.peerId) {
+        fail('invalid_payload', '$["payload"]["certificateAssemblerPeerId"]');
+    }
+    if (type === 'peer.hello' ||
+        type === 'peer.card' ||
+        type === 'peer.goodbye') {
         if (audience.kind === 'mesh' && audience.topic !== 'membership') {
             fail('invalid_audience', '$["audience"]["topic"]');
         }
-        return;
     }
-    if (audience.kind !== 'peer') {
+    else if (type === 'capability.advertise' ||
+        type === 'capability.withdraw') {
+        if (audience.kind === 'mesh' && audience.topic !== 'capability') {
+            fail('invalid_audience', '$["audience"]["topic"]');
+        }
+    }
+    else if (type === 'objective.announce' ||
+        type === 'objective.revise' ||
+        type === 'objective.cancel') {
+        if (audience.kind === 'mesh' && audience.topic !== 'objective') {
+            fail('invalid_audience', '$["audience"]["topic"]');
+        }
+    }
+    else if (type === 'work.offer') {
+        if (audience.kind === 'mesh' && audience.topic !== 'work') {
+            fail('invalid_audience', '$["audience"]["topic"]');
+        }
+    }
+    else if (type === 'work.bid') {
+        if (audience.kind !== 'peer') {
+            fail('invalid_audience', '$["audience"]');
+        }
+        if (audience.peerId !== payload.ownerPeerId) {
+            fail('invalid_audience', '$["audience"]["peerId"]');
+        }
+    }
+    else if (type === 'work.award' ||
+        type === 'work.accept' ||
+        type === 'work.decline' ||
+        type === 'work.progress' ||
+        type === 'work.checkpoint' ||
+        type === 'work.result' ||
+        type === 'work.release' ||
+        type === 'work.cancel' ||
+        type === 'lease.renew' ||
+        type === 'lease.takeover_proposal' ||
+        type === 'lease.vote' ||
+        type === 'lease.certificate') {
+        if (audience.kind !== 'peer') {
+            fail('invalid_audience', '$["audience"]');
+        }
+        if (type === 'work.decline' &&
+            audience.peerId !== payload.ownerPeerId) {
+            fail('invalid_audience', '$["audience"]["peerId"]');
+        }
+    }
+    else if (audience.kind !== 'peer') {
         fail('invalid_audience', '$["audience"]');
     }
-    if (objectiveId !== undefined) {
+    if (type !== 'peer.hello' &&
+        type.startsWith('peer.') &&
+        objectiveId !== undefined) {
         fail('invalid_payload', '$["objectiveId"]');
     }
-    if (type === 'peer.ping_ack' && causationId === undefined) {
+    if (type === 'peer.ping_ack' ||
+        type === 'peer.goodbye' ||
+        type === 'capability.withdraw' ||
+        type === 'objective.cancel') {
+        if (causationId === undefined) {
+            fail('invalid_payload', '$["causationId"]');
+        }
+    }
+    else if (type === 'peer.card' || type === 'capability.advertise') {
+        const revision = payload.type === 'peer.card'
+            ? payload.cardRevision
+            : payload.capabilityRevision;
+        if (revision === 1 && causationId !== undefined) {
+            fail('invalid_payload', '$["causationId"]');
+        }
+        if (revision > 1 && causationId === undefined) {
+            fail('invalid_payload', '$["causationId"]');
+        }
+    }
+    else if (type === 'objective.announce') {
+        if (causationId !== undefined) {
+            fail('invalid_payload', '$["causationId"]');
+        }
+    }
+    else if (type === 'objective.revise' && causationId === undefined) {
+        fail('invalid_payload', '$["causationId"]');
+    }
+    else if (type === 'work.offer') {
+        const offer = payload;
+        if (offer.offerAttempt === 1 && causationId !== undefined) {
+            fail('invalid_payload', '$["causationId"]');
+        }
+        if (offer.offerAttempt > 1 && causationId === undefined) {
+            fail('invalid_payload', '$["causationId"]');
+        }
+    }
+    else if ((type === 'work.bid' ||
+        type === 'work.award' ||
+        type === 'work.accept' ||
+        type === 'work.decline' ||
+        type === 'work.progress' ||
+        type === 'work.checkpoint' ||
+        type === 'work.result' ||
+        type === 'work.release' ||
+        type === 'work.cancel' ||
+        type === 'lease.renew' ||
+        type === 'lease.takeover_proposal' ||
+        type === 'lease.vote' ||
+        type === 'lease.certificate') &&
+        causationId === undefined) {
         fail('invalid_payload', '$["causationId"]');
     }
+    if (type === 'objective.announce' ||
+        type === 'objective.revise' ||
+        type === 'objective.cancel' ||
+        type === 'work.offer' ||
+        type === 'work.bid' ||
+        type === 'work.award' ||
+        type === 'work.accept' ||
+        type === 'work.decline' ||
+        type === 'work.progress' ||
+        type === 'work.checkpoint' ||
+        type === 'work.result' ||
+        type === 'work.release' ||
+        type === 'work.cancel' ||
+        type === 'lease.renew' ||
+        type === 'lease.takeover_proposal' ||
+        type === 'lease.vote' ||
+        type === 'lease.certificate') {
+        if (objectiveId === undefined ||
+            objectiveId !==
+                payload.objectiveId) {
+            fail('invalid_payload', '$["objectiveId"]');
+        }
+    }
+    if (payload.type === 'work.offer') {
+        validateWorkOfferTimes(payload, sentAt, expiresAt);
+    }
+    else if (payload.type === 'work.bid') {
+        validateWorkBidTimes(payload, sentAt, expiresAt);
+    }
+    else if (payload.type === 'work.award') {
+        validateWorkAwardTimes(payload, sentAt, expiresAt);
+    }
+    else if (payload.type === 'work.accept' ||
+        payload.type === 'work.decline') {
+        validateWorkAssignmentResponseTimes(payload, sentAt, expiresAt);
+    }
+    else if (payload.type === 'work.progress' ||
+        payload.type === 'work.checkpoint' ||
+        payload.type === 'work.result' ||
+        payload.type === 'lease.renew') {
+        validateWorkExecutionTimes(payload, sentAt, expiresAt);
+    }
+    else if (payload.type === 'work.release' &&
+        payload.releaseAuthority === 'assignee') {
+        validateWorkExecutionTimes(payload, sentAt, expiresAt);
+    }
+}
+function validateWorkOfferTimes(payload, sentAt, expiresAt) {
+    const bidDeadline = parseRfc3339(payload.bidDeadline, '$["payload"]["bidDeadline"]');
+    const workDeadline = parseRfc3339(payload.workDeadline, '$["payload"]["workDeadline"]');
+    if (bidDeadline <= sentAt) {
+        fail('invalid_payload', '$["payload"]["bidDeadline"]');
+    }
+    if (workDeadline <= bidDeadline) {
+        fail('invalid_payload', '$["payload"]["workDeadline"]');
+    }
+    if (bidDeadline - sentAt > BigInt(maximumWorkBidWindowMs) * 1000000n) {
+        fail('invalid_payload', '$["payload"]["bidDeadline"]');
+    }
+    if (workDeadline - sentAt > BigInt(maximumWorkDeadlineMs) * 1000000n) {
+        fail('invalid_payload', '$["payload"]["workDeadline"]');
+    }
+    if (expiresAt > bidDeadline) {
+        fail('invalid_lifetime', '$["expiresAt"]');
+    }
+}
+function validateWorkBidTimes(payload, sentAt, expiresAt) {
+    const bidExpiresAt = parseRfc3339(payload.bidExpiresAt, '$["payload"]["bidExpiresAt"]');
+    const bidDeadline = parseRfc3339(payload.bidDeadline, '$["payload"]["bidDeadline"]');
+    const expectedCompletionAt = parseRfc3339(payload.expectedCompletionAt, '$["payload"]["expectedCompletionAt"]');
+    const workDeadline = parseRfc3339(payload.workDeadline, '$["payload"]["workDeadline"]');
+    if (bidExpiresAt <= sentAt) {
+        fail('invalid_payload', '$["payload"]["bidExpiresAt"]');
+    }
+    if (bidExpiresAt > bidDeadline) {
+        fail('invalid_payload', '$["payload"]["bidExpiresAt"]');
+    }
+    if (bidDeadline >= expectedCompletionAt) {
+        fail('invalid_payload', '$["payload"]["expectedCompletionAt"]');
+    }
+    if (expectedCompletionAt > workDeadline) {
+        fail('invalid_payload', '$["payload"]["expectedCompletionAt"]');
+    }
+    if (bidDeadline - sentAt > BigInt(maximumWorkBidWindowMs) * 1000000n) {
+        fail('invalid_payload', '$["payload"]["bidDeadline"]');
+    }
+    if (workDeadline - sentAt > BigInt(maximumWorkDeadlineMs) * 1000000n) {
+        fail('invalid_payload', '$["payload"]["workDeadline"]');
+    }
+    if (expiresAt > bidExpiresAt) {
+        fail('invalid_lifetime', '$["expiresAt"]');
+    }
+}
+function validateWorkAwardTimes(payload, sentAt, expiresAt) {
+    const leaseStartsAt = parseRfc3339(payload.leaseStartsAt, '$["payload"]["leaseStartsAt"]');
+    const acceptanceDeadline = parseRfc3339(payload.acceptanceDeadline, '$["payload"]["acceptanceDeadline"]');
+    const leaseExpiresAt = parseRfc3339(payload.leaseExpiresAt, '$["payload"]["leaseExpiresAt"]');
+    const workDeadline = parseRfc3339(payload.workDeadline, '$["payload"]["workDeadline"]');
+    if (leaseStartsAt < sentAt) {
+        fail('invalid_payload', '$["payload"]["leaseStartsAt"]');
+    }
+    if (acceptanceDeadline <= leaseStartsAt) {
+        fail('invalid_payload', '$["payload"]["acceptanceDeadline"]');
+    }
+    if (leaseExpiresAt < acceptanceDeadline) {
+        fail('invalid_payload', '$["payload"]["leaseExpiresAt"]');
+    }
+    if (workDeadline < leaseExpiresAt) {
+        fail('invalid_payload', '$["payload"]["workDeadline"]');
+    }
+    if (acceptanceDeadline - sentAt >
+        BigInt(maximumAcceptanceWindowMs) * 1000000n) {
+        fail('invalid_payload', '$["payload"]["acceptanceDeadline"]');
+    }
+    if (leaseExpiresAt - leaseStartsAt >
+        BigInt(maximumLeaseDurationMs) * 1000000n) {
+        fail('invalid_payload', '$["payload"]["leaseExpiresAt"]');
+    }
+    if (workDeadline - sentAt > BigInt(maximumWorkDeadlineMs) * 1000000n) {
+        fail('invalid_payload', '$["payload"]["workDeadline"]');
+    }
+    if (expiresAt > acceptanceDeadline) {
+        fail('invalid_lifetime', '$["expiresAt"]');
+    }
+}
+function validateWorkAssignmentResponseTimes(payload, sentAt, expiresAt) {
+    const acceptanceDeadline = parseRfc3339(payload.acceptanceDeadline, '$["payload"]["acceptanceDeadline"]');
+    if (sentAt >= acceptanceDeadline) {
+        fail('invalid_payload', '$["payload"]["acceptanceDeadline"]');
+    }
+    if (expiresAt > acceptanceDeadline) {
+        fail('invalid_lifetime', '$["expiresAt"]');
+    }
+}
+function validateWorkExecutionTimes(payload, sentAt, expiresAt) {
+    const leaseExpiresAt = parseRfc3339(payload.leaseExpiresAt, '$["payload"]["leaseExpiresAt"]');
+    if (sentAt >= leaseExpiresAt) {
+        fail('invalid_payload', '$["payload"]["leaseExpiresAt"]');
+    }
+    if (expiresAt > leaseExpiresAt) {
+        fail('invalid_lifetime', '$["expiresAt"]');
+    }
+}
+function validateRevisionPredecessor(revision, predecessor, path) {
+    if (revision === 1 && predecessor !== undefined) {
+        fail('invalid_payload', path);
+    }
+    if (revision > 1 && predecessor === undefined) {
+        fail('invalid_payload', path);
+    }
+}
+function assertBoundedValidity(validFrom, validUntil) {
+    if (validUntil <= validFrom) {
+        fail('invalid_payload', '$["payload"]["validUntil"]');
+    }
+    if (validUntil - validFrom >
+        BigInt(maximumAdvertisementValidityMs) * 1000000n) {
+        fail('invalid_payload', '$["payload"]["validUntil"]');
+    }
+}
+function assertObjectiveValidity(validFrom, validUntil) {
+    if (validUntil <= validFrom) {
+        fail('invalid_payload', '$["payload"]["validUntil"]');
+    }
+    const duration = validUntil - validFrom;
+    if (duration > BigInt(maximumObjectiveValidityMs) * 1000000n) {
+        fail('invalid_payload', '$["payload"]["validUntil"]');
+    }
+    return duration;
+}
+function assertRfc3339PayloadTimestamp(input, path) {
+    const text = assertString(input, path, 'invalid_payload');
+    try {
+        return { text, instant: parseRfc3339(text, path) };
+    }
+    catch (error) {
+        if (error instanceof ValidationFailure) {
+            fail('invalid_payload', path);
+        }
+        throw error;
+    }
+}
+function validateProtocolVersions(input) {
+    const path = '$["payload"]["protocolVersions"]';
+    if (!Array.isArray(input) ||
+        input.length === 0 ||
+        input.length > maximumProtocolVersions) {
+        fail('invalid_payload', path);
+    }
+    let previous;
+    let includesCurrentWireVersion = false;
+    const result = [];
+    for (const [index, value] of input.entries()) {
+        if (typeof value !== 'number' ||
+            !Number.isSafeInteger(value) ||
+            value < 0 ||
+            (previous !== undefined && value <= previous)) {
+            fail('invalid_payload', `${path}[${index}]`);
+        }
+        if (value === MESH_WIRE_VERSION)
+            includesCurrentWireVersion = true;
+        previous = value;
+        result.push(value);
+    }
+    if (!includesCurrentWireVersion) {
+        fail('invalid_payload', path);
+    }
+    return result;
+}
+function validateIdentifierArray(input, path, maximumItems, limits) {
+    if (!Array.isArray(input) || input.length > maximumItems) {
+        fail('invalid_payload', path);
+    }
+    let previous;
+    const result = [];
+    for (const [index, value] of input.entries()) {
+        const itemPath = `${path}[${index}]`;
+        const identifier = assertIdentifier(value, itemPath, limits);
+        if (previous !== undefined &&
+            compareUtf16CodeUnits(identifier, previous) !== 1) {
+            fail('invalid_payload', itemPath);
+        }
+        previous = identifier;
+        result.push(identifier);
+    }
+    return result;
+}
+function validateBoundedStringArray(input, path, maximumItems, maximumItemBytes, maximumAggregateBytes, sortedUnique = false) {
+    if (!Array.isArray(input) || input.length > maximumItems) {
+        fail('invalid_payload', path);
+    }
+    let aggregateBytes = 0;
+    let previous;
+    const result = [];
+    for (const [index, value] of input.entries()) {
+        const itemPath = `${path}[${index}]`;
+        const item = assertBoundedString(value, itemPath, maximumItemBytes);
+        if (sortedUnique &&
+            previous !== undefined &&
+            compareUtf16CodeUnits(item, previous) !== 1) {
+            fail('invalid_payload', itemPath);
+        }
+        aggregateBytes += utf8Encoder.encode(item).byteLength;
+        if (maximumAggregateBytes !== undefined &&
+            aggregateBytes > maximumAggregateBytes) {
+            fail('invalid_payload', path);
+        }
+        previous = item;
+        result.push(item);
+    }
+    return result;
+}
+/**
+ * Compares raw UTF-16 code units lexicographically, matching JavaScript string
+ * relational ordering and the property-name ordering used by JCS/RFC 8785.
+ */
+function compareUtf16CodeUnits(left, right) {
+    const sharedLength = Math.min(left.length, right.length);
+    for (let index = 0; index < sharedLength; index += 1) {
+        const leftCodeUnit = left.charCodeAt(index);
+        const rightCodeUnit = right.charCodeAt(index);
+        if (leftCodeUnit < rightCodeUnit)
+            return -1;
+        if (leftCodeUnit > rightCodeUnit)
+            return 1;
+    }
+    if (left.length < right.length)
+        return -1;
+    if (left.length > right.length)
+        return 1;
+    return 0;
+}
+function validateAttributes(input, path = '$["payload"]["attributes"]') {
+    const attributes = assertRecord(input, path, 'invalid_payload');
+    const keys = Object.keys(attributes);
+    if (keys.length > maximumAttributes) {
+        fail('invalid_payload', path);
+    }
+    let aggregateBytes = 0;
+    const result = {};
+    for (const key of keys) {
+        const keyPath = `${path}[${JSON.stringify(key)}]`;
+        if (key.length === 0 ||
+            utf8Encoder.encode(key).byteLength > maximumAttributeKeyBytes) {
+            fail('invalid_payload', keyPath);
+        }
+        const value = assertBoundedString(attributes[key], keyPath, maximumAttributeValueBytes);
+        aggregateBytes +=
+            utf8Encoder.encode(key).byteLength + utf8Encoder.encode(value).byteLength;
+        if (aggregateBytes > maximumAttributesBytes) {
+            fail('invalid_payload', path);
+        }
+        Object.defineProperty(result, key, {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    return result;
+}
+function assertBoundedString(input, path, maximumBytes) {
+    const value = assertString(input, path, 'invalid_payload');
+    if (value.length === 0 ||
+        utf8Encoder.encode(value).byteLength > maximumBytes) {
+        fail('invalid_payload', path);
+    }
+    return value;
 }
 function validateLifetime(type, sentAt, expiresAt, limits) {
     if (expiresAt <= sentAt) {
         fail('invalid_lifetime', '$["expiresAt"]');
     }
-    const messageMaximum = type === 'peer.hello' ? 120_000 : 30_000;
+    const messageMaximum = type === 'peer.ping' || type === 'peer.ping_ack'
+        ? 30_000
+        : type === 'peer.goodbye' ||
+            type === 'lease.takeover_proposal' ||
+            type === 'lease.vote' ||
+            type === 'lease.certificate'
+            ? 60_000
+            : type === 'objective.announce' || type === 'objective.revise'
+                ? 5 * 60_000
+                : type === 'work.progress' ||
+                    type === 'work.checkpoint' ||
+                    type === 'work.result'
+                    ? maximumWorkExecutionLifetimeMs
+                    : type === 'lease.renew'
+                        ? 30_000
+                        : 120_000;
     const maximum = Math.min(limits.maximumLifetimeMs, messageMaximum);
     if (expiresAt - sentAt > BigInt(maximum) * 1000000n) {
         fail('invalid_lifetime', '$["expiresAt"]');
@@ -415,6 +2009,14 @@ function assertPayloadHash(input, path) {
     }
     return value;
 }
+function assertContentDigest(input, path) {
+    const value = assertString(input, path, 'invalid_payload');
+    if (!value.startsWith('sha256:') ||
+        !isCanonicalBase64Url(value.slice('sha256:'.length), 32)) {
+        fail('invalid_payload', path);
+    }
+    return value;
+}
 function assertMessageId(input, path) {
     const value = assertString(input, path, 'invalid_message_id');
     if (!isCanonicalBase64Url(value, 16)) {
@@ -435,6 +2037,19 @@ function assertPositiveSafeInteger(input, path, code = 'invalid_sequence') {
     }
     return input;
 }
+function assertNonnegativeSafeInteger(input, path) {
+    if (typeof input !== 'number' || !Number.isSafeInteger(input) || input < 0) {
+        fail('invalid_payload', path);
+    }
+    return input;
+}
+function assertBoundedPositiveSafeInteger(input, path, maximum) {
+    const value = assertPositiveSafeInteger(input, path, 'invalid_payload');
+    if (value > maximum) {
+        fail('invalid_payload', path);
+    }
+    return value;
+}
 function assertString(input, path, code = 'invalid_payload') {
     if (typeof input !== 'string')
         fail(code, path);
@@ -535,8 +2150,31 @@ function isCanonicalBase64Url(value, expectedBytes) {
     const unusedBits = 6 - significantBits;
     return (finalIndex & ((1 << unusedBits) - 1)) === 0;
 }
-function isAlphaOneMessageType(value) {
-    return (value === 'peer.hello' || value === 'peer.ping' || value === 'peer.ping_ack');
+function isImplementedMessageType(value) {
+    return (value === 'peer.hello' ||
+        value === 'peer.card' ||
+        value === 'peer.ping' ||
+        value === 'peer.ping_ack' ||
+        value === 'peer.goodbye' ||
+        value === 'capability.advertise' ||
+        value === 'capability.withdraw' ||
+        value === 'objective.announce' ||
+        value === 'objective.revise' ||
+        value === 'objective.cancel' ||
+        value === 'work.offer' ||
+        value === 'work.bid' ||
+        value === 'work.award' ||
+        value === 'work.accept' ||
+        value === 'work.decline' ||
+        value === 'work.progress' ||
+        value === 'work.checkpoint' ||
+        value === 'work.result' ||
+        value === 'work.release' ||
+        value === 'work.cancel' ||
+        value === 'lease.renew' ||
+        value === 'lease.takeover_proposal' ||
+        value === 'lease.vote' ||
+        value === 'lease.certificate');
 }
 function canonicalizeMeshJsonInternal(input, options) {
     const limits = resolveLimits(options.limits);