@serve.zone/interfaces 32.24.0 → 32.26.0

package/dist_ts/platform/objectstorage.js

@@ -18,4 +18,139 @@ export const validatePlatformObjectStorageBucketName = (bucketNameArg, pathArg =
     }
     return [];
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0c3RvcmFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3BsYXRmb3JtL29iamVjdHN0b3JhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBT0EsTUFBTSxDQUFDLE1BQU0scUNBQXFDLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQztJQUNqRSxZQUFZLEVBQUUsQ0FBQztJQUNmLFlBQVksRUFBRSxFQUFFO0NBQ2pCLENBQUMsQ0FBQztBQUVILHNGQUFzRjtBQUN0RixNQUFNLENBQUMsTUFBTSx1Q0FBdUMsR0FBRyxDQUNyRCxhQUFzQixFQUN0QixPQUFPLEdBQUcsMEJBQTBCLEVBQzFCLEVBQUU7SUFDWixJQUFJLE9BQU8sYUFBYSxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBQ3RDLE9BQU8sQ0FBQyxHQUFHLE9BQU8scUNBQXFDLENBQUMsQ0FBQztJQUMzRCxDQUFDO0lBQ0QsTUFBTSxTQUFTLEdBQUcsYUFBYSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUMzQyxNQUFNLGFBQWEsR0FBRyxTQUFTLENBQUMsTUFBTSxLQUFLLENBQUMsSUFBSSxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxDQUMzRSxVQUFVLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsSUFBSSxHQUFHLENBQ25ELENBQUMsQ0FBQztJQUNILElBQUksYUFBYSxDQUFDLE1BQU0sR0FBRyxxQ0FBcUMsQ0FBQyxZQUFZO1dBQ3hFLGFBQWEsQ0FBQyxNQUFNLEdBQUcscUNBQXFDLENBQUMsWUFBWTtXQUN6RSxDQUFDLCtCQUErQixDQUFDLElBQUksQ0FBQyxhQUFhLENBQUM7V0FDcEQsYUFBYSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUM7V0FDNUIsYUFBYSxFQUFFLENBQUM7UUFDbkIsT0FBTyxDQUFDLEdBQUcsT0FBTyxxQ0FBcUMsQ0FBQyxDQUFDO0lBQzNELENBQUM7SUFDRCxPQUFPLEVBQUUsQ0FBQztBQUNaLENBQUMsQ0FBQyJ9
+export const platformObjectStorageEndpointLimits = Object.freeze({
+    maximumEndpointLength: 2048,
+    maximumRegionLength: 64,
+});
+const platformObjectStorageRegionPattern = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+const isPlainObject = (valueArg) => (Boolean(valueArg)
+    && typeof valueArg === 'object'
+    && !Array.isArray(valueArg)
+    && (Object.getPrototypeOf(valueArg) === Object.prototype
+        || Object.getPrototypeOf(valueArg) === null));
+/** Validates an object-storage endpoint and names every reason it is refused. */
+export const validatePlatformObjectStorageEndpoint = (valueArg, pathArg = 'objectstorage endpoint') => {
+    if (!isPlainObject(valueArg)
+        || Object.keys(valueArg).length !== 2
+        || !Object.hasOwn(valueArg, 'endpoint')
+        || !Object.hasOwn(valueArg, 'region')) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    const endpoint = valueArg.endpoint;
+    if (typeof endpoint !== 'string'
+        || endpoint.length === 0
+        || endpoint.length > platformObjectStorageEndpointLimits.maximumEndpointLength) {
+        errors.push(`${pathArg} endpoint must be a string of 1 to `
+            + `${platformObjectStorageEndpointLimits.maximumEndpointLength} characters`);
+    }
+    else {
+        let parsedEndpoint;
+        try {
+            parsedEndpoint = new URL(endpoint);
+        }
+        catch {
+            errors.push(`${pathArg} endpoint must be a parsable URL`);
+        }
+        if (parsedEndpoint) {
+            if (parsedEndpoint.protocol !== 'http:' && parsedEndpoint.protocol !== 'https:') {
+                errors.push(`${pathArg} endpoint must use the http or https scheme`);
+            }
+            if (parsedEndpoint.username || parsedEndpoint.password) {
+                errors.push(`${pathArg} endpoint must not carry userinfo`);
+            }
+            if (parsedEndpoint.origin !== endpoint) {
+                errors.push(`${pathArg} endpoint must be a canonical origin without a path, query, `
+                    + 'fragment, trailing slash or default port');
+            }
+        }
+    }
+    if (typeof valueArg.region !== 'string'
+        || !platformObjectStorageRegionPattern.test(valueArg.region)) {
+        errors.push(`${pathArg} region must be 1 to `
+            + `${platformObjectStorageEndpointLimits.maximumRegionLength} lowercase letters, digits `
+            + 'and inner hyphens');
+    }
+    return errors;
+};
+/**
+ * The non-secret environment names that tell a workload where its bucket is.
+ *
+ * These are the names Corestore has always handed a workload for a bucket, so an application that
+ * read them keeps working unchanged. The six credential aliases (`S3_ACCESS_KEY`,
+ * `S3_ACCESS_KEY_ID`, `S3_SECRET_KEY`, `S3_SECRET_ACCESS_KEY`, `AWS_ACCESS_KEY_ID`,
+ * `AWS_SECRET_ACCESS_KEY`) are not among them: they are Secrets and reach the workload only through
+ * the binding's sealed Secret set.
+ *
+ * - `S3_ENDPOINT`, `AWS_ENDPOINT_URL`: the endpoint origin, identical.
+ * - `S3_ENDPOINT_HOST`: the origin's host, as the URL states it (an IPv6 literal keeps its brackets).
+ * - `S3_PORT`: the origin's port in decimal, `80` or `443` when the origin states none.
+ * - `S3_USE_SSL`: `true` for an `https:` origin, `false` for `http:`.
+ * - `S3_REGION`, `AWS_REGION`: the signing region, identical.
+ * - `S3_BUCKET`: the binding's bucket, `IPlatformBinding.objectstorageBucketName`.
+ * - `AWS_S3_FORCE_PATH_STYLE`: always `true` — a node-local origin has no wildcard DNS and a bucket
+ *   name may contain dots, so path-style addressing is the only one that reaches the bucket.
+ */
+export const objectStorageEndpointEnvironmentKeys = Object.freeze([
+    'S3_ENDPOINT',
+    'S3_ENDPOINT_HOST',
+    'S3_PORT',
+    'S3_REGION',
+    'S3_BUCKET',
+    'S3_USE_SSL',
+    'AWS_ENDPOINT_URL',
+    'AWS_REGION',
+    'AWS_S3_FORCE_PATH_STYLE',
+]);
+/**
+ * The endpoint environment for one bucket.
+ *
+ * Throws the first reason the endpoint or the bucket name is refused; nothing is defaulted.
+ */
+export const createObjectStorageEndpointEnvironment = (endpointArg, bucketNameArg) => {
+    const errors = [
+        ...validatePlatformObjectStorageEndpoint(endpointArg),
+        ...validatePlatformObjectStorageBucketName(bucketNameArg),
+    ];
+    if (errors.length > 0)
+        throw new Error(errors[0]);
+    const origin = new URL(endpointArg.endpoint);
+    const useSsl = origin.protocol === 'https:';
+    return {
+        S3_ENDPOINT: endpointArg.endpoint,
+        S3_ENDPOINT_HOST: origin.hostname,
+        S3_PORT: origin.port || (useSsl ? '443' : '80'),
+        S3_REGION: endpointArg.region,
+        S3_BUCKET: bucketNameArg,
+        S3_USE_SSL: useSsl ? 'true' : 'false',
+        AWS_ENDPOINT_URL: endpointArg.endpoint,
+        AWS_REGION: endpointArg.region,
+        AWS_S3_FORCE_PATH_STYLE: 'true',
+    };
+};
+/**
+ * Validates an endpoint environment: exactly its nine keys, each value the one
+ * `createObjectStorageEndpointEnvironment()` derives from the same endpoint and bucket.
+ */
+export const validateObjectStorageEndpointEnvironment = (environmentArg, pathArg = 'objectstorage endpoint environment') => {
+    if (!isPlainObject(environmentArg)
+        || Object.keys(environmentArg).length !== objectStorageEndpointEnvironmentKeys.length
+        || objectStorageEndpointEnvironmentKeys.some((keyArg) => (!Object.hasOwn(environmentArg, keyArg) || typeof environmentArg[keyArg] !== 'string'))) {
+        return [`${pathArg} must contain exactly its string keys`];
+    }
+    const endpoint = { endpoint: environmentArg.S3_ENDPOINT, region: environmentArg.S3_REGION };
+    const errors = [
+        ...validatePlatformObjectStorageEndpoint(endpoint, pathArg),
+        ...validatePlatformObjectStorageBucketName(environmentArg.S3_BUCKET, `${pathArg} S3_BUCKET`),
+    ];
+    if (errors.length > 0)
+        return errors;
+    const expected = createObjectStorageEndpointEnvironment(endpoint, environmentArg.S3_BUCKET);
+    for (const key of objectStorageEndpointEnvironmentKeys) {
+        if (environmentArg[key] !== expected[key]) {
+            errors.push(`${pathArg} ${key} must equal the value derived from its endpoint`);
+        }
+    }
+    return errors;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/platform/objectstorageenvironment.d.ts

@@ -0,0 +1,108 @@
+import type { IPlatformBinding } from './types.js';
+import type { IPlatformObjectStorageEndpoint, TObjectStorageEndpointEnvironment, TObjectStorageEndpointEnvironmentKey } from './objectstorage.js';
+import type { TServiceRuntimeRefusal, TServiceRuntimeWaitingReason } from '../data/serviceruntime.js';
+import type { TObjectStorageRetentionEnvironment, TObjectStorageRetentionEnvironmentKey } from './objectstorageretention.js';
+/**
+ * Every non-secret environment name an object-storage binding can give a workload: the nine
+ * endpoint names first, then the eleven retention names.
+ */
+export declare const objectStorageBindingEnvironmentKeys: readonly ["S3_ENDPOINT", "S3_ENDPOINT_HOST", "S3_PORT", "S3_REGION", "S3_BUCKET", "S3_USE_SSL", "AWS_ENDPOINT_URL", "AWS_REGION", "AWS_S3_FORCE_PATH_STYLE", "S3_RETENTION_MODE", "S3_RETENTION_POLICY_ID", "S3_RETENTION_DURATION_SECONDS", "S3_RETENTION_INTENT_SHA256", "S3_RETENTION_SENTINEL_KEY", "S3_RETENTION_CONFIGURED_AT", "S3_RETENTION_SENTINEL_CREATED_AT", "S3_RETENTION_SENTINEL_RETAIN_UNTIL", "S3_RETENTION_SENTINEL_PAYLOAD_SHA256", "S3_RETENTION_SENTINEL_METADATA_SHA256", "S3_RETENTION_SENTINEL_ETAG"];
+export type TObjectStorageBindingEnvironmentKey = TObjectStorageEndpointEnvironmentKey | TObjectStorageRetentionEnvironmentKey;
+/**
+ * The non-secret environment of one object-storage binding: always the endpoint names, and the
+ * retention names exactly when the binding declares compliance retention. Never a credential.
+ */
+export type TObjectStorageBindingEnvironment = TObjectStorageEndpointEnvironment | (TObjectStorageEndpointEnvironment & TObjectStorageRetentionEnvironment);
+/**
+ * The environment Cloudly composes into a workload's runtime configuration for one binding.
+ *
+ * `bindingArg` is the Cloudly binding document and `endpointArg` the
+ * `IClusterNode.data.corestoreObjectStorage` of the node the binding is placed on. Refused by
+ * name, never guessed:
+ *
+ * - a binding that is not `objectstorage` or carries no canonical `objectstorageBucketName`;
+ * - an endpoint that `validatePlatformObjectStorageEndpoint()` refuses;
+ * - a binding that declares `objectstorageRetention` without `evidence`. Its bucket's retention is
+ *   not proven yet, so the workload is not given an environment that would let it run as if its
+ *   bucket were ordinary storage; the caller waits for the evidence.
+ * - evidence that does not prove the binding's own service, binding id, bucket and intent.
+ *
+ * A binding without `objectstorageRetention` gets the endpoint names alone: it promised no
+ * retention, so there is nothing to state.
+ *
+ * The evidence's reconciliation generation and binding-request digest are read from its own
+ * authority: they are what Cloudly checked when it admitted the evidence, and the binding document
+ * does not repeat them. Everything the binding does state is checked again here.
+ *
+ * `composeObjectStorageServiceEnvironment()` answers the same questions with a service runtime
+ * reason instead of an error.
+ */
+export declare const createObjectStorageBindingEnvironment: (bindingArg: IPlatformBinding, endpointArg: IPlatformObjectStorageEndpoint) => Promise<TObjectStorageBindingEnvironment>;
+/**
+ * Validates one binding's environment: the nine endpoint names, the eleven retention names all or
+ * none, and nothing else — so a credential alias, or any other name, is refused.
+ */
+export declare const validateObjectStorageBindingEnvironment: (environmentArg: unknown, pathArg?: string) => Promise<string[]>;
+/**
+ * A workload environment with one binding's environment added.
+ *
+ * Refuses, naming every key, when the environment already holds one of the binding's names: a
+ * service that sets `S3_ENDPOINT` itself, or a second object-storage binding on the same service,
+ * would otherwise have one value silently replace the other. The inputs are not changed.
+ */
+export declare const mergeObjectStorageBindingEnvironment: (environmentArg: Readonly<Record<string, string>>, bindingEnvironmentArg: TObjectStorageBindingEnvironment) => Record<string, string>;
+/** One enabled object-storage binding of a service and the endpoint of the node it is placed on. */
+export interface IObjectStorageBindingEnvironmentSource {
+    binding: IPlatformBinding;
+    /**
+     * The `IClusterNode.data.corestoreObjectStorage` of the node the binding is placed on, `null`
+     * when that node states none. A binding placed on no node is not a source: its service waits as
+     * `bindings-pending`.
+     */
+    endpoint: IPlatformObjectStorageEndpoint | null;
+}
+/**
+ * The service runtime waiting reason an object-storage environment reports:
+ * `objectstorage-retention-pending`, a binding that declares compliance retention whose evidence
+ * has not arrived.
+ */
+export type TObjectStorageEnvironmentWaitingReason = Extract<TServiceRuntimeWaitingReason, 'objectstorage-retention-pending'>;
+/**
+ * The service runtime refusals an object-storage environment reports.
+ * `objectstorage-endpoint-missing` is a binding whose node states no valid
+ * `corestoreObjectStorage`; `objectstorage-binding-invalid` a binding
+ * `createObjectStorageBindingEnvironment()` refuses (not `objectstorage`, no canonical bucket, no
+ * canonical retention intent, or evidence that does not prove this binding);
+ * `objectstorage-environment-conflict` a name the service's own environment or another binding
+ * already sets.
+ */
+export type TObjectStorageEnvironmentRefusal = Extract<TServiceRuntimeRefusal, 'objectstorage-endpoint-missing' | 'objectstorage-binding-invalid' | 'objectstorage-environment-conflict'>;
+/** A service's environment with every object-storage binding added, or the one reason it is not. */
+export type TObjectStorageServiceEnvironmentComposition = {
+    status: 'composed';
+    environment: Record<string, string>;
+} | {
+    status: 'waiting';
+    reason: TObjectStorageEnvironmentWaitingReason;
+    bindingId: string;
+    message: string;
+} | {
+    status: 'refused';
+    reason: TObjectStorageEnvironmentRefusal;
+    bindingId: string;
+    message: string;
+};
+/**
+ * The service's own environment with the environment of every enabled object-storage binding
+ * added, or the service runtime reason it cannot be — so a producer reports the contract's
+ * verdict instead of classifying its errors.
+ *
+ * Each binding's names are `createObjectStorageBindingEnvironment()`'s from its node's endpoint,
+ * added as `mergeObjectStorageBindingEnvironment()` adds them. Bindings are taken in id order, so
+ * the verdict does not depend on the order of `sourcesArg`. A refusal outranks a wait, because a
+ * wait resolves on its own and a refusal never does: a binding waiting for retention evidence
+ * already claims all twenty of its names, so a collision with it is refused now, not once its
+ * evidence arrives. The first refusal is answered, otherwise the first wait, otherwise the
+ * composed environment. The inputs are not changed.
+ */
+export declare const composeObjectStorageServiceEnvironment: (serviceEnvironmentArg: Readonly<Record<string, string>>, sourcesArg: readonly IObjectStorageBindingEnvironmentSource[]) => Promise<TObjectStorageServiceEnvironmentComposition>;

package/dist_ts/platform/objectstorageenvironment.js

@@ -0,0 +1,194 @@
+import { createObjectStorageEndpointEnvironment, objectStorageEndpointEnvironmentKeys, validateObjectStorageEndpointEnvironment, validatePlatformObjectStorageBucketName, validatePlatformObjectStorageEndpoint, } from './objectstorage.js';
+import { createObjectStorageRetentionEnvironment, objectStorageRetentionEnvironmentKeys, validateObjectStorageRetentionEnvironment, validateObjectStorageRetentionEvidence, validateObjectStorageRetentionIntent, } from './objectstorageretention.js';
+import { isPlainRecord, readDataProperties } from '../private/dataproperties.js';
+/**
+ * Every non-secret environment name an object-storage binding can give a workload: the nine
+ * endpoint names first, then the eleven retention names.
+ */
+export const objectStorageBindingEnvironmentKeys = Object.freeze([
+    ...objectStorageEndpointEnvironmentKeys,
+    ...objectStorageRetentionEnvironmentKeys,
+]);
+/**
+ * The one place a binding's environment is decided. `createObjectStorageBindingEnvironment()`
+ * throws its message, `composeObjectStorageServiceEnvironment()` reports its reason.
+ */
+const resolveBindingEnvironment = async (bindingArg, endpointArg) => {
+    const binding = readDataProperties(bindingArg);
+    if (binding === null || binding.capability !== 'objectstorage') {
+        return { status: 'refused', reason: 'objectstorage-binding-invalid',
+            message: 'objectstorage binding environment requires an objectstorage binding' };
+    }
+    const bindingName = typeof binding.id === 'string' ? binding.id : '(unnamed)';
+    if (validatePlatformObjectStorageBucketName(binding.objectstorageBucketName).length > 0) {
+        return { status: 'refused', reason: 'objectstorage-binding-invalid',
+            message: `objectstorage binding ${bindingName} carries no canonical bucket name; Cloudly owns `
+                + 'it and no environment invents one' };
+    }
+    if (endpointArg === null) {
+        return { status: 'refused', reason: 'objectstorage-endpoint-missing',
+            message: `objectstorage binding ${bindingName} is placed on a node that states no `
+                + 'corestoreObjectStorage endpoint' };
+    }
+    const endpointErrors = validatePlatformObjectStorageEndpoint(endpointArg);
+    if (endpointErrors.length > 0) {
+        return { status: 'refused', reason: 'objectstorage-endpoint-missing', message: endpointErrors[0] };
+    }
+    const bucketName = binding.objectstorageBucketName;
+    const endpointEnvironment = createObjectStorageEndpointEnvironment(endpointArg, bucketName);
+    const retention = binding.objectstorageRetention;
+    if (retention === undefined) {
+        return { status: 'composed', environment: endpointEnvironment };
+    }
+    const retentionBinding = readDataProperties(retention);
+    if (retentionBinding === null
+        || validateObjectStorageRetentionIntent(retentionBinding.intent).length > 0) {
+        return { status: 'refused', reason: 'objectstorage-binding-invalid',
+            message: `objectstorage binding ${bindingName} must declare canonical compliance-retention `
+                + 'intent' };
+    }
+    const evidence = retentionBinding.evidence;
+    if (evidence === undefined) {
+        return { status: 'waiting', reason: 'objectstorage-retention-pending',
+            message: `objectstorage binding ${bindingName} declares compliance retention without `
+                + 'verified evidence; its workload environment waits for the evidence' };
+    }
+    const authority = isPlainRecord(evidence) ? readDataProperties(evidence.authority) : null;
+    if (authority === null) {
+        return { status: 'refused', reason: 'objectstorage-binding-invalid',
+            message: 'objectstorage retention evidence must use its exact schema' };
+    }
+    const expectation = {
+        serviceId: binding.serviceId,
+        bindingId: binding.id,
+        reconciliationGeneration: authority.reconciliationGeneration,
+        bindingRequestDigest: authority.bindingRequestDigest,
+        bucketName,
+        intent: retentionBinding.intent,
+    };
+    const evidenceErrors = await validateObjectStorageRetentionEvidence(evidence, expectation);
+    if (evidenceErrors.length > 0) {
+        return { status: 'refused', reason: 'objectstorage-binding-invalid', message: evidenceErrors[0] };
+    }
+    const retentionEnvironment = await createObjectStorageRetentionEnvironment(evidence, expectation);
+    return { status: 'composed', environment: { ...endpointEnvironment, ...retentionEnvironment } };
+};
+/**
+ * The environment Cloudly composes into a workload's runtime configuration for one binding.
+ *
+ * `bindingArg` is the Cloudly binding document and `endpointArg` the
+ * `IClusterNode.data.corestoreObjectStorage` of the node the binding is placed on. Refused by
+ * name, never guessed:
+ *
+ * - a binding that is not `objectstorage` or carries no canonical `objectstorageBucketName`;
+ * - an endpoint that `validatePlatformObjectStorageEndpoint()` refuses;
+ * - a binding that declares `objectstorageRetention` without `evidence`. Its bucket's retention is
+ *   not proven yet, so the workload is not given an environment that would let it run as if its
+ *   bucket were ordinary storage; the caller waits for the evidence.
+ * - evidence that does not prove the binding's own service, binding id, bucket and intent.
+ *
+ * A binding without `objectstorageRetention` gets the endpoint names alone: it promised no
+ * retention, so there is nothing to state.
+ *
+ * The evidence's reconciliation generation and binding-request digest are read from its own
+ * authority: they are what Cloudly checked when it admitted the evidence, and the binding document
+ * does not repeat them. Everything the binding does state is checked again here.
+ *
+ * `composeObjectStorageServiceEnvironment()` answers the same questions with a service runtime
+ * reason instead of an error.
+ */
+export const createObjectStorageBindingEnvironment = async (bindingArg, endpointArg) => {
+    const resolution = await resolveBindingEnvironment(bindingArg, endpointArg);
+    if (resolution.status !== 'composed')
+        throw new Error(resolution.message);
+    return resolution.environment;
+};
+/**
+ * Validates one binding's environment: the nine endpoint names, the eleven retention names all or
+ * none, and nothing else — so a credential alias, or any other name, is refused.
+ */
+export const validateObjectStorageBindingEnvironment = async (environmentArg, pathArg = 'objectstorage binding environment') => {
+    const environment = readDataProperties(environmentArg);
+    if (environment === null) {
+        return [`${pathArg} must be a plain record of data properties`];
+    }
+    const allowedKeys = objectStorageBindingEnvironmentKeys;
+    const foreignKeys = Object.keys(environment).filter((keyArg) => !allowedKeys.includes(keyArg));
+    if (foreignKeys.length > 0) {
+        return [`${pathArg} must not contain ${foreignKeys.sort().join(', ')}`];
+    }
+    const endpointEnvironment = {};
+    for (const key of objectStorageEndpointEnvironmentKeys) {
+        if (Object.hasOwn(environment, key))
+            endpointEnvironment[key] = environment[key];
+    }
+    const errors = validateObjectStorageEndpointEnvironment(endpointEnvironment, pathArg);
+    const retentionKeys = objectStorageRetentionEnvironmentKeys.filter((keyArg) => (Object.hasOwn(environment, keyArg)));
+    if (retentionKeys.length > 0) {
+        const retentionEnvironment = {};
+        for (const key of retentionKeys)
+            retentionEnvironment[key] = environment[key];
+        errors.push(...await validateObjectStorageRetentionEnvironment(retentionEnvironment, pathArg));
+    }
+    return errors;
+};
+const findEnvironmentCollisions = (claimedKeysArg, keysArg) => keysArg.filter((keyArg) => claimedKeysArg.has(keyArg)).sort();
+const describeEnvironmentCollisions = (collisionsArg) => (`objectstorage binding environment collides with ${collisionsArg.join(', ')} already set on the `
+    + 'workload');
+/**
+ * A workload environment with one binding's environment added.
+ *
+ * Refuses, naming every key, when the environment already holds one of the binding's names: a
+ * service that sets `S3_ENDPOINT` itself, or a second object-storage binding on the same service,
+ * would otherwise have one value silently replace the other. The inputs are not changed.
+ */
+export const mergeObjectStorageBindingEnvironment = (environmentArg, bindingEnvironmentArg) => {
+    const collisions = findEnvironmentCollisions(new Set(Object.keys(environmentArg)), Object.keys(bindingEnvironmentArg));
+    if (collisions.length > 0)
+        throw new Error(describeEnvironmentCollisions(collisions));
+    return { ...environmentArg, ...bindingEnvironmentArg };
+};
+/**
+ * The service's own environment with the environment of every enabled object-storage binding
+ * added, or the service runtime reason it cannot be — so a producer reports the contract's
+ * verdict instead of classifying its errors.
+ *
+ * Each binding's names are `createObjectStorageBindingEnvironment()`'s from its node's endpoint,
+ * added as `mergeObjectStorageBindingEnvironment()` adds them. Bindings are taken in id order, so
+ * the verdict does not depend on the order of `sourcesArg`. A refusal outranks a wait, because a
+ * wait resolves on its own and a refusal never does: a binding waiting for retention evidence
+ * already claims all twenty of its names, so a collision with it is refused now, not once its
+ * evidence arrives. The first refusal is answered, otherwise the first wait, otherwise the
+ * composed environment. The inputs are not changed.
+ */
+export const composeObjectStorageServiceEnvironment = async (serviceEnvironmentArg, sourcesArg) => {
+    const sources = [...sourcesArg].sort((leftArg, rightArg) => (leftArg.binding.id < rightArg.binding.id ? -1 : leftArg.binding.id > rightArg.binding.id ? 1 : 0));
+    let environment = { ...serviceEnvironmentArg };
+    const claimedKeys = new Set(Object.keys(environment));
+    let wait = null;
+    for (const source of sources) {
+        const bindingId = source.binding.id;
+        const resolution = await resolveBindingEnvironment(source.binding, source.endpoint);
+        if (resolution.status === 'refused') {
+            return { status: 'refused', reason: resolution.reason, bindingId, message: resolution.message };
+        }
+        const keys = resolution.status === 'composed'
+            ? Object.keys(resolution.environment)
+            : objectStorageBindingEnvironmentKeys;
+        const collisions = findEnvironmentCollisions(claimedKeys, keys);
+        if (collisions.length > 0) {
+            return { status: 'refused', reason: 'objectstorage-environment-conflict', bindingId,
+                message: describeEnvironmentCollisions(collisions) };
+        }
+        for (const key of keys)
+            claimedKeys.add(key);
+        if (resolution.status === 'composed') {
+            environment = { ...environment, ...resolution.environment };
+        }
+        else {
+            wait ??= { status: 'waiting', reason: resolution.reason, bindingId, message: resolution.message };
+        }
+    }
+    return wait ?? { status: 'composed', environment };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"objectstorageenvironment.js","sourceRoot":"","sources":["../../ts/platform/objectstorageenvironment.ts"],"names":[],"mappings":"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"}

package/dist_ts/platform/objectstorageretention.d.ts

@@ -65,3 +65,43 @@ export declare const objectStorageRetentionIntentsEqual: (leftArg: unknown, righ
 export declare const validateObjectStorageRetentionEvidence: (evidenceArg: unknown, expectedArg: IObjectStorageRetentionEvidenceExpectation) => Promise<string[]>;
 export declare const validateObjectStorageRetentionBinding: (bindingArg: unknown, expectedArg: IObjectStorageRetentionEvidenceExpectation) => Promise<string[]>;
 export declare const validatePlatformBindingObjectStorageRetention: (bindingArg: unknown, expectedArg: IObjectStorageRetentionEvidenceExpectation) => Promise<string[]>;
+/**
+ * The non-secret environment names that tell a workload which retention its bucket carries.
+ *
+ * The names are the ones the cluster relay handed workloads on the Docker path, so an application
+ * that read them keeps working unchanged. Every value is a projection of verified
+ * `IObjectStorageRetentionEvidence`; none is a credential.
+ *
+ * - `S3_RETENTION_MODE`: `intent.mode`, always `compliance`.
+ * - `S3_RETENTION_POLICY_ID`: `intent.policyId`.
+ * - `S3_RETENTION_DURATION_SECONDS`: `intent.retentionDurationSeconds` in decimal.
+ * - `S3_RETENTION_INTENT_SHA256`: `intentSha256`.
+ * - `S3_RETENTION_SENTINEL_KEY`: `receipt.sentinelKey`.
+ * - `S3_RETENTION_CONFIGURED_AT`: `receipt.configuredAt`, Unix milliseconds in decimal.
+ * - `S3_RETENTION_SENTINEL_CREATED_AT`: `receipt.sentinel.createdAt`, Unix milliseconds in decimal.
+ * - `S3_RETENTION_SENTINEL_RETAIN_UNTIL`: `receipt.sentinel.retainUntil`, Unix milliseconds in
+ *   decimal.
+ * - `S3_RETENTION_SENTINEL_PAYLOAD_SHA256`: `receipt.sentinel.payloadSha256`.
+ * - `S3_RETENTION_SENTINEL_METADATA_SHA256`: `receipt.sentinel.metadataSha256`.
+ * - `S3_RETENTION_SENTINEL_ETAG`: `receipt.sentinel.etag`.
+ */
+export declare const objectStorageRetentionEnvironmentKeys: readonly ["S3_RETENTION_MODE", "S3_RETENTION_POLICY_ID", "S3_RETENTION_DURATION_SECONDS", "S3_RETENTION_INTENT_SHA256", "S3_RETENTION_SENTINEL_KEY", "S3_RETENTION_CONFIGURED_AT", "S3_RETENTION_SENTINEL_CREATED_AT", "S3_RETENTION_SENTINEL_RETAIN_UNTIL", "S3_RETENTION_SENTINEL_PAYLOAD_SHA256", "S3_RETENTION_SENTINEL_METADATA_SHA256", "S3_RETENTION_SENTINEL_ETAG"];
+export type TObjectStorageRetentionEnvironmentKey = typeof objectStorageRetentionEnvironmentKeys[number];
+export type TObjectStorageRetentionEnvironment = {
+    [TKey in TObjectStorageRetentionEnvironmentKey]: string;
+};
+/**
+ * The retention environment of evidence that proves `expectedArg`.
+ *
+ * The evidence is validated against the expectation first, with the same validator every other
+ * consumer of retention evidence uses; the first reason it is refused is thrown. A workload is
+ * never told about a retention nobody proved.
+ */
+export declare const createObjectStorageRetentionEnvironment: (evidenceArg: IObjectStorageRetentionEvidence, expectedArg: IObjectStorageRetentionEvidenceExpectation) => Promise<TObjectStorageRetentionEnvironment>;
+/**
+ * Validates a retention environment on its own: exactly its eleven keys, canonical values, an
+ * intent digest that matches the stated intent, and sentinel timestamps that agree with the
+ * duration. It cannot prove the authority or the bucket the evidence was bound to — the
+ * environment does not carry them — so it judges the shape a workload reads, not the proof.
+ */
+export declare const validateObjectStorageRetentionEnvironment: (environmentArg: unknown, pathArg?: string) => Promise<string[]>;