@claudian-collab/protocol 3.2.0 → 3.3.0

package/dist/esm/CollabCloudProjectEvent.mjs

@@ -0,0 +1,150 @@
+import { COLLAB_LIMITS, COLLAB_PROTOCOL_VERSION } from './CollabConstants.mjs';
+import { CollabError } from './CollabError.mjs';
+import { hasUtf8ByteLengthAtMost, isCollabGitOid, isCollabMemberId, isCollabOpaqueId, isCollabProjectId, } from './CollabValidation.mjs';
+export const COLLAB_CLOUD_EVENT_KINDS = Object.freeze([
+    'membership.updated',
+    'request.updated',
+    'request.comment-added',
+    'ticket.updated',
+    'ticket.comment-added',
+    'main.updated',
+    'authority-transfer.updated',
+    'membership.claimed',
+    'project.retired',
+]);
+const EVENT_KIND_SET = new Set(COLLAB_CLOUD_EVENT_KINDS);
+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 stringField(source, field, maximum, validate) {
+    const value = source[field];
+    if (typeof value !== 'string'
+        || value.length === 0
+        || value.length > maximum
+        || !validate(value))
+        throw invalidPayload(field);
+    return value;
+}
+function nonNegativeInteger(source, field) {
+    const value = source[field];
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        throw invalidPayload(field);
+    }
+    return value;
+}
+function positiveInteger(source, field) {
+    const value = nonNegativeInteger(source, field);
+    if (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 decodePayload(kind, value) {
+    switch (kind) {
+        case 'authority-transfer.updated': {
+            const source = exactRecord(value, 'payload', ['transferId']);
+            return { transferId: stringField(source, 'transferId', 128, isCollabOpaqueId) };
+        }
+        case 'membership.updated': {
+            const source = exactRecord(value, 'payload', ['memberId']);
+            return { memberId: stringField(source, 'memberId', 64, isCollabMemberId) };
+        }
+        case 'membership.claimed': {
+            const source = exactRecord(value, 'payload', ['memberId', 'transferId']);
+            return {
+                memberId: stringField(source, 'memberId', 64, isCollabMemberId),
+                transferId: stringField(source, 'transferId', 128, isCollabOpaqueId),
+            };
+        }
+        case 'project.retired': {
+            const source = exactRecord(value, 'payload', ['retiredAt', 'retirementId']);
+            return {
+                retiredAt: timestamp(source, 'retiredAt'),
+                retirementId: stringField(source, 'retirementId', 128, isCollabOpaqueId),
+            };
+        }
+        case 'request.updated':
+        case 'request.comment-added': {
+            const source = exactRecord(value, 'payload', ['requestId']);
+            return { requestId: stringField(source, 'requestId', 128, isCollabOpaqueId) };
+        }
+        case 'ticket.updated':
+        case 'ticket.comment-added': {
+            const source = exactRecord(value, 'payload', ['ticketId']);
+            return { ticketId: stringField(source, 'ticketId', 128, isCollabOpaqueId) };
+        }
+        case 'main.updated': {
+            const source = exactRecord(value, 'payload', ['mainOid', 'requestId']);
+            return {
+                mainOid: stringField(source, 'mainOid', 64, isCollabGitOid),
+                requestId: stringField(source, 'requestId', 128, isCollabOpaqueId),
+            };
+        }
+    }
+}
+export function decodeCollabCloudProjectEventMessage(value) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        throw invalidPayload('event');
+    }
+    if (!hasUtf8ByteLengthAtMost(serialized, COLLAB_LIMITS.maxJsonPayloadUtf8Bytes)) {
+        throw invalidPayload('event');
+    }
+    const candidate = record(value, 'event');
+    if (candidate.kind === 'snapshot.required') {
+        const source = exactRecord(candidate, 'snapshot.required', ['kind', 'latestSequence']);
+        return {
+            kind: 'snapshot.required',
+            latestSequence: nonNegativeInteger(source, 'latestSequence'),
+        };
+    }
+    const source = exactRecord(candidate, 'event', [
+        'kind',
+        'occurredAt',
+        'payload',
+        'projectId',
+        'protocolVersion',
+        'sequence',
+    ]);
+    if (source.protocolVersion !== COLLAB_PROTOCOL_VERSION
+        || typeof source.kind !== 'string'
+        || !EVENT_KIND_SET.has(source.kind))
+        throw invalidPayload('event');
+    const kind = source.kind;
+    return {
+        kind,
+        occurredAt: timestamp(source, 'occurredAt'),
+        payload: decodePayload(kind, source.payload),
+        projectId: stringField(source, 'projectId', 64, isCollabProjectId),
+        protocolVersion: COLLAB_PROTOCOL_VERSION,
+        sequence: positiveInteger(source, 'sequence'),
+    };
+}

package/dist/esm/CollabCloudProjectSnapshot.mjs

@@ -0,0 +1,277 @@
+import { COLLAB_LIMITS, COLLAB_MAIN_REF, } from './CollabConstants.mjs';
+import { COLLAB_CLOUD_BINDING_LIMITS } from './CollabCloudBinding.mjs';
+import { CollabError } from './CollabError.mjs';
+import { collabMemberRef } from './types.mjs';
+import { hasUtf8ByteLengthAtMost, isCollabGitOid, isCollabMemberId, isCollabOpaqueId, isCollabProjectId, } from './CollabValidation.mjs';
+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, required, optional = []) {
+    const source = record(value, field);
+    const allowed = new Set([...required, ...optional]);
+    if (!required.every(key => Object.hasOwn(source, key))
+        || Object.keys(source).some(key => !allowed.has(key)))
+        throw invalidPayload(field);
+    return source;
+}
+function stringField(source, field, maximum, validate, allowEmpty = false) {
+    const value = source[field];
+    if (typeof value !== 'string'
+        || (!allowEmpty && value.length === 0)
+        || value.length > maximum
+        || (validate && !validate(value)))
+        throw invalidPayload(field);
+    return value;
+}
+function textUtf8(source, field, maximum) {
+    const value = source[field];
+    if (typeof value !== 'string'
+        || !hasUtf8ByteLengthAtMost(value, maximum))
+        throw invalidPayload(field);
+    return value;
+}
+function timestamp(source, field) {
+    const value = stringField(source, field, 64);
+    if (Number.isNaN(Date.parse(value)) || new Date(value).toISOString() !== value) {
+        throw invalidPayload(field);
+    }
+    return value;
+}
+function nonNegativeInteger(source, field, maximum) {
+    const value = source[field];
+    if (typeof value !== 'number'
+        || !Number.isSafeInteger(value)
+        || value < 0
+        || (maximum !== undefined && value > maximum))
+        throw invalidPayload(field);
+    return value;
+}
+function positiveInteger(source, field) {
+    const value = nonNegativeInteger(source, field);
+    if (value < 1)
+        throw invalidPayload(field);
+    return value;
+}
+function decodeProject(value) {
+    const source = exactRecord(value, 'project', [
+        'createdAt',
+        'expectedMainOid',
+        'id',
+        'mainRef',
+        'name',
+    ]);
+    if (source.mainRef !== COLLAB_MAIN_REF)
+        throw invalidPayload('mainRef');
+    return {
+        createdAt: timestamp(source, 'createdAt'),
+        expectedMainOid: stringField(source, 'expectedMainOid', 64, isCollabGitOid),
+        id: stringField(source, 'id', 64, isCollabProjectId),
+        mainRef: COLLAB_MAIN_REF,
+        name: stringField(source, 'name', COLLAB_LIMITS.maxProjectNameUtf16),
+    };
+}
+function decodeMember(value) {
+    const source = exactRecord(value, 'member', [
+        'activatedAt',
+        'createdAt',
+        'displayName',
+        'id',
+        'personalRef',
+        'role',
+        'status',
+    ]);
+    const id = stringField(source, 'id', 64, isCollabMemberId);
+    if (source.status !== 'active'
+        || (source.role !== 'manager' && source.role !== 'member'))
+        throw invalidPayload('member');
+    const personalRef = stringField(source, 'personalRef', COLLAB_LIMITS.maxRepositoryPathUtf16);
+    if (personalRef !== collabMemberRef(id))
+        throw invalidPayload('personalRef');
+    return {
+        activatedAt: timestamp(source, 'activatedAt'),
+        createdAt: timestamp(source, 'createdAt'),
+        displayName: stringField(source, 'displayName', COLLAB_LIMITS.maxMemberDisplayNameUtf16),
+        id,
+        personalRef,
+        role: source.role,
+        status: 'active',
+    };
+}
+function decodeRequestTicketRelation(value) {
+    const source = exactRecord(value, 'request.ticketRelations', [
+        'commitOid',
+        'id',
+        'kind',
+        'state',
+        'ticketId',
+        'ticketNumber',
+        'ticketRevision',
+        'ticketTitle',
+    ]);
+    if ((source.kind !== 'references' && source.kind !== 'resolves')
+        || (source.state !== 'pending' && source.state !== 'accepted'))
+        throw invalidPayload('request.ticketRelations');
+    return {
+        commitOid: stringField(source, 'commitOid', 64, isCollabGitOid),
+        id: stringField(source, 'id', 128, isCollabOpaqueId),
+        kind: source.kind,
+        state: source.state,
+        ticketId: stringField(source, 'ticketId', 128, isCollabOpaqueId),
+        ticketNumber: positiveInteger(source, 'ticketNumber'),
+        ticketRevision: positiveInteger(source, 'ticketRevision'),
+        ticketTitle: stringField(source, 'ticketTitle', COLLAB_LIMITS.maxTicketTitleUtf16),
+    };
+}
+function decodeOpenRequest(value) {
+    const source = exactRecord(value, 'openRequest', [
+        'commentCount',
+        'createdAt',
+        'description',
+        'firstBaseOid',
+        'id',
+        'latestHeadOid',
+        'memberId',
+        'revision',
+        'status',
+        'ticketRelations',
+        'updatedAt',
+    ]);
+    if (source.status !== 'open'
+        || !Array.isArray(source.ticketRelations)
+        || source.ticketRelations.length > COLLAB_LIMITS.maxRequestTicketRelations)
+        throw invalidPayload('openRequest');
+    return {
+        commentCount: nonNegativeInteger(source, 'commentCount', COLLAB_LIMITS.maxRequestComments),
+        createdAt: timestamp(source, 'createdAt'),
+        description: textUtf8(source, 'description', COLLAB_LIMITS.maxRequestDescriptionBytes),
+        firstBaseOid: stringField(source, 'firstBaseOid', 64, isCollabGitOid),
+        id: stringField(source, 'id', 128, isCollabOpaqueId),
+        latestHeadOid: stringField(source, 'latestHeadOid', 64, isCollabGitOid),
+        memberId: stringField(source, 'memberId', 64, isCollabMemberId),
+        revision: nonNegativeInteger(source, 'revision'),
+        status: 'open',
+        ticketRelations: source.ticketRelations.map(decodeRequestTicketRelation),
+        updatedAt: timestamp(source, 'updatedAt'),
+    };
+}
+function decodeOpenTicket(value) {
+    const source = exactRecord(value, 'ticketHighlight', [
+        'acceptedRelationCount',
+        'authorMemberId',
+        'commentCount',
+        'createdAt',
+        'id',
+        'number',
+        'revision',
+        'status',
+        'title',
+        'updatedAt',
+    ]);
+    if (source.status !== 'open')
+        throw invalidPayload('ticketHighlight');
+    return {
+        acceptedRelationCount: nonNegativeInteger(source, 'acceptedRelationCount', COLLAB_LIMITS.maxTicketAcceptedRelations),
+        authorMemberId: stringField(source, 'authorMemberId', 64, isCollabMemberId),
+        commentCount: nonNegativeInteger(source, 'commentCount', COLLAB_LIMITS.maxTicketComments),
+        createdAt: timestamp(source, 'createdAt'),
+        id: stringField(source, 'id', 128, isCollabOpaqueId),
+        number: positiveInteger(source, 'number'),
+        revision: nonNegativeInteger(source, 'revision'),
+        status: 'open',
+        title: stringField(source, 'title', COLLAB_LIMITS.maxTicketTitleUtf16),
+        updatedAt: timestamp(source, 'updatedAt'),
+    };
+}
+function assertSnapshotSize(value) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        throw invalidPayload('snapshot');
+    }
+    if (!hasUtf8ByteLengthAtMost(serialized, COLLAB_CLOUD_BINDING_LIMITS.maxCloudSnapshotUtf8Bytes))
+        throw invalidPayload('snapshot');
+}
+export function decodeCollabCloudProjectSnapshot(value) {
+    assertSnapshotSize(value);
+    const source = exactRecord(value, 'snapshot', [
+        'currentMember',
+        'eventSequence',
+        'members',
+        'openRequests',
+        'openTicketCount',
+        'project',
+        'ticketHighlights',
+    ]);
+    if (!Array.isArray(source.members)
+        || source.members.length < 1
+        || source.members.length > COLLAB_CLOUD_BINDING_LIMITS.maxCloudProjectMembers
+        || !Array.isArray(source.openRequests)
+        || source.openRequests.length > COLLAB_CLOUD_BINDING_LIMITS.maxCloudOpenRequests
+        || !Array.isArray(source.ticketHighlights)
+        || source.ticketHighlights.length > COLLAB_CLOUD_BINDING_LIMITS.maxCloudTicketHighlights)
+        throw invalidPayload('snapshotCollections');
+    const members = source.members.map(decodeMember);
+    if (members.some((item, index) => (index > 0 && members[index - 1].id.localeCompare(item.id, 'en-US') >= 0)))
+        throw invalidPayload('members');
+    const currentMember = decodeMember(source.currentMember);
+    const matchingMember = members.find(member => member.id === currentMember.id);
+    if (!matchingMember || JSON.stringify(matchingMember) !== JSON.stringify(currentMember)) {
+        throw invalidPayload('currentMember');
+    }
+    const openRequests = source.openRequests.map(decodeOpenRequest);
+    if (openRequests.some((item, index) => ((index > 0 && openRequests[index - 1].id.localeCompare(item.id, 'en-US') >= 0)
+        || !members.some(member => member.id === item.memberId))))
+        throw invalidPayload('openRequests');
+    const ticketHighlights = source.ticketHighlights.map(decodeOpenTicket);
+    if (ticketHighlights.some((item, index) => {
+        if (index === 0)
+            return false;
+        const previous = ticketHighlights[index - 1];
+        return previous.updatedAt < item.updatedAt
+            || (previous.updatedAt === item.updatedAt
+                && previous.id.localeCompare(item.id, 'en-US') >= 0);
+    }))
+        throw invalidPayload('ticketHighlights');
+    const openTicketCount = nonNegativeInteger(source, 'openTicketCount');
+    if (openTicketCount < ticketHighlights.length)
+        throw invalidPayload('openTicketCount');
+    return {
+        currentMember,
+        eventSequence: nonNegativeInteger(source, 'eventSequence'),
+        members,
+        openRequests,
+        openTicketCount,
+        project: decodeProject(source.project),
+        ticketHighlights,
+    };
+}
+function decodeSnapshotRequest(value) {
+    try {
+        const source = exactRecord(value, 'request', ['projectId']);
+        return {
+            status: 'ok',
+            value: { projectId: stringField(source, 'projectId', 64, isCollabProjectId) },
+        };
+    }
+    catch (error) {
+        return {
+            status: 'invalid',
+            error: error instanceof CollabError ? error : invalidPayload('request'),
+        };
+    }
+}
+export const COLLAB_CLOUD_PROJECT_SNAPSHOT_CODEC = Object.freeze({
+    decodeRequest: decodeSnapshotRequest,
+    decodeResponse: decodeCollabCloudProjectSnapshot,
+});

package/dist/esm/CollabConstants.mjs

@@ -0,0 +1,31 @@
+export const COLLAB_PROTOCOL_VERSION = 6;
+export const COLLAB_MAIN_REF = 'refs/heads/main';
+export const COLLAB_MEMBER_REF_PREFIX = 'refs/heads/members/';
+export const COLLAB_LIMITS = Object.freeze({
+    maxBlobBytes: 50 * 1024 * 1024,
+    maxChangedPaths: 2_000,
+    maxCommentBytes: 16 * 1024,
+    maxMemberDisplayNameUtf16: 200,
+    maxRequestDescriptionBytes: 16 * 1024,
+    maxProjectNameUtf16: 200,
+    maxTicketTitleUtf16: 200,
+    maxTicketBodyBytes: 32 * 1024,
+    maxTicketCommentBytes: 16 * 1024,
+    maxRequestTicketRelations: 32,
+    maxRequestComments: 500,
+    defaultTicketPageSize: 50,
+    maxTicketPageSize: 100,
+    maxTicketComments: 500,
+    maxTicketAcceptedRelations: 2_000,
+    defaultCommentPageSize: 50,
+    maxCommentPageSize: 100,
+    commentPageMaxUtf8Bytes: 128 * 1024,
+    maxRelationsPerPage: 100,
+    relationPageMaxUtf8Bytes: 96 * 1024,
+    ticketPageMaxUtf8Bytes: 96 * 1024,
+    detailMaxUtf8Bytes: 448 * 1024,
+    maxJsonPayloadUtf8Bytes: 512 * 1024,
+    maxPageCursorUtf16: 512,
+    maxPathSegmentUtf16: 120,
+    maxRepositoryPathUtf16: 240,
+});

package/dist/esm/CollabControlOperationCodecs.mjs

@@ -0,0 +1,106 @@
+import { COLLAB_AUTHORITY_TRANSFER_OPERATIONS, decodeCollabAuthorityTransferOperationRequest, decodeCollabAuthorityTransferOperationResponse, } from './CollabAuthorityTransfer.mjs';
+import { CollabError } from './CollabError.mjs';
+import { COLLAB_PROJECT_MEMBERSHIP_OPERATION_CODECS } from './CollabProjectMembership.mjs';
+import { COLLAB_PROJECT_RETIREMENT_OPERATIONS, decodeCollabProjectRetirementOperationRequest, decodeCollabProjectRetirementOperationResponse, } from './CollabProjectRetirement.mjs';
+import { decodeCollabRequestTicketOperationRequest, } from './CollabRequestTicketRequestCodecs.mjs';
+import { decodeAcceptResponse, decodeCommentPageResponse, decodeCreateCommentResponse, decodeCreateTicketResponse, decodeEnsureMyRequestResponse, decodeRequestDetailResponse, decodeTicketAcceptedRelationPageResponse, decodeTicketCommentPageResponse, decodeTicketCommentResponse, decodeTicketDetailResponse, decodeTicketMutationResponse, decodeTicketPageResponse, decodeUpdateRequestMetadataResponse, } from './CollabRequestTicketResponseCodecs.mjs';
+const AUTHORITY_TRANSFER_OPERATION_SET = new Set(COLLAB_AUTHORITY_TRANSFER_OPERATIONS);
+const PROJECT_RETIREMENT_OPERATION_SET = new Set(COLLAB_PROJECT_RETIREMENT_OPERATIONS);
+function lifecycleDecodeResult(decode) {
+    try {
+        return { status: 'ok', value: decode() };
+    }
+    catch (error) {
+        if (error instanceof CollabError && error.code === 'protocol-payload-invalid') {
+            return { error, status: 'invalid' };
+        }
+        throw error;
+    }
+}
+function decodeRequest(operation, input) {
+    if (AUTHORITY_TRANSFER_OPERATION_SET.has(operation)) {
+        return lifecycleDecodeResult(() => decodeCollabAuthorityTransferOperationRequest(operation, input));
+    }
+    if (PROJECT_RETIREMENT_OPERATION_SET.has(operation)) {
+        return lifecycleDecodeResult(() => decodeCollabProjectRetirementOperationRequest(operation, input));
+    }
+    return decodeCollabRequestTicketOperationRequest(operation, input);
+}
+function decodeResponse(operation, input) {
+    if (AUTHORITY_TRANSFER_OPERATION_SET.has(operation)) {
+        return decodeCollabAuthorityTransferOperationResponse(operation, input);
+    }
+    if (PROJECT_RETIREMENT_OPERATION_SET.has(operation)) {
+        return decodeCollabProjectRetirementOperationResponse(operation, input);
+    }
+    switch (operation) {
+        case 'getRequest': return decodeRequestDetailResponse(input);
+        case 'listRequestComments': return decodeCommentPageResponse(input);
+        case 'ensureMyRequest': return decodeEnsureMyRequestResponse(input);
+        case 'createComment': return decodeCreateCommentResponse(input);
+        case 'listTickets': return decodeTicketPageResponse(input);
+        case 'getTicket': return decodeTicketDetailResponse(input);
+        case 'listTicketComments': return decodeTicketCommentPageResponse(input);
+        case 'listTicketAcceptedRelations':
+            return decodeTicketAcceptedRelationPageResponse(input);
+        case 'createTicket': return decodeCreateTicketResponse(input);
+        case 'updateTicketContent': return decodeTicketMutationResponse(input);
+        case 'createTicketComment': return decodeTicketCommentResponse(input);
+        case 'closeTicket': return decodeTicketMutationResponse(input);
+        case 'reopenTicket': return decodeTicketMutationResponse(input);
+        case 'updateMyRequestMetadata': return decodeUpdateRequestMetadataResponse(input);
+        case 'acceptRequest': return decodeAcceptResponse(input);
+    }
+}
+function codec(operation) {
+    return Object.freeze({
+        decodeRequest: (input) => decodeRequest(operation, input),
+        decodeResponse: (input) => decodeResponse(operation, input),
+    });
+}
+export const COLLAB_CONTROL_OPERATION_CODECS = Object.freeze({
+    getRequest: codec('getRequest'),
+    listRequestComments: codec('listRequestComments'),
+    ensureMyRequest: codec('ensureMyRequest'),
+    createComment: codec('createComment'),
+    listTickets: codec('listTickets'),
+    getTicket: codec('getTicket'),
+    listTicketComments: codec('listTicketComments'),
+    listTicketAcceptedRelations: codec('listTicketAcceptedRelations'),
+    createTicket: codec('createTicket'),
+    updateTicketContent: codec('updateTicketContent'),
+    createTicketComment: codec('createTicketComment'),
+    closeTicket: codec('closeTicket'),
+    reopenTicket: codec('reopenTicket'),
+    updateMyRequestMetadata: codec('updateMyRequestMetadata'),
+    acceptRequest: codec('acceptRequest'),
+    requestLanToCloudTransfer: codec('requestLanToCloudTransfer'),
+    acceptLanToCloudTransferTarget: codec('acceptLanToCloudTransferTarget'),
+    beginLanToCloudTransfer: codec('beginLanToCloudTransfer'),
+    getProjectAuthorityTransfer: codec('getProjectAuthorityTransfer'),
+    getAuthorityTransferReceiptVerifier: codec('getAuthorityTransferReceiptVerifier'),
+    rotateTransferredMembershipClaims: codec('rotateTransferredMembershipClaims'),
+    acknowledgeTransferredMembershipClaimBatch: codec('acknowledgeTransferredMembershipClaimBatch'),
+    getTransferredMembershipClaim: codec('getTransferredMembershipClaim'),
+    claimTransferredMembership: codec('claimTransferredMembership'),
+    acknowledgeTransferredMembershipClaimRedemption: codec('acknowledgeTransferredMembershipClaimRedemption'),
+    commitLanToCloudRelinquishment: codec('commitLanToCloudRelinquishment'),
+    beginCloudToLanTransfer: codec('beginCloudToLanTransfer'),
+    acceptCloudToLanTransferTarget: codec('acceptCloudToLanTransferTarget'),
+    reportCloudToLanTargetStaged: codec('reportCloudToLanTargetStaged'),
+    confirmCloudToLanTargetActive: codec('confirmCloudToLanTargetActive'),
+    cancelProjectAuthorityTransfer: codec('cancelProjectAuthorityTransfer'),
+    retireProject: codec('retireProject'),
+    acknowledgeProjectRetirement: codec('acknowledgeProjectRetirement'),
+    ...COLLAB_PROJECT_MEMBERSHIP_OPERATION_CODECS,
+});
+export function collabControlOperationCodec(operation) {
+    if (!Object.hasOwn(COLLAB_CONTROL_OPERATION_CODECS, operation)) {
+        throw new CollabError({
+            code: 'operation-failed',
+            safeContext: { reason: 'control-operation-codec-missing' },
+        });
+    }
+    const selected = COLLAB_CONTROL_OPERATION_CODECS[operation];
+    return selected;
+}