@reventlessdev/reventless-seed-aws 1.0.0-alpha.4 → 1.0.0-alpha.5

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.5 (2026-07-31)
+
+### Bug Fixes
+
+* **seed:** address a deployment's per-store upload endpoints ([45b226e](https://github.com/ReventlessDev/reventless-core/commit/45b226e00604af9fd28b6fb0b75ba7d3414791f2))
+
+
 # 1.0.0-alpha.4 (2026-07-27)
 
 ### Features

package/lib/bs/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1785181007711)
-#Done(1785181012329)
+#Start(1785495045190)
+#Done(1785495045219)

package/lib/bs/.sourcedirs.json

@@ -0,0 +1 @@
+{"cmt_scan":[{"also_scan_build_root":true,"build_root":"lib/bs","scan_dirs":["src","tests"]}],"dirs":["src","tests"],"generated":[],"pkgs":[["@reventlessdev/rescript-aws-sdk","/home/runner/work/reventless-core/reventless-core/rescript/aws-sdk"],["@reventlessdev/rescript-jest","/home/runner/work/reventless-core/reventless-core/rescript/jest"],["@reventlessdev/reventless-seed","/home/runner/work/reventless-core/reventless-core/reventless/seed"]],"version":2}

package/lib/bs/compiler-info.json

@@ -2,7 +2,7 @@
   "version": "12.3.0",
   "bsc_path": "/home/runner/work/reventless-core/reventless-core/node_modules/@rescript/linux-x64/bin/bsc.exe",
   "bsc_hash": "75e3a59c95cc953608fd3dd6ea6ed68141bba4414a20a52f114261b8a48385fa",
-  "rescript_config_hash": "3d482ebc161b93b84503a064c1b55dbce9106efcb53cc320aba2d3d291d8ab86",
+  "rescript_config_hash": "80febfc1b083fe35268276ef15c3829eae3bbacfedb30515f97c99ea938ae1a4",
   "runtime_path": "/home/runner/work/reventless-core/reventless-core/node_modules/@rescript/runtime",
-  "generated_at": "1785181012338"
+  "generated_at": "1785495045225"
 }

package/lib/bs/src/ReventlessSeedAws.res

@@ -41,6 +41,18 @@ let asString = (json: JSON.t): option<string> =>
   | _ => None
   }
 
+// Non-string members are dropped rather than failing the whole map: one
+// malformed entry should not cost a run every endpoint it could have used.
+let asStringDict = (json: JSON.t): dict<string> =>
+  switch json {
+  | Object(obj) =>
+    obj
+    ->Dict.toArray
+    ->Array.filterMap(((k, v)) => v->asString->Option.map(s => (k, s)))
+    ->Dict.fromArray
+  | _ => Dict.make()
+  }
+
 // ── Stack discovery ───────────────────────────────────────────────────────────
 
 // Which Pulumi backend the `pulumi` subprocess reads from. When `backend` is
@@ -147,70 +159,118 @@ let resolveField = (~envKey: string, ~fromSource: option<string>, ~human: string
     }
   }
 
-// Returns (graphqlEndpoint, uploadEndpoint, cognitoRegion, cognitoClientId).
-// `uploadEndpoint` is "" when the deployment publishes none — the data set's
-// upload phase no-ops on empty.
-let resolveEndpoints = async (~projectDir: string, ~backend: option<string>, ~stack: string): (
-  string,
-  string,
-  string,
-  string,
-) => {
-  let outputs = stackOutputs(~projectDir, ~backend, stack)
-  switch outputs->field("hostShellUrl")->Option.flatMap(asString) {
-  | Some(hostShellUrl) =>
-    let cfg = await fetchConfig(hostShellUrl)
+// Same precedence, for a value whose absence is a legitimate answer rather than
+// a broken deployment: a stack that declares no store publishes no upload
+// endpoint, and that must stay a no-op at the data set instead of failing the
+// run before a single command is sent.
+let optionalField = (~envKey: string, ~fromSource: option<string>): string =>
+  switch Seed.Prompt.envValue(envKey) {
+  | Some(v) => v
+  | None => fromSource->Option.getOr("")
+  }
+
+// Which document publishes the deployment's endpoints. A stack that serves a
+// host shell publishes them in the shell's `config.json` under the client's key
+// names; one that does not publishes them as stack outputs under Pulumi's. The
+// two arms name different keys for the same values, which is why this is a
+// variant and not a merged lookup.
+type source = HostShellConfig(JSON.t) | StackOutputs(JSON.t)
+
+type endpoints = {
+  graphql: string,
+  // The legacy single presign service; "" when the deployment publishes none.
+  uploadEndpoint: string,
+  // Qualified `{plugin}.{store}` → that store's presign endpoint. Empty when the
+  // deployment declares no store.
+  uploadEndpoints: dict<string>,
+  cognitoRegion: string,
+  cognitoClientId: string,
+}
+
+/**
+ * The endpoints a source document publishes — pure, so the branch selection and
+ * every key it reads can be exercised with synthetic documents.
+ *
+ * `uploadEndpoints` is read on **both** arms. It was read on neither: the
+ * host-shell arm looked only at the singular `uploadEndpoint`, and the
+ * stack-output arm had no upload lookup at all, so a platform that publishes its
+ * stores and no host shell resolved "" and reported itself as serving no
+ * uploads.
+ *
+ * `REVENTLESS_UPLOAD_ENDPOINT` still overrides the singular endpoint and does
+ * not touch the map: one string cannot express a map, so it could only ever
+ * override one store and would need a naming convention to say which.
+ */
+let endpointsFrom = (~stack: string, source: source): endpoints =>
+  switch source {
+  | HostShellConfig(cfg) =>
     let fromCfg = key => cfg->field(key)->Option.flatMap(asString)
-    let endpoint = resolveField(
-      ~envKey="REVENTLESS_GRAPHQL_ENDPOINT",
-      ~fromSource=fromCfg("apiEndpoint"),
-      ~human="apiEndpoint",
-    )
-    let uploadEndpoint = resolveField(
-      ~envKey="REVENTLESS_UPLOAD_ENDPOINT",
-      ~fromSource=fromCfg("uploadEndpoint"),
-      ~human="uploadEndpoint",
-    )
-    let region = resolveField(
-      ~envKey="AWS_REGION",
-      ~fromSource=fromCfg("region"),
-      ~human="region",
-    )
-    let clientId = resolveField(
-      ~envKey="COGNITO_CLIENT_ID",
-      ~fromSource=fromCfg("cognitoClientId"),
-      ~human="cognitoClientId",
-    )
-    (endpoint, uploadEndpoint, region, clientId)
-  | None =>
+    {
+      graphql: resolveField(
+        ~envKey="REVENTLESS_GRAPHQL_ENDPOINT",
+        ~fromSource=fromCfg("apiEndpoint"),
+        ~human="apiEndpoint",
+      ),
+      uploadEndpoint: optionalField(
+        ~envKey="REVENTLESS_UPLOAD_ENDPOINT",
+        ~fromSource=fromCfg("uploadEndpoint"),
+      ),
+      uploadEndpoints: cfg->field("uploadEndpoints")->Option.mapOr(Dict.make(), asStringDict),
+      cognitoRegion: resolveField(
+        ~envKey="AWS_REGION",
+        ~fromSource=fromCfg("region"),
+        ~human="region",
+      ),
+      cognitoClientId: resolveField(
+        ~envKey="COGNITO_CLIENT_ID",
+        ~fromSource=fromCfg("cognitoClientId"),
+        ~human="cognitoClientId",
+      ),
+    }
+  | StackOutputs(outputs) =>
     let out = key => outputs->field(key)->Option.flatMap(asString)
-    let endpoint = switch (
-      Seed.Prompt.envValue("REVENTLESS_GRAPHQL_ENDPOINT"),
-      out("domainMergedApiEndpoint"),
-      out("domainApiEndpoint"),
-    ) {
-    | (Some(v), _, _) | (_, Some(v), _) | (_, _, Some(v)) => v
-    | _ =>
-      throw(
-        Seed.Failed(
-          `stack "${stack}" exports neither domainMergedApiEndpoint nor domainApiEndpoint`,
-        ),
-      )
+    {
+      graphql: switch (
+        Seed.Prompt.envValue("REVENTLESS_GRAPHQL_ENDPOINT"),
+        out("domainMergedApiEndpoint"),
+        out("domainApiEndpoint"),
+      ) {
+      | (Some(v), _, _) | (_, Some(v), _) | (_, _, Some(v)) => v
+      | _ =>
+        throw(
+          Seed.Failed(
+            `stack "${stack}" exports neither domainMergedApiEndpoint nor domainApiEndpoint`,
+          ),
+        )
+      },
+      // No stack output carries the legacy single service — it exists only in a
+      // host shell's config.json — so here the env override is its only source.
+      uploadEndpoint: optionalField(~envKey="REVENTLESS_UPLOAD_ENDPOINT", ~fromSource=None),
+      uploadEndpoints: outputs->field("uploadEndpoints")->Option.mapOr(Dict.make(), asStringDict),
+      cognitoRegion: resolveField(
+        ~envKey="AWS_REGION",
+        ~fromSource=out("cognitoRegion"),
+        ~human="cognitoRegion",
+      ),
+      cognitoClientId: resolveField(
+        ~envKey="COGNITO_CLIENT_ID",
+        ~fromSource=out("cognitoUserPoolClientId"),
+        ~human="cognitoUserPoolClientId",
+      ),
     }
-    let region = resolveField(
-      ~envKey="AWS_REGION",
-      ~fromSource=out("cognitoRegion"),
-      ~human="cognitoRegion",
-    )
-    let clientId = resolveField(
-      ~envKey="COGNITO_CLIENT_ID",
-      ~fromSource=out("cognitoUserPoolClientId"),
-      ~human="cognitoUserPoolClientId",
-    )
-    // Absent → "" → the data set skips its upload phase.
-    let uploadEndpoint = Seed.Prompt.envValue("REVENTLESS_UPLOAD_ENDPOINT")->Option.getOr("")
-    (endpoint, uploadEndpoint, region, clientId)
   }
+
+let resolveEndpoints = async (
+  ~projectDir: string,
+  ~backend: option<string>,
+  ~stack: string,
+): endpoints => {
+  let outputs = stackOutputs(~projectDir, ~backend, stack)
+  let source = switch outputs->field("hostShellUrl")->Option.flatMap(asString) {
+  | Some(hostShellUrl) => HostShellConfig(await fetchConfig(hostShellUrl))
+  | None => StackOutputs(outputs)
+  }
+  endpointsFrom(~stack, source)
 }
 
 // ── Cognito login ─────────────────────────────────────────────────────────────
@@ -302,15 +362,12 @@ let connect = (~projectDir: string=".", ~stack=?, ~backend=?, ()): (
     | None => backend
     }
     let stackName = await resolveStack(~projectDir, ~backend, ~stack)
-    let (endpoint, uploadEndpoint, region, clientId) = await resolveEndpoints(
-      ~projectDir,
-      ~backend,
-      ~stack=stackName,
-    )
+    let eps = await resolveEndpoints(~projectDir, ~backend, ~stack=stackName)
     await Seed.Connect.make(
       ~label=stackName,
-      ~endpoint,
-      ~uploadEndpoint,
-      ~login=cognito(~region, ~clientId),
+      ~endpoint=eps.graphql,
+      ~uploadEndpoint=eps.uploadEndpoint,
+      ~uploadEndpoints=eps.uploadEndpoints,
+      ~login=cognito(~region=eps.cognitoRegion, ~clientId=eps.cognitoClientId),
     )
   }

package/lib/bs/src/ReventlessSeedAws.res.mjs

@@ -19,6 +19,20 @@ function asString(json) {
   }
 }
 
+function asStringDict(json) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    return Object.fromEntries(Stdlib_Array.filterMap(Object.entries(json), param => {
+      let k = param[0];
+      return Stdlib_Option.map(asString(param[1]), s => [
+        k,
+        s
+      ]);
+    }));
+  } else {
+    return {};
+  }
+}
+
 function envForBackend(backend) {
   if (backend === undefined) {
     return;
@@ -152,34 +166,39 @@ function resolveField(envKey, fromSource, human) {
   };
 }
 
-async function resolveEndpoints(projectDir, backend, stack) {
-  let outputs = stackOutputs(projectDir, backend, stack);
-  let hostShellUrl = Stdlib_Option.flatMap(field(outputs, "hostShellUrl"), asString);
-  if (hostShellUrl !== undefined) {
-    let cfg = await fetchConfig(hostShellUrl);
+function optionalField(envKey, fromSource) {
+  let v = Seed_Prompt$ReventlessSeed.envValue(envKey);
+  if (v !== undefined) {
+    return v;
+  } else {
+    return Stdlib_Option.getOr(fromSource, "");
+  }
+}
+
+function endpointsFrom(stack, source) {
+  if (source.TAG === "HostShellConfig") {
+    let cfg = source._0;
     let fromCfg = key => Stdlib_Option.flatMap(field(cfg, key), asString);
-    let endpoint = resolveField("REVENTLESS_GRAPHQL_ENDPOINT", fromCfg("apiEndpoint"), "apiEndpoint");
-    let uploadEndpoint = resolveField("REVENTLESS_UPLOAD_ENDPOINT", fromCfg("uploadEndpoint"), "uploadEndpoint");
-    let region = resolveField("AWS_REGION", fromCfg("region"), "region");
-    let clientId = resolveField("COGNITO_CLIENT_ID", fromCfg("cognitoClientId"), "cognitoClientId");
-    return [
-      endpoint,
-      uploadEndpoint,
-      region,
-      clientId
-    ];
+    return {
+      graphql: resolveField("REVENTLESS_GRAPHQL_ENDPOINT", fromCfg("apiEndpoint"), "apiEndpoint"),
+      uploadEndpoint: optionalField("REVENTLESS_UPLOAD_ENDPOINT", fromCfg("uploadEndpoint")),
+      uploadEndpoints: Stdlib_Option.mapOr(field(cfg, "uploadEndpoints"), {}, asStringDict),
+      cognitoRegion: resolveField("AWS_REGION", fromCfg("region"), "region"),
+      cognitoClientId: resolveField("COGNITO_CLIENT_ID", fromCfg("cognitoClientId"), "cognitoClientId")
+    };
   }
+  let outputs = source._0;
   let out = key => Stdlib_Option.flatMap(field(outputs, key), asString);
   let match = Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_GRAPHQL_ENDPOINT");
   let match$1 = out("domainMergedApiEndpoint");
   let match$2 = out("domainApiEndpoint");
-  let endpoint$1;
+  let tmp;
   if (match !== undefined) {
-    endpoint$1 = match;
+    tmp = match;
   } else if (match$1 !== undefined) {
-    endpoint$1 = match$1;
+    tmp = match$1;
   } else if (match$2 !== undefined) {
-    endpoint$1 = match$2;
+    tmp = match$2;
   } else {
     throw {
       RE_EXN_ID: Seed$ReventlessSeed.Failed,
@@ -187,15 +206,26 @@ async function resolveEndpoints(projectDir, backend, stack) {
       Error: new Error()
     };
   }
-  let region$1 = resolveField("AWS_REGION", out("cognitoRegion"), "cognitoRegion");
-  let clientId$1 = resolveField("COGNITO_CLIENT_ID", out("cognitoUserPoolClientId"), "cognitoUserPoolClientId");
-  let uploadEndpoint$1 = Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_UPLOAD_ENDPOINT"), "");
-  return [
-    endpoint$1,
-    uploadEndpoint$1,
-    region$1,
-    clientId$1
-  ];
+  return {
+    graphql: tmp,
+    uploadEndpoint: optionalField("REVENTLESS_UPLOAD_ENDPOINT", undefined),
+    uploadEndpoints: Stdlib_Option.mapOr(field(outputs, "uploadEndpoints"), {}, asStringDict),
+    cognitoRegion: resolveField("AWS_REGION", out("cognitoRegion"), "cognitoRegion"),
+    cognitoClientId: resolveField("COGNITO_CLIENT_ID", out("cognitoUserPoolClientId"), "cognitoUserPoolClientId")
+  };
+}
+
+async function resolveEndpoints(projectDir, backend, stack) {
+  let outputs = stackOutputs(projectDir, backend, stack);
+  let hostShellUrl = Stdlib_Option.flatMap(field(outputs, "hostShellUrl"), asString);
+  let source = hostShellUrl !== undefined ? ({
+      TAG: "HostShellConfig",
+      _0: await fetchConfig(hostShellUrl)
+    }) : ({
+      TAG: "StackOutputs",
+      _0: outputs
+    });
+  return endpointsFrom(stack, source);
 }
 
 function cognito(region, clientId) {
@@ -282,14 +312,15 @@ function connect($staropt$star, stack, backend, param) {
     let url = Seed_Prompt$ReventlessSeed.envValue("SEED_PULUMI_BACKEND");
     let backend$1 = url !== undefined ? url : backend;
     let stackName = await resolveStack(projectDir, backend$1, stack);
-    let match = await resolveEndpoints(projectDir, backend$1, stackName);
-    return await Seed_Connect$ReventlessSeed.make(stackName, match[0], match[1], cognito(match[2], match[3]), undefined);
+    let eps = await resolveEndpoints(projectDir, backend$1, stackName);
+    return await Seed_Connect$ReventlessSeed.make(stackName, eps.graphql, eps.uploadEndpoint, eps.uploadEndpoints, cognito(eps.cognitoRegion, eps.cognitoClientId), undefined);
   };
 }
 
 export {
   field,
   asString,
+  asStringDict,
   envForBackend,
   pulumi,
   deployedStacks,
@@ -298,6 +329,8 @@ export {
   resolveStack,
   fetchConfig,
   resolveField,
+  optionalField,
+  endpointsFrom,
   resolveEndpoints,
   cognito,
   connect,

package/lib/bs/tests/EndpointResolutionTest.res

@@ -0,0 +1,181 @@
+// Which document `resolveEndpoints` reads, and what each arm takes from it.
+//
+// `endpointsFrom` is the pure half of `resolveEndpoints`; the impure half is a
+// `pulumi stack output` subprocess and a `config.json` fetch, and the decision
+// these tests pin is in neither. The defect they lock out: **neither arm read
+// `uploadEndpoints`**, so a platform that publishes a presign endpoint per
+// declared store resolved "" and the seeder reported it as serving no uploads.
+// The stack-outputs arm is the one that matters — a platform deploying no host
+// shell publishes no `hostShellUrl` by construction, so it takes that arm, and
+// the per-store endpoint is its only way to reach the store.
+
+open JestGlobals
+open ReventlessSeed
+
+@val @scope("process") external processEnv: dict<string> = "env"
+
+// Every value read here has an env override, and an ambient one in the runner's
+// environment (AWS_REGION is routinely set) would silently stand in for the
+// document under test. An empty string reads as unset.
+let clearOverrides = () =>
+  [
+    "REVENTLESS_GRAPHQL_ENDPOINT",
+    "REVENTLESS_UPLOAD_ENDPOINT",
+    "AWS_REGION",
+    "COGNITO_CLIENT_ID",
+    "SEED_SKIP_UPLOADS",
+  ]->Array.forEach(k => processEnv->Dict.set(k, ""))
+
+let obj = entries => JSON.Encode.object(entries->Dict.fromArray)
+let str = JSON.Encode.string
+
+// A host shell's config.json and the stack outputs of a platform that serves no
+// shell — the two documents the two arms read, minus the upload keys each test
+// supplies.
+let config = (~extra: array<(string, JSON.t)>) =>
+  obj(
+    Array.concat(
+      [
+        ("apiEndpoint", str("https://api.example/graphql")),
+        ("region", str("eu-west-1")),
+        ("cognitoClientId", str("client-abc")),
+      ],
+      extra,
+    ),
+  )
+
+let outputs = (~extra: array<(string, JSON.t)>) =>
+  obj(
+    Array.concat(
+      [
+        ("domainApiEndpoint", str("https://domain.example/graphql")),
+        ("cognitoRegion", str("eu-west-1")),
+        ("cognitoUserPoolClientId", str("client-abc")),
+      ],
+      extra,
+    ),
+  )
+
+let storeEndpoints = obj([("Catalog.productImages", str("https://presign.example/"))])
+
+describe("endpointsFrom — host shell arm", () => {
+  beforeEach(clearOverrides)
+
+  testSync("reads the legacy single service and the per-store map together", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="alpha",
+      HostShellConfig(
+        config(
+          ~extra=[
+            ("uploadEndpoint", str("https://legacy.example/")),
+            ("uploadEndpoints", storeEndpoints),
+          ],
+        ),
+      ),
+    )
+    expect(eps.uploadEndpoint)->toBe("https://legacy.example/")
+    expect(eps.uploadEndpoints)->toEqual(
+      Dict.fromArray([("Catalog.productImages", "https://presign.example/")]),
+    )
+  })
+
+  // A shell fronting only declared stores writes no singular key. That used to
+  // fail the whole run before a command was sent ("deployment is missing
+  // uploadEndpoint"), which is a harder failure than the one this plan fixes.
+  testSync("a shell publishing only per-store endpoints resolves an empty legacy service", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="alpha",
+      HostShellConfig(config(~extra=[("uploadEndpoints", storeEndpoints)])),
+    )
+    expect(eps.uploadEndpoint)->toBe("")
+    expect(eps.uploadEndpoints->Dict.keysToArray)->toEqual(["Catalog.productImages"])
+  })
+
+  testSync("REVENTLESS_UPLOAD_ENDPOINT overrides the legacy service and leaves the map alone", () => {
+    processEnv->Dict.set("REVENTLESS_UPLOAD_ENDPOINT", "https://override.example/")
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="alpha",
+      HostShellConfig(
+        config(
+          ~extra=[
+            ("uploadEndpoint", str("https://legacy.example/")),
+            ("uploadEndpoints", storeEndpoints),
+          ],
+        ),
+      ),
+    )
+    expect(eps.uploadEndpoint)->toBe("https://override.example/")
+    expect(eps.uploadEndpoints->Dict.get("Catalog.productImages"))->toEqual(
+      Some("https://presign.example/"),
+    )
+  })
+})
+
+describe("endpointsFrom — stack outputs arm", () => {
+  beforeEach(clearOverrides)
+
+  // The lookup that was missing entirely: this arm had no upload source but the
+  // env var, so a `PlatformOwned` deployment resolved "" whatever it published.
+  testSync("reads the uploadEndpoints stack output", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="pr-verify",
+      StackOutputs(outputs(~extra=[("uploadEndpoints", storeEndpoints)])),
+    )
+    expect(eps.uploadEndpoints)->toEqual(
+      Dict.fromArray([("Catalog.productImages", "https://presign.example/")]),
+    )
+  })
+
+  // Declaring no store is a legitimate deployment, not a broken one — it stays a
+  // no-op at the data set rather than failing the run.
+  testSync("a deployment declaring no store resolves an empty map without failing", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(~stack="pr-verify", StackOutputs(outputs(~extra=[])))
+    expect(eps.uploadEndpoint)->toBe("")
+    expect(eps.uploadEndpoints->Dict.keysToArray)->toEqual([])
+  })
+
+  testSync("prefers the merged API endpoint over the per-plugin one", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="pr-verify",
+      StackOutputs(outputs(~extra=[("domainMergedApiEndpoint", str("https://merged.example/"))])),
+    )
+    expect(eps.graphql)->toBe("https://merged.example/")
+  })
+
+  testSync("fails naming both keys when the stack exports neither API endpoint", () =>
+    switch ReventlessSeedAws.endpointsFrom(
+      ~stack="pr-verify",
+      StackOutputs(obj([("cognitoRegion", str("eu-west-1"))])),
+    ) {
+    | _ => fail("expected endpointsFrom to fail")
+    | exception Seed.Failed(msg) =>
+      expect(msg)->toContain("domainMergedApiEndpoint")
+      expect(msg)->toContain("domainApiEndpoint")
+    }
+  )
+})
+
+describe("endpointsFrom — malformed uploadEndpoints", () => {
+  beforeEach(clearOverrides)
+
+  // One bad member should not cost the run every endpoint it could have used.
+  testSync("drops a non-string member rather than the whole map", () => {
+    let eps = ReventlessSeedAws.endpointsFrom(
+      ~stack="pr-verify",
+      StackOutputs(
+        outputs(
+          ~extra=[
+            (
+              "uploadEndpoints",
+              obj([
+                ("Catalog.productImages", str("https://presign.example/")),
+                ("Catalog.broken", JSON.Encode.int(7)),
+              ]),
+            ),
+          ],
+        ),
+      ),
+    )
+    expect(eps.uploadEndpoints->Dict.keysToArray)->toEqual(["Catalog.productImages"])
+  })
+})