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

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.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
+
+* **reventless-aws:** thread partitionTag into deployed DCB command Lambda append ([68f0859](https://github.com/ReventlessDev/reventless-core/commit/68f0859d3d5e44f6217a5dc0d8537cfec3d21194))
+
+
 # 3.0.0-alpha.184 (2026-07-08)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.184",
+  "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.145",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.90",
+    "@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.9",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.68"
+    "@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/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs

@@ -12,6 +12,7 @@ import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/Req
 import {
   extractVariantNames,
   deriveEffectiveScope,
+  derivePartitionTag,
 } from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import { $$String as IdString } from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import { Make as dcbEventLogOperationsMake } from "@reventlessdev/reventless-core/src/components/DcbEventLog/DcbEventLog_Operations.res.mjs";
@@ -89,6 +90,61 @@ function getIdStringSchema() {
 // can drive the real `cmdGenHandler` end-to-end against DynamoDB Local.
 export async function buildHandlersForConfig(config, opts = {}) {
   const loadModule = opts.loadModule ?? dynamicImport;
+
+  // Load all spec/behavior pairs first. Both the decision-query scope
+  // (crossPartitionTagKeys / tagKeysByEventType) AND the storage `partitionTag`
+  // are derived from the produced event schemas, and the DynamoDB storage ops
+  // below must be built with them — so slices load before anything else.
+  const loadedSlices = await Promise.all(
+    config.stateChangeSliceModules.map(async ({ spec, behavior }) => {
+      const specModule = await loadModule(spec);
+      const behaviorModule = await loadModule(behavior);
+      const patchedSpec = patchSpecId(specModule);
+      return { patchedSpec, behaviorModule };
+    })
+  );
+
+  // Single source of truth with Dcb_Builder.res: prefer slice-graph inference
+  // (which classifies cross-partition `@ref` reference reads), falling back to
+  // annotations only on ambiguity. Re-deriving from annotations alone here
+  // silently dropped inferred cross-partition reads, so every reference-guarded
+  // command was rejected on the deployed path — see
+  // docs/analysis/dcb-runtime-scope-annotation-drift.md.
+  const { crossPartitionTagKeys, tagKeysByEventType } = deriveEffectiveScope(
+    loadedSlices.map(({ patchedSpec }) => ({
+      name: patchedSpec.name,
+      commandSchema: patchedSpec.commandSchema,
+      consumedEventSchema: patchedSpec.consumedEventSchema,
+      eventSchema: patchedSpec.eventSchema,
+    }))
+  );
+
+  // Derive the storage partition tag the SAME way Dcb_Builder.res does at
+  // deploy time (over the produced event schemas). This MUST reach the DynamoDB
+  // `append` — without it `partitionTag` defaults to `None`, the composite-fence
+  // collapse (gated on `Composite`) never fires, and a `@compositePartitionTag`
+  // slice writes one fence PER MEMBER instead of one synthetic composite fence.
+  // A deploy-time fan-out sharing low-cardinality members (environment, plugin,
+  // …) then turns those member fences hot → TransactionConflict → retries
+  // exhausted. The deploy-time adapter (DcbEventLogStorage_DynamoDb.make) already
+  // threads it; the deployed Lambda dropped it. See
+  // docs/plans/dcb-composite-fence-residual-burst-contention.md.
+  // `derivePartitionTag` throws only on a misconfigured spec, which the deploy
+  // would already have rejected; guard defensively so a runtime edge case
+  // degrades to the (old) untagged behaviour rather than crashing cold start.
+  let partitionTag = undefined;
+  try {
+    partitionTag = derivePartitionTag(
+      loadedSlices.map(({ patchedSpec }) => [
+        patchedSpec.name,
+        patchedSpec.moduleUrl ?? patchedSpec.name,
+        patchedSpec.eventSchema,
+      ])
+    );
+  } catch (err) {
+    log.warn("could not derive partitionTag; falling back to untagged fences: " + (err && err.message), { comp: "DcbCommandTopicRuntime" });
+  }
+
   // `pgConnection`, when present in HANDLER_CONFIG, selects the Postgres DCB
   // runtime (dcbEventLogTableName doubles as the `dcb_event.log_name`); absence
   // keeps the DynamoDB path byte-identical. NB: this swaps only the *storage*
@@ -108,10 +164,18 @@ export async function buildHandlersForConfig(config, opts = {}) {
       })()
     : (() => {
         const resolvedTable = { name: config.dcbEventLogTableName };
+        // Positional args match the ReScript-compiled signatures:
+        //   read(table, crossPartitionTagKeys)
+        //   append(table, partitionTag, crossPartitionTagKeys)
+        //   readStream(table, crossPartitionTagKeys)
+        // Threading partitionTag activates the composite-fence collapse; threading
+        // crossPartitionTagKeys routes single-tag `@crossPartition` reads to the
+        // per-tag GSI and bumps their fences on every carrier — matching the
+        // deploy-time adapter's storage ops exactly.
         return {
-          read: read(resolvedTable),
-          append: append(resolvedTable),
-          readStream: readStream(resolvedTable),
+          read: read(resolvedTable, crossPartitionTagKeys),
+          append: append(resolvedTable, partitionTag, crossPartitionTagKeys),
+          readStream: readStream(resolvedTable, crossPartitionTagKeys),
         };
       })();
 
@@ -126,34 +190,6 @@ export async function buildHandlersForConfig(config, opts = {}) {
     publishJson: async (_name, _meta, _json) => {},
   });
 
-  // Load all spec/behavior pairs first, then derive the per-plugin
-  // tagKeysByEventType / crossPartitionTagKeys across the produced event
-  // schemas — mirroring Dcb_Builder.res's build-time derivation — so the
-  // runtime slice callback receives the same values it would in-process.
-  const loadedSlices = await Promise.all(
-    config.stateChangeSliceModules.map(async ({ spec, behavior }) => {
-      const specModule = await loadModule(spec);
-      const behaviorModule = await loadModule(behavior);
-      const patchedSpec = patchSpecId(specModule);
-      return { patchedSpec, behaviorModule };
-    })
-  );
-
-  // Single source of truth with Dcb_Builder.res: prefer slice-graph inference
-  // (which classifies cross-partition `@ref` reference reads), falling back to
-  // annotations only on ambiguity. Re-deriving from annotations alone here
-  // silently dropped inferred cross-partition reads, so every reference-guarded
-  // command was rejected on the deployed path — see
-  // docs/analysis/dcb-runtime-scope-annotation-drift.md.
-  const { crossPartitionTagKeys, tagKeysByEventType } = deriveEffectiveScope(
-    loadedSlices.map(({ patchedSpec }) => ({
-      name: patchedSpec.name,
-      commandSchema: patchedSpec.commandSchema,
-      consumedEventSchema: patchedSpec.consumedEventSchema,
-      eventSchema: patchedSpec.eventSchema,
-    }))
-  );
-
   loadedSlices.forEach(({ patchedSpec, behaviorModule }) => {
     const sliceCallback = stateChangeSliceCallbackMake(patchedSpec)(behaviorModule);
     const commandSchema = patchedSpec.commandSchema;

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

@@ -59,6 +59,67 @@ let runOneAppSyncEvent: (string, JSON.t) => promise<JSON.t> = %raw(`
   }
 `)
 
+// Same as `runOneAppSyncEvent` but wires the composite-partition fixture
+// (EpCompositeSlice) through the real entry point. Proves the deployed path
+// derives and threads `partitionTag = Composite(...)` into the DynamoDB
+// `append` — the fix for the residual burst-contention bug.
+let runOneCompositeEvent: (string, JSON.t) => promise<JSON.t> = %raw(`
+  async (tableName, event) => {
+    const { buildHandlersForConfig } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs"
+    );
+    const Effect = await import("effect/Effect");
+    const { tag: requestContextTag } = await import(
+      "@reventlessdev/reventless-core/src/RequestContext.res.mjs"
+    );
+    const { commandOutcomeToJson } = await import(
+      "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs"
+    );
+
+    const loadModule = async (specifier) => {
+      if (specifier === "ep-composite://spec") return await import("./EpCompositeSlice.res.mjs");
+      if (specifier === "ep-composite://behavior") return await import("./EpCompositeSliceBehavior.res.mjs");
+      throw new Error("unknown test specifier: " + specifier);
+    };
+
+    const config = {
+      pluginName: "EpCompositePlugin",
+      dcbEventLogTableName: tableName,
+      stateChangeSliceModules: [{ spec: "ep-composite://spec", behavior: "ep-composite://behavior" }],
+      queueUrl: "https://sqs.eu-west-1.amazonaws.com/000000000000/ep-composite-queue",
+    };
+
+    const [, cmdGenHandler] = await buildHandlersForConfig(config, { loadModule });
+
+    const effect = cmdGenHandler(event)
+      .pipe(Effect.provideService(requestContextTag, { correlationId: "ep-composite" }));
+    const outcome = await Effect.runPromise(effect);
+    return commandOutcomeToJson(outcome);
+  }
+`)
+
+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.
+  let arguments = Dict.fromArray([
+    ("environment", environment->JSON.Encode.string),
+    ("resourceName", resourceName->JSON.Encode.string),
+  ])
+  let meta = Dict.fromArray([
+    ("user", "ep-composite"->JSON.Encode.string),
+    ("ip", JSON.Encode.null),
+  ])
+  Dict.fromArray([
+    ("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
@@ -98,4 +159,101 @@ describe("DcbCommandTopicEntryPoint integration", () => {
       expect(s->String.includes("CommandAccepted"))->toBe(true)
     },
   )
+
+  // Residual composite-fence burst contention
+  // (docs/plans/dcb-composite-fence-residual-burst-contention.md).
+  //
+  // The entry point must derive `partitionTag = Composite(...)` and thread it
+  // into the DynamoDB `append`, so a `@compositePartitionTag` slice collapses to
+  // ONE synthetic composite fence per entity. Without the thread (the bug),
+  // `partitionTag` defaults to None, the collapse never fires, and each append
+  // fences on its individual members — the shared low-cardinality `environment`
+  // member then serialises/rejects distinct resources.
+  testAsync(
+    "composite-partition burst: distinct resources sharing a prefix all commit, only composite fences written",
+    async () => {
+      let table = await H.createDcbTableWithTagKeys(
+        "EpComposite_" ++ Date.now()->Float.toString,
+        ["environment", "resourceName"],
+      )
+      let env = "prod"
+      let resourceNames = ["res-a", "res-b", "res-c", "res-d", "res-e"]
+
+      // Concurrent burst — simulates the deploy-sync fan-out that surfaced the
+      // `retries exhausted` cascade on alpha.
+      let outcomes =
+        await resourceNames
+        ->Array.map(resourceName =>
+          runOneCompositeEvent(table.name, buildAddResourceEvent(~environment=env, ~resourceName))
+        )
+        ->Promise.all
+
+      // Every distinct composite entity must commit — none may conflict on the
+      // shared `environment` prefix.
+      outcomes->Array.forEach(outcomeJson => {
+        let s = outcomeJson->JSON.stringifyAny->Option.getOr("<unserializable>")
+        expect(s->String.includes("CommandAccepted"))->toBe(true)
+      })
+
+      // Mechanism-level proof: the only fence rows are the synthetic composite
+      // fences (`fence#__dcb_composite__:…`) — one per entity — with NO
+      // per-member `fence#environment:…` / `fence#resourceName:…` rows.
+      let fenceIds = await H.scanFenceIds(table)
+      let compositeFencePrefix = "fence#" ++ DcbEventLogStorage_DynamoDb_Runtime.compositeFenceTagKey
+      expect(fenceIds->Array.length)->toBe(resourceNames->Array.length)
+      fenceIds->Array.forEach(id => expect(id->String.startsWith(compositeFencePrefix))->toBe(true))
+
+      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,7 +1,9 @@
 // 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";
 
 let runOneAppSyncEvent = (async (tableName, event) => {
     const { buildHandlersForConfig } = await import(
@@ -36,6 +38,80 @@ let runOneAppSyncEvent = (async (tableName, event) => {
     return commandOutcomeToJson(outcome);
   });
 
+let runOneCompositeEvent = (async (tableName, event) => {
+    const { buildHandlersForConfig } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs"
+    );
+    const Effect = await import("effect/Effect");
+    const { tag: requestContextTag } = await import(
+      "@reventlessdev/reventless-core/src/RequestContext.res.mjs"
+    );
+    const { commandOutcomeToJson } = await import(
+      "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs"
+    );
+
+    const loadModule = async (specifier) => {
+      if (specifier === "ep-composite://spec") return await import("./EpCompositeSlice.res.mjs");
+      if (specifier === "ep-composite://behavior") return await import("./EpCompositeSliceBehavior.res.mjs");
+      throw new Error("unknown test specifier: " + specifier);
+    };
+
+    const config = {
+      pluginName: "EpCompositePlugin",
+      dcbEventLogTableName: tableName,
+      stateChangeSliceModules: [{ spec: "ep-composite://spec", behavior: "ep-composite://behavior" }],
+      queueUrl: "https://sqs.eu-west-1.amazonaws.com/000000000000/ep-composite-queue",
+    };
+
+    const [, cmdGenHandler] = await buildHandlersForConfig(config, { loadModule });
+
+    const effect = cmdGenHandler(event)
+      .pipe(Effect.provideService(requestContextTag, { correlationId: "ep-composite" }));
+    const outcome = await Effect.runPromise(effect);
+    return commandOutcomeToJson(outcome);
+  });
+
+function buildCompositeCommandEvent(command, environment, resourceName) {
+  let $$arguments = Object.fromEntries([
+    [
+      "environment",
+      environment
+    ],
+    [
+      "resourceName",
+      resourceName
+    ]
+  ]);
+  let meta = Object.fromEntries([
+    [
+      "user",
+      "ep-composite"
+    ],
+    [
+      "ip",
+      null
+    ]
+  ]);
+  return Object.fromEntries([
+    [
+      "command",
+      command
+    ],
+    [
+      "arguments",
+      $$arguments
+    ],
+    [
+      "meta",
+      meta
+    ]
+  ]);
+}
+
+function buildAddResourceEvent(environment, resourceName) {
+  return buildCompositeCommandEvent("AddResource", environment, resourceName);
+}
+
 function buildAppSyncEvent(widgetId) {
   let command = Object.fromEntries([[
       "AddWidget",
@@ -79,6 +155,49 @@ globalThis.describe("DcbCommandTopicEntryPoint integration", () => {
     let s = Stdlib_Option.getOr(JSON.stringify(outcomeJson), "<unserializable>");
     globalThis.expect(s.includes("CommandAccepted")).toBe(true);
   });
+  globalThis.test("composite-partition burst: distinct resources sharing a prefix all commit, only composite fences written", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.createDcbTableWithTagKeys("EpComposite_" + Date.now().toString(), [
+      "environment",
+      "resourceName"
+    ]);
+    let resourceNames = [
+      "res-a",
+      "res-b",
+      "res-c",
+      "res-d",
+      "res-e"
+    ];
+    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);
+    });
+    let fenceIds = await DcbIntegrationHarness$ReventlessAws.scanFenceIds(table);
+    let compositeFencePrefix = "fence#" + DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.compositeFenceTagKey;
+    globalThis.expect(fenceIds.length).toBe(resourceNames.length);
+    fenceIds.forEach(id => {
+      globalThis.expect(id.startsWith(compositeFencePrefix)).toBe(true);
+    });
+    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;
@@ -86,6 +205,9 @@ let H;
 export {
   H,
   runOneAppSyncEvent,
+  runOneCompositeEvent,
+  buildCompositeCommandEvent,
+  buildAddResourceEvent,
   buildAppSyncEvent,
 }
 /* runOneAppSyncEvent Not a pure module */

package/tests/integration/DcbIntegrationHarness.res

@@ -73,6 +73,69 @@ let createDcbTable = async (tableName): Util_DynamoDb_Runtime.resolvedTable => {
   }
 }
 
+// Like `createDcbTable` but with a caller-supplied set of `tag_<key>` GSI names
+// plus `tag_composite`. Used by the composite-partition scenarios whose member
+// keys (e.g. `environment`, `resourceName`) are not in the default online-shop
+// `gsiNames` superset.
+let createDcbTableWithTagKeys = async (
+  tableName,
+  tagKeys: array<string>,
+): Util_DynamoDb_Runtime.resolvedTable => {
+  let indexNames =
+    tagKeys->Array.map(k => `tag_${k}`)->Array.concat(["tag_composite"])
+  let attributeDefinitions = Array.concat(
+    [attrDef("id"), attrDef("position")],
+    indexNames->Array.map(attrDef),
+  )
+  let input =
+    Dict.fromArray([
+      ("TableName", s(tableName)),
+      ("AttributeDefinitions", attributeDefinitions->JSON.Encode.array),
+      ("KeySchema", [keyEl("id", "HASH"), keyEl("position", "RANGE")]->JSON.Encode.array),
+      ("GlobalSecondaryIndexes", indexNames->Array.map(gsi)->JSON.Encode.array),
+      ("BillingMode", s("PAY_PER_REQUEST")),
+    ])->JSON.Encode.object
+  let _ = await send(createTableCommand(input))
+  {
+    Util_DynamoDb_Runtime.id: tableName,
+    name: tableName,
+    arn: `arn:aws:dynamodb:local:000000000000:table/${tableName}`,
+    hashKey: "id",
+  }
+}
+
+// Returns the `id`s of every fence sentinel row in the table (`id` begins with
+// `fence#`). Lets a test assert the fence *shape* directly — the mechanism-level
+// signal that the composite collapse fired (one `fence#__dcb_composite__:…` per
+// entity) rather than per-member `fence#<member>:…` rows.
+let scanFenceIds = 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("id"))
+    ->Option.flatMap(JSON.Decode.string)
+    ->Option.flatMap(id => id->String.startsWith("fence#") ? Some(id) : None)
+  )
+}
+
+// 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

@@ -1,5 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.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 Effect from "effect/Effect";
 import * as ClientDynamodb from "@aws-sdk/client-dynamodb";
 import * as DynamoDb_DynamoDb$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DynamoDb.res.mjs";
 import * as Util_DynamoDb_Runtime$ReventlessAws from "../../src/util/Util_DynamoDb_Runtime.res.mjs";
@@ -111,6 +116,65 @@ async function createDcbTable(tableName) {
   };
 }
 
+async function createDcbTableWithTagKeys(tableName, tagKeys) {
+  let indexNames = tagKeys.map(k => `tag_` + k).concat(["tag_composite"]);
+  let attributeDefinitions = [
+    attrDef("id"),
+    attrDef("position")
+  ].concat(indexNames.map(attrDef));
+  let input = Object.fromEntries([
+    [
+      "TableName",
+      tableName
+    ],
+    [
+      "AttributeDefinitions",
+      attributeDefinitions
+    ],
+    [
+      "KeySchema",
+      [
+        keyEl("id", "HASH"),
+        keyEl("position", "RANGE")
+      ]
+    ],
+    [
+      "GlobalSecondaryIndexes",
+      indexNames.map(gsi)
+    ],
+    [
+      "BillingMode",
+      "PAY_PER_REQUEST"
+    ]
+  ]);
+  let cmd = new ClientDynamodb.CreateTableCommand(input);
+  await DynamoDb_DynamoDb$AwsSdk.client().send(cmd);
+  return {
+    id: tableName,
+    name: tableName,
+    arn: `arn:aws:dynamodb:local:000000000000:table/` + tableName,
+    hashKey: "id"
+  };
+}
+
+async function scanFenceIds(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_Option.flatMap(Stdlib_JSON.Decode.object(item), obj => obj["id"]), Stdlib_JSON.Decode.string), id => {
+    if (id.startsWith("fence#")) {
+      return id;
+    }
+  }));
+}
+
+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",
@@ -154,9 +218,12 @@ export {
   gsi,
   gsiNames,
   createDcbTable,
+  createDcbTableWithTagKeys,
+  scanFenceIds,
+  scanEventTypes,
   deleteTable,
   counter,
   freshTable,
   setFence,
 }
-/* @aws-sdk/client-dynamodb Not a pure module */
+/* Stream Not a pure module */

package/tests/integration/EpCompositeSlice.res

@@ -0,0 +1,61 @@
+// Composite-partition slice fixture for `DcbCommandTopicEntryPoint_IntegrationTest`.
+//
+// Reproduces the deploy-sync workload shape from
+// 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
+// `partitionTag = Composite(...)` into the DynamoDB `append`, activating the
+// 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})
+  | 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,
+    })
+  | 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
+  | 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,
+    })
+  | 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"
+let commandAuthorization = (_: command): Reventless.Authorization.permission => AllowAnonymous
+let readConsistency = Reventless.ReadConsistency.EscalateOnRetry
+
+// `module Id = Reventless.Id.String` — patched in by `patchSpecId` at runtime.

package/tests/integration/EpCompositeSlice.res.mjs

@@ -0,0 +1,70 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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.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";
+}
+
+let name = "EpCompositeSlice";
+
+let moduleUrl = "ep-test://EpCompositeSlice";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  consumedEventSchema,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+  name,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* consumedEventSchema Not a pure module */

package/tests/integration/EpCompositeSliceBehavior.res

@@ -0,0 +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 `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 =
+  | Absent
+  | Added
+
+let initialState = Absent
+
+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) {
+  | (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

@@ -0,0 +1,52 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function evolve(_state, event) {
+  return "Added";
+}
+
+function decide(state, command) {
+  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"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "ResourceTouched",
+          environment: command.environment,
+          resourceName: command.resourceName
+        }]
+    };
+  }
+}
+
+let initialState = "Absent";
+
+let moduleUrl = "ep-test://EpCompositeSliceBehavior";
+
+export {
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* No side effect */