@reventlessdev/reventless-aws 3.0.0-alpha.241 → 3.0.0-alpha.243

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.243 (2026-07-29)
+
+### Bug Fixes
+
+* **aws:** call the AppSync operations that exist, not the resource's names ([777c8ff](https://github.com/ReventlessDev/reventless-core/commit/777c8ff7e3641b4e7d2228b332f62c14fe690a42))
+
+
+# 3.0.0-alpha.242 (2026-07-29)
+
+### Bug Fixes
+
+* **platform:** export the bucket's physical name, not the layout's ([43b8ba4](https://github.com/ReventlessDev/reventless-core/commit/43b8ba4f04499c918c7c16921962ad640ea20198))
+### Features
+
+* **platform:** fail a plugin deploy that needs a store the platform lacks ([8f2b6e6](https://github.com/ReventlessDev/reventless-core/commit/8f2b6e6ca8ea472c70bee40e57c959a64f2a7b4e))
+
+
 # 3.0.0-alpha.241 (2026-07-29)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.241",
+  "version": "3.0.0-alpha.243",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -13,15 +13,15 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.25",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
-    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.61",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
+    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.61",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.190",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.108",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.191",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.109",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.54",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.83"
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.55",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.84"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res

@@ -61,7 +61,12 @@ type objectStoreEndpoint = {
   // The path this store's keys are rooted at, and therefore the path it must be
   // served under for a minted `/{key}` ref to resolve.
   keyPrefix: string,
-  bucketName: string,
+  // The bucket's **physical** name, which is not the name the layout computes:
+  // Pulumi auto-names the resource, so a `SharedBucket` stack asking for
+  // `alpha-stores` gets `alpha-stores-507202d`. An Output because that suffix is
+  // only known after the bucket resolves — and a plain string here is exactly
+  // how this shipped exporting a bucket name that no ARN matches.
+  bucketName: Pulumi.Output.t<string>,
   uploadUrl: Pulumi.Output.t<string>,
   // Public base URL the store is served from, when the platform serves it
   // itself. `None` when a host-UI bundle is deployed — there the shell's own
@@ -1586,7 +1591,11 @@ module MakeWithConfig = (
         ~bucketName=storeHandle.bucketName,
         ~servedPrefix=storeHandle.keyPrefix,
       )
-      (`${plugin}.${store}`, keyPrefix, bucketName, presign.url)
+      // `bucketName` is the layout's *logical* name and groups the served view
+      // below; `storeHandle.bucketName` is the physical one Pulumi resolves, and
+      // is what a consumer needs to build an ARN. Carrying both is the point —
+      // they are different strings and only one of them exists in S3.
+      (`${plugin}.${store}`, keyPrefix, bucketName, storeHandle.bucketName, presign.url)
     })
 
     // Group the served view by bucket: one origin and one bucket policy per
@@ -1597,7 +1606,7 @@ module MakeWithConfig = (
       ->Option.map(b => {
         ReventlessInfra.Platform.id: bucketName,
         prefixes: declaredStoreServices
-        ->Array.filterMap(((_, prefix, bn, _)) => bn == bucketName ? Some(prefix) : None),
+        ->Array.filterMap(((_, prefix, bn, _, _)) => bn == bucketName ? Some(prefix) : None),
         bucketId: b.bucketId,
         bucketArn: b.bucketArn,
         bucketRegionalDomainName: b.bucketRegionalDomainName,
@@ -1634,9 +1643,16 @@ module MakeWithConfig = (
     let declaredStoreEndpoints = declaredStoreServices->Array.map(((
       store,
       keyPrefix,
-      bucketName,
+      _logicalBucketName,
+      physicalBucketName,
       uploadUrl,
-    )) => {store, keyPrefix, bucketName, uploadUrl, baseUrl: storeServingBaseUrl})
+    )) => {
+      store,
+      keyPrefix,
+      bucketName: physicalBucketName->Pulumi.Output.fromInput,
+      uploadUrl,
+      baseUrl: storeServingBaseUrl,
+    })
     objectStoreEndpointsRef := declaredStoreEndpoints
 
     // Exported unconditionally — the provisioning above already is. Their only
@@ -1657,18 +1673,18 @@ module MakeWithConfig = (
         "objectStores",
         declaredStoreEndpoints
         ->Array.map(e =>
-          switch e.baseUrl {
-          | Some(u) => u->Pulumi.Output.apply(b => (e, Some(b)))
-          | None => Pulumi.Output.make((e, None))
-          }
+          Pulumi.Output.all2((e.bucketName, e.baseUrl->Pulumi.Output.allOpt))->Pulumi.Output.apply(((
+            bucketName,
+            baseUrl,
+          )) => (e, bucketName, baseUrl))
         )
         ->Pulumi.Output.all
-        ->Pulumi.Output.apply(pairs =>
-          pairs
-          ->Array.map(((e, baseUrl)) => (
+        ->Pulumi.Output.apply(resolved =>
+          resolved
+          ->Array.map(((e, bucketName, baseUrl)) => (
             e.store,
             [
-              ("bucketName", JSON.Encode.string(e.bucketName)),
+              ("bucketName", JSON.Encode.string(bucketName)),
               ("keyPrefix", JSON.Encode.string(e.keyPrefix)),
             ]
             // Absent when the host shell serves the store: there the object is
@@ -1825,7 +1841,7 @@ module MakeWithConfig = (
       // built before per-store binding reads it and is unaffected.
       let storeUploadEndpointsOutput: Pulumi.Output.t<array<(string, string)>> =
         declaredStoreServices
-        ->Array.map(((qualified, _, _, url)) => url->Pulumi.Output.apply(u => (qualified, u)))
+        ->Array.map(((qualified, _, _, _, url)) => url->Pulumi.Output.apply(u => (qualified, u)))
         ->Pulumi.Output.all
 
       let configJsonContent =
@@ -2053,11 +2069,66 @@ module MakeWithConfig = (
         ~mergedApiIdentifier=checkedMergedApiArn,
         ~association,
       )
+
+      // ── Capability coverage ────────────────────────────────────────────────
+      //
+      // `requiredStores` is what this plugin's fields *declare*; the platform's
+      // `objectStores` output is what it actually provisioned. A store in the
+      // first and not the second is the split-stack ordering hazard: the
+      // platform deploys before the plugin and cannot see the plugin's schemas,
+      // so the capability list is hand-written and can simply be wrong.
+      //
+      // It is worth failing on because every symptom is silent. The upload
+      // input finds no per-store endpoint, falls back to the legacy single
+      // service, and writes to whatever bucket that serves — a 2xx, a plausible
+      // ref, and the wrong destination. A case slip in the hand-written name
+      // produces exactly that, and so does forgetting the entry entirely.
+      //
+      // Two outcomes rather than one, because "you got it wrong" and "you have
+      // not started" deserve different answers. A platform exporting no stores
+      // at all has not adopted capability provisioning; failing it would break
+      // deployments that are working. A platform exporting *some* stores but
+      // not this one has adopted it and is missing or misspelling an entry.
+      //
+      // Folded into the association export for the same reason the merge gate
+      // is: a dangling `apply` is not guaranteed to be evaluated, and a check
+      // that might not run is not a check.
+      let capabilityGate: Pulumi.Output.t<unit> =
+        (pluginOutputs.pluginStructure, stackRef->Pulumi.StackReference.getOutput("objectStores"))
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply((((structure, objectStores): (_, option<JSON.t>))) => {
+          let required =
+            structure->Option.flatMap(s => s.requiredStores)->Option.getOr([])
+          let provisioned =
+            objectStores
+            ->Option.flatMap(JSON.Decode.object)
+            ->Option.map(Dict.keysToArray)
+            ->Option.getOr([])
+          switch Util_StoreLayout.coverageFor(~required, ~provisioned) {
+          | Covered => ()
+          | NotAdopted(missing) =>
+            log.warn(
+              ~comp="Platform:deployPlugin",
+              `declares ${missing->Array.join(", ")} but the platform stack provisions no object stores — ` ++
+              `add them to the platform's ~capabilities and redeploy the platform first, ` ++
+              `or uploads will fall back to the legacy service and write to the wrong bucket`,
+            )
+          | Missing({missing, provisioned}) =>
+            JsError.throwWithMessage(
+              `Plugin requires object store(s) the platform does not provision: ${missing->Array.join(", ")}.\n` ++
+              `  The platform stack provisions: ${provisioned->Array.join(", ")}.\n` ++
+              `  A store's key is {plugin}.{store}, where {plugin} is the name the plugin registers — ` ++
+              `check the capability's spelling and case against it.\n` ++
+              `  Add the missing entr(ies) to the platform's ~capabilities and redeploy the platform stack first.`,
+            )
+          }
+        })
+
       Pulumi.Pulumi.export(
         "sourceApiAssociationId",
-        (association.associationId, mergeGate)
-        ->Pulumi.Output.all2
-        ->Pulumi.Output.apply(((id, _)) => id),
+        (association.associationId, mergeGate, capabilityGate)
+        ->Pulumi.Output.all3
+        ->Pulumi.Output.apply(((id, _, _)) => id),
       )
       Pulumi.Pulumi.export(
         "pluginSourceApiId",

package/src/Platform.res.mjs

@@ -11,6 +11,7 @@ import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output
 import * as Pulumi$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Pulumi.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Plugin$ReventlessAws from "./components/Plugin.res.mjs";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
@@ -935,6 +936,7 @@ function MakeWithConfig(Config) {
         plugin + `.` + store,
         keyPrefix,
         bucketName,
+        storeHandle.bucketName,
         presign.url
       ];
     });
@@ -963,8 +965,8 @@ function MakeWithConfig(Config) {
     let declaredStoreEndpoints = declaredStoreServices.map(param => ({
       store: param[0],
       keyPrefix: param[1],
-      bucketName: param[2],
-      uploadUrl: param[3],
+      bucketName: param[3],
+      uploadUrl: param[4],
       baseUrl: storeServingBaseUrl
     }));
     objectStoreEndpointsRef.contents = declaredStoreEndpoints;
@@ -973,28 +975,22 @@ function MakeWithConfig(Config) {
         e.store,
         u
       ]))).apply(pairs => Object.fromEntries(pairs)));
-      Pulumi$Pulumi.$$export("objectStores", Pulumi.all(declaredStoreEndpoints.map(e => {
-        let u = e.baseUrl;
-        if (u !== undefined) {
-          return u.apply(b => [
-            e,
-            b
-          ]);
-        } else {
-          return Pulumi.output([
-            e,
-            undefined
-          ]);
-        }
-      })).apply(pairs => Object.fromEntries(pairs.map(param => {
-        let baseUrl = param[1];
+      Pulumi$Pulumi.$$export("objectStores", Pulumi.all(declaredStoreEndpoints.map(e => Pulumi.all([
+        e.bucketName,
+        Output$Pulumi.allOpt(e.baseUrl)
+      ]).apply(param => [
+        e,
+        param[0],
+        param[1]
+      ]))).apply(resolved => Object.fromEntries(resolved.map(param => {
+        let baseUrl = param[2];
         let e = param[0];
         return [
           e.store,
           Object.fromEntries([
             [
               "bucketName",
-              e.bucketName
+              param[1]
             ],
             [
               "keyPrefix",
@@ -1047,7 +1043,7 @@ function MakeWithConfig(Config) {
       let uploadEndpointOutput = store$1 !== undefined ? Upload_Presign_S3$ReventlessAws.make(store$1.bucketName, undefined, undefined, undefined, undefined).url.apply(u => u) : Pulumi.output(undefined);
       let storeUploadEndpointsOutput = Pulumi.all(declaredStoreServices.map(param => {
         let qualified = param[0];
-        return param[3].apply(u => [
+        return param[4].apply(u => [
           qualified,
           u
         ]);
@@ -1208,9 +1204,25 @@ function MakeWithConfig(Config) {
       ]).apply(param => param[0]);
       let association = AppSync_MergedApi$ReventlessAws.associateSourceWithMergedArn("PluginSourceAssociation", arnAfterSchemaPush, domainApi, {});
       let mergeGate = AppSync_MergedApi$ReventlessAws.mergeStatusGateWith(checkedMergedApiArn, association);
+      let capabilityGate = Pulumi.all([
+        pluginOutputs.pluginStructure,
+        stackRef.getOutput("objectStores")
+      ]).apply(param => {
+        let required = Stdlib_Option.getOr(Stdlib_Option.flatMap(param[0], s => s.requiredStores), []);
+        let provisioned = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(param[1], Stdlib_JSON.Decode.object), prim => Object.keys(prim)), []);
+        let missing = Util_StoreLayout$ReventlessAws.coverageFor(required, provisioned);
+        if (typeof missing !== "object") {
+          return;
+        } else if (missing.TAG === "NotAdopted") {
+          return log.warn("Platform:deployPlugin", undefined, `declares ` + missing._0.join(", ") + ` but the platform stack provisions no object stores — add them to the platform's ~capabilities and redeploy the platform first, or uploads will fall back to the legacy service and write to the wrong bucket`);
+        } else {
+          return Stdlib_JsError.throwWithMessage(`Plugin requires object store(s) the platform does not provision: ` + missing.missing.join(", ") + `.\n` + (`  The platform stack provisions: ` + missing.provisioned.join(", ") + `.\n`) + `  A store's key is {plugin}.{store}, where {plugin} is the name the plugin registers — check the capability's spelling and case against it.\n  Add the missing entr(ies) to the platform's ~capabilities and redeploy the platform stack first.`);
+        }
+      });
       Pulumi$Pulumi.$$export("sourceApiAssociationId", Pulumi.all([
         association.associationId,
-        mergeGate
+        mergeGate,
+        capabilityGate
       ]).apply(param => param[0]));
       Pulumi$Pulumi.$$export("pluginSourceApiId", Output$Pulumi.flatMap(domainApi, api => api.id));
       Pulumi$Pulumi.$$export("pluginSourceApiEndpoint", Output$Pulumi.flatMap(domainApi, api => api.uris.apply(uris => uris.GRAPHQL)));
@@ -2079,6 +2091,7 @@ function Make($star) {
         plugin + `.` + store,
         keyPrefix,
         bucketName,
+        storeHandle.bucketName,
         presign.url
       ];
     });
@@ -2107,8 +2120,8 @@ function Make($star) {
     let declaredStoreEndpoints = declaredStoreServices.map(param => ({
       store: param[0],
       keyPrefix: param[1],
-      bucketName: param[2],
-      uploadUrl: param[3],
+      bucketName: param[3],
+      uploadUrl: param[4],
       baseUrl: storeServingBaseUrl
     }));
     objectStoreEndpointsRef.contents = declaredStoreEndpoints;
@@ -2117,28 +2130,22 @@ function Make($star) {
         e.store,
         u
       ]))).apply(pairs => Object.fromEntries(pairs)));
-      Pulumi$Pulumi.$$export("objectStores", Pulumi.all(declaredStoreEndpoints.map(e => {
-        let u = e.baseUrl;
-        if (u !== undefined) {
-          return u.apply(b => [
-            e,
-            b
-          ]);
-        } else {
-          return Pulumi.output([
-            e,
-            undefined
-          ]);
-        }
-      })).apply(pairs => Object.fromEntries(pairs.map(param => {
-        let baseUrl = param[1];
+      Pulumi$Pulumi.$$export("objectStores", Pulumi.all(declaredStoreEndpoints.map(e => Pulumi.all([
+        e.bucketName,
+        Output$Pulumi.allOpt(e.baseUrl)
+      ]).apply(param => [
+        e,
+        param[0],
+        param[1]
+      ]))).apply(resolved => Object.fromEntries(resolved.map(param => {
+        let baseUrl = param[2];
         let e = param[0];
         return [
           e.store,
           Object.fromEntries([
             [
               "bucketName",
-              e.bucketName
+              param[1]
             ],
             [
               "keyPrefix",
@@ -2191,7 +2198,7 @@ function Make($star) {
       let uploadEndpointOutput = store$1 !== undefined ? Upload_Presign_S3$ReventlessAws.make(store$1.bucketName, undefined, undefined, undefined, undefined).url.apply(u => u) : Pulumi.output(undefined);
       let storeUploadEndpointsOutput = Pulumi.all(declaredStoreServices.map(param => {
         let qualified = param[0];
-        return param[3].apply(u => [
+        return param[4].apply(u => [
           qualified,
           u
         ]);
@@ -2352,9 +2359,25 @@ function Make($star) {
       ]).apply(param => param[0]);
       let association = AppSync_MergedApi$ReventlessAws.associateSourceWithMergedArn("PluginSourceAssociation", arnAfterSchemaPush, domainApi, {});
       let mergeGate = AppSync_MergedApi$ReventlessAws.mergeStatusGateWith(checkedMergedApiArn, association);
+      let capabilityGate = Pulumi.all([
+        pluginOutputs.pluginStructure,
+        stackRef.getOutput("objectStores")
+      ]).apply(param => {
+        let required = Stdlib_Option.getOr(Stdlib_Option.flatMap(param[0], s => s.requiredStores), []);
+        let provisioned = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(param[1], Stdlib_JSON.Decode.object), prim => Object.keys(prim)), []);
+        let missing = Util_StoreLayout$ReventlessAws.coverageFor(required, provisioned);
+        if (typeof missing !== "object") {
+          return;
+        } else if (missing.TAG === "NotAdopted") {
+          return log.warn("Platform:deployPlugin", undefined, `declares ` + missing._0.join(", ") + ` but the platform stack provisions no object stores — add them to the platform's ~capabilities and redeploy the platform first, or uploads will fall back to the legacy service and write to the wrong bucket`);
+        } else {
+          return Stdlib_JsError.throwWithMessage(`Plugin requires object store(s) the platform does not provision: ` + missing.missing.join(", ") + `.\n` + (`  The platform stack provisions: ` + missing.provisioned.join(", ") + `.\n`) + `  A store's key is {plugin}.{store}, where {plugin} is the name the plugin registers — check the capability's spelling and case against it.\n  Add the missing entr(ies) to the platform's ~capabilities and redeploy the platform stack first.`);
+        }
+      });
       Pulumi$Pulumi.$$export("sourceApiAssociationId", Pulumi.all([
         association.associationId,
-        mergeGate
+        mergeGate,
+        capabilityGate
       ]).apply(param => param[0]));
       Pulumi$Pulumi.$$export("pluginSourceApiId", Output$Pulumi.flatMap(domainApi, api => api.id));
       Pulumi$Pulumi.$$export("pluginSourceApiEndpoint", Output$Pulumi.flatMap(domainApi, api => api.uris.apply(uris => uris.GRAPHQL)));

package/src/adapter/Api/AppSync_SourceApiAssociation_Retrying.res

@@ -63,11 +63,21 @@ type deleteCmd
 
 // Shape of the dynamically-imported `@aws-sdk/client-appsync` module. Only the
 // three association commands are needed here.
+//
+// The create/delete names follow the *API operation*, not the resource: AppSync
+// has `AssociateSourceGraphqlApi` / `DisassociateSourceGraphqlApi`, and there is
+// no `Create…`/`Delete…SourceApiAssociation` command. Those names are only the
+// CloudFormation/Pulumi resource's, and naming the constructors after the
+// resource made `create` throw `C is not a constructor` on every fresh stack —
+// `new undefined(...)`, since a missing export is just undefined on the module
+// namespace. `Get` exists under the resource-style name, which is why read and
+// diff always worked and only creation was broken. The request payloads below
+// already match the operations exactly.
 type sdkModule = {
   @as("AppSyncClient") clientCtor: unit => appSyncClient,
-  @as("CreateSourceApiAssociationCommand") createCtor: createInput => createCmd,
+  @as("AssociateSourceGraphqlApiCommand") createCtor: createInput => createCmd,
   @as("GetSourceApiAssociationCommand") getCtor: idInput => getCmd,
-  @as("DeleteSourceApiAssociationCommand") deleteCtor: idInput => deleteCmd,
+  @as("DisassociateSourceGraphqlApiCommand") deleteCtor: idInput => deleteCmd,
 }
 
 // Calls a constructor with `new` — the SDK exports plain classes.
@@ -277,7 +287,7 @@ let extractIds = (resp: createResult): (string, string) =>
   | Some({associationArn: ?Some(arn), associationId: ?Some(aid)}) => (arn, aid)
   | _ =>
     JsError.throwWithMessage(
-      "CreateSourceApiAssociation returned no associationArn / associationId",
+      "AssociateSourceGraphqlApi returned no associationArn / associationId",
     )
   }
 

package/src/adapter/Api/AppSync_SourceApiAssociation_Retrying.res.mjs

@@ -181,11 +181,11 @@ function identifiersFrom(id, props) {
 function extractIds(resp) {
   let match = resp.sourceApiAssociation;
   if (match === undefined) {
-    return Stdlib_JsError.throwWithMessage("CreateSourceApiAssociation returned no associationArn / associationId");
+    return Stdlib_JsError.throwWithMessage("AssociateSourceGraphqlApi returned no associationArn / associationId");
   }
   let aid = match.associationId;
   if (aid === undefined) {
-    return Stdlib_JsError.throwWithMessage("CreateSourceApiAssociation returned no associationArn / associationId");
+    return Stdlib_JsError.throwWithMessage("AssociateSourceGraphqlApi returned no associationArn / associationId");
   }
   let arn = match.associationArn;
   if (arn !== undefined) {
@@ -194,14 +194,14 @@ function extractIds(resp) {
       aid
     ];
   } else {
-    return Stdlib_JsError.throwWithMessage("CreateSourceApiAssociation returned no associationArn / associationId");
+    return Stdlib_JsError.throwWithMessage("AssociateSourceGraphqlApi returned no associationArn / associationId");
   }
 }
 
 async function create(inputs) {
   let sdk = await getSdk();
   let client = await getClient();
-  let match = await runWithRetry(undefined, undefined, undefined, undefined, () => client.send(newOf1(sdk.CreateSourceApiAssociationCommand, {
+  let match = await runWithRetry(undefined, undefined, undefined, undefined, () => client.send(newOf1(sdk.AssociateSourceGraphqlApiCommand, {
     mergedApiIdentifier: inputs.mergedApiIdentifier,
     sourceApiIdentifier: inputs.sourceApiIdentifier,
     sourceApiAssociationConfig: {
@@ -235,7 +235,7 @@ async function delete_(id, props) {
     return log.warn("AppSync_SourceApiAssociation_Retrying", undefined, `delete: could not derive association identifiers from id "` + id + `"; treating as already gone`);
   }
   try {
-    return await runWithRetry(undefined, undefined, undefined, undefined, () => client.send(newOf1(sdk.DeleteSourceApiAssociationCommand, ids)));
+    return await runWithRetry(undefined, undefined, undefined, undefined, () => client.send(newOf1(sdk.DisassociateSourceGraphqlApiCommand, ids)));
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     if (Stdlib_Option.mapOr(Stdlib_JsExn.fromException(exn), false, isAlreadyGoneError)) {

package/src/util/Util_StoreLayout.res

@@ -34,6 +34,17 @@ type protection =
   | Protected
   | Unprotected
 
+/** Whether the platform provisions everything a plugin's fields declare. */
+type coverage =
+  /** Every declared store is provisioned. */
+  | Covered
+  /** The platform provisions no stores at all — it has not adopted capability
+      provisioning, which is a different situation from getting it wrong. */
+  | NotAdopted(array<string>)
+  /** The platform provisions stores, but not these. Carries what it does
+      provision, because the usual cause is a near-miss worth showing. */
+  | Missing({missing: array<string>, provisioned: array<string>})
+
 /** Which distribution fronts the declared stores. */
 type serving =
   /** No store is declared, so nothing is served. */
@@ -134,3 +145,31 @@ let servingFor = (~hasHostUiBundle: bool, ~declaredBucketCount: int): serving =>
   | (true, _) => HostShell
   | (false, _) => PlatformOwned
   }
+
+/**
+Does the platform provision what the plugin's fields declare?
+
+The split-stack ordering hazard, stated as a set difference: the platform
+deploys before the plugin and cannot read its schemas, so its capability list is
+written by hand and can simply be wrong. `required` comes from
+`pluginStructure.requiredStores`; `provisioned` from the platform's exported
+`objectStores` keys. Both are qualified `{plugin}.{store}`.
+
+**Three outcomes, not two.** A platform provisioning nothing has not adopted
+capability provisioning; failing it would break deployments that work today. A
+platform provisioning *some* stores but not this one has adopted it and has a
+missing or misspelled entry. Collapsing those two into one verdict forces a
+choice between breaking the first group and not helping the second.
+
+Worth being strict about because every symptom is silent: the upload input finds
+no per-store endpoint, falls back to the legacy single service, and writes to
+whatever bucket that serves — a 2xx, a plausible ref, and the wrong destination.
+*/
+let coverageFor = (~required: array<string>, ~provisioned: array<string>): coverage => {
+  let missing = required->Array.filter(r => !(provisioned->Array.includes(r)))
+  switch (missing, provisioned) {
+  | ([], _) => Covered
+  | (missing, []) => NotAdopted(missing)
+  | (missing, provisioned) => Missing({missing, provisioned})
+  }
+}

package/src/util/Util_StoreLayout.res.mjs

@@ -44,6 +44,26 @@ function servingFor(hasHostUiBundle, declaredBucketCount) {
   }
 }
 
+function coverageFor(required, provisioned) {
+  let missing = required.filter(r => !provisioned.includes(r));
+  if (missing.length !== 0) {
+    if (provisioned.length !== 0) {
+      return {
+        TAG: "Missing",
+        missing: missing,
+        provisioned: provisioned
+      };
+    } else {
+      return {
+        TAG: "NotAdopted",
+        _0: missing
+      };
+    }
+  } else {
+    return "Covered";
+  }
+}
+
 export {
   defaultEphemeralPrefixes,
   layoutFor,
@@ -51,5 +71,6 @@ export {
   bucketNameFor,
   keyPrefixFor,
   servingFor,
+  coverageFor,
 }
 /* No side effect */

package/tests/Util_StoreLayoutTest.res

@@ -80,6 +80,80 @@ describe("Util_StoreLayout.servingFor", () => {
   )
 })
 
+describe("Util_StoreLayout.coverageFor", () => {
+  testSync("everything declared is provisioned", () =>
+    expect(
+      Util_StoreLayout.coverageFor(
+        ~required=["Catalog.productImages"],
+        ~provisioned=["Catalog.productImages"],
+      ),
+    )->toEqual(Util_StoreLayout.Covered)
+  )
+
+  testSync("declaring nothing is covered, whatever the platform provisions", () =>
+    expect(Util_StoreLayout.coverageFor(~required=[], ~provisioned=["Catalog.productImages"]))->toEqual(
+      Util_StoreLayout.Covered,
+    )
+  )
+
+  // A platform provisioning nothing has not adopted capability provisioning.
+  // Failing it would break deployments that work today, so this is the arm that
+  // must NOT be a hard error.
+  testSync("a platform provisioning nothing has not adopted, rather than got it wrong", () =>
+    expect(Util_StoreLayout.coverageFor(~required=["Catalog.productImages"], ~provisioned=[]))->toEqual(
+      Util_StoreLayout.NotAdopted(["Catalog.productImages"]),
+    )
+  )
+
+  // The case that shipped: the platform declared the store under a lowercased
+  // plugin name, so both sides had a productImages store and neither matched.
+  // It carries what IS provisioned because the cause is usually a near-miss.
+  testSync("a near-miss reports both sides — this is the case-slip shape", () =>
+    expect(
+      Util_StoreLayout.coverageFor(
+        ~required=["Catalog.productImages"],
+        ~provisioned=["catalog.productImages"],
+      ),
+    )->toEqual(
+      Util_StoreLayout.Missing({
+        missing: ["Catalog.productImages"],
+        provisioned: ["catalog.productImages"],
+      }),
+    )
+  )
+
+  testSync("only the uncovered stores are reported missing", () =>
+    expect(
+      Util_StoreLayout.coverageFor(
+        ~required=["Catalog.productImages", "Catalog.manuals"],
+        ~provisioned=["Catalog.productImages"],
+      ),
+    )->toEqual(
+      Util_StoreLayout.Missing({
+        missing: ["Catalog.manuals"],
+        provisioned: ["Catalog.productImages"],
+      }),
+    )
+  )
+
+  // Matching is exact. Suffix or case-insensitive matching would "fix" the
+  // case slip above by silently binding to the wrong store, and two plugins may
+  // legitimately name a store the same.
+  testSync("matching is exact — a suffix match is not a match", () =>
+    expect(
+      Util_StoreLayout.coverageFor(
+        ~required=["Catalog.productImages"],
+        ~provisioned=["Ordering.productImages"],
+      ),
+    )->toEqual(
+      Util_StoreLayout.Missing({
+        missing: ["Catalog.productImages"],
+        provisioned: ["Ordering.productImages"],
+      }),
+    )
+  )
+})
+
 describe("Util_StoreLayout.protectionFor", () => {
   // The pairing a single layout-driven switch would have got wrong: alpha
   // shares a bucket and is still protected.

package/tests/Util_StoreLayoutTest.res.mjs

@@ -45,6 +45,45 @@ globalThis.describe("Util_StoreLayout.servingFor", () => {
   });
 });
 
+globalThis.describe("Util_StoreLayout.coverageFor", () => {
+  globalThis.test("everything declared is provisioned", () => {
+    globalThis.expect(Util_StoreLayout$ReventlessAws.coverageFor(["Catalog.productImages"], ["Catalog.productImages"])).toEqual("Covered");
+  });
+  globalThis.test("declaring nothing is covered, whatever the platform provisions", () => {
+    globalThis.expect(Util_StoreLayout$ReventlessAws.coverageFor([], ["Catalog.productImages"])).toEqual("Covered");
+  });
+  globalThis.test("a platform provisioning nothing has not adopted, rather than got it wrong", () => {
+    globalThis.expect(Util_StoreLayout$ReventlessAws.coverageFor(["Catalog.productImages"], [])).toEqual({
+      TAG: "NotAdopted",
+      _0: ["Catalog.productImages"]
+    });
+  });
+  globalThis.test("a near-miss reports both sides — this is the case-slip shape", () => {
+    globalThis.expect(Util_StoreLayout$ReventlessAws.coverageFor(["Catalog.productImages"], ["catalog.productImages"])).toEqual({
+      TAG: "Missing",
+      missing: ["Catalog.productImages"],
+      provisioned: ["catalog.productImages"]
+    });
+  });
+  globalThis.test("only the uncovered stores are reported missing", () => {
+    globalThis.expect(Util_StoreLayout$ReventlessAws.coverageFor([
+      "Catalog.productImages",
+      "Catalog.manuals"
+    ], ["Catalog.productImages"])).toEqual({
+      TAG: "Missing",
+      missing: ["Catalog.manuals"],
+      provisioned: ["Catalog.productImages"]
+    });
+  });
+  globalThis.test("matching is exact — a suffix match is not a match", () => {
+    globalThis.expect(Util_StoreLayout$ReventlessAws.coverageFor(["Catalog.productImages"], ["Ordering.productImages"])).toEqual({
+      TAG: "Missing",
+      missing: ["Catalog.productImages"],
+      provisioned: ["Ordering.productImages"]
+    });
+  });
+});
+
 globalThis.describe("Util_StoreLayout.protectionFor", () => {
   globalThis.test("alpha shares a bucket and is still protected", () => {
     globalThis.expect(Util_StoreLayout$ReventlessAws.layoutFor("alpha", Util_HostUiDomain$ReventlessAws.defaultProdStacks)).toEqual("SharedBucket");