@reventlessdev/reventless-local 3.0.0-alpha.115 → 3.0.0-alpha.117

package/tests/adapter/ProjectionCheckpointTest.res.mjs

@@ -0,0 +1,401 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as ProjectionPending$ReventlessLocal from "../../src/adapter/ProjectionPending.res.mjs";
+import * as ProjectionCheckpoint$ReventlessLocal from "../../src/adapter/ProjectionCheckpoint.res.mjs";
+import * as EventLogStorage_Sqlite$ReventlessLocal from "../../src/adapter/EventLog/EventLogStorage_Sqlite.res.mjs";
+import * as DcbEventLogStorage_Sqlite$ReventlessLocal from "../../src/adapter/DcbEventLog/DcbEventLogStorage_Sqlite.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+function makeFreshDb() {
+  return SqliteDriver$ReventlessLocal.openDb(":memory:");
+}
+
+function flatEvent(id, seq, eventType, dataOpt, msgId, serviceOpt) {
+  let data = dataOpt !== undefined ? dataOpt : [];
+  let service = serviceOpt !== undefined ? serviceOpt : "Products";
+  return Object.fromEntries([
+    [
+      "id",
+      id
+    ],
+    [
+      "position",
+      seq.toString().padStart(9, "0")
+    ],
+    [
+      "event",
+      eventType
+    ],
+    [
+      "data",
+      Object.fromEntries(data)
+    ],
+    [
+      "recordedAt",
+      "2026-07-03T00:00:00.000Z"
+    ],
+    [
+      "service",
+      service
+    ],
+    [
+      "time",
+      "2026-07-03T00:00:00.000Z"
+    ],
+    [
+      "msgId",
+      msgId
+    ],
+    [
+      "correlationId",
+      msgId
+    ]
+  ]);
+}
+
+function msgIdOfEnvelope(json) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["meta"]), Stdlib_JSON.Decode.object), m => m["msgId"]), Stdlib_JSON.Decode.string), "<none>");
+}
+
+function makeHandler() {
+  let received = [];
+  let handler = (json, _ctx) => {
+    received.push(json);
+    return Promise.resolve();
+  };
+  return [
+    received,
+    handler
+  ];
+}
+
+function dcbEvent(eventType, tags, dataOpt, msgId) {
+  let data = dataOpt !== undefined ? dataOpt : [];
+  return {
+    eventType: eventType,
+    data: Object.fromEntries(data),
+    tags: tags,
+    meta: {
+      service: "OrderingDcbEventLog",
+      time: "2026-07-03T00:00:00.000Z",
+      msgId: msgId,
+      correlationId: msgId
+    }
+  };
+}
+
+async function makeDcbStorage(db, name) {
+  let match = DcbEventLogStorage_Sqlite$ReventlessLocal.makeStorage(db, name, [], {
+    TAG: "Simple",
+    _0: {
+      key: "k"
+    }
+  }, opts);
+  return await TestRunner$ReventlessLocal.resolve(match[2].operations);
+}
+
+function idOfEnvelope(json) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["id"]), Stdlib_JSON.Decode.string), "<none>");
+}
+
+globalThis.describe("ProjectionCheckpoint", () => {
+  globalThis.describe("pending low-watermark", () => {
+    globalThis.test("out-of-order publish completion cannot advance past a pending earlier append", async () => {
+      ProjectionPending$ReventlessLocal.reset();
+      ProjectionPending$ReventlessLocal.enableTracking();
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+      let DbProvider = {
+        db: db
+      };
+      let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+      let s = Storage.make("agg", opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.append(0, "id-1", [
+        flatEvent("id-1", 0, "Created", undefined, "a1", undefined),
+        flatEvent("id-1", 1, "Renamed", undefined, "a2", undefined)
+      ]);
+      await ops.append(0, "id-2", [flatEvent("id-2", 0, "Created", undefined, "b1", undefined)]);
+      ProjectionCheckpoint$ReventlessLocal.setPosition(db, "RM", 0);
+      ProjectionCheckpoint$ReventlessLocal.completePublished(db, ["b1"]);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "RM")).toBe(0);
+      ProjectionCheckpoint$ReventlessLocal.completePublished(db, [
+        "a1",
+        "a2"
+      ]);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "RM")).toBe(3);
+      return ProjectionPending$ReventlessLocal.reset();
+    });
+    globalThis.test("appendStream batches never enter the pending set", async () => {
+      ProjectionPending$ReventlessLocal.reset();
+      ProjectionPending$ReventlessLocal.enableTracking();
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+      let DbProvider = {
+        db: db
+      };
+      let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+      let s = Storage.make("agg", opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await Effect.runPromise(ops.appendStream(0, "id-bulk", Stream.fromIterable([
+        flatEvent("id-bulk", 0, "Created", undefined, "s1", undefined),
+        flatEvent("id-bulk", 1, "Renamed", undefined, "s2", undefined)
+      ])));
+      globalThis.expect(ProjectionPending$ReventlessLocal.minPending("Aggregate")).toEqual(undefined);
+      ProjectionCheckpoint$ReventlessLocal.setPosition(db, "RM", 0);
+      ProjectionCheckpoint$ReventlessLocal.completePublished(db, []);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "RM")).toBe(2);
+      return ProjectionPending$ReventlessLocal.reset();
+    });
+  });
+  globalThis.describe("catchupEnvelope", () => {
+    globalThis.test("rebuilds the live {id, meta, event} envelope from a stored row", () => {
+      let flat = flatEvent("p-1", 4, "Created", [[
+          "name",
+          "Widget"
+        ]], "m-1", undefined);
+      let envelope = ProjectionCheckpoint$ReventlessLocal.catchupEnvelope(flat);
+      if (envelope !== undefined) {
+        let dict = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(envelope), undefined);
+        globalThis.expect(dict["id"]).toEqual("p-1");
+        globalThis.expect(msgIdOfEnvelope(envelope)).toBe("m-1");
+        globalThis.expect(dict["event"]).toEqual(Object.fromEntries([
+          [
+            "TAG",
+            "Created"
+          ],
+          [
+            "name",
+            "Widget"
+          ]
+        ]));
+        return;
+      }
+      globalThis.expect("envelope").toBe("None");
+    });
+    globalThis.test("payload-less variants come back as a bare JSON string", () => {
+      let flat = flatEvent("p-1", 0, "Deleted", undefined, "m-2", undefined);
+      let event = Stdlib_Option.flatMap(Stdlib_Option.flatMap(ProjectionCheckpoint$ReventlessLocal.catchupEnvelope(flat), Stdlib_JSON.Decode.object), d => d["event"]);
+      globalThis.expect(event).toEqual("Deleted");
+    });
+    globalThis.test("malformed stored rows yield None instead of throwing", () => {
+      let flat = Object.fromEntries([
+        [
+          "id",
+          "p-1"
+        ],
+        [
+          "event",
+          "Created"
+        ]
+      ]);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.catchupEnvelope(flat)).toEqual(undefined);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.catchupEnvelope("junk")).toEqual(undefined);
+    });
+  });
+  globalThis.describe("runCatchup", () => {
+    globalThis.test("delivers the missed range in rowid order, exactly once", async () => {
+      ProjectionPending$ReventlessLocal.reset();
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+      let DbProvider = {
+        db: db
+      };
+      let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+      let s = Storage.make("agg", opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.append(0, "id-1", [flatEvent("id-1", 0, "Created", undefined, "m1", undefined)]);
+      await ops.append(0, "id-2", [flatEvent("id-2", 0, "Created", undefined, "m2", undefined)]);
+      await ops.append(1, "id-1", [flatEvent("id-1", 1, "Renamed", undefined, "m3", undefined)]);
+      let match = makeHandler();
+      let handlerA = match[1];
+      let receivedA = match[0];
+      let match$1 = makeHandler();
+      let handlerB = match$1[1];
+      let receivedB = match$1[0];
+      let upperBound = ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Aggregate");
+      globalThis.expect(upperBound).toBe(3);
+      await ProjectionCheckpoint$ReventlessLocal.runCatchup(db, upperBound, 0, [
+        [
+          "RM-A",
+          handlerA
+        ],
+        [
+          "RM-B",
+          handlerB
+        ]
+      ]);
+      globalThis.expect(receivedA.map(msgIdOfEnvelope)).toEqual([
+        "m1",
+        "m2",
+        "m3"
+      ]);
+      globalThis.expect(receivedB.map(msgIdOfEnvelope)).toEqual([
+        "m1",
+        "m2",
+        "m3"
+      ]);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "RM-A")).toBe(3);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "RM-B")).toBe(3);
+      await ProjectionCheckpoint$ReventlessLocal.runCatchup(db, ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Aggregate"), 0, [
+        [
+          "RM-A",
+          handlerA
+        ],
+        [
+          "RM-B",
+          handlerB
+        ]
+      ]);
+      globalThis.expect(receivedA.length).toBe(3);
+      globalThis.expect(receivedB.length).toBe(3);
+    });
+    globalThis.test("a fresh database still stamps checkpoint rows at 0", async () => {
+      ProjectionPending$ReventlessLocal.reset();
+      let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+      let match = makeHandler();
+      await ProjectionCheckpoint$ReventlessLocal.runCatchup(db, 0, 0, [[
+          "RM-Fresh",
+          match[1]
+        ]]);
+      let stamped = SqliteDriver$ReventlessLocal.get(SqliteDriver$ReventlessLocal.prepare(db, "SELECT COUNT(*) AS c FROM projection_checkpoint WHERE read_model = ?"), ["RM-Fresh"]);
+      globalThis.expect(Stdlib_Option.flatMap(stamped, r => r["c"])).toEqual(1.0);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "RM-Fresh")).toBe(0);
+    });
+    globalThis.test("a read model without a checkpoint row is seeded from history", async () => {
+      ProjectionPending$ReventlessLocal.reset();
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+      let DbProvider = {
+        db: db
+      };
+      let Storage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+      let s = Storage.make("agg", opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.append(0, "id-1", [flatEvent("id-1", 0, "Created", undefined, "m1", undefined)]);
+      let match = makeHandler();
+      let handlerA = match[1];
+      let receivedA = match[0];
+      await ProjectionCheckpoint$ReventlessLocal.runCatchup(db, ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Aggregate"), 0, [[
+          "RM-A",
+          handlerA
+        ]]);
+      globalThis.expect(receivedA.length).toBe(1);
+      let match$1 = makeHandler();
+      await ProjectionCheckpoint$ReventlessLocal.runCatchup(db, ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Aggregate"), 0, [
+        [
+          "RM-A",
+          handlerA
+        ],
+        [
+          "RM-New",
+          match$1[1]
+        ]
+      ]);
+      globalThis.expect(receivedA.length).toBe(1);
+      globalThis.expect(match$1[0].map(msgIdOfEnvelope)).toEqual(["m1"]);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "RM-New")).toBe(1);
+    });
+  });
+  globalThis.describe("DCB axis", () => {
+    globalThis.test("catch-up delivers missed DCB events with the tag-derived entityId, exactly once", async () => {
+      ProjectionPending$ReventlessLocal.reset();
+      let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+      let dcbOps = await makeDcbStorage(db, "OrderingDcbEventLog");
+      await dcbOps.append([dcbEvent("OrderPlaced", [
+          {
+            key: "orderId",
+            value: "o-1"
+          },
+          {
+            key: "productId",
+            value: "p-1"
+          }
+        ], [[
+            "qty",
+            2
+          ]], "d1")], undefined);
+      await dcbOps.append([dcbEvent("MaintenanceRan", [], undefined, "d2")], undefined);
+      let match = makeHandler();
+      let handler = match[1];
+      let received = match[0];
+      await ProjectionCheckpoint$ReventlessLocal.runCatchup(db, 0, ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Dcb"), [[
+          "SV",
+          handler
+        ]]);
+      globalThis.expect(received.map(msgIdOfEnvelope)).toEqual([
+        "d1",
+        "d2"
+      ]);
+      globalThis.expect(received.map(idOfEnvelope)).toEqual([
+        "o-1",
+        "OrderingDcbEventLog"
+      ]);
+      globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(received[0], Stdlib_JSON.Decode.object), d => d["event"])).toEqual(Object.fromEntries([
+        [
+          "TAG",
+          "OrderPlaced"
+        ],
+        [
+          "qty",
+          2
+        ]
+      ]));
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "dcb:SV")).toBe(2);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "SV")).toBe(0);
+      await ProjectionCheckpoint$ReventlessLocal.runCatchup(db, 0, ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Dcb"), [[
+          "SV",
+          handler
+        ]]);
+      globalThis.expect(received.length).toBe(2);
+    });
+    globalThis.test("the two axes' watermarks are independent", async () => {
+      ProjectionPending$ReventlessLocal.reset();
+      ProjectionPending$ReventlessLocal.enableTracking();
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+      let DbProvider = {
+        db: db
+      };
+      let AggStorage = EventLogStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+      let aggS = AggStorage.make("agg", opts);
+      let aggOps = await TestRunner$ReventlessLocal.resolve(aggS.operations);
+      let dcbOps = await makeDcbStorage(db, "dcb-log");
+      await aggOps.append(0, "id-1", [flatEvent("id-1", 0, "Created", undefined, "agg1", undefined)]);
+      await dcbOps.append([dcbEvent("OrderPlaced", [{
+            key: "orderId",
+            value: "o-1"
+          }], undefined, "dcb1")], undefined);
+      ProjectionCheckpoint$ReventlessLocal.setPosition(db, "RM", 0);
+      ProjectionCheckpoint$ReventlessLocal.setPosition(db, "dcb:RM", 0);
+      ProjectionCheckpoint$ReventlessLocal.completePublished(db, ["dcb1"]);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "dcb:RM")).toBe(1);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "RM")).toBe(0);
+      ProjectionCheckpoint$ReventlessLocal.completePublished(db, ["agg1"]);
+      globalThis.expect(ProjectionCheckpoint$ReventlessLocal.getPosition(db, "RM")).toBe(1);
+      return ProjectionPending$ReventlessLocal.reset();
+    });
+  });
+});
+
+export {
+  opts,
+  makeFreshDb,
+  flatEvent,
+  msgIdOfEnvelope,
+  makeHandler,
+  dcbEvent,
+  makeDcbStorage,
+  idOfEnvelope,
+}
+/*  Not a pure module */

package/tests/adapter/QueryDbGsiTtlTest.res

@@ -147,6 +147,84 @@ describe("QueryDbStorage_Sqlite — GSI", () => {
   })
 })
 
+describe("QueryDb — indexed equality lookup (B4 push-down)", () => {
+  let byOwner: Reventless.ReadModel.indexConfig = {
+    index: "ByOwner",
+    type_: "S",
+    idField: "ownerId",
+    projectionType: ALL,
+  }
+  let item = (owner: string) => {
+    let o = Dict.make()
+    o->Dict.set("ownerId", JSON.Encode.string(owner))
+    JSON.Encode.object(o)
+  }
+
+  testPromise("sqlite lookup returns only rows whose indexed field matches", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = openFreshDb()
+    }
+    module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
+    let s = Storage.make(~name="orders", ~indexes=[byOwner], ~api=(), ~apiRole=(), ~opts)
+    let ops = await s.operations->TestRunner.resolve
+    let _ = await ops.save("k1", item("o1"), ReventlessCore.QueryDb.Any, None)
+    let _ = await ops.save("k2", item("o2"), ReventlessCore.QueryDb.Any, None)
+    let _ = await ops.save("k3", item("o1"), ReventlessCore.QueryDb.Any, None)
+
+    let lookup = TestBus.getQueryDbIndexLookup("orders")->Option.getOrThrow
+    expect(lookup("ownerId", "o1")->Array.length)->toBe(2)
+    expect(lookup("ownerId", "o2")->Array.length)->toBe(1)
+    expect(lookup("ownerId", "absent")->Array.length)->toBe(0)
+  })
+
+  testPromise("sqlite lookup excludes expired rows", async () => {
+    module TestBus = LocalBus.Make()
+    module DbProvider = {
+      let db = openFreshDb()
+    }
+    module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
+    let s = Storage.make(~name="orders", ~indexes=[byOwner], ~api=(), ~apiRole=(), ~opts)
+    let ops = await s.operations->TestRunner.resolve
+    let aMinuteAgo = Float.toInt(Date.now() /. 1000.0) - 60
+    let _ = await ops.save("k1", item("o1"), ReventlessCore.QueryDb.Any, None)
+    let _ = await ops.save("k2", item("o1"), ReventlessCore.QueryDb.Any, Some(aMinuteAgo))
+    let lookup = TestBus.getQueryDbIndexLookup("orders")->Option.getOrThrow
+    expect(lookup("ownerId", "o1")->Array.length)->toBe(1)
+  })
+
+  testPromise("in-memory lookup matches the sqlite result (backend parity)", async () => {
+    module TestBus = LocalBus.Make()
+    module Storage = QueryDbStorage_InMemory.Make(TestBus)
+    let s = Storage.makeMemory(~name="orders", ~indexes=[byOwner], ~api=(), ~apiRole=(), ~opts)
+    let ops = await s.operations->TestRunner.resolve
+    let _ = await ops.save("k1", item("o1"), ReventlessCore.QueryDb.Any, None)
+    let _ = await ops.save("k2", item("o2"), ReventlessCore.QueryDb.Any, None)
+    let _ = await ops.save("k3", item("o1"), ReventlessCore.QueryDb.Any, None)
+    let lookup = TestBus.getQueryDbIndexLookup("orders")->Option.getOrThrow
+    expect(lookup("ownerId", "o1")->Array.length)->toBe(2)
+    expect(lookup("ownerId", "o2")->Array.length)->toBe(1)
+    expect(lookup("ownerId", "absent")->Array.length)->toBe(0)
+  })
+})
+
+describe("QueryDbStorage_InMemory — lazy scan snapshot (B4 dirty-flag)", () => {
+  testPromise("interleaved save/scan reflects each write without stale reads", async () => {
+    module TestBus = LocalBus.Make()
+    module Storage = QueryDbStorage_InMemory.Make(TestBus)
+    let s = Storage.make(~name="lazy", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+    let ops = await s.operations->TestRunner.resolve
+    let scanFn = TestBus.getQueryDbScan("lazy")->Option.getOrThrow
+    expect(scanFn()->Array.length)->toBe(0)
+    let _ = await ops.save("a", JSON.Encode.string("va"), ReventlessCore.QueryDb.Any, None)
+    expect(scanFn()->Array.length)->toBe(1)
+    let _ = await ops.save("b", JSON.Encode.string("vb"), ReventlessCore.QueryDb.Any, None)
+    expect(scanFn()->Array.length)->toBe(2)
+    let _ = await ops.delete("a", None)
+    expect(scanFn()->Array.length)->toBe(1)
+  })
+})
+
 describe("QueryDbStorage_Sqlite — TTL", () => {
   testPromise("save with TTL in the future returns the item", async () => {
     module TestBus = LocalBus.Make()

package/tests/adapter/QueryDbGsiTtlTest.res.mjs

@@ -7,6 +7,7 @@ import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
 import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
 import * as QueryDbStorage_Sqlite$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbStorage_Sqlite.res.mjs";
+import * as QueryDbStorage_InMemory$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbStorage_InMemory.res.mjs";
 
 TestRunner$ReventlessLocal.setup();
 
@@ -120,6 +121,82 @@ globalThis.describe("QueryDbStorage_Sqlite — GSI", () => {
   });
 });
 
+globalThis.describe("QueryDb — indexed equality lookup (B4 push-down)", () => {
+  let byOwner = {
+    index: "ByOwner",
+    type_: "S",
+    idField: "ownerId",
+    projectionType: "ALL"
+  };
+  let item = owner => {
+    let o = {};
+    o["ownerId"] = owner;
+    return o;
+  };
+  globalThis.test("sqlite lookup returns only rows whose indexed field matches", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("orders", [byOwner], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    await ops.save("k1", item("o1"), "Any", undefined);
+    await ops.save("k2", item("o2"), "Any", undefined);
+    await ops.save("k3", item("o1"), "Any", undefined);
+    let lookup = Stdlib_Option.getOrThrow(TestBus.getQueryDbIndexLookup("orders"), undefined);
+    globalThis.expect(lookup("ownerId", "o1").length).toBe(2);
+    globalThis.expect(lookup("ownerId", "o2").length).toBe(1);
+    globalThis.expect(lookup("ownerId", "absent").length).toBe(0);
+  });
+  globalThis.test("sqlite lookup excludes expired rows", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("orders", [byOwner], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let aMinuteAgo = (Date.now() / 1000.0 | 0) - 60 | 0;
+    await ops.save("k1", item("o1"), "Any", undefined);
+    await ops.save("k2", item("o1"), "Any", aMinuteAgo);
+    let lookup = Stdlib_Option.getOrThrow(TestBus.getQueryDbIndexLookup("orders"), undefined);
+    globalThis.expect(lookup("ownerId", "o1").length).toBe(1);
+  });
+  globalThis.test("in-memory lookup matches the sqlite result (backend parity)", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let s = Storage.makeMemory("orders", [byOwner], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    await ops.save("k1", item("o1"), "Any", undefined);
+    await ops.save("k2", item("o2"), "Any", undefined);
+    await ops.save("k3", item("o1"), "Any", undefined);
+    let lookup = Stdlib_Option.getOrThrow(TestBus.getQueryDbIndexLookup("orders"), undefined);
+    globalThis.expect(lookup("ownerId", "o1").length).toBe(2);
+    globalThis.expect(lookup("ownerId", "o2").length).toBe(1);
+    globalThis.expect(lookup("ownerId", "absent").length).toBe(0);
+  });
+});
+
+globalThis.describe("QueryDbStorage_InMemory — lazy scan snapshot (B4 dirty-flag)", () => {
+  globalThis.test("interleaved save/scan reflects each write without stale reads", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+    let s = Storage.make("lazy", [], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    let scanFn = Stdlib_Option.getOrThrow(TestBus.getQueryDbScan("lazy"), undefined);
+    globalThis.expect(scanFn().length).toBe(0);
+    await ops.save("a", "va", "Any", undefined);
+    globalThis.expect(scanFn().length).toBe(1);
+    await ops.save("b", "vb", "Any", undefined);
+    globalThis.expect(scanFn().length).toBe(2);
+    await ops.delete("a", undefined);
+    globalThis.expect(scanFn().length).toBe(1);
+  });
+});
+
 globalThis.describe("QueryDbStorage_Sqlite — TTL", () => {
   globalThis.test("save with TTL in the future returns the item", async () => {
     let TestBus = LocalBus$ReventlessLocal.Make({});