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

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.115",
+  "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": {
@@ -36,15 +36,15 @@
     "@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/reventless-core": "3.0.0-alpha.136",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.76",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.83",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.63"
+    "@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({
@@ -860,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 => ()
         }
       })
     }
@@ -1239,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)
@@ -1328,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

package/src/Platform.res.mjs

@@ -11,6 +11,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as Effect from "effect/Effect";
 import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as Plugin$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin.res.mjs";
@@ -45,12 +46,15 @@ import * as Scheduler_Builder$ReventlessCore from "@reventlessdev/reventless-cor
 import * as Aggregate_Builder$ReventlessLocal from "./components/Aggregate_Builder.res.mjs";
 import * as LocalClonerRunner$ReventlessLocal from "./adapter/Cloner/LocalClonerRunner.res.mjs";
 import * as PluginBaseFragment$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/api/PluginBaseFragment.res.mjs";
+import * as ProjectionPending$ReventlessLocal from "./adapter/ProjectionPending.res.mjs";
 import * as ReadModel_Builder$ReventlessLocal from "./components/ReadModel_Builder.res.mjs";
 import * as PlatformMCP_Server$ReventlessLocal from "./adapter/PlatformMCP_Server.res.mjs";
 import * as Auth_GraphqlContext$ReventlessLocal from "./adapter/Auth/Auth_GraphqlContext.res.mjs";
 import * as PluginsReadModelSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs";
 import * as DomainGraphQL_Server$ReventlessLocal from "./adapter/DomainGraphQL_Server.res.mjs";
+import * as EventPublish_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventLog/EventPublish_Callback.res.mjs";
 import * as LocalGraphQL_Adapter$ReventlessLocal from "./adapter/Api/LocalGraphQL_Adapter.res.mjs";
+import * as ProjectionCheckpoint$ReventlessLocal from "./adapter/ProjectionCheckpoint.res.mjs";
 import * as ExtensionPointMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionPointMapping.res.mjs";
 import * as EventLogStorage_Sqlite$ReventlessLocal from "./adapter/EventLog/EventLogStorage_Sqlite.res.mjs";
 import * as ExtensionPoint_Builder$ReventlessLocal from "./components/ExtensionPoint_Builder.res.mjs";
@@ -93,6 +97,14 @@ let platformMCPRef = {
   contents: undefined
 };
 
+function decodePluginEventEnvelope(eventJson) {
+  try {
+    return Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(eventJson), d => d["event"]), payload => S.parseJsonOrThrow(payload, PluginSpec$ReventlessCore.eventSchema));
+  } catch (exn) {
+    return;
+  }
+}
+
 function MakeWithConfig(Config) {
   TestRunner$ReventlessLocal.setup();
   let match = Config.backend;
@@ -106,6 +118,12 @@ function MakeWithConfig(Config) {
     let db = SqliteDriver$ReventlessLocal.openDb(path);
     BackendState$ReventlessLocal.setSqlite(db, path);
     LocalBus$ReventlessLocal.seedEventTapSeq(EventLogStorage_Sqlite$ReventlessLocal.countAll(db) + DcbEventLogStorage_Sqlite$ReventlessLocal.countAll(db) | 0);
+    ProjectionPending$ReventlessLocal.enableTracking();
+    EventPublish_Callback$ReventlessCore.registerAfterPublish(async publishedEvent => {
+      let metas = publishedEvent.metas;
+      let msgIds = metas !== undefined ? metas.map(m => m.msgId) : Stdlib_Array.filterMap(publishedEvent.eventsJson, json => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["msgId"]), Stdlib_JSON.Decode.string));
+      return ProjectionCheckpoint$ReventlessLocal.completePublished(db, msgIds);
+    });
   }
   let Bus = LocalBus$ReventlessLocal.Impl({
     capacity: undefined,
@@ -637,6 +655,7 @@ function MakeWithConfig(Config) {
     initialState: PluginBehavior$ReventlessCore.initialState,
     evolve: PluginBehavior$ReventlessCore.evolve,
     decide: PluginBehavior$ReventlessCore.decide,
+    snapshot: undefined,
     moduleUrl: PluginBehavior$ReventlessCore.moduleUrl
   })(NoEventMappings$ReventlessInfra.Make({
     name: PluginSpec$ReventlessCore.name,
@@ -787,33 +806,31 @@ function MakeWithConfig(Config) {
       ]
     ]));
     Bus.subscribeToEvents(pluginEventTopicKey, async (_service, _meta, eventJson) => {
-      let def;
-      try {
-        def = S.convertOrThrow(eventJson, PluginSpec$ReventlessCore.eventSchema);
-      } catch (exn) {
+      let match = decodePluginEventEnvelope(eventJson);
+      if (match === undefined) {
         return;
       }
-      switch (def.TAG) {
+      switch (match.TAG) {
         case "VersionDisconnected" :
-          return publishStatus(def._0.name, "Disconnected");
+          return publishStatus(match._0.name, "Disconnected");
         case "VersionDeactivated" :
-          return publishStatus(def._0.name, "Inactive");
+          return publishStatus(match._0.name, "Inactive");
         case "VersionRetired" :
-          return publishStatus(def._0.name, "Retired");
+          return publishStatus(match._0.name, "Retired");
         case "VersionDetected" :
         case "VersionSuperseded" :
         case "IncompatiblePluginDetected" :
           return;
         case "UIFragmentRegistered" :
-          let data = def._0;
+          let data = match._0;
           return publishUIFragment(Plugin$ReventlessCore.name(data.pluginId), "Registered", S.reverseConvertToJsonOrThrow(data.manifest, Plugin$Reventless.uiFragmentManifestSchema));
         case "UIFragmentUpdated" :
-          let data$1 = def._0;
+          let data$1 = match._0;
           return publishUIFragment(Plugin$ReventlessCore.name(data$1.pluginId), "Updated", S.reverseConvertToJsonOrThrow(data$1.newManifest, Plugin$Reventless.uiFragmentManifestSchema));
         case "UIFragmentDeregistered" :
-          return publishUIFragment(Plugin$ReventlessCore.name(def._0.pluginId), "Deregistered", null);
+          return publishUIFragment(Plugin$ReventlessCore.name(match._0.pluginId), "Deregistered", null);
         default:
-          return publishStatus(def._0.name, "Connected");
+          return publishStatus(match._0.name, "Connected");
       }
     });
   };
@@ -1081,6 +1098,11 @@ function MakeWithConfig(Config) {
         match.resetOnStart ? ", resetOnStart" : ""
       ) + `)`;
     log.info("Platform", undefined, tmp);
+    let projectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getDb(), db => [
+      db,
+      ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Aggregate"),
+      ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Dcb")
+    ]);
     let scheduler = makeScheduler();
     hooks_scheduler.contents = scheduler;
     hooks_api.contents = {
@@ -1139,9 +1161,22 @@ function MakeWithConfig(Config) {
       adminResources: []
     });
     subscribeToPluginEvents();
-    connectPlugin(plugins$1);
-    seedUIFragmentRegistryQueryDb(plugins$1);
-    seedPluginStructuresStore(plugins$1);
+    let seedAdminStores = () => {
+      connectPlugin(plugins$1);
+      seedUIFragmentRegistryQueryDb(plugins$1);
+      seedPluginStructuresStore(plugins$1);
+    };
+    if (projectionCatchup !== undefined) {
+      Stdlib_Promise.$$catch(ProjectionCheckpoint$ReventlessLocal.startupCatchup(projectionCatchup[0], projectionCatchup[1], projectionCatchup[2], () => Bus.projectionCatchupHandlers()), e => {
+        console.error("[Platform] projection catch-up failed:", e);
+        return Promise.resolve();
+      }).then(() => {
+        seedAdminStores();
+        return Promise.resolve();
+      });
+    } else {
+      seedAdminStores();
+    }
     pluginStructuresStore.contents[Platform_Admin_Structure$ReventlessCore.pluginId] = Platform_Admin_Structure$ReventlessCore.structure;
     CommandGeneratorResolvers_GraphQL$ReventlessLocal.setPluginStatusGate(field => {
       let parts = field.split("_");
@@ -1698,6 +1733,12 @@ function Make($star) {
     let db = SqliteDriver$ReventlessLocal.openDb(path);
     BackendState$ReventlessLocal.setSqlite(db, path);
     LocalBus$ReventlessLocal.seedEventTapSeq(EventLogStorage_Sqlite$ReventlessLocal.countAll(db) + DcbEventLogStorage_Sqlite$ReventlessLocal.countAll(db) | 0);
+    ProjectionPending$ReventlessLocal.enableTracking();
+    EventPublish_Callback$ReventlessCore.registerAfterPublish(async publishedEvent => {
+      let metas = publishedEvent.metas;
+      let msgIds = metas !== undefined ? metas.map(m => m.msgId) : Stdlib_Array.filterMap(publishedEvent.eventsJson, json => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["msgId"]), Stdlib_JSON.Decode.string));
+      return ProjectionCheckpoint$ReventlessLocal.completePublished(db, msgIds);
+    });
   }
   let Bus = LocalBus$ReventlessLocal.Impl({
     capacity: undefined,
@@ -2222,6 +2263,7 @@ function Make($star) {
     initialState: PluginBehavior$ReventlessCore.initialState,
     evolve: PluginBehavior$ReventlessCore.evolve,
     decide: PluginBehavior$ReventlessCore.decide,
+    snapshot: undefined,
     moduleUrl: PluginBehavior$ReventlessCore.moduleUrl
   })(NoEventMappings$ReventlessInfra.Make({
     name: PluginSpec$ReventlessCore.name,
@@ -2372,33 +2414,31 @@ function Make($star) {
       ]
     ]));
     Bus.subscribeToEvents(pluginEventTopicKey, async (_service, _meta, eventJson) => {
-      let def;
-      try {
-        def = S.convertOrThrow(eventJson, PluginSpec$ReventlessCore.eventSchema);
-      } catch (exn) {
+      let match = decodePluginEventEnvelope(eventJson);
+      if (match === undefined) {
         return;
       }
-      switch (def.TAG) {
+      switch (match.TAG) {
         case "VersionDisconnected" :
-          return publishStatus(def._0.name, "Disconnected");
+          return publishStatus(match._0.name, "Disconnected");
         case "VersionDeactivated" :
-          return publishStatus(def._0.name, "Inactive");
+          return publishStatus(match._0.name, "Inactive");
         case "VersionRetired" :
-          return publishStatus(def._0.name, "Retired");
+          return publishStatus(match._0.name, "Retired");
         case "VersionDetected" :
         case "VersionSuperseded" :
         case "IncompatiblePluginDetected" :
           return;
         case "UIFragmentRegistered" :
-          let data = def._0;
+          let data = match._0;
           return publishUIFragment(Plugin$ReventlessCore.name(data.pluginId), "Registered", S.reverseConvertToJsonOrThrow(data.manifest, Plugin$Reventless.uiFragmentManifestSchema));
         case "UIFragmentUpdated" :
-          let data$1 = def._0;
+          let data$1 = match._0;
           return publishUIFragment(Plugin$ReventlessCore.name(data$1.pluginId), "Updated", S.reverseConvertToJsonOrThrow(data$1.newManifest, Plugin$Reventless.uiFragmentManifestSchema));
         case "UIFragmentDeregistered" :
-          return publishUIFragment(Plugin$ReventlessCore.name(def._0.pluginId), "Deregistered", null);
+          return publishUIFragment(Plugin$ReventlessCore.name(match._0.pluginId), "Deregistered", null);
         default:
-          return publishStatus(def._0.name, "Connected");
+          return publishStatus(match._0.name, "Connected");
       }
     });
   };
@@ -2661,6 +2701,11 @@ function Make($star) {
         backend.resetOnStart ? ", resetOnStart" : ""
       ) + `)`;
     log.info("Platform", undefined, tmp);
+    let projectionCatchup = Stdlib_Option.map(BackendState$ReventlessLocal.getDb(), db => [
+      db,
+      ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Aggregate"),
+      ProjectionCheckpoint$ReventlessLocal.maxPosition(db, "Dcb")
+    ]);
     let scheduler = makeScheduler();
     hooks_scheduler.contents = scheduler;
     hooks_api.contents = {
@@ -2719,9 +2764,22 @@ function Make($star) {
       adminResources: []
     });
     subscribeToPluginEvents();
-    connectPlugin(plugins$1);
-    seedUIFragmentRegistryQueryDb(plugins$1);
-    seedPluginStructuresStore(plugins$1);
+    let seedAdminStores = () => {
+      connectPlugin(plugins$1);
+      seedUIFragmentRegistryQueryDb(plugins$1);
+      seedPluginStructuresStore(plugins$1);
+    };
+    if (projectionCatchup !== undefined) {
+      Stdlib_Promise.$$catch(ProjectionCheckpoint$ReventlessLocal.startupCatchup(projectionCatchup[0], projectionCatchup[1], projectionCatchup[2], () => Bus.projectionCatchupHandlers()), e => {
+        console.error("[Platform] projection catch-up failed:", e);
+        return Promise.resolve();
+      }).then(() => {
+        seedAdminStores();
+        return Promise.resolve();
+      });
+    } else {
+      seedAdminStores();
+    }
     pluginStructuresStore.contents[Platform_Admin_Structure$ReventlessCore.pluginId] = Platform_Admin_Structure$ReventlessCore.structure;
     CommandGeneratorResolvers_GraphQL$ReventlessLocal.setPluginStatusGate(field => {
       let parts = field.split("_");
@@ -3256,6 +3314,7 @@ export {
   platformGraphQLRef,
   getPlatformGraphQL,
   platformMCPRef,
+  decodePluginEventEnvelope,
   MakeWithConfig,
   Make,
 }

package/src/adapter/DcbEventLog/DcbEventLogStorage_InMemory.res

@@ -25,18 +25,108 @@ let matchesQuery = (event: DcbEventLog_Adapter.rawSequencedEvent, query: Reventl
     })
   }
 
+// Composite key for the per-(key,value) tag posting list. NUL can't appear in a
+// tag key or value, so it's an unambiguous separator.
+let tagPostingKey = (key: string, value: string) => key ++ "\x00" ++ value
+
+// Intersect two ascending, duplicate-free index arrays (two-pointer merge).
+let intersectSorted = (a: array<int>, b: array<int>): array<int> => {
+  let out = []
+  let i = ref(0)
+  let j = ref(0)
+  while i.contents < a->Array.length && j.contents < b->Array.length {
+    let av = a->Array.getUnsafe(i.contents)
+    let bv = b->Array.getUnsafe(j.contents)
+    if av == bv {
+      out->Array.push(av)
+      i := i.contents + 1
+      j := j.contents + 1
+    } else if av < bv {
+      i := i.contents + 1
+    } else {
+      j := j.contents + 1
+    }
+  }
+  out
+}
+
 let makeStorage = (~name as _name, ~indexes as _, ~partitionTag as _, ~opts as _) => {
   let events: ref<array<DcbEventLog_Adapter.rawSequencedEvent>> = ref([])
   let position = ref(0)
+  // Posting lists: tag "key\0value" / eventType → ascending array indices into
+  // `events`. Events are only ever appended (never removed) in position order, so
+  // every list stays sorted and duplicate-free by construction. They turn the
+  // per-read / per-conditional-append full scan (O(n) → O(n²) over a session)
+  // into a lookup + intersection over the (usually tiny) candidate set.
+  let byTag: Dict.t<array<int>> = Dict.make()
+  let byType: Dict.t<array<int>> = Dict.make()
+  let pushInto = (dict: Dict.t<array<int>>, key: string, idx: int) =>
+    switch dict->Dict.get(key) {
+    | Some(list) => list->Array.push(idx)
+    | None => dict->Dict.set(key, [idx])
+    }
+  let indexEvent = (idx: int, ev: DcbEventLog_Adapter.rawSequencedEvent) => {
+    pushInto(byType, ev.eventType, idx)
+    ev.tags->Array.forEach(t => pushInto(byTag, tagPostingKey(t.key, t.value), idx))
+  }
 
-  let read = async (~query, ~after=?) => {
-    let filtered = events.contents->Array.filter(event => {
+  // Ascending, duplicate-free superset of the indices that could satisfy the
+  // query (an OR of clauses). Narrowing only — the authoritative `matchesQuery`
+  // predicate is still applied to each candidate, so the result is identical to
+  // the old linear scan even if this over-includes. Callers guarantee query≠[].
+  let candidateIndices = (query: Reventless.DcbTag.query): array<int> => {
+    let acc: Dict.t<int> = Dict.make()
+    let addAll = (arr: array<int>) => arr->Array.forEach(i => acc->Dict.set(Int.toString(i), i))
+    query->Array.forEach(clause => {
+      switch clause.tags {
+      | Some(tags) if tags->Array.length > 0 =>
+        // Events carrying ALL of the clause's tags = intersection of the tags'
+        // posting lists; a missing tag ⇒ empty ⇒ this clause adds nothing.
+        let lists = tags->Array.map(t =>
+          byTag->Dict.get(tagPostingKey(t.key, t.value))->Option.getOr([])
+        )
+        if lists->Array.some(l => l->Array.length == 0) {
+          ()
+        } else {
+          let sorted = lists->Array.toSorted((a, b) => Int.toFloat(a->Array.length - b->Array.length))
+          let acc0 = sorted->Array.getUnsafe(0)
+          let folded =
+            sorted->Array.slice(~start=1, ~end=sorted->Array.length)->Array.reduce(acc0, intersectSorted)
+          addAll(folded)
+        }
+      | _ =>
+        // No tag constraint: narrow by event type when present (union of the
+        // types' posting lists — disjoint since an event has one type), else the
+        // clause is unconstrained and matches everything.
+        switch clause.eventTypes {
+        | Some(types) => types->Array.forEach(t => addAll(byType->Dict.get(t)->Option.getOr([])))
+        | None => events.contents->Array.forEachWithIndex((_, i) => acc->Dict.set(Int.toString(i), i))
+        }
+      }
+    })
+    acc->Dict.valuesToArray->Array.toSorted((a, b) => Int.toFloat(a - b))
+  }
+
+  let matchingEvents = (~query, ~after): array<DcbEventLog_Adapter.rawSequencedEvent> => {
+    let pass = (ev: DcbEventLog_Adapter.rawSequencedEvent) => {
       let afterMatch = switch after {
-      | Some(afterPos) => event.position->posToInt > afterPos->posToInt
+      | Some(afterPos) => ev.position->posToInt > afterPos->posToInt
       | None => true
       }
-      afterMatch && matchesQuery(event, query)
-    })
+      afterMatch && matchesQuery(ev, query)
+    }
+    if query->Array.length == 0 {
+      events.contents->Array.filter(pass)
+    } else {
+      candidateIndices(query)->Array.filterMap(i => {
+        let ev = events.contents->Array.getUnsafe(i)
+        pass(ev) ? Some(ev) : None
+      })
+    }
+  }
+
+  let read = async (~query, ~after=?) => {
+    let filtered = matchingEvents(~query, ~after)
     let headPosition =
       events.contents
       ->Array.get(events.contents->Array.length - 1)
@@ -50,30 +140,27 @@ let makeStorage = (~name as _name, ~indexes as _, ~partitionTag as _, ~opts as _
   let append = async (newEvents, ~condition=?) => {
     let conflictDetected = switch condition {
     | Some(cond: Reventless.DcbTag.appendCondition) =>
-      events.contents->Array.some(event => {
-        let afterMatch = switch cond.after {
-        | Some(pos) => event.position->posToInt > pos->posToInt
-        | None => true
-        }
-        afterMatch && matchesQuery(event, cond.query)
-      })
+      matchingEvents(~query=cond.query, ~after=cond.after)->Array.length > 0
     | None => false
     }
     if conflictDetected {
       Error("conflict: condition check failed")
     } else {
+      let base = events.contents->Array.length
       let storedEvents =
-        newEvents->Array.map((event: DcbEventLog_Adapter.rawStoredEvent) => {
+        newEvents->Array.mapWithIndex((event: DcbEventLog_Adapter.rawStoredEvent, j) => {
           position := position.contents + 1
           let pos = position.contents->Int.toString
-          {
-            DcbEventLog_Adapter.position: pos,
+          let stored: DcbEventLog_Adapter.rawSequencedEvent = {
+            position: pos,
             eventType: event.eventType,
             data: event.data,
             tags: event.tags,
             meta: event.meta,
             recordedAt: Message.nowAsISOString(),
           }
+          indexEvent(base + j, stored)
+          stored
         })
       events := events.contents->Array.concat(storedEvents)
       Ok(position.contents->Int.toString)
@@ -113,8 +200,6 @@ module Make = (Bus: LocalBus.T) => {
     | Some(db) =>
       let (storageName, read, storage) = DcbEventLogStorage_Sqlite.makeStorage(
         ~db,
-        ~bus=(_, _) => (),
-        ~publishToTopic=(~topicName as _, ~json as _) => (),
         ~name,
         ~indexes,
         ~partitionTag,