@serve.zone/interfaces 32.25.0 → 32.26.0

package/changelog.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 2026-09-25 - 32.26.0
+
+### Features
+
+- Add the service runtime reasons for the object-storage binding environment, and the helper that
+  reports them.
+  - `TServiceRuntimeWaitingReason` gains `objectstorage-retention-pending` (a binding declares
+    compliance retention whose evidence has not arrived). `TServiceRuntimeRefusal` gains
+    `objectstorage-endpoint-missing` (the binding's node states no valid `corestoreObjectStorage`),
+    `objectstorage-binding-invalid` (`createObjectStorageBindingEnvironment()` refuses the binding)
+    and `objectstorage-environment-conflict` (the service's own environment or another binding
+    already sets a name). An object-storage binding placed on no node keeps `bindings-pending`.
+  - `composeObjectStorageServiceEnvironment(serviceEnvironment, sources)` composes a service's
+    environment from `IObjectStorageBindingEnvironmentSource { binding, endpoint }` and answers a
+    `TObjectStorageServiceEnvironmentComposition`: the environment, or the first refusal, otherwise
+    the first wait, in binding id order, with the binding id and the contract's message. A binding
+    waiting for evidence already claims its names, so a collision with it is refused at once.
+    `TObjectStorageEnvironmentWaitingReason` and `TObjectStorageEnvironmentRefusal` name its
+    reasons. `createObjectStorageBindingEnvironment()` refuses exactly as before, with the same
+    messages.
+
+### Maintenance
+
+- Bring the release-time tooling current: `@git.zone/tstest` 6.2.0 → 6.2.1; pnpm stays 12.5.0 and `@types/node` 26.6.1 by the seven-day rule; the other @git.zone tools are current.
+
 ## 2026-09-25 - 32.25.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '32.25.0',
+    version: '32.26.0',
     description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFNBQVM7SUFDbEIsV0FBVyxFQUFFLHVGQUF1RjtDQUNyRyxDQUFBIn0=

package/dist_ts/data/serviceruntime.d.ts

@@ -71,16 +71,19 @@ export declare const serviceRuntimeContract: Readonly<{
     /** The largest `limit` `getClusterRuntimeAssignments` accepts; Cloudly refuses a larger one. */
     readonly maximumAssignmentPageSize: 256;
 }>;
-declare const serviceRuntimeWaitingReasons: readonly ["node-network-pending", "conflict", "failure-backoff", "storage-import-pending", "bindings-pending", "legacy-adoption-pending"];
-declare const serviceRuntimeRefusals: readonly ["cluster-runtime-missing", "organization-missing", "image-plan-missing", "platform-unsupported", "secrets-unsupported", "volumes-unsupported", "port-protocol-unsupported", "ports-too-many", "readiness-target-undeclared", "environment-too-large", "no-eligible-node", "replica-limit", "node-authority-unsupported", "network-policy-missing", "network-policy-mismatch", "network-workload-pool-missing", "network-workload-pool-exhausted", "volume-driver-unsupported", "volume-options-unsupported", "volume-shared-unsupported", "volume-placement-unsupported", "volume-initialization-unknown", "volume-ownership-unknown"];
+declare const serviceRuntimeWaitingReasons: readonly ["node-network-pending", "conflict", "failure-backoff", "storage-import-pending", "bindings-pending", "legacy-adoption-pending", "objectstorage-retention-pending"];
+declare const serviceRuntimeRefusals: readonly ["cluster-runtime-missing", "organization-missing", "image-plan-missing", "platform-unsupported", "secrets-unsupported", "volumes-unsupported", "port-protocol-unsupported", "ports-too-many", "readiness-target-undeclared", "environment-too-large", "no-eligible-node", "replica-limit", "node-authority-unsupported", "network-policy-missing", "network-policy-mismatch", "network-workload-pool-missing", "network-workload-pool-exhausted", "volume-driver-unsupported", "volume-options-unsupported", "volume-shared-unsupported", "volume-placement-unsupported", "volume-initialization-unknown", "volume-ownership-unknown", "objectstorage-endpoint-missing", "objectstorage-binding-invalid", "objectstorage-environment-conflict"];
 /**
  * Why the producer is not converging yet, though nothing needs an administrator:
  * `node-network-pending` waits for a node's network readiness, `conflict` for a sweep over inputs
  * that changed while it ran, `failure-backoff` for a failed replica's backoff to elapse,
  * `storage-import-pending` for an `import` local storage claim whose bytes have not arrived on its
- * node, `bindings-pending` for the secret manifest to cover every enabled binding of the service, and
- * `legacy-adoption-pending` for a Corestore binding whose legacy resource waits for the offline
- * adoption Corestore requires (the binding's `statusReason` of the same name).
+ * node, `bindings-pending` for the secret manifest to cover every enabled binding of the service (and
+ * for an object-storage binding placed on no node), `legacy-adoption-pending` for a Corestore binding
+ * whose legacy resource waits for the offline adoption Corestore requires (the binding's
+ * `statusReason` of the same name), and `objectstorage-retention-pending` for an object-storage
+ * binding that declares compliance retention whose evidence has not arrived: its workload is not
+ * handed the bucket as if it were ordinary storage.
  */
 export type TServiceRuntimeWaitingReason = typeof serviceRuntimeWaitingReasons[number];
 /**
@@ -100,6 +103,12 @@ export type TServiceRuntimeWaitingReason = typeof serviceRuntimeWaitingReasons[n
  * `volume-initialization-unknown` is a volume without an initialization and
  * `volume-ownership-unknown` a `run-as` ownership under `runAs: null`
  * (`deriveServiceVolumeClaimInitialization`); neither is defaulted.
+ *
+ * The object-storage refusals name why a binding's environment cannot be composed
+ * (`composeObjectStorageServiceEnvironment`): `objectstorage-endpoint-missing` a binding whose node
+ * states no valid `corestoreObjectStorage`, `objectstorage-binding-invalid` a binding
+ * `createObjectStorageBindingEnvironment` refuses, and `objectstorage-environment-conflict` a name
+ * the service's own environment or another binding already sets.
  */
 export type TServiceRuntimeRefusal = typeof serviceRuntimeRefusals[number];
 interface IServiceRuntimeStatusBase {

package/dist_ts/data/serviceruntime.js

@@ -16,7 +16,7 @@ export const serviceRuntimeContract = Object.freeze({
 });
 const serviceRuntimeWaitingReasons = [
     'node-network-pending', 'conflict', 'failure-backoff', 'storage-import-pending', 'bindings-pending',
-    'legacy-adoption-pending',
+    'legacy-adoption-pending', 'objectstorage-retention-pending',
 ];
 const serviceRuntimeRefusals = [
     'cluster-runtime-missing', 'organization-missing', 'image-plan-missing', 'platform-unsupported',
@@ -26,6 +26,7 @@ const serviceRuntimeRefusals = [
     'network-workload-pool-missing', 'network-workload-pool-exhausted',
     'volume-driver-unsupported', 'volume-options-unsupported', 'volume-shared-unsupported',
     'volume-placement-unsupported', 'volume-initialization-unknown', 'volume-ownership-unknown',
+    'objectstorage-endpoint-missing', 'objectstorage-binding-invalid', 'objectstorage-environment-conflict',
 ];
 /** Sorted, duplicate-free and read by the vocabulary the ids belong to: a node's, or the canonical one. */
 const sortedIds = (value, maximum, read) => networkSorted(networkList(value, maximum, read), id => id);
@@ -99,4 +100,4 @@ export const snapshotServiceRuntimeStatus = (value) => producerSafe(() => {
     requireNetwork(item.state === 'refused' && isOneOf(serviceRuntimeRefusals, item.reason));
     return { ...base, state: item.state, reason: item.reason };
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/platform/objectstorageenvironment.d.ts

@@ -1,5 +1,6 @@
 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
@@ -32,6 +33,9 @@ export type TObjectStorageBindingEnvironment = TObjectStorageEndpointEnvironment
  * 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>;
 /**
@@ -47,3 +51,58 @@ export declare const validateObjectStorageBindingEnvironment: (environmentArg: u
  * 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

@@ -1,5 +1,5 @@
-import { createObjectStorageEndpointEnvironment, objectStorageEndpointEnvironmentKeys, validateObjectStorageEndpointEnvironment, validatePlatformObjectStorageBucketName, } from './objectstorage.js';
-import { createObjectStorageRetentionEnvironment, objectStorageRetentionEnvironmentKeys, validateObjectStorageRetentionEnvironment, validateObjectStorageRetentionIntent, } from './objectstorageretention.js';
+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
@@ -10,65 +10,98 @@ export const objectStorageBindingEnvironmentKeys = Object.freeze([
     ...objectStorageRetentionEnvironmentKeys,
 ]);
 /**
- * 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.
+ * The one place a binding's environment is decided. `createObjectStorageBindingEnvironment()`
+ * throws its message, `composeObjectStorageServiceEnvironment()` reports its reason.
  */
-export const createObjectStorageBindingEnvironment = async (bindingArg, endpointArg) => {
+const resolveBindingEnvironment = async (bindingArg, endpointArg) => {
     const binding = readDataProperties(bindingArg);
     if (binding === null || binding.capability !== 'objectstorage') {
-        throw new Error('objectstorage binding environment requires an objectstorage binding');
+        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) {
-        throw new Error(`objectstorage binding ${bindingName} carries no canonical bucket name; Cloudly owns it and `
-            + 'no environment invents one');
+        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 endpointEnvironment;
+        return { status: 'composed', environment: endpointEnvironment };
     }
     const retentionBinding = readDataProperties(retention);
     if (retentionBinding === null
         || validateObjectStorageRetentionIntent(retentionBinding.intent).length > 0) {
-        throw new Error(`objectstorage binding ${bindingName} must declare canonical compliance-retention intent`);
+        return { status: 'refused', reason: 'objectstorage-binding-invalid',
+            message: `objectstorage binding ${bindingName} must declare canonical compliance-retention `
+                + 'intent' };
     }
     const evidence = retentionBinding.evidence;
     if (evidence === undefined) {
-        throw new Error(`objectstorage binding ${bindingName} declares compliance retention without verified `
-            + 'evidence; its workload environment waits for the evidence');
+        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) {
-        throw new Error('objectstorage retention evidence must use its exact schema');
+        return { status: 'refused', reason: 'objectstorage-binding-invalid',
+            message: 'objectstorage retention evidence must use its exact schema' };
     }
-    const retentionEnvironment = await createObjectStorageRetentionEnvironment(evidence, {
+    const expectation = {
         serviceId: binding.serviceId,
         bindingId: binding.id,
         reconciliationGeneration: authority.reconciliationGeneration,
         bindingRequestDigest: authority.bindingRequestDigest,
         bucketName,
         intent: retentionBinding.intent,
-    });
-    return { ...endpointEnvironment, ...retentionEnvironment };
+    };
+    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
@@ -99,6 +132,9 @@ export const validateObjectStorageBindingEnvironment = async (environmentArg, pa
     }
     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.
  *
@@ -107,13 +143,52 @@ export const validateObjectStorageBindingEnvironment = async (environmentArg, pa
  * would otherwise have one value silently replace the other. The inputs are not changed.
  */
 export const mergeObjectStorageBindingEnvironment = (environmentArg, bindingEnvironmentArg) => {
-    const collisions = Object.keys(bindingEnvironmentArg)
-        .filter((keyArg) => Object.hasOwn(environmentArg, keyArg))
-        .sort();
-    if (collisions.length > 0) {
-        throw new Error(`objectstorage binding environment collides with ${collisions.join(', ')} already set on the `
-            + 'workload');
-    }
+    const collisions = findEnvironmentCollisions(new Set(Object.keys(environmentArg)), Object.keys(bindingEnvironmentArg));
+    if (collisions.length > 0)
+        throw new Error(describeEnvironmentCollisions(collisions));
     return { ...environmentArg, ...bindingEnvironmentArg };
 };
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/interfaces",
-  "version": "32.25.0",
+  "version": "32.26.0",
   "private": false,
   "description": "Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.",
   "exports": {
@@ -30,7 +30,7 @@
     "@git.zone/tsbuild": "^5.0.0",
     "@git.zone/tsdoc": "^2.2.2",
     "@git.zone/tsrun": "^3.0.0",
-    "@git.zone/tstest": "6.2.0",
+    "@git.zone/tstest": "6.2.1",
     "@types/node": "26.6.1"
   },
   "files": [

package/readme.md

@@ -1419,21 +1419,25 @@ on one spec revision, and each reason belongs to exactly one state. `converged`
 carry `reason: null`. `waiting` carries a `TServiceRuntimeWaitingReason`: `node-network-pending`,
 `conflict`, `failure-backoff`, `storage-import-pending` (an `import` local storage claim whose bytes
 have not arrived on its node), `bindings-pending` (the secret manifest does not cover every enabled
-binding of the service yet) or `legacy-adoption-pending` (a Corestore binding of the service waits for
-the offline adoption of its legacy resource, see
-[Corestore Legacy Resource Adoption](#corestore-legacy-resource-adoption)). `refused` carries a
-`TServiceRuntimeRefusal`:
+binding of the service yet, or an object-storage binding is placed on no node),
+`legacy-adoption-pending` (a Corestore binding of the service waits for the offline adoption of its
+legacy resource, see [Corestore Legacy Resource Adoption](#corestore-legacy-resource-adoption)) or
+`objectstorage-retention-pending` (an object-storage binding declares compliance retention whose
+evidence has not arrived). `refused` carries a `TServiceRuntimeRefusal`:
 `cluster-runtime-missing`, `organization-missing`, `image-plan-missing`, `platform-unsupported`,
 `secrets-unsupported`, `volumes-unsupported`, `port-protocol-unsupported`, `ports-too-many`,
 `readiness-target-undeclared`, `environment-too-large`, `no-eligible-node`, `replica-limit`,
 `node-authority-unsupported`, `network-policy-missing`, `network-policy-mismatch`,
 `network-workload-pool-missing`, `network-workload-pool-exhausted`, `volume-driver-unsupported`,
 `volume-options-unsupported`, `volume-shared-unsupported`, `volume-placement-unsupported`,
-`volume-initialization-unknown` or `volume-ownership-unknown`. The first four volume refusals name
-what a local storage claim cannot express: a volume driver other than a node-local directory, driver
-or mount options, one volume mounted by more than one replica or service, and a placement that does
-not pin each volume to one node. The last two name what Cloudly will not guess, see
-[Service Volume Initialization](#service-volume-initialization). `ports-too-many` is a service declaring more target ports than the
+`volume-initialization-unknown`, `volume-ownership-unknown`, `objectstorage-endpoint-missing`,
+`objectstorage-binding-invalid` or `objectstorage-environment-conflict`. The first four volume
+refusals name what a local storage claim cannot express: a volume driver other than a node-local
+directory, driver or mount options, one volume mounted by more than one replica or service, and a
+placement that does not pin each volume to one node. The other two name what Cloudly will not guess,
+see [Service Volume Initialization](#service-volume-initialization). The three object-storage
+refusals name why a binding's environment cannot be composed, see
+[Object-Storage Binding Environment](#object-storage-binding-environment). `ports-too-many` is a service declaring more target ports than the
 `runtimeConfigContract.maximumTargetPorts` (64) a config carries, where `port-protocol-unsupported`
 is about one port's protocol; `node-authority-unsupported` is a node whose session resolved fewer
 workload authorities than the spec needs, refused at the admit step rather than handed to a node
@@ -3551,6 +3555,28 @@ to a workload environment and refuses, naming every key, a name that is already
 service itself or by a second object-storage binding — instead of letting one value replace
 another.
 
+**Reporting.** `composeObjectStorageServiceEnvironment(serviceEnvironment, sources)` composes a
+whole service and answers in the service runtime vocabulary, so a producer never classifies the
+errors above. Each `IObjectStorageBindingEnvironmentSource { binding, endpoint }` is an enabled
+object-storage binding and the `corestoreObjectStorage` of the node it is placed on, `null` when
+that node states none; a binding placed on no node is not a source, and its service waits as
+`bindings-pending`. The answer is a `TObjectStorageServiceEnvironmentComposition`:
+
+| `status` | `reason` | When |
+| --- | --- | --- |
+| `composed` | — | `environment` is the service's own with every binding's names added. |
+| `waiting` | `objectstorage-retention-pending` | A binding declares compliance retention whose evidence has not arrived. |
+| `refused` | `objectstorage-endpoint-missing` | The binding's node states no valid `corestoreObjectStorage`. |
+| `refused` | `objectstorage-binding-invalid` | `createObjectStorageBindingEnvironment()` refuses the binding: not `objectstorage`, no canonical bucket, no canonical retention intent, or evidence that does not prove this binding. |
+| `refused` | `objectstorage-environment-conflict` | The service's own environment or another binding already sets one of the binding's names. |
+
+`waiting` and `refused` carry the `bindingId` and the contract's `message`. Bindings are taken in
+id order, so the verdict does not depend on the order of the sources, and a refusal outranks a
+wait: a binding waiting for its evidence already claims all twenty names, so a collision with it
+is refused now rather than once the evidence arrives. The reasons are
+`TObjectStorageEnvironmentWaitingReason` and `TObjectStorageEnvironmentRefusal`, members of
+`TServiceRuntimeWaitingReason` and `TServiceRuntimeRefusal`.
+
 **Validating.** `validateObjectStorageBindingEnvironment()` accepts exactly the endpoint names and
 all or none of the retention names, each value the one its endpoint and evidence derive, and
 refuses any other name — so a credential alias in the public environment is refused by name.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/interfaces',
-  version: '32.25.0',
+  version: '32.26.0',
   description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 }

package/ts/data/serviceruntime.ts

@@ -78,7 +78,7 @@ export const serviceRuntimeContract = Object.freeze({
 
 const serviceRuntimeWaitingReasons = [
   'node-network-pending', 'conflict', 'failure-backoff', 'storage-import-pending', 'bindings-pending',
-  'legacy-adoption-pending',
+  'legacy-adoption-pending', 'objectstorage-retention-pending',
 ] as const;
 const serviceRuntimeRefusals = [
   'cluster-runtime-missing', 'organization-missing', 'image-plan-missing', 'platform-unsupported',
@@ -88,6 +88,7 @@ const serviceRuntimeRefusals = [
   'network-workload-pool-missing', 'network-workload-pool-exhausted',
   'volume-driver-unsupported', 'volume-options-unsupported', 'volume-shared-unsupported',
   'volume-placement-unsupported', 'volume-initialization-unknown', 'volume-ownership-unknown',
+  'objectstorage-endpoint-missing', 'objectstorage-binding-invalid', 'objectstorage-environment-conflict',
 ] as const;
 
 /**
@@ -95,9 +96,12 @@ const serviceRuntimeRefusals = [
  * `node-network-pending` waits for a node's network readiness, `conflict` for a sweep over inputs
  * that changed while it ran, `failure-backoff` for a failed replica's backoff to elapse,
  * `storage-import-pending` for an `import` local storage claim whose bytes have not arrived on its
- * node, `bindings-pending` for the secret manifest to cover every enabled binding of the service, and
- * `legacy-adoption-pending` for a Corestore binding whose legacy resource waits for the offline
- * adoption Corestore requires (the binding's `statusReason` of the same name).
+ * node, `bindings-pending` for the secret manifest to cover every enabled binding of the service (and
+ * for an object-storage binding placed on no node), `legacy-adoption-pending` for a Corestore binding
+ * whose legacy resource waits for the offline adoption Corestore requires (the binding's
+ * `statusReason` of the same name), and `objectstorage-retention-pending` for an object-storage
+ * binding that declares compliance retention whose evidence has not arrived: its workload is not
+ * handed the bucket as if it were ordinary storage.
  */
 export type TServiceRuntimeWaitingReason = typeof serviceRuntimeWaitingReasons[number];
 
@@ -118,6 +122,12 @@ export type TServiceRuntimeWaitingReason = typeof serviceRuntimeWaitingReasons[n
  * `volume-initialization-unknown` is a volume without an initialization and
  * `volume-ownership-unknown` a `run-as` ownership under `runAs: null`
  * (`deriveServiceVolumeClaimInitialization`); neither is defaulted.
+ *
+ * The object-storage refusals name why a binding's environment cannot be composed
+ * (`composeObjectStorageServiceEnvironment`): `objectstorage-endpoint-missing` a binding whose node
+ * states no valid `corestoreObjectStorage`, `objectstorage-binding-invalid` a binding
+ * `createObjectStorageBindingEnvironment` refuses, and `objectstorage-environment-conflict` a name
+ * the service's own environment or another binding already sets.
  */
 export type TServiceRuntimeRefusal = typeof serviceRuntimeRefusals[number];
 

package/ts/platform/objectstorageenvironment.ts

@@ -9,9 +9,12 @@ import {
   objectStorageEndpointEnvironmentKeys,
   validateObjectStorageEndpointEnvironment,
   validatePlatformObjectStorageBucketName,
+  validatePlatformObjectStorageEndpoint,
 } from './objectstorage.js';
+import type { TServiceRuntimeRefusal, TServiceRuntimeWaitingReason } from '../data/serviceruntime.js';
 import type {
   IObjectStorageRetentionEvidence,
+  IObjectStorageRetentionEvidenceExpectation,
   IObjectStorageRetentionIntent,
   TObjectStorageRetentionEnvironment,
   TObjectStorageRetentionEnvironmentKey,
@@ -20,6 +23,7 @@ import {
   createObjectStorageRetentionEnvironment,
   objectStorageRetentionEnvironmentKeys,
   validateObjectStorageRetentionEnvironment,
+  validateObjectStorageRetentionEvidence,
   validateObjectStorageRetentionIntent,
 } from './objectstorageretention.js';
 import { isPlainRecord, readDataProperties } from '../private/dataproperties.js';
@@ -45,78 +49,118 @@ export type TObjectStorageBindingEnvironment =
   | TObjectStorageEndpointEnvironment
   | (TObjectStorageEndpointEnvironment & TObjectStorageRetentionEnvironment);
 
+/** How one binding's environment resolves, in the service runtime vocabulary. */
+type TBindingEnvironmentResolution =
+  | { status: 'composed'; environment: TObjectStorageBindingEnvironment }
+  | { status: 'waiting'; reason: TObjectStorageEnvironmentWaitingReason; message: string }
+  | {
+    status: 'refused';
+    reason: Exclude<TObjectStorageEnvironmentRefusal, 'objectstorage-environment-conflict'>;
+    message: string;
+  };
+
 /**
- * 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.
+ * The one place a binding's environment is decided. `createObjectStorageBindingEnvironment()`
+ * throws its message, `composeObjectStorageServiceEnvironment()` reports its reason.
  */
-export const createObjectStorageBindingEnvironment = async (
+const resolveBindingEnvironment = async (
   bindingArg: IPlatformBinding,
-  endpointArg: IPlatformObjectStorageEndpoint,
-): Promise<TObjectStorageBindingEnvironment> => {
+  endpointArg: IPlatformObjectStorageEndpoint | null,
+): Promise<TBindingEnvironmentResolution> => {
   const binding = readDataProperties(bindingArg);
   if (binding === null || binding.capability !== 'objectstorage') {
-    throw new Error('objectstorage binding environment requires an objectstorage binding');
+    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) {
-    throw new Error(
-      `objectstorage binding ${bindingName} carries no canonical bucket name; Cloudly owns it and `
-        + 'no environment invents one',
-    );
+    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 as string;
   const endpointEnvironment = createObjectStorageEndpointEnvironment(endpointArg, bucketName);
   const retention = binding.objectstorageRetention;
   if (retention === undefined) {
-    return endpointEnvironment;
+    return { status: 'composed', environment: endpointEnvironment };
   }
   const retentionBinding = readDataProperties(retention);
   if (retentionBinding === null
     || validateObjectStorageRetentionIntent(retentionBinding.intent).length > 0) {
-    throw new Error(
-      `objectstorage binding ${bindingName} must declare canonical compliance-retention intent`,
-    );
+    return { status: 'refused', reason: 'objectstorage-binding-invalid',
+      message: `objectstorage binding ${bindingName} must declare canonical compliance-retention `
+        + 'intent' };
   }
   const evidence = retentionBinding.evidence;
   if (evidence === undefined) {
-    throw new Error(
-      `objectstorage binding ${bindingName} declares compliance retention without verified `
-        + 'evidence; its workload environment waits for the evidence',
-    );
+    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) {
-    throw new Error('objectstorage retention evidence must use its exact schema');
+    return { status: 'refused', reason: 'objectstorage-binding-invalid',
+      message: 'objectstorage retention evidence must use its exact schema' };
+  }
+  const expectation: IObjectStorageRetentionEvidenceExpectation = {
+    serviceId: binding.serviceId as string,
+    bindingId: binding.id as string,
+    reconciliationGeneration: authority.reconciliationGeneration as number,
+    bindingRequestDigest: authority.bindingRequestDigest as string,
+    bucketName,
+    intent: retentionBinding.intent as IObjectStorageRetentionIntent,
+  };
+  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 as IObjectStorageRetentionEvidence,
-    {
-      serviceId: binding.serviceId as string,
-      bindingId: binding.id as string,
-      reconciliationGeneration: authority.reconciliationGeneration as number,
-      bindingRequestDigest: authority.bindingRequestDigest as string,
-      bucketName,
-      intent: retentionBinding.intent as IObjectStorageRetentionIntent,
-    },
+    expectation,
   );
-  return { ...endpointEnvironment, ...retentionEnvironment };
+  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: IPlatformBinding,
+  endpointArg: IPlatformObjectStorageEndpoint,
+): Promise<TObjectStorageBindingEnvironment> => {
+  const resolution = await resolveBindingEnvironment(bindingArg, endpointArg);
+  if (resolution.status !== 'composed') throw new Error(resolution.message);
+  return resolution.environment;
 };
 
 /**
@@ -152,6 +196,16 @@ export const validateObjectStorageBindingEnvironment = async (
   return errors;
 };
 
+const findEnvironmentCollisions = (
+  claimedKeysArg: ReadonlySet<string>,
+  keysArg: readonly string[],
+): string[] => keysArg.filter((keyArg) => claimedKeysArg.has(keyArg)).sort();
+
+const describeEnvironmentCollisions = (collisionsArg: readonly string[]): string => (
+  `objectstorage binding environment collides with ${collisionsArg.join(', ')} already set on the `
+    + 'workload'
+);
+
 /**
  * A workload environment with one binding's environment added.
  *
@@ -163,14 +217,105 @@ export const mergeObjectStorageBindingEnvironment = (
   environmentArg: Readonly<Record<string, string>>,
   bindingEnvironmentArg: TObjectStorageBindingEnvironment,
 ): Record<string, string> => {
-  const collisions = Object.keys(bindingEnvironmentArg)
-    .filter((keyArg) => Object.hasOwn(environmentArg, keyArg))
-    .sort();
-  if (collisions.length > 0) {
-    throw new Error(
-      `objectstorage binding environment collides with ${collisions.join(', ')} already set on the `
-        + 'workload',
-    );
-  }
+  const collisions = findEnvironmentCollisions(
+    new Set(Object.keys(environmentArg)),
+    Object.keys(bindingEnvironmentArg),
+  );
+  if (collisions.length > 0) throw new Error(describeEnvironmentCollisions(collisions));
   return { ...environmentArg, ...bindingEnvironmentArg };
 };
+
+/** 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 const composeObjectStorageServiceEnvironment = async (
+  serviceEnvironmentArg: Readonly<Record<string, string>>,
+  sourcesArg: readonly IObjectStorageBindingEnvironmentSource[],
+): Promise<TObjectStorageServiceEnvironmentComposition> => {
+  const sources = [...sourcesArg].sort((leftArg, rightArg) => (
+    leftArg.binding.id < rightArg.binding.id ? -1 : leftArg.binding.id > rightArg.binding.id ? 1 : 0
+  ));
+  let environment: Record<string, string> = { ...serviceEnvironmentArg };
+  const claimedKeys = new Set(Object.keys(environment));
+  let wait: Extract<TObjectStorageServiceEnvironmentComposition, { status: 'waiting' }> | null = 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: readonly string[] = 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 };
+};