@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/components/dcb/DcbCrossPartitionReadTest.res

@@ -0,0 +1,68 @@
+// End-to-end proof of the inferred cross-partition read fix: a sibling product
+// sharing the same categoryId must NOT be returned by AddProduct's decision read,
+// because the categoryId clause indexes only the category's own events. Exercises
+// the full command → narrowed query → in-memory DcbEventLog read → decide path
+// that the unit tests and GWTs do not cover (the GWT harness folds events raw).
+
+open JestGlobals
+open DcbCrossPartitionFixtures
+
+describe("DCB inferred cross-partition read (sibling exclusion)", () => {
+  let _ = beforeAllAsync(async () => {
+    let _ = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+  })
+
+  let _ = beforeEach(() => {
+    capturedEventCount := 0
+  })
+
+  testPromise(
+    "a sibling product sharing the categoryId is not read; the new product is added",
+    async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      // Category cat1 exists, and a DIFFERENT product p1 already lives in it
+      // (tagged productId=p1 AND categoryId=cat1).
+      let _ = await ops.append([
+        encodeEvent(CategoryAdded({categoryId: "cat1", name: "Electronics"})),
+        encodeEvent(ProductAdded({productId: "p1", categoryId: "cat1", name: "Laptop"})),
+      ])
+      capturedEventCount := 0 // count only events produced by the command below
+
+      // Add a new product p2 in cat1. The categoryId clause narrows ProductAdded
+      // out, so it reads only CategoryAdded — p1 is invisible — and p2 is added.
+      await dispatch(addProductJson("p2", "cat1", "Mouse"), "p2")
+      expect(capturedEventCount.contents)->toBe(1)
+    },
+  )
+
+  testPromise(
+    "a product added through the slice is NOT written to the categoryId GSI (payload, not indexed)",
+    async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await ops.append([encodeEvent(CategoryAdded({categoryId: "cat3", name: "Toys"}))])
+      // p3 is produced by the slice → its categoryId is filtered out on write.
+      await dispatch(addProductJson("p3", "cat3", "Blocks"), "p3")
+
+      // Queryable by its own partition key…
+      let byProduct = await ops.read(~query=[{tags: [{Reventless.DcbTag.key: "productId", value: "p3"}]}])
+      expect(byProduct.events->Array.some(e => e.eventType == "ProductAdded"))->toBe(true)
+
+      // …but the categoryId index returns only the category's own event, never p3.
+      let byCategory = await ops.read(~query=[{tags: [{Reventless.DcbTag.key: "categoryId", value: "cat3"}]}])
+      expect(byCategory.events->Array.some(e => e.eventType == "ProductAdded"))->toBe(false)
+      expect(byCategory.events->Array.some(e => e.eventType == "CategoryAdded"))->toBe(true)
+    },
+  )
+
+  testPromise("re-adding the same product is still rejected (its own read is partition-scoped)", async () => {
+    let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+    let _ = await ops.append([
+      encodeEvent(CategoryAdded({categoryId: "cat2", name: "Books"})),
+      encodeEvent(ProductAdded({productId: "p9", categoryId: "cat2", name: "Novel"})),
+    ])
+    capturedEventCount := 0 // count only events produced by the command below
+    // p9 already exists — its own productId clause returns its ProductAdded.
+    await dispatch(addProductJson("p9", "cat2", "Novel"), "p9")
+    expect(capturedEventCount.contents)->toBe(0)
+  })
+})

package/tests/components/dcb/DcbCrossPartitionReadTest.res.mjs

@@ -0,0 +1,78 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as DcbCrossPartitionFixtures$ReventlessLocal from "./DcbCrossPartitionFixtures.res.mjs";
+
+globalThis.describe("DCB inferred cross-partition read (sibling exclusion)", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbCrossPartitionFixtures$ReventlessLocal.eventLog));
+  });
+  globalThis.beforeEach(() => {
+    DcbCrossPartitionFixtures$ReventlessLocal.capturedEventCount.contents = 0;
+  });
+  globalThis.test("a sibling product sharing the categoryId is not read; the new product is added", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbCrossPartitionFixtures$ReventlessLocal.eventLog));
+    await ops.append([
+      DcbCrossPartitionFixtures$ReventlessLocal.encodeEvent({
+        TAG: "CategoryAdded",
+        categoryId: "cat1",
+        name: "Electronics"
+      }),
+      DcbCrossPartitionFixtures$ReventlessLocal.encodeEvent({
+        TAG: "ProductAdded",
+        productId: "p1",
+        categoryId: "cat1",
+        name: "Laptop"
+      })
+    ], undefined);
+    DcbCrossPartitionFixtures$ReventlessLocal.capturedEventCount.contents = 0;
+    await DcbCrossPartitionFixtures$ReventlessLocal.dispatch(DcbCrossPartitionFixtures$ReventlessLocal.addProductJson("p2", "cat1", "Mouse"), "p2");
+    globalThis.expect(DcbCrossPartitionFixtures$ReventlessLocal.capturedEventCount.contents).toBe(1);
+  });
+  globalThis.test("a product added through the slice is NOT written to the categoryId GSI (payload, not indexed)", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbCrossPartitionFixtures$ReventlessLocal.eventLog));
+    await ops.append([DcbCrossPartitionFixtures$ReventlessLocal.encodeEvent({
+        TAG: "CategoryAdded",
+        categoryId: "cat3",
+        name: "Toys"
+      })], undefined);
+    await DcbCrossPartitionFixtures$ReventlessLocal.dispatch(DcbCrossPartitionFixtures$ReventlessLocal.addProductJson("p3", "cat3", "Blocks"), "p3");
+    let byProduct = await ops.read([{
+        tags: [{
+            key: "productId",
+            value: "p3"
+          }]
+      }], undefined);
+    globalThis.expect(byProduct.events.some(e => e.eventType === "ProductAdded")).toBe(true);
+    let byCategory = await ops.read([{
+        tags: [{
+            key: "categoryId",
+            value: "cat3"
+          }]
+      }], undefined);
+    globalThis.expect(byCategory.events.some(e => e.eventType === "ProductAdded")).toBe(false);
+    globalThis.expect(byCategory.events.some(e => e.eventType === "CategoryAdded")).toBe(true);
+  });
+  globalThis.test("re-adding the same product is still rejected (its own read is partition-scoped)", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbCrossPartitionFixtures$ReventlessLocal.eventLog));
+    await ops.append([
+      DcbCrossPartitionFixtures$ReventlessLocal.encodeEvent({
+        TAG: "CategoryAdded",
+        categoryId: "cat2",
+        name: "Books"
+      }),
+      DcbCrossPartitionFixtures$ReventlessLocal.encodeEvent({
+        TAG: "ProductAdded",
+        productId: "p9",
+        categoryId: "cat2",
+        name: "Novel"
+      })
+    ], undefined);
+    DcbCrossPartitionFixtures$ReventlessLocal.capturedEventCount.contents = 0;
+    await DcbCrossPartitionFixtures$ReventlessLocal.dispatch(DcbCrossPartitionFixtures$ReventlessLocal.addProductJson("p9", "cat2", "Novel"), "p9");
+    globalThis.expect(DcbCrossPartitionFixtures$ReventlessLocal.capturedEventCount.contents).toBe(0);
+  });
+});
+
+/*  Not a pure module */

package/tests/components/dcb/DcbEventLogAppendStreamTest.res

@@ -0,0 +1,72 @@
+// Tests for DcbEventLog.appendStream (Phase H of effect-stream-integration plan).
+// Verifies that a Stream<rawEvent> can drive a single atomic append, and that
+// the readStream → appendStream pipeline works end-to-end.
+
+open JestGlobals
+open DcbFixtures
+
+// Helper to encode a typed event into a raw event for appending to the DcbEventLog
+let encodeEvent = (event: DcbFixtures.ItemEventLog.event): ReventlessInfra.DcbEventLog.rawEvent => {
+  let json = event->S.reverseConvertToJsonOrThrow(DcbFixtures.ItemEventLog.eventSchema)
+  let (eventType, data) = json->ReventlessCore.Message.splitMessage
+  let tags = Reventless.DcbTag.extractTags(DcbFixtures.ItemEventLog.eventSchema, event)
+  let meta = ReventlessCore.Message.generateMeta(~service="test")
+  {eventType, data: JSON.Object(data), tags, meta}
+}
+
+describe("DcbEventLog.appendStream (in-memory adapter)", () => {
+  let _ = beforeAllAsync(async () => {
+    let _ = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+  })
+
+  let _ = beforeEach(() => {
+    capturedEventCount := 0
+  })
+
+  testPromise("appendStream writes all events from stream", async () => {
+    let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+    let stream = [
+      encodeEvent(DcbFixtures.ItemEventLog.ItemAdded({id: "as-w1", name: "Widget1"})),
+      encodeEvent(DcbFixtures.ItemEventLog.ItemAdded({id: "as-w1", name: "Widget2"})),
+    ]->Stream.fromIterable
+    let result = await ops.appendStream(stream)->Effect.runPromise
+    let isOk = switch result {
+    | Ok(_) => true
+    | Error(_) => false
+    }
+    expect(isOk)->toBe(true)
+    let read = await ops.read(~query=tagQuery("as-w1"))
+    expect(read.events->Array.length)->toBe(2)
+  })
+
+  testPromise("appendStream on empty stream succeeds", async () => {
+    let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+    // Empty stream → empty array append → storage returns Ok(position)
+    let result = await ops.appendStream(Stream.empty)->Effect.runPromise
+    let isOk = switch result {
+    | Ok(_) => true
+    | Error(_) => false
+    }
+    expect(isOk)->toBe(true)
+  })
+
+  testPromise("readStream → appendStream pipeline copies events", async () => {
+    let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+    let _ = await ops.append([encodeEvent(DcbFixtures.ItemEventLog.ItemAdded({id: "as-src", name: "Source"}))])
+    // readStream returns rawSequencedEvent; extract bare rawEvent for appendStream
+    let srcStream =
+      ops.readStream(~query=tagQuery("as-src"))->Stream.map(se => {
+        let rawEvent: ReventlessInfra.DcbEventLog.rawEvent = {
+          eventType: se.eventType,
+          data: se.data,
+          tags: se.tags,
+          meta: se.meta,
+        }
+        rawEvent
+      })
+    let _ = await ops.appendStream(srcStream)->Effect.runPromise
+    let dst = await ops.read(~query=tagQuery("as-src"))
+    // 1 original + 1 copy = 2 events for the same tag
+    expect(dst.events->Array.length)->toBe(2)
+  })
+})

package/tests/components/dcb/DcbEventLogAppendStreamTest.res.mjs

@@ -0,0 +1,82 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as DcbFixtures$ReventlessLocal from "./DcbFixtures.res.mjs";
+
+function encodeEvent(event) {
+  let json = S.reverseConvertToJsonOrThrow(event, DcbFixtures$ReventlessLocal.ItemEventLog.eventSchema);
+  let match = Message$ReventlessCore.splitMessage(json);
+  let tags = DcbTag$Reventless.extractTags(DcbFixtures$ReventlessLocal.ItemEventLog.eventSchema, event);
+  let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  return {
+    eventType: match[0],
+    data: match[1],
+    tags: tags,
+    meta: meta
+  };
+}
+
+globalThis.describe("DcbEventLog.appendStream (in-memory adapter)", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbFixtures$ReventlessLocal.eventLog));
+  });
+  globalThis.beforeEach(() => {
+    DcbFixtures$ReventlessLocal.capturedEventCount.contents = 0;
+  });
+  globalThis.test("appendStream writes all events from stream", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbFixtures$ReventlessLocal.eventLog));
+    let stream = Stream.fromIterable([
+      encodeEvent({
+        TAG: "ItemAdded",
+        id: "as-w1",
+        name: "Widget1"
+      }),
+      encodeEvent({
+        TAG: "ItemAdded",
+        id: "as-w1",
+        name: "Widget2"
+      })
+    ]);
+    let result = await Effect.runPromise(ops.appendStream(stream, undefined));
+    let isOk;
+    isOk = result.TAG === "Ok";
+    globalThis.expect(isOk).toBe(true);
+    let read = await ops.read(DcbFixtures$ReventlessLocal.tagQuery("as-w1"), undefined);
+    globalThis.expect(read.events.length).toBe(2);
+  });
+  globalThis.test("appendStream on empty stream succeeds", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbFixtures$ReventlessLocal.eventLog));
+    let result = await Effect.runPromise(ops.appendStream(Stream.empty, undefined));
+    let isOk;
+    isOk = result.TAG === "Ok";
+    globalThis.expect(isOk).toBe(true);
+  });
+  globalThis.test("readStream → appendStream pipeline copies events", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbFixtures$ReventlessLocal.eventLog));
+    await ops.append([encodeEvent({
+        TAG: "ItemAdded",
+        id: "as-src",
+        name: "Source"
+      })], undefined);
+    let srcStream = Stream.map(ops.readStream(DcbFixtures$ReventlessLocal.tagQuery("as-src"), undefined, undefined), se => ({
+      eventType: se.eventType,
+      data: se.data,
+      tags: se.tags,
+      meta: se.meta
+    }));
+    await Effect.runPromise(ops.appendStream(srcStream, undefined));
+    let dst = await ops.read(DcbFixtures$ReventlessLocal.tagQuery("as-src"), undefined);
+    globalThis.expect(dst.events.length).toBe(2);
+  });
+});
+
+export {
+  encodeEvent,
+}
+/*  Not a pure module */

package/tests/components/dcb/DcbEventLogStreamTest.res

@@ -0,0 +1,103 @@
+// Tests for DcbEventLog.readStream (Phase D of effect-stream-integration plan).
+// Mirrors the pattern of EventLogStreamTest.res for the DCB event log.
+
+open JestGlobals
+open DcbFixtures
+
+describe("DcbEventLog.readStream (in-memory adapter)", () => {
+  let _ = beforeAllAsync(async () => {
+    let _ = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+  })
+
+  let _ = beforeEach(() => {
+    capturedEventCount := 0
+  })
+
+  describe("basic streaming", () => {
+    testPromise("readStream for tag with no matching events returns empty stream", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let count = await ops.readStream(~query=tagQuery("no-such-id"))
+        ->Stream.runFold(0, (n, _) => n + 1)
+        ->Effect.runPromise
+      expect(count)->toBe(0)
+    })
+
+    testPromise("readStream emits all events matching a tag query", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await dispatch(addItemJson("stream-1", "Widget"), "stream-1")
+      let count = await ops.readStream(~query=tagQuery("stream-1"))
+        ->Stream.runFold(0, (n, _) => n + 1)
+        ->Effect.runPromise
+      expect(count)->toBe(1)
+    })
+
+    testPromise("readStream for distinct IDs returns independent streams", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await dispatch(addItemJson("stream-A", "Alpha"), "stream-A")
+      let _ = await dispatch(addItemJson("stream-B", "Beta"), "stream-B")
+      let countA = await ops.readStream(~query=tagQuery("stream-A"))
+        ->Stream.runFold(0, (n, _) => n + 1)
+        ->Effect.runPromise
+      let countB = await ops.readStream(~query=tagQuery("stream-B"))
+        ->Stream.runFold(0, (n, _) => n + 1)
+        ->Effect.runPromise
+      expect(countA)->toBe(1)
+      expect(countB)->toBe(1)
+    })
+
+    testPromise("take(1) limits stream without loading all", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await dispatch(addItemJson("stream-C1", "C1"), "stream-C1")
+      let _ = await dispatch(addItemJson("stream-C2", "C2"), "stream-C2")
+      // Broad query: all ItemAdded events regardless of tag value
+      let result = await ops.readStream(~query=typeQuery("ItemAdded"))
+        ->Stream.take(1)
+        ->Stream.runCollect
+        ->Effect.runPromise
+      expect(result->Array.length)->toBe(1)
+    })
+  })
+
+  describe("fold patterns — (state, headPosition) used in StateChangeSlice_Callback", () => {
+    testPromise("runFold extracts last headPosition for append condition", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await dispatch(addItemJson("fold-1", "FoldItem"), "fold-1")
+      let (_, headPosition) = await ops.readStream(~query=tagQuery("fold-1"))
+        ->Stream.runFold(((), None), ((_dm, _pos), se) => ((), Some(se.position)))
+        ->Effect.runPromise
+      expect(Option.isSome(headPosition))->toBe(true)
+    })
+
+    testPromise("runFold on empty stream returns initial accumulator", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let (_, headPosition) = await ops.readStream(~query=tagQuery("no-such-id-fold"))
+        ->Stream.runFold((false, None), ((_dm, _pos), se) => (true, Some(se.position)))
+        ->Effect.runPromise
+      expect(headPosition)->toEqual(None)
+    })
+  })
+
+  describe("StateChangeSlice regression — second command sees first event via stream fold", () => {
+    testPromise("second AddItem with same ID is rejected (state sees existing event)", async () => {
+      // First command succeeds → ItemAdded event stored
+      // Second command: readStream folds all events → state = true (exists)
+      // decide(true, AddItem) → Error(ItemAlreadyExists) → no new events
+      let id = "dup-test-stream"
+      let _ = await dispatch(addItemJson(id, "First"), id)
+      let countBefore = capturedEventCount.contents
+      let _ = await dispatch(addItemJson(id, "Duplicate"), id)
+      // Duplicate command must not publish a second event
+      expect(capturedEventCount.contents)->toBe(countBefore)
+    })
+
+    testPromise("second AddItem with different ID succeeds", async () => {
+      let id1 = "distinct-1"
+      let id2 = "distinct-2"
+      let _ = await dispatch(addItemJson(id1, "First"), id1)
+      let countAfterFirst = capturedEventCount.contents
+      let _ = await dispatch(addItemJson(id2, "Second"), id2)
+      // New ID should publish an event
+      expect(capturedEventCount.contents)->toBe(countAfterFirst + 1)
+    })
+  })
+})

package/tests/components/dcb/DcbEventLogStreamTest.res.mjs

@@ -0,0 +1,91 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as DcbFixtures$ReventlessLocal from "./DcbFixtures.res.mjs";
+
+globalThis.describe("DcbEventLog.readStream (in-memory adapter)", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbFixtures$ReventlessLocal.eventLog));
+  });
+  globalThis.beforeEach(() => {
+    DcbFixtures$ReventlessLocal.capturedEventCount.contents = 0;
+  });
+  globalThis.describe("basic streaming", () => {
+    globalThis.test("readStream for tag with no matching events returns empty stream", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbFixtures$ReventlessLocal.eventLog));
+      let count = await Effect.runPromise(Stream$1.runFold(ops.readStream(DcbFixtures$ReventlessLocal.tagQuery("no-such-id"), undefined, undefined), 0, (n, param) => n + 1 | 0));
+      globalThis.expect(count).toBe(0);
+    });
+    globalThis.test("readStream emits all events matching a tag query", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbFixtures$ReventlessLocal.eventLog));
+      await DcbFixtures$ReventlessLocal.dispatch(DcbFixtures$ReventlessLocal.addItemJson("stream-1", "Widget"), "stream-1");
+      let count = await Effect.runPromise(Stream$1.runFold(ops.readStream(DcbFixtures$ReventlessLocal.tagQuery("stream-1"), undefined, undefined), 0, (n, param) => n + 1 | 0));
+      globalThis.expect(count).toBe(1);
+    });
+    globalThis.test("readStream for distinct IDs returns independent streams", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbFixtures$ReventlessLocal.eventLog));
+      await DcbFixtures$ReventlessLocal.dispatch(DcbFixtures$ReventlessLocal.addItemJson("stream-A", "Alpha"), "stream-A");
+      await DcbFixtures$ReventlessLocal.dispatch(DcbFixtures$ReventlessLocal.addItemJson("stream-B", "Beta"), "stream-B");
+      let countA = await Effect.runPromise(Stream$1.runFold(ops.readStream(DcbFixtures$ReventlessLocal.tagQuery("stream-A"), undefined, undefined), 0, (n, param) => n + 1 | 0));
+      let countB = await Effect.runPromise(Stream$1.runFold(ops.readStream(DcbFixtures$ReventlessLocal.tagQuery("stream-B"), undefined, undefined), 0, (n, param) => n + 1 | 0));
+      globalThis.expect(countA).toBe(1);
+      globalThis.expect(countB).toBe(1);
+    });
+    globalThis.test("take(1) limits stream without loading all", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbFixtures$ReventlessLocal.eventLog));
+      await DcbFixtures$ReventlessLocal.dispatch(DcbFixtures$ReventlessLocal.addItemJson("stream-C1", "C1"), "stream-C1");
+      await DcbFixtures$ReventlessLocal.dispatch(DcbFixtures$ReventlessLocal.addItemJson("stream-C2", "C2"), "stream-C2");
+      let result = await Effect.runPromise(Stream.runCollect(Stream$1.take(ops.readStream(DcbFixtures$ReventlessLocal.typeQuery("ItemAdded"), undefined, undefined), 1)));
+      globalThis.expect(result.length).toBe(1);
+    });
+  });
+  globalThis.describe("fold patterns — (state, headPosition) used in StateChangeSlice_Callback", () => {
+    globalThis.test("runFold extracts last headPosition for append condition", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbFixtures$ReventlessLocal.eventLog));
+      await DcbFixtures$ReventlessLocal.dispatch(DcbFixtures$ReventlessLocal.addItemJson("fold-1", "FoldItem"), "fold-1");
+      let match = await Effect.runPromise(Stream$1.runFold(ops.readStream(DcbFixtures$ReventlessLocal.tagQuery("fold-1"), undefined, undefined), [
+        undefined,
+        undefined
+      ], (param, se) => [
+        undefined,
+        se.position
+      ]));
+      globalThis.expect(Stdlib_Option.isSome(match[1])).toBe(true);
+    });
+    globalThis.test("runFold on empty stream returns initial accumulator", async () => {
+      let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(DcbFixtures$ReventlessLocal.eventLog));
+      let match = await Effect.runPromise(Stream$1.runFold(ops.readStream(DcbFixtures$ReventlessLocal.tagQuery("no-such-id-fold"), undefined, undefined), [
+        false,
+        undefined
+      ], (param, se) => [
+        true,
+        se.position
+      ]));
+      globalThis.expect(match[1]).toEqual(undefined);
+    });
+  });
+  globalThis.describe("StateChangeSlice regression — second command sees first event via stream fold", () => {
+    globalThis.test("second AddItem with same ID is rejected (state sees existing event)", async () => {
+      let id = "dup-test-stream";
+      await DcbFixtures$ReventlessLocal.dispatch(DcbFixtures$ReventlessLocal.addItemJson(id, "First"), id);
+      let countBefore = DcbFixtures$ReventlessLocal.capturedEventCount.contents;
+      await DcbFixtures$ReventlessLocal.dispatch(DcbFixtures$ReventlessLocal.addItemJson(id, "Duplicate"), id);
+      globalThis.expect(DcbFixtures$ReventlessLocal.capturedEventCount.contents).toBe(countBefore);
+    });
+    globalThis.test("second AddItem with different ID succeeds", async () => {
+      let id1 = "distinct-1";
+      let id2 = "distinct-2";
+      await DcbFixtures$ReventlessLocal.dispatch(DcbFixtures$ReventlessLocal.addItemJson(id1, "First"), id1);
+      let countAfterFirst = DcbFixtures$ReventlessLocal.capturedEventCount.contents;
+      await DcbFixtures$ReventlessLocal.dispatch(DcbFixtures$ReventlessLocal.addItemJson(id2, "Second"), id2);
+      globalThis.expect(DcbFixtures$ReventlessLocal.capturedEventCount.contents).toBe(countAfterFirst + 1 | 0);
+    });
+  });
+});
+
+/*  Not a pure module */

package/tests/components/dcb/DcbFixtures.res

@@ -0,0 +1,145 @@
+// E2E test fixtures for DcbEventLog + StateChangeSlice.
+// Contains specs, bus setup, component wiring, and shared test helpers.
+
+open TestFixtures
+
+// ─────────────────────────────────────────────────────────────
+// Event type definition for the DcbEventLog
+// ─────────────────────────────────────────────────────────────
+
+module ItemEventLog = {
+  @schema
+  type event = ItemAdded({id: @s.matches(Reventless.DcbTag.string) string, name: string})
+}
+
+// ─────────────────────────────────────────────────────────────
+// Minimal StateChangeSlice spec
+// ─────────────────────────────────────────────────────────────
+
+module AddItemSpec = {
+  let name = "AddItem"
+  module Id = Reventless.Id.String
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type event = ItemAdded({id: @s.matches(Reventless.DcbTag.string) string, name: string})
+
+  @schema
+  type consumedEvent = ItemAdded
+
+  @schema
+  type command = AddItem({id: @s.matches(Reventless.DcbTag.string) string, name: string})
+
+  @schema
+  type error = ItemAlreadyExists
+
+  let commandSchema = commandSchema // auto-generated by @schema
+}
+
+module AddItemBehavior = {
+  module Spec = AddItemSpec
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  type state = bool // true = item exists
+  let initialState = false
+
+  let evolve = (_state: state, _event: Spec.consumedEvent) => true // any event means item exists
+
+  let decide = (state: state, command: Spec.command): result<array<Spec.event>, Spec.error> =>
+    if state {
+      Error(ItemAlreadyExists)
+    } else {
+      switch command {
+      | AddItem({id, name}) => Ok([Spec.ItemAdded({id, name})])
+      }
+    }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Isolated bus for this test suite
+// ─────────────────────────────────────────────────────────────
+
+module Bus = LocalBus.Make()
+
+// Topic name = DcbEventLog name ++ "EventTopic" = "ItemEventLogEventTopic"
+let capturedEventCount: ref<int> = ref(0)
+let _ = Bus.subscribeToEvents("ItemEventLogEventTopic", async (_, _, _) => {
+  capturedEventCount := capturedEventCount.contents + 1
+})
+
+// ─────────────────────────────────────────────────────────────
+// Activate Pulumi mock mode (must be before any Component.make)
+// ─────────────────────────────────────────────────────────────
+
+let _ = TestRunner.setup()
+
+// ─────────────────────────────────────────────────────────────
+// Build DcbEventLog
+// ─────────────────────────────────────────────────────────────
+
+module ItemEventLogMaker = DcbEventLog_Builder.Make(Bus)
+let eventLog = ItemEventLogMaker.make(~name="ItemEventLog", ~partitionTag=Reventless.DcbTag.Simple({key: "id"}))
+
+// ─────────────────────────────────────────────────────────────
+// Build StateChangeSlice
+// ─────────────────────────────────────────────────────────────
+
+module AddItemMaker = StateChangeSlice_Builder.Make(AddItemSpec, AddItemBehavior)
+
+// publishJsons routing — dispatches each command to its registered handler.
+let publishJsons: ReventlessInfra.CommandTopic.publishJsons = async cmdJsons => {
+  let _ = await cmdJsons
+  ->Array.map(async cmdJson => {
+    let typeName = switch cmdJson.commandJson {
+    | JSON.Object(dict) =>
+      dict
+      ->Dict.get("TAG")
+      ->Option.flatMap(j =>
+        switch j {
+        | JSON.String(s) => Some(s)
+        | _ => None
+        }
+      )
+      ->Option.getOr("")
+    | _ => ""
+    }
+    let fullBody = JSON.Encode.object(
+      Dict.fromArray([
+        ("id", JSON.Encode.string(cmdJson.id)),
+        ("meta", cmdJson.meta->S.reverseConvertToJsonOrThrow(Reventless.Message.metaSchema)),
+        ("command", cmdJson.commandJson),
+      ]),
+    )
+    let handlers = ReventlessCore.CommandTopic.getHandlers(typeName)
+    let _ = await handlers
+    ->Array.map(async entry => {
+      let item: ReventlessInfra.CommandTopic.topicItem<JSON.t> = {
+        reference: cmdJson.id,
+        command: fullBody,
+      }
+      let _ = await entry.handler(Stream.fromIterable([item]))->Effect.runPromise
+    })
+    ->Promise.all
+  })
+  ->Promise.all
+}
+
+let publishJsonsOutput = publishJsons->Pulumi.Output.make
+
+let _addItemSlice = AddItemMaker.make(~dcbEventLog=eventLog, ~publishJsons=publishJsonsOutput)
+
+// ─────────────────────────────────────────────────────────────
+// Test helpers
+// ─────────────────────────────────────────────────────────────
+
+let dispatch = async (commandJson, id) =>
+  await publishJsons([{Reventless.Message.id, meta: testMeta, commandJson}])
+
+let tagQuery = (id: string): Reventless.DcbTag.query => [
+  {tags: [{Reventless.DcbTag.key: "id", value: id}]},
+]
+
+let typeQuery = (eventType: string): Reventless.DcbTag.query => [{eventTypes: [eventType]}]
+
+let addItemJson = (id, name) =>
+  AddItemSpec.AddItem({id, name})->S.reverseConvertToJsonOrThrow(AddItemSpec.commandSchema)