@claudian-collab/protocol 1.0.0

package/dist/CollabCloudProjectEvent.d.ts

@@ -0,0 +1,41 @@
+import { COLLAB_PROTOCOL_VERSION } from './CollabConstants';
+import type { CollabGitOid, CollabIsoTimestamp, CollabMemberId, CollabProjectId, CollabRequestId, CollabTicketId } from './types';
+export declare const COLLAB_CLOUD_EVENT_KINDS: readonly ["membership.updated", "request.updated", "request.comment-added", "ticket.updated", "ticket.comment-added", "main.updated"];
+export type CollabCloudEventKind = typeof COLLAB_CLOUD_EVENT_KINDS[number];
+export interface CollabCloudEventPayloadMap {
+    readonly 'main.updated': {
+        readonly mainOid: CollabGitOid;
+        readonly requestId: CollabRequestId;
+    };
+    readonly 'membership.updated': {
+        readonly memberId: CollabMemberId;
+    };
+    readonly 'request.comment-added': {
+        readonly requestId: CollabRequestId;
+    };
+    readonly 'request.updated': {
+        readonly requestId: CollabRequestId;
+    };
+    readonly 'ticket.comment-added': {
+        readonly ticketId: CollabTicketId;
+    };
+    readonly 'ticket.updated': {
+        readonly ticketId: CollabTicketId;
+    };
+}
+export type CollabCloudProjectEvent = {
+    readonly [Kind in CollabCloudEventKind]: {
+        readonly kind: Kind;
+        readonly occurredAt: CollabIsoTimestamp;
+        readonly payload: CollabCloudEventPayloadMap[Kind];
+        readonly projectId: CollabProjectId;
+        readonly protocolVersion: typeof COLLAB_PROTOCOL_VERSION;
+        readonly sequence: number;
+    };
+}[CollabCloudEventKind];
+export interface CollabCloudSnapshotRequired {
+    readonly kind: 'snapshot.required';
+    readonly latestSequence: number;
+}
+export type CollabCloudProjectEventMessage = CollabCloudProjectEvent | CollabCloudSnapshotRequired;
+export declare function decodeCollabCloudProjectEventMessage(value: unknown): CollabCloudProjectEventMessage;

package/dist/CollabCloudProjectEvent.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLLAB_CLOUD_EVENT_KINDS = void 0;
+exports.decodeCollabCloudProjectEventMessage = decodeCollabCloudProjectEventMessage;
+const CollabConstants_1 = require("./CollabConstants");
+const CollabError_1 = require("./CollabError");
+const CollabValidation_1 = require("./CollabValidation");
+exports.COLLAB_CLOUD_EVENT_KINDS = Object.freeze([
+    'membership.updated',
+    'request.updated',
+    'request.comment-added',
+    'ticket.updated',
+    'ticket.comment-added',
+    'main.updated',
+]);
+const EVENT_KIND_SET = new Set(exports.COLLAB_CLOUD_EVENT_KINDS);
+function invalidPayload(field) {
+    return new CollabError_1.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 'membership.updated': {
+            const source = exactRecord(value, 'payload', ['memberId']);
+            return { memberId: stringField(source, 'memberId', 64, CollabValidation_1.isCollabMemberId) };
+        }
+        case 'request.updated':
+        case 'request.comment-added': {
+            const source = exactRecord(value, 'payload', ['requestId']);
+            return { requestId: stringField(source, 'requestId', 128, CollabValidation_1.isCollabOpaqueId) };
+        }
+        case 'ticket.updated':
+        case 'ticket.comment-added': {
+            const source = exactRecord(value, 'payload', ['ticketId']);
+            return { ticketId: stringField(source, 'ticketId', 128, CollabValidation_1.isCollabOpaqueId) };
+        }
+        case 'main.updated': {
+            const source = exactRecord(value, 'payload', ['mainOid', 'requestId']);
+            return {
+                mainOid: stringField(source, 'mainOid', 64, CollabValidation_1.isCollabGitOid),
+                requestId: stringField(source, 'requestId', 128, CollabValidation_1.isCollabOpaqueId),
+            };
+        }
+    }
+}
+function decodeCollabCloudProjectEventMessage(value) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        throw invalidPayload('event');
+    }
+    if (!(0, CollabValidation_1.hasUtf8ByteLengthAtMost)(serialized, CollabConstants_1.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 !== CollabConstants_1.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, CollabValidation_1.isCollabProjectId),
+        protocolVersion: CollabConstants_1.COLLAB_PROTOCOL_VERSION,
+        sequence: positiveInteger(source, 'sequence'),
+    };
+}

package/dist/CollabCloudProjectSnapshot.d.ts

@@ -0,0 +1,42 @@
+import { COLLAB_MAIN_REF } from './CollabConstants';
+import type { CollabDecodeResult } from './CollabProtocol';
+import type { CollabChangeRequest, CollabGitOid, CollabIsoTimestamp, CollabMemberId, CollabProjectId, CollabRole, CollabTicketSummary } from './types';
+export interface CollabCloudProjectSummary {
+    readonly createdAt: CollabIsoTimestamp;
+    readonly expectedMainOid: CollabGitOid;
+    readonly id: CollabProjectId;
+    readonly mainRef: typeof COLLAB_MAIN_REF;
+    readonly name: string;
+}
+export interface CollabCloudProjectMember {
+    readonly activatedAt: CollabIsoTimestamp;
+    readonly createdAt: CollabIsoTimestamp;
+    readonly displayName: string;
+    readonly id: CollabMemberId;
+    readonly personalRef: string;
+    readonly role: CollabRole;
+    readonly status: 'active';
+}
+export interface CollabCloudProjectSnapshot {
+    readonly currentMember: CollabCloudProjectMember;
+    readonly eventSequence: number;
+    readonly members: readonly CollabCloudProjectMember[];
+    readonly openRequests: readonly CollabChangeRequest[];
+    readonly openTicketCount: number;
+    readonly project: CollabCloudProjectSummary;
+    readonly ticketHighlights: readonly CollabTicketSummary[];
+}
+export interface GetCollabCloudProjectSnapshotRequest {
+    readonly projectId: CollabProjectId;
+}
+export interface CollabCloudProjectSnapshotCodec {
+    readonly decodeRequest: (value: unknown) => CollabDecodeResult<GetCollabCloudProjectSnapshotRequest>;
+    readonly decodeResponse: (value: unknown) => CollabCloudProjectSnapshot;
+}
+export declare function decodeCollabCloudProjectSnapshot(value: unknown): CollabCloudProjectSnapshot;
+declare function decodeSnapshotRequest(value: unknown): CollabDecodeResult<GetCollabCloudProjectSnapshotRequest>;
+export declare const COLLAB_CLOUD_PROJECT_SNAPSHOT_CODEC: Readonly<{
+    readonly decodeRequest: typeof decodeSnapshotRequest;
+    readonly decodeResponse: typeof decodeCollabCloudProjectSnapshot;
+}>;
+export {};

package/dist/CollabCloudProjectSnapshot.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLLAB_CLOUD_PROJECT_SNAPSHOT_CODEC = void 0;
+exports.decodeCollabCloudProjectSnapshot = decodeCollabCloudProjectSnapshot;
+const CollabConstants_1 = require("./CollabConstants");
+const CollabCloudBinding_1 = require("./CollabCloudBinding");
+const CollabError_1 = require("./CollabError");
+const types_1 = require("./types");
+const CollabValidation_1 = require("./CollabValidation");
+function invalidPayload(field) {
+    return new CollabError_1.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'
+        || !(0, CollabValidation_1.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 !== CollabConstants_1.COLLAB_MAIN_REF)
+        throw invalidPayload('mainRef');
+    return {
+        createdAt: timestamp(source, 'createdAt'),
+        expectedMainOid: stringField(source, 'expectedMainOid', 64, CollabValidation_1.isCollabGitOid),
+        id: stringField(source, 'id', 64, CollabValidation_1.isCollabProjectId),
+        mainRef: CollabConstants_1.COLLAB_MAIN_REF,
+        name: stringField(source, 'name', CollabConstants_1.COLLAB_LIMITS.maxProjectNameUtf16),
+    };
+}
+function decodeMember(value) {
+    const source = exactRecord(value, 'member', [
+        'activatedAt',
+        'createdAt',
+        'displayName',
+        'id',
+        'personalRef',
+        'role',
+        'status',
+    ]);
+    const id = stringField(source, 'id', 64, CollabValidation_1.isCollabMemberId);
+    if (source.status !== 'active'
+        || (source.role !== 'manager' && source.role !== 'member'))
+        throw invalidPayload('member');
+    const personalRef = stringField(source, 'personalRef', CollabConstants_1.COLLAB_LIMITS.maxRepositoryPathUtf16);
+    if (personalRef !== (0, types_1.collabMemberRef)(id))
+        throw invalidPayload('personalRef');
+    return {
+        activatedAt: timestamp(source, 'activatedAt'),
+        createdAt: timestamp(source, 'createdAt'),
+        displayName: stringField(source, 'displayName', CollabConstants_1.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, CollabValidation_1.isCollabGitOid),
+        id: stringField(source, 'id', 128, CollabValidation_1.isCollabOpaqueId),
+        kind: source.kind,
+        state: source.state,
+        ticketId: stringField(source, 'ticketId', 128, CollabValidation_1.isCollabOpaqueId),
+        ticketNumber: positiveInteger(source, 'ticketNumber'),
+        ticketRevision: positiveInteger(source, 'ticketRevision'),
+        ticketTitle: stringField(source, 'ticketTitle', CollabConstants_1.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 > CollabConstants_1.COLLAB_LIMITS.maxRequestTicketRelations)
+        throw invalidPayload('openRequest');
+    return {
+        commentCount: nonNegativeInteger(source, 'commentCount', CollabConstants_1.COLLAB_LIMITS.maxRequestComments),
+        createdAt: timestamp(source, 'createdAt'),
+        description: textUtf8(source, 'description', CollabConstants_1.COLLAB_LIMITS.maxRequestDescriptionBytes),
+        firstBaseOid: stringField(source, 'firstBaseOid', 64, CollabValidation_1.isCollabGitOid),
+        id: stringField(source, 'id', 128, CollabValidation_1.isCollabOpaqueId),
+        latestHeadOid: stringField(source, 'latestHeadOid', 64, CollabValidation_1.isCollabGitOid),
+        memberId: stringField(source, 'memberId', 64, CollabValidation_1.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', CollabConstants_1.COLLAB_LIMITS.maxTicketAcceptedRelations),
+        authorMemberId: stringField(source, 'authorMemberId', 64, CollabValidation_1.isCollabMemberId),
+        commentCount: nonNegativeInteger(source, 'commentCount', CollabConstants_1.COLLAB_LIMITS.maxTicketComments),
+        createdAt: timestamp(source, 'createdAt'),
+        id: stringField(source, 'id', 128, CollabValidation_1.isCollabOpaqueId),
+        number: positiveInteger(source, 'number'),
+        revision: nonNegativeInteger(source, 'revision'),
+        status: 'open',
+        title: stringField(source, 'title', CollabConstants_1.COLLAB_LIMITS.maxTicketTitleUtf16),
+        updatedAt: timestamp(source, 'updatedAt'),
+    };
+}
+function assertSnapshotSize(value) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        throw invalidPayload('snapshot');
+    }
+    if (!(0, CollabValidation_1.hasUtf8ByteLengthAtMost)(serialized, CollabCloudBinding_1.COLLAB_CLOUD_BINDING_LIMITS.maxCloudSnapshotUtf8Bytes))
+        throw invalidPayload('snapshot');
+}
+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 > CollabCloudBinding_1.COLLAB_CLOUD_BINDING_LIMITS.maxCloudProjectMembers
+        || !Array.isArray(source.openRequests)
+        || source.openRequests.length > CollabCloudBinding_1.COLLAB_CLOUD_BINDING_LIMITS.maxCloudOpenRequests
+        || !Array.isArray(source.ticketHighlights)
+        || source.ticketHighlights.length > CollabCloudBinding_1.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, CollabValidation_1.isCollabProjectId) },
+        };
+    }
+    catch (error) {
+        return {
+            status: 'invalid',
+            error: error instanceof CollabError_1.CollabError ? error : invalidPayload('request'),
+        };
+    }
+}
+exports.COLLAB_CLOUD_PROJECT_SNAPSHOT_CODEC = Object.freeze({
+    decodeRequest: decodeSnapshotRequest,
+    decodeResponse: decodeCollabCloudProjectSnapshot,
+});

package/dist/CollabConstants.d.ts

@@ -0,0 +1,32 @@
+export declare const COLLAB_PROTOCOL_VERSION: 4;
+export declare const COLLAB_MAIN_REF: "refs/heads/main";
+export declare const COLLAB_MEMBER_REF_PREFIX: "refs/heads/members/";
+export declare const COLLAB_LIMITS: Readonly<{
+    maxBlobBytes: number;
+    maxChangedPaths: 2000;
+    maxCommentBytes: number;
+    maxMemberDisplayNameUtf16: 200;
+    maxRequestDescriptionBytes: number;
+    maxProjectNameUtf16: 200;
+    maxTicketTitleUtf16: 200;
+    maxTicketBodyBytes: number;
+    maxTicketCommentBytes: number;
+    maxRequestTicketRelations: 32;
+    maxRequestComments: 500;
+    defaultTicketPageSize: 50;
+    maxTicketPageSize: 100;
+    maxTicketComments: 500;
+    maxTicketAcceptedRelations: 2000;
+    defaultCommentPageSize: 50;
+    maxCommentPageSize: 100;
+    commentPageMaxUtf8Bytes: number;
+    maxRelationsPerPage: 100;
+    relationPageMaxUtf8Bytes: number;
+    ticketPageMaxUtf8Bytes: number;
+    detailMaxUtf8Bytes: number;
+    maxJsonPayloadUtf8Bytes: number;
+    maxPageCursorUtf16: 512;
+    maxPathSegmentUtf16: 120;
+    maxRepositoryPathUtf16: 240;
+}>;
+export type CollabProtocolVersion = typeof COLLAB_PROTOCOL_VERSION;

package/dist/CollabConstants.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLLAB_LIMITS = exports.COLLAB_MEMBER_REF_PREFIX = exports.COLLAB_MAIN_REF = exports.COLLAB_PROTOCOL_VERSION = void 0;
+exports.COLLAB_PROTOCOL_VERSION = 4;
+exports.COLLAB_MAIN_REF = 'refs/heads/main';
+exports.COLLAB_MEMBER_REF_PREFIX = 'refs/heads/members/';
+exports.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/CollabControlOperationCodecs.d.ts

@@ -0,0 +1,28 @@
+import { type CollabControlOperationMap, type CollabDecodeResult } from './CollabProtocol';
+export type CollabControlOperation = keyof CollabControlOperationMap;
+export interface CollabControlOperationCodec<Request, Response> {
+    readonly decodeRequest: (input: unknown) => CollabDecodeResult<Request>;
+    readonly decodeResponse: (input: unknown) => Response;
+}
+type CodecMap = {
+    readonly [Operation in CollabControlOperation]: CollabControlOperationCodec<CollabControlOperationMap[Operation]['request'], CollabControlOperationMap[Operation]['response']>;
+};
+export declare const COLLAB_CONTROL_OPERATION_CODECS: Readonly<{
+    readonly getRequest: CollabControlOperationCodec<import("./CollabProtocol").GetRequestRequest, import("./types").CollabRequestDetail>;
+    readonly listRequestComments: CollabControlOperationCodec<import("./CollabProtocol").ListRequestCommentsRequest, import("./types").CollabCommentPage>;
+    readonly ensureMyRequest: CollabControlOperationCodec<import("./CollabProtocol").EnsureMyRequestRequest, import("./CollabProtocol").EnsureMyRequestResponse>;
+    readonly createComment: CollabControlOperationCodec<import("./CollabProtocol").CreateCommentRequest, import("./CollabProtocol").CreateCommentResponse>;
+    readonly listTickets: CollabControlOperationCodec<import("./CollabProtocol").ListTicketsRequest, import("./types").CollabTicketPage>;
+    readonly getTicket: CollabControlOperationCodec<import("./CollabProtocol").GetTicketRequest, import("./types").CollabTicketDetail>;
+    readonly listTicketComments: CollabControlOperationCodec<import("./CollabProtocol").ListTicketCommentsRequest, import("./types").CollabTicketCommentPage>;
+    readonly listTicketAcceptedRelations: CollabControlOperationCodec<import("./CollabProtocol").ListTicketAcceptedRelationsRequest, import("./types").CollabTicketAcceptedRelationPage>;
+    readonly createTicket: CollabControlOperationCodec<import("./CollabProtocol").CreateTicketRequest, import("./CollabProtocol").CreateTicketResponse>;
+    readonly updateTicketContent: CollabControlOperationCodec<import("./CollabProtocol").UpdateTicketContentRequest, import("./CollabProtocol").TicketMutationResponse>;
+    readonly createTicketComment: CollabControlOperationCodec<import("./CollabProtocol").CreateTicketCommentRequest, import("./CollabProtocol").CreateTicketCommentResponse>;
+    readonly closeTicket: CollabControlOperationCodec<import("./CollabProtocol").ChangeTicketStatusRequest, import("./CollabProtocol").TicketMutationResponse>;
+    readonly reopenTicket: CollabControlOperationCodec<import("./CollabProtocol").ChangeTicketStatusRequest, import("./CollabProtocol").TicketMutationResponse>;
+    readonly updateMyRequestMetadata: CollabControlOperationCodec<import("./CollabProtocol").UpdateMyRequestMetadataRequest, import("./CollabProtocol").UpdateMyRequestMetadataResponse>;
+    readonly acceptRequest: CollabControlOperationCodec<import("./CollabProtocol").AcceptRequest, import("./CollabProtocol").AcceptResponse>;
+}>;
+export declare function collabControlOperationCodec<Operation extends CollabControlOperation>(operation: Operation): CodecMap[Operation];
+export {};

package/dist/CollabControlOperationCodecs.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COLLAB_CONTROL_OPERATION_CODECS = void 0;
+exports.collabControlOperationCodec = collabControlOperationCodec;
+const CollabError_1 = require("./CollabError");
+const CollabRequestTicketRequestCodecs_1 = require("./CollabRequestTicketRequestCodecs");
+const CollabRequestTicketResponseCodecs_1 = require("./CollabRequestTicketResponseCodecs");
+function decodeRequest(operation, input) {
+    return (0, CollabRequestTicketRequestCodecs_1.decodeCollabRequestTicketOperationRequest)(operation, input);
+}
+function decodeResponse(operation, input) {
+    switch (operation) {
+        case 'getRequest': return (0, CollabRequestTicketResponseCodecs_1.decodeRequestDetailResponse)(input);
+        case 'listRequestComments': return (0, CollabRequestTicketResponseCodecs_1.decodeCommentPageResponse)(input);
+        case 'ensureMyRequest': return (0, CollabRequestTicketResponseCodecs_1.decodeEnsureMyRequestResponse)(input);
+        case 'createComment': return (0, CollabRequestTicketResponseCodecs_1.decodeCreateCommentResponse)(input);
+        case 'listTickets': return (0, CollabRequestTicketResponseCodecs_1.decodeTicketPageResponse)(input);
+        case 'getTicket': return (0, CollabRequestTicketResponseCodecs_1.decodeTicketDetailResponse)(input);
+        case 'listTicketComments': return (0, CollabRequestTicketResponseCodecs_1.decodeTicketCommentPageResponse)(input);
+        case 'listTicketAcceptedRelations':
+            return (0, CollabRequestTicketResponseCodecs_1.decodeTicketAcceptedRelationPageResponse)(input);
+        case 'createTicket': return (0, CollabRequestTicketResponseCodecs_1.decodeCreateTicketResponse)(input);
+        case 'updateTicketContent': return (0, CollabRequestTicketResponseCodecs_1.decodeTicketMutationResponse)(input);
+        case 'createTicketComment': return (0, CollabRequestTicketResponseCodecs_1.decodeTicketCommentResponse)(input);
+        case 'closeTicket': return (0, CollabRequestTicketResponseCodecs_1.decodeTicketMutationResponse)(input);
+        case 'reopenTicket': return (0, CollabRequestTicketResponseCodecs_1.decodeTicketMutationResponse)(input);
+        case 'updateMyRequestMetadata': return (0, CollabRequestTicketResponseCodecs_1.decodeUpdateRequestMetadataResponse)(input);
+        case 'acceptRequest': return (0, CollabRequestTicketResponseCodecs_1.decodeAcceptResponse)(input);
+    }
+}
+function codec(operation) {
+    return Object.freeze({
+        decodeRequest: (input) => decodeRequest(operation, input),
+        decodeResponse: (input) => decodeResponse(operation, input),
+    });
+}
+exports.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'),
+});
+function collabControlOperationCodec(operation) {
+    if (!Object.hasOwn(exports.COLLAB_CONTROL_OPERATION_CODECS, operation)) {
+        throw new CollabError_1.CollabError({
+            code: 'operation-failed',
+            safeContext: { reason: 'control-operation-codec-missing' },
+        });
+    }
+    const selected = exports.COLLAB_CONTROL_OPERATION_CODECS[operation];
+    return selected;
+}