@claudian-collab/protocol 3.1.0 → 3.2.1

package/dist/esm/CollabAuthorityTransfer.mjs

@@ -0,0 +1,884 @@
+import { CollabError } from './CollabError.mjs';
+import { hasUtf8ByteLengthAtMost, isCollabMemberId, isCollabOpaqueId, isCollabProjectId, } from './CollabValidation.mjs';
+export const COLLAB_LAN_TO_CLOUD_TRANSFER_PHASES = Object.freeze([
+    'collecting-readiness',
+    'source-quiesced',
+    'checkpoint-received',
+    'checkpoint-validated',
+    'claims-retained',
+    'repository-published',
+    'source-relinquished',
+    'cloud-activated',
+    'completed',
+]);
+export const COLLAB_CLOUD_TO_LAN_TRANSFER_PHASES = Object.freeze([
+    'collecting-readiness',
+    'cloud-quiesced',
+    'checkpoint-captured',
+    'target-staged',
+    'claims-retained',
+    'cloud-relinquished',
+    'lan-activated',
+    'completed',
+]);
+export const COLLAB_AUTHORITY_TRANSFER_CANCELLATION_PHASES = Object.freeze([
+    'cancel-intent',
+    'target-invalidated',
+    'target-cleaned',
+    'source-reopened',
+    'cancelled',
+]);
+export const COLLAB_AUTHORITY_TRANSFER_CANCELLABLE_PHASES = Object.freeze([
+    'collecting-readiness',
+    'source-quiesced',
+    'checkpoint-received',
+    'checkpoint-validated',
+    'claims-retained',
+    'repository-published',
+    'cloud-quiesced',
+    'checkpoint-captured',
+    'target-staged',
+    'cancel-intent',
+    'target-invalidated',
+    'target-cleaned',
+    'source-reopened',
+]);
+export const COLLAB_AUTHORITY_TRANSFER_OPERATIONS = Object.freeze([
+    'requestLanToCloudTransfer',
+    'acceptLanToCloudTransferTarget',
+    'beginLanToCloudTransfer',
+    'getProjectAuthorityTransfer',
+    'getAuthorityTransferReceiptVerifier',
+    'rotateTransferredMembershipClaims',
+    'acknowledgeTransferredMembershipClaimBatch',
+    'getTransferredMembershipClaim',
+    'claimTransferredMembership',
+    'acknowledgeTransferredMembershipClaimRedemption',
+    'commitLanToCloudRelinquishment',
+    'beginCloudToLanTransfer',
+    'acceptCloudToLanTransferTarget',
+    'reportCloudToLanTargetStaged',
+    'confirmCloudToLanTargetActive',
+    'cancelProjectAuthorityTransfer',
+]);
+const SHA256_PATTERN = /^[0-9a-f]{64}$/u;
+const BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/u;
+const BASE64URL_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+function invalidPayload(field) {
+    return new CollabError({ code: 'protocol-payload-invalid', safeContext: { field } });
+}
+function record(value, field) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw invalidPayload(field);
+    }
+    return value;
+}
+function exactRecord(value, field, keys) {
+    const source = record(value, field);
+    const expected = new Set(keys);
+    if (!keys.every(key => Object.hasOwn(source, key))
+        || Object.keys(source).some(key => !expected.has(key)))
+        throw invalidPayload(field);
+    return source;
+}
+function token(source, field, validate = isCollabOpaqueId) {
+    const value = source[field];
+    if (typeof value !== 'string' || !validate(value))
+        throw invalidPayload(field);
+    return value;
+}
+function boundedString(source, field, maximumBytes) {
+    const value = source[field];
+    if (typeof value !== 'string'
+        || value.length === 0
+        || !hasUtf8ByteLengthAtMost(value, maximumBytes))
+        throw invalidPayload(field);
+    return value;
+}
+function positiveInteger(source, field) {
+    const value = source[field];
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1) {
+        throw invalidPayload(field);
+    }
+    return value;
+}
+function timestamp(source, field) {
+    const value = source[field];
+    if (typeof value !== 'string'
+        || value.length > 64
+        || Number.isNaN(Date.parse(value))
+        || new Date(value).toISOString() !== value)
+        throw invalidPayload(field);
+    return value;
+}
+function sha256(source, field) {
+    const value = source[field];
+    if (typeof value !== 'string' || !SHA256_PATTERN.test(value))
+        throw invalidPayload(field);
+    return value;
+}
+function base64url(source, field, maximumBytes = 4096) {
+    const value = boundedString(source, field, maximumBytes);
+    if (!BASE64URL_PATTERN.test(value))
+        throw invalidPayload(field);
+    return value;
+}
+function fixedBase64url(source, field, decodedBytes) {
+    const encodedLength = Math.ceil(decodedBytes * 4 / 3);
+    const value = base64url(source, field, encodedLength);
+    const finalIndex = BASE64URL_ALPHABET.indexOf(value[value.length - 1]);
+    const remainder = value.length % 4;
+    if (value.length !== encodedLength
+        || remainder === 1
+        || (remainder === 2 && (finalIndex & 15) !== 0)
+        || (remainder === 3 && (finalIndex & 3) !== 0))
+        throw invalidPayload(field);
+    return value;
+}
+function literal(source, field, values) {
+    const value = source[field];
+    if (typeof value !== 'string' || !values.includes(value))
+        throw invalidPayload(field);
+    return value;
+}
+function authority(value, field) {
+    const source = exactRecord(value, field, ['generation', 'kind']);
+    return {
+        generation: positiveInteger(source, 'generation'),
+        kind: literal(source, 'kind', ['cloud', 'lan']),
+    };
+}
+function absoluteTargetUrl(source) {
+    const targetUrl = boundedString(source, 'targetUrl', 2048);
+    let parsed;
+    try {
+        parsed = new URL(targetUrl);
+    }
+    catch {
+        throw invalidPayload('targetUrl');
+    }
+    if ((parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+        || parsed.username.length > 0
+        || parsed.password.length > 0
+        || targetUrl.includes('?')
+        || targetUrl.includes('#'))
+        throw invalidPayload('targetUrl');
+    return targetUrl;
+}
+export function decodeCollabAuthorityTransferProposal(value) {
+    const source = exactRecord(value, 'proposal', [
+        'expectedSourceAuthority',
+        'idempotencyKey',
+        'projectId',
+        'proposedByMemberId',
+        'proposedAt',
+        'targetAuthorityKind',
+        'targetUrl',
+    ]);
+    const expectedSourceAuthority = authority(source.expectedSourceAuthority, 'expectedSourceAuthority');
+    const targetAuthorityKind = literal(source, 'targetAuthorityKind', ['cloud', 'lan']);
+    if (expectedSourceAuthority.kind === targetAuthorityKind) {
+        throw invalidPayload('targetAuthorityKind');
+    }
+    return {
+        expectedSourceAuthority,
+        idempotencyKey: token(source, 'idempotencyKey'),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        proposedByMemberId: token(source, 'proposedByMemberId', isCollabMemberId),
+        proposedAt: timestamp(source, 'proposedAt'),
+        targetAuthorityKind,
+        targetUrl: absoluteTargetUrl(source),
+    };
+}
+function claimItem(value) {
+    const source = exactRecord(value, 'claim', ['claim', 'memberId']);
+    return {
+        claim: base64url(source, 'claim'),
+        memberId: token(source, 'memberId', isCollabMemberId),
+    };
+}
+export function decodeCollabTransferredMembershipClaimBatch(value) {
+    const source = exactRecord(value, 'claimBatch', [
+        'batchRevision',
+        'batchSha256',
+        'checkpointSha256',
+        'claims',
+        'expiresAt',
+        'projectId',
+        'targetAuthorityGeneration',
+        'transferId',
+    ]);
+    if (!Array.isArray(source.claims)) {
+        throw invalidPayload('claims');
+    }
+    const claims = source.claims.map(claimItem);
+    if (claims.some((item, index) => index > 0
+        && claims[index - 1].memberId.localeCompare(item.memberId, 'en-US') >= 0)
+        || new Set(claims.map(item => item.claim)).size !== claims.length)
+        throw invalidPayload('claims');
+    return {
+        batchRevision: positiveInteger(source, 'batchRevision'),
+        batchSha256: sha256(source, 'batchSha256'),
+        checkpointSha256: sha256(source, 'checkpointSha256'),
+        claims: Object.freeze(claims),
+        expiresAt: timestamp(source, 'expiresAt'),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        targetAuthorityGeneration: positiveInteger(source, 'targetAuthorityGeneration'),
+        transferId: token(source, 'transferId'),
+    };
+}
+export function encodeCollabTransferredMembershipClaimBatchDigestInput(batch) {
+    const decoded = decodeCollabTransferredMembershipClaimBatch(batch);
+    return JSON.stringify({
+        batchRevision: decoded.batchRevision,
+        checkpointSha256: decoded.checkpointSha256,
+        claims: decoded.claims,
+        expiresAt: decoded.expiresAt,
+        projectId: decoded.projectId,
+        targetAuthorityGeneration: decoded.targetAuthorityGeneration,
+        transferId: decoded.transferId,
+    });
+}
+export function decodeCollabTransferredMembershipClaimCustodyReceipt(value) {
+    const source = exactRecord(value, 'custodyReceipt', [
+        'batchRevision',
+        'batchSha256',
+        'checkpointSha256',
+        'committedAt',
+        'custodyAuthority',
+        'operationIntentId',
+        'projectId',
+        'receiptId',
+        'submittedByMemberId',
+        'targetAuthorityGeneration',
+        'transferId',
+    ]);
+    const custodyAuthority = authority(source.custodyAuthority, 'custodyAuthority');
+    const targetAuthorityGeneration = positiveInteger(source, 'targetAuthorityGeneration');
+    if (targetAuthorityGeneration !== custodyAuthority.generation + 1) {
+        throw invalidPayload('targetAuthorityGeneration');
+    }
+    return {
+        batchRevision: positiveInteger(source, 'batchRevision'),
+        batchSha256: sha256(source, 'batchSha256'),
+        checkpointSha256: sha256(source, 'checkpointSha256'),
+        committedAt: timestamp(source, 'committedAt'),
+        custodyAuthority,
+        operationIntentId: token(source, 'operationIntentId'),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        receiptId: token(source, 'receiptId'),
+        submittedByMemberId: token(source, 'submittedByMemberId', isCollabMemberId),
+        targetAuthorityGeneration,
+        transferId: token(source, 'transferId'),
+    };
+}
+export function decodeCollabTransferredMembershipClaim(value) {
+    const source = exactRecord(value, 'claim', [
+        'claim',
+        'expiresAt',
+        'memberId',
+        'projectId',
+        'targetAuthorityGeneration',
+        'transferId',
+    ]);
+    return {
+        claim: base64url(source, 'claim'),
+        expiresAt: timestamp(source, 'expiresAt'),
+        memberId: token(source, 'memberId', isCollabMemberId),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        targetAuthorityGeneration: positiveInteger(source, 'targetAuthorityGeneration'),
+        transferId: token(source, 'transferId'),
+    };
+}
+const REDEMPTION_RECEIPT_SIGNING_PAYLOAD_KEYS = [
+    'checkpointSha256',
+    'claimSha256',
+    'memberId',
+    'operationIntentId',
+    'projectId',
+    'receiptId',
+    'receiptKeyId',
+    'redeemedAt',
+    'signatureAlgorithm',
+    'targetAuthorityGeneration',
+    'transferId',
+];
+function redemptionReceiptSigningPayload(source) {
+    return {
+        checkpointSha256: sha256(source, 'checkpointSha256'),
+        claimSha256: sha256(source, 'claimSha256'),
+        memberId: token(source, 'memberId', isCollabMemberId),
+        operationIntentId: token(source, 'operationIntentId'),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        receiptId: token(source, 'receiptId'),
+        receiptKeyId: boundedString(source, 'receiptKeyId', 256),
+        redeemedAt: timestamp(source, 'redeemedAt'),
+        signatureAlgorithm: literal(source, 'signatureAlgorithm', ['ed25519']),
+        targetAuthorityGeneration: positiveInteger(source, 'targetAuthorityGeneration'),
+        transferId: token(source, 'transferId'),
+    };
+}
+export function encodeCollabTransferredMembershipRedemptionReceiptSigningInput(payload) {
+    const source = exactRecord(payload, 'redemptionReceiptSigningPayload', REDEMPTION_RECEIPT_SIGNING_PAYLOAD_KEYS);
+    return JSON.stringify({
+        domain: 'claudian-collab.transferred-membership-redemption-receipt.v1',
+        payload: redemptionReceiptSigningPayload(source),
+    });
+}
+export function decodeCollabTransferredMembershipRedemptionReceipt(value) {
+    const source = exactRecord(value, 'redemptionReceipt', [
+        ...REDEMPTION_RECEIPT_SIGNING_PAYLOAD_KEYS,
+        'signature',
+    ]);
+    const payload = redemptionReceiptSigningPayload(source);
+    return {
+        checkpointSha256: payload.checkpointSha256,
+        claimSha256: payload.claimSha256,
+        memberId: payload.memberId,
+        operationIntentId: payload.operationIntentId,
+        projectId: payload.projectId,
+        receiptId: payload.receiptId,
+        receiptKeyId: payload.receiptKeyId,
+        redeemedAt: payload.redeemedAt,
+        signature: fixedBase64url(source, 'signature', 64),
+        signatureAlgorithm: payload.signatureAlgorithm,
+        targetAuthorityGeneration: payload.targetAuthorityGeneration,
+        transferId: payload.transferId,
+    };
+}
+const RELINQUISHMENT_PROOF_SIGNING_PAYLOAD_KEYS = [
+    'batchRevision',
+    'batchSha256',
+    'certificateAlgorithm',
+    'checkpointSha256',
+    'committedAt',
+    'operationIntentId',
+    'projectId',
+    'sourceAuthority',
+    'sourceHostMemberId',
+    'targetAuthority',
+    'transferId',
+];
+function authorityRelinquishmentProofSigningPayload(source) {
+    const sourceAuthority = authority(source.sourceAuthority, 'sourceAuthority');
+    const targetAuthority = authority(source.targetAuthority, 'targetAuthority');
+    const sourceHostMemberId = source.sourceHostMemberId === null
+        ? null
+        : token(source, 'sourceHostMemberId', isCollabMemberId);
+    if (sourceAuthority.kind === targetAuthority.kind
+        || targetAuthority.generation !== sourceAuthority.generation + 1
+        || (sourceAuthority.kind === 'lan') !== (sourceHostMemberId !== null))
+        throw invalidPayload('targetAuthority');
+    return {
+        batchRevision: positiveInteger(source, 'batchRevision'),
+        batchSha256: sha256(source, 'batchSha256'),
+        certificateAlgorithm: literal(source, 'certificateAlgorithm', ['ed25519']),
+        checkpointSha256: sha256(source, 'checkpointSha256'),
+        committedAt: timestamp(source, 'committedAt'),
+        operationIntentId: token(source, 'operationIntentId'),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        sourceAuthority,
+        sourceHostMemberId,
+        targetAuthority,
+        transferId: token(source, 'transferId'),
+    };
+}
+export function encodeCollabAuthorityRelinquishmentProofSigningInput(payload) {
+    const source = exactRecord(payload, 'relinquishmentProofSigningPayload', RELINQUISHMENT_PROOF_SIGNING_PAYLOAD_KEYS);
+    return JSON.stringify({
+        domain: 'claudian-collab.authority-relinquishment-proof.v1',
+        payload: authorityRelinquishmentProofSigningPayload(source),
+    });
+}
+export function decodeCollabAuthorityRelinquishmentProof(value) {
+    const source = exactRecord(value, 'relinquishmentProof', [
+        ...RELINQUISHMENT_PROOF_SIGNING_PAYLOAD_KEYS,
+        'certificate',
+    ]);
+    const payload = authorityRelinquishmentProofSigningPayload(source);
+    return {
+        batchRevision: payload.batchRevision,
+        batchSha256: payload.batchSha256,
+        certificate: fixedBase64url(source, 'certificate', 64),
+        certificateAlgorithm: payload.certificateAlgorithm,
+        checkpointSha256: payload.checkpointSha256,
+        committedAt: payload.committedAt,
+        operationIntentId: payload.operationIntentId,
+        projectId: payload.projectId,
+        sourceAuthority: payload.sourceAuthority,
+        sourceHostMemberId: payload.sourceHostMemberId,
+        targetAuthority: payload.targetAuthority,
+        transferId: payload.transferId,
+    };
+}
+const LAN_TO_CLOUD_PHASE_SET = new Set(COLLAB_LAN_TO_CLOUD_TRANSFER_PHASES);
+const CLOUD_TO_LAN_PHASE_SET = new Set(COLLAB_CLOUD_TO_LAN_TRANSFER_PHASES);
+const CANCELLATION_PHASE_SET = new Set(COLLAB_AUTHORITY_TRANSFER_CANCELLATION_PHASES);
+const CANCELLABLE_PHASE_SET = new Set(COLLAB_AUTHORITY_TRANSFER_CANCELLABLE_PHASES);
+const LAN_TO_CLOUD_CHECKPOINT_REQUIRED_PHASE_SET = new Set(COLLAB_LAN_TO_CLOUD_TRANSFER_PHASES.slice(2));
+const CLOUD_TO_LAN_CHECKPOINT_REQUIRED_PHASE_SET = new Set(COLLAB_CLOUD_TO_LAN_TRANSFER_PHASES.slice(2));
+const LAN_TO_CLOUD_BATCH_REQUIRED_PHASE_SET = new Set(COLLAB_LAN_TO_CLOUD_TRANSFER_PHASES.slice(4));
+const CLOUD_TO_LAN_BATCH_REQUIRED_PHASE_SET = new Set(COLLAB_CLOUD_TO_LAN_TRANSFER_PHASES.slice(4));
+const LAN_TO_CLOUD_RELINQUISHMENT_REQUIRED_PHASE_SET = new Set(COLLAB_LAN_TO_CLOUD_TRANSFER_PHASES.slice(6));
+const CLOUD_TO_LAN_RELINQUISHMENT_REQUIRED_PHASE_SET = new Set(COLLAB_CLOUD_TO_LAN_TRANSFER_PHASES.slice(5));
+function transferPhase(source, direction) {
+    const value = source.phase;
+    const directionSet = direction === 'lan-to-cloud'
+        ? LAN_TO_CLOUD_PHASE_SET
+        : CLOUD_TO_LAN_PHASE_SET;
+    if (typeof value !== 'string' || (!directionSet.has(value) && !CANCELLATION_PHASE_SET.has(value))) {
+        throw invalidPayload('phase');
+    }
+    return value;
+}
+export function decodeCollabAuthorityTransferLifecycleFence(value) {
+    const source = exactRecord(value, 'transferLifecycleFence', [
+        'batchRevision',
+        'batchSha256',
+        'checkpointSha256',
+        'direction',
+        'phase',
+    ]);
+    const direction = literal(source, 'direction', ['cloud-to-lan', 'lan-to-cloud']);
+    const phase = transferPhase(source, direction);
+    const checkpointSha256 = source.checkpointSha256 === null
+        ? null
+        : sha256(source, 'checkpointSha256');
+    const batchRevision = source.batchRevision === null
+        ? null
+        : positiveInteger(source, 'batchRevision');
+    const batchSha256 = source.batchSha256 === null
+        ? null
+        : sha256(source, 'batchSha256');
+    if ((batchRevision === null) !== (batchSha256 === null)
+        || (batchRevision !== null && checkpointSha256 === null)
+        || ((direction === 'lan-to-cloud'
+            ? LAN_TO_CLOUD_CHECKPOINT_REQUIRED_PHASE_SET
+            : CLOUD_TO_LAN_CHECKPOINT_REQUIRED_PHASE_SET).has(phase)
+            && checkpointSha256 === null)
+        || ((direction === 'lan-to-cloud'
+            ? LAN_TO_CLOUD_BATCH_REQUIRED_PHASE_SET
+            : CLOUD_TO_LAN_BATCH_REQUIRED_PHASE_SET).has(phase)
+            && batchRevision === null))
+        throw invalidPayload('claimBatch');
+    const relinquishmentRequired = (direction === 'lan-to-cloud'
+        ? LAN_TO_CLOUD_RELINQUISHMENT_REQUIRED_PHASE_SET
+        : CLOUD_TO_LAN_RELINQUISHMENT_REQUIRED_PHASE_SET).has(phase);
+    return {
+        batchRevision,
+        batchSha256,
+        checkpointSha256,
+        direction,
+        phase,
+        relinquishmentRequired,
+    };
+}
+export function decodeCollabAuthorityTransferStatus(value) {
+    const source = exactRecord(value, 'transferStatus', [
+        'batchRevision',
+        'batchSha256',
+        'checkpointSha256',
+        'createdAt',
+        'direction',
+        'expiresAt',
+        'phase',
+        'projectId',
+        'relinquishmentProof',
+        'sourceAuthority',
+        'state',
+        'targetAuthority',
+        'targetUrl',
+        'transferId',
+        'updatedAt',
+    ]);
+    const lifecycleFence = decodeCollabAuthorityTransferLifecycleFence({
+        batchRevision: source.batchRevision,
+        batchSha256: source.batchSha256,
+        checkpointSha256: source.checkpointSha256,
+        direction: source.direction,
+        phase: source.phase,
+    });
+    const { batchRevision, batchSha256, checkpointSha256, direction, phase, relinquishmentRequired, } = lifecycleFence;
+    const sourceAuthority = authority(source.sourceAuthority, 'sourceAuthority');
+    const targetAuthority = authority(source.targetAuthority, 'targetAuthority');
+    const state = literal(source, 'state', ['active', 'cancelled', 'completed']);
+    if (sourceAuthority.kind === targetAuthority.kind
+        || targetAuthority.generation !== sourceAuthority.generation + 1
+        || (direction === 'lan-to-cloud'
+            && (sourceAuthority.kind !== 'lan' || targetAuthority.kind !== 'cloud'))
+        || (direction === 'cloud-to-lan'
+            && (sourceAuthority.kind !== 'cloud' || targetAuthority.kind !== 'lan'))
+        || (state === 'cancelled' && phase !== 'cancelled')
+        || (state === 'completed' && phase !== 'completed')
+        || (state === 'active' && (phase === 'cancelled' || phase === 'completed')))
+        throw invalidPayload('transferStatus');
+    const relinquishmentProof = source.relinquishmentProof === null
+        ? null
+        : decodeCollabAuthorityRelinquishmentProof(source.relinquishmentProof);
+    if (relinquishmentRequired !== (relinquishmentProof !== null)
+        || (relinquishmentProof !== null && (relinquishmentProof.batchRevision !== batchRevision
+            || relinquishmentProof.batchSha256 !== batchSha256
+            || relinquishmentProof.checkpointSha256 !== checkpointSha256
+            || relinquishmentProof.projectId !== source.projectId
+            || relinquishmentProof.sourceAuthority.generation !== sourceAuthority.generation
+            || relinquishmentProof.sourceAuthority.kind !== sourceAuthority.kind
+            || relinquishmentProof.targetAuthority.generation !== targetAuthority.generation
+            || relinquishmentProof.targetAuthority.kind !== targetAuthority.kind
+            || relinquishmentProof.transferId !== source.transferId)))
+        throw invalidPayload('relinquishmentProof');
+    const createdAt = timestamp(source, 'createdAt');
+    const updatedAt = timestamp(source, 'updatedAt');
+    const expiresAt = timestamp(source, 'expiresAt');
+    if (Date.parse(updatedAt) < Date.parse(createdAt)
+        || Date.parse(expiresAt) <= Date.parse(updatedAt))
+        throw invalidPayload('transferStatus');
+    return {
+        batchRevision,
+        batchSha256,
+        checkpointSha256,
+        createdAt,
+        direction,
+        expiresAt,
+        phase,
+        projectId: token(source, 'projectId', isCollabProjectId),
+        relinquishmentProof,
+        sourceAuthority,
+        state,
+        targetAuthority,
+        targetUrl: absoluteTargetUrl(source),
+        transferId: token(source, 'transferId'),
+        updatedAt,
+    };
+}
+function mutationFields(source) {
+    return {
+        idempotencyKey: token(source, 'idempotencyKey'),
+        projectId: token(source, 'projectId', isCollabProjectId),
+    };
+}
+function decodeRequestLanToCloudTransfer(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedAuthorityGeneration',
+        'idempotencyKey',
+        'projectId',
+        'targetUrl',
+    ]);
+    return {
+        expectedAuthorityGeneration: positiveInteger(source, 'expectedAuthorityGeneration'),
+        ...mutationFields(source),
+        targetUrl: absoluteTargetUrl(source),
+    };
+}
+function decodeAcceptLanToCloudTransferTarget(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedAuthorityGeneration',
+        'idempotencyKey',
+        'projectId',
+        'targetUrl',
+        'transferId',
+    ]);
+    return {
+        expectedAuthorityGeneration: positiveInteger(source, 'expectedAuthorityGeneration'),
+        ...mutationFields(source),
+        targetUrl: absoluteTargetUrl(source),
+        transferId: token(source, 'transferId'),
+    };
+}
+function decodeBeginLanToCloudTransfer(value) {
+    const source = exactRecord(value, 'request', [
+        'checkpointManifestSha256',
+        'expectedSourceAuthorityGeneration',
+        'idempotencyKey',
+        'projectId',
+        'sourceHostMemberId',
+        'sourceProof',
+        'targetUrl',
+        'transferId',
+    ]);
+    return {
+        checkpointManifestSha256: sha256(source, 'checkpointManifestSha256'),
+        expectedSourceAuthorityGeneration: positiveInteger(source, 'expectedSourceAuthorityGeneration'),
+        ...mutationFields(source),
+        sourceHostMemberId: token(source, 'sourceHostMemberId', isCollabMemberId),
+        sourceProof: base64url(source, 'sourceProof'),
+        targetUrl: absoluteTargetUrl(source),
+        transferId: token(source, 'transferId'),
+    };
+}
+function decodeGetProjectAuthorityTransfer(value) {
+    const source = exactRecord(value, 'request', ['projectId', 'transferId']);
+    return {
+        projectId: token(source, 'projectId', isCollabProjectId),
+        transferId: token(source, 'transferId'),
+    };
+}
+function decodeAuthorityTransferReceiptVerifier(value) {
+    const source = exactRecord(value, 'receiptVerifier', [
+        'projectId',
+        'receiptKeyId',
+        'receiptPublicKey',
+        'receiptPublicKeyEncoding',
+        'signatureAlgorithm',
+        'transferId',
+    ]);
+    return {
+        projectId: token(source, 'projectId', isCollabProjectId),
+        receiptKeyId: boundedString(source, 'receiptKeyId', 256),
+        receiptPublicKey: fixedBase64url(source, 'receiptPublicKey', 32),
+        receiptPublicKeyEncoding: literal(source, 'receiptPublicKeyEncoding', ['base64url-raw']),
+        signatureAlgorithm: literal(source, 'signatureAlgorithm', ['ed25519']),
+        transferId: token(source, 'transferId'),
+    };
+}
+function decodeRotateTransferredMembershipClaims(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedBatchRevision',
+        'expectedBatchSha256',
+        'idempotencyKey',
+        'projectId',
+        'transferId',
+    ]);
+    return {
+        expectedBatchRevision: positiveInteger(source, 'expectedBatchRevision'),
+        expectedBatchSha256: sha256(source, 'expectedBatchSha256'),
+        ...mutationFields(source),
+        transferId: token(source, 'transferId'),
+    };
+}
+function decodeAcknowledgeTransferredMembershipClaimBatch(value) {
+    const source = exactRecord(value, 'request', [
+        'batchRevision',
+        'batchSha256',
+        'idempotencyKey',
+        'operationIntentId',
+        'projectId',
+        'transferId',
+    ]);
+    return {
+        batchRevision: positiveInteger(source, 'batchRevision'),
+        batchSha256: sha256(source, 'batchSha256'),
+        ...mutationFields(source),
+        operationIntentId: token(source, 'operationIntentId'),
+        transferId: token(source, 'transferId'),
+    };
+}
+function decodeGetTransferredMembershipClaim(value) {
+    return decodeGetProjectAuthorityTransfer(value);
+}
+function decodeClaimTransferredMembership(value) {
+    const raw = record(value, 'request');
+    const hasCredentialHash = Object.hasOwn(raw, 'credentialHash');
+    const source = exactRecord(value, 'request', hasCredentialHash
+        ? ['claim', 'credentialHash', 'idempotencyKey', 'projectId', 'transferId']
+        : ['claim', 'idempotencyKey', 'projectId', 'transferId']);
+    const common = {
+        claim: base64url(source, 'claim'),
+        ...mutationFields(source),
+        transferId: token(source, 'transferId'),
+    };
+    return hasCredentialHash
+        ? {
+            ...common,
+            credentialHash: sha256(source, 'credentialHash'),
+        }
+        : common;
+}
+function decodeAcknowledgeTransferredMembershipClaimRedemption(value) {
+    const source = exactRecord(value, 'request', [
+        'idempotencyKey',
+        'projectId',
+        'receipt',
+        'transferId',
+    ]);
+    const common = mutationFields(source);
+    const transferId = token(source, 'transferId');
+    const receipt = decodeCollabTransferredMembershipRedemptionReceipt(source.receipt);
+    if (receipt.projectId !== common.projectId || receipt.transferId !== transferId) {
+        throw invalidPayload('receipt');
+    }
+    return { ...common, receipt, transferId };
+}
+function decodeCommitLanToCloudRelinquishment(value) {
+    const source = exactRecord(value, 'request', [
+        'idempotencyKey',
+        'projectId',
+        'proof',
+        'transferId',
+    ]);
+    const common = mutationFields(source);
+    const transferId = token(source, 'transferId');
+    const proof = decodeCollabAuthorityRelinquishmentProof(source.proof);
+    if (proof.projectId !== common.projectId || proof.transferId !== transferId) {
+        throw invalidPayload('proof');
+    }
+    return { ...common, proof, transferId };
+}
+function decodeBeginCloudToLanTransfer(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedAuthorityGeneration',
+        'idempotencyKey',
+        'projectId',
+        'targetHostMemberId',
+        'targetUrl',
+    ]);
+    return {
+        expectedAuthorityGeneration: positiveInteger(source, 'expectedAuthorityGeneration'),
+        ...mutationFields(source),
+        targetHostMemberId: token(source, 'targetHostMemberId', isCollabMemberId),
+        targetUrl: absoluteTargetUrl(source),
+    };
+}
+function decodeAcceptCloudToLanTransferTarget(value) {
+    const source = exactRecord(value, 'request', [
+        'idempotencyKey',
+        'projectId',
+        'targetHostMemberId',
+        'targetProof',
+        'transferId',
+    ]);
+    return {
+        ...mutationFields(source),
+        targetHostMemberId: token(source, 'targetHostMemberId', isCollabMemberId),
+        targetProof: base64url(source, 'targetProof'),
+        transferId: token(source, 'transferId'),
+    };
+}
+function decodeReportCloudToLanTargetStaged(value) {
+    const source = exactRecord(value, 'request', [
+        'checkpointSha256',
+        'claimBatch',
+        'idempotencyKey',
+        'projectId',
+        'stageSha256',
+        'targetAuthority',
+        'targetProof',
+        'transferId',
+    ]);
+    const targetAuthority = authority(source.targetAuthority, 'targetAuthority');
+    if (targetAuthority.kind !== 'lan')
+        throw invalidPayload('targetAuthority');
+    const common = mutationFields(source);
+    const transferId = token(source, 'transferId');
+    const checkpointSha256 = sha256(source, 'checkpointSha256');
+    const claimBatch = decodeCollabTransferredMembershipClaimBatch(source.claimBatch);
+    if (claimBatch.projectId !== common.projectId
+        || claimBatch.transferId !== transferId
+        || claimBatch.checkpointSha256 !== checkpointSha256
+        || claimBatch.targetAuthorityGeneration !== targetAuthority.generation)
+        throw invalidPayload('claimBatch');
+    return {
+        checkpointSha256,
+        claimBatch,
+        ...common,
+        stageSha256: sha256(source, 'stageSha256'),
+        targetAuthority,
+        targetProof: base64url(source, 'targetProof'),
+        transferId,
+    };
+}
+function decodeConfirmCloudToLanTargetActive(value) {
+    const source = exactRecord(value, 'request', [
+        'idempotencyKey',
+        'projectId',
+        'relinquishmentProof',
+        'targetActivationProof',
+        'transferId',
+    ]);
+    const common = mutationFields(source);
+    const transferId = token(source, 'transferId');
+    const relinquishmentProof = decodeCollabAuthorityRelinquishmentProof(source.relinquishmentProof);
+    if (relinquishmentProof.projectId !== common.projectId
+        || relinquishmentProof.transferId !== transferId
+        || relinquishmentProof.sourceAuthority.kind !== 'cloud'
+        || relinquishmentProof.targetAuthority.kind !== 'lan')
+        throw invalidPayload('relinquishmentProof');
+    return {
+        ...common,
+        relinquishmentProof,
+        targetActivationProof: base64url(source, 'targetActivationProof'),
+        transferId,
+    };
+}
+function decodeCancelProjectAuthorityTransfer(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedPhase',
+        'idempotencyKey',
+        'projectId',
+        'transferId',
+    ]);
+    const expectedPhase = source.expectedPhase;
+    if (typeof expectedPhase !== 'string'
+        || !CANCELLABLE_PHASE_SET.has(expectedPhase))
+        throw invalidPayload('expectedPhase');
+    return {
+        expectedPhase: expectedPhase,
+        ...mutationFields(source),
+        transferId: token(source, 'transferId'),
+    };
+}
+export function decodeCollabAuthorityTransferOperationRequest(operation, value) {
+    const decoded = (() => {
+        switch (operation) {
+            case 'requestLanToCloudTransfer': return decodeRequestLanToCloudTransfer(value);
+            case 'acceptLanToCloudTransferTarget': return decodeAcceptLanToCloudTransferTarget(value);
+            case 'beginLanToCloudTransfer': return decodeBeginLanToCloudTransfer(value);
+            case 'getProjectAuthorityTransfer': return decodeGetProjectAuthorityTransfer(value);
+            case 'getAuthorityTransferReceiptVerifier':
+                return decodeGetProjectAuthorityTransfer(value);
+            case 'rotateTransferredMembershipClaims':
+                return decodeRotateTransferredMembershipClaims(value);
+            case 'acknowledgeTransferredMembershipClaimBatch':
+                return decodeAcknowledgeTransferredMembershipClaimBatch(value);
+            case 'getTransferredMembershipClaim': return decodeGetTransferredMembershipClaim(value);
+            case 'claimTransferredMembership': return decodeClaimTransferredMembership(value);
+            case 'acknowledgeTransferredMembershipClaimRedemption':
+                return decodeAcknowledgeTransferredMembershipClaimRedemption(value);
+            case 'commitLanToCloudRelinquishment':
+                return decodeCommitLanToCloudRelinquishment(value);
+            case 'beginCloudToLanTransfer': return decodeBeginCloudToLanTransfer(value);
+            case 'acceptCloudToLanTransferTarget': return decodeAcceptCloudToLanTransferTarget(value);
+            case 'reportCloudToLanTargetStaged': return decodeReportCloudToLanTargetStaged(value);
+            case 'confirmCloudToLanTargetActive': return decodeConfirmCloudToLanTargetActive(value);
+            case 'cancelProjectAuthorityTransfer': return decodeCancelProjectAuthorityTransfer(value);
+        }
+    })();
+    return decoded;
+}
+function decodeRedemptionAcknowledgement(value) {
+    const source = exactRecord(value, 'redemptionAcknowledgement', [
+        'acknowledgedAt',
+        'memberId',
+        'projectId',
+        'receiptId',
+        'transferId',
+    ]);
+    return {
+        acknowledgedAt: timestamp(source, 'acknowledgedAt'),
+        memberId: token(source, 'memberId', isCollabMemberId),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        receiptId: token(source, 'receiptId'),
+        transferId: token(source, 'transferId'),
+    };
+}
+export function decodeCollabAuthorityTransferOperationResponse(operation, value) {
+    const decoded = (() => {
+        switch (operation) {
+            case 'rotateTransferredMembershipClaims':
+                return decodeCollabTransferredMembershipClaimBatch(value);
+            case 'acknowledgeTransferredMembershipClaimBatch':
+            case 'reportCloudToLanTargetStaged':
+                return decodeCollabTransferredMembershipClaimCustodyReceipt(value);
+            case 'getTransferredMembershipClaim':
+                return decodeCollabTransferredMembershipClaim(value);
+            case 'claimTransferredMembership':
+                return decodeCollabTransferredMembershipRedemptionReceipt(value);
+            case 'acknowledgeTransferredMembershipClaimRedemption':
+                return decodeRedemptionAcknowledgement(value);
+            case 'getAuthorityTransferReceiptVerifier':
+                return decodeAuthorityTransferReceiptVerifier(value);
+            default:
+                return decodeCollabAuthorityTransferStatus(value);
+        }
+    })();
+    return decoded;
+}