@serve.zone/interfaces 32.48.0 → 32.49.0

package/dist_ts/appstore/versionconfig.js

@@ -0,0 +1,685 @@
+/**
+ * The member rules of an App Store version config.
+ *
+ * These are the rules the `@serve.zone/appstore` resolver applied before a host installed a
+ * version (`validateAppStoreVersionConfig` and its storage validation), owned here so the catalog
+ * contract judges every version config in full and every consumer judges it the same way. Each
+ * validator stops at the first violation, as the resolver did, and answers it as a one-element
+ * list; an empty list means the config passes.
+ *
+ * Where a value reaches a typed helper (`data.normalizeServicePortConfig`), it is first read as
+ * exactly that type, so a member of the wrong JSON type is refused here instead of being coerced.
+ *
+ * A storage request on its own — its members, capacity, protection, delivery and mount path — is
+ * judged by the package's one storage-request judge (`private/storagecontract.ts`, the rules behind
+ * `platform.normalizeStorageRequest`), reporting through this module's rejection. What this module
+ * adds are the rules a request can only break inside a version config: its class is declared and of
+ * its kind, the class backs a declared limit or protection, ids and destinations are used once, the
+ * legacy names stay reserved, and the storage feature ids are named.
+ */
+import { normalizeServiceAbsolutePath, validateServiceContainerArgs } from '../data/service.js';
+import { normalizeServicePortConfig } from '../data/serviceports.js';
+import { readDataElements, readDataProperties } from '../private/dataproperties.js';
+import { createStorageContractReaders } from '../private/storagecontract.js';
+import { appStoreStorageFeatureIds, validateAppStoreEnvironmentDeclarations, validateAppStoreVersionPlatformOidc, } from './types.js';
+const versionConfigMemberList = [
+    'image',
+    'port',
+    'containerArgs',
+    'targetPorts',
+    'domains',
+    'publicPortMappings',
+    'envVars',
+    'volumes',
+    'storageClasses',
+    'storageRequests',
+    'publishedPorts',
+    'platformRequirements',
+    'platformOidc',
+    'minOneboxVersion',
+    'minCloudlyVersion',
+    'appStoreVersion',
+    'upgradeStrategy',
+    'source',
+    'resolvedSource',
+    'resolvedImageDigest',
+    'changelog',
+    'breaking',
+    'requiresManualReview',
+    'migrationRequired',
+    'backupBeforeUpgrade',
+    'requiresFeatures',
+    'healthCheck',
+];
+/** Every member an `IAppStoreVersionConfig` may carry; any other member is refused. */
+export const appStoreVersionConfigKeys = Object.freeze(versionConfigMemberList);
+const defaultLabel = 'appstore config';
+const maximumPortListEntries = 256;
+const storageClassKeyPattern = /^[A-Za-z][A-Za-z0-9-]{0,62}$/;
+/**
+ * App Store request ids share one namespace with the ids derived for legacy volumes
+ * (`legacy-volume-<name>`) and legacy S3 (`legacy-s3`), so an author's id is a stable lowercase
+ * identifier; the storage contract alone admits any canonical identifier.
+ */
+const storageRequestIdPattern = /^[a-z][a-z0-9-]{0,62}$/;
+/**
+ * An App Store object-storage file delivery is one file directly below `/run/secrets`; the storage
+ * contract alone admits any path below it.
+ */
+const secretFileTargetPattern = /^\/run\/secrets\/[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const legacyFilesystemClassKey = 'legacyFilesystem';
+const legacyObjectStorageClassKey = 'legacyObjectStorage';
+const legacyObjectStorageRequestId = 'legacy-s3';
+const knownStorageFeatureIds = Object.values(appStoreStorageFeatureIds);
+const platformRequirementKeys = ['mongodb', 's3', 'clickhouse', 'valkey', 'mariadb', 'mail'];
+/** Thrown inside this module only; every exported validator answers it as its result. */
+class AppStoreVersionConfigRejection extends Error {
+}
+function reject(messageArg) {
+    throw new AppStoreVersionConfigRejection(messageArg);
+}
+const firstRejection = (runArg) => {
+    try {
+        runArg();
+        return [];
+    }
+    catch (error) {
+        if (error instanceof AppStoreVersionConfigRejection)
+            return [error.message];
+        throw error;
+    }
+};
+/**
+ * The package's storage-request judge, failing through this module's rejection. Its reasons start
+ * with the field they name, which is the label this module passes in.
+ */
+const storageContract = createStorageContractReaders((reasonArg) => reject(`Invalid ${reasonArg}`));
+function readRecord(valueArg, labelArg) {
+    return readDataProperties(valueArg) ?? reject(`Invalid ${labelArg}: expected an object`);
+}
+function assertExactKeys(recordArg, allowedKeysArg, labelArg) {
+    const unknownKeys = Object.keys(recordArg).filter((keyArg) => !allowedKeysArg.includes(keyArg));
+    if (unknownKeys.length > 0) {
+        reject(`Invalid ${labelArg}: unknown field(s) ${unknownKeys.sort().join(', ')}`);
+    }
+}
+function assertMember(valueArg, allowedValuesArg, labelArg) {
+    if (!allowedValuesArg.some((allowedArg) => allowedArg === valueArg)) {
+        reject(`Invalid ${labelArg}: expected one of ${allowedValuesArg.join(', ')}`);
+    }
+}
+function assertOptionalMember(valueArg, allowedValuesArg, labelArg) {
+    if (valueArg !== undefined)
+        assertMember(valueArg, allowedValuesArg, labelArg);
+}
+function assertValidPort(portArg, labelArg) {
+    if (typeof portArg !== 'number' || !Number.isInteger(portArg) || portArg < 1 || portArg > 65535) {
+        reject(`Invalid ${labelArg}: ${String(portArg)}. Expected an integer port between 1 and 65535.`);
+    }
+}
+const pathsOverlap = (leftArg, rightArg) => {
+    const left = normalizeServiceAbsolutePath(leftArg);
+    const right = normalizeServiceAbsolutePath(rightArg);
+    if (!left || !right)
+        return false;
+    if (left === '/' || right === '/')
+        return true;
+    return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+};
+function assertNoPathCollision(pathArg, pathsArg, labelArg) {
+    const collision = pathsArg.find((existingPathArg) => pathsOverlap(pathArg, existingPathArg));
+    if (collision)
+        reject(`Invalid ${labelArg}: path '${pathArg}' overlaps '${collision}'`);
+}
+// ---------------------------------------------------------------------------------------------
+// Ports
+const isServiceTargetProtocol = (valueArg) => valueArg === 'http' || valueArg === 'https' || valueArg === 'ssh' || valueArg === 'tcp'
+    || valueArg === 'udp' || (typeof valueArg === 'string' && valueArg.startsWith('custom:'));
+const isTargetPortRef = (valueArg) => typeof valueArg === 'string' || typeof valueArg === 'number';
+function readList(valueArg, labelArg) {
+    return readDataElements(valueArg, maximumPortListEntries)
+        ?? reject(`Invalid ${labelArg}: expected an array with at most ${maximumPortListEntries} entries`);
+}
+function readOptionalString(recordArg, keyArg, labelArg) {
+    const value = recordArg[keyArg];
+    if (value !== undefined && typeof value !== 'string')
+        reject(`Invalid ${labelArg}.${keyArg}: expected a string`);
+    return typeof value === 'string' ? value : undefined;
+}
+function readOptionalNumber(recordArg, keyArg, labelArg) {
+    const value = recordArg[keyArg];
+    if (value !== undefined && typeof value !== 'number')
+        reject(`Invalid ${labelArg}.${keyArg}: expected a number`);
+    return typeof value === 'number' ? value : undefined;
+}
+function readOptionalBoolean(recordArg, keyArg, labelArg) {
+    const value = recordArg[keyArg];
+    if (value !== undefined && typeof value !== 'boolean')
+        reject(`Invalid ${labelArg}.${keyArg}: expected a boolean`);
+    return typeof value === 'boolean' ? value : undefined;
+}
+const readTargetPorts = (valueArg, labelArg) => readList(valueArg, `${labelArg} targetPorts`).map((entryArg, indexArg) => {
+    const entryLabel = `${labelArg} targetPorts[${indexArg}]`;
+    const entry = readRecord(entryArg, entryLabel);
+    assertExactKeys(entry, ['name', 'port', 'portEnd', 'protocol', 'description', 'default'], entryLabel);
+    const { name, port, protocol } = entry;
+    if (typeof name !== 'string')
+        return reject(`Invalid ${entryLabel}.name: expected a string`);
+    if (typeof port !== 'number')
+        return reject(`Invalid ${entryLabel}.port: expected a number`);
+    if (!isServiceTargetProtocol(protocol)) {
+        return reject(`Invalid ${entryLabel}.protocol: expected http, https, ssh, tcp, udp or custom:<name>`);
+    }
+    const portEnd = readOptionalNumber(entry, 'portEnd', entryLabel);
+    const description = readOptionalString(entry, 'description', entryLabel);
+    const isDefault = readOptionalBoolean(entry, 'default', entryLabel);
+    return {
+        name,
+        port,
+        protocol,
+        ...(portEnd === undefined ? {} : { portEnd }),
+        ...(description === undefined ? {} : { description }),
+        ...(isDefault === undefined ? {} : { default: isDefault }),
+    };
+});
+const readDomains = (valueArg, labelArg) => readList(valueArg, `${labelArg} domains`).map((entryArg, indexArg) => {
+    const entryLabel = `${labelArg} domains[${indexArg}]`;
+    const entry = readRecord(entryArg, entryLabel);
+    assertExactKeys(entry, ['domainId', 'name', 'targetPort', 'port', 'protocol', 'sourceProfileRef', 'proxied'], entryLabel);
+    const { name, targetPort, protocol } = entry;
+    if (typeof name !== 'string')
+        return reject(`Invalid ${entryLabel}.name: expected a string`);
+    if (targetPort !== undefined && !isTargetPortRef(targetPort)) {
+        return reject(`Invalid ${entryLabel}.targetPort: expected a target port name or number`);
+    }
+    assertOptionalMember(protocol, ['http', 'https'], `${entryLabel}.protocol`);
+    const domainId = readOptionalString(entry, 'domainId', entryLabel);
+    const port = readOptionalNumber(entry, 'port', entryLabel);
+    const sourceProfileRef = readOptionalString(entry, 'sourceProfileRef', entryLabel);
+    const proxied = readOptionalBoolean(entry, 'proxied', entryLabel);
+    return {
+        name,
+        ...(domainId === undefined ? {} : { domainId }),
+        ...(targetPort === undefined ? {} : { targetPort }),
+        ...(port === undefined ? {} : { port }),
+        ...(protocol === undefined ? {} : { protocol }),
+        ...(sourceProfileRef === undefined ? {} : { sourceProfileRef }),
+        ...(proxied === undefined ? {} : { proxied }),
+    };
+});
+const readPublicPortMappings = (valueArg, labelArg) => readList(valueArg, `${labelArg} publicPortMappings`).map((entryArg, indexArg) => {
+    const entryLabel = `${labelArg} publicPortMappings[${indexArg}]`;
+    const entry = readRecord(entryArg, entryLabel);
+    assertExactKeys(entry, ['name', 'publicPort', 'publicPortEnd', 'targetPort', 'protocol', 'sourceProfileRef', 'exclusive'], entryLabel);
+    const { name, publicPort, targetPort, protocol, exclusive } = entry;
+    if (typeof name !== 'string')
+        return reject(`Invalid ${entryLabel}.name: expected a string`);
+    if (typeof publicPort !== 'number')
+        return reject(`Invalid ${entryLabel}.publicPort: expected a number`);
+    if (!isTargetPortRef(targetPort)) {
+        return reject(`Invalid ${entryLabel}.targetPort: expected a target port name or number`);
+    }
+    // The messages of data.normalizeServicePortConfig, which judges the same members afterwards.
+    if (exclusive !== true)
+        return reject(`Invalid ${labelArg}: Public port mapping '${name}' on ${labelArg} must be exclusive`);
+    if (protocol !== 'tcp' && protocol !== 'udp') {
+        return reject(`Invalid ${labelArg}: Public port mapping '${name}' on ${labelArg} has unsupported protocol '${String(protocol)}'`);
+    }
+    const publicPortEnd = readOptionalNumber(entry, 'publicPortEnd', entryLabel);
+    const sourceProfileRef = readOptionalString(entry, 'sourceProfileRef', entryLabel);
+    return {
+        name,
+        publicPort,
+        targetPort,
+        protocol,
+        exclusive,
+        ...(publicPortEnd === undefined ? {} : { publicPortEnd }),
+        ...(sourceProfileRef === undefined ? {} : { sourceProfileRef }),
+    };
+});
+function checkPortModel(configArg, labelArg) {
+    const { port } = configArg;
+    if (port !== undefined)
+        assertValidPort(port, `${labelArg} port`);
+    const targetPorts = configArg.targetPorts === undefined
+        ? undefined
+        : readTargetPorts(configArg.targetPorts, labelArg);
+    if (port === undefined && (!targetPorts || targetPorts.length === 0)) {
+        reject(`Invalid ${labelArg}: either port or targetPorts is required`);
+    }
+    const domains = configArg.domains === undefined ? undefined : readDomains(configArg.domains, labelArg);
+    const publicPortMappings = configArg.publicPortMappings === undefined
+        ? undefined
+        : readPublicPortMappings(configArg.publicPortMappings, labelArg);
+    try {
+        normalizeServicePortConfig({
+            name: labelArg,
+            ports: port !== undefined ? { web: port } : undefined,
+            targetPorts,
+            domains,
+            publicPortMappings,
+        });
+    }
+    catch (error) {
+        reject(`Invalid ${labelArg}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function checkPublishedPorts(publishedPortsArg, labelArg) {
+    if (publishedPortsArg === undefined)
+        return;
+    const entries = readList(publishedPortsArg, `${labelArg} publishedPorts`);
+    const seenPublishedPorts = new Set();
+    entries.forEach((entryArg, indexArg) => {
+        const entryLabel = `${labelArg} publishedPorts[${indexArg}]`;
+        const entry = readRecord(entryArg, entryLabel);
+        assertExactKeys(entry, ['targetPort', 'targetPortEnd', 'publishedPort', 'publishedPortEnd', 'protocol', 'hostIp'], entryLabel);
+        const protocol = entry.protocol || 'tcp';
+        const targetStart = entry.targetPort;
+        const hostIp = entry.hostIp || '0.0.0.0';
+        if (protocol !== 'tcp' && protocol !== 'udp') {
+            reject(`Invalid ${labelArg}: published port protocol '${String(protocol)}' is not supported`);
+        }
+        if (typeof hostIp !== 'string')
+            reject(`Invalid ${entryLabel}.hostIp: expected a string`);
+        assertValidPort(targetStart, `${labelArg} targetPort`);
+        const targetEnd = entry.targetPortEnd || targetStart;
+        assertValidPort(targetEnd, `${labelArg} targetPortEnd`);
+        const publishedStart = entry.publishedPort || targetStart;
+        assertValidPort(publishedStart, `${labelArg} publishedPort`);
+        const publishedEnd = entry.publishedPortEnd || (publishedStart + (targetEnd - targetStart));
+        assertValidPort(publishedEnd, `${labelArg} publishedPortEnd`);
+        if (targetEnd < targetStart || publishedEnd < publishedStart) {
+            reject(`Invalid ${labelArg}: published port ranges must be ascending`);
+        }
+        if ((targetEnd - targetStart) !== (publishedEnd - publishedStart)) {
+            reject(`Invalid ${labelArg}: target and published port ranges must have the same size`);
+        }
+        if ((targetEnd - targetStart) > 1000) {
+            reject(`Invalid ${labelArg}: published port ranges may not exceed 1001 ports`);
+        }
+        for (let offset = 0; offset <= targetEnd - targetStart; offset++) {
+            const publishedPort = publishedStart + offset;
+            const publishedKey = `${String(hostIp)}/${protocol}/${publishedPort}`;
+            const wildcardKey = `0.0.0.0/${protocol}/${publishedPort}`;
+            const conflictsWithWildcard = hostIp === '0.0.0.0'
+                ? Array.from(seenPublishedPorts).some((keyArg) => keyArg.endsWith(`/${protocol}/${publishedPort}`))
+                : seenPublishedPorts.has(wildcardKey);
+            if (seenPublishedPorts.has(publishedKey) || conflictsWithWildcard) {
+                reject(`Invalid ${labelArg}: duplicate published port ${String(hostIp)}:${publishedPort}/${protocol}`);
+            }
+            seenPublishedPorts.add(publishedKey);
+        }
+    });
+}
+function collectAppInputDestinations(configArg, labelArg) {
+    const declaredEnvironmentKeys = new Set();
+    const runtimeEnvironmentOwners = new Map();
+    const secretFileOwners = new Map();
+    const addDestination = (ownersArg, destinationArg, ownerArg, kindArg) => {
+        const existingOwner = ownersArg.get(destinationArg);
+        if (existingOwner) {
+            reject(`Invalid ${labelArg}: ${kindArg} destination '${destinationArg}' is used by both ${existingOwner} and ${ownerArg}`);
+        }
+        ownersArg.set(destinationArg, ownerArg);
+    };
+    // The declarations were judged by validateAppStoreEnvironmentDeclarations first.
+    for (const declarationArg of readDataElements(configArg.envVars, Number.MAX_SAFE_INTEGER) ?? []) {
+        const declaration = readDataProperties(declarationArg);
+        if (declaration === null || typeof declaration.key !== 'string')
+            continue;
+        declaredEnvironmentKeys.add(declaration.key);
+        const owner = `envVars.${declaration.key}`;
+        if (declaration.secret === true) {
+            const delivery = readDataProperties(declaration.delivery);
+            if (delivery?.type === 'launcher-environment' && typeof delivery.variableName === 'string') {
+                addDestination(runtimeEnvironmentOwners, delivery.variableName, owner, 'environment');
+            }
+            else if (delivery !== null && typeof delivery.targetPath === 'string') {
+                addDestination(secretFileOwners, delivery.targetPath, owner, 'secret file');
+            }
+        }
+        else {
+            addDestination(runtimeEnvironmentOwners, declaration.key, owner, 'environment');
+        }
+    }
+    const environmentVariables = readDataProperties(readDataProperties(configArg.platformOidc)?.environmentVariables);
+    for (const [field, destination] of Object.entries(environmentVariables ?? {})) {
+        if (typeof destination === 'string') {
+            addDestination(runtimeEnvironmentOwners, destination, `platformOidc.${field}`, 'environment');
+        }
+    }
+    return {
+        declaredEnvironmentKeys,
+        runtimeEnvironmentKeys: new Set(runtimeEnvironmentOwners.keys()),
+        declaredSecretPaths: new Set(secretFileOwners.keys()),
+    };
+}
+function checkPlatformRequirements(requirementsArg, labelArg) {
+    if (requirementsArg === undefined)
+        return {};
+    const requirements = readRecord(requirementsArg, `${labelArg} platformRequirements`);
+    assertExactKeys(requirements, platformRequirementKeys, `${labelArg} platformRequirements`);
+    for (const [keyArg, valueArg] of Object.entries(requirements)) {
+        if (typeof valueArg !== 'boolean') {
+            reject(`Invalid ${labelArg} platformRequirements.${keyArg}: expected a boolean`);
+        }
+    }
+    return requirements;
+}
+function checkClassRequirement(requirementArg, labelArg) {
+    if (requirementArg === undefined)
+        return undefined;
+    const requirement = readRecord(requirementArg, labelArg);
+    assertExactKeys(requirement, [
+        'performanceTier',
+        'durability',
+        'topology',
+        'hardQuota',
+        'snapshots',
+        'backup',
+        'encryptedInTransit',
+    ], labelArg);
+    assertOptionalMember(requirement.performanceTier, ['standard', 'highIops', 'capacity'], `${labelArg}.performanceTier`);
+    assertOptionalMember(requirement.durability, ['ephemeral', 'persistent'], `${labelArg}.durability`);
+    assertOptionalMember(requirement.topology, ['singleNode', 'multiNode'], `${labelArg}.topology`);
+    assertOptionalMember(requirement.snapshots, ['portable', 'native'], `${labelArg}.snapshots`);
+    for (const booleanKey of ['hardQuota', 'backup', 'encryptedInTransit']) {
+        if (requirement[booleanKey] !== undefined && requirement[booleanKey] !== true) {
+            reject(`Invalid ${labelArg}.${booleanKey}: only true may be declared`);
+        }
+    }
+    return requirement;
+}
+function checkStorageClasses(classesArg, labelArg) {
+    const classes = new Map();
+    if (classesArg === undefined)
+        return classes;
+    const entries = Object.entries(readRecord(classesArg, `${labelArg} storageClasses`));
+    if (entries.length === 0 || entries.length > 64) {
+        reject(`Invalid ${labelArg}: storageClasses must contain between 1 and 64 entries`);
+    }
+    for (const [classKey, candidateArg] of entries) {
+        if (!storageClassKeyPattern.test(classKey)) {
+            reject(`Invalid ${labelArg}: storage class key '${classKey}' is not stable`);
+        }
+        const classLabel = `${labelArg} storageClasses.${classKey}`;
+        const candidate = readRecord(candidateArg, classLabel);
+        assertExactKeys(candidate, ['kind', 'purpose', 'required', 'preferred'], classLabel);
+        const { kind } = candidate;
+        if (kind !== 'filesystem' && kind !== 'objectStorage') {
+            return reject(`Invalid ${classLabel}: kind must be filesystem or objectStorage`);
+        }
+        if (!['runtime', 'database', 'registry', 'backup'].some((purposeArg) => purposeArg === candidate.purpose)) {
+            reject(`Invalid ${classLabel}: purpose is not supported`);
+        }
+        const required = checkClassRequirement(candidate.required, `${classLabel}.required`);
+        const preferred = checkClassRequirement(candidate.preferred, `${classLabel}.preferred`);
+        if (required && preferred) {
+            for (const requirementKey of Object.keys(required)) {
+                if (preferred[requirementKey] !== undefined && preferred[requirementKey] !== required[requirementKey]) {
+                    reject(`Invalid ${classLabel}: preferred.${requirementKey} conflicts with required.${requirementKey}`);
+                }
+            }
+        }
+        classes.set(classKey, { kind, required });
+    }
+    return classes;
+}
+/** A judged delivery's destinations against the app's inputs and the other storage requests. */
+function checkObjectStorageDeliveryDestinations(deliveryArg, requestLabelArg, destinationsArg, deliveryEnvironmentKeysArg, deliverySecretPathsArg) {
+    const deliveryLabel = `${requestLabelArg}.delivery`;
+    if (deliveryArg.type === 'launcher-environment') {
+        for (const targetKey of Object.values(deliveryArg.keys)) {
+            if (destinationsArg.declaredEnvironmentKeys.has(targetKey)
+                || destinationsArg.runtimeEnvironmentKeys.has(targetKey)) {
+                reject(`Invalid ${deliveryLabel}: environment key '${targetKey}' collides with an app runtime input`);
+            }
+            if (deliveryEnvironmentKeysArg.has(targetKey)) {
+                reject(`Invalid ${deliveryLabel}: environment key '${targetKey}' is used by another storage request`);
+            }
+        }
+        for (const targetKey of Object.values(deliveryArg.keys))
+            deliveryEnvironmentKeysArg.add(targetKey);
+        return;
+    }
+    const { targetPath } = deliveryArg;
+    if (!secretFileTargetPattern.test(targetPath)) {
+        reject(`Invalid ${deliveryLabel}: targetPath must be a unique canonical file below /run/secrets`);
+    }
+    if (destinationsArg.declaredSecretPaths.has(targetPath)) {
+        reject(`Invalid ${deliveryLabel}: targetPath collides with an app secret delivery`);
+    }
+    if (deliverySecretPathsArg.has(targetPath)) {
+        reject(`Invalid ${deliveryLabel}: targetPath is used by another storage request`);
+    }
+    deliverySecretPathsArg.add(targetPath);
+}
+/**
+ * Each request is judged on its own by the storage contract, then against the version config it
+ * sits in: its id, its declared class and what that class backs, and its delivery destinations.
+ */
+function checkExplicitStorageRequests(requestsArg, classesArg, destinationsArg, labelArg) {
+    if (requestsArg === undefined)
+        return [];
+    const entries = readDataElements(requestsArg, 64);
+    if (entries === null || entries.length === 0) {
+        return reject(`Invalid ${labelArg}: storageRequests must contain between 1 and 64 entries`);
+    }
+    const requestIds = new Set();
+    const usedClassKeys = new Set();
+    const deliveryEnvironmentKeys = new Set();
+    const deliverySecretPaths = new Set();
+    const requests = entries.map((candidateArg, indexArg) => {
+        const requestLabel = `${labelArg} storageRequests[${indexArg}]`;
+        const request = storageContract.normalizeStorageRequest(candidateArg, requestLabel);
+        if (!storageRequestIdPattern.test(request.id)) {
+            reject(`Invalid ${requestLabel}: id must be a stable lowercase identifier`);
+        }
+        if (requestIds.has(request.id))
+            reject(`Invalid ${labelArg}: storage request id '${request.id}' is duplicated`);
+        requestIds.add(request.id);
+        const storageClass = classesArg.get(request.storageClass)
+            ?? reject(`Invalid ${requestLabel}: storageClass '${request.storageClass}' is not declared`);
+        if (storageClass.kind !== request.kind) {
+            reject(`Invalid ${requestLabel}: storageClass kind does not match request kind`);
+        }
+        usedClassKeys.add(request.storageClass);
+        if (request.capacity?.limit !== undefined && storageClass.required?.hardQuota !== true) {
+            reject(`Invalid ${requestLabel}: capacity.limit requires storageClass.required.hardQuota`);
+        }
+        if (request.protection?.backup === 'required' && storageClass.required?.backup !== true) {
+            reject(`Invalid ${requestLabel}: required backup must be declared by the storage class`);
+        }
+        if (request.kind === 'filesystem') {
+            const snapshots = request.protection?.snapshots;
+            if (snapshots !== undefined && storageClass.required?.snapshots !== snapshots) {
+                reject(`Invalid ${requestLabel}: required snapshots must be declared by the storage class`);
+            }
+            return request;
+        }
+        checkObjectStorageDeliveryDestinations(request.delivery, requestLabel, destinationsArg, deliveryEnvironmentKeys, deliverySecretPaths);
+        return request;
+    });
+    for (const classKey of classesArg.keys()) {
+        if (!usedClassKeys.has(classKey)) {
+            reject(`Invalid ${labelArg}: storage class '${classKey}' is not used by a request`);
+        }
+    }
+    return requests;
+}
+function checkFeatureDeclaration(requiresFeaturesArg, explicitRequestsArg, labelArg) {
+    const derivedFeatures = new Set();
+    if (explicitRequestsArg.length > 0)
+        derivedFeatures.add(appStoreStorageFeatureIds.bindings);
+    if (explicitRequestsArg.some((requestArg) => requestArg.kind === 'filesystem')) {
+        derivedFeatures.add(appStoreStorageFeatureIds.filesystem);
+    }
+    if (explicitRequestsArg.some((requestArg) => requestArg.kind === 'objectStorage')) {
+        derivedFeatures.add(appStoreStorageFeatureIds.objectStorage);
+    }
+    if (explicitRequestsArg.some((requestArg) => requestArg.kind === 'objectStorage' && requestArg.delivery.type === 'file')) {
+        derivedFeatures.add(appStoreStorageFeatureIds.objectStorageFile);
+    }
+    const declaredEntries = requiresFeaturesArg === undefined
+        ? []
+        : readDataElements(requiresFeaturesArg, Number.MAX_SAFE_INTEGER);
+    const declaredFeatures = [];
+    for (const entry of declaredEntries ?? [null]) {
+        if (typeof entry !== 'string')
+            return reject(`Invalid ${labelArg}: requiresFeatures must be an array of strings`);
+        declaredFeatures.push(entry);
+    }
+    if (new Set(declaredFeatures).size !== declaredFeatures.length) {
+        reject(`Invalid ${labelArg}: requiresFeatures must not contain duplicates`);
+    }
+    for (const derivedFeature of derivedFeatures) {
+        if (!declaredFeatures.includes(derivedFeature)) {
+            reject(`Invalid ${labelArg}: requiresFeatures is missing '${derivedFeature}'`);
+        }
+    }
+    for (const declaredFeature of declaredFeatures) {
+        if (declaredFeature.startsWith('storage.') && !knownStorageFeatureIds.includes(declaredFeature)) {
+            reject(`Invalid ${labelArg}: unknown storage feature '${declaredFeature}'`);
+        }
+        if (knownStorageFeatureIds.includes(declaredFeature) && !derivedFeatures.has(declaredFeature)) {
+            reject(`Invalid ${labelArg}: storage feature '${declaredFeature}' is not used`);
+        }
+    }
+}
+function checkLegacyVolumes(volumesArg, labelArg) {
+    if (volumesArg === undefined)
+        return [];
+    const entries = readDataElements(volumesArg, 64)
+        ?? reject(`Invalid ${labelArg}: volumes must be an array with at most 64 entries`);
+    return entries.map((volumeArg, indexArg) => {
+        const volumeLabel = `${labelArg} volumes[${indexArg}]`;
+        const volume = typeof volumeArg === 'string'
+            ? { mountPath: volumeArg }
+            : readRecord(volumeArg, volumeLabel);
+        assertExactKeys(volume, ['name', 'source', 'mountPath', 'driver', 'readOnly', 'backup', 'options'], volumeLabel);
+        for (const forbiddenKey of ['source', 'driver', 'options']) {
+            if (volume[forbiddenKey] !== undefined) {
+                reject(`Invalid ${volumeLabel}: physical field '${forbiddenKey}' cannot be normalized portably`);
+            }
+        }
+        const { name } = volume;
+        // A legacy volume becomes a filesystem storage request, so its mount path is a request's.
+        const mountPath = storageContract.readMountPath(volume.mountPath, `${volumeLabel}.mountPath`);
+        if (name !== undefined && (typeof name !== 'string' || !storageRequestIdPattern.test(name))) {
+            reject(`Invalid ${volumeLabel}: name must be a stable lowercase identifier`);
+        }
+        for (const booleanKey of ['readOnly', 'backup']) {
+            if (volume[booleanKey] !== undefined && typeof volume[booleanKey] !== 'boolean') {
+                reject(`Invalid ${volumeLabel}.${booleanKey}: expected a boolean`);
+            }
+        }
+        return {
+            mountPath,
+            ...(typeof name === 'string' ? { name } : {}),
+        };
+    });
+}
+function legacyVolumeRequestId(volumeArg, indexArg, labelArg) {
+    const stablePart = volumeArg.name || volumeArg.mountPath
+        .toLowerCase()
+        .split('/')
+        .filter(Boolean)
+        .join('-')
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    const requestId = `legacy-volume-${stablePart}`;
+    if (!stablePart || !storageRequestIdPattern.test(requestId)) {
+        reject(`Invalid ${labelArg} volumes[${indexArg}]: cannot derive a stable request id; declare a shorter lowercase name`);
+    }
+    return requestId;
+}
+function checkStorage(configArg, labelArg) {
+    assertExactKeys(configArg, appStoreVersionConfigKeys, labelArg);
+    const environmentErrors = validateAppStoreEnvironmentDeclarations(configArg.envVars);
+    if (environmentErrors.length > 0)
+        reject(`Invalid ${labelArg}: ${environmentErrors.join('; ')}`);
+    const destinations = collectAppInputDestinations(configArg, labelArg);
+    const platformRequirements = checkPlatformRequirements(configArg.platformRequirements, labelArg);
+    if ((configArg.storageClasses !== undefined) !== (configArg.storageRequests !== undefined)) {
+        reject(`Invalid ${labelArg}: storageClasses and storageRequests must be declared together`);
+    }
+    const storageClasses = checkStorageClasses(configArg.storageClasses, labelArg);
+    const explicitRequests = checkExplicitStorageRequests(configArg.storageRequests, storageClasses, destinations, labelArg);
+    checkFeatureDeclaration(configArg.requiresFeatures, explicitRequests, labelArg);
+    const legacyS3 = platformRequirements.s3 === true;
+    if (legacyS3 && explicitRequests.some((requestArg) => requestArg.kind === 'objectStorage')) {
+        reject(`Invalid ${labelArg}: platformRequirements.s3 cannot coexist with explicit objectStorage requests`);
+    }
+    const requestIds = new Set(explicitRequests.map((requestArg) => requestArg.id));
+    const mountPaths = explicitRequests.flatMap((requestArg) => (requestArg.kind === 'filesystem' ? [requestArg.mountPath] : []));
+    const legacyVolumes = checkLegacyVolumes(configArg.volumes, labelArg);
+    if (legacyVolumes.length > 0 && storageClasses.has(legacyFilesystemClassKey)) {
+        reject(`Invalid ${labelArg}: storageClasses key '${legacyFilesystemClassKey}' is reserved for legacy volume normalization`);
+    }
+    const allMounts = explicitRequests.flatMap((requestArg) => (requestArg.kind === 'filesystem' ? [{ id: requestArg.id, mountPath: requestArg.mountPath }] : []));
+    legacyVolumes.forEach((volumeArg, indexArg) => {
+        const requestId = legacyVolumeRequestId(volumeArg, indexArg, labelArg);
+        if (requestIds.has(requestId))
+            reject(`Invalid ${labelArg}: storage request id '${requestId}' is duplicated`);
+        assertNoPathCollision(volumeArg.mountPath, mountPaths, `${labelArg} legacy volume ${indexArg + 1}`);
+        requestIds.add(requestId);
+        mountPaths.push(volumeArg.mountPath);
+        allMounts.push({ id: requestId, mountPath: volumeArg.mountPath });
+    });
+    if (legacyS3) {
+        if (storageClasses.has(legacyObjectStorageClassKey)) {
+            reject(`Invalid ${labelArg}: storageClasses key '${legacyObjectStorageClassKey}' is reserved for legacy S3 normalization`);
+        }
+        if (requestIds.has(legacyObjectStorageRequestId)) {
+            reject(`Invalid ${labelArg}: storage request id '${legacyObjectStorageRequestId}' is reserved for legacy S3 normalization`);
+        }
+    }
+    const checkedMounts = [];
+    for (const mount of allMounts) {
+        assertNoPathCollision(mount.mountPath, checkedMounts, `${labelArg} request '${mount.id}'`);
+        checkedMounts.push(mount.mountPath);
+    }
+    const objectSecretPaths = explicitRequests.flatMap((requestArg) => (requestArg.kind === 'objectStorage' && requestArg.delivery.type === 'file' ? [requestArg.delivery.targetPath] : []));
+    for (const secretPath of [...destinations.declaredSecretPaths, ...objectSecretPaths]) {
+        if (checkedMounts.some((mountPathArg) => pathsOverlap(secretPath, mountPathArg))) {
+            reject(`Invalid ${labelArg}: secret target '${secretPath}' overlaps a filesystem mount`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------------------------
+// Exported validators
+function readConfig(configArg, labelArg) {
+    return readDataProperties(configArg) ?? reject(`Invalid ${labelArg}: config must be an object`);
+}
+/** `port`, `targetPorts`, `domains` and `publicPortMappings`, resolved as a host resolves them. */
+export const validateAppStoreVersionPortModel = (configArg, labelArg = defaultLabel) => firstRejection(() => checkPortModel(readConfig(configArg, labelArg), labelArg));
+/** Docker `publishedPorts`: canonical ranges and no published port taken twice. */
+export const validateAppStorePublishedPorts = (publishedPortsArg, labelArg = defaultLabel) => firstRejection(() => checkPublishedPorts(publishedPortsArg, labelArg));
+/**
+ * The config's member set and its storage: legacy `volumes`, `storageClasses`, `storageRequests`,
+ * `platformRequirements`, the storage feature ids `requiresFeatures` must name, and every
+ * environment, secret-file and mount destination being used once.
+ */
+export const validateAppStoreVersionStorage = (configArg, labelArg = defaultLabel) => firstRejection(() => checkStorage(readConfig(configArg, labelArg), labelArg));
+/**
+ * Every member rule of a version config, in the order a host applies them: image, port model,
+ * container arguments, environment declarations, storage, platform OIDC, published ports.
+ */
+export const validateAppStoreVersionConfig = (configArg, labelArg = defaultLabel) => firstRejection(() => {
+    const config = readConfig(configArg, labelArg);
+    if (!config.image || typeof config.image !== 'string')
+        reject(`Invalid ${labelArg}: image is required`);
+    checkPortModel(config, labelArg);
+    const containerArgErrors = validateServiceContainerArgs(config.containerArgs);
+    if (containerArgErrors.length > 0)
+        reject(`Invalid ${labelArg}: ${containerArgErrors.join('; ')}`);
+    const environmentErrors = validateAppStoreEnvironmentDeclarations(config.envVars);
+    if (environmentErrors.length > 0)
+        reject(`Invalid ${labelArg}: ${environmentErrors.join('; ')}`);
+    checkStorage(config, labelArg);
+    const platformOidcErrors = validateAppStoreVersionPlatformOidc(config);
+    if (platformOidcErrors.length > 0)
+        reject(`Invalid ${labelArg}: ${platformOidcErrors.join('; ')}`);
+    checkPublishedPorts(config.publishedPorts, labelArg);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"versionconfig.js","sourceRoot":"","sources":["../../ts/appstore/versionconfig.ts"],"names":[],"mappings":"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"}