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

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)
+  })
+})