@reventlessdev/reventless-local 3.0.0-alpha.114 → 3.0.0-alpha.116

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res.mjs

@@ -4,8 +4,10 @@ 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 Stream from "effect/Stream";
 import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as LocalBus$ReventlessLocal from "../LocalBus.res.mjs";
 import * as SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
+import * as QueryDbListQuery$ReventlessLocal from "./QueryDbListQuery.res.mjs";
 
 function tableName(name) {
   return "qdb_" + name.replaceAll("-", "_");
@@ -146,12 +148,27 @@ function makeStorage(db, bus, name, indexes, subIdField) {
   let deleteBySubKeyStmt = SqliteDriver$ReventlessLocal.prepare(db, `DELETE FROM ` + table + ` WHERE partition_key = ? AND sub_key = ?`);
   let scanAllStmt = SqliteDriver$ReventlessLocal.prepare(db, `SELECT partition_key, sub_key, item FROM ` + table + ` WHERE ` + notExpiredClause + ` ORDER BY partition_key, sub_key`);
   let rowsFor = id => SqliteDriver$ReventlessLocal.all(selectByPartitionStmt, [id]).map(decodeItem);
-  let allRows = () => SqliteDriver$ReventlessLocal.all(scanAllStmt, []).map(row => {
+  let rowToItem = row => {
     let item = decodeItem(row);
     let match = row["partition_key"];
     let partition = typeof match === "string" ? match : "";
     return withId(item, partition);
-  });
+  };
+  let allRows = () => SqliteDriver$ReventlessLocal.all(scanAllStmt, []).map(rowToItem);
+  let indexLookupStmts = {};
+  let lookupByField = (field, value) => {
+    let s = indexLookupStmts[field];
+    let stmt;
+    if (s !== undefined) {
+      stmt = Primitive_option.valFromOption(s);
+    } else {
+      let escapedField = field.replaceAll("'", "''");
+      let s$1 = SqliteDriver$ReventlessLocal.prepare(db, `SELECT partition_key, sub_key, item FROM ` + table + ` WHERE json_extract(item, '$.` + escapedField + `') = ? AND ` + notExpiredClause);
+      indexLookupStmts[field] = s$1;
+      stmt = s$1;
+    }
+    return SqliteDriver$ReventlessLocal.all(stmt, [value]).map(rowToItem);
+  };
   let saveOne = (id, state, ttl) => {
     let subKey = computeSubKey(state, subIdField);
     let expiresAt = ttl !== undefined ? ttl : null;
@@ -209,10 +226,25 @@ function makeStorage(db, bus, name, indexes, subIdField) {
       _0: undefined
     };
   };
-  let count = async (_id, _fieldName, inc) => ({
-    TAG: "Ok",
-    _0: inc
-  });
+  let count = async (id, fieldName, inc) => {
+    let existing = Stdlib_Option.flatMap(rowsFor(id)[0], Stdlib_JSON.Decode.object);
+    let current = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(existing, o => o[fieldName]), Stdlib_JSON.Decode.float), 0, prim => prim | 0);
+    let next = current + inc | 0;
+    let obj = {};
+    if (existing !== undefined) {
+      Object.entries(existing).forEach(param => {
+        obj[param[0]] = param[1];
+      });
+    }
+    obj["id"] = id;
+    obj[fieldName] = next;
+    saveOne(id, obj, undefined);
+    publishUpdated(id, obj);
+    return {
+      TAG: "Ok",
+      _0: next
+    };
+  };
   let deleteOne = (id, subIdOpt) => {
     if (subIdOpt !== undefined) {
       return SqliteDriver$ReventlessLocal.run(deleteBySubKeyStmt, [
@@ -272,6 +304,83 @@ function makeStorage(db, bus, name, indexes, subIdField) {
   bus.registerQueryDb(name, ops);
   bus.registerQueryDbScan(name, () => allRows());
   bus.registerQueryDbStream(name, () => Stream.fromIterable(allRows()));
+  bus.registerQueryDbIndexLookup(name, lookupByField);
+  let listStmtCache = {};
+  let preparedList = sql => {
+    let s = listStmtCache[sql];
+    if (s !== undefined) {
+      return Primitive_option.valFromOption(s);
+    }
+    let s$1 = SqliteDriver$ReventlessLocal.prepare(db, sql);
+    listStmtCache[sql] = s$1;
+    return s$1;
+  };
+  let jsonText = field => `CAST(json_extract(item, '$.` + field.replaceAll("'", "''") + `') AS TEXT)`;
+  let idExpr = "COALESCE(json_extract(item, '$.id'), partition_key)";
+  let listPage = (argsDict, capability, param) => {
+    let filterDict = Stdlib_Option.getOr(Stdlib_Option.flatMap(argsDict["filter"], Stdlib_JSON.Decode.object), {});
+    let strNonEmpty = k => Stdlib_Option.mapOr(Stdlib_Option.flatMap(filterDict[k], Stdlib_JSON.Decode.string), false, s => s.length > 0);
+    let hasIds = Stdlib_Option.mapOr(Stdlib_Option.flatMap(filterDict["ids"], Stdlib_JSON.Decode.array), false, a => a.length !== 0);
+    let last = Stdlib_Option.flatMap(argsDict["last"], Stdlib_JSON.Decode.float);
+    let before = Stdlib_Option.flatMap(argsDict["before"], Stdlib_JSON.Decode.string);
+    if (strNonEmpty("search") || strNonEmpty("searchPrefix") || hasIds || Stdlib_Option.isSome(last) || Stdlib_Option.isSome(before)) {
+      return;
+    }
+    let whereParts = [notExpiredClause];
+    let params = [];
+    let valString = v => {
+      let s = Stdlib_JSON.Decode.string(v);
+      if (s !== undefined) {
+        return s;
+      } else {
+        return Stdlib_Option.map(Stdlib_JSON.Decode.float(v), f => f.toString());
+      }
+    };
+    capability.filterFields.forEach(f => {
+      let v = filterDict[f.name + "Eq"];
+      if (v !== undefined && v !== null) {
+        whereParts.push(jsonText(f.name) + ` = ?`);
+        params.push(Stdlib_Option.getOr(valString(v), ""));
+      }
+      if (!f.range) {
+        return;
+      }
+      let v$1 = filterDict[f.name + "From"];
+      if (v$1 !== undefined && v$1 !== null) {
+        whereParts.push(jsonText(f.name) + ` >= ?`);
+        params.push(Stdlib_Option.getOr(valString(v$1), ""));
+      }
+      let v$2 = filterDict[f.name + "To"];
+      if (v$2 !== undefined && v$2 !== null) {
+        whereParts.push(jsonText(f.name) + ` <= ?`);
+        params.push(Stdlib_Option.getOr(valString(v$2), ""));
+        return;
+      }
+    });
+    let orderByDict = Stdlib_Option.flatMap(argsDict["orderBy"], Stdlib_JSON.Decode.object);
+    let orderByField = Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["field"]), Stdlib_JSON.Decode.string);
+    let isDesc = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(orderByDict, ob => ob["direction"]), Stdlib_JSON.Decode.string), "ASC") === "DESC";
+    let cursorExpr = orderByField !== undefined ? jsonText(orderByField) : idExpr;
+    let c = Stdlib_Option.flatMap(argsDict["after"], Stdlib_JSON.Decode.string);
+    if (c !== undefined) {
+      whereParts.push(cursorExpr + ` ` + (
+        isDesc ? "<" : ">"
+      ) + ` ?`);
+      params.push(QueryDbListQuery$ReventlessLocal.decodeCursor(c));
+    }
+    let orderClause = orderByField !== undefined ? jsonText(orderByField) + ` ` + (
+        isDesc ? "DESC" : "ASC"
+      ) + `, ` + idExpr + ` ASC` : idExpr + ` ASC`;
+    let pageSize = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(argsDict["first"], Stdlib_JSON.Decode.float), prim => prim | 0), QueryDbListQuery$ReventlessLocal.defaultListPageSize);
+    let sql = `SELECT partition_key, item FROM ` + table + ` WHERE ` + whereParts.join(" AND ") + ` ORDER BY ` + orderClause + ` LIMIT ?`;
+    let rows = SqliteDriver$ReventlessLocal.all(preparedList(sql), params.concat([pageSize + 1 | 0])).map(rowToItem);
+    let hasMore = rows.length > pageSize;
+    let pageItems = rows.slice(0, pageSize);
+    let cursorField = Stdlib_Option.getOr(orderByField, "id");
+    let cursorValueOf = item => Stdlib_Option.getOr(QueryDbListQuery$ReventlessLocal.getFieldString(item, cursorField), QueryDbListQuery$ReventlessLocal.getId(item));
+    return QueryDbListQuery$ReventlessLocal.buildConnection(pageItems, hasMore, false, cursorValueOf);
+  };
+  bus.registerQueryDbListPage(name, listPage);
   return {
     resources: [],
     dataSourceName: Pulumi.output(""),
@@ -285,11 +394,15 @@ function Make(Bus) {
     let busCallbacks_registerQueryDb = Bus.registerQueryDb;
     let busCallbacks_registerQueryDbScan = Bus.registerQueryDbScan;
     let busCallbacks_registerQueryDbStream = Bus.registerQueryDbStream;
+    let busCallbacks_registerQueryDbIndexLookup = Bus.registerQueryDbIndexLookup;
+    let busCallbacks_registerQueryDbListPage = Bus.registerQueryDbListPage;
     let busCallbacks = {
       publishStateChange: busCallbacks_publishStateChange,
       registerQueryDb: busCallbacks_registerQueryDb,
       registerQueryDbScan: busCallbacks_registerQueryDbScan,
-      registerQueryDbStream: busCallbacks_registerQueryDbStream
+      registerQueryDbStream: busCallbacks_registerQueryDbStream,
+      registerQueryDbIndexLookup: busCallbacks_registerQueryDbIndexLookup,
+      registerQueryDbListPage: busCallbacks_registerQueryDbListPage
     };
     let make = (name, indexes, subIdField, param, param$1, param$2, param$3) => makeStorage(DbProvider.db, busCallbacks, name, indexes, subIdField);
     return {

package/src/adapter/SqliteDriver.res

@@ -27,7 +27,17 @@ let openDb = (~path) => {
   if path !== ":memory:" {
     mkdirSync(dirname(path), {recursive: true})
   }
-  openDatabaseSync(path)
+  let db = openDatabaseSync(path)
+  // Connection pragmas. WAL lets readers proceed concurrently with a writer and
+  // batches fsyncs into the write-ahead log (a no-op for `:memory:`, which stays
+  // on its MEMORY journal); `synchronous=NORMAL` is the safe WAL companion —
+  // durable across app crashes, only a power-loss window remains — and cuts the
+  // per-commit fsync cost that dominated replay-heavy dev sessions;
+  // `busy_timeout` makes a momentarily-locked db wait rather than throw SQLITE_BUSY.
+  _exec(db, "PRAGMA journal_mode=WAL")
+  _exec(db, "PRAGMA synchronous=NORMAL")
+  _exec(db, "PRAGMA busy_timeout=5000")
+  db
 }
 let close = db => _close(db)
 let exec = (db, sql) => _exec(db, sql)
@@ -46,7 +56,12 @@ let transaction = (db, fn) => {
     result
   } catch {
   | exn =>
-    exec(db, "ROLLBACK")
+    // Roll back, but never let a failing ROLLBACK replace the original error —
+    // the original is the diagnostic one; a rollback failure (e.g. no active
+    // transaction) would otherwise mask it.
+    try exec(db, "ROLLBACK") catch {
+    | _ => ()
+    }
     throw(exn)
   }
 }

package/src/adapter/SqliteDriver.res.mjs

@@ -19,7 +19,11 @@ function openDb(path) {
       recursive: true
     });
   }
-  return new Nodesqlite.DatabaseSync(path);
+  let db = new Nodesqlite.DatabaseSync(path);
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA synchronous=NORMAL");
+  db.exec("PRAGMA busy_timeout=5000");
+  return db;
 }
 
 function close(db) {
@@ -57,7 +61,11 @@ function transaction(db, fn) {
     db.exec("COMMIT");
     return result;
   } catch (exn) {
-    db.exec("ROLLBACK");
+    try {
+      db.exec("ROLLBACK");
+    } catch (exn$1) {
+      
+    }
     throw exn;
   }
 }

package/src/components/DcbEventLog_Builder.res

@@ -3,7 +3,13 @@
 module Make = (Bus: LocalBus.T) => {
   module EventTopicPublisher = LocalEventTopicPublisher.Make(Bus)
 
-  module Inner = ReventlessCore.DcbEventLog_Builder.Make(DcbEventLogStorage_InMemory, EventTopicPublisher)
+  // Use the backend-aware storage functor (as Platform does), not the plain
+  // module: the functor consults BackendState so a standalone DCB log honours
+  // REVENTLESS_LOCAL_BACKEND=sqlite, and it registers the read with the Bus so
+  // `Bus.getDcbEventLogRead` can see it. The plain module did neither — the log
+  // silently stayed in memory under SQLite and was invisible to bus readers.
+  module Storage = DcbEventLogStorage_InMemory.Make(Bus)
+  module Inner = ReventlessCore.DcbEventLog_Builder.Make(Storage, EventTopicPublisher)
   type component = ReventlessInfra.DcbEventLog.component
   let make: (
     ~name: string,

package/src/components/DcbEventLog_Builder.res.mjs

@@ -7,11 +7,11 @@ import * as DcbEventLogStorage_InMemory$ReventlessLocal from "../adapter/DcbEven
 
 function Make(Bus) {
   let EventTopicPublisher = LocalEventTopicPublisher$ReventlessLocal.Make(Bus);
-  let Inner = DcbEventLog_Builder$ReventlessCore.Make({
-    make: DcbEventLogStorage_InMemory$ReventlessLocal.make
-  })(EventTopicPublisher);
+  let Storage = DcbEventLogStorage_InMemory$ReventlessLocal.Make(Bus);
+  let Inner = DcbEventLog_Builder$ReventlessCore.Make(Storage)(EventTopicPublisher);
   return {
     EventTopicPublisher: EventTopicPublisher,
+    Storage: Storage,
     Inner: Inner,
     make: Inner.make,
     operations: Component$ReventlessInfra.operations

package/src/components/ReadModel_Builder.res

@@ -2,7 +2,9 @@
 
 module Make = (Bus: LocalBus.T) => {
   module RuntimeEnvironment = LocalRuntimeEnvironment
-  module EventCollectorChannel = LocalEventCollectorChannel.Make(Bus)
+  // MakeProjection (not Make): also registers the resolved handler for the
+  // SQLite backend's startup projection catch-up (ProjectionCheckpoint).
+  module EventCollectorChannel = LocalEventCollectorChannel.MakeProjection(Bus)
   module EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder.Make(
     Bus,
     EventCollectorChannel,

package/src/components/ReadModel_Builder.res.mjs

@@ -9,8 +9,11 @@ import * as LocalEventCollectorChannel$ReventlessLocal from "../adapter/EventCol
 import * as LocalEventCollectorRuntime_Builder$ReventlessLocal from "../adapter/Runtime/LocalEventCollectorRuntime_Builder.res.mjs";
 
 function Make(Bus) {
-  let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.Make(Bus);
-  let EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder$ReventlessLocal.Make(Bus)(EventCollectorChannel);
+  let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.MakeProjection(Bus);
+  let EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder$ReventlessLocal.Make(Bus)({
+    make: EventCollectorChannel.make,
+    connect: EventCollectorChannel.connect
+  });
   let QueryDbStorage = QueryDbStorage_InMemory$ReventlessLocal.Make(Bus);
   let QueryDbResolvers = QueryDbResolvers_GraphQL$ReventlessLocal.Make(Bus);
   let Make$1 = Spec => (Mappings => ReadModel_Builder$ReventlessCore.Make(Spec)(Mappings)({
@@ -23,7 +26,10 @@ function Make(Bus) {
     make: QueryDbStorage.make
   })({
     make: QueryDbResolvers.make
-  })(EventCollectorChannel)(EventCollectorRuntimeBuilder));
+  })({
+    make: EventCollectorChannel.make,
+    connect: EventCollectorChannel.connect
+  })(EventCollectorRuntimeBuilder));
   let NoResolvers = QueryDb_Adapter$ReventlessCore.NoResolvers({
     make: QueryDbStorage.make
   });
@@ -35,7 +41,10 @@ function Make(Bus) {
     asEffectHandler: prim => prim
   })({
     make: QueryDbStorage.make
-  })(NoResolvers)(EventCollectorChannel)(EventCollectorRuntimeBuilder));
+  })(NoResolvers)({
+    make: EventCollectorChannel.make,
+    connect: EventCollectorChannel.connect
+  })(EventCollectorRuntimeBuilder));
   return {
     RuntimeEnvironment: undefined,
     EventCollectorChannel: EventCollectorChannel,

package/src/components/StateViewSlice_Builder.res

@@ -3,7 +3,10 @@
 
 module Make = (Bus: LocalBus.T) => {
   module RuntimeEnvironment = LocalRuntimeEnvironment
-  module EventCollectorChannel = LocalEventCollectorChannel.Make(Bus)
+  // MakeProjection (not Make): also registers the resolved handler for the
+  // SQLite backend's startup projection catch-up (ProjectionCheckpoint) —
+  // StateViewSlices are pure projections fed by DCB events.
+  module EventCollectorChannel = LocalEventCollectorChannel.MakeProjection(Bus)
   module EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder.Make(
     Bus,
     EventCollectorChannel,

package/src/components/StateViewSlice_Builder.res.mjs

@@ -9,8 +9,11 @@ import * as LocalEventCollectorChannel$ReventlessLocal from "../adapter/EventCol
 import * as LocalEventCollectorRuntime_Builder$ReventlessLocal from "../adapter/Runtime/LocalEventCollectorRuntime_Builder.res.mjs";
 
 function Make(Bus) {
-  let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.Make(Bus);
-  let EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder$ReventlessLocal.Make(Bus)(EventCollectorChannel);
+  let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.MakeProjection(Bus);
+  let EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder$ReventlessLocal.Make(Bus)({
+    make: EventCollectorChannel.make,
+    connect: EventCollectorChannel.connect
+  });
   let QueryDbStorage = QueryDbStorage_InMemory$ReventlessLocal.Make(Bus);
   let QueryDbResolvers = QueryDbResolvers_GraphQL$ReventlessLocal.Make(Bus);
   let api = () => {};
@@ -29,7 +32,10 @@ function Make(Bus) {
     make: QueryDbStorage.make
   })({
     make: QueryDbResolvers.make
-  })(EventCollectorChannel)(EventCollectorRuntimeBuilder)(Api);
+  })({
+    make: EventCollectorChannel.make,
+    connect: EventCollectorChannel.connect
+  })(EventCollectorRuntimeBuilder)(Api);
   let Make$1 = Spec => (Projection => {
     let Inner = CoreMaker.Make(Spec)(Projection);
     return {

package/src/test/Mocks/MockEventLogStorage.res

@@ -15,7 +15,7 @@ let make = (~name as _="mock-event-log", ~opts as _: Pulumi.CustomResourceOption
   let append: ReventlessCore.EventLog.append<string, JSON.t> = async (_seqNr, id, jsons) => {
     if failNextAppends.contents > 0 {
       failNextAppends := failNextAppends.contents - 1
-      Error("mock append failure")
+      Error(ReventlessCore.EventLog.StorageFailure("mock append failure"))
     } else {
       let existing = events.contents->Dict.get(id)->Option.getOr([])
       events.contents->Dict.set(id, existing->Array.concat(jsons))
@@ -27,8 +27,22 @@ let make = (~name as _="mock-event-log", ~opts as _: Pulumi.CustomResourceOption
     events.contents->Dict.get(id)->Option.getOr([])
   }
 
-  let replayStream: string => Stream.t<JSON.t, string, unit> = id =>
-    events.contents->Dict.get(id)->Option.getOr([])->Stream.fromIterable
+  let replayStream = (id, ~fromSeq=0) =>
+    events.contents
+    ->Dict.get(id)
+    ->Option.getOr([])
+    ->Array.filterWithIndex((_, i) => i >= fromSeq)
+    ->Stream.fromIterable
+
+  let snapshots: dict<ReventlessCore.EventLog.snapshot> = Dict.make()
+
+  let latestSnapshot: ReventlessCore.EventLog.latestSnapshot<string> = async id =>
+    Ok(snapshots->Dict.get(id))
+
+  let writeSnapshot: ReventlessCore.EventLog.writeSnapshot<string> = async (id, snap) => {
+    snapshots->Dict.set(id, snap)
+    Ok()
+  }
 
   let appendStream: ReventlessCore.EventLog.appendStream<string, JSON.t> = (_startingSeqNr, id, stream) =>
     stream->Stream.runForEach(json =>
@@ -45,11 +59,14 @@ let make = (~name as _="mock-event-log", ~opts as _: Pulumi.CustomResourceOption
       replay,
       replayStream,
       appendStream,
+      latestSnapshot,
+      writeSnapshot,
     }),
   }
 
   let reset = () => {
     events := Dict.make()
+    snapshots->Dict.forEachWithKey((_, k) => snapshots->Dict.delete(k))
     failNextAppends := 0
   }
 

package/src/test/Mocks/MockEventLogStorage.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.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";
@@ -21,7 +22,10 @@ function make($staropt$star, $staropt$star$1) {
       failNextAppends.contents = failNextAppends.contents - 1 | 0;
       return {
         TAG: "Error",
-        _0: "mock append failure"
+        _0: {
+          TAG: "StorageFailure",
+          _0: "mock append failure"
+        }
       };
     }
     let existing = Stdlib_Option.getOr(events.contents[id], []);
@@ -32,7 +36,22 @@ function make($staropt$star, $staropt$star$1) {
     };
   };
   let replay = async id => Stdlib_Option.getOr(events.contents[id], []);
-  let replayStream = id => Stream.fromIterable(Stdlib_Option.getOr(events.contents[id], []));
+  let replayStream = (id, fromSeqOpt) => {
+    let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
+    return Stream.fromIterable(Stdlib_Option.getOr(events.contents[id], []).filter((param, i) => i >= fromSeq));
+  };
+  let snapshots = {};
+  let latestSnapshot = async id => ({
+    TAG: "Ok",
+    _0: snapshots[id]
+  });
+  let writeSnapshot = async (id, snap) => {
+    snapshots[id] = snap;
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
   let appendStream = (_startingSeqNr, id, stream) => Stream.runForEach(stream, json => Effect.sync(() => {
     let existing = Stdlib_Option.getOr(events.contents[id], []);
     events.contents[id] = existing.concat([json]);
@@ -42,7 +61,9 @@ function make($staropt$star, $staropt$star$1) {
     append: append,
     replay: replay,
     replayStream: replayStream,
-    appendStream: appendStream
+    appendStream: appendStream,
+    latestSnapshot: latestSnapshot,
+    writeSnapshot: writeSnapshot
   });
   let storage = {
     resources: storage_resources,
@@ -50,6 +71,7 @@ function make($staropt$star, $staropt$star$1) {
   };
   let reset = () => {
     events.contents = {};
+    Stdlib_Dict.forEachWithKey(snapshots, (param, k) => Stdlib_Dict.$$delete(snapshots, k));
     failNextAppends.contents = 0;
   };
   return {

package/tests/PluginEventDecodeTest.res

@@ -0,0 +1,51 @@
+// Regression: subscribeToPluginEvents' Source-C emission decoded the WHOLE bus
+// envelope {id, meta, event} with the bare Plugin event schema — convert mode
+// "succeeded" and then threw a TypeError on every variant's payload access, so
+// the onPluginStatusChange / onUIFragmentChange subscription emissions never
+// fired on the local platform. decodePluginEventEnvelope must decode the
+// payload under "event" and degrade to None on anything malformed.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+let meta = ReventlessCore.Message.generateMeta(~service=ReventlessCore.PluginSpec.name)
+
+let envelopeOf = (event: ReventlessCore.PluginSpec.event) =>
+  ReventlessCore.Message.composeEventJson'(
+    "Catalog",
+    meta,
+    event->S.reverseConvertToJsonOrThrow(ReventlessCore.PluginSpec.eventSchema),
+  )
+
+describe("Platform.decodePluginEventEnvelope", () => {
+  testSync("decodes a VersionConnected event from the published envelope", () => {
+    let envelope = envelopeOf(VersionConnected(Plugin_Fixtures.pluginDefinition))
+    switch Platform.decodePluginEventEnvelope(envelope) {
+    | Some(VersionConnected(def)) => expect(def.name)->toBe(Plugin_Fixtures.pluginDefinition.name)
+    | _ => expect("VersionConnected")->toBe("something else")
+    }
+  })
+
+  testSync("decodes a payload-light variant (VersionDetected)", () => {
+    let envelope = envelopeOf(VersionDetected("2.0.0"))
+    expect(Platform.decodePluginEventEnvelope(envelope))->toEqual(
+      Some(ReventlessCore.PluginSpec.VersionDetected("2.0.0")),
+    )
+  })
+
+  testSync("returns None for a bare event JSON (no envelope) and malformed input", () => {
+    // The old bug class: input that is not the {id, meta, event} envelope.
+    let bare =
+      ReventlessCore.PluginSpec.VersionDetected("2.0.0")->S.reverseConvertToJsonOrThrow(
+        ReventlessCore.PluginSpec.eventSchema,
+      )
+    expect(Platform.decodePluginEventEnvelope(bare))->toEqual(None)
+    expect(Platform.decodePluginEventEnvelope(JSON.Encode.string("junk")))->toEqual(None)
+    expect(
+      Platform.decodePluginEventEnvelope(
+        JSON.Encode.object(Dict.fromArray([("event", JSON.Encode.object(Dict.make()))])),
+      ),
+    )->toEqual(None)
+  })
+})

package/tests/PluginEventDecodeTest.res.mjs

@@ -0,0 +1,63 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as Platform$ReventlessLocal from "../src/Platform.res.mjs";
+import * as PluginSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginSpec.res.mjs";
+import * as TestRunner$ReventlessLocal from "../src/test/TestRunner.res.mjs";
+import * as Plugin_Fixtures$ReventlessLocal from "./plugin/Plugin_Fixtures.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let meta = Message$ReventlessCore.generateMeta(PluginSpec$ReventlessCore.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+
+function envelopeOf(event) {
+  return Message$ReventlessCore.composeEventJson$p("Catalog", meta, S.reverseConvertToJsonOrThrow(event, PluginSpec$ReventlessCore.eventSchema));
+}
+
+globalThis.describe("Platform.decodePluginEventEnvelope", () => {
+  globalThis.test("decodes a VersionConnected event from the published envelope", () => {
+    let envelope = envelopeOf({
+      TAG: "VersionConnected",
+      _0: Plugin_Fixtures$ReventlessLocal.pluginDefinition
+    });
+    let match = Platform$ReventlessLocal.decodePluginEventEnvelope(envelope);
+    if (match !== undefined) {
+      if (match.TAG === "VersionConnected") {
+        globalThis.expect(match._0.name).toBe(Plugin_Fixtures$ReventlessLocal.pluginDefinition.name);
+        return;
+      }
+      globalThis.expect("VersionConnected").toBe("something else");
+      return;
+    }
+    globalThis.expect("VersionConnected").toBe("something else");
+  });
+  globalThis.test("decodes a payload-light variant (VersionDetected)", () => {
+    let envelope = envelopeOf({
+      TAG: "VersionDetected",
+      _0: "2.0.0"
+    });
+    globalThis.expect(Platform$ReventlessLocal.decodePluginEventEnvelope(envelope)).toEqual({
+      TAG: "VersionDetected",
+      _0: "2.0.0"
+    });
+  });
+  globalThis.test("returns None for a bare event JSON (no envelope) and malformed input", () => {
+    let bare = S.reverseConvertToJsonOrThrow({
+      TAG: "VersionDetected",
+      _0: "2.0.0"
+    }, PluginSpec$ReventlessCore.eventSchema);
+    globalThis.expect(Platform$ReventlessLocal.decodePluginEventEnvelope(bare)).toEqual(undefined);
+    globalThis.expect(Platform$ReventlessLocal.decodePluginEventEnvelope("junk")).toEqual(undefined);
+    globalThis.expect(Platform$ReventlessLocal.decodePluginEventEnvelope(Object.fromEntries([[
+        "event",
+        {}
+      ]]))).toEqual(undefined);
+  });
+});
+
+export {
+  meta,
+  envelopeOf,
+}
+/*  Not a pure module */

package/tests/adapter/BackendParityTest.res

@@ -70,6 +70,70 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     await runUnderSqlite(scenario)
   })
 
+  testPromise("QueryDb: count returns a running total and loadStream reflects it under both", async () => {
+    let scenario = async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="parity-count", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+
+      // First increment creates the counter item and returns the new total.
+      let r1 = await ops.count("prod-1", "orderCount", 3)
+      expect(r1)->toEqual(Ok(3))
+      // Second increment accumulates (not just echoes the increment).
+      let r2 = await ops.count("prod-1", "orderCount", 2)
+      expect(r2)->toEqual(Ok(5))
+
+      // loadStream must see the persisted counter — count is not a side channel.
+      let items =
+        await ops.loadStream("prod-1")
+        ->Stream.runCollect
+        ->Effect.catchAll(_ => Effect.succeed([]))
+        ->Effect.runPromise
+      expect(items->Array.length)->toBe(1)
+      let field =
+        items
+        ->Array.getUnsafe(0)
+        ->JSON.Decode.object
+        ->Option.flatMap(o => o->Dict.get("orderCount"))
+        ->Option.flatMap(JSON.Decode.float)
+        ->Option.mapOr(0, Float.toInt)
+      expect(field)->toBe(5)
+    }
+
+    await runUnderMemory(scenario)
+    await runUnderSqlite(scenario)
+  })
+
+  testPromise("QueryDb: an expired-TTL item is filtered from loadStream under both", async () => {
+    let scenario = async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="parity-ttl", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+
+      let item = k => JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string(k))]))
+      let readCount = async k =>
+        (
+          await ops.loadStream(k)
+          ->Stream.runCollect
+          ->Effect.catchAll(_ => Effect.succeed([]))
+          ->Effect.runPromise
+        )->Array.length
+
+      // A live item (no TTL) and one whose absolute expiry (epoch second 1) is
+      // long past — the expired one must not surface under either backend.
+      let _ = await ops.save("live", item("live"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("dead", item("dead"), ReventlessCore.QueryDb.Any, Some(1))
+
+      expect(await readCount("live"))->toBe(1)
+      expect(await readCount("dead"))->toBe(0)
+    }
+
+    await runUnderMemory(scenario)
+    await runUnderSqlite(scenario)
+  })
+
   testPromise("EventLog: conflict detection works under both", async () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()