@reventlessdev/reventless-aws 3.0.0-alpha.181 → 3.0.0-alpha.182

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.182 (2026-07-07)
+
+### Bug Fixes
+
+* **reventless-aws:** fence composite-partition DCB slices on one composite key ([e5f2d95](https://github.com/ReventlessDev/reventless-core/commit/e5f2d95652d795e4dea60e28548f96100a997e78))
+
+
 # 3.0.0-alpha.181 (2026-07-07)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.181",
+  "version": "3.0.0-alpha.182",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -10,15 +10,15 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.20",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.46",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
     "@reventlessdev/reventless-core": "3.0.0-alpha.144",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.90",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.68",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.8",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.90"
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.8"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res

@@ -3,10 +3,33 @@ open AwsSdk.DynamoDb.DocumentClient
 
 // --- Position Generation ---
 
+// Hybrid-logical-clock minimal variant. The module-level refs live for the life of
+// a warm Lambda container (reset on cold start), giving strictly-monotonic positions
+// per call WITHIN a container: same-millisecond calls increment `counter`; a forward
+// tick resets it to 0. No cross-container coordination — two same-ms writers on
+// different containers both start at counter 0 and are ordered by the UUID tiebreaker
+// (best-effort, exactly as the old `<ms>-<uuid>` format was). Format:
+// `<ms>-<6-digit counter>-<uuid>`. Correctness never depends on this — fence
+// comparisons anchor to what a slice observed, and `TransactWriteItems` serialises
+// commits; this only makes reader/replay ordering predictable per container. Old
+// `<ms>-<uuid>` positions remain valid: the ms prefix keeps the same 13-digit width,
+// so cross-format comparison still orders by timestamp. See
+// docs/plans/done/dcb-monotonic-position-generation.md.
+let lastMs = ref(0.0)
+let counter = ref(0)
+
 let generatePosition = () => {
-  let timestamp = Date.make()->Date.getTime->Float.toString
+  let now = Date.make()->Date.getTime
+  if now == lastMs.contents {
+    counter := counter.contents + 1
+  } else {
+    lastMs := now
+    counter := 0
+  }
+  let ms = now->Float.toString
+  let counterStr = counter.contents->Int.toString->String.padStart(6, "0")
   let uuid = Uuid.v4()
-  `${timestamp}-${uuid}`
+  `${ms}-${counterStr}-${uuid}`
 }
 
 let generatePositionForBatch = (basePosition, index) => {
@@ -915,20 +938,39 @@ let appendUnconditional = async (
   }
 }
 
+// A Composite partition fences on the WHOLE composite value, not on each member.
+// The synthetic fence tag is keyed on `getCompositePartitionKeyValue` — the same
+// value `derivePartitionKey` uses for the base-table `id` — so it is exactly as
+// selective as the entity's storage partition (and the `tag_composite` read
+// scope). Fencing per-member (the historical behaviour) gave every low-cardinality
+// member (e.g. `environment`, `platformName`) its own fence, which a deploy-time
+// fan-out sharing those prefixes turns into a hot partition → `TransactionConflict`
+// → `retries exhausted`; it also over-fenced (two DISTINCT composite entities
+// sharing a member value serialized needlessly). Plan:
+// docs/plans/Backlog/dcb-hot-tag-fence-contention.md § "Root-cause correction".
+let compositeFenceTagKey = "__dcb_composite__"
+
+let makeCompositeFenceTag = (
+  tags: array<Reventless.DcbTag.tag>,
+  spec: Reventless.DcbTag.compositePartitionSpec,
+): Reventless.DcbTag.tag => {
+  key: compositeFenceTagKey,
+  value: Reventless.DcbTag.getCompositePartitionKeyValue(tags, spec),
+}
+
 // The partition tag(s) of a written event — the ONLY fences an append may BUMP.
 // A tag's fence must track exactly the partition-scoped events a single-tag read
 // of that tag observes (events are stored under `id="<partitionKey>:<value>"`),
 // so only the partition tag may advance it. Mirrors `derivePartitionKey`.
 //
-// For a Composite partition tag there is no single fence key that represents the
-// partition, so we keep the historical behaviour (treat every tag as a partition
-// tag) rather than risk under-fencing composite-partition slices.
+// A Composite partition collapses to a single synthetic composite fence tag (see
+// `makeCompositeFenceTag`) — one fence per composite entity, not one per member.
 let eventPartitionTags = (
   event: ReventlessCore.DcbEventLog_Adapter.rawStoredEvent,
   ~partitionTag: option<Reventless.DcbTag.derivedPartitionTag>,
 ): array<Reventless.DcbTag.tag> =>
   switch partitionTag {
-  | Some(Composite(_)) => event.tags
+  | Some(Composite(spec)) => [makeCompositeFenceTag(event.tags, spec)]
   | Some(Simple(pt)) =>
     switch event.tags->Array.find(t => t.key == pt.key) {
     | Some(t) => [t]
@@ -994,6 +1036,32 @@ let buildConditionalTransactItems = (
   ~partitionTag: option<Reventless.DcbTag.derivedPartitionTag>=?,
   ~crossPartitionTagKeys: array<string>=[],
 ): array<TransactWriteCommand.transactWriteItem> => {
+  // For a Composite partition, fold the multi-tag composite read clause into a
+  // single synthetic composite fence tag (`makeCompositeFenceTag`) so the rest of
+  // this function fences it exactly like a Simple partition — one fence per
+  // composite entity — instead of once per member (the hot-fence source). Only the
+  // FENCE view of the query is rewritten here; the read path (`readStream`) keeps
+  // the original member tags and its `tag_composite` GSI lookup. Gated on
+  // `Composite`: Simple-partition composite-read slices (e.g. RecordProductDemand's
+  // `{productId, orderId}` pair, where `productId` is a real independent partition)
+  // are left untouched. `@crossPartition` carriers are unaffected — they are
+  // handled by `crossPartitionEventTags` below, not by this composite clause.
+  let cond = switch partitionTag {
+  | Some(Composite(spec)) => {
+      ...cond,
+      query: cond.query->Array.map(qi =>
+        switch qi.tags {
+        | Some(clauseTags) if clauseTags->Array.length > 1 => {
+            ...qi,
+            tags: [makeCompositeFenceTag(clauseTags, spec)],
+          }
+        | _ => qi
+        }
+      ),
+    }
+  | _ => cond
+  }
+
   // The partitions this append writes into — the only fences it may BUMP
   // (partition-scoped tags only; cross-partition tags below override this).
   let partitionTags = collectEventPartitionTags(events, ~partitionTag)

package/src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs

@@ -20,10 +20,26 @@ import * as DynamoDb_Error$ReventlessAws from "../../errors/DynamoDb_Error.res.m
 import * as DynamoDb_DocumentClient$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DocumentClient.res.mjs";
 import * as Util_DynamoDb_Runtime$ReventlessAws from "../../util/Util_DynamoDb_Runtime.res.mjs";
 
+let lastMs = {
+  contents: 0.0
+};
+
+let counter = {
+  contents: 0
+};
+
 function generatePosition() {
-  let timestamp = new Date().getTime().toString();
+  let now = new Date().getTime();
+  if (now === lastMs.contents) {
+    counter.contents = counter.contents + 1 | 0;
+  } else {
+    lastMs.contents = now;
+    counter.contents = 0;
+  }
+  let ms = now.toString();
+  let counterStr = counter.contents.toString().padStart(6, "0");
   let uuid = Uuid.v4();
-  return timestamp + `-` + uuid;
+  return ms + `-` + counterStr + `-` + uuid;
 }
 
 function generatePositionForBatch(basePosition, index) {
@@ -695,10 +711,19 @@ async function appendUnconditional(table, events, partitionTag) {
   return await runTransactWrite(input, basePosition, "DCB append failed");
 }
 
+let compositeFenceTagKey = "__dcb_composite__";
+
+function makeCompositeFenceTag(tags, spec) {
+  return {
+    key: compositeFenceTagKey,
+    value: DcbTag$Reventless.getCompositePartitionKeyValue(tags, spec)
+  };
+}
+
 function eventPartitionTags(event, partitionTag) {
   if (partitionTag !== undefined) {
     if (partitionTag.TAG !== "Simple") {
-      return event.tags;
+      return [makeCompositeFenceTag(event.tags, partitionTag._0)];
     }
     let pt = partitionTag._0;
     let t = event.tags.find(t => t.key === pt.key);
@@ -753,6 +778,26 @@ function partitionTypesByTag(events, partitionTag) {
 
 function buildConditionalTransactItems(table, events, cond, basePosition, partitionTag, crossPartitionTagKeysOpt) {
   let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+  let cond$1;
+  if (partitionTag !== undefined && partitionTag.TAG !== "Simple") {
+    let spec = partitionTag._0;
+    let newrecord = {...cond};
+    newrecord.query = cond.query.map(qi => {
+      let clauseTags = qi.tags;
+      if (clauseTags === undefined) {
+        return qi;
+      }
+      if (clauseTags.length <= 1) {
+        return qi;
+      }
+      let newrecord = {...qi};
+      newrecord.tags = [makeCompositeFenceTag(clauseTags, spec)];
+      return newrecord;
+    });
+    cond$1 = newrecord;
+  } else {
+    cond$1 = cond;
+  }
   let partitionTags = collectEventPartitionTags(events, partitionTag);
   let partitionKeySet = new Set();
   partitionTags.forEach(t => {
@@ -770,7 +815,7 @@ function buildConditionalTransactItems(table, events, cond, basePosition, partit
       )[k], []);
   };
   let consumedMap = {};
-  cond.query.forEach(qi => {
+  cond$1.query.forEach(qi => {
     let match = qi.tags;
     let match$1 = qi.eventTypes;
     if (match !== undefined && match$1 !== undefined) {
@@ -785,7 +830,7 @@ function buildConditionalTransactItems(table, events, cond, basePosition, partit
   let consumedTypesFor = t => Stdlib_Option.getOr(consumedMap[t.key + `:` + t.value], []);
   let compositeKeySet = new Set();
   let compositeQueryTags = [];
-  cond.query.forEach(qi => {
+  cond$1.query.forEach(qi => {
     let tags = qi.tags;
     if (tags !== undefined && tags.length > 1) {
       tags.forEach(tag => {
@@ -812,7 +857,7 @@ function buildConditionalTransactItems(table, events, cond, basePosition, partit
       return;
     }
   };
-  cond.query.forEach(qi => {
+  cond$1.query.forEach(qi => {
     let tags = qi.tags;
     if (tags === undefined) {
       return;
@@ -821,7 +866,7 @@ function buildConditionalTransactItems(table, events, cond, basePosition, partit
       if (tags.length <= 1) {
         return;
       }
-      let match = cond.after;
+      let match = cond$1.after;
       if (match !== undefined) {
         tags.forEach(pushUpdate);
         return;
@@ -833,7 +878,7 @@ function buildConditionalTransactItems(table, events, cond, basePosition, partit
     if (crossPartitionTagKeys.includes(tag.key)) {
       return pushUpdate(tag);
     }
-    let match$1 = cond.after;
+    let match$1 = cond$1.after;
     if (match$1 !== undefined) {
       if (isPartition(tag) || isCompositeQueryTag(tag)) {
         return pushUpdate(tag);
@@ -853,7 +898,7 @@ function buildConditionalTransactItems(table, events, cond, basePosition, partit
       return;
     }
   });
-  let match = cond.after;
+  let match = cond$1.after;
   if (match !== undefined) {
     
   } else {
@@ -864,7 +909,7 @@ function buildConditionalTransactItems(table, events, cond, basePosition, partit
     bumpSeen.add(t.key + `:` + t.value);
   });
   let bumpTags = [];
-  let match$1 = cond.after;
+  let match$1 = cond$1.after;
   let candidateBumps = match$1 !== undefined ? partitionTags.concat(crossPartitionEventTags) : partitionTags.concat(compositeQueryTags.concat(crossPartitionEventTags));
   candidateBumps.forEach(tag => {
     let k = tag.key + `:` + tag.value;
@@ -881,7 +926,7 @@ function buildConditionalTransactItems(table, events, cond, basePosition, partit
       return;
     } else {
       return {
-        Update: buildConditionalFenceUpdate(table.name, tag, consumedTypesFor(tag), producedTypes, basePosition, cond.after)
+        Update: buildConditionalFenceUpdate(table.name, tag, consumedTypesFor(tag), producedTypes, basePosition, cond$1.after)
       };
     }
   });
@@ -891,7 +936,7 @@ function buildConditionalTransactItems(table, events, cond, basePosition, partit
       return;
     } else {
       return {
-        ConditionCheck: buildFenceConditionCheck(table.name, tag, consumedTypes, cond.after)
+        ConditionCheck: buildFenceConditionCheck(table.name, tag, consumedTypes, cond$1.after)
       };
     }
   });
@@ -1102,6 +1147,8 @@ function readStream(table, $staropt$star) {
 let transactWriteItemsLimit = 100;
 
 export {
+  lastMs,
+  counter,
   generatePosition,
   generatePositionForBatch,
   tagToAttributeName,
@@ -1140,6 +1187,8 @@ export {
   buildEventPuts,
   runTransactWrite,
   appendUnconditional,
+  compositeFenceTagKey,
+  makeCompositeFenceTag,
   eventPartitionTags,
   collectEventPartitionTags,
   partitionTypesByTag,

package/tests/DcbEventLogStorage_DynamoDb_RuntimeTest.res

@@ -435,6 +435,97 @@ describe("Runtime.buildConditionalTransactItems — fence-scope = read-scope", (
   })
 })
 
+describe("Runtime.buildConditionalTransactItems — composite partition fences on ONE composite key", () => {
+  // SyncResource-style: @compositePartitionTag over {environment, platformName,
+  // pluginName}. The read is one exact `tag_composite` match, so the fence must be
+  // a SINGLE composite-key fence — not one per member. Per-member fencing made the
+  // low-cardinality prefix (`environment`, `platformName`) hot under a deploy
+  // fan-out. Plan: docs/plans/Backlog/dcb-hot-tag-fence-contention.md.
+  let event = (eventType, tags): ReventlessCore.DcbEventLog_Adapter.rawStoredEvent => {
+    eventType,
+    data: JSON.Object(Dict.make()),
+    tags,
+    meta: testMeta(),
+  }
+  let findFence = (
+    items: array<AwsSdk.DynamoDb.DocumentClient.TransactWriteCommand.transactWriteItem>,
+    fenceId,
+  ) =>
+    items->Array.find(it => {
+      let idOf = key => key->Dict.get("id") == Some(fenceId->JSON.Encode.string)
+      switch (it.update, it.conditionCheck) {
+      | (Some(u), _) => idOf(u.key)
+      | (_, Some(c)) => idOf(c.key)
+      | _ => false
+      }
+    })
+  let isUpdate = it =>
+    it->Option.flatMap(i => i.AwsSdk.DynamoDb.DocumentClient.TransactWriteCommand.update)->Option.isSome
+  let fenceIds = (items: array<AwsSdk.DynamoDb.DocumentClient.TransactWriteCommand.transactWriteItem>) =>
+    items
+    ->Array.filterMap(it => {
+      let idOf = key => key->Dict.get("id")->Option.flatMap(JSON.Decode.string)
+      switch (it.update, it.conditionCheck) {
+      | (Some(u), _) => idOf(u.key)
+      | (_, Some(c)) => idOf(c.key)
+      | _ => None
+      }
+    })
+    ->Array.filter(s => s->String.startsWith("fence#"))
+
+  let spec: Reventless.DcbTag.compositePartitionSpec = {
+    keys: ["environment", "platformName", "pluginName"],
+    seps: ["/", "/"],
+  }
+  let partitionTag = Some(Reventless.DcbTag.Composite(spec))
+  let members = [tag("environment", "prod"), tag("platformName", "plat"), tag("pluginName", "plug")]
+  let compositeFence = "fence#__dcb_composite__:prod/plat/plug"
+
+  describe("at after=Some (entity exists)", () => {
+    let resource = event("ResourceAdded", members)
+    let cond: Reventless.DcbTag.appendCondition = {
+      query: [{tags: members, eventTypes: ["ResourceAdded"]}],
+      after: "50",
+    }
+    let items = Runtime.buildConditionalTransactItems(table, [resource], cond, "100", ~partitionTag?)
+
+    testSync("the whole composite key is a single conditional Update", () => {
+      expect(isUpdate(findFence(items, compositeFence)))->toBe(true)
+    })
+
+    testSync("no per-member fence is emitted (the hot-fence regression)", () => {
+      expect(findFence(items, "fence#environment:prod")->Option.isSome)->toBe(false)
+      expect(findFence(items, "fence#platformName:plat")->Option.isSome)->toBe(false)
+      expect(findFence(items, "fence#pluginName:plug")->Option.isSome)->toBe(false)
+    })
+
+    testSync("exactly one fence item total (the composite fence, no members)", () => {
+      expect(fenceIds(items))->toEqual([compositeFence])
+    })
+  })
+
+  describe("at after=None (folded create guard)", () => {
+    let resource = event("ResourceAdded", members)
+    let cond: Reventless.DcbTag.appendCondition = {
+      query: [{tags: members, eventTypes: ["ResourceAdded"]}],
+    }
+    let items = Runtime.buildConditionalTransactItems(table, [resource], cond, "100", ~partitionTag?)
+
+    testSync("the composite fence is a create-guard Update gated on attribute_not_exists", () => {
+      let u =
+        findFence(items, compositeFence)
+        ->Option.flatMap(i => i.AwsSdk.DynamoDb.DocumentClient.TransactWriteCommand.update)
+        ->Option.getOrThrow
+      expect(u.conditionExpression)->toEqual(Some("attribute_not_exists(#c0)"))
+      expect(u.expressionAttributeValues->Option.flatMap(v => v->Dict.get(":after")))->toEqual(None)
+    })
+
+    testSync("still exactly one composite fence (no per-member create guards)", () => {
+      expect(fenceIds(items))->toEqual([compositeFence])
+    })
+  })
+})
+
 describe("Runtime.buildConditionalTransactItems — folded create guard (after=None)", () => {
   let event = (eventType, tags): ReventlessCore.DcbEventLog_Adapter.rawStoredEvent => {
     eventType,
@@ -604,3 +695,52 @@ describe("Runtime.indexKeepsFullProjection", () => {
     expect(Runtime.indexKeepsFullProjection("tag_productId"))->toBe(false)
   })
 })
+
+describe("Runtime.generatePosition — monotonic HLC positions", () => {
+  testSync("a rapid sequence of positions is strictly increasing (lexical == commit order)", () => {
+    // Most of these land in the same millisecond (counter increments); the loop
+    // also crosses ms ticks (counter resets, ms prefix dominates). Either way the
+    // sequence must be strictly increasing under byte-wise (DynamoDB) string order.
+    let positions = Array.fromInitializer(~length=50, _ => Runtime.generatePosition())
+    let strictlyIncreasing = ref(true)
+    for i in 1 to Array.length(positions) - 1 {
+      let prev = positions->Array.getUnsafe(i - 1)
+      let curr = positions->Array.getUnsafe(i)
+      if !(prev < curr) {
+        strictlyIncreasing := false
+      }
+    }
+    expect(strictlyIncreasing.contents)->toBe(true)
+  })
+
+  testSync("format carries a 6-digit counter segment between ms and uuid", () => {
+    // `<ms>-<6-digit counter>-<uuid>`. Splitting on '-' yields [ms, counter, …uuid].
+    let segments = Runtime.generatePosition()->String.split("-")
+    expect(segments->Array.length >= 3)->toBe(true)
+    let counterSeg = segments->Array.getUnsafe(1)
+    expect(counterSeg->String.length)->toBe(6)
+  })
+
+  testSync("generatePositionForBatch preserves order for same base, ascending index", () => {
+    let base = Runtime.generatePosition()
+    let p0 = Runtime.generatePositionForBatch(base, 0)
+    let p1 = Runtime.generatePositionForBatch(base, 1)
+    let p2 = Runtime.generatePositionForBatch(base, 2)
+    // index 0 is the base itself; later batch items sort strictly after it, in order.
+    expect(p0)->toBe(base)
+    expect(base < p1)->toBe(true)
+    expect(p1 < p2)->toBe(true)
+  })
+
+  testSync("old <ms>-<uuid> positions still sort by timestamp against new-format ones", () => {
+    // Backwards compatibility: the ms prefix keeps the same 13-digit width, so an
+    // older position with a smaller ms sorts before a newer-format one regardless of
+    // the counter segment. Sorting an unsorted mix must recover timestamp order.
+    let older = "1700000000000-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" // old <ms>-<uuid>
+    let newer = "1700000000001-000000-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" // new <ms>-<ctr>-<uuid>
+    let cmp = (a, b) => a < b ? -1.0 : a > b ? 1.0 : 0.0
+    let sorted = [newer, older]->Array.toSorted(cmp)
+    expect(sorted->Array.getUnsafe(0))->toBe(older)
+    expect(sorted->Array.getUnsafe(1))->toBe(newer)
+  })
+})

package/tests/DcbEventLogStorage_DynamoDb_RuntimeTest.res.mjs

@@ -544,6 +544,115 @@ globalThis.describe("Runtime.buildConditionalTransactItems — fence-scope = rea
   });
 });
 
+globalThis.describe("Runtime.buildConditionalTransactItems — composite partition fences on ONE composite key", () => {
+  let event = (eventType, tags) => ({
+    eventType: eventType,
+    data: {},
+    tags: tags,
+    meta: testMeta()
+  });
+  let findFence = (items, fenceId) => items.find(it => {
+    let idOf = key => Primitive_object.equal(key["id"], fenceId);
+    let match = it.Update;
+    let match$1 = it.ConditionCheck;
+    if (match !== undefined) {
+      return idOf(match.Key);
+    } else if (match$1 !== undefined) {
+      return idOf(match$1.Key);
+    } else {
+      return false;
+    }
+  });
+  let isUpdate = it => Stdlib_Option.isSome(Stdlib_Option.flatMap(it, i => i.Update));
+  let fenceIds = items => Stdlib_Array.filterMap(items, it => {
+    let idOf = key => Stdlib_Option.flatMap(key["id"], Stdlib_JSON.Decode.string);
+    let match = it.Update;
+    let match$1 = it.ConditionCheck;
+    if (match !== undefined) {
+      return idOf(match.Key);
+    } else if (match$1 !== undefined) {
+      return idOf(match$1.Key);
+    } else {
+      return;
+    }
+  }).filter(s => s.startsWith("fence#"));
+  let spec_keys = [
+    "environment",
+    "platformName",
+    "pluginName"
+  ];
+  let spec_seps = [
+    "/",
+    "/"
+  ];
+  let spec = {
+    keys: spec_keys,
+    seps: spec_seps
+  };
+  let partitionTag = {
+    TAG: "Composite",
+    _0: spec
+  };
+  let members = [
+    {
+      key: "environment",
+      value: "prod"
+    },
+    {
+      key: "platformName",
+      value: "plat"
+    },
+    {
+      key: "pluginName",
+      value: "plug"
+    }
+  ];
+  let compositeFence = "fence#__dcb_composite__:prod/plat/plug";
+  globalThis.describe("at after=Some (entity exists)", () => {
+    let resource = event("ResourceAdded", members);
+    let cond_query = [{
+        eventTypes: ["ResourceAdded"],
+        tags: members
+      }];
+    let cond_after = "50";
+    let cond = {
+      query: cond_query,
+      after: cond_after
+    };
+    let items = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalTransactItems(table, [resource], cond, "100", partitionTag, undefined);
+    globalThis.test("the whole composite key is a single conditional Update", () => {
+      globalThis.expect(isUpdate(findFence(items, compositeFence))).toBe(true);
+    });
+    globalThis.test("no per-member fence is emitted (the hot-fence regression)", () => {
+      globalThis.expect(Stdlib_Option.isSome(findFence(items, "fence#environment:prod"))).toBe(false);
+      globalThis.expect(Stdlib_Option.isSome(findFence(items, "fence#platformName:plat"))).toBe(false);
+      globalThis.expect(Stdlib_Option.isSome(findFence(items, "fence#pluginName:plug"))).toBe(false);
+    });
+    globalThis.test("exactly one fence item total (the composite fence, no members)", () => {
+      globalThis.expect(fenceIds(items)).toEqual([compositeFence]);
+    });
+  });
+  globalThis.describe("at after=None (folded create guard)", () => {
+    let resource = event("ResourceAdded", members);
+    let cond_query = [{
+        eventTypes: ["ResourceAdded"],
+        tags: members
+      }];
+    let cond = {
+      query: cond_query
+    };
+    let items = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalTransactItems(table, [resource], cond, "100", partitionTag, undefined);
+    globalThis.test("the composite fence is a create-guard Update gated on attribute_not_exists", () => {
+      let u = Stdlib_Option.getOrThrow(Stdlib_Option.flatMap(findFence(items, compositeFence), i => i.Update), undefined);
+      globalThis.expect(u.ConditionExpression).toEqual("attribute_not_exists(#c0)");
+      globalThis.expect(Stdlib_Option.flatMap(u.ExpressionAttributeValues, v => v[":after"])).toEqual(undefined);
+    });
+    globalThis.test("still exactly one composite fence (no per-member create guards)", () => {
+      globalThis.expect(fenceIds(items)).toEqual([compositeFence]);
+    });
+  });
+});
+
 globalThis.describe("Runtime.buildConditionalTransactItems — folded create guard (after=None)", () => {
   let event = (eventType, tags) => ({
     eventType: eventType,
@@ -746,6 +855,55 @@ globalThis.describe("Runtime.indexKeepsFullProjection", () => {
   });
 });
 
+globalThis.describe("Runtime.generatePosition — monotonic HLC positions", () => {
+  globalThis.test("a rapid sequence of positions is strictly increasing (lexical == commit order)", () => {
+    let positions = Stdlib_Array.fromInitializer(50, param => DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.generatePosition());
+    let strictlyIncreasing = true;
+    for (let i = 1, i_finish = positions.length; i < i_finish; ++i) {
+      let prev = positions[i - 1 | 0];
+      let curr = positions[i];
+      if (prev >= curr) {
+        strictlyIncreasing = false;
+      }
+    }
+    globalThis.expect(strictlyIncreasing).toBe(true);
+  });
+  globalThis.test("format carries a 6-digit counter segment between ms and uuid", () => {
+    let segments = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.generatePosition().split("-");
+    globalThis.expect(segments.length >= 3).toBe(true);
+    let counterSeg = segments[1];
+    globalThis.expect(counterSeg.length).toBe(6);
+  });
+  globalThis.test("generatePositionForBatch preserves order for same base, ascending index", () => {
+    let base = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.generatePosition();
+    let p0 = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.generatePositionForBatch(base, 0);
+    let p1 = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.generatePositionForBatch(base, 1);
+    let p2 = DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.generatePositionForBatch(base, 2);
+    globalThis.expect(p0).toBe(base);
+    globalThis.expect(base < p1).toBe(true);
+    globalThis.expect(p1 < p2).toBe(true);
+  });
+  globalThis.test("old <ms>-<uuid> positions still sort by timestamp against new-format ones", () => {
+    let older = "1700000000000-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+    let newer = "1700000000001-000000-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+    let cmp = (a, b) => {
+      if (Primitive_object.lessthan(a, b)) {
+        return -1.0;
+      } else if (Primitive_object.greaterthan(a, b)) {
+        return 1.0;
+      } else {
+        return 0.0;
+      }
+    };
+    let sorted = [
+      newer,
+      older
+    ].toSorted(cmp);
+    globalThis.expect(sorted[0]).toBe(older);
+    globalThis.expect(sorted[1]).toBe(newer);
+  });
+});
+
 let Runtime;
 
 export {

package/tests/integration/DcbEventLogStorage_DynamoDb_IntegrationTest.res

@@ -1,10 +1,9 @@
-// ⚠️ PENDING REWRITE (dcb-fence-event-type-granularity): this suite still encodes
-// the OLD scalar-`lastPosition` fence + `create#…` create-guard model. The adapter
-// now uses PER-TYPE `pos#<eventType>` fence attributes with the create guard folded
-// in, so `H.setFence(~lastPosition=…)` seeding, the `create#…`-row assertions, and
-// the tag-only (no `eventTypes`) queries below must be reworked and re-run against
-// DynamoDB Local before they pass. Tracked as Test plan #2 in
-// docs/plans/dcb-fence-event-type-granularity.md. Not run by the default unit suite
+// Fence model: PER-TYPE `pos#<eventType>` attributes with the create guard folded
+// into the fence Update (dcb-fence-event-type-granularity). Conflict-expecting
+// scenarios name the consumed event type on each query clause (a tag-only clause
+// produces no fence check) and advance the fence via `H.setFence(~eventTypes,
+// ~position=…)`, which writes the matching `pos#<eventType>` attribute — the same
+// attribute a real conditional append checks. Not run by the default unit suite
 // (CI `pnpm test`), so it does not gate the build.
 //
 // DCB DynamoDB integration suite — exercises the real fence path against a
@@ -105,17 +104,23 @@ describe("DCB DynamoDb integration — fence-scope = read-scope (Issue 1 regress
     let table = await H.freshTable()
     let _ = await seed(table, event("CatalogProductSynced", [productTag]), ~partitionTag=simple("productId"))
 
-    // Order reads its decision model (after = the sync's position)…
-    let query: Reventless.DcbTag.query = [{tags: [tag("orderId", "O1")]}, {tags: [productTag]}]
+    // Order reads its decision model (after = the sync's position). Each clause
+    // names the event type it reads — the per-type fence model checks the
+    // consumed type's `pos#<type>`, so a tag-only clause would produce no fence
+    // check at all.
+    let query: Reventless.DcbTag.query = [
+      {tags: [tag("orderId", "O1")], eventTypes: ["OrderPlaced"]},
+      {tags: [productTag], eventTypes: ["CatalogProductSynced"]},
+    ]
     let after = (await readAfter(table, query))->Option.getOr("")
     expect(after == "")->toBe(false)
 
-    // …a concurrent re-sync advances fence#productId:P5 past `after`. We set the
-    // fence directly (rather than racing a second appendUnconditional) so the
-    // advance is deterministically > after — same-millisecond writers can
-    // otherwise tie on UUID order (analysis Issue 7). Appending "z" stays
-    // lexically greater than any real position.
-    let _ = await H.setFence(table, productTag, ~lastPosition=after ++ "z")
+    // …a concurrent re-sync advances fence#productId:P5's pos#CatalogProductSynced
+    // past `after`. We set the fence directly (rather than racing a second
+    // appendUnconditional) so the advance is deterministically > after —
+    // same-millisecond writers can otherwise tie on UUID order (analysis Issue 7).
+    // Appending "z" stays lexically greater than any real position.
+    let _ = await H.setFence(table, productTag, ~eventTypes=["CatalogProductSynced"], ~position=after ++ "z")
 
     // …so the now-stale order append must conflict on the productId fence.
     let r = await Runtime.appendConditional(
@@ -280,9 +285,11 @@ describe("DCB DynamoDb integration — optimistic concurrency primitives", () =>
 
   testAsync("a failed fence condition aborts the whole transaction (multi-tag atomicity)", async () => {
     let table = await H.freshTable()
-    // Composite slice: one multi-tag clause → both tags get check+bump.
+    // Composite slice: one multi-tag clause → both tags get check+bump. The
+    // clause names the consumed type so the per-type fence check has a `pos#<type>`
+    // to assert against.
     let tags = [tag("productId", "p1"), tag("orderId", "o1")]
-    let query: Reventless.DcbTag.query = [{tags: tags}]
+    let query: Reventless.DcbTag.query = [{tags: tags, eventTypes: ["ProductDemandRecorded"]}]
 
     // Seed one event so the next append rides after=Some.
     let seedRes = await Runtime.appendConditional(
@@ -296,9 +303,14 @@ describe("DCB DynamoDb integration — optimistic concurrency primitives", () =>
     let after = (await readAfter(table, query))->Option.getOr("")
     expect(after == "")->toBe(false)
 
-    // A concurrent writer advances ONLY the productId fence past `after`.
-    // Appending "z" keeps the position lexically greater than any real position.
-    let _ = await H.setFence(table, tag("productId", "p1"), ~lastPosition=after ++ "z")
+    // A concurrent writer advances ONLY the productId fence's pos#ProductDemandRecorded
+    // past `after`. Appending "z" keeps the position lexically greater than any real one.
+    let _ = await H.setFence(
+      table,
+      tag("productId", "p1"),
+      ~eventTypes=["ProductDemandRecorded"],
+      ~position=after ++ "z",
+    )
 
     let r = await Runtime.appendConditional(
       table,
@@ -314,3 +326,135 @@ describe("DCB DynamoDb integration — optimistic concurrency primitives", () =>
     expect(readResult.events->Array.length)->toBe(1)
   })
 })
+
+// A `@compositePartitionTag` slice (platform-inspector's SyncResource shape) fences
+// on the WHOLE composite key, not on each member. Distinct entities sharing a
+// low-cardinality prefix (environment/platformName/pluginName) must therefore NOT
+// serialize on that prefix — the deploy-fan-out hot-fence regression. Plan:
+// docs/plans/Backlog/dcb-hot-tag-fence-contention.md § "Root-cause correction".
+describe("DCB DynamoDb integration — composite partition hot-fence fix", () => {
+  let composite = (keys, seps): Reventless.DcbTag.derivedPartitionTag => Composite({keys, seps})
+  let specKeys = ["environment", "platformName", "pluginName", "resourceName"]
+  let specSeps = ["/", "/", "/"]
+  let pt = composite(specKeys, specSeps)
+  let members = resourceName => [
+    tag("environment", "prod"),
+    tag("platformName", "plat"),
+    tag("pluginName", "plug"),
+    tag("resourceName", resourceName),
+  ]
+
+  testAsync("distinct composite entities sharing a prefix do NOT false-conflict", async () => {
+    let table = await H.freshTable()
+    let tagsA = members("resA")
+    let tagsB = members("resB")
+    // Both are first-writers (after=None). They share environment/platformName/
+    // pluginName but are DIFFERENT composite entities → different composite fences.
+    let rA = await Runtime.appendConditional(
+      table,
+      [event("ResourceAdded", tagsA)],
+      {query: [{tags: tagsA}], after: ?None},
+      ~partitionTag=pt,
+    )
+    let rB = await Runtime.appendConditional(
+      table,
+      [event("ResourceAdded", tagsB)],
+      {query: [{tags: tagsB}], after: ?None},
+      ~partitionTag=pt,
+    )
+    // Pre-fix: rB conflicts on the shared `fence#environment:prod` create guard.
+    expect(isOk(rA))->toBe(true)
+    expect(isOk(rB))->toBe(true)
+  })
+
+  testAsync("two first-writers of the SAME composite key still serialize (OCC preserved)", async () => {
+    let table = await H.freshTable()
+    let tags = members("resA")
+    let query: Reventless.DcbTag.query = [{tags: tags}]
+    let r1 = await Runtime.appendConditional(
+      table,
+      [event("ResourceAdded", tags)],
+      {query, after: ?None},
+      ~partitionTag=pt,
+    )
+    let r2 = await Runtime.appendConditional(
+      table,
+      [event("ResourceAdded", tags)],
+      {query, after: ?None},
+      ~partitionTag=pt,
+    )
+    expect(isOk(r1))->toBe(true)
+    // The folded create guard (attribute_not_exists on the composite fence) rejects
+    // the second first-write of the same entity.
+    expect(isConflict(r2))->toBe(true)
+  })
+})
+
+// The fence is PER event type (`pos#<eventType>` attributes), not a single scalar
+// `lastPosition` per partition. So two slices consuming DIFFERENT types on the same
+// entity (e.g. price vs name changes on one productId) never contend, and an entity
+// never wedges into a permanent Conflict after one attribute changes. This is the
+// live proof of the per-type granularity fix (dcb-fence-event-type-granularity,
+// `a20646f31`); the unit suite only asserts the built transaction's shape.
+describe("DCB DynamoDb integration — per-type fence granularity", () => {
+  let productTag = tag("productId", "P")
+
+  // Change one attribute of P: read only its own event type on the partition, then
+  // append that type. Each type carries its own `pos#<type>` fence, so distinct
+  // attributes advance independently.
+  let change = async (table, ~eventType) => {
+    let query: Reventless.DcbTag.query = [{tags: [productTag], eventTypes: [eventType]}]
+    let after = await readAfter(table, query)
+    await Runtime.appendConditional(
+      table,
+      [event(eventType, [productTag])],
+      {query, after: ?after},
+      ~partitionTag=simple("productId"),
+    )
+  }
+
+  testAsync("interleaved distinct-type changes on one product all succeed (never wedges)", async () => {
+    let table = await H.freshTable()
+    let _ = await seed(table, event("ProductAdded", [productTag]), ~partitionTag=simple("productId"))
+
+    // Two rounds of interleaved price/name/description changes. Pre-fix, the first
+    // PriceChanged bumped the single partition fence, so the following NameChanged
+    // read a stale head and conflicted PERMANENTLY — the entity wedged after one edit.
+    let results = [
+      await change(table, ~eventType="PriceChanged"),
+      await change(table, ~eventType="NameChanged"),
+      await change(table, ~eventType="DescriptionChanged"),
+      await change(table, ~eventType="PriceChanged"),
+      await change(table, ~eventType="NameChanged"),
+    ]
+    expect(results->Array.every(isOk))->toBe(true)
+  })
+
+  testAsync("two concurrent SAME-type changes still serialize (per-type OCC preserved)", async () => {
+    let table = await H.freshTable()
+    let _ = await seed(table, event("ProductAdded", [productTag]), ~partitionTag=simple("productId"))
+    // Seed one NameChanged so both racers read the same after=Some head.
+    let _ = await change(table, ~eventType="NameChanged")
+
+    let query: Reventless.DcbTag.query = [{tags: [productTag], eventTypes: ["NameChanged"]}]
+    let after = await readAfter(table, query)
+    let rename = () =>
+      Runtime.appendConditional(
+        table,
+        [event("NameChanged", [productTag])],
+        {query, after: ?after},
+        ~partitionTag=simple("productId"),
+      )
+
+    // Per-type granularity must NOT weaken same-type OCC: two concurrent NameChanged
+    // at the same `pos#NameChanged` head → at most one commits, every non-winner
+    // conflicts. (DynamoDB may cancel both with a mutual TransactionConflict; the
+    // slice callback's retry loop makes exactly one win in prod.)
+    let results = await Promise.all([rename(), rename()])
+    let oks = results->Array.filter(isOk)->Array.length
+    let conflicts = results->Array.filter(isConflict)->Array.length
+    expect(oks <= 1)->toBe(true)
+    expect(oks + conflicts)->toBe(2)
+    expect(conflicts >= 1)->toBe(true)
+  })
+})

package/tests/integration/DcbEventLogStorage_DynamoDb_IntegrationTest.res.mjs

@@ -129,18 +129,20 @@ globalThis.describe("DCB DynamoDb integration — fence-scope = read-scope (Issu
     });
     let query = [
       {
+        eventTypes: ["OrderPlaced"],
         tags: [{
             key: "orderId",
             value: "O1"
           }]
       },
       {
+        eventTypes: ["CatalogProductSynced"],
         tags: [productTag]
       }
     ];
     let after = Stdlib_Option.getOr(await readAfter(table, query), "");
     globalThis.expect(after === "").toBe(false);
-    await DcbIntegrationHarness$ReventlessAws.setFence(table, productTag, after + "z");
+    await DcbIntegrationHarness$ReventlessAws.setFence(table, productTag, ["CatalogProductSynced"], after + "z");
     let r = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("OrderPlaced", [
         {
           key: "orderId",
@@ -384,6 +386,7 @@ globalThis.describe("DCB DynamoDb integration — optimistic concurrency primiti
       }
     ];
     let query = [{
+        eventTypes: ["ProductDemandRecorded"],
         tags: tags
       }];
     let seedRes = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ProductDemandRecorded", tags)], {
@@ -400,7 +403,7 @@ globalThis.describe("DCB DynamoDb integration — optimistic concurrency primiti
     await DcbIntegrationHarness$ReventlessAws.setFence(table, {
       key: "productId",
       value: "p1"
-    }, after + "z");
+    }, ["ProductDemandRecorded"], after + "z");
     let r = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ProductDemandRecorded", tags)], {
       query: query,
       after: after
@@ -416,6 +419,150 @@ globalThis.describe("DCB DynamoDb integration — optimistic concurrency primiti
   });
 });
 
+globalThis.describe("DCB DynamoDb integration — composite partition hot-fence fix", () => {
+  let specKeys = [
+    "environment",
+    "platformName",
+    "pluginName",
+    "resourceName"
+  ];
+  let specSeps = [
+    "/",
+    "/",
+    "/"
+  ];
+  let pt = {
+    TAG: "Composite",
+    _0: {
+      keys: specKeys,
+      seps: specSeps
+    }
+  };
+  let members = resourceName => [
+    {
+      key: "environment",
+      value: "prod"
+    },
+    {
+      key: "platformName",
+      value: "plat"
+    },
+    {
+      key: "pluginName",
+      value: "plug"
+    },
+    {
+      key: "resourceName",
+      value: resourceName
+    }
+  ];
+  globalThis.test("distinct composite entities sharing a prefix do NOT false-conflict", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    let tagsA = members("resA");
+    let tagsB = members("resB");
+    let rA = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ResourceAdded", tagsA)], {
+      query: [{
+          tags: tagsA
+        }]
+    }, pt, undefined);
+    let rB = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ResourceAdded", tagsB)], {
+      query: [{
+          tags: tagsB
+        }]
+    }, pt, undefined);
+    globalThis.expect(isOk(rA)).toBe(true);
+    globalThis.expect(isOk(rB)).toBe(true);
+  });
+  globalThis.test("two first-writers of the SAME composite key still serialize (OCC preserved)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    let tags = members("resA");
+    let query = [{
+        tags: tags
+      }];
+    let r1 = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ResourceAdded", tags)], {
+      query: query
+    }, pt, undefined);
+    let r2 = await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("ResourceAdded", tags)], {
+      query: query
+    }, pt, undefined);
+    globalThis.expect(isOk(r1)).toBe(true);
+    globalThis.expect(isConflict(r2)).toBe(true);
+  });
+});
+
+globalThis.describe("DCB DynamoDb integration — per-type fence granularity", () => {
+  let productTag = {
+    key: "productId",
+    value: "P"
+  };
+  let change = async (table, eventType) => {
+    let query = [{
+        eventTypes: [eventType],
+        tags: [productTag]
+      }];
+    let after = await readAfter(table, query);
+    return await DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event(eventType, [productTag])], {
+      query: query,
+      after: after
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined);
+  };
+  globalThis.test("interleaved distinct-type changes on one product all succeed (never wedges)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    await seed(table, event("ProductAdded", [productTag]), {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    });
+    let results = [
+      await change(table, "PriceChanged"),
+      await change(table, "NameChanged"),
+      await change(table, "DescriptionChanged"),
+      await change(table, "PriceChanged"),
+      await change(table, "NameChanged")
+    ];
+    globalThis.expect(results.every(isOk)).toBe(true);
+  });
+  globalThis.test("two concurrent SAME-type changes still serialize (per-type OCC preserved)", async () => {
+    let table = await DcbIntegrationHarness$ReventlessAws.freshTable();
+    await seed(table, event("ProductAdded", [productTag]), {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    });
+    await change(table, "NameChanged");
+    let query = [{
+        eventTypes: ["NameChanged"],
+        tags: [productTag]
+      }];
+    let after = await readAfter(table, query);
+    let rename = () => DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.appendConditional(table, [event("NameChanged", [productTag])], {
+      query: query,
+      after: after
+    }, {
+      TAG: "Simple",
+      _0: {
+        key: "productId"
+      }
+    }, undefined);
+    let results = await Promise.all([
+      rename(),
+      rename()
+    ]);
+    let oks = results.filter(isOk).length;
+    let conflicts = results.filter(isConflict).length;
+    globalThis.expect(oks <= 1).toBe(true);
+    globalThis.expect(oks + conflicts | 0).toBe(2);
+    globalThis.expect(conflicts >= 1).toBe(true);
+  });
+});
+
 let H;
 
 let Runtime;

package/tests/integration/DcbIntegrationHarness.res

@@ -85,18 +85,29 @@ let freshTable = async () => {
   await createDcbTable(`DcbItTest_${counter.contents->Int.toString}`)
 }
 
-// Directly overwrite a fence sentinel's `lastPosition` — used to simulate a
-// concurrent writer having advanced a fence between a slice's read and append.
+// Directly advance a fence sentinel — used to simulate a concurrent writer having
+// bumped a fence between a slice's read and append. The fence model is per event
+// type (`pos#<eventType>` attributes, not a scalar `lastPosition`), so the caller
+// names the event type(s) whose position to set; each `pos#<eventType>` is written
+// to `position`, exactly as a real conditional append would advance them.
 let setFence = async (
   table: Util_DynamoDb_Runtime.resolvedTable,
   tag: Reventless.DcbTag.tag,
-  ~lastPosition: string,
+  ~eventTypes: array<string>,
+  ~position: string,
 ) => {
   let item =
-    Dict.fromArray([
-      ("id", s(DcbEventLogStorage_DynamoDb_Runtime.fencePartitionKey(tag))),
-      ("position", s("FENCE")),
-      ("lastPosition", s(lastPosition)),
-    ])->JSON.Encode.object
+    Array.concat(
+      [
+        ("id", s(DcbEventLogStorage_DynamoDb_Runtime.fencePartitionKey(tag))),
+        ("position", s("FENCE")),
+      ],
+      eventTypes->Array.map(et => (
+        DcbEventLogStorage_DynamoDb_Runtime.fenceTypeAttr(et),
+        s(position),
+      )),
+    )
+    ->Dict.fromArray
+    ->JSON.Encode.object
   await Util_DynamoDb_Runtime.put(table, item)
 }

package/tests/integration/DcbIntegrationHarness.res.mjs

@@ -129,7 +129,7 @@ async function freshTable() {
   return await createDcbTable(`DcbItTest_` + counter.contents.toString());
 }
 
-async function setFence(table, tag, lastPosition) {
+async function setFence(table, tag, eventTypes, position) {
   let item = Object.fromEntries([
     [
       "id",
@@ -138,12 +138,11 @@ async function setFence(table, tag, lastPosition) {
     [
       "position",
       "FENCE"
-    ],
-    [
-      "lastPosition",
-      lastPosition
     ]
-  ]);
+  ].concat(eventTypes.map(et => [
+    DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.fenceTypeAttr(et),
+    position
+  ])));
   return await Util_DynamoDb_Runtime$ReventlessAws.put(table, item);
 }