@reventlessdev/reventless-local 3.0.0-alpha.249 → 3.0.0-alpha.251

package/tests/adapter/EventCollectorChannelTest.res

@@ -18,9 +18,9 @@ let testMeta: Reventless.Message.meta = {
 // Helper: build a minimal runtime with a completed handler Deferred
 // ─────────────────────────────────────────────────────────────
 
-let makeRuntime = (
-  handler: LocalRuntimeEnvironment.handler,
-): ReventlessCore.Runtime.environment<LocalRuntimeEnvironment.parts> => {
+let makeRuntime = (handler: LocalRuntimeEnvironment.handler): ReventlessCore.Runtime.environment<
+  LocalRuntimeEnvironment.parts,
+> => {
   let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
     Deferred.make()->Effect.runSync
   Deferred.succeed(handlerDeferred, handler)->Effect.runSync->ignore
@@ -35,132 +35,161 @@ let makeRuntime = (
 
 describe("LocalEventCollectorChannel", () => {
   describe("make", () => {
-    testPromise("collects all event topic resources as channel resources", async () => {
-      module TestBus = LocalBus.Make()
-      module TestPublisher = LocalEventTopicPublisher.Make(TestBus)
-      module TestCollector = LocalEventCollectorChannel.Make(TestBus)
-      let pubA = TestPublisher.make(~name="topicA", ~storageResources=[], ~owner=None, ~opts={})
-      let pubB = TestPublisher.make(~name="topicB", ~storageResources=[], ~owner=None, ~opts={})
-      let eventTopics = Dict.fromArray([
-        ("topicA", {ReventlessInfra.EventTopic.resources: pubA.resources}),
-        ("topicB", {ReventlessInfra.EventTopic.resources: pubB.resources}),
-      ])
-      let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
-      // Each publisher returns 1 resource, so 2 total
-      expect(ch.resources->Array.length)->toBe(2)
-    })
+    testPromise(
+      "collects all event topic resources as channel resources",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestPublisher = LocalEventTopicPublisher.Make(TestBus)
+        module TestCollector = LocalEventCollectorChannel.Make(TestBus)
+        let pubA = TestPublisher.make(~name="topicA", ~storageResources=[], ~owner=None, ~opts={})
+        let pubB = TestPublisher.make(~name="topicB", ~storageResources=[], ~owner=None, ~opts={})
+        let eventTopics = Dict.fromArray([
+          ("topicA", {ReventlessInfra.EventTopic.resources: pubA.resources}),
+          ("topicB", {ReventlessInfra.EventTopic.resources: pubB.resources}),
+        ])
+        let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
+        // Each publisher returns 1 resource, so 2 total
+        expect(ch.resources->Array.length)->toBe(2)
+      },
+    )
 
-    testPromise("empty eventTopics produces empty resources", async () => {
-      module TestBus = LocalBus.Make()
-      module TestCollector = LocalEventCollectorChannel.Make(TestBus)
-      let ch = TestCollector.make(~name="collector", ~eventTopics=Dict.make(), ~owner=None, ~opts={})
-      expect(ch.resources->Array.length)->toBe(0)
-    })
+    testPromise(
+      "empty eventTopics produces empty resources",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestCollector = LocalEventCollectorChannel.Make(TestBus)
+        let ch = TestCollector.make(
+          ~name="collector",
+          ~eventTopics=Dict.make(),
+          ~owner=None,
+          ~opts={},
+        )
+        expect(ch.resources->Array.length)->toBe(0)
+      },
+    )
   })
 
   describe("connect", () => {
-    testPromise("subscribes to event topic; published events reach the handler", async () => {
-      module TestBus = LocalBus.Make()
-      module TestPublisher = LocalEventTopicPublisher.Make(TestBus)
-      module TestCollector = LocalEventCollectorChannel.Make(TestBus)
-      let received: ref<int> = ref(0)
-      let runtime = makeRuntime(async (_, _ctx) => {
-        received := received.contents + 1
-      })
-      let pub = TestPublisher.make(~name="eventA", ~storageResources=[], ~owner=None, ~opts={})
-      let eventTopics = Dict.fromArray([
-        ("eventA", {ReventlessInfra.EventTopic.resources: pub.resources}),
-      ])
-      let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
-      let channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<JSON.t, unit, unit> = {
-        channel: ch,
-        eventTopics,
-        resources: [],
-      }
-      let _ = TestCollector.connect(
-        ~name="collector",
-        ~channelSpecs=[channelSpec],
-        ~runtime,
-        ~opts={},
-      )
-      // Await the subscriptionLatch — opens after Output.apply fires and subscription registers
-      await runtime.parts.subscriptionLatch->Latch.await_->Effect.runPromise
-      let publishFn = await pub.publishJson->TestRunner.resolve
-      await publishFn("svc", testMeta, JSON.Null)
-      expect(received.contents)->toBe(1)
-    })
+    testPromise(
+      "subscribes to event topic; published events reach the handler",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestPublisher = LocalEventTopicPublisher.Make(TestBus)
+        module TestCollector = LocalEventCollectorChannel.Make(TestBus)
+        let received: ref<int> = ref(0)
+        let runtime = makeRuntime(
+          async (_, _ctx) => {
+            received := received.contents + 1
+          },
+        )
+        let pub = TestPublisher.make(~name="eventA", ~storageResources=[], ~owner=None, ~opts={})
+        let eventTopics = Dict.fromArray([
+          ("eventA", {ReventlessInfra.EventTopic.resources: pub.resources}),
+        ])
+        let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
+        let channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<JSON.t, unit, unit> = {
+          channel: ch,
+          eventTopics,
+          resources: [],
+        }
+        let _ = TestCollector.connect(
+          ~name="collector",
+          ~channelSpecs=[channelSpec],
+          ~runtime,
+          ~opts={},
+        )
+        // Await the subscriptionLatch — opens after Output.apply fires and subscription registers
+        await runtime.parts.subscriptionLatch->Latch.await_->Effect.runPromise
+        let publishFn = await pub.publishJson->TestRunner.resolve
+        await publishFn("svc", testMeta, JSON.Null)
+        expect(received.contents)->toBe(1)
+      },
+    )
 
-    testPromise("multiple event topics all deliver to the same handler", async () => {
-      module TestBus = LocalBus.Make()
-      module TestPublisher = LocalEventTopicPublisher.Make(TestBus)
-      module TestCollector = LocalEventCollectorChannel.Make(TestBus)
-      let received: ref<int> = ref(0)
-      let runtime = makeRuntime(async (_, _) => {
-        received := received.contents + 1
-      })
-      let pub1 = TestPublisher.make(~name="topicX", ~storageResources=[], ~owner=None, ~opts={})
-      let pub2 = TestPublisher.make(~name="topicY", ~storageResources=[], ~owner=None, ~opts={})
-      let eventTopics = Dict.fromArray([
-        ("topicX", {ReventlessInfra.EventTopic.resources: pub1.resources}),
-        ("topicY", {ReventlessInfra.EventTopic.resources: pub2.resources}),
-      ])
-      let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
-      let channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<JSON.t, unit, unit> = {
-        channel: ch,
-        eventTopics,
-        resources: [],
-      }
-      let _ = TestCollector.connect(
-        ~name="collector",
-        ~channelSpecs=[channelSpec],
-        ~runtime,
-        ~opts={},
-      )
-      // Wait for both subscriptions via the publish functions (each Output resolves per-topic)
-      let pub1Fn = await pub1.publishJson->TestRunner.resolve
-      let pub2Fn = await pub2.publishJson->TestRunner.resolve
-      await pub1Fn("svc", testMeta, JSON.Null)
-      await pub2Fn("svc", testMeta, JSON.Null)
-      expect(received.contents)->toBe(2)
-    })
+    testPromise(
+      "multiple event topics all deliver to the same handler",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestPublisher = LocalEventTopicPublisher.Make(TestBus)
+        module TestCollector = LocalEventCollectorChannel.Make(TestBus)
+        let received: ref<int> = ref(0)
+        let runtime = makeRuntime(
+          async (_, _) => {
+            received := received.contents + 1
+          },
+        )
+        let pub1 = TestPublisher.make(~name="topicX", ~storageResources=[], ~owner=None, ~opts={})
+        let pub2 = TestPublisher.make(~name="topicY", ~storageResources=[], ~owner=None, ~opts={})
+        let eventTopics = Dict.fromArray([
+          ("topicX", {ReventlessInfra.EventTopic.resources: pub1.resources}),
+          ("topicY", {ReventlessInfra.EventTopic.resources: pub2.resources}),
+        ])
+        let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
+        let channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<JSON.t, unit, unit> = {
+          channel: ch,
+          eventTopics,
+          resources: [],
+        }
+        let _ = TestCollector.connect(
+          ~name="collector",
+          ~channelSpecs=[channelSpec],
+          ~runtime,
+          ~opts={},
+        )
+        // Wait for both subscriptions via the publish functions (each Output resolves per-topic)
+        let pub1Fn = await pub1.publishJson->TestRunner.resolve
+        let pub2Fn = await pub2.publishJson->TestRunner.resolve
+        await pub1Fn("svc", testMeta, JSON.Null)
+        await pub2Fn("svc", testMeta, JSON.Null)
+        expect(received.contents)->toBe(2)
+      },
+    )
 
-    testPromise("unresolved Deferred does not crash on event delivery", async () => {
-      module TestBus = LocalBus.Make()
-      module TestPublisher = LocalEventTopicPublisher.Make(TestBus)
-      module TestCollector = LocalEventCollectorChannel.Make(TestBus)
-      // Deferred left incomplete — bus callback starts a pending Effect (no crash)
-      let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
-        Deferred.make()->Effect.runSync
-      let runtime: ReventlessCore.Runtime.environment<LocalRuntimeEnvironment.parts> = {
-        parts: {
-          handlerDeferred,
-          subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
-        },
-        resources: [],
-      }
-      let pub = TestPublisher.make(~name="noHandlerTopic", ~storageResources=[], ~owner=None, ~opts={})
-      let eventTopics = Dict.fromArray([
-        ("noHandlerTopic", {ReventlessInfra.EventTopic.resources: pub.resources}),
-      ])
-      let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
-      let channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<JSON.t, unit, unit> = {
-        channel: ch,
-        eventTopics,
-        resources: [],
-      }
-      let _ = TestCollector.connect(
-        ~name="collector",
-        ~channelSpecs=[channelSpec],
-        ~runtime,
-        ~opts={},
-      )
-      await runtime.parts.subscriptionLatch->Latch.await_->Effect.runPromise
-      let publishFn = await pub.publishJson->TestRunner.resolve
-      // Fire-and-forget — the Deferred.await_ will stay pending
-      publishFn("svc", testMeta, JSON.Null)->ignore
-      expect(true)->toBe(true)
-      // Complete the Deferred to avoid open handle
-      Deferred.succeed(handlerDeferred, async (_, _) => ())->Effect.runSync->ignore
-    })
+    testPromise(
+      "unresolved Deferred does not crash on event delivery",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module TestPublisher = LocalEventTopicPublisher.Make(TestBus)
+        module TestCollector = LocalEventCollectorChannel.Make(TestBus)
+        // Deferred left incomplete — bus callback starts a pending Effect (no crash)
+        let handlerDeferred: Deferred.t<LocalRuntimeEnvironment.handler, unit> =
+          Deferred.make()->Effect.runSync
+        let runtime: ReventlessCore.Runtime.environment<LocalRuntimeEnvironment.parts> = {
+          parts: {
+            handlerDeferred,
+            subscriptionLatch: Effect.makeLatch(false)->Effect.runSync,
+          },
+          resources: [],
+        }
+        let pub = TestPublisher.make(
+          ~name="noHandlerTopic",
+          ~storageResources=[],
+          ~owner=None,
+          ~opts={},
+        )
+        let eventTopics = Dict.fromArray([
+          ("noHandlerTopic", {ReventlessInfra.EventTopic.resources: pub.resources}),
+        ])
+        let ch = TestCollector.make(~name="collector", ~eventTopics, ~owner=None, ~opts={})
+        let channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<JSON.t, unit, unit> = {
+          channel: ch,
+          eventTopics,
+          resources: [],
+        }
+        let _ = TestCollector.connect(
+          ~name="collector",
+          ~channelSpecs=[channelSpec],
+          ~runtime,
+          ~opts={},
+        )
+        await runtime.parts.subscriptionLatch->Latch.await_->Effect.runPromise
+        let publishFn = await pub.publishJson->TestRunner.resolve
+        // Fire-and-forget — the Deferred.await_ will stay pending
+        publishFn("svc", testMeta, JSON.Null)->ignore
+        expect(true)->toBe(true)
+        // Complete the Deferred to avoid open handle
+        Deferred.succeed(handlerDeferred, async (_, _) => ())->Effect.runSync->ignore
+      },
+    )
   })
 })

package/tests/adapter/EventHistoryResolverTest.res

@@ -18,7 +18,14 @@ let metaOf = (~user=?, ~time="2026-01-01T00:00:00Z", ()) =>
     ("causationId", JSON.Encode.null),
   ])->JSON.Encode.object
 
-let rec_ = (~position, ~eventType="OrderPlaced", ~tags=[], ~user=?, ~time="2026-01-01T00:00:00Z", ()): EH.record => {
+let rec_ = (
+  ~position,
+  ~eventType="OrderPlaced",
+  ~tags=[],
+  ~user=?,
+  ~time="2026-01-01T00:00:00Z",
+  (),
+): EH.record => {
   position,
   eventType,
   payload: JSON.Encode.object(Dict.make()),
@@ -86,9 +93,8 @@ describe("EventHistoryResolvers_GraphQL — position ordering", () => {
   })
 
   testSync("a cursor bound crossing a digit boundary skips nothing", () => {
-    let records = Array.make(~length=12, 0)->Array.mapWithIndex((_, i) =>
-      rec_(~position=i->Int.toString, ())
-    )
+    let records =
+      Array.make(~length=12, 0)->Array.mapWithIndex((_, i) => rec_(~position=i->Int.toString, ()))
     // Page 1 ends at position 9; page 2 must start at 10, not at 1.
     let page1 = EH.paginate(~records, ~args=args(~first=10, ()))
     expect(page1->positionsOf->Array.length)->toBe(10)
@@ -101,9 +107,30 @@ describe("EventHistoryResolvers_GraphQL — position ordering", () => {
 
 describe("EventHistoryResolvers_GraphQL — filtering", () => {
   let records = [
-    rec_(~position="1", ~eventType="OrderPlaced", ~tags=[tag("orderId", "o-1")], ~user="alice", ~time="2026-01-01T00:00:00Z", ()),
-    rec_(~position="2", ~eventType="OrderShipped", ~tags=[tag("orderId", "o-1")], ~user="bob", ~time="2026-01-05T00:00:00Z", ()),
-    rec_(~position="3", ~eventType="OrderPlaced", ~tags=[tag("orderId", "o-2")], ~user="alice", ~time="2026-01-09T00:00:00Z", ()),
+    rec_(
+      ~position="1",
+      ~eventType="OrderPlaced",
+      ~tags=[tag("orderId", "o-1")],
+      ~user="alice",
+      ~time="2026-01-01T00:00:00Z",
+      (),
+    ),
+    rec_(
+      ~position="2",
+      ~eventType="OrderShipped",
+      ~tags=[tag("orderId", "o-1")],
+      ~user="bob",
+      ~time="2026-01-05T00:00:00Z",
+      (),
+    ),
+    rec_(
+      ~position="3",
+      ~eventType="OrderPlaced",
+      ~tags=[tag("orderId", "o-2")],
+      ~user="alice",
+      ~time="2026-01-09T00:00:00Z",
+      (),
+    ),
   ]
   let filtered = f => records->Array.filter(r => EH.matchesFilter(r, f))->Array.map(r => r.position)
 
@@ -129,9 +156,9 @@ describe("EventHistoryResolvers_GraphQL — filtering", () => {
   testSync("time range is inclusive on both bounds", () => {
     expect(filtered({timeFrom: "2026-01-05T00:00:00Z"}))->toEqual(["2", "3"])
     expect(filtered({timeTo: "2026-01-05T00:00:00Z"}))->toEqual(["1", "2"])
-    expect(
-      filtered({timeFrom: "2026-01-05T00:00:00Z", timeTo: "2026-01-05T00:00:00Z"}),
-    )->toEqual(["2"])
+    expect(filtered({timeFrom: "2026-01-05T00:00:00Z", timeTo: "2026-01-05T00:00:00Z"}))->toEqual([
+      "2",
+    ])
   })
 
   testSync("an empty filter keeps everything", () => {
@@ -154,10 +181,7 @@ describe("EventHistoryResolvers_GraphQL — argument decoding", () => {
               ("entityId", JSON.Encode.string("o-1")),
               ("tagKey", JSON.Encode.string("orderId")),
               ("tagValue", JSON.Encode.string("o-1")),
-              (
-                "eventTypes",
-                [JSON.Encode.string("OrderPlaced")]->JSON.Encode.array,
-              ),
+              ("eventTypes", [JSON.Encode.string("OrderPlaced")]->JSON.Encode.array),
               ("user", JSON.Encode.string("alice")),
               ("timeFrom", JSON.Encode.string("2026-01-01")),
               ("timeTo", JSON.Encode.string("2026-02-01")),
@@ -183,9 +207,10 @@ describe("EventHistoryResolvers_GraphQL — argument decoding", () => {
 })
 
 describe("EventHistoryResolvers_GraphQL — pagination", () => {
-  let records = Array.make(~length=5, 0)->Array.mapWithIndex((_, i) =>
-    rec_(~position=(i + 1)->Int.toString, ())
-  )
+  let records =
+    Array.make(~length=5, 0)->Array.mapWithIndex((_, i) =>
+      rec_(~position=(i + 1)->Int.toString, ())
+    )
 
   testSync("forward paging reports hasNextPage until exhausted", () => {
     let page = EH.paginate(~records, ~args=args(~first=2, ()))
@@ -242,7 +267,10 @@ describe("EventHistoryResolvers_GraphQL — naming the caller", () => {
 
   testSync("say so when the caller sent no filter at all", () =>
     expect(
-      EH.describeCaller(~ctx=ctxOf(~operationName="AuditTrail", ~userId="local-admin", ()), ~filter={}),
+      EH.describeCaller(
+        ~ctx=ctxOf(~operationName="AuditTrail", ~userId="local-admin", ()),
+        ~filter={},
+      ),
     )->toBe(`operation "AuditTrail" as local-admin, with no filter`)
   )
 

package/tests/adapter/EventLogSnapshotParityTest.res

@@ -28,54 +28,66 @@ let backends = [("memory", makeMemoryOps), ("sqlite", makeSqliteOps)]
 
 describe("EventLog snapshot backend parity", () => {
   backends->Array.forEach(((label, makeOps)) => {
-    testPromise(`${label}: latestSnapshot is None before any write`, async () => {
-      let ops = await makeOps()
-      expect(await ops.latestSnapshot("id-1"))->toEqual(Ok(None))
-    })
+    testPromise(
+      `${label}: latestSnapshot is None before any write`,
+      async () => {
+        let ops = await makeOps()
+        expect(await ops.latestSnapshot("id-1"))->toEqual(Ok(None))
+      },
+    )
 
-    testPromise(`${label}: snapshot round-trips and keep-one overwrites`, async () => {
-      let ops = await makeOps()
-      let state = JSON.Encode.object(Dict.fromArray([("n", JSON.Encode.int(1))]))
-      expect(
-        await ops.writeSnapshot(
+    testPromise(
+      `${label}: snapshot round-trips and keep-one overwrites`,
+      async () => {
+        let ops = await makeOps()
+        let state = JSON.Encode.object(Dict.fromArray([("n", JSON.Encode.int(1))]))
+        expect(
+          await ops.writeSnapshot(
+            "id-1",
+            {ReventlessCore.EventLog.seqNr: 2, state, schemaHash: "h1"},
+          ),
+        )->toEqual(Ok())
+        expect(await ops.latestSnapshot("id-1"))->toEqual(
+          Ok(Some({ReventlessCore.EventLog.seqNr: 2, state, schemaHash: "h1"})),
+        )
+        let state2 = JSON.Encode.object(Dict.fromArray([("n", JSON.Encode.int(9))]))
+        let _ = await ops.writeSnapshot(
           "id-1",
-          {ReventlessCore.EventLog.seqNr: 2, state, schemaHash: "h1"},
-        ),
-      )->toEqual(Ok())
-      expect(await ops.latestSnapshot("id-1"))->toEqual(
-        Ok(Some({ReventlessCore.EventLog.seqNr: 2, state, schemaHash: "h1"})),
-      )
-      let state2 = JSON.Encode.object(Dict.fromArray([("n", JSON.Encode.int(9))]))
-      let _ = await ops.writeSnapshot(
-        "id-1",
-        {ReventlessCore.EventLog.seqNr: 9, state: state2, schemaHash: "h2"},
-      )
-      expect(await ops.latestSnapshot("id-1"))->toEqual(
-        Ok(Some({ReventlessCore.EventLog.seqNr: 9, state: state2, schemaHash: "h2"})),
-      )
-    })
+          {ReventlessCore.EventLog.seqNr: 9, state: state2, schemaHash: "h2"},
+        )
+        expect(await ops.latestSnapshot("id-1"))->toEqual(
+          Ok(Some({ReventlessCore.EventLog.seqNr: 9, state: state2, schemaHash: "h2"})),
+        )
+      },
+    )
 
-    testPromise(`${label}: snapshots are per-aggregate-id`, async () => {
-      let ops = await makeOps()
-      let state = JSON.Encode.object(Dict.fromArray([("n", JSON.Encode.int(1))]))
-      let _ = await ops.writeSnapshot(
-        "id-a",
-        {ReventlessCore.EventLog.seqNr: 1, state, schemaHash: "h"},
-      )
-      expect(await ops.latestSnapshot("id-b"))->toEqual(Ok(None))
-    })
+    testPromise(
+      `${label}: snapshots are per-aggregate-id`,
+      async () => {
+        let ops = await makeOps()
+        let state = JSON.Encode.object(Dict.fromArray([("n", JSON.Encode.int(1))]))
+        let _ = await ops.writeSnapshot(
+          "id-a",
+          {ReventlessCore.EventLog.seqNr: 1, state, schemaHash: "h"},
+        )
+        expect(await ops.latestSnapshot("id-b"))->toEqual(Ok(None))
+      },
+    )
 
-    testPromise(`${label}: replayStream ~fromSeq equals the tail of a full replay`, async () => {
-      let ops = await makeOps()
-      let ev = i => JSON.Encode.object(Dict.fromArray([("i", JSON.Encode.int(i))]))
-      let _ = await ops.append(0, "id-1", [ev(0), ev(1), ev(2), ev(3), ev(4)])
-      let delta = await ops.replayStream("id-1", ~fromSeq=3)->Stream.runCollect->Effect.runPromise
-      expect(delta)->toEqual([ev(3), ev(4)])
-      // fromSeq at the head yields nothing; omitted fromSeq yields everything.
-      let empty = await ops.replayStream("id-1", ~fromSeq=5)->Stream.runCollect->Effect.runPromise
-      expect(empty)->toEqual([])
-      let full = await ops.replayStream("id-1")->Stream.runCollect->Effect.runPromise
-      expect(full->Array.length)->toBe(5)
-    })
+    testPromise(
+      `${label}: replayStream ~fromSeq equals the tail of a full replay`,
+      async () => {
+        let ops = await makeOps()
+        let ev = i => JSON.Encode.object(Dict.fromArray([("i", JSON.Encode.int(i))]))
+        let _ = await ops.append(0, "id-1", [ev(0), ev(1), ev(2), ev(3), ev(4)])
+        let delta = await ops.replayStream("id-1", ~fromSeq=3)->Stream.runCollect->Effect.runPromise
+        expect(delta)->toEqual([ev(3), ev(4)])
+        // fromSeq at the head yields nothing; omitted fromSeq yields everything.
+        let empty = await ops.replayStream("id-1", ~fromSeq=5)->Stream.runCollect->Effect.runPromise
+        expect(empty)->toEqual([])
+        let full = await ops.replayStream("id-1")->Stream.runCollect->Effect.runPromise
+        expect(full->Array.length)->toBe(5)
+      },
+    )
   })
 })

package/tests/adapter/EventLogStorageSqliteTest.res

@@ -19,12 +19,8 @@ describe("EventLogStorage_Sqlite", () => {
     let s = Storage.make(~name="agg", ~owner=None, ~opts)
     let ops = await s.operations->TestRunner.resolve
 
-    let event1 = JSON.Encode.object(
-      Dict.fromArray([("tag", JSON.Encode.string("Created"))]),
-    )
-    let event2 = JSON.Encode.object(
-      Dict.fromArray([("tag", JSON.Encode.string("Renamed"))]),
-    )
+    let event1 = JSON.Encode.object(Dict.fromArray([("tag", JSON.Encode.string("Created"))]))
+    let event2 = JSON.Encode.object(Dict.fromArray([("tag", JSON.Encode.string("Renamed"))]))
 
     let r1 = await ops.append(0, "id-1", [event1])
     expect(r1)->toEqual(Ok())
@@ -98,9 +94,11 @@ describe("EventLogStorage_Sqlite", () => {
     let ev = i => JSON.Encode.object(Dict.fromArray([("i", JSON.Encode.int(i))]))
     // Seed one event, then stream three more starting at seq 1.
     let _ = await ops.append(0, "id-s", [ev(0)])
-    let _ =
-      await ops.appendStream(1, "id-s", Stream.fromIterable([ev(1), ev(2), ev(3)]))
-      ->Effect.runPromise
+    let _ = await ops.appendStream(
+      1,
+      "id-s",
+      Stream.fromIterable([ev(1), ev(2), ev(3)]),
+    )->Effect.runPromise
     let replayed = await ops.replay("id-s")
     expect(replayed->Array.length)->toBe(4)
     expect(replayed->Array.getUnsafe(0))->toEqual(ev(0))
@@ -206,8 +204,9 @@ describe("EventLogStorage_Sqlite", () => {
   testPromise("events persist across a reopen of the database file", async () => {
     let path = `/tmp/reventless-test-eventlog-${Float.toString(Date.now())}.db`
 
-    // Session 1: write
     {
+      // Session 1: write
+
       module TestBus = LocalBus.Make()
       module DbProvider = {
         let db = SqliteDriver.openDb(~path)