@reventlessdev/reventless-aws 3.0.0-alpha.185 → 3.0.0-alpha.187

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.187 (2026-07-09)
+
+### Bug Fixes
+
+* **reventless-aws:** thread subIdConfig into deployed StateViewSlice projection runtime ([78ebf80](https://github.com/ReventlessDev/reventless-core/commit/78ebf8086406327a6d665d5dcf034630650c6803))
+
+
+# 3.0.0-alpha.186 (2026-07-08)
+
+### Bug Fixes
+
+* **reventless-core:** composite DCB slices can read back their own events ([4604a91](https://github.com/ReventlessDev/reventless-core/commit/4604a9159fb8bf59b2191ad69fee6613c7f75cd9))
+
+
 # 3.0.0-alpha.185 (2026-07-08)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.185",
+  "version": "3.0.0-alpha.187",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -11,13 +11,13 @@
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.20",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
+    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.47",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.147",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.146",
-    "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.47",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.91",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.11",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.10",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.69"
   },
   "devDependencies": {

package/src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res

@@ -124,7 +124,12 @@ let toItem = (
     item->Dict.set(attrName, tag.value->JSON.Encode.string)
   })
 
-  // Add composite tag attribute if multiple tags
+  // Add composite tag attribute if multiple tags. The tag set here is exactly the
+  // event's *entity* tags (no framework provenance tag is smuggled in — see
+  // docs/plans/done/dcb-composite-query-clause-fence-contention.md), so the stored
+  // `tag_composite` key is byte-identical to the key a composite decision read
+  // builds from the command's entity tags — the write/read match a composite
+  // slice's OCC depends on.
   if event.tags->Array.length > 1 {
     let composite = compositeTagKey(event.tags)
     item->Dict.set("tag_composite", composite->JSON.Encode.string)

package/src/adapter/EventLogSubscription/EventLogSubscription_AppSync.res

@@ -18,8 +18,7 @@ open PulumiAws
 // ── Handler code ─────────────────────────────────────────────────────────────
 //
 // Receives SNS-via-SQS records (rawMessageDelivery=true → body IS the event JSON).
-// Publishes {position, eventType, payload, originatorSlice} to AppSync Events channel.
-// The "originatorSlice" tag is injected by StateChangeSlice_Callback.encodeEvent.
+// Publishes {position, eventType, payload} to AppSync Events channel.
 
 let makeHandlerCode = (~topicName: string): string => {
   // Mirrors StateTopic_AppSync.pathSegment: AppSync Events channel segments
@@ -72,8 +71,7 @@ export async function handler(event) {
       console.error("EventLogSubscription: failed to parse record body", record.body, e);
       continue;
     }
-    const originatorSlice = body.tags?.find(t => t.key === "originatorSlice")?.value;
-    const payload = { position: body.position, eventType: body.eventType, payload: body.data, originatorSlice: originatorSlice ?? null };
+    const payload = { position: body.position, eventType: body.eventType, payload: body.data };
     const reqBody = JSON.stringify({ id: record.messageId, channel: CHANNEL, events: [JSON.stringify(payload)] });
     const auth = await signedHeaders(url.hostname, "/event", reqBody);
     const res = await fetch(APPSYNC_ENDPOINT + "/event", {

package/src/adapter/EventLogSubscription/EventLogSubscription_AppSync.res.mjs

@@ -61,8 +61,7 @@ export async function handler(event) {
       console.error("EventLogSubscription: failed to parse record body", record.body, e);
       continue;
     }
-    const originatorSlice = body.tags?.find(t => t.key === "originatorSlice")?.value;
-    const payload = { position: body.position, eventType: body.eventType, payload: body.data, originatorSlice: originatorSlice ?? null };
+    const payload = { position: body.position, eventType: body.eventType, payload: body.data };
     const reqBody = JSON.stringify({ id: record.messageId, channel: CHANNEL, events: [JSON.stringify(payload)] });
     const auth = await signedHeaders(url.hostname, "/event", reqBody);
     const res = await fetch(APPSYNC_ENDPOINT + "/event", {

package/src/adapter/Runtime/StateViewSliceEntryPoint.mjs

@@ -45,7 +45,7 @@ function groupBySource(records) {
 // `pgConnection`, when present, selects the Postgres QueryDb runtime for this
 // slice's view table (`queryDbTableName` is then the slice spec name, the shared
 // `qdb_<name>` discriminator). Absent → the DynamoDB path is byte-identical.
-function buildJsonEventsHandler(specModule, projectionModule, queryDbTableName, pgConnection, stateTopicName) {
+export function buildJsonEventsHandler(specModule, projectionModule, queryDbTableName, pgConnection, stateTopicName) {
   let queryDbOps;
   if (pgConnection) {
     const indexes = (specModule.config && specModule.config.indexes) || [];
@@ -92,7 +92,12 @@ function buildJsonEventsHandler(specModule, projectionModule, queryDbTableName,
       actions => Stream.fromIterable(actions)
     ),
     action => Effect.map(
-      Effect.promise(() => handleAction(action, queryDbOps, undefined)),
+      // Thread the slice's `subIdConfig` (generated from `@subId`) so sub-id-dependent
+      // actions like `UpdateMultiState` can resolve the sort key. Dropping it here made
+      // every such action hit the `MissingSubIdConfig` guard and silently write nothing,
+      // while the test-harness callback path (which threads it) stayed green. `undefined`
+      // for slices without an `@subId` is correct — those never emit sub-id actions.
+      Effect.promise(() => handleAction(action, queryDbOps, specModule.subIdConfig)),
       _ => {}
     )
   );

package/tests/DcbEventLogStorage_DynamoDb_RuntimeTest.res

@@ -526,6 +526,39 @@ describe("Runtime.buildConditionalTransactItems — composite partition fences o
   })
 })
 
+describe("Runtime.toItem — tag_composite is keyed on the event's entity tags", () => {
+  // Guards the composite write/read key alignment a composite-partition slice's OCC
+  // depends on: the stored `tag_composite` must equal the key a composite decision
+  // read builds from the command's entity tags (`compositeTagKey`). Historically an
+  // `originatorSlice` provenance tag was smuggled into the tag set and polluted this
+  // key, so a composite slice could never read back its own events. See
+  // docs/analysis/dcb-event-provenance-and-metadata.md and
+  // docs/plans/done/dcb-composite-query-clause-fence-contention.md.
+  let tagOf = (key, value): Reventless.DcbTag.tag => {key, value}
+  let entityTags = [
+    tagOf("environment", "prod"),
+    tagOf("platformName", "plat"),
+    tagOf("pluginName", "plug"),
+    tagOf("componentName", "compA"),
+    tagOf("resourceName", "r1"),
+  ]
+  let storedEvent: ReventlessCore.DcbEventLog_Adapter.rawStoredEvent = {
+    eventType: "ResourceAdded",
+    data: JSON.Object(Dict.make()),
+    tags: entityTags,
+    meta: testMeta(),
+  }
+  let storedComposite =
+    Runtime.toItem("100", storedEvent, ~recordedAt="2026-07-08T00:00:00Z")
+    ->JSON.Decode.object
+    ->Option.flatMap(o => o->Dict.get("tag_composite"))
+    ->Option.flatMap(JSON.Decode.string)
+
+  testSync("stored tag_composite equals the key a composite read would query", () => {
+    expect(storedComposite)->toEqual(Some(Runtime.compositeTagKey(entityTags)))
+  })
+})
+
 describe("Runtime.buildConditionalTransactItems — folded create guard (after=None)", () => {
   let event = (eventType, tags): ReventlessCore.DcbEventLog_Adapter.rawStoredEvent => {
     eventType,

package/tests/DcbEventLogStorage_DynamoDb_RuntimeTest.res.mjs

@@ -653,6 +653,43 @@ globalThis.describe("Runtime.buildConditionalTransactItems — composite partiti
   });
 });
 
+globalThis.describe("Runtime.toItem — tag_composite is keyed on the event's entity tags", () => {
+  let entityTags = [
+    {
+      key: "environment",
+      value: "prod"
+    },
+    {
+      key: "platformName",
+      value: "plat"
+    },
+    {
+      key: "pluginName",
+      value: "plug"
+    },
+    {
+      key: "componentName",
+      value: "compA"
+    },
+    {
+      key: "resourceName",
+      value: "r1"
+    }
+  ];
+  let storedEvent_data = {};
+  let storedEvent_meta = testMeta();
+  let storedEvent = {
+    eventType: "ResourceAdded",
+    data: storedEvent_data,
+    tags: entityTags,
+    meta: storedEvent_meta
+  };
+  let storedComposite = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.toItem("100", storedEvent, undefined, "2026-07-08T00:00:00Z")), o => o["tag_composite"]), Stdlib_JSON.Decode.string);
+  globalThis.test("stored tag_composite equals the key a composite read would query", () => {
+    globalThis.expect(storedComposite).toEqual(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.compositeTagKey(entityTags));
+  });
+});
+
 globalThis.describe("Runtime.buildConditionalTransactItems — folded create guard (after=None)", () => {
   let event = (eventType, tags) => ({
     eventType: eventType,

package/tests/integration/DcbCommandTopicEntryPoint_IntegrationTest.res

@@ -98,7 +98,7 @@ let runOneCompositeEvent: (string, JSON.t) => promise<JSON.t> = %raw(`
   }
 `)
 
-let buildAddResourceEvent = (~environment, ~resourceName): JSON.t => {
+let buildCompositeCommandEvent = (~command, ~environment, ~resourceName): JSON.t => {
   // `command` is the command type name as a plain string — the shape AppSync's
   // direct-invoke resolver sends and `CommandGenerator.payload.command: string`
   // expects.
@@ -111,12 +111,15 @@ let buildAddResourceEvent = (~environment, ~resourceName): JSON.t => {
     ("ip", JSON.Encode.null),
   ])
   Dict.fromArray([
-    ("command", "AddResource"->JSON.Encode.string),
+    ("command", command->JSON.Encode.string),
     ("arguments", arguments->JSON.Encode.object),
     ("meta", meta->JSON.Encode.object),
   ])->JSON.Encode.object
 }
 
+let buildAddResourceEvent = (~environment, ~resourceName): JSON.t =>
+  buildCompositeCommandEvent(~command="AddResource", ~environment, ~resourceName)
+
 let buildAppSyncEvent = (widgetId): JSON.t => {
   // CommandGenerator payload: `{command, arguments, meta, identity?}` — the
   // exact shape AppSync's direct-invoke resolver sends (matches the resolver
@@ -203,4 +206,54 @@ describe("DcbCommandTopicEntryPoint integration", () => {
       await H.deleteTable(table)
     },
   )
+
+  // Composite read-back invariant
+  // (docs/plans/done/dcb-composite-query-clause-fence-contention.md).
+  //
+  // A composite-partition slice must be able to READ BACK its own events. The
+  // stored `tag_composite` key is computed from the event's tags; if the
+  // framework `originatorSlice` provenance tag (appended by
+  // StateChangeSlice_Callback.encodeEvent) leaks into that key, it diverges from
+  // the read key (built from the command's entity tags only) and the composite
+  // GSI read never matches — so a follow-up command reads empty state.
+  //
+  // `TouchResource` requires state `Added` (i.e. it must observe the prior
+  // `ResourceAdded`) to succeed. With the bug the read misses → state `Absent` →
+  // `NotFound` → CommandRejected. With the fix the read hits → `ResourceTouched`
+  // is produced → CommandAccepted and a second event persists.
+  testAsync(
+    "composite read-back: a follow-up command sees the slice's own prior event",
+    async () => {
+      let table = await H.createDcbTableWithTagKeys(
+        "EpCompositeRB_" ++ Date.now()->Float.toString,
+        ["environment", "resourceName"],
+      )
+      let env = "prod"
+      let res = "res-rb"
+
+      let addOutcome = await runOneCompositeEvent(
+        table.name,
+        buildCompositeCommandEvent(~command="AddResource", ~environment=env, ~resourceName=res),
+      )
+      expect(
+        addOutcome->JSON.stringifyAny->Option.getOr("")->String.includes("CommandAccepted"),
+      )->toBe(true)
+
+      let touchOutcome = await runOneCompositeEvent(
+        table.name,
+        buildCompositeCommandEvent(~command="TouchResource", ~environment=env, ~resourceName=res),
+      )
+      // The read must have observed the ResourceAdded — otherwise TouchResource
+      // rejects NotFound (the originatorSlice-in-tag_composite regression).
+      expect(
+        touchOutcome->JSON.stringifyAny->Option.getOr("")->String.includes("CommandAccepted"),
+      )->toBe(true)
+
+      // Both events persisted: ResourceAdded + ResourceTouched.
+      let events = await H.scanEventTypes(table)
+      expect(events->Array.toSorted(String.compare))->toEqual(["ResourceAdded", "ResourceTouched"])
+
+      await H.deleteTable(table)
+    },
+  )
 })

package/tests/integration/DcbCommandTopicEntryPoint_IntegrationTest.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 Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as DcbIntegrationHarness$ReventlessAws from "./DcbIntegrationHarness.res.mjs";
 import * as DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws from "../../src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
 
@@ -70,7 +71,7 @@ let runOneCompositeEvent = (async (tableName, event) => {
     return commandOutcomeToJson(outcome);
   });
 
-function buildAddResourceEvent(environment, resourceName) {
+function buildCompositeCommandEvent(command, environment, resourceName) {
   let $$arguments = Object.fromEntries([
     [
       "environment",
@@ -94,7 +95,7 @@ function buildAddResourceEvent(environment, resourceName) {
   return Object.fromEntries([
     [
       "command",
-      "AddResource"
+      command
     ],
     [
       "arguments",
@@ -107,6 +108,10 @@ function buildAddResourceEvent(environment, resourceName) {
   ]);
 }
 
+function buildAddResourceEvent(environment, resourceName) {
+  return buildCompositeCommandEvent("AddResource", environment, resourceName);
+}
+
 function buildAppSyncEvent(widgetId) {
   let command = Object.fromEntries([[
       "AddWidget",
@@ -162,7 +167,7 @@ globalThis.describe("DcbCommandTopicEntryPoint integration", () => {
       "res-d",
       "res-e"
     ];
-    let outcomes = await Promise.all(resourceNames.map(resourceName => runOneCompositeEvent(table.name, buildAddResourceEvent("prod", resourceName))));
+    let outcomes = await Promise.all(resourceNames.map(resourceName => runOneCompositeEvent(table.name, buildCompositeCommandEvent("AddResource", "prod", resourceName))));
     outcomes.forEach(outcomeJson => {
       let s = Stdlib_Option.getOr(JSON.stringify(outcomeJson), "<unserializable>");
       globalThis.expect(s.includes("CommandAccepted")).toBe(true);
@@ -175,6 +180,24 @@ globalThis.describe("DcbCommandTopicEntryPoint integration", () => {
     });
     return await DcbIntegrationHarness$ReventlessAws.deleteTable(table);
   });
+  globalThis.test("composite read-back: a follow-up command sees the slice's own prior event", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.createDcbTableWithTagKeys("EpCompositeRB_" + Date.now().toString(), [
+      "environment",
+      "resourceName"
+    ]);
+    let env = "prod";
+    let res = "res-rb";
+    let addOutcome = await runOneCompositeEvent(table.name, buildCompositeCommandEvent("AddResource", env, res));
+    globalThis.expect(Stdlib_Option.getOr(JSON.stringify(addOutcome), "").includes("CommandAccepted")).toBe(true);
+    let touchOutcome = await runOneCompositeEvent(table.name, buildCompositeCommandEvent("TouchResource", env, res));
+    globalThis.expect(Stdlib_Option.getOr(JSON.stringify(touchOutcome), "").includes("CommandAccepted")).toBe(true);
+    let events = await DcbIntegrationHarness$ReventlessAws.scanEventTypes(table);
+    globalThis.expect(events.toSorted(Primitive_string.compare)).toEqual([
+      "ResourceAdded",
+      "ResourceTouched"
+    ]);
+    return await DcbIntegrationHarness$ReventlessAws.deleteTable(table);
+  });
 });
 
 let H;
@@ -183,6 +206,7 @@ export {
   H,
   runOneAppSyncEvent,
   runOneCompositeEvent,
+  buildCompositeCommandEvent,
   buildAddResourceEvent,
   buildAppSyncEvent,
 }

package/tests/integration/DcbIntegrationHarness.res

@@ -121,6 +121,21 @@ let scanFenceIds = async (table: Util_DynamoDb_Runtime.resolvedTable): array<str
   )
 }
 
+// Returns the `event` attribute of every stored event row (fence sentinels carry
+// no `event` attribute and are skipped). Lets a test assert which events actually
+// persisted — the signal that a composite slice could read back its own state.
+let scanEventTypes = async (table: Util_DynamoDb_Runtime.resolvedTable): array<string> => {
+  let items = await Util_DynamoDb_Runtime.scanStream({tableName: table.name})
+    ->Stream.runCollect
+    ->Effect.runPromise
+  items->Array.filterMap(item =>
+    item
+    ->JSON.Decode.object
+    ->Option.flatMap(obj => obj->Dict.get("event"))
+    ->Option.flatMap(JSON.Decode.string)
+  )
+}
+
 let deleteTable = async (table: Util_DynamoDb_Runtime.resolvedTable) => {
   let input = Dict.fromArray([("TableName", s(table.name))])->JSON.Encode.object
   let _ = await send(deleteTableCommand(input))

package/tests/integration/DcbIntegrationHarness.res.mjs

@@ -168,6 +168,13 @@ async function scanFenceIds(table) {
   }));
 }
 
+async function scanEventTypes(table) {
+  let items = await Effect.runPromise(Stream.runCollect(Util_DynamoDb_Runtime$ReventlessAws.scanStream({
+    TableName: table.name
+  })));
+  return Stdlib_Array.filterMap(items, item => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), obj => obj["event"]), Stdlib_JSON.Decode.string));
+}
+
 async function deleteTable(table) {
   let input = Object.fromEntries([[
       "TableName",
@@ -213,6 +220,7 @@ export {
   createDcbTable,
   createDcbTableWithTagKeys,
   scanFenceIds,
+  scanEventTypes,
   deleteTable,
   counter,
   freshTable,

package/tests/integration/EpCompositeSlice.res

@@ -1,7 +1,7 @@
 // Composite-partition slice fixture for `DcbCommandTopicEntryPoint_IntegrationTest`.
 //
 // Reproduces the deploy-sync workload shape from
-// docs/plans/dcb-composite-fence-residual-burst-contention.md: a
+// docs/plans/done/dcb-composite-fence-residual-burst-contention.md: a
 // `@compositePartitionTag` over a low-cardinality prefix (`environment`) plus a
 // high-cardinality tail (`resourceName`). Distinct resources sharing the same
 // `environment` must NOT contend — but only if the entry point threads
@@ -9,27 +9,49 @@
 // single-composite-fence collapse. Without that thread the slice writes one
 // fence per member and the shared `environment` member goes hot.
 //
+// It ALSO guards the composite read-back invariant from
+// docs/plans/done/dcb-composite-query-clause-fence-contention.md: `TouchResource`
+// requires the slice to READ its own prior `ResourceAdded` (state must be
+// `Added`), which only works if the stored `tag_composite` key matches the read
+// key — i.e. the framework `originatorSlice` provenance tag is excluded from the
+// composite key. With that bug present the read misses, state stays `Absent`, and
+// `TouchResource` is rejected `NotFound`.
+//
 // Explicit `@s.matches(Reventless.DcbTag.compositePartitionMember(...))` form
 // (not the `@compositePartitionTag` PPX shorthand) because reventless-ppx is not
 // wired into reventless-aws's rescript.json — same reason as EpTestSlice.
 
 @schema
-type consumedEvent = ResourceAdded({environment: string, resourceName: string})
+type consumedEvent =
+  | ResourceAdded({environment: string, resourceName: string})
+  | ResourceTouched({environment: string, resourceName: string})
 
 @schema
-type command = AddResource({
-  environment: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=0, ~sep="/")) string,
-  resourceName: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=1, ~sep="/")) string,
-})
+type command =
+  | AddResource({
+      environment: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=0, ~sep="/")) string,
+      resourceName: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=1, ~sep="/")) string,
+    })
+  | TouchResource({
+      environment: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=0, ~sep="/")) string,
+      resourceName: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=1, ~sep="/")) string,
+    })
 
 @schema
-type error = AlreadyAdded
+type error =
+  | AlreadyAdded
+  | NotFound
 
 @schema
-type event = ResourceAdded({
-  environment: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=0, ~sep="/")) string,
-  resourceName: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=1, ~sep="/")) string,
-})
+type event =
+  | ResourceAdded({
+      environment: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=0, ~sep="/")) string,
+      resourceName: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=1, ~sep="/")) string,
+    })
+  | ResourceTouched({
+      environment: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=0, ~sep="/")) string,
+      resourceName: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=1, ~sep="/")) string,
+    })
 
 let name = "EpCompositeSlice"
 let moduleUrl = "ep-test://EpCompositeSlice"

package/tests/integration/EpCompositeSlice.res.mjs

@@ -3,25 +3,49 @@
 import * as S from "sury/src/S.res.mjs";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 
-let consumedEventSchema = S.schema(s => ({
-  TAG: "ResourceAdded",
-  environment: s.m(S.string),
-  resourceName: s.m(S.string)
-}));
-
-let commandSchema = S.schema(s => ({
-  TAG: "AddResource",
-  environment: s.m(DcbTag$Reventless.compositePartitionMember(0, "/")),
-  resourceName: s.m(DcbTag$Reventless.compositePartitionMember(1, "/"))
-}));
-
-let errorSchema = S.literal("AlreadyAdded");
-
-let eventSchema = S.schema(s => ({
-  TAG: "ResourceAdded",
-  environment: s.m(DcbTag$Reventless.compositePartitionMember(0, "/")),
-  resourceName: s.m(DcbTag$Reventless.compositePartitionMember(1, "/"))
-}));
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "ResourceAdded",
+    environment: s.m(S.string),
+    resourceName: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ResourceTouched",
+    environment: s.m(S.string),
+    resourceName: s.m(S.string)
+  }))
+]);
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "AddResource",
+    environment: s.m(DcbTag$Reventless.compositePartitionMember(0, "/")),
+    resourceName: s.m(DcbTag$Reventless.compositePartitionMember(1, "/"))
+  })),
+  S.schema(s => ({
+    TAG: "TouchResource",
+    environment: s.m(DcbTag$Reventless.compositePartitionMember(0, "/")),
+    resourceName: s.m(DcbTag$Reventless.compositePartitionMember(1, "/"))
+  }))
+]);
+
+let errorSchema = S.union([
+  S.literal("AlreadyAdded"),
+  S.literal("NotFound")
+]);
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "ResourceAdded",
+    environment: s.m(DcbTag$Reventless.compositePartitionMember(0, "/")),
+    resourceName: s.m(DcbTag$Reventless.compositePartitionMember(1, "/"))
+  })),
+  S.schema(s => ({
+    TAG: "ResourceTouched",
+    environment: s.m(DcbTag$Reventless.compositePartitionMember(0, "/")),
+    resourceName: s.m(DcbTag$Reventless.compositePartitionMember(1, "/"))
+  }))
+]);
 
 function commandAuthorization(param) {
   return "AllowAnonymous";

package/tests/integration/EpCompositeSliceBehavior.res

@@ -1,22 +1,35 @@
 // Behavior pair for `EpCompositeSlice`. Append-on-empty / reject-on-seen, per
 // composite entity: the decision read is scoped to one `{environment,
-// resourceName}` composite, so a fresh resource sees empty state and appends,
-// while a duplicate of the same composite key sees `true` and is rejected.
+// resourceName}` composite, so a fresh resource sees `Absent` and appends, while
+// a duplicate of the same composite key sees `Added` and is rejected.
+//
+// `TouchResource` is the read-back probe: it requires the slice to have already
+// observed its own `ResourceAdded` (state `Added`) to succeed, so it exercises
+// the composite read-matching-its-own-write invariant.
 
-type state = bool
+type state =
+  | Absent
+  | Added
 
-let initialState = false
+let initialState = Absent
 
-let evolve = (_state, _event: EpCompositeSlice.consumedEvent) => true
+let evolve = (_state, event: EpCompositeSlice.consumedEvent) =>
+  switch event {
+  | ResourceAdded(_) => Added
+  | ResourceTouched(_) => Added
+  }
 
 let decide = (state, command: EpCompositeSlice.command): result<
   array<EpCompositeSlice.event>,
   EpCompositeSlice.error,
 > =>
   switch (state, command) {
-  | (true, _) => Error(AlreadyAdded)
-  | (false, AddResource({environment, resourceName})) =>
+  | (Added, AddResource(_)) => Error(AlreadyAdded)
+  | (Absent, AddResource({environment, resourceName})) =>
     Ok([ResourceAdded({environment, resourceName})])
+  | (Added, TouchResource({environment, resourceName})) =>
+    Ok([ResourceTouched({environment, resourceName})])
+  | (Absent, TouchResource(_)) => Error(NotFound)
   }
 
 let moduleUrl = "ep-test://EpCompositeSliceBehavior"

package/tests/integration/EpCompositeSliceBehavior.res.mjs

@@ -1,12 +1,28 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 
-function evolve(_state, _event) {
-  return true;
+function evolve(_state, event) {
+  return "Added";
 }
 
 function decide(state, command) {
-  if (state) {
+  if (state === "Absent") {
+    if (command.TAG === "AddResource") {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "ResourceAdded",
+            environment: command.environment,
+            resourceName: command.resourceName
+          }]
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "NotFound"
+      };
+    }
+  } else if (command.TAG === "AddResource") {
     return {
       TAG: "Error",
       _0: "AlreadyAdded"
@@ -15,7 +31,7 @@ function decide(state, command) {
     return {
       TAG: "Ok",
       _0: [{
-          TAG: "ResourceAdded",
+          TAG: "ResourceTouched",
           environment: command.environment,
           resourceName: command.resourceName
         }]
@@ -23,7 +39,7 @@ function decide(state, command) {
   }
 }
 
-let initialState = false;
+let initialState = "Absent";
 
 let moduleUrl = "ep-test://EpCompositeSliceBehavior";
 

package/tests/integration/StateViewSliceEntryPoint_IntegrationTest.res

@@ -0,0 +1,123 @@
+// Integration regression guard for the StateViewSlice projection Lambda entry
+// point (`StateViewSliceEntryPoint.mjs`), run against DynamoDB Local.
+//
+// Covers the 2026-07-09 incident: the deployed runtime built its projection
+// loop with `handleAction(action, queryDbOps, undefined)` — hardcoding
+// `subIdConfig` to `undefined` instead of threading the slice's
+// `specModule.subIdConfig`. Every sub-id-dependent action (`UpdateMultiState`)
+// then hit the `MissingSubIdConfig` guard and silently wrote nothing, while the
+// in-memory GWT/callback path (which threads `subIdConfig`) stayed green. This
+// is a deployed-runtime vs test-harness parity gap: a unit test on the callback
+// path cannot catch it, so this test drives the *real* `.mjs` entry point that
+// production uses.
+//
+// The fixture `SvsTestSlice` is an `@subId productId` view slice whose only
+// projection path is `UpdateMultiState`. Before the fix both appends no-op and
+// the table stays empty; after the fix each product is a distinct row.
+//
+// Boots via the same `pnpm run test:integration` Docker-gated suite as the DCB
+// entry-point test; reuses `DcbIntegrationHarness` for table lifecycle commands.
+
+open JestGlobals
+
+module H = DcbIntegrationHarness
+
+let s = JSON.Encode.string
+
+// A view table for a `@subId` slice is a composite-key table: HASH `id`
+// (primary id attribute injected by the QueryDb runtime) + RANGE `productId`
+// (the slice's `subIdField`, carried as a plain attribute of each state row).
+let createViewTable = async (tableName): Util_DynamoDb_Runtime.resolvedTable => {
+  let attrDef = name =>
+    Dict.fromArray([("AttributeName", s(name)), ("AttributeType", s("S"))])->JSON.Encode.object
+  let keyEl = (name, keyType) =>
+    Dict.fromArray([("AttributeName", s(name)), ("KeyType", s(keyType))])->JSON.Encode.object
+  let input =
+    Dict.fromArray([
+      ("TableName", s(tableName)),
+      ("AttributeDefinitions", [attrDef("id"), attrDef("productId")]->JSON.Encode.array),
+      ("KeySchema", [keyEl("id", "HASH"), keyEl("productId", "RANGE")]->JSON.Encode.array),
+      ("BillingMode", s("PAY_PER_REQUEST")),
+    ])->JSON.Encode.object
+  let _ = await H.send(H.createTableCommand(input))
+  {
+    Util_DynamoDb_Runtime.id: tableName,
+    name: tableName,
+    arn: `arn:aws:dynamodb:local:000000000000:table/${tableName}`,
+    hashKey: "id",
+  }
+}
+
+// Drives the real entry point: builds the handler via its exported
+// `buildJsonEventsHandler` factory (DynamoDB path — `pgConnection`/`stateTopicName`
+// undefined), feeds one encoded event through the effect Stream, and runs the
+// resulting Effect through the request context the production handler supplies.
+let runOneEvent: (string, JSON.t) => promise<unit> = %raw(`
+  async (tableName, eventJson) => {
+    const { buildJsonEventsHandler } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint.mjs"
+    );
+    const specModule = await import("./SvsTestSlice.res.mjs");
+    const projectionModule = await import("./SvsTestSlice_Projection.res.mjs");
+    const Effect = await import("effect/Effect");
+    const Stream = await import("effect/Stream");
+    const { tag: requestContextTag } = await import(
+      "@reventlessdev/reventless-core/src/RequestContext.res.mjs"
+    );
+
+    const handler = buildJsonEventsHandler(specModule, projectionModule, tableName, undefined, undefined);
+    const stream = Stream.fromIterable([eventJson]);
+    const effect = handler(stream)
+      .pipe(Effect.provideService(requestContextTag, { correlationId: "svs-test" }));
+    await Effect.runPromise(effect);
+  }
+`)
+
+// Encode the consumed event exactly as the runtime decodes it: the entry point
+// calls `parseJsonOrThrow(eventJson, consumedEventSchema)`, so we produce the
+// JSON via the same schema to guarantee a faithful round-trip.
+let encodeEvent = (event): JSON.t =>
+  event->S.reverseConvertToJsonOrThrow(SvsTestSlice.consumedEventSchema)
+
+describe("StateViewSliceEntryPoint integration", () => {
+  testAsync(
+    "UpdateMultiState on an @subId view slice persists a row per product (was silent no-op)",
+    async () => {
+      let table = await createViewTable("SvsIt_" ++ Date.now()->Float.toString)
+
+      // Two products added to the same cart → two distinct sub-id rows under the
+      // same primary id. The second append also reads back the first row, so a
+      // dropped `subIdConfig` (the bug) leaves the table empty at both steps.
+      await runOneEvent(
+        table.name,
+        encodeEvent(ItemAddedToCart({cartId: "cart-1", productId: "prod-a", qty: 2})),
+      )
+      await runOneEvent(
+        table.name,
+        encodeEvent(ItemAddedToCart({cartId: "cart-1", productId: "prod-b", qty: 5})),
+      )
+
+      let rows = switch await QueryDbStorage_DynamoDb_Runtime.load(table)("cart-1") {
+      | Ok(rows) => rows
+      | Error(_) => []
+      }
+
+      // Before the fix: 0 rows (both UpdateMultiState actions no-op with
+      // `MissingSubIdConfig`). After the fix: one row per product.
+      expect(rows->Array.length)->toBe(2)
+
+      let productIds =
+        rows
+        ->Array.filterMap(row =>
+          row
+          ->JSON.Decode.object
+          ->Option.flatMap(o => o->Dict.get("productId"))
+          ->Option.flatMap(JSON.Decode.string)
+        )
+        ->Array.toSorted(String.compare)
+      expect(productIds)->toEqual(["prod-a", "prod-b"])
+
+      await H.deleteTable(table)
+    },
+  )
+})

package/tests/integration/StateViewSliceEntryPoint_IntegrationTest.res.mjs

@@ -0,0 +1,131 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as ClientDynamodb from "@aws-sdk/client-dynamodb";
+import * as SvsTestSlice$ReventlessAws from "./SvsTestSlice.res.mjs";
+import * as DcbIntegrationHarness$ReventlessAws from "./DcbIntegrationHarness.res.mjs";
+import * as QueryDbStorage_DynamoDb_Runtime$ReventlessAws from "../../src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
+
+function s(prim) {
+  return prim;
+}
+
+async function createViewTable(tableName) {
+  let attrDef = name => Object.fromEntries([
+    [
+      "AttributeName",
+      name
+    ],
+    [
+      "AttributeType",
+      "S"
+    ]
+  ]);
+  let keyEl = (name, keyType) => Object.fromEntries([
+    [
+      "AttributeName",
+      name
+    ],
+    [
+      "KeyType",
+      keyType
+    ]
+  ]);
+  let input = Object.fromEntries([
+    [
+      "TableName",
+      tableName
+    ],
+    [
+      "AttributeDefinitions",
+      [
+        attrDef("id"),
+        attrDef("productId")
+      ]
+    ],
+    [
+      "KeySchema",
+      [
+        keyEl("id", "HASH"),
+        keyEl("productId", "RANGE")
+      ]
+    ],
+    [
+      "BillingMode",
+      "PAY_PER_REQUEST"
+    ]
+  ]);
+  await DcbIntegrationHarness$ReventlessAws.send(new ClientDynamodb.CreateTableCommand(input));
+  return {
+    id: tableName,
+    name: tableName,
+    arn: `arn:aws:dynamodb:local:000000000000:table/` + tableName,
+    hashKey: "id"
+  };
+}
+
+let runOneEvent = (async (tableName, eventJson) => {
+    const { buildJsonEventsHandler } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint.mjs"
+    );
+    const specModule = await import("./SvsTestSlice.res.mjs");
+    const projectionModule = await import("./SvsTestSlice_Projection.res.mjs");
+    const Effect = await import("effect/Effect");
+    const Stream = await import("effect/Stream");
+    const { tag: requestContextTag } = await import(
+      "@reventlessdev/reventless-core/src/RequestContext.res.mjs"
+    );
+
+    const handler = buildJsonEventsHandler(specModule, projectionModule, tableName, undefined, undefined);
+    const stream = Stream.fromIterable([eventJson]);
+    const effect = handler(stream)
+      .pipe(Effect.provideService(requestContextTag, { correlationId: "svs-test" }));
+    await Effect.runPromise(effect);
+  });
+
+function encodeEvent(event) {
+  return S.reverseConvertToJsonOrThrow(event, SvsTestSlice$ReventlessAws.consumedEventSchema);
+}
+
+globalThis.describe("StateViewSliceEntryPoint integration", () => {
+  globalThis.test("UpdateMultiState on an @subId view slice persists a row per product (was silent no-op)", async () => {
+    let table = await createViewTable("SvsIt_" + Date.now().toString());
+    await runOneEvent(table.name, S.reverseConvertToJsonOrThrow({
+      TAG: "ItemAddedToCart",
+      cartId: "cart-1",
+      productId: "prod-a",
+      qty: 2
+    }, SvsTestSlice$ReventlessAws.consumedEventSchema));
+    await runOneEvent(table.name, S.reverseConvertToJsonOrThrow({
+      TAG: "ItemAddedToCart",
+      cartId: "cart-1",
+      productId: "prod-b",
+      qty: 5
+    }, SvsTestSlice$ReventlessAws.consumedEventSchema));
+    let rows = await QueryDbStorage_DynamoDb_Runtime$ReventlessAws.load(table)("cart-1");
+    let rows$1;
+    rows$1 = rows.TAG === "Ok" ? rows._0 : [];
+    globalThis.expect(rows$1.length).toBe(2);
+    let productIds = Stdlib_Array.filterMap(rows$1, row => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(row), o => o["productId"]), Stdlib_JSON.Decode.string)).toSorted(Primitive_string.compare);
+    globalThis.expect(productIds).toEqual([
+      "prod-a",
+      "prod-b"
+    ]);
+    return await DcbIntegrationHarness$ReventlessAws.deleteTable(table);
+  });
+});
+
+let H;
+
+export {
+  H,
+  s,
+  createViewTable,
+  runOneEvent,
+  encodeEvent,
+}
+/* runOneEvent Not a pure module */

package/tests/integration/SvsTestSlice.res

@@ -0,0 +1,32 @@
+// Tiny StateViewSlice spec exercised by
+// `StateViewSliceEntryPoint_IntegrationTest`. Standalone schema — does not
+// depend on the example apps — so the fixture's shape can drift independently
+// of any shipped slice.
+//
+// Hand-written explicit form rather than the `@@reventless.spec` PPX shorthand:
+// the reventless-ppx is only wired into reventless-core's rescript.json, not
+// reventless-aws's. So `consumedEventSchema`, `subIdConfig` etc. are declared
+// directly.
+//
+// The slice models a per-cart, per-product line: primary id = `cartId`,
+// sub-id = `productId`. Its projection uses `UpdateMultiState`, the action that
+// hits the runtime's `subIdConfig` guard — the exact path the deployed entry
+// point used to no-op by hardcoding `subIdConfig = undefined`.
+
+@schema
+type consumedEvent = ItemAddedToCart({cartId: string, productId: string, qty: int})
+
+@schema
+type state = {
+  cartId: string,
+  productId: string,
+  qty: int,
+}
+
+// `Some({subIdField, getSubId})` — the compiled per-slice spec that a real
+// `@subId productId` view slice carries. `subIdField` is the DynamoDB range-key
+// attribute; `getSubId` extracts it from a projected state row.
+let subIdConfig: option<Reventless.ReadModel.subIdConfig<state>> = Some({
+  subIdField: "productId",
+  getSubId: state => state.productId,
+})

package/tests/integration/SvsTestSlice.res.mjs

@@ -0,0 +1,28 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+let consumedEventSchema = S.schema(s => ({
+  TAG: "ItemAddedToCart",
+  cartId: s.m(S.string),
+  productId: s.m(S.string),
+  qty: s.m(S.int)
+}));
+
+let stateSchema = S.schema(s => ({
+  cartId: s.m(S.string),
+  productId: s.m(S.string),
+  qty: s.m(S.int)
+}));
+
+let subIdConfig = {
+  subIdField: "productId",
+  getSubId: state => state.productId
+};
+
+export {
+  consumedEventSchema,
+  stateSchema,
+  subIdConfig,
+}
+/* consumedEventSchema Not a pure module */

package/tests/integration/SvsTestSlice_Projection.res

@@ -0,0 +1,24 @@
+// Projection for `SvsTestSlice`. Hand-written `open` (no `@@reventless.projection`
+// PPX in reventless-aws): `open Reventless.Projection` brings the action
+// constructors (`UpdateMultiState`, …) into scope; `open SvsTestSlice` brings the
+// consumed-event/state types.
+//
+// Every event upserts the cart's line for one product via `UpdateMultiState`,
+// keyed by `productId` (the sub-id). This is the multi-state path that silently
+// no-oped in the deployed runtime before `subIdConfig` was threaded.
+
+open Reventless.Projection
+open SvsTestSlice
+
+let project = event =>
+  switch event {
+  | ItemAddedToCart({cartId, productId, qty}) => [
+      UpdateMultiState(
+        cartId,
+        states => {
+          let others = states->Array.filter(s => s.productId != productId)
+          others->Array.concat([{cartId, productId, qty}])
+        },
+      ),
+    ]
+  }

package/tests/integration/SvsTestSlice_Projection.res.mjs

@@ -0,0 +1,25 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function project(event) {
+  let qty = event.qty;
+  let productId = event.productId;
+  let cartId = event.cartId;
+  return [{
+      TAG: "UpdateMultiState",
+      _0: cartId,
+      _1: states => {
+        let others = states.filter(s => s.productId !== productId);
+        return others.concat([{
+            cartId: cartId,
+            productId: productId,
+            qty: qty
+          }]);
+      }
+    }];
+}
+
+export {
+  project,
+}
+/* No side effect */