@reventlessdev/reventless-aws 3.0.0-alpha.316 → 3.0.0-alpha.318

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.318 (2026-08-21)
+
+### Bug Fixes
+
+* **core:** make @resolves/[@resolves](https://github.com/resolves)Many work end to end ([4c52957](https://github.com/ReventlessDev/reventless-core/commit/4c5295759dcb4b3eda4f0f4f2c1bc387fed88fcb))
+* **deps:** update sury to 11.0.0-rc.2 to fix unreachable union constructors ([fa5744f](https://github.com/ReventlessDev/reventless-core/commit/fa5744fed8de975e2f14725c856c6e5ce7d04a74))
+
+
+# 3.0.0-alpha.317 (2026-08-20)
+
+### Bug Fixes
+
+* **aws:** stamp union member types on the deployed projection path ([140251a](https://github.com/ReventlessDev/reventless-core/commit/140251ac7c18f484be32e8683a725f6fac2b9519))
+
+
 # 3.0.0-alpha.316 (2026-08-20)
 
 **Note:** Version bump only for package @reventlessdev/reventless-aws

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.316",
+  "version": "3.0.0-alpha.318",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -10,24 +10,24 @@
     "@aws-sdk/client-location": "3.970.0",
     "@aws-sdk/client-s3": "3.970.0",
     "@aws-sdk/s3-request-presigner": "3.970.0",
-    "sury": "11.0.0-rc.1",
+    "sury": "11.0.0-rc.2",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.12",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.1",
     "@reventlessdev/rescript-node": "2.0.0-alpha.8",
+    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.2",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.245",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.148",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.120",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.109",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.32",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.246",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.149",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.33",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.121",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.110"
   },
   "devDependencies": {
     "rescript": "12.3.0",
-    "sury-ppx": "11.0.0-rc.1"
+    "sury-ppx": "11.0.0-rc.2"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/adapter/QueryDb/PgQueryResolver_Lambda.res

@@ -443,10 +443,15 @@ let dispatch = async (
         items->Array.filter(it => it->argStr(subField)->Option.getOr("") == subVal)
       | _ => items
       }
+      // The target's own rules, applied to the target's rows — `binding` here is
+      // the target's, so `ownerAllows` / `retiredAllows` ask its questions. A
+      // nested field takes no `includeRetired` argument, so a retired row never
+      // travels through one.
+      let allowed = filtered->Array.filter(item => ownerAllows(item) && retiredAllows(item))
       if payload.multi->Option.getOr(false) {
-        JSON.Encode.array(filtered)
+        JSON.Encode.array(allowed)
       } else {
-        switch filtered->Array.get(0) {
+        switch allowed->Array.get(0) {
         | Some(item) => item
         | None => JSON.Encode.null
         }
@@ -459,7 +464,11 @@ let dispatch = async (
       let target = payload.target->Option.getOr(rm)
       let source = payload.source->Option.getOr(JSON.Encode.null)
       let ids = source->argStrs(payload.sourceIdsField->Option.getOr(""))
-      JSON.Encode.array(await binding.pushdowns.byIds(~readModelName=target, ids))
+      JSON.Encode.array(
+        (await binding.pushdowns.byIds(~readModelName=target, ids))->Array.filter(item =>
+          ownerAllows(item) && retiredAllows(item)
+        ),
+      )
 
     | other =>
       // Fail loudly on unmapped kinds (feature-parity guard, per the B3.2 plan).

package/src/adapter/QueryDb/PgQueryResolver_Lambda.res.mjs

@@ -241,7 +241,13 @@ async function dispatch(binding, lookupBindingOpt, payload) {
         let target = Stdlib_Option.getOr(payload.target, rm);
         let source = Stdlib_Option.getOr(payload.source, null);
         let ids$2 = argStrs(source, Stdlib_Option.getOr(payload.sourceIdsField, ""));
-        return await binding.pushdowns.byIds(target, ids$2);
+        return (await binding.pushdowns.byIds(target, ids$2)).filter(item => {
+          if (ownerAllows(item)) {
+            return retiredAllows(item);
+          } else {
+            return false;
+          }
+        });
       case "resolveOne" :
         let target$1 = Stdlib_Option.getOr(payload.target, rm);
         let source$1 = Stdlib_Option.getOr(payload.source, null);
@@ -265,10 +271,17 @@ async function dispatch(binding, lookupBindingOpt, payload) {
         } else {
           filtered = items$2;
         }
+        let allowed = filtered.filter(item => {
+          if (ownerAllows(item)) {
+            return retiredAllows(item);
+          } else {
+            return false;
+          }
+        });
         if (Stdlib_Option.getOr(payload.multi, false)) {
-          return filtered;
+          return allowed;
         }
-        let item = filtered[0];
+        let item = allowed[0];
         if (item !== undefined) {
           return item;
         } else {

package/src/adapter/QueryDb/QueryDbResolvers_AppSync.res

@@ -522,6 +522,32 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
       None
     }
 
+    // The GraphQL type the cross-table fields hang off. `name` is the QueryDb's
+    // own (capitalised spec) name; the SDL calls the type by its plugin-prefixed
+    // name, and a resolver naming the other one is refused at deploy with
+    // "No field named X found on type Y".
+    let parentTypeName = switch registryEntry {
+    | Some({returnTypeName}) => returnTypeName
+    | None => name
+    }
+
+    // A cross-table field hands back rows from the TARGET's table, so the owner
+    // and retirement rules that apply are the target's. Read from the same
+    // registry this view reads its own from — populated for every queryable in
+    // the plugin before any resolver is built.
+    let targetScope = (targetName: string) => {
+      let schema = ReventlessCore.Plugin_Helpers.stateSchemaRegistry->Dict.get(targetName)
+      let retired =
+        schema
+        ->Option.flatMap(Reventless.StateAnnotations.getSpec)
+        ->Option.flatMap(spec => spec.retired)
+      (
+        schema->Option.flatMap(s => Reventless.Owner.fieldNames(s)->Array.get(0)),
+        retired->Option.map(r => r.field),
+        retired->Option.flatMap(r => r.values),
+      )
+    }
+
     let idResolvers = idResolverConfigs->Array.map(config => {
       let {
         source: {idField: sourceIdField, subId: sourceSubId, resolvedField},
@@ -533,71 +559,100 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
       | _ => ("", "")
       }
       let storageResource = storageResource(~pluginName=target.pluginName, ~tableName)
-      switch resolvedField {
-      | Single(field)
-      | Multi(field) =>
-        let dataSourceName =
-          DataSource.makeDynamoDBDataSourceWithTableName(
-            ~name=name ++ (field->String.capitalize ++ "Resolver"),
-            ~api,
-            ~tableName=storageResource.name,
-            ~serviceRole=apiRole,
-            ~opts,
-          ).name->Pulumi.Output.asInput
-
-        Resolver.makeUnitJsResolver(
-          ~name=name ++ field->String.capitalize,
+      let (targetOwnerField, targetRetiredField, targetRetiredValues) = targetScope(tableName)
+      let (field, multi) = switch resolvedField {
+      | Single(field) => (field, false)
+      | Multi(field) => (field, true)
+      }
+      let response = Resolver.Functions.resolvedFieldResponse(
+        ~multi,
+        ~ownerField=targetOwnerField,
+        ~elevatedGroups,
+        ~retiredField=?targetRetiredField,
+        ~retiredValues=?targetRetiredValues,
+      )
+      let dataSourceName =
+        DataSource.makeDynamoDBDataSourceWithTableName(
+          ~name=name ++ (field->String.capitalize ++ "Resolver"),
           ~api,
-          ~dataSourceName,
-          ~type_=name->Pulumi.Input.make,
-          ~field=field->Pulumi.Input.make,
-          ~code=switch (targetId, sourceSubId, target.subIdField) {
-          | (Id, Field(sourceSortField), Some(targetSortField)) =>
-            Resolver.Functions.resolveIdSort(~sourceIdField, ~sourceSortField, ~targetSortField)
-          | (Id, Argument(sourceSortArgument), Some(targetSortField)) =>
-            Resolver.Functions.resolveIdSortArgument(
-              ~sourceIdField,
-              ~sourceSortArgument,
-              ~targetSortField,
-            )
-          | (Id, _, _) => Resolver.Functions.resolveId(~sourceIdField)
-
-          | (_, Field(sourceSortField), Some(targetSortField)) =>
-            Resolver.Functions.resolveIdByIndexSort(
-              ~index,
-              ~sourceIdField,
-              ~targetIdField,
-              ~sourceSortField,
-              ~targetSortField,
-            )
-          | (_, Argument(sourceSortArgument), Some(targetSortField)) =>
-            Resolver.Functions.resolveIdByIndexSortArgument(
-              ~index,
-              ~sourceIdField,
-              ~targetIdField,
-              ~sourceSortArgument,
-              ~targetSortField,
-            )
-          | _ => Resolver.Functions.resolveIdByIndex(~index, ~sourceIdField, ~targetIdField)
-          },
+          ~tableName=storageResource.name,
+          ~serviceRole=apiRole,
           ~opts,
-        )
-      }
+        ).name->Pulumi.Output.asInput
+
+      Resolver.makeUnitJsResolver(
+        ~name=name ++ field->String.capitalize,
+        ~api,
+        ~dataSourceName,
+        ~type_=parentTypeName->Pulumi.Input.make,
+        ~field=field->Pulumi.Input.make,
+        ~code=switch (targetId, sourceSubId, target.subIdField) {
+        | (Id, Field(sourceSortField), Some(targetSortField)) =>
+          Resolver.Functions.resolveIdSort(
+            ~sourceIdField,
+            ~sourceSortField,
+            ~targetSortField,
+            ~response,
+          )
+        | (Id, Argument(sourceSortArgument), Some(targetSortField)) =>
+          Resolver.Functions.resolveIdSortArgument(
+            ~sourceIdField,
+            ~sourceSortArgument,
+            ~targetSortField,
+            ~response,
+          )
+        | (Id, _, _) => Resolver.Functions.resolveId(~sourceIdField, ~response)
+
+        | (_, Field(sourceSortField), Some(targetSortField)) =>
+          Resolver.Functions.resolveIdByIndexSort(
+            ~index,
+            ~sourceIdField,
+            ~targetIdField,
+            ~sourceSortField,
+            ~targetSortField,
+            ~response,
+          )
+        | (_, Argument(sourceSortArgument), Some(targetSortField)) =>
+          Resolver.Functions.resolveIdByIndexSortArgument(
+            ~index,
+            ~sourceIdField,
+            ~targetIdField,
+            ~sourceSortArgument,
+            ~targetSortField,
+            ~response,
+          )
+        | _ =>
+          Resolver.Functions.resolveIdByIndex(~index, ~sourceIdField, ~targetIdField, ~response)
+        },
+        ~opts,
+      )
     })
 
+    // `@resolvesMany` — BatchGetItem against the target's table. Runs on THIS
+    // view's data source rather than one of the target's: the tables map names
+    // the target explicitly, and every QueryDb in the plugin has already granted
+    // `dynamodb:*` on itself to the API role the data source assumes.
     let idsResolvers = idsResolverConfigs->Array.map(config => {
       let {source: {idsField, resolvedField}, target: {tableName} as target} = config
       let storageResource = storageResource(~pluginName=target.pluginName, ~tableName)
+      let (targetOwnerField, targetRetiredField, targetRetiredValues) = targetScope(tableName)
 
       Resolver.makeUnitJsResolver(
-        ~name=name ++ idsField->String.capitalize,
+        ~name=name ++ resolvedField->String.capitalize,
         ~api,
         ~dataSourceName,
-        ~type_=name->Pulumi.Input.make,
+        ~type_=parentTypeName->Pulumi.Input.make,
         ~field=resolvedField->Pulumi.Input.make,
         ~code=generateCode(
           ~storageResource,
-          ~template=Resolver.Functions.resolveIds(~idsField, ~sortField=target.subIdField, ...),
+          ~template=Resolver.Functions.resolveIds(
+            ~idsField,
+            ~sortField=target.subIdField,
+            ~ownerField=?targetOwnerField,
+            ~retiredField=?targetRetiredField,
+            ~retiredValues=?targetRetiredValues,
+            ~elevatedGroups,
+          ),
         ),
         ~opts,
       )

package/src/adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs

@@ -171,10 +171,22 @@ function make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolve
     } else {
       resolverRefs = undefined;
     }
+    let parentTypeName = registryEntry !== undefined ? registryEntry.returnTypeName : name$1;
+    let targetScope = targetName => {
+      let schema = Plugin_Helpers$ReventlessCore.stateSchemaRegistry[targetName];
+      let retired = Stdlib_Option.flatMap(Stdlib_Option.flatMap(schema, StateAnnotations$Reventless.getSpec), spec => spec.retired);
+      return [
+        Stdlib_Option.flatMap(schema, s => Owner$Reventless.fieldNames(s)[0]),
+        Stdlib_Option.map(retired, r => r.field),
+        Stdlib_Option.flatMap(retired, r => r.values)
+      ];
+    };
     let idResolvers = idResolverConfigs.map(config => {
       let target = config.target;
       let targetId = target.idField;
+      let tableName = target.tableName;
       let match = config.source;
+      let resolvedField = match.resolvedField;
       let sourceSubId = match.subId;
       let sourceIdField = match.idField;
       let match$1;
@@ -197,40 +209,62 @@ function make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolve
       }
       let targetIdField = match$1[1];
       let index$1 = match$1[0];
-      let storageResource$1 = storageResource(target.pluginName, target.tableName);
-      let field = match.resolvedField._0;
+      let storageResource$1 = storageResource(target.pluginName, tableName);
+      let match$2 = targetScope(tableName);
+      let match$3;
+      match$3 = resolvedField.TAG === "Single" ? [
+          resolvedField._0,
+          false
+        ] : [
+          resolvedField._0,
+          true
+        ];
+      let field = match$3[0];
+      let response = AppSync_Resolver_Functions$PulumiAws.resolvedFieldResponse(match$3[1], match$2[0], elevatedGroups, match$2[1], match$2[2]);
       let dataSourceName = AppSync_DataSource$PulumiAws.makeDynamoDBDataSourceWithTableName(name$1 + (Stdlib_String.capitalize(field) + "Resolver"), api, storageResource$1.name, apiRole, opts).name;
-      let match$2 = target.subIdField;
+      let match$4 = target.subIdField;
       let tmp;
       let exit = 0;
+      let exit$1 = 0;
       if (typeof targetId !== "object") {
-        tmp = typeof sourceSubId !== "object" ? AppSync_Resolver_Functions$PulumiAws.resolveId(sourceIdField) : (
+        tmp = typeof sourceSubId !== "object" ? AppSync_Resolver_Functions$PulumiAws.resolveId(sourceIdField, response) : (
             sourceSubId.TAG === "Field" ? (
-                match$2 !== undefined ? AppSync_Resolver_Functions$PulumiAws.resolveIdSort(sourceIdField, sourceSubId._0, match$2) : AppSync_Resolver_Functions$PulumiAws.resolveId(sourceIdField)
+                match$4 !== undefined ? AppSync_Resolver_Functions$PulumiAws.resolveIdSort(sourceIdField, sourceSubId._0, match$4, response) : AppSync_Resolver_Functions$PulumiAws.resolveId(sourceIdField, response)
               ) : (
-                match$2 !== undefined ? AppSync_Resolver_Functions$PulumiAws.resolveIdSortArgument(sourceIdField, sourceSubId._0, match$2) : AppSync_Resolver_Functions$PulumiAws.resolveId(sourceIdField)
+                match$4 !== undefined ? AppSync_Resolver_Functions$PulumiAws.resolveIdSortArgument(sourceIdField, sourceSubId._0, match$4, response) : AppSync_Resolver_Functions$PulumiAws.resolveId(sourceIdField, response)
               )
           );
       } else {
-        exit = 1;
+        exit$1 = 2;
+      }
+      if (exit$1 === 2) {
+        if (typeof sourceSubId !== "object") {
+          exit = 1;
+        } else if (sourceSubId.TAG === "Field") {
+          if (match$4 !== undefined) {
+            tmp = AppSync_Resolver_Functions$PulumiAws.resolveIdByIndexSort(index$1, sourceIdField, sourceSubId._0, targetIdField, match$4, response);
+          } else {
+            exit = 1;
+          }
+        } else if (match$4 !== undefined) {
+          tmp = AppSync_Resolver_Functions$PulumiAws.resolveIdByIndexSortArgument(index$1, sourceIdField, sourceSubId._0, targetIdField, match$4, response);
+        } else {
+          exit = 1;
+        }
       }
       if (exit === 1) {
-        tmp = typeof sourceSubId !== "object" ? AppSync_Resolver_Functions$PulumiAws.resolveIdByIndex(index$1, sourceIdField, targetIdField) : (
-            sourceSubId.TAG === "Field" ? (
-                match$2 !== undefined ? AppSync_Resolver_Functions$PulumiAws.resolveIdByIndexSort(index$1, sourceIdField, sourceSubId._0, targetIdField, match$2) : AppSync_Resolver_Functions$PulumiAws.resolveIdByIndex(index$1, sourceIdField, targetIdField)
-              ) : (
-                match$2 !== undefined ? AppSync_Resolver_Functions$PulumiAws.resolveIdByIndexSortArgument(index$1, sourceIdField, sourceSubId._0, targetIdField, match$2) : AppSync_Resolver_Functions$PulumiAws.resolveIdByIndex(index$1, sourceIdField, targetIdField)
-              )
-          );
+        tmp = AppSync_Resolver_Functions$PulumiAws.resolveIdByIndex(index$1, sourceIdField, targetIdField, response);
       }
-      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(field), api, dataSourceName, name$1, field, tmp, opts);
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(field), api, dataSourceName, parentTypeName, field, tmp, opts);
     });
     let idsResolvers = idsResolverConfigs.map(config => {
       let target = config.target;
+      let tableName = target.tableName;
       let match = config.source;
-      let idsField = match.idsField;
-      let storageResource$1 = storageResource(target.pluginName, target.tableName);
-      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(idsField), api, dataSourceName, name$1, match.resolvedField, generateCode(storageResource$1, none => AppSync_Resolver_Functions$PulumiAws.resolveIds(none, idsField, target.subIdField)), opts);
+      let resolvedField = match.resolvedField;
+      let storageResource$1 = storageResource(target.pluginName, tableName);
+      let match$1 = targetScope(tableName);
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(resolvedField), api, dataSourceName, parentTypeName, resolvedField, generateCode(storageResource$1, AppSync_Resolver_Functions$PulumiAws.resolveIds(match.idsField, target.subIdField, match$1[0], match$1[1], match$1[2], elevatedGroups)), opts);
     });
     let mainResolvers = resolverByIdMultiple !== undefined ? (
         resolverByIds !== undefined ? [

package/src/adapter/QueryDb/QueryDbResolvers_Lambda.res

@@ -231,6 +231,14 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
       }
     })
 
+    // The GraphQL type the cross-table fields hang off — the plugin-prefixed SDL
+    // name, not the QueryDb's own. A resolver naming the other one is refused at
+    // deploy with "No field named X found on type Y".
+    let parentTypeName = switch registryEntry {
+    | Some({returnTypeName}) => returnTypeName
+    | None => name
+    }
+
     // @resolves — single cross-table field resolver on this (parent) type. The
     // target's binding key is its capitalized spec name (mirrors how the binding
     // registry is keyed); the parent object flows via ctx.source.
@@ -259,7 +267,7 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
         ~name=name ++ field->String.capitalize,
         ~api,
         ~dataSourceName,
-        ~type_=name->Pulumi.Input.make,
+        ~type_=parentTypeName->Pulumi.Input.make,
         ~field=field->Pulumi.Input.make,
         ~code=invokeFieldTemplate(~sourceType=name, ~kind="resolveOne", ~target=targetKey, ~extra),
         ~opts,
@@ -275,7 +283,7 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
         ~name=name ++ resolvedField->String.capitalize,
         ~api,
         ~dataSourceName,
-        ~type_=name->Pulumi.Input.make,
+        ~type_=parentTypeName->Pulumi.Input.make,
         ~field=resolvedField->Pulumi.Input.make,
         ~code=invokeFieldTemplate(~sourceType=name, ~kind="resolveMany", ~target=targetKey, ~extra),
         ~opts,

package/src/adapter/QueryDb/QueryDbResolvers_Lambda.res.mjs

@@ -107,6 +107,7 @@ function make(name, api, param, dataSourceName, indexes, subIdField, idResolverC
         return mkResolver(resolverName, field, "index", index, undefined, undefined);
       }
     });
+    let parentTypeName = registryEntry !== undefined ? registryEntry.returnTypeName : name$1;
     let idResolvers = idResolverConfigs.map(config => {
       let target = config.target;
       let match = config.source;
@@ -139,14 +140,14 @@ function make(name, api, param, dataSourceName, indexes, subIdField, idResolverC
       let extra = `\n      sourceIdField: '` + match.idField + `',\n      multi: ` + (
         match$1[1] ? "true" : "false"
       ) + `,` + targetFrag + subIdFrag;
-      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(field), api, dataSourceName, name$1, field, invokeFieldTemplate(name$1, "resolveOne", targetKey, extra), opts);
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(field), api, dataSourceName, parentTypeName, field, invokeFieldTemplate(name$1, "resolveOne", targetKey, extra), opts);
     });
     let idsResolvers = idsResolverConfigs.map(config => {
       let match = config.source;
       let resolvedField = match.resolvedField;
       let targetKey = Stdlib_String.capitalize(config.target.tableName);
       let extra = `\n      sourceIdsField: '` + match.idsField + `',`;
-      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(resolvedField), api, dataSourceName, name$1, resolvedField, invokeFieldTemplate(name$1, "resolveMany", targetKey, extra), opts);
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(resolvedField), api, dataSourceName, parentTypeName, resolvedField, invokeFieldTemplate(name$1, "resolveMany", targetKey, extra), opts);
     });
     return [
       byId,

package/src/adapter/Runtime/ProjectionEntryPoint_Ops.res

@@ -55,6 +55,37 @@ external withLiveUpdates: (
   liveConfig,
 ) => ReventlessCore.QueryDb_Adapter.operations = "withLiveUpdates"
 
+/**
+Stamps every union value in a saved row with the GraphQL member type it is.
+
+`QueryDb_Operations.Make` does this for the typed path — the local platform and
+the storage tests — but the deployed projection Lambdas do not go through that
+functor: they assemble JSON-level operations here. Without this the stamp never
+ran on AWS, every union member resolved to null, and the null took its
+non-nullable parent, so rows vanished from a view rather than erroring.
+
+`stateSchema` is `None` for a spec module that predates it, which leaves rows
+exactly as they were.
+*/
+let withUnionMemberTypes = (
+  base: ReventlessCore.QueryDb_Adapter.operations,
+  ~stateSchema: option<S.t<unknown>>,
+): ReventlessCore.QueryDb_Adapter.operations =>
+  switch stateSchema {
+  | None => base
+  | Some(schema) =>
+    let stamp = (state: JSON.t) => {
+      Reventless.TaggedUnion.stampInto(~schema, state)
+      state
+    }
+    {
+      ...base,
+      save: (id, state, saveMode, ttl) => base.save(id, stamp(state), saveMode, ttl),
+      saveBatch: items =>
+        base.saveBatch(items->Array.map(((id, state, ttl)) => (id, stamp(state), ttl))),
+    }
+  }
+
 let makeQueryDbOps = (
   ~queryDbTableName: string,
   ~pgConnection: option<PgConnection.connectionConfig>,

package/src/adapter/Runtime/ProjectionEntryPoint_Ops.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
 import * as StateTopicPublishMjs from "./StateTopicPublish.mjs";
 import * as QueryDbEntryPoint_Ops$ReventlessAws from "./QueryDbEntryPoint_Ops.res.mjs";
 import * as QueryDbStorage_Postgres_Runtime$ReventlessAws from "../QueryDb/QueryDbStorage_Postgres_Runtime.res.mjs";
@@ -17,6 +18,29 @@ function withLiveUpdates(prim0, prim1) {
   return StateTopicPublishMjs.withLiveUpdates(prim0, prim1);
 }
 
+function withUnionMemberTypes(base, stateSchema) {
+  if (stateSchema !== undefined) {
+    return {
+      load: base.load,
+      loadStream: base.loadStream,
+      save: (id, state, saveMode, ttl) => base.save(id, (TaggedUnion$Reventless.stampInto(stateSchema, state), state), saveMode, ttl),
+      saveBatch: items => base.saveBatch(items.map(param => {
+        let state = param[1];
+        return [
+          param[0],
+          (TaggedUnion$Reventless.stampInto(stateSchema, state), state),
+          param[2]
+        ];
+      })),
+      count: base.count,
+      delete: base.delete,
+      deleteBatch: base.deleteBatch
+    };
+  } else {
+    return base;
+  }
+}
+
 function makeQueryDbOps(queryDbTableName, pgConnection, stateTopicName, indexes, subIdField) {
   if (pgConnection !== undefined) {
     return StateTopicPublishMjs.withLiveUpdates(QueryDbStorage_Postgres_Runtime$ReventlessAws.opsFor(pgConnection, queryDbTableName, indexes, subIdField), {
@@ -34,6 +58,7 @@ export {
   indexesOf,
   subIdFieldOf,
   withLiveUpdates,
+  withUnionMemberTypes,
   makeQueryDbOps,
 }
-/* ./StateTopicPublish.mjs Not a pure module */
+/* TaggedUnion-Reventless Not a pure module */

package/src/adapter/Runtime/ReadModelEntryPoint.mjs

@@ -47,6 +47,7 @@ async function buildAllHandlers() {
     const operations = Ops.buildOperations(entry, {
       config: specModule.config,
       subIdConfig: specModule.subIdConfig,
+      stateSchema: specModule.stateSchema,
     });
     const callback = readModelCallbackMake(specModule)(mappingsModule)({
       ReadModelSpec: specModule,

package/src/adapter/Runtime/ReadModelEntryPoint_Ops.res

@@ -90,6 +90,8 @@ let withInjectedId = (
 type specInfo = {
   config: option<ProjectionEntryPoint_Ops.specConfig>,
   subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
+  // Read off the runtime-loaded spec module; `None` on a module that predates it.
+  stateSchema: option<S.t<unknown>>,
 }
 
 let buildOperations = (
@@ -102,7 +104,9 @@ let buildOperations = (
     ~stateTopicName=entry.stateTopicName,
     ~indexes=ProjectionEntryPoint_Ops.indexesOf(spec.config),
     ~subIdField=ProjectionEntryPoint_Ops.subIdFieldOf(spec.subIdConfig),
-  )->withInjectedId
+  )
+  ->ProjectionEntryPoint_Ops.withUnionMemberTypes(~stateSchema=spec.stateSchema)
+  ->withInjectedId
 
 let makeRegisteredHandler = (
   entry: handlerEntry,

package/src/adapter/Runtime/ReadModelEntryPoint_Ops.res.mjs

@@ -60,7 +60,7 @@ function withInjectedId(base) {
 }
 
 function buildOperations(entry, spec) {
-  return withInjectedId(ProjectionEntryPoint_Ops$ReventlessAws.makeQueryDbOps(entry.queryDbTableName, entry.pgConnection, entry.stateTopicName, ProjectionEntryPoint_Ops$ReventlessAws.indexesOf(spec.config), ProjectionEntryPoint_Ops$ReventlessAws.subIdFieldOf(spec.subIdConfig)));
+  return withInjectedId(ProjectionEntryPoint_Ops$ReventlessAws.withUnionMemberTypes(ProjectionEntryPoint_Ops$ReventlessAws.makeQueryDbOps(entry.queryDbTableName, entry.pgConnection, entry.stateTopicName, ProjectionEntryPoint_Ops$ReventlessAws.indexesOf(spec.config), ProjectionEntryPoint_Ops$ReventlessAws.subIdFieldOf(spec.subIdConfig)), spec.stateSchema));
 }
 
 function makeRegisteredHandler(entry, handleJsonEvents) {

package/src/adapter/Runtime/StateViewSliceEntryPoint.mjs

@@ -42,6 +42,7 @@ async function buildAllHandlers() {
         project: projectionModule.project,
         config: specModule.config,
         subIdConfig: specModule.subIdConfig,
+        stateSchema: specModule.stateSchema,
       })
     );
   }));

package/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res

@@ -176,6 +176,8 @@ type sliceModules<'event> = {
   >,
   config: option<ProjectionEntryPoint_Ops.specConfig>,
   subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
+  // Same union stamp the read-model path needs; a slice's state can hold one too.
+  stateSchema: option<S.t<unknown>>,
 }
 
 let makeRegisteredHandler = (
@@ -188,7 +190,7 @@ let makeRegisteredHandler = (
     ~stateTopicName=entry.stateTopicName,
     ~indexes=ProjectionEntryPoint_Ops.indexesOf(modules.config),
     ~subIdField=ProjectionEntryPoint_Ops.subIdFieldOf(modules.subIdConfig),
-  )
+  )->ProjectionEntryPoint_Ops.withUnionMemberTypes(~stateSchema=modules.stateSchema)
   {
     handler: StreamRoutedEntryPoint_Ops.toStreamHandler(
       makeJsonEventsHandler(

package/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res.mjs

@@ -84,7 +84,7 @@ function makeJsonEventsHandler(sliceName, eventSchema, project, queryDbOps, subI
 }
 
 function makeRegisteredHandler(entry, modules) {
-  let queryDbOps = ProjectionEntryPoint_Ops$ReventlessAws.makeQueryDbOps(entry.queryDbTableName, entry.pgConnection, entry.stateTopicName, ProjectionEntryPoint_Ops$ReventlessAws.indexesOf(modules.config), ProjectionEntryPoint_Ops$ReventlessAws.subIdFieldOf(modules.subIdConfig));
+  let queryDbOps = ProjectionEntryPoint_Ops$ReventlessAws.withUnionMemberTypes(ProjectionEntryPoint_Ops$ReventlessAws.makeQueryDbOps(entry.queryDbTableName, entry.pgConnection, entry.stateTopicName, ProjectionEntryPoint_Ops$ReventlessAws.indexesOf(modules.config), ProjectionEntryPoint_Ops$ReventlessAws.subIdFieldOf(modules.subIdConfig)), modules.stateSchema);
   return {
     handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(makeJsonEventsHandler(modules.name, modules.consumedEventSchema, modules.project, queryDbOps, modules.subIdConfig)),
     comp: `StateViewSlice(` + modules.name + `)`

package/tests/AppSync_RetirementNarrowingTest.res

@@ -308,3 +308,81 @@ describe("the unowned stub is callable where the door calls it", () => {
     ))->Expect.toEqual((true, true))
   })
 })
+
+// ── The cross-table doors (`@resolves` / `@resolvesMany`) ────────────────────
+//
+// A field that follows a foreign key hands back the TARGET's rows, so the
+// target's rules narrow them. The field takes no `includeRetired` argument, so
+// `_wantsRetired` is never true through one — `{list}Refs` is the door that
+// names a row the archive took.
+
+describe("the cross-table batch door", () => {
+  let code = F.resolveIds(
+    ~idsField="productIds",
+    ~sortField=None,
+    ~retiredField="shelfStatus",
+    ~retiredValues=["Archived"],
+    ~elevatedGroups=elevated,
+  )("ProductsTable")
+
+  // BatchGetItem answers `{data: {<table>: [...]}}`; returning `ctx.result`
+  // handed the whole envelope to a field typed as a list, which fails at
+  // execution for every caller that selects it.
+  testSync("returns the rows out of the batch envelope", () =>
+    expect(code->String.includes("ctx.result?.data?.['ProductsTable']"))->Expect.toBe(true)
+  )
+
+  testSync("drops retired rows from the returned array", () =>
+    expect(code->String.includes("item !== null && _live(item)"))->Expect.toBe(true)
+  )
+
+  // An empty id array used to fall through to a GetItem on the PARENT's own id
+  // against the target's table — a read that answers a shape the field cannot be.
+  testSync("short-circuits an empty id array instead of reading", () =>
+    expect((
+      code->String.includes("if (idList.length === 0) return runtime.earlyReturn([]);"),
+      code->String.includes("operation: 'GetItem'"),
+    ))->toEqual((true, false))
+  )
+
+  testSync("is unchanged for a target that declares neither rule", () => {
+    let plain = F.resolveIds(~idsField="productIds", ~sortField=None)("ProductsTable")
+    expect((plain->String.includes("_owns"), plain->String.includes("_live")))->toEqual((
+      false,
+      false,
+    ))
+  })
+})
+
+describe("the cross-table single door", () => {
+  let response = (~multi) =>
+    F.resolvedFieldResponse(
+      ~multi,
+      ~ownerField=Some("customerId"),
+      ~elevatedGroups=elevated,
+      ~retiredField="shelfStatus",
+      ~retiredValues=["Archived"],
+    )
+
+  testSync("narrows the one row it hands back", () =>
+    expect(response(~multi=false)->String.includes("_owns(_row) && _live(_row) ? _row : null"))
+    ->Expect.toBe(true)
+  )
+
+  testSync("narrows every row of the list form", () =>
+    expect(
+      response(~multi=true)->String.includes("filter(_row => _owns(_row) && _live(_row))"),
+    )->Expect.toBe(true)
+  )
+
+  // The list form used to answer with the first row alone, whatever the SDL said.
+  testSync("the list form returns the list", () =>
+    expect(response(~multi=true)->String.includes("ctx.result.items[0]"))->Expect.toBe(false)
+  )
+
+  testSync("a target with neither rule keeps the plain response", () => {
+    let plain = F.resolvedFieldResponse(~multi=false, ~ownerField=None, ~elevatedGroups=elevated)
+    expect((plain->String.includes("_owns"), plain->String.includes("ctx.result.items[0]")))
+    ->toEqual((false, true))
+  })
+})

package/tests/AppSync_RetirementNarrowingTest.res.mjs

@@ -206,6 +206,58 @@ globalThis.describe("the unowned stub is callable where the door calls it", () =
   });
 });
 
+globalThis.describe("the cross-table batch door", () => {
+  let code = AppSync_Resolver_Functions$PulumiAws.resolveIds("productIds", undefined, undefined, "shelfStatus", ["Archived"], elevated)("ProductsTable");
+  globalThis.test("returns the rows out of the batch envelope", () => {
+    globalThis.expect(code.includes("ctx.result?.data?.['ProductsTable']")).toBe(true);
+  });
+  globalThis.test("drops retired rows from the returned array", () => {
+    globalThis.expect(code.includes("item !== null && _live(item)")).toBe(true);
+  });
+  globalThis.test("short-circuits an empty id array instead of reading", () => {
+    globalThis.expect([
+      code.includes("if (idList.length === 0) return runtime.earlyReturn([]);"),
+      code.includes("operation: 'GetItem'")
+    ]).toEqual([
+      true,
+      false
+    ]);
+  });
+  globalThis.test("is unchanged for a target that declares neither rule", () => {
+    let plain = AppSync_Resolver_Functions$PulumiAws.resolveIds("productIds", undefined, undefined, undefined, undefined, undefined)("ProductsTable");
+    globalThis.expect([
+      plain.includes("_owns"),
+      plain.includes("_live")
+    ]).toEqual([
+      false,
+      false
+    ]);
+  });
+});
+
+globalThis.describe("the cross-table single door", () => {
+  let response = multi => AppSync_Resolver_Functions$PulumiAws.resolvedFieldResponse(multi, "customerId", elevated, "shelfStatus", ["Archived"]);
+  globalThis.test("narrows the one row it hands back", () => {
+    globalThis.expect(response(false).includes("_owns(_row) && _live(_row) ? _row : null")).toBe(true);
+  });
+  globalThis.test("narrows every row of the list form", () => {
+    globalThis.expect(response(true).includes("filter(_row => _owns(_row) && _live(_row))")).toBe(true);
+  });
+  globalThis.test("the list form returns the list", () => {
+    globalThis.expect(response(true).includes("ctx.result.items[0]")).toBe(false);
+  });
+  globalThis.test("a target with neither rule keeps the plain response", () => {
+    let plain = AppSync_Resolver_Functions$PulumiAws.resolvedFieldResponse(false, undefined, elevated, undefined, undefined);
+    globalThis.expect([
+      plain.includes("_owns"),
+      plain.includes("ctx.result.items[0]")
+    ]).toEqual([
+      false,
+      true
+    ]);
+  });
+});
+
 let F;
 
 export {

package/tests/ProjectionEntryPoint_UnionStampTest.res

@@ -0,0 +1,88 @@
+// The deployed projection Lambdas assemble JSON-level QueryDb operations rather
+// than going through `QueryDb_Operations.Make`, so the union `__typename` stamp
+// that functor applies never ran on AWS. Every union member resolved to null and
+// took its non-nullable parent with it — rows vanished from a view instead of
+// erroring, on every read door, with nothing reporting it.
+//
+// The typed path was covered from the start; this side was not, which is the
+// whole reason it shipped.
+
+open JestGlobals
+
+@schema
+type geolocation =
+  | Pending({requestedFor: string})
+  | Located({lat: float, lng: float})
+
+let geolocationSchema = Reventless.TaggedUnion.named(~name="Geolocation", geolocationSchema)
+
+@schema
+type rowState = {customerId: string, geolocation: geolocation}
+
+// A recording stand-in for the storage the runtime would wrap.
+let capture = (): (ReventlessCore.QueryDb_Adapter.operations, array<JSON.t>) => {
+  let saved: array<JSON.t> = []
+  let base: ReventlessCore.QueryDb_Adapter.operations = {
+    load: _ => Promise.resolve(Ok([])),
+    loadStream: _ => Stream.empty,
+    save: (_id, state, _saveMode, _ttl) => {
+      saved->Array.push(state)
+      Promise.resolve(Ok())
+    },
+    saveBatch: items => {
+      items->Array.forEach(((_, state, _)) => saved->Array.push(state))
+      Promise.resolve(Ok())
+    },
+    count: (_, _, _) => Promise.resolve(Ok(0)),
+    delete: (_, _) => Promise.resolve(Ok()),
+    deleteBatch: _ => Promise.resolve(Ok()),
+  }
+  (base, saved)
+}
+
+let memberOf = (json: JSON.t) =>
+  json
+  ->JSON.Decode.object
+  ->Option.flatMap(o => o->Dict.get("geolocation"))
+  ->Option.flatMap(JSON.Decode.object)
+  ->Option.flatMap(o => o->Dict.get("__typename"))
+  ->Option.flatMap(JSON.Decode.string)
+
+let row = (): JSON.t =>
+  ({customerId: "c1", geolocation: Located({lat: 1.0, lng: 2.0})}: rowState)
+  ->ReventlessCore.Message.encode(rowStateSchema)
+
+describe("ProjectionEntryPoint_Ops.withUnionMemberTypes", () => {
+  testPromise("stamps the member type on save", async () => {
+    let (base, saved) = capture()
+    let ops =
+      base->ProjectionEntryPoint_Ops.withUnionMemberTypes(
+        ~stateSchema=Some(rowStateSchema->S.castToUnknown),
+      )
+    let _ = await ops.save("c1", row(), ReventlessCore.QueryDb.Any, None)
+    expect(saved->Array.get(0)->Option.flatMap(memberOf))->toEqual(Some("GeolocationLocated"))
+  })
+
+  // saveBatch is the path a multi-event projection takes, and it was missing the
+  // stamp for the same reason save was.
+  testPromise("stamps every row in a batch", async () => {
+    let (base, saved) = capture()
+    let ops =
+      base->ProjectionEntryPoint_Ops.withUnionMemberTypes(
+        ~stateSchema=Some(rowStateSchema->S.castToUnknown),
+      )
+    let _ = await ops.saveBatch([("c1", row(), None), ("c2", row(), None)])
+    expect(saved->Array.map(memberOf))->toEqual([
+      Some("GeolocationLocated"),
+      Some("GeolocationLocated"),
+    ])
+  })
+
+  // A spec module without a stateSchema leaves rows untouched rather than throwing.
+  testPromise("passes rows through when the spec has no schema", async () => {
+    let (base, saved) = capture()
+    let ops = base->ProjectionEntryPoint_Ops.withUnionMemberTypes(~stateSchema=None)
+    let _ = await ops.save("c1", row(), ReventlessCore.QueryDb.Any, None)
+    expect(saved->Array.get(0)->Option.flatMap(memberOf))->toEqual(None)
+  })
+})

package/tests/ProjectionEntryPoint_UnionStampTest.res.mjs

@@ -0,0 +1,137 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stream from "effect/Stream";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
+import * as ProjectionEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/ProjectionEntryPoint_Ops.res.mjs";
+
+let geolocationSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "Pending",
+    requestedFor: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Located",
+    lat: s.m(Sury.float),
+    lng: s.m(Sury.float)
+  }))
+]);
+
+let geolocationSchema$1 = TaggedUnion$Reventless.named("Geolocation", geolocationSchema);
+
+let rowStateSchema = Sury.$schema(s => ({
+  customerId: s.m(Sury.string),
+  geolocation: s.m(geolocationSchema$1)
+}));
+
+function capture() {
+  let saved = [];
+  let base_load = param => Promise.resolve({
+    TAG: "Ok",
+    _0: []
+  });
+  let base_loadStream = param => Stream.empty;
+  let base_save = (_id, state, _saveMode, _ttl) => {
+    saved.push(state);
+    return Promise.resolve({
+      TAG: "Ok",
+      _0: undefined
+    });
+  };
+  let base_saveBatch = items => {
+    items.forEach(param => {
+      saved.push(param[1]);
+    });
+    return Promise.resolve({
+      TAG: "Ok",
+      _0: undefined
+    });
+  };
+  let base_count = (param, param$1, param$2) => Promise.resolve({
+    TAG: "Ok",
+    _0: 0
+  });
+  let base_delete = (param, param$1) => Promise.resolve({
+    TAG: "Ok",
+    _0: undefined
+  });
+  let base_deleteBatch = param => Promise.resolve({
+    TAG: "Ok",
+    _0: undefined
+  });
+  let base = {
+    load: base_load,
+    loadStream: base_loadStream,
+    save: base_save,
+    saveBatch: base_saveBatch,
+    count: base_count,
+    delete: base_delete,
+    deleteBatch: base_deleteBatch
+  };
+  return [
+    base,
+    saved
+  ];
+}
+
+function memberOf(json) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o["geolocation"]), Stdlib_JSON.Decode.object), o => o["__typename"]), Stdlib_JSON.Decode.string);
+}
+
+function row() {
+  return Message$ReventlessCore.encode({
+    customerId: "c1",
+    geolocation: {
+      TAG: "Located",
+      lat: 1.0,
+      lng: 2.0
+    }
+  }, rowStateSchema);
+}
+
+globalThis.describe("ProjectionEntryPoint_Ops.withUnionMemberTypes", () => {
+  globalThis.test("stamps the member type on save", async () => {
+    let match = capture();
+    let ops = ProjectionEntryPoint_Ops$ReventlessAws.withUnionMemberTypes(match[0], rowStateSchema);
+    await ops.save("c1", row(), "Any", undefined);
+    globalThis.expect(Stdlib_Option.flatMap(match[1][0], memberOf)).toEqual("GeolocationLocated");
+  });
+  globalThis.test("stamps every row in a batch", async () => {
+    let match = capture();
+    let ops = ProjectionEntryPoint_Ops$ReventlessAws.withUnionMemberTypes(match[0], rowStateSchema);
+    await ops.saveBatch([
+      [
+        "c1",
+        row(),
+        undefined
+      ],
+      [
+        "c2",
+        row(),
+        undefined
+      ]
+    ]);
+    globalThis.expect(match[1].map(memberOf)).toEqual([
+      "GeolocationLocated",
+      "GeolocationLocated"
+    ]);
+  });
+  globalThis.test("passes rows through when the spec has no schema", async () => {
+    let match = capture();
+    let ops = ProjectionEntryPoint_Ops$ReventlessAws.withUnionMemberTypes(match[0], undefined);
+    await ops.save("c1", row(), "Any", undefined);
+    globalThis.expect(Stdlib_Option.flatMap(match[1][0], memberOf)).toEqual(undefined);
+  });
+});
+
+export {
+  geolocationSchema$1 as geolocationSchema,
+  rowStateSchema,
+  capture,
+  memberOf,
+  row,
+}
+/* geolocationSchema Not a pure module */

package/tests/integration/StateViewSliceEntryPoint_IntegrationTest.res

@@ -85,6 +85,7 @@ let runOneEvent: (string, JSON.t) => promise<unit> = %raw(`
         project: projectionModule.project,
         config: specModule.config,
         subIdConfig: specModule.subIdConfig,
+        stateSchema: specModule.stateSchema,
       },
     );
     const event = {
@@ -146,6 +147,21 @@ describe("StateViewSliceEntryPoint integration", () => {
         ->Array.toSorted(String.compare)
       expect(productIds)->toEqual(["prod-a", "prod-b"])
 
+      // The runtime path's union stamp, against real DynamoDB. The deployed
+      // Lambdas assemble JSON-level ops and skipped it entirely, so a member
+      // resolved to null and took its non-nullable parent with it.
+      let members =
+        rows
+        ->Array.filterMap(row =>
+          row
+          ->JSON.Decode.object
+          ->Option.flatMap(o => o->Dict.get("fulfilment"))
+          ->Option.flatMap(JSON.Decode.object)
+          ->Option.flatMap(o => o->Dict.get("__typename"))
+          ->Option.flatMap(JSON.Decode.string)
+        )
+      expect(members)->toEqual(["FulfilmentShipped", "FulfilmentShipped"])
+
       await H.deleteTable(table)
     },
   )

package/tests/integration/StateViewSliceEntryPoint_IntegrationTest.res.mjs

@@ -94,6 +94,7 @@ let runOneEvent = (async (tableName, eventJson) => {
         project: projectionModule.project,
         config: specModule.config,
         subIdConfig: specModule.subIdConfig,
+        stateSchema: specModule.stateSchema,
       },
     );
     const event = {
@@ -138,6 +139,11 @@ globalThis.describe("StateViewSliceEntryPoint integration", () => {
       "prod-a",
       "prod-b"
     ]);
+    let members = Stdlib_Array.filterMap(rows$1, row => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(row), o => o["fulfilment"]), Stdlib_JSON.Decode.object), o => o["__typename"]), Stdlib_JSON.Decode.string));
+    globalThis.expect(members).toEqual([
+      "FulfilmentShipped",
+      "FulfilmentShipped"
+    ]);
     return await DcbIntegrationHarness$ReventlessAws.deleteTable(table);
   });
 });

package/tests/integration/SvsTestSlice.res

@@ -16,11 +16,21 @@
 @schema
 type consumedEvent = ItemAddedToCart({cartId: string, productId: string, qty: int})
 
+// A union on the state, so the integration test covers the runtime path's
+// `__typename` stamp — the one the deployed Lambdas skipped entirely.
+@schema
+type fulfilment =
+  | Pending({requestedFor: string})
+  | Shipped({carrier: string})
+
+let fulfilmentSchema = Reventless.TaggedUnion.named(~name="Fulfilment", fulfilmentSchema)
+
 @schema
 type state = {
   cartId: string,
   productId: string,
   qty: int,
+  fulfilment: fulfilment,
 }
 
 // `Some({subIdField, getSubId})` — the compiled per-slice spec that a real

package/tests/integration/SvsTestSlice.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Sury from "sury";
+import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
 
 let consumedEventSchema = Sury.$schema(s => ({
   TAG: "ItemAddedToCart",
@@ -9,10 +10,24 @@ let consumedEventSchema = Sury.$schema(s => ({
   qty: s.m(Sury.int)
 }));
 
+let fulfilmentSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "Pending",
+    requestedFor: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Shipped",
+    carrier: s.m(Sury.string)
+  }))
+]);
+
+let fulfilmentSchema$1 = TaggedUnion$Reventless.named("Fulfilment", fulfilmentSchema);
+
 let stateSchema = Sury.$schema(s => ({
   cartId: s.m(Sury.string),
   productId: s.m(Sury.string),
-  qty: s.m(Sury.int)
+  qty: s.m(Sury.int),
+  fulfilment: s.m(fulfilmentSchema$1)
 }));
 
 let subIdConfig = {
@@ -22,6 +37,7 @@ let subIdConfig = {
 
 export {
   consumedEventSchema,
+  fulfilmentSchema$1 as fulfilmentSchema,
   stateSchema,
   subIdConfig,
 }

package/tests/integration/SvsTestSlice_Projection.res

@@ -17,7 +17,9 @@ let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
         cartId,
         states => {
           let others = states->Array.filter(s => s.productId != productId)
-          others->Array.concat([{cartId, productId, qty}])
+          others->Array.concat([
+            {cartId, productId, qty, fulfilment: Shipped({carrier: "dhl"})},
+          ])
         },
       ),
     ]

package/tests/integration/SvsTestSlice_Projection.res.mjs

@@ -14,7 +14,11 @@ function project(param) {
         return others.concat([{
             cartId: cartId,
             productId: productId,
-            qty: qty
+            qty: qty,
+            fulfilment: {
+              TAG: "Shipped",
+              carrier: "dhl"
+            }
           }]);
       }
     }];