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

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.116 (2026-07-03)
+
+### Bug Fixes
+
+* **local:** decode plugin events from the bus envelope in subscribeToPluginEvents ([0f24dc1](https://github.com/ReventlessDev/reventless-core/commit/0f24dc129bf2631b94c300d7d5f6ceba3a9bb9f7))
+### Features
+
+* **core,local,aws:** EventLog snapshot storage surface, all backends (aggregate-snapshotting plan, steps 3+4) ([b6e50e2](https://github.com/ReventlessDev/reventless-core/commit/b6e50e2e5fe50b7372e54811f883fa91f6758dd1))
+* **local:** DCB-axis projection checkpoints + startup catch-up (plan B5) ([8f9b11d](https://github.com/ReventlessDev/reventless-core/commit/8f9b11d24627bb6cc105d37af4974745444b80ba))
+* **local:** projection checkpoints + startup catch-up under SQLite (plan B5) ([d28f30e](https://github.com/ReventlessDev/reventless-core/commit/d28f30e25d43cbf378b3aab091b1979dbb449a4f))
+### Performance Improvements
+
+* **local:** DCB in-memory posting lists for tag/type queries (plan B4) ([7859fed](https://github.com/ReventlessDev/reventless-core/commit/7859fede8ad6ab44f657d4d9dd44fba08e85e3aa))
+* **local:** DCB SQLite batched tag reads + EXISTS conflict check (plan B4) ([c9d647b](https://github.com/ReventlessDev/reventless-core/commit/c9d647b73adba4e054edbeba83dfb9c8111e4dfb))
+* **local:** EventLog SQLite MAX(seq_nr)+1 + batched appendStream (plan B4) ([7b24fb1](https://github.com/ReventlessDev/reventless-core/commit/7b24fb12b78b79854d3c345a74f1eab68a28e745))
+* **local:** SQLite connection-list push-down with parity harness (plan B4 complete) ([d78d428](https://github.com/ReventlessDev/reventless-core/commit/d78d4282c923c64cbde3432cd906845705a1e97b))
+* **local:** SQLite pragmas, lazy in-memory scan, indexed lookup push-down (plan B4) ([b0ff78a](https://github.com/ReventlessDev/reventless-core/commit/b0ff78a5c02030eef9fc5bb1ee8b92c65114fa45))
+
+
+# 3.0.0-alpha.115 (2026-07-02)
+
+### Bug Fixes
+
+* **core,local:** projection/publisher/bus correctness (plan A5,A7) ([86e27a5](https://github.com/ReventlessDev/reventless-core/commit/86e27a5d68873d7dd9e746f9b4126f4d5bad63c9))
+* **local:** conflict classification, rollback masking, MCP pagination (plan A6) ([b3e6d24](https://github.com/ReventlessDev/reventless-core/commit/b3e6d242ddf2df066ca94b0db2266275f1453fbf))
+* **local:** InMemory QueryDb TTL parity + backend-aware UIFragment store (plan A6) ([c31727f](https://github.com/ReventlessDev/reventless-core/commit/c31727fa3fe98b4f15b55300fdf8b80221fabbee))
+* **local:** QueryDb count returns a running total, not the increment (plan A6) ([4ac3822](https://github.com/ReventlessDev/reventless-core/commit/4ac3822ac310d62bb4b1c4c021a85f45883f4785))
+* **local:** wire standalone DCB log through the backend-aware storage (plan A6) ([40734e9](https://github.com/ReventlessDev/reventless-core/commit/40734e902436dfce623061416e9edeafa822f1d3))
+
+
 # 3.0.0-alpha.114 (2026-06-29)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.114",
+  "version": "3.0.0-alpha.116",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "jest": {
@@ -31,20 +31,20 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0-alpha.4",
     "ws": "^8.18.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.23",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.17",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.16",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.3",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.135",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.75",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.82",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.62"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.137",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.77",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.84",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.64"
   },
   "devDependencies": {
     "rescript": "^12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.48"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.50"
   },
   "peerDependencies": {
     "rescript": "^12.3.0"

package/src/Platform.res

@@ -28,6 +28,22 @@ let getPlatformGraphQL = () => platformGraphQLRef.contents
 // Populated by makePlatform when splitApi=true.
 let platformMCPRef: ref<option<MCP_ServerInstance.t>> = ref(None)
 
+// Decode a Plugin aggregate event from the published bus envelope.
+// The bus delivers the EventTopic envelope {id, meta, event} — the event
+// payload lives under "event". (The previous code fed the WHOLE envelope to
+// the event schema in convert mode, which "succeeded" and then threw a
+// TypeError on every variant's payload access, so the Source-C status /
+// UI-fragment subscription emissions never fired.) Top-level, not inside the
+// functor, so the decode is unit-testable.
+let decodePluginEventEnvelope = (eventJson: JSON.t): option<ReventlessCore.PluginSpec.event> =>
+  switch eventJson
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("event"))
+  ->Option.map(payload => payload->S.parseJsonOrThrow(ReventlessCore.PluginSpec.eventSchema)) {
+  | result => result
+  | exception _ => None
+  }
+
 // Configurable platform — set silent=true to suppress diagnostic warnings in tests,
 // splitApi=true to serve core and plugin APIs on separate ports,
 // backend=Backend.Sqlite({...}) to opt into file-backed SQLite persistence.
@@ -76,6 +92,29 @@ module MakeWithConfig = (
     LocalBus.seedEventTapSeq(
       EventLogStorage_Sqlite.countAll(db) + DcbEventLogStorage_Sqlite.countAll(db),
     )
+    // Projection checkpoints (plan B5): the event-log storage tracks each
+    // appended batch as pending; this hook resolves it once the publish cycle
+    // completes (publishEvent returns only after every subscriber processed the
+    // events), advancing the persisted per-read-model checkpoints to the
+    // low-watermark. Startup catch-up in makePlatform replays anything below a
+    // read model's checkpoint that a crash left unprojected.
+    ProjectionPending.enableTracking()
+    ReventlessCore.EventPublish_Callback.registerAfterPublish(async publishedEvent => {
+      // Aggregate EventLog batches carry flat stored events (msgId at the top
+      // level of each eventsJson entry); DcbEventLog batches carry bare event
+      // payloads and expose the per-event metas separately.
+      let msgIds = switch publishedEvent.metas {
+      | Some(metas) => metas->Array.map(m => m.msgId)
+      | None =>
+        publishedEvent.eventsJson->Array.filterMap(json =>
+          json
+          ->JSON.Decode.object
+          ->Option.flatMap(d => d->Dict.get("msgId"))
+          ->Option.flatMap(JSON.Decode.string)
+        )
+      }
+      ProjectionCheckpoint.completePublished(db, msgIds)
+    })
   }
 
   module Bus = LocalBus.Impl({
@@ -279,10 +318,18 @@ module MakeWithConfig = (
             ])->JSON.Encode.object
 
           let paginate = (events: array<JSON.t>, getPosition: JSON.t => option<string>) => {
+            // Positions are numeric strings; compare them as ints, not lexically
+            // ("10" > "9" is false as strings) — otherwise cursor pages skip or
+            // duplicate events once positions cross a digit boundary.
+            let positionGt = (p, afterPos) =>
+              switch (Int.fromString(p), Int.fromString(afterPos)) {
+              | (Some(pi), Some(ai)) => pi > ai
+              | _ => p > afterPos
+              }
             let filtered = switch after {
             | Some(afterPos) =>
               let idx =
-                events->Array.findIndex(e => getPosition(e)->Option.mapOr(false, p => p > afterPos))
+                events->Array.findIndex(e => getPosition(e)->Option.mapOr(false, p => positionGt(p, afterPos)))
               if idx >= 0 {
                 events->Array.slice(~start=idx, ~end=events->Array.length)
               } else {
@@ -749,60 +796,27 @@ module MakeWithConfig = (
   // UIFragmentRegistry QueryDb store ops — initialized lazily on first seed call.
   let uiFragmentQueryDbOpsRef: ref<option<ReventlessCore.QueryDb_Adapter.operations>> = ref(None)
 
+  // Backend-aware storage for the UIFragment registry — the same functor every
+  // other read model uses. Replaces a hand-rolled memory-only store that ignored
+  // BackendState, so the registry now persists under SQLite too.
+  module UIFragmentStorage = QueryDbStorage_InMemory.Make(Bus)
+
   let ensureUIFragmentRegistryQueryDbStore = () => {
     switch uiFragmentQueryDbOpsRef.contents {
     | Some(ops) => ops
     | None =>
       let name = ReventlessCore.UIFragmentRegistryReadModelSpec.name
-      let store: ref<dict<array<JSON.t>>> = ref(Dict.make())
-      let allItems: ref<array<JSON.t>> = ref([])
-      let syncAll = () => {
-        allItems.contents =
-          store.contents
-          ->Dict.toArray
-          ->Array.flatMap(((id, items)) =>
-            items->Array.map(item => {
-              let obj = item->JSON.Decode.object->Option.getOr(Dict.make())
-              if !(obj->Dict.get("id")->Option.isSome) {
-                let copy = Dict.make()
-                obj->Dict.toArray->Array.forEach(((k, v)) => copy->Dict.set(k, v))
-                copy->Dict.set("id", JSON.Encode.string(id))
-                JSON.Encode.object(copy)
-              } else {
-                item
-              }
-            })
-          )
-      }
-      let ops: ReventlessCore.QueryDb_Adapter.operations = {
-        load: async id => Ok(store.contents->Dict.get(id)->Option.getOr([])),
-        loadStream: id =>
-          store.contents->Dict.get(id)->Option.getOr([])->Stream.fromIterable,
-        save: async (id, state, _, _) => {
-          store.contents->Dict.set(id, [state])
-          syncAll()
-          Ok()
-        },
-        saveBatch: async batch => {
-          batch->Array.forEach(((id, state, _)) => store.contents->Dict.set(id, [state]))
-          syncAll()
-          Ok()
-        },
-        count: async (_, _, inc) => Ok(inc),
-        delete: async (id, _) => {
-          store.contents->Dict.delete(id)
-          syncAll()
-          Ok()
-        },
-        deleteBatch: async ids => {
-          ids->Array.forEach(((id, _)) => store.contents->Dict.delete(id))
-          syncAll()
-          Ok()
-        },
-      }
-      Bus.registerQueryDb(name, ops)
-      Bus.registerQueryDbScan(name, () => allItems.contents)
-      Bus.registerQueryDbStream(name, () => allItems.contents->Stream.fromIterable)
+      // `make` registers the ops (and scan/stream) with the Bus for the active
+      // backend; retrieve them synchronously via getQueryDb rather than resolving
+      // the Pulumi Output.
+      let _ = UIFragmentStorage.make(
+        ~name,
+        ~indexes=[],
+        ~api=(),
+        ~apiRole=(),
+        ~opts=({}: Pulumi.CustomResourceOptions.t),
+      )
+      let ops = Bus.getQueryDb(name)->Option.getOrThrow
       uiFragmentQueryDbOpsRef := Some(ops)
       ops
     }
@@ -885,36 +899,36 @@ module MakeWithConfig = (
       let manifestJson = (m: Reventless.Plugin.uiFragmentManifest) =>
         m->S.reverseConvertToJsonOrThrow(Reventless.Plugin.uiFragmentManifestSchema)
       Bus.subscribeToEvents(pluginEventTopicKey, async (_service, _meta, eventJson) => {
-        switch eventJson->S.convertOrThrow(ReventlessCore.PluginSpec.eventSchema) {
-        | VersionConnected(def)
-        | VersionActivated(def)
-        | VersionPromoted(def) =>
+        switch decodePluginEventEnvelope(eventJson) {
+        | Some(VersionConnected(def))
+        | Some(VersionActivated(def))
+        | Some(VersionPromoted(def)) =>
           publishStatus(~name=def.name, ~status="Connected")
-        | VersionDisconnected(def) => publishStatus(~name=def.name, ~status="Disconnected")
-        | VersionDeactivated(def) => publishStatus(~name=def.name, ~status="Inactive")
-        | VersionRetired(def) => publishStatus(~name=def.name, ~status="Retired")
-        | UIFragmentRegistered(data) =>
+        | Some(VersionDisconnected(def)) => publishStatus(~name=def.name, ~status="Disconnected")
+        | Some(VersionDeactivated(def)) => publishStatus(~name=def.name, ~status="Inactive")
+        | Some(VersionRetired(def)) => publishStatus(~name=def.name, ~status="Retired")
+        | Some(UIFragmentRegistered(data)) =>
           publishUIFragment(
             ~name=ReventlessCore.Plugin.name(data.pluginId),
             ~changeKind="Registered",
             ~manifest=manifestJson(data.manifest),
           )
-        | UIFragmentUpdated(data) =>
+        | Some(UIFragmentUpdated(data)) =>
           publishUIFragment(
             ~name=ReventlessCore.Plugin.name(data.pluginId),
             ~changeKind="Updated",
             ~manifest=manifestJson(data.newManifest),
           )
-        | UIFragmentDeregistered(data) =>
+        | Some(UIFragmentDeregistered(data)) =>
           publishUIFragment(
             ~name=ReventlessCore.Plugin.name(data.pluginId),
             ~changeKind="Deregistered",
             ~manifest=JSON.Encode.null,
           )
-        | VersionDetected(_)
-        | VersionSuperseded(_)
-        | IncompatiblePluginDetected(_) => ()
-        | exception _ => ()
+        | Some(VersionDetected(_))
+        | Some(VersionSuperseded(_))
+        | Some(IncompatiblePluginDetected(_))
+        | None => ()
         }
       })
     }
@@ -1264,6 +1278,16 @@ module MakeWithConfig = (
         `backend: sqlite (${path}${resetOnStart ? ", resetOnStart" : ""})`
       },
     )
+    // Projection catch-up bound (plan B5): the highest persisted event position
+    // BEFORE this session appends anything. Catch-up replays only (checkpoint,
+    // bound] — this session's own events (Connect dispatches, user commands)
+    // are live-delivered and must not be redelivered.
+    let projectionCatchup = BackendState.getDb()->Option.map(db => (
+      db,
+      ProjectionCheckpoint.maxPosition(db, ProjectionPending.Aggregate),
+      ProjectionCheckpoint.maxPosition(db, ProjectionPending.Dcb),
+    ))
+
     // Create scheduler and populate platform context refs.
     let scheduler = makeScheduler()
     hooks.scheduler := Some(scheduler)
@@ -1353,9 +1377,34 @@ module MakeWithConfig = (
     // Drive the admin Plugin read models via synthetic Connect dispatch through
     // LocalPluginAggregate (replaces the old direct-write seed). The real
     // PluginsProjection folds the emitted events into the "Plugins" QueryDb store.
-    connectPlugin(~pluginComponents=plugins)
-    seedUIFragmentRegistryQueryDb(~pluginComponents=plugins)
-    seedPluginStructuresStore(~pluginComponents=plugins)
+    //
+    // Under SQLite this trio is sequenced AFTER the projection catch-up: the
+    // catch-up replays PRIOR sessions' stored events (e.g. the admin plugin
+    // lifecycle history) into the projections, and this session's Connect
+    // events must fold on top of — never race and be overwritten by — that
+    // replay. All three calls are internally fire-and-forget Output.apply
+    // chains, so deferring their invocation changes no synchronous contract.
+    let seedAdminStores = () => {
+      connectPlugin(~pluginComponents=plugins)
+      seedUIFragmentRegistryQueryDb(~pluginComponents=plugins)
+      seedPluginStructuresStore(~pluginComponents=plugins)
+    }
+    switch projectionCatchup {
+    | Some((db, upperBound, dcbUpperBound)) =>
+      let _ =
+        ProjectionCheckpoint.startupCatchup(~db, ~upperBound, ~dcbUpperBound, ~handlers=() =>
+          Bus.projectionCatchupHandlers()
+        )
+        ->Promise.catch(e => {
+          Console.error2("[Platform] projection catch-up failed:", e)
+          Promise.resolve()
+        })
+        ->Promise.then(() => {
+          seedAdminStores()
+          Promise.resolve()
+        })
+    | None => seedAdminStores()
+    }
 
     // Seed the built-in admin plugin's structure so its Auto UI (Plugin list with
     // Activate/Deactivate buttons) renders alongside the user plugins. Admin.construct