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

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.
 
+# 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.186",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -9,16 +9,16 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@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/rescript-effect": "0.1.0-alpha.25",
     "@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-core": "3.0.0-alpha.147",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.91",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.10",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.69"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.69",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.11"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

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/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";