@claudian-collab/protocol 3.2.0 → 3.2.1

package/dist/esm/DevelopmentBootstrap.mjs

@@ -0,0 +1,537 @@
+import { COLLAB_LIMITS, COLLAB_MAIN_REF, COLLAB_PROTOCOL_VERSION, } 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';
+export const DEVELOPMENT_BOOTSTRAP_MANIFEST_SCHEMA_VERSION = 1;
+export const DEVELOPMENT_BOOTSTRAP_ATTEMPT_STATES = Object.freeze([
+    'collecting',
+    'validating',
+    'ready',
+    'activating',
+    'rejected',
+    'cancelled',
+    'recovery-required',
+    'activated',
+]);
+export const DEVELOPMENT_BOOTSTRAP_ACTIVATION_PHASES = Object.freeze([
+    'publish-intent',
+    'repository-published',
+    'activated',
+    'completed',
+]);
+export const DEVELOPMENT_BOOTSTRAP_CANCELLATION_PHASES = Object.freeze([
+    'cancel-intent',
+    'cancelled',
+    'recovery-required',
+]);
+export const DEVELOPMENT_BOOTSTRAP_OPERATIONS = Object.freeze([
+    'beginDevelopmentBootstrap',
+    'submitDevelopmentBootstrapReport',
+    'getDevelopmentBootstrap',
+    'activateDevelopmentBootstrap',
+    'cancelDevelopmentBootstrap',
+    'putDevelopmentBootstrapGitBundle',
+]);
+const ATTEMPT_STATE_SET = new Set(DEVELOPMENT_BOOTSTRAP_ATTEMPT_STATES);
+const ACTIVATION_PHASE_SET = new Set(DEVELOPMENT_BOOTSTRAP_ACTIVATION_PHASES);
+const CANCELLATION_PHASE_SET = new Set(DEVELOPMENT_BOOTSTRAP_CANCELLATION_PHASES);
+const SHA256_PATTERN = /^[0-9a-f]{64}$/u;
+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 exactRecordWithOptional(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) {
+    const value = source[field];
+    if (typeof value !== 'string'
+        || value.length === 0
+        || value.length > maximum
+        || (validate && !validate(value)))
+        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) {
+    const value = source[field];
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        throw invalidPayload(field);
+    }
+    return value;
+}
+function positiveInteger(source, field, maximum) {
+    const value = nonNegativeInteger(source, field);
+    if (value < 1 || (maximum !== undefined && value > maximum)) {
+        throw invalidPayload(field);
+    }
+    return value;
+}
+function exactTrue(source, field) {
+    if (source[field] !== true)
+        throw invalidPayload(field);
+    return true;
+}
+function sha256(source, field) {
+    return stringField(source, field, 64, value => SHA256_PATTERN.test(value));
+}
+function assertSerializedLimit(value, maximum, field) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        throw invalidPayload(field);
+    }
+    if (!hasUtf8ByteLengthAtMost(serialized, maximum))
+        throw invalidPayload(field);
+}
+function decodeComparisonMember(value) {
+    const source = exactRecord(value, 'comparison.members', [
+        'activatedAt',
+        'createdAt',
+        'displayName',
+        'memberId',
+        'personalRef',
+        'role',
+        'status',
+    ]);
+    const memberId = stringField(source, 'memberId', 64, isCollabMemberId);
+    const role = source.role;
+    if (role !== 'manager' && role !== 'member')
+        throw invalidPayload('role');
+    if (source.status !== 'active')
+        throw invalidPayload('status');
+    const personalRef = stringField(source, 'personalRef', COLLAB_LIMITS.maxRepositoryPathUtf16);
+    if (personalRef !== collabMemberRef(memberId))
+        throw invalidPayload('personalRef');
+    return {
+        activatedAt: timestamp(source, 'activatedAt'),
+        createdAt: timestamp(source, 'createdAt'),
+        displayName: stringField(source, 'displayName', COLLAB_LIMITS.maxMemberDisplayNameUtf16),
+        memberId,
+        personalRef,
+        role,
+        status: 'active',
+    };
+}
+function decodeComparison(value) {
+    const source = exactRecord(value, 'comparison', [
+        'mainOid',
+        'mainRef',
+        'managerSetGeneration',
+        'members',
+        'projectCreatedAt',
+        'projectId',
+        'projectName',
+        'sourceCaFingerprint',
+        'sourceEventSequence',
+        'sourceHostMemberId',
+    ]);
+    if (!Array.isArray(source.members) || source.members.length !== 2) {
+        throw invalidPayload('members');
+    }
+    const members = source.members.map(decodeComparisonMember);
+    if (members[0].memberId.localeCompare(members[1].memberId, 'en-US') >= 0
+        || !members.some(member => member.role === 'manager'))
+        throw invalidPayload('members');
+    const sourceHostMemberId = stringField(source, 'sourceHostMemberId', 64, isCollabMemberId);
+    if (!members.some(member => member.memberId === sourceHostMemberId)) {
+        throw invalidPayload('sourceHostMemberId');
+    }
+    if (source.mainRef !== COLLAB_MAIN_REF)
+        throw invalidPayload('mainRef');
+    return {
+        mainOid: stringField(source, 'mainOid', 64, isCollabGitOid),
+        mainRef: COLLAB_MAIN_REF,
+        managerSetGeneration: nonNegativeInteger(source, 'managerSetGeneration'),
+        members,
+        projectCreatedAt: timestamp(source, 'projectCreatedAt'),
+        projectId: stringField(source, 'projectId', 64, isCollabProjectId),
+        projectName: stringField(source, 'projectName', COLLAB_LIMITS.maxProjectNameUtf16),
+        sourceCaFingerprint: stringField(source, 'sourceCaFingerprint', 64, candidate => SHA256_PATTERN.test(candidate)),
+        sourceEventSequence: nonNegativeInteger(source, 'sourceEventSequence'),
+        sourceHostMemberId,
+    };
+}
+function decodeSourceEligibility(value) {
+    const keys = [
+        'liveInvitations',
+        'nonActiveMemberships',
+        'nonterminalAcceptOperations',
+        'nonterminalHostTransfers',
+        'nonterminalManagerOffers',
+        'requestComments',
+        'requests',
+        'terminalProjectTransitions',
+        'ticketComments',
+        'ticketMentions',
+        'ticketRelations',
+        'tickets',
+    ];
+    const source = exactRecord(value, 'sourceEligibility', keys);
+    if (keys.some(key => source[key] !== 0))
+        throw invalidPayload('sourceEligibility');
+    return {
+        liveInvitations: 0,
+        nonActiveMemberships: 0,
+        nonterminalAcceptOperations: 0,
+        nonterminalHostTransfers: 0,
+        nonterminalManagerOffers: 0,
+        requestComments: 0,
+        requests: 0,
+        terminalProjectTransitions: 0,
+        ticketComments: 0,
+        ticketMentions: 0,
+        ticketRelations: 0,
+        tickets: 0,
+    };
+}
+function decodeGit(value, comparison) {
+    const source = exactRecord(value, 'git', ['bundle', 'objectFormat', 'refs']);
+    if (source.objectFormat !== 'sha1' && source.objectFormat !== 'sha256') {
+        throw invalidPayload('objectFormat');
+    }
+    const objectFormat = source.objectFormat;
+    const bundleSource = exactRecord(source.bundle, 'bundle', ['byteCount', 'sha256']);
+    if (!Array.isArray(source.refs) || source.refs.length !== 3)
+        throw invalidPayload('refs');
+    const refs = source.refs.map((item) => {
+        const ref = exactRecord(item, 'refs', ['name', 'oid']);
+        const oid = stringField(ref, 'oid', 64, isCollabGitOid);
+        if (oid.length !== (objectFormat === 'sha1' ? 40 : 64))
+            throw invalidPayload('oid');
+        return {
+            name: stringField(ref, 'name', COLLAB_LIMITS.maxRepositoryPathUtf16),
+            oid,
+        };
+    });
+    if (refs.some((item, index) => (index > 0 && refs[index - 1].name.localeCompare(item.name, 'en-US') >= 0)))
+        throw invalidPayload('refs');
+    const expectedNames = [
+        COLLAB_MAIN_REF,
+        ...comparison.members.map(member => member.personalRef),
+    ].sort((left, right) => left.localeCompare(right, 'en-US'));
+    if (refs.some((item, index) => item.name !== expectedNames[index])
+        || refs.find(item => item.name === COLLAB_MAIN_REF)?.oid !== comparison.mainOid)
+        throw invalidPayload('refs');
+    return {
+        bundle: {
+            byteCount: positiveInteger(bundleSource, 'byteCount', COLLAB_CLOUD_BINDING_LIMITS.maxDevelopmentBootstrapGitBundleBytes),
+            sha256: sha256(bundleSource, 'sha256'),
+        },
+        objectFormat,
+        refs,
+    };
+}
+export function decodeDevelopmentBootstrapManifest(value) {
+    assertSerializedLimit(value, COLLAB_CLOUD_BINDING_LIMITS.maxDevelopmentBootstrapManifestUtf8Bytes, 'manifest');
+    const source = exactRecord(value, 'manifest', [
+        'attemptId',
+        'comparison',
+        'createdAt',
+        'git',
+        'manifestSchemaVersion',
+        'protocolVersion',
+        'sourceEligibility',
+    ]);
+    if (source.manifestSchemaVersion !== DEVELOPMENT_BOOTSTRAP_MANIFEST_SCHEMA_VERSION
+        || source.protocolVersion !== COLLAB_PROTOCOL_VERSION)
+        throw invalidPayload('manifestVersion');
+    const comparison = decodeComparison(source.comparison);
+    return {
+        attemptId: stringField(source, 'attemptId', 128, isCollabOpaqueId),
+        comparison,
+        createdAt: timestamp(source, 'createdAt'),
+        git: decodeGit(source.git, comparison),
+        manifestSchemaVersion: DEVELOPMENT_BOOTSTRAP_MANIFEST_SCHEMA_VERSION,
+        protocolVersion: COLLAB_PROTOCOL_VERSION,
+        sourceEligibility: decodeSourceEligibility(source.sourceEligibility),
+    };
+}
+export function encodeDevelopmentBootstrapManifestCanonicalJson(value) {
+    return JSON.stringify(decodeDevelopmentBootstrapManifest(value));
+}
+function decodeClientReadiness(value) {
+    const keys = [
+        'cleanupSettled',
+        'collabGitChildrenDrained',
+        'conflictRecoverySettled',
+        'hostTransferSettled',
+        'joinSettled',
+        'leaveSettled',
+        'managerResponsibilitySettled',
+        'projectOperationQueueDrained',
+        'projectSetupSettled',
+        'projectWorkSessionClosed',
+        'publishSettled',
+        'reconciliationSettled',
+        'reconnectSettled',
+        'repositoryIdentityExact',
+        'retirementSettled',
+    ];
+    const source = exactRecord(value, 'clientReadiness', keys);
+    const result = Object.fromEntries(keys.map(key => [key, exactTrue(source, key)]));
+    return result;
+}
+function decodeHostStopAttestation(value, attemptId, projectId) {
+    const source = exactRecord(value, 'hostStopAttestation', [
+        'attemptId',
+        'autoStartDisabled',
+        'fenceDurable',
+        'fenceId',
+        'hostStopped',
+        'manifestSha256',
+        'projectId',
+        'resourcesDrained',
+        'routeUnregistered',
+        'stoppedAt',
+    ]);
+    const decodedAttemptId = stringField(source, 'attemptId', 128, isCollabOpaqueId);
+    const decodedProjectId = stringField(source, 'projectId', 64, isCollabProjectId);
+    if (decodedAttemptId !== attemptId || decodedProjectId !== projectId) {
+        throw invalidPayload('hostStopAttestation');
+    }
+    return {
+        attemptId: decodedAttemptId,
+        autoStartDisabled: exactTrue(source, 'autoStartDisabled'),
+        fenceDurable: exactTrue(source, 'fenceDurable'),
+        fenceId: stringField(source, 'fenceId', 128, isCollabOpaqueId),
+        hostStopped: exactTrue(source, 'hostStopped'),
+        manifestSha256: sha256(source, 'manifestSha256'),
+        projectId: decodedProjectId,
+        resourcesDrained: exactTrue(source, 'resourcesDrained'),
+        routeUnregistered: exactTrue(source, 'routeUnregistered'),
+        stoppedAt: timestamp(source, 'stoppedAt'),
+    };
+}
+export function decodeDevelopmentBootstrapReport(value) {
+    assertSerializedLimit(value, COLLAB_CLOUD_BINDING_LIMITS.maxDevelopmentBootstrapReportUtf8Bytes, 'report');
+    const source = exactRecordWithOptional(value, 'report', [
+        'attemptId',
+        'capturedAt',
+        'clientReadiness',
+        'comparison',
+        'observedPersonalRefOid',
+        'reporterMemberId',
+    ], ['hostStopAttestation']);
+    const attemptId = stringField(source, 'attemptId', 128, isCollabOpaqueId);
+    const comparison = decodeComparison(source.comparison);
+    const reporterMemberId = stringField(source, 'reporterMemberId', 64, isCollabMemberId);
+    if (!comparison.members.some(member => member.memberId === reporterMemberId)) {
+        throw invalidPayload('reporterMemberId');
+    }
+    const isHost = reporterMemberId === comparison.sourceHostMemberId;
+    if (isHost !== Object.hasOwn(source, 'hostStopAttestation')) {
+        throw invalidPayload('hostStopAttestation');
+    }
+    const hostStopAttestation = isHost
+        ? decodeHostStopAttestation(source.hostStopAttestation, attemptId, comparison.projectId)
+        : undefined;
+    return {
+        attemptId,
+        capturedAt: timestamp(source, 'capturedAt'),
+        clientReadiness: decodeClientReadiness(source.clientReadiness),
+        comparison,
+        ...(hostStopAttestation ? { hostStopAttestation } : {}),
+        observedPersonalRefOid: stringField(source, 'observedPersonalRefOid', 64, isCollabGitOid),
+        reporterMemberId,
+    };
+}
+function decodeActivationResult(value) {
+    const source = exactRecord(value, 'activationResult', [
+        'activatedAt',
+        'activationOperationId',
+        'placementGeneration',
+        'projectId',
+    ]);
+    return {
+        activatedAt: timestamp(source, 'activatedAt'),
+        activationOperationId: stringField(source, 'activationOperationId', 128, isCollabOpaqueId),
+        placementGeneration: positiveInteger(source, 'placementGeneration'),
+        projectId: stringField(source, 'projectId', 64, isCollabProjectId),
+    };
+}
+function decodeAttemptStatus(value) {
+    const source = exactRecordWithOptional(value, 'attempt', [
+        'attemptId',
+        'bundleState',
+        'createdAt',
+        'expiresAt',
+        'manifestSha256',
+        'projectId',
+        'reporterMemberIds',
+        'state',
+    ], ['activationPhase', 'activationResult', 'cancellationPhase']);
+    if (typeof source.state !== 'string' || !ATTEMPT_STATE_SET.has(source.state)) {
+        throw invalidPayload('state');
+    }
+    if (source.bundleState !== 'missing'
+        && source.bundleState !== 'uploaded'
+        && source.bundleState !== 'validated')
+        throw invalidPayload('bundleState');
+    if (!Array.isArray(source.reporterMemberIds) || source.reporterMemberIds.length > 2) {
+        throw invalidPayload('reporterMemberIds');
+    }
+    const reporterMemberIds = source.reporterMemberIds.map((item) => {
+        if (!isCollabMemberId(item))
+            throw invalidPayload('reporterMemberIds');
+        return item;
+    });
+    if (reporterMemberIds.some((item, index) => (index > 0 && reporterMemberIds[index - 1].localeCompare(item, 'en-US') >= 0)))
+        throw invalidPayload('reporterMemberIds');
+    const activationPhase = source.activationPhase;
+    const cancellationPhase = source.cancellationPhase;
+    if (activationPhase !== undefined
+        && (typeof activationPhase !== 'string' || !ACTIVATION_PHASE_SET.has(activationPhase)))
+        throw invalidPayload('activationPhase');
+    if (cancellationPhase !== undefined
+        && (typeof cancellationPhase !== 'string' || !CANCELLATION_PHASE_SET.has(cancellationPhase)))
+        throw invalidPayload('cancellationPhase');
+    const activationResult = source.activationResult === undefined
+        ? undefined
+        : decodeActivationResult(source.activationResult);
+    const projectId = stringField(source, 'projectId', 64, isCollabProjectId);
+    if (source.state === 'activated'
+        && ((activationPhase !== 'activated' && activationPhase !== 'completed')
+            || activationResult === undefined))
+        throw invalidPayload('activationResult');
+    if (source.state !== 'activated'
+        && activationResult !== undefined)
+        throw invalidPayload('activationResult');
+    if (activationPhase !== undefined && cancellationPhase !== undefined) {
+        throw invalidPayload('attemptPhase');
+    }
+    if (activationResult !== undefined && activationResult.projectId !== projectId) {
+        throw invalidPayload('activationResult');
+    }
+    return {
+        ...(activationPhase
+            ? { activationPhase: activationPhase }
+            : {}),
+        ...(activationResult ? { activationResult } : {}),
+        attemptId: stringField(source, 'attemptId', 128, isCollabOpaqueId),
+        bundleState: source.bundleState,
+        ...(cancellationPhase
+            ? { cancellationPhase: cancellationPhase }
+            : {}),
+        createdAt: timestamp(source, 'createdAt'),
+        expiresAt: timestamp(source, 'expiresAt'),
+        manifestSha256: sha256(source, 'manifestSha256'),
+        projectId,
+        reporterMemberIds,
+        state: source.state,
+    };
+}
+function decodeAttemptOnlyRequest(value) {
+    const source = exactRecord(value, 'request', ['attemptId']);
+    return { attemptId: stringField(source, 'attemptId', 128, isCollabOpaqueId) };
+}
+function decodeOperationRequest(operation, value) {
+    switch (operation) {
+        case 'beginDevelopmentBootstrap': {
+            const source = exactRecord(value, 'request', ['manifest']);
+            return { manifest: decodeDevelopmentBootstrapManifest(source.manifest) };
+        }
+        case 'submitDevelopmentBootstrapReport': {
+            const source = exactRecord(value, 'request', ['attemptId', 'report']);
+            const attemptId = stringField(source, 'attemptId', 128, isCollabOpaqueId);
+            const report = decodeDevelopmentBootstrapReport(source.report);
+            if (report.attemptId !== attemptId)
+                throw invalidPayload('attemptId');
+            return { attemptId, report };
+        }
+        case 'getDevelopmentBootstrap':
+        case 'cancelDevelopmentBootstrap':
+            return decodeAttemptOnlyRequest(value);
+        case 'activateDevelopmentBootstrap': {
+            const source = exactRecord(value, 'request', ['attemptId', 'manifestSha256']);
+            return {
+                attemptId: stringField(source, 'attemptId', 128, isCollabOpaqueId),
+                manifestSha256: sha256(source, 'manifestSha256'),
+            };
+        }
+        case 'putDevelopmentBootstrapGitBundle': {
+            const source = exactRecord(value, 'request', [
+                'attemptId',
+                'byteCount',
+                'contentEncoding',
+                'contentType',
+                'sha256',
+            ]);
+            if (source.contentEncoding !== 'identity'
+                || source.contentType !== 'application/x-git-bundle')
+                throw invalidPayload('contentType');
+            return {
+                attemptId: stringField(source, 'attemptId', 128, isCollabOpaqueId),
+                byteCount: positiveInteger(source, 'byteCount', COLLAB_CLOUD_BINDING_LIMITS.maxDevelopmentBootstrapGitBundleBytes),
+                contentEncoding: 'identity',
+                contentType: 'application/x-git-bundle',
+                sha256: sha256(source, 'sha256'),
+            };
+        }
+    }
+}
+function decodeRequestResult(operation, value) {
+    try {
+        return { status: 'ok', value: decodeOperationRequest(operation, value) };
+    }
+    catch (error) {
+        return {
+            status: 'invalid',
+            error: error instanceof CollabError ? error : invalidPayload('request'),
+        };
+    }
+}
+function codec(operation) {
+    return Object.freeze({
+        decodeRequest: (value) => decodeRequestResult(operation, value),
+        decodeResponse: decodeAttemptStatus,
+    });
+}
+export const DEVELOPMENT_BOOTSTRAP_OPERATION_CODECS = Object.freeze({
+    beginDevelopmentBootstrap: codec('beginDevelopmentBootstrap'),
+    submitDevelopmentBootstrapReport: codec('submitDevelopmentBootstrapReport'),
+    getDevelopmentBootstrap: codec('getDevelopmentBootstrap'),
+    activateDevelopmentBootstrap: codec('activateDevelopmentBootstrap'),
+    cancelDevelopmentBootstrap: codec('cancelDevelopmentBootstrap'),
+    putDevelopmentBootstrapGitBundle: codec('putDevelopmentBootstrapGitBundle'),
+});
+export function developmentBootstrapOperationCodec(operation) {
+    const selected = DEVELOPMENT_BOOTSTRAP_OPERATION_CODECS[operation];
+    if (!selected) {
+        throw new CollabError({
+            code: 'operation-failed',
+            safeContext: { reason: 'bootstrap-operation-codec-missing' },
+        });
+    }
+    return selected;
+}

package/dist/esm/index.mjs

@@ -0,0 +1,16 @@
+export { COLLAB_LIMITS, COLLAB_MAIN_REF, COLLAB_MEMBER_REF_PREFIX, COLLAB_PROTOCOL_VERSION, } from './CollabConstants.mjs';
+export { COLLAB_AUTHORITY_TRANSFER_CANCELLABLE_PHASES, COLLAB_AUTHORITY_TRANSFER_CANCELLATION_PHASES, COLLAB_AUTHORITY_TRANSFER_OPERATIONS, COLLAB_CLOUD_TO_LAN_TRANSFER_PHASES, COLLAB_LAN_TO_CLOUD_TRANSFER_PHASES, decodeCollabAuthorityRelinquishmentProof, decodeCollabAuthorityTransferOperationRequest, decodeCollabAuthorityTransferOperationResponse, decodeCollabAuthorityTransferProposal, decodeCollabAuthorityTransferStatus, decodeCollabTransferredMembershipClaim, decodeCollabTransferredMembershipClaimBatch, decodeCollabTransferredMembershipClaimCustodyReceipt, decodeCollabTransferredMembershipRedemptionReceipt, encodeCollabAuthorityRelinquishmentProofSigningInput, encodeCollabTransferredMembershipClaimBatchDigestInput, encodeCollabTransferredMembershipRedemptionReceiptSigningInput, } from './CollabAuthorityTransfer.mjs';
+export { COLLAB_CHECKPOINT_ARTIFACT_LIMITS, COLLAB_CHECKPOINT_BACKUP_RECORD_KINDS, COLLAB_CHECKPOINT_PORTABLE_RECORD_KINDS, COLLAB_CHECKPOINT_PROFILES, COLLAB_PROJECT_CHECKPOINT_ARTIFACTS, COLLAB_PROJECT_CHECKPOINT_MANIFEST_SCHEMA_VERSION, COLLAB_PROJECT_COORDINATION_FORMAT_VERSION, COLLAB_PROTECTED_CLAIM_ENVELOPE_LIMITS, COLLAB_PROTECTED_CLAIM_ENVELOPE_VERSION, decodeCollabProjectCheckpointCoordinationNdjson, decodeCollabProjectCheckpointManifest, encodeCollabProjectCheckpointCoordinationNdjson, encodeCollabProjectCheckpointManifestCanonicalJson, encodeCollabProjectCheckpointManifestDigestInput, encodeCollabProtectedClaimAssociatedData, validateCollabProjectCheckpointConsistency, } from './CollabProjectCheckpoint.mjs';
+export { COLLAB_PROJECT_BACKUP_COORDINATION_FORMAT_VERSION, COLLAB_PROJECT_BACKUP_RECORD_KINDS, collabProjectBackupIdempotencyRecordId, decodeCollabProjectBackupCheckpointCoordinationNdjson, decodeCollabProjectBackupCheckpointManifest, encodeCollabProjectBackupCheckpointCoordinationNdjson, encodeCollabProjectBackupCheckpointManifestCanonicalJson, encodeCollabProjectBackupCheckpointManifestDigestInput, validateCollabProjectBackupCheckpointConsistency, } from './CollabProjectBackupCheckpoint.mjs';
+export { COLLAB_PROJECT_RETIREMENT_OPERATIONS, COLLAB_PROJECT_RETIREMENT_RESULT_KINDS, decodeCollabProjectRetirementAcknowledgement, decodeCollabProjectRetirementOperationRequest, decodeCollabProjectRetirementOperationResponse, decodeCollabProjectRetirementRequest, decodeCollabProjectRetirementResult, } from './CollabProjectRetirement.mjs';
+export { COLLAB_CLOUD_BINDING_LIMITS, COLLAB_CLOUD_BINDING_VERSION, COLLAB_CLOUD_CAPABILITIES, COLLAB_CLOUD_CAPABILITY_DOCUMENT_SCHEMA_VERSION, COLLAB_CLOUD_JSON_OPERATIONS, collabCloudAuthorityTransferArtifactRoute, collabCloudCapabilityDocument, collabCloudCapabilitySupported, collabCloudCapabilitiesRoute, collabCloudErrorEnvelope, collabCloudGitRoute, collabCloudProjectCheckpointExportArtifactRoute, collabCloudProjectCheckpointExportRoute, collabCloudProjectEventsRoute, collabCloudProjectOperationRoute, collabCloudSuccessEnvelope, collabDevelopmentBootstrapRoute, decodeCollabCloudCapabilityDocument, decodeCollabCloudErrorEnvelope, decodeCollabCloudProjectCheckpointExportStatus, decodeCollabCloudSuccessEnvelope, matchCollabCloudRoute, } from './CollabCloudBinding.mjs';
+export { DEVELOPMENT_BOOTSTRAP_ACTIVATION_PHASES, DEVELOPMENT_BOOTSTRAP_ATTEMPT_STATES, DEVELOPMENT_BOOTSTRAP_CANCELLATION_PHASES, DEVELOPMENT_BOOTSTRAP_MANIFEST_SCHEMA_VERSION, DEVELOPMENT_BOOTSTRAP_OPERATIONS, DEVELOPMENT_BOOTSTRAP_OPERATION_CODECS, decodeDevelopmentBootstrapManifest, decodeDevelopmentBootstrapReport, developmentBootstrapOperationCodec, encodeDevelopmentBootstrapManifestCanonicalJson, } from './DevelopmentBootstrap.mjs';
+export { COLLAB_CLOUD_PROJECT_SNAPSHOT_CODEC, decodeCollabCloudProjectSnapshot, } from './CollabCloudProjectSnapshot.mjs';
+export { COLLAB_CLOUD_EVENT_KINDS, decodeCollabCloudProjectEventMessage, } from './CollabCloudProjectEvent.mjs';
+export { COLLAB_CONTROL_OPERATION_CODECS, collabControlOperationCodec, } from './CollabControlOperationCodecs.mjs';
+export { COLLAB_ERROR_CODES, CollabError, collabErrorGroup, sanitizeCollabDiagnosticContext, } from './CollabError.mjs';
+export { parseCollabMemberMentions } from './CollabMemberMentionParser.mjs';
+export { decodeCollabProtocolEnvelope } from './CollabProtocol.mjs';
+export { parseCollabTicketReferences, scanCollabTicketReferences, } from './CollabTicketReferenceParser.mjs';
+export { isCollabGitOid, isCollabMemberId, isCollabOpaqueId, isCollabProjectId, } from './CollabValidation.mjs';
+export { collabMemberRef } from './types.mjs';

package/dist/esm/types.mjs

@@ -0,0 +1,8 @@
+import { COLLAB_MEMBER_REF_PREFIX, } from './CollabConstants.mjs';
+import { isCollabMemberId } from './CollabValidation.mjs';
+export function collabMemberRef(memberId) {
+    if (!isCollabMemberId(memberId)) {
+        throw new RangeError('Invalid Collab member ID');
+    }
+    return `${COLLAB_MEMBER_REF_PREFIX}${memberId}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudian-collab/protocol",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "Canonical Collab wire and Cloud binding contract for Claudian clients and servers.",
   "license": "MIT",
   "repository": {
@@ -21,10 +21,13 @@
   "packageManager": "npm@11.13.0",
   "type": "commonjs",
   "main": "./dist/index.js",
+  "module": "./dist/esm/index.mjs",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/index.js",
       "default": "./dist/index.js"
     }
   },
@@ -34,7 +37,7 @@
   ],
   "sideEffects": false,
   "scripts": {
-    "build": "npm run clean && tsc -p tsconfig.json",
+    "build": "npm run clean && tsc -p tsconfig.json && tsc -p tsconfig.esm.json && node scripts/finalize-esm.mjs",
     "check:compatibility": "node scripts/check-compatibility.mjs",
     "check:migration-provenance": "node scripts/check-migration-provenance.mjs --verify-standalone",
     "clean": "node scripts/clean.mjs",