@serve.zone/interfaces 25.1.0 → 25.2.0

package/dist_ts/runtime.corestore.js

@@ -0,0 +1,620 @@
+import * as plugins from './plugins.js';
+import { isSha256Digest } from './data/immutableimage.js';
+import { validateSecretRecipientMetadata, verifySecretEnvelopeContext, } from './data/secret.js';
+import { validateObjectStorageRetentionEvidence } from './platform/objectstorageretention.js';
+export const corestoreProviderConfigIds = Object.freeze({
+    database: 'cloudly-corestore-database',
+    objectstorage: 'cloudly-corestore-objectstorage',
+});
+export const corestoreControlUrl = 'http://corestore:3000';
+export const corestoreCredentialManagementScope = 'platform:cloudly-corestore';
+export const corestoreControlCredentialKey = 'CORESTORE_API_TOKEN';
+export const corestoreCredentialEnvironment = 'production';
+export const corestoreCredentialRuntimeLimits = Object.freeze({
+    maximumIdentifierLength: 200,
+    maximumPublicationGrants: 256,
+    maximumGrantLifetimeMs: 24 * 60 * 60 * 1000,
+    maximumCredentialStringBytes: 8 * 1024,
+    maximumSealedMaterialBytes: 64 * 1024,
+    minimumControlTokenBytes: 32,
+    maximumControlTokenBytes: 4096,
+    maximumSealedControlCredentialBytes: 12 * 1024,
+});
+export const getCorestoreProviderConfigId = (capabilityArg) => {
+    if (capabilityArg !== 'database' && capabilityArg !== 'objectstorage') {
+        throw new Error('corestore capability must be database or objectstorage');
+    }
+    return corestoreProviderConfigIds[capabilityArg];
+};
+const identifierPattern = /^[A-Za-z0-9][A-Za-z0-9:._-]{0,199}$/;
+const bareSha256Pattern = /^[a-f0-9]{64}$/;
+const environmentKeyPattern = /^[A-Z_][A-Z0-9_]{0,127}$/;
+const isRecord = (valueArg) => (Boolean(valueArg)
+    && typeof valueArg === 'object'
+    && !Array.isArray(valueArg)
+    && (Object.getPrototypeOf(valueArg) === Object.prototype
+        || Object.getPrototypeOf(valueArg) === null));
+const hasExactKeys = (valueArg, keysArg) => {
+    const actual = Object.keys(valueArg).sort();
+    const expected = [...keysArg].sort();
+    return actual.length === expected.length
+        && actual.every((keyArg, indexArg) => keyArg === expected[indexArg]);
+};
+const hasKeys = (valueArg, requiredArg, optionalArg) => requiredArg.every((keyArg) => Object.hasOwn(valueArg, keyArg))
+    && Object.keys(valueArg).every((keyArg) => requiredArg.includes(keyArg)
+        || optionalArg.includes(keyArg));
+const isIdentifier = (valueArg) => (typeof valueArg === 'string' && identifierPattern.test(valueArg));
+const isPositiveSafeInteger = (valueArg) => (Number.isSafeInteger(valueArg) && valueArg > 0);
+const isNonNegativeSafeInteger = (valueArg) => (Number.isSafeInteger(valueArg) && valueArg >= 0 && !Object.is(valueArg, -0));
+const isJwtIdentity = (valueArg) => (isRecord(valueArg)
+    && hasExactKeys(valueArg, ['jwt'])
+    && typeof valueArg.jwt === 'string'
+    && valueArg.jwt.length > 0);
+const utf8ByteLength = (valueArg) => new TextEncoder().encode(valueArg).byteLength;
+const isCorestoreControlToken = (valueArg) => {
+    if (typeof valueArg !== 'string' || valueArg.length === 0 || /\s/u.test(valueArg))
+        return false;
+    const encoded = new TextEncoder().encode(valueArg);
+    let roundTrip;
+    try {
+        roundTrip = new TextDecoder('utf-8', { fatal: true }).decode(encoded);
+    }
+    catch {
+        return false;
+    }
+    return roundTrip === valueArg
+        && encoded.byteLength >= corestoreCredentialRuntimeLimits.minimumControlTokenBytes
+        && encoded.byteLength <= corestoreCredentialRuntimeLimits.maximumControlTokenBytes;
+};
+export const validateGetCorestoreControlCredentialMaterialRequest = (requestArg, activeRecipientArg) => {
+    if (!isRecord(requestArg)
+        || !hasExactKeys(requestArg, [
+            'identity',
+            'requestId',
+            'capability',
+            'expectedRecipientKeyId',
+            'expectedRecipientGeneration',
+        ])) {
+        return ['corestore control credential request must use its exact schema'];
+    }
+    const errors = [];
+    if (!isJwtIdentity(requestArg.identity)) {
+        errors.push('corestore control credential request requires only a JWT identity');
+    }
+    if (!isIdentifier(requestArg.requestId)
+        || !isIdentifier(requestArg.expectedRecipientKeyId)) {
+        errors.push('corestore control credential request identifiers must be canonical');
+    }
+    if (requestArg.capability !== 'database' && requestArg.capability !== 'objectstorage') {
+        errors.push('corestore control credential capability must be database or objectstorage');
+    }
+    if (!isPositiveSafeInteger(requestArg.expectedRecipientGeneration)) {
+        errors.push('corestore control credential recipient generation must be positive');
+    }
+    if (validateSecretRecipientMetadata(activeRecipientArg).length > 0
+        || activeRecipientArg.lifecycleState !== 'active'
+        || requestArg.expectedRecipientKeyId !== activeRecipientArg.recipientKeyId
+        || requestArg.expectedRecipientGeneration !== activeRecipientArg.generation) {
+        errors.push('corestore control credential request must target the active recipient');
+    }
+    return errors;
+};
+export const createCorestoreControlCredentialMaterialEnvelopeContext = (materialArg) => new TextEncoder().encode(JSON.stringify({
+    schemaVersion: 1,
+    purpose: 'serve.zone/corestore-control-credential-material',
+    requestId: materialArg.requestId,
+    clusterId: materialArg.clusterId,
+    capability: materialArg.capability,
+    providerConfigId: getCorestoreProviderConfigId(materialArg.capability),
+    controlUrl: corestoreControlUrl,
+    managementScope: corestoreCredentialManagementScope,
+    key: corestoreControlCredentialKey,
+    environment: corestoreCredentialEnvironment,
+    recipientKeyId: materialArg.recipientKeyId,
+    recipientGeneration: materialArg.recipientGeneration,
+}));
+export const validateCorestoreControlCredentialPlaintext = (plaintextArg) => {
+    if (!isRecord(plaintextArg)
+        || !hasExactKeys(plaintextArg, ['schemaVersion', 'key', 'environment', 'value'])) {
+        return ['corestore control credential plaintext must use its exact schema'];
+    }
+    const errors = [];
+    if (plaintextArg.schemaVersion !== 1
+        || plaintextArg.key !== corestoreControlCredentialKey
+        || plaintextArg.environment !== corestoreCredentialEnvironment) {
+        errors.push('corestore control credential plaintext constants must be canonical');
+    }
+    if (!isCorestoreControlToken(plaintextArg.value)) {
+        errors.push('corestore control credential value must be 32-4096 UTF-8 bytes without whitespace');
+    }
+    return errors;
+};
+export const validateCorestoreControlCredentialMaterial = async (materialArg, expectedArg) => {
+    if (!isRecord(materialArg)
+        || !hasExactKeys(materialArg, [
+            'schemaVersion',
+            'requestId',
+            'clusterId',
+            'capability',
+            'providerConfigId',
+            'controlUrl',
+            'managementScope',
+            'key',
+            'environment',
+            'recipientKeyId',
+            'recipientGeneration',
+            'envelope',
+        ])) {
+        return ['corestore control credential material must use its exact schema'];
+    }
+    const errors = [];
+    if (materialArg.schemaVersion !== 1
+        || !isIdentifier(materialArg.requestId)
+        || !isIdentifier(materialArg.clusterId)
+        || !isIdentifier(materialArg.recipientKeyId)
+        || !isPositiveSafeInteger(materialArg.recipientGeneration)) {
+        errors.push('corestore control credential material metadata must be canonical');
+    }
+    if (materialArg.capability !== 'database' && materialArg.capability !== 'objectstorage') {
+        errors.push('corestore control credential material capability must be canonical');
+    }
+    else if (materialArg.providerConfigId !== getCorestoreProviderConfigId(materialArg.capability)) {
+        errors.push('corestore control credential provider must be derived from capability');
+    }
+    if (materialArg.controlUrl !== corestoreControlUrl
+        || materialArg.managementScope !== corestoreCredentialManagementScope
+        || materialArg.key !== corestoreControlCredentialKey
+        || materialArg.environment !== corestoreCredentialEnvironment) {
+        errors.push('corestore control credential material constants must be canonical');
+    }
+    if (materialArg.requestId !== expectedArg.requestId
+        || materialArg.clusterId !== expectedArg.clusterId
+        || materialArg.capability !== expectedArg.capability
+        || materialArg.recipientKeyId !== expectedArg.expectedRecipientKeyId
+        || materialArg.recipientGeneration !== expectedArg.expectedRecipientGeneration) {
+        errors.push('corestore control credential material does not match its request authority');
+    }
+    let envelope;
+    try {
+        envelope = plugins.smartcrypto.parseX25519Envelope(materialArg.envelope);
+        if (envelope.ciphertext.length
+            > Math.ceil(corestoreCredentialRuntimeLimits.maximumSealedControlCredentialBytes * 4 / 3)) {
+            errors.push('corestore control credential envelope exceeds its byte limit');
+        }
+    }
+    catch {
+        errors.push('corestore control credential envelope must be strict');
+    }
+    if (envelope) {
+        if (envelope.recipientKeyId !== materialArg.recipientKeyId) {
+            errors.push('corestore control credential envelope recipient must match');
+        }
+        else if (errors.length === 0 && !await verifySecretEnvelopeContext(envelope, createCorestoreControlCredentialMaterialEnvelopeContext(materialArg))) {
+            errors.push('corestore control credential envelope context must match');
+        }
+    }
+    return errors;
+};
+export const validateCorestoreCredentialPublicationGrant = (grantArg, trustedNowArg) => {
+    if (!isRecord(grantArg)
+        || !hasExactKeys(grantArg, [
+            'schemaVersion',
+            'operationId',
+            'serviceId',
+            'bindingId',
+            'capability',
+            'reconciliationGeneration',
+            'expectedTargetSecretsRevision',
+            'bindingRequestDigest',
+            'issuedAt',
+            'expiresAt',
+        ])) {
+        return ['corestore credential publication grant must use its exact schema'];
+    }
+    const errors = [];
+    if (grantArg.schemaVersion !== 1) {
+        errors.push('corestore credential publication grant schemaVersion must be 1');
+    }
+    if (!isIdentifier(grantArg.operationId)
+        || !isIdentifier(grantArg.serviceId)
+        || !isIdentifier(grantArg.bindingId)) {
+        errors.push('corestore credential publication grant identifiers must be canonical');
+    }
+    if (grantArg.capability !== 'database' && grantArg.capability !== 'objectstorage') {
+        errors.push('corestore credential publication grant capability must be canonical');
+    }
+    if (!isPositiveSafeInteger(grantArg.reconciliationGeneration)
+        || !isNonNegativeSafeInteger(grantArg.expectedTargetSecretsRevision)) {
+        errors.push('corestore credential publication grant revisions must be canonical');
+    }
+    if (typeof grantArg.bindingRequestDigest !== 'string'
+        || !bareSha256Pattern.test(grantArg.bindingRequestDigest)) {
+        errors.push('corestore credential publication grant digest must be bare lowercase 64-hex');
+    }
+    if (!isPositiveSafeInteger(grantArg.issuedAt)
+        || !isPositiveSafeInteger(grantArg.expiresAt)
+        || grantArg.expiresAt <= grantArg.issuedAt
+        || grantArg.expiresAt - grantArg.issuedAt
+            > corestoreCredentialRuntimeLimits.maximumGrantLifetimeMs) {
+        errors.push('corestore credential publication grant lifetime must be positive and bounded');
+    }
+    if (trustedNowArg !== undefined
+        && (!isPositiveSafeInteger(trustedNowArg)
+            || trustedNowArg < grantArg.issuedAt
+            || trustedNowArg >= grantArg.expiresAt)) {
+        errors.push('corestore credential publication grant must be currently valid');
+    }
+    return errors;
+};
+export const corestoreCredentialPublicationGrantsEqual = (leftArg, rightArg) => validateCorestoreCredentialPublicationGrant(leftArg).length === 0
+    && validateCorestoreCredentialPublicationGrant(rightArg).length === 0
+    && leftArg.schemaVersion
+        === rightArg.schemaVersion
+    && leftArg.operationId
+        === rightArg.operationId
+    && leftArg.serviceId
+        === rightArg.serviceId
+    && leftArg.bindingId
+        === rightArg.bindingId
+    && leftArg.capability
+        === rightArg.capability
+    && leftArg.reconciliationGeneration
+        === rightArg.reconciliationGeneration
+    && leftArg.expectedTargetSecretsRevision
+        === rightArg.expectedTargetSecretsRevision
+    && leftArg.bindingRequestDigest
+        === rightArg.bindingRequestDigest
+    && leftArg.issuedAt
+        === rightArg.issuedAt
+    && leftArg.expiresAt
+        === rightArg.expiresAt;
+const comparePublicationGrants = (leftArg, rightArg) => leftArg.bindingId < rightArg.bindingId
+    ? -1
+    : leftArg.bindingId > rightArg.bindingId
+        ? 1
+        : leftArg.operationId < rightArg.operationId
+            ? -1
+            : leftArg.operationId > rightArg.operationId
+                ? 1
+                : 0;
+export const validateCorestoreCredentialPublicationGrants = (grantsArg, trustedNowArg) => {
+    if (!Array.isArray(grantsArg)
+        || grantsArg.length > corestoreCredentialRuntimeLimits.maximumPublicationGrants) {
+        return ['corestore credential publication grants must be a bounded array'];
+    }
+    const errors = [];
+    let previous;
+    for (const [index, grantArg] of grantsArg.entries()) {
+        const grantErrors = validateCorestoreCredentialPublicationGrant(grantArg, trustedNowArg);
+        errors.push(...grantErrors.map((errorArg) => `publication grants[${index}] ${errorArg}`));
+        if (grantErrors.length === 0) {
+            const grant = grantArg;
+            if (previous && comparePublicationGrants(previous, grant) >= 0) {
+                errors.push('corestore credential publication grants must be unique and sorted by bindingId then operationId');
+            }
+            previous = grant;
+        }
+    }
+    return errors;
+};
+export const corestoreDatabaseCredentialKeys = Object.freeze([
+    'MONGODB_URI',
+    'MONGODB_URL',
+    'MONGO_URL',
+    'MONGODB_HOST',
+    'MONGODB_PORT',
+    'MONGODB_DATABASE',
+    'MONGO_DBNAME',
+    'MONGODB_USERNAME',
+    'MONGO_DBUSER',
+    'MONGODB_PASSWORD',
+    'MONGO_DBPASS',
+]);
+export const corestoreObjectStorageCredentialKeys = Object.freeze([
+    'accessKeyId',
+    'secretAccessKey',
+]);
+const readCredentialString = (valueArg) => typeof valueArg === 'string'
+    && valueArg.length > 0
+    && utf8ByteLength(valueArg) <= corestoreCredentialRuntimeLimits.maximumCredentialStringBytes
+    && !valueArg.includes('\0');
+export const validateCorestoreDatabaseCredentialMaterial = (materialArg) => {
+    if (!isRecord(materialArg)
+        || !hasExactKeys(materialArg, ['schemaVersion', 'capability', 'values'])
+        || materialArg.schemaVersion !== 1
+        || materialArg.capability !== 'database'
+        || !isRecord(materialArg.values)
+        || !hasExactKeys(materialArg.values, corestoreDatabaseCredentialKeys)) {
+        return ['corestore database credential material must use its exact schema'];
+    }
+    const values = materialArg.values;
+    const errors = [];
+    if (corestoreDatabaseCredentialKeys.some((keyArg) => !readCredentialString(values[keyArg]))) {
+        errors.push('corestore database credential values must be bounded non-empty strings');
+    }
+    if (values.MONGODB_URI !== values.MONGODB_URL
+        || values.MONGODB_URI !== values.MONGO_URL) {
+        errors.push('corestore database URI aliases must be equal');
+    }
+    if (values.MONGODB_DATABASE !== values.MONGO_DBNAME) {
+        errors.push('corestore database name aliases must be equal');
+    }
+    if (values.MONGODB_USERNAME !== values.MONGO_DBUSER) {
+        errors.push('corestore database username aliases must be equal');
+    }
+    if (values.MONGODB_PASSWORD !== values.MONGO_DBPASS) {
+        errors.push('corestore database password aliases must be equal');
+    }
+    if (typeof values.MONGODB_PORT !== 'string'
+        || !/^[1-9][0-9]{0,4}$/.test(values.MONGODB_PORT)
+        || Number(values.MONGODB_PORT) > 65535) {
+        errors.push('corestore database port must be canonical');
+    }
+    return errors;
+};
+export const validateCorestoreObjectStorageCredentialMaterial = async (materialArg, retentionExpectationArg) => {
+    if (!isRecord(materialArg)
+        || !hasKeys(materialArg, ['schemaVersion', 'capability', 'values'], ['retention'])
+        || materialArg.schemaVersion !== 1
+        || materialArg.capability !== 'objectstorage'
+        || !isRecord(materialArg.values)
+        || !hasExactKeys(materialArg.values, corestoreObjectStorageCredentialKeys)) {
+        return ['corestore objectstorage credential material must use its exact schema'];
+    }
+    const errors = [];
+    if (!readCredentialString(materialArg.values.accessKeyId)
+        || !readCredentialString(materialArg.values.secretAccessKey)) {
+        errors.push('corestore objectstorage credential values must be bounded non-empty strings');
+    }
+    if (materialArg.retention !== undefined) {
+        if (!retentionExpectationArg) {
+            errors.push('corestore objectstorage retention evidence requires trusted binding authority');
+        }
+        else {
+            errors.push(...await validateObjectStorageRetentionEvidence(materialArg.retention, retentionExpectationArg));
+        }
+    }
+    return errors;
+};
+export const validateCorestoreCredentialPlaintextMaterial = async (materialArg, retentionExpectationArg) => isRecord(materialArg) && materialArg.capability === 'database'
+    ? validateCorestoreDatabaseCredentialMaterial(materialArg)
+    : validateCorestoreObjectStorageCredentialMaterial(materialArg, retentionExpectationArg);
+export const createPublishCorestoreCredentialMaterialEnvelopeContext = (requestArg) => new TextEncoder().encode(JSON.stringify({
+    schemaVersion: 1,
+    purpose: 'serve.zone/publish-corestore-credential-material',
+    mutationId: requestArg.mutationId,
+    grant: {
+        schemaVersion: requestArg.grant.schemaVersion,
+        operationId: requestArg.grant.operationId,
+        serviceId: requestArg.grant.serviceId,
+        bindingId: requestArg.grant.bindingId,
+        capability: requestArg.grant.capability,
+        reconciliationGeneration: requestArg.grant.reconciliationGeneration,
+        expectedTargetSecretsRevision: requestArg.grant.expectedTargetSecretsRevision,
+        bindingRequestDigest: requestArg.grant.bindingRequestDigest,
+        issuedAt: requestArg.grant.issuedAt,
+        expiresAt: requestArg.grant.expiresAt,
+    },
+    expectedIngressRecipientKeyId: requestArg.expectedIngressRecipientKeyId,
+    expectedIngressRecipientGeneration: requestArg.expectedIngressRecipientGeneration,
+}));
+export const validatePublishCorestoreCredentialMaterialRequest = async (requestArg, expectedGrantArg, activeRecipientArg, trustedNowArg) => {
+    if (!isRecord(requestArg)
+        || !hasExactKeys(requestArg, [
+            'identity',
+            'mutationId',
+            'grant',
+            'expectedIngressRecipientKeyId',
+            'expectedIngressRecipientGeneration',
+            'envelope',
+        ])) {
+        return ['publish corestore credential request must use its exact schema'];
+    }
+    const errors = validateCorestoreCredentialPublicationGrant(requestArg.grant, trustedNowArg);
+    if (!corestoreCredentialPublicationGrantsEqual(requestArg.grant, expectedGrantArg)) {
+        errors.push('publish corestore credential request grant must match current server authority');
+    }
+    if (!isJwtIdentity(requestArg.identity)) {
+        errors.push('publish corestore credential request requires only a JWT identity');
+    }
+    if (!isIdentifier(requestArg.mutationId)
+        || !isIdentifier(requestArg.expectedIngressRecipientKeyId)
+        || !isPositiveSafeInteger(requestArg.expectedIngressRecipientGeneration)) {
+        errors.push('publish corestore credential request recipient and mutation must be canonical');
+    }
+    let envelope;
+    try {
+        envelope = plugins.smartcrypto.parseX25519Envelope(requestArg.envelope);
+        if (envelope.ciphertext.length
+            > Math.ceil(corestoreCredentialRuntimeLimits.maximumSealedMaterialBytes * 4 / 3)) {
+            errors.push('publish corestore credential envelope exceeds its byte limit');
+        }
+    }
+    catch {
+        errors.push('publish corestore credential envelope must be strict');
+    }
+    if (validateSecretRecipientMetadata(activeRecipientArg).length > 0
+        || activeRecipientArg.lifecycleState !== 'active'
+        || activeRecipientArg.recipientKeyId !== requestArg.expectedIngressRecipientKeyId
+        || activeRecipientArg.generation !== requestArg.expectedIngressRecipientGeneration) {
+        errors.push('publish corestore credential request must target the active ingress recipient');
+    }
+    if (envelope) {
+        if (envelope.recipientKeyId !== requestArg.expectedIngressRecipientKeyId) {
+            errors.push('publish corestore credential envelope recipient must match');
+        }
+        else if (errors.length === 0 && !await verifySecretEnvelopeContext(envelope, createPublishCorestoreCredentialMaterialEnvelopeContext(requestArg))) {
+            errors.push('publish corestore credential envelope context must match');
+        }
+    }
+    return errors;
+};
+const expectedCoverageKeys = (capabilityArg) => capabilityArg === 'database'
+    ? corestoreDatabaseCredentialKeys
+    : corestoreObjectStorageCredentialKeys;
+const computeRuntimeSha256 = async (valueArg) => {
+    const digest = new Uint8Array(await globalThis.crypto.subtle.digest('SHA-256', new Uint8Array(valueArg)));
+    return [...digest].map((byteArg) => byteArg.toString(16).padStart(2, '0')).join('');
+};
+const verifyPublicationAdmissionBinding = async (bindingArg, envelopeArg, contextArg) => {
+    try {
+        const envelope = plugins.smartcrypto.parseX25519Envelope(envelopeArg);
+        if (envelope.recipientKeyId !== bindingArg.recipientKeyId
+            || !await verifySecretEnvelopeContext(envelope, contextArg)) {
+            return false;
+        }
+        const envelopeDigestInput = JSON.stringify({
+            schemaVersion: envelope.schemaVersion,
+            profile: envelope.profile,
+            recipientKeyId: envelope.recipientKeyId,
+            ephemeralPublicKey: envelope.ephemeralPublicKey,
+            nonce: envelope.nonce,
+            ciphertext: envelope.ciphertext,
+            tag: envelope.tag,
+            contextDigest: envelope.contextDigest,
+        });
+        return bindingArg.envelopeDigest
+            === `sha256:${await computeRuntimeSha256(new TextEncoder().encode(envelopeDigestInput))}`
+            && bindingArg.requestContextDigest
+                === `sha256:${await computeRuntimeSha256(contextArg)}`;
+    }
+    catch {
+        return false;
+    }
+};
+export const validateCorestoreCredentialPublicationReceipt = async (receiptArg, expectedArg) => {
+    if (!isRecord(receiptArg)
+        || !hasExactKeys(receiptArg, [
+            'schemaVersion',
+            'mutationId',
+            'organizationId',
+            'clusterId',
+            'serviceId',
+            'bindingId',
+            'capability',
+            'grant',
+            'coverage',
+            'expectedTargetSecretsRevision',
+            'targetSecretsRevision',
+            'ingressAdmissionBinding',
+            'acceptedAt',
+            'replayed',
+        ])) {
+        return ['corestore credential publication receipt must use its exact schema'];
+    }
+    const errors = validateCorestoreCredentialPublicationGrant(receiptArg.grant);
+    if (receiptArg.schemaVersion !== 1
+        || !isIdentifier(receiptArg.mutationId)
+        || !isIdentifier(receiptArg.organizationId)
+        || !isIdentifier(receiptArg.clusterId)
+        || !isIdentifier(receiptArg.serviceId)
+        || !isIdentifier(receiptArg.bindingId)) {
+        errors.push('corestore credential publication receipt identifiers must be canonical');
+    }
+    const grant = receiptArg.grant;
+    if ((receiptArg.capability !== 'database' && receiptArg.capability !== 'objectstorage')
+        || receiptArg.serviceId !== grant.serviceId
+        || receiptArg.bindingId !== grant.bindingId
+        || receiptArg.capability !== grant.capability
+        || receiptArg.expectedTargetSecretsRevision !== grant.expectedTargetSecretsRevision) {
+        errors.push('corestore credential publication receipt must exactly bind its grant');
+    }
+    if (receiptArg.mutationId !== expectedArg.request.mutationId
+        || receiptArg.organizationId !== expectedArg.organizationId
+        || receiptArg.clusterId !== expectedArg.clusterId
+        || !corestoreCredentialPublicationGrantsEqual(receiptArg.grant, expectedArg.request.grant)) {
+        errors.push('corestore credential publication receipt must match its trusted request scope');
+    }
+    if (!isRecord(receiptArg.coverage)
+        || !hasExactKeys(receiptArg.coverage, ['keys', 'versionReferences'])
+        || !Array.isArray(receiptArg.coverage.keys)
+        || !Array.isArray(receiptArg.coverage.versionReferences)) {
+        errors.push('corestore credential publication coverage must use its exact schema');
+    }
+    else if (receiptArg.capability === 'database' || receiptArg.capability === 'objectstorage') {
+        const requiredKeys = expectedCoverageKeys(receiptArg.capability);
+        if (JSON.stringify(receiptArg.coverage.keys) !== JSON.stringify(requiredKeys)
+            || receiptArg.coverage.versionReferences.length !== requiredKeys.length) {
+            errors.push('corestore credential publication coverage must be exact');
+        }
+        else {
+            const secretIds = new Set();
+            const secretVersionIds = new Set();
+            for (const [index, referenceArg] of receiptArg.coverage.versionReferences.entries()) {
+                if (!isRecord(referenceArg)
+                    || !hasExactKeys(referenceArg, ['key', 'secretId', 'secretVersionId'])
+                    || referenceArg.key !== requiredKeys[index]
+                    || !isIdentifier(referenceArg.secretId)
+                    || !isIdentifier(referenceArg.secretVersionId)) {
+                    errors.push('corestore credential publication version references must exactly cover keys');
+                    break;
+                }
+                if (secretIds.has(referenceArg.secretId)
+                    || secretVersionIds.has(referenceArg.secretVersionId)) {
+                    errors.push('corestore credential publication version references must be unique');
+                    break;
+                }
+                secretIds.add(referenceArg.secretId);
+                secretVersionIds.add(referenceArg.secretVersionId);
+            }
+        }
+    }
+    const referenceCount = isRecord(receiptArg.coverage)
+        && Array.isArray(receiptArg.coverage.versionReferences)
+        ? receiptArg.coverage.versionReferences.length
+        : 0;
+    if (!isNonNegativeSafeInteger(receiptArg.expectedTargetSecretsRevision)
+        || !isNonNegativeSafeInteger(receiptArg.targetSecretsRevision)
+        || receiptArg.targetSecretsRevision !== receiptArg.expectedTargetSecretsRevision + referenceCount) {
+        errors.push('corestore credential publication target Secrets revision must exactly cover created versions');
+    }
+    const admission = receiptArg.ingressAdmissionBinding;
+    if (!isRecord(admission)
+        || !hasExactKeys(admission, [
+            'schemaVersion',
+            'recipientKeyId',
+            'recipientGeneration',
+            'envelopeDigest',
+            'requestContextDigest',
+        ])
+        || admission.schemaVersion !== 1
+        || !isIdentifier(admission.recipientKeyId)
+        || !isPositiveSafeInteger(admission.recipientGeneration)
+        || typeof admission.envelopeDigest !== 'string'
+        || !isSha256Digest(admission.envelopeDigest)
+        || typeof admission.requestContextDigest !== 'string'
+        || !isSha256Digest(admission.requestContextDigest)) {
+        errors.push('corestore credential publication ingress admission binding must be canonical');
+    }
+    else if (admission.recipientKeyId !== expectedArg.request.expectedIngressRecipientKeyId
+        || admission.recipientGeneration !== expectedArg.request.expectedIngressRecipientGeneration
+        || !await verifyPublicationAdmissionBinding(admission, expectedArg.request.envelope, createPublishCorestoreCredentialMaterialEnvelopeContext(expectedArg.request))) {
+        errors.push('corestore credential publication ingress admission binding must match the request');
+    }
+    if (!isPositiveSafeInteger(receiptArg.acceptedAt)
+        || receiptArg.acceptedAt < grant.issuedAt
+        || receiptArg.acceptedAt >= grant.expiresAt
+        || typeof receiptArg.replayed !== 'boolean') {
+        errors.push('corestore credential publication receipt acceptance must be canonical');
+    }
+    return errors;
+};
+export const corestoreCredentialPublicationErrorMetadata = Object.freeze({
+    INVALID_IDENTITY: Object.freeze({ retryable: false }),
+    INVALID_REQUEST: Object.freeze({ retryable: false }),
+    GRANT_EXPIRED: Object.freeze({ retryable: false }),
+    GRANT_SCOPE_MISMATCH: Object.freeze({ retryable: false }),
+    GRANT_REVISION_MISMATCH: Object.freeze({ retryable: true }),
+    INGRESS_RECIPIENT_MISMATCH: Object.freeze({ retryable: true }),
+    ENVELOPE_INVALID: Object.freeze({ retryable: false }),
+    MATERIAL_INVALID: Object.freeze({ retryable: false }),
+    SECRETS_REVISION_CONFLICT: Object.freeze({ retryable: true }),
+    REPLAY_CONFLICT: Object.freeze({ retryable: false }),
+    INTERNAL_ERROR: Object.freeze({ retryable: true }),
+});
+export const getCorestoreCredentialPublicationErrorMetadata = (codeArg) => ({
+    schemaVersion: 1,
+    code: codeArg,
+    retryable: corestoreCredentialPublicationErrorMetadata[codeArg].retryable,
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.corestore.js","sourceRoot":"","sources":["../ts/runtime.corestore.ts"],"names":[],"mappings":"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"}