@reventlessdev/reventless-local 3.0.0-alpha.317 → 3.0.0-alpha.319

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 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.319 (2026-11-01)
+
+### Features
+
+* **core:** a component's log line carries the ids of the message it is about ([9c26267](https://github.com/ReventlessDev/reventless-core/commit/9c26267ca6d03ff66b8406caa32243e205e29b5a))
+* **local:** the registry entry names the platform API, and a command's outcome names its cause ([51717c4](https://github.com/ReventlessDev/reventless-core/commit/51717c441820c19dc59e595559b037b808ca716a))
+
+
+# 3.0.0-alpha.318 (2026-11-01)
+
+### Features
+
+* **core:** a command's outcome, the flow through automations, and each view change are told ([dcaeed2](https://github.com/ReventlessDev/reventless-core/commit/dcaeed2fabe2047a21797b459f2931618474dec3))
+* **local:** the local platform serves its logs and events to whoever watches it ([0c29b0d](https://github.com/ReventlessDev/reventless-core/commit/0c29b0d08c668ad5b948a8017178dad8692647d0))
+
+
 # 3.0.0-alpha.317 (2026-10-31)
 
 **Note:** Version bump only for package @reventlessdev/reventless-local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.317",
+  "version": "3.0.0-alpha.319",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -35,18 +35,18 @@
     "sury": "11.0.0",
     "ws": "^8.18.0",
     "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.29",
+    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.30",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.25",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.24",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.24",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.327",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.175",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.325",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.220",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.274",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.173",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.189",
-    "@reventlessdev/reventless-seed": "1.0.0-alpha.39",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.191"
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.276",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.221",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.191",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.192",
+    "@reventlessdev/reventless-seed": "1.0.0-alpha.40"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/LocalPlatformRegistry.res

@@ -27,6 +27,12 @@ type entry = {
   // DELETES an entry it cannot decode, so requiring it would silently hide every
   // platform from an older build. Absent ⇒ stdout only.
   tapPort?: int,
+  // Where the log feed is served, when it is: the platform's recent and live log
+  // records. Optional for the same reason as `tapPort`.
+  logPort?: int,
+  // Where the platform API is served: its own port when the platform serves two
+  // APIs, else the same endpoint as `endpoint`. Optional for the same reason.
+  platformEndpoint?: string,
 }
 
 // Threaded rather than read at each use, so tests need not move the process.
@@ -112,6 +118,7 @@ let write = (
   ~loginEndpoint: string,
   ~store: store,
   ~tapPort: option<int>=?,
+  ~platformEndpoint: option<string>=?,
   ~pid: int=NodeProcess.pid,
   ~cwd: string=NodeProcess.cwd(),
 ): string => {
@@ -125,6 +132,7 @@ let write = (
     store,
     startedAt: Date.make()->Date.toISOString,
     ?tapPort,
+    ?platformEndpoint,
   }
   try {
     NodeFs.mkdirSync(runningDir(~cwd, ()), {recursive: true})
@@ -159,6 +167,22 @@ let publishTapPort = (~port: int, ~tapPort: int, ~cwd=NodeProcess.cwd()): unit =
   }
 }
 
+/** Adds the log feed's port to an entry already written, once its socket is
+    bound; see {!publishTapPort}. */
+let publishLogPort = (~port: int, ~logPort: int, ~cwd=NodeProcess.cwd()): unit => {
+  let path = entryPath(~port, ~cwd)
+  switch readEntry(path) {
+  | None => ()
+  | Some(entry) =>
+    try NodeFs.writeFileSync(
+      path,
+      {...entry, logPort}->Reventless.Util_Sury.toJson(entrySchema)->JSON.stringify(~space=2),
+    ) catch {
+    | _ => ()
+    }
+  }
+}
+
 /** Publishes this process, and unpublishes it on the way out. Both paths are
     needed: `exit` is sync-only, and registering a signal handler suppresses
     Node's default exit, so each signal must leave explicitly. */
@@ -168,8 +192,9 @@ let register = (
   ~loginEndpoint: string,
   ~store: store,
   ~tapPort: option<int>=?,
+  ~platformEndpoint: option<string>=?,
 ): unit => {
-  let path = write(~port, ~endpoint, ~loginEndpoint, ~store, ~tapPort?)
+  let path = write(~port, ~endpoint, ~loginEndpoint, ~store, ~tapPort?, ~platformEndpoint?)
   NodeProcess.onExit(_ => removeQuietly(path))
   NodeProcess.onSignal(SIGINT, () => {
     removeQuietly(path)

package/src/LocalPlatformRegistry.res.mjs

@@ -22,7 +22,9 @@ let entrySchema = Sury.$schema(s => ({
   loginEndpoint: s.m(Sury.string),
   store: s.m(storeSchema),
   startedAt: s.m(Sury.string),
-  tapPort: s.m(Sury.$option(Sury.int32))
+  tapPort: s.m(Sury.$option(Sury.int32)),
+  logPort: s.m(Sury.$option(Sury.int32)),
+  platformEndpoint: s.m(Sury.$option(Sury.string))
 }));
 
 function runningDir(cwdOpt, param) {
@@ -109,7 +111,7 @@ function list(cwdOpt, param) {
   }).toSorted((a, b) => Primitive_int.compare(a.port, b.port));
 }
 
-function write(port, endpoint, loginEndpoint, store, tapPort, pidOpt, cwdOpt) {
+function write(port, endpoint, loginEndpoint, store, tapPort, platformEndpoint, pidOpt, cwdOpt) {
   let pid = pidOpt !== undefined ? pidOpt : process.pid;
   let cwd = cwdOpt !== undefined ? cwdOpt : process.cwd();
   let path = entryPath(port, cwd);
@@ -123,7 +125,8 @@ function write(port, endpoint, loginEndpoint, store, tapPort, pidOpt, cwdOpt) {
     loginEndpoint: loginEndpoint,
     store: store,
     startedAt: entry_startedAt,
-    tapPort: tapPort
+    tapPort: tapPort,
+    platformEndpoint: platformEndpoint
   };
   try {
     Nodefs.mkdirSync(runningDir(cwd, undefined), {
@@ -152,8 +155,24 @@ function publishTapPort(port, tapPort, cwdOpt) {
   }
 }
 
-function register(port, endpoint, loginEndpoint, store, tapPort) {
-  let path = write(port, endpoint, loginEndpoint, store, tapPort, undefined, undefined);
+function publishLogPort(port, logPort, cwdOpt) {
+  let cwd = cwdOpt !== undefined ? cwdOpt : process.cwd();
+  let path = entryPath(port, cwd);
+  let entry = readEntry(path);
+  if (entry === undefined) {
+    return;
+  }
+  try {
+    let newrecord = {...entry};
+    Nodefs.writeFileSync(path, JSON.stringify(Util_Sury$Reventless.toJson((newrecord.logPort = logPort, newrecord), entrySchema), undefined, 2), "utf8");
+    return;
+  } catch (exn) {
+    return;
+  }
+}
+
+function register(port, endpoint, loginEndpoint, store, tapPort, platformEndpoint) {
+  let path = write(port, endpoint, loginEndpoint, store, tapPort, platformEndpoint, undefined, undefined);
   process.on("exit", param => removeQuietly(path));
   process.on("SIGINT", () => {
     removeQuietly(path);
@@ -177,6 +196,7 @@ export {
   list,
   write,
   publishTapPort,
+  publishLogPort,
   register,
 }
 /* storeSchema Not a pure module */

package/src/Platform.res

@@ -106,6 +106,13 @@ module MakeWithConfig = (
   // local platform has no per-component process boundary.
   let _ = Config.commandHandlerConfig
 
+  // Keep the recent log records from here on, for the log feed and the MCP
+  // resource that read them.
+  LocalLogFeed.install()
+  // What became of each command, and each row a projection changed, on the
+  // event tap; a rejected command also in the problem ring.
+  LocalTapLines.install()
+
   // What this platform provides for the roles its plugins need: every account it
   // can sign in as, built-in and loaded alike, or the file the store will load
   // when the servers start — after the plugins are built and checked.
@@ -327,8 +334,13 @@ module MakeWithConfig = (
     // Event-history queries — the historical read counterpart of the Source A
     // subscription bridged further down. Same `eventLogEntries`, so the two
     // always describe the same set of streams.
-    eventQueryResolverHook: params =>
-      EventHistoryResolvers.register(~server=resolveTargetGraphQL(), params),
+    eventQueryResolverHook: params => {
+      // The read across every log names each event's plugin.
+      params.eventLogEntries->Array.forEach(entry =>
+        LocalEventLogRead.notePlugin(~log=entry.busKey, ~plugin=params.pluginName)
+      )
+      EventHistoryResolvers.register(~server=resolveTargetGraphQL(), params)
+    },
     // MCP tools and resources — registered during plugin construction.
     // See the large lambda below; it references Bus for QueryDb lookups.
     mcpSchemaRegistrationHook: ({
@@ -1410,6 +1422,9 @@ module MakeWithConfig = (
       ~endpoint=`http://localhost:${domainPort->Int.toString}/graphql`,
       ~loginEndpoint=`http://localhost:${domainPort->Int.toString}/__inmemory/login`,
       ~store={kind, ?path},
+      ~platformEndpoint=Config.splitApi
+        ? `http://localhost:${platformPort->Int.toString}/graphql`
+        : `http://localhost:${domainPort->Int.toString}/graphql`,
     )
     // After the register, and it fills the tap port in once the socket is bound:
     // the port is ephemeral by default, so it is not known until `listen` calls
@@ -1418,6 +1433,11 @@ module MakeWithConfig = (
       ~onBound=tapPort => LocalPlatformRegistry.publishTapPort(~port=domainPort, ~tapPort),
       (),
     )
+    // The log feed, the same way: its port is filled in once it is bound.
+    LocalLogFeed.start(
+      ~onBound=logPort => LocalPlatformRegistry.publishLogPort(~port=domainPort, ~logPort),
+      (),
+    )
     // Fire onPlatformDeployed after all servers are started so late-deployed
     // plugins (e.g. PlatformInspector) have their handler refs populated.
     ReventlessCore.Plugin_Helpers.firePlatformDeployedHook({
@@ -2113,6 +2133,11 @@ module MakeWithConfig = (
 
     platformGraphQL.registerQueries(~sdlFields=baseParts.queries, ~resolvers=queryResolvers)
 
+    // What a tool watching this platform reads: every event of every log, and
+    // the log level while running.
+    LocalPlatformObserve.registerGraphQL(platformGraphQL)
+    LocalPlatformObserve.registerMcp(platformMCP)
+
     // Admin Plugin lifecycle mutations (Activate / Deactivate / Retire) now flow
     // through the LocalPluginAggregate, mirroring AWS. The resolver looks up the
     // plugin's current version from the "Plugins" read model (the aggregate is

package/src/Platform.res.mjs

@@ -38,11 +38,13 @@ import * as ShellConfig$ReventlessLocal from "./ShellConfig.res.mjs";
 import * as AccountStore$ReventlessLocal from "./adapter/Auth/AccountStore.res.mjs";
 import * as BackendState$ReventlessLocal from "./adapter/BackendState.res.mjs";
 import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/src/ComponentType.res.mjs";
+import * as LocalLogFeed$ReventlessLocal from "./adapter/LocalLogFeed.res.mjs";
 import * as SqliteDriver$ReventlessLocal from "./adapter/SqliteDriver.res.mjs";
 import * as Task_Builder$ReventlessLocal from "./components/Task_Builder.res.mjs";
 import * as BakedManifest$ReventlessLocal from "./BakedManifest.res.mjs";
 import * as HostShellDist$ReventlessLocal from "./HostShellDist.res.mjs";
 import * as LocalEventTap$ReventlessLocal from "./adapter/LocalEventTap.res.mjs";
+import * as LocalTapLines$ReventlessLocal from "./adapter/LocalTapLines.res.mjs";
 import * as Platform_Admin$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_Admin.res.mjs";
 import * as PluginDecision$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginDecision.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
@@ -63,6 +65,7 @@ import * as Scheduler_Builder$ReventlessCore from "@reventlessdev/reventless-cor
 import * as Aggregate_Builder$ReventlessLocal from "./components/Aggregate_Builder.res.mjs";
 import * as LocalCapabilities$ReventlessLocal from "./adapter/LocalCapabilities.res.mjs";
 import * as LocalClonerRunner$ReventlessLocal from "./adapter/Cloner/LocalClonerRunner.res.mjs";
+import * as LocalEventLogRead$ReventlessLocal from "./adapter/LocalEventLogRead.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";
@@ -77,6 +80,7 @@ import * as PluginsReadModelSpec$ReventlessCore from "@reventlessdev/reventless-
 import * as StorePrefixCollision$ReventlessCore from "@reventlessdev/reventless-core/src/util/StorePrefixCollision.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 LocalPlatformObserve$ReventlessLocal from "./adapter/LocalPlatformObserve.res.mjs";
 import * as LocalUploadResolvers$ReventlessLocal from "./adapter/LocalUploadResolvers.res.mjs";
 import * as ProjectionCheckpoint$ReventlessLocal from "./adapter/ProjectionCheckpoint.res.mjs";
 import * as ExtensionPointMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionPointMapping.res.mjs";
@@ -146,6 +150,8 @@ function decodeUiFragmentRegistryEventEnvelope(eventJson) {
 }
 
 function MakeWithConfig(Config) {
+  LocalLogFeed$ReventlessLocal.install(undefined);
+  LocalTapLines$ReventlessLocal.install();
   Role$Reventless.provideGroupsFrom(AccountStore$ReventlessLocal.providedGroups);
   TestRunner$ReventlessLocal.setup();
   let match = Config.backend;
@@ -444,7 +450,10 @@ function MakeWithConfig(Config) {
     });
     LocalGraphQL_SubscriptionResolvers$ReventlessLocal.registerAll(server, subscriptionFields, sourceAEntries, []);
   };
-  let hooks_eventQueryResolverHook = params => EventHistoryResolvers.register(resolveTargetGraphQL(), params);
+  let hooks_eventQueryResolverHook = params => {
+    params.eventLogEntries.forEach(entry => LocalEventLogRead$ReventlessLocal.notePlugin(entry.busKey, params.pluginName));
+    EventHistoryResolvers.register(resolveTargetGraphQL(), params);
+  };
   let hooks_adminExtensionPoints = {
     contents: Pulumi.output({})
   };
@@ -1167,8 +1176,9 @@ function MakeWithConfig(Config) {
     LocalPlatformRegistry$ReventlessLocal.register(domainPort, `http://localhost:` + domainPort.toString() + `/graphql`, `http://localhost:` + domainPort.toString() + `/__inmemory/login`, {
       kind: match[0],
       path: match[1]
-    }, undefined);
+    }, undefined, Config.splitApi ? `http://localhost:` + platformPort.toString() + `/graphql` : `http://localhost:` + domainPort.toString() + `/graphql`);
     LocalEventTap$ReventlessLocal.start(undefined, tapPort => LocalPlatformRegistry$ReventlessLocal.publishTapPort(domainPort, tapPort, undefined), undefined);
+    LocalLogFeed$ReventlessLocal.start(undefined, logPort => LocalPlatformRegistry$ReventlessLocal.publishLogPort(domainPort, logPort, undefined), undefined);
     Plugin_Helpers$ReventlessCore.firePlatformDeployedHook({
       name: "local",
       environment: Pulumi.getStack(),
@@ -1545,6 +1555,8 @@ function MakeWithConfig(Config) {
     };
     registerAdminItemsAndIndexResolvers(queryResolvers, true);
     platformGraphQL.registerQueries(baseParts.queries, queryResolvers);
+    LocalPlatformObserve$ReventlessLocal.registerGraphQL(platformGraphQL);
+    LocalPlatformObserve$ReventlessLocal.registerMcp(platformMCP);
     let argId = args => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d["id"]), Stdlib_JSON.Decode.string), "");
     let currentVersionOf = pluginName => {
       let scanAll = Bus.getQueryDbScan(PluginsReadModelSpec$ReventlessCore.name);
@@ -1946,6 +1958,8 @@ function MakeWithConfig(Config) {
 
 function Make($star) {
   let backend = Backend$ReventlessLocal.fromEnv();
+  LocalLogFeed$ReventlessLocal.install(undefined);
+  LocalTapLines$ReventlessLocal.install();
   Role$Reventless.provideGroupsFrom(AccountStore$ReventlessLocal.providedGroups);
   TestRunner$ReventlessLocal.setup();
   if (typeof backend !== "object") {
@@ -2237,7 +2251,10 @@ function Make($star) {
     });
     LocalGraphQL_SubscriptionResolvers$ReventlessLocal.registerAll(server, subscriptionFields, sourceAEntries, []);
   };
-  let hooks_eventQueryResolverHook = params => EventHistoryResolvers.register(resolveTargetGraphQL(), params);
+  let hooks_eventQueryResolverHook = params => {
+    params.eventLogEntries.forEach(entry => LocalEventLogRead$ReventlessLocal.notePlugin(entry.busKey, params.pluginName));
+    EventHistoryResolvers.register(resolveTargetGraphQL(), params);
+  };
   let hooks_adminExtensionPoints = {
     contents: Pulumi.output({})
   };
@@ -2956,8 +2973,9 @@ function Make($star) {
     LocalPlatformRegistry$ReventlessLocal.register(domainPort, `http://localhost:` + domainPort.toString() + `/graphql`, `http://localhost:` + domainPort.toString() + `/__inmemory/login`, {
       kind: match[0],
       path: match[1]
-    }, undefined);
+    }, undefined, `http://localhost:` + platformPort.toString() + `/graphql`);
     LocalEventTap$ReventlessLocal.start(undefined, tapPort => LocalPlatformRegistry$ReventlessLocal.publishTapPort(domainPort, tapPort, undefined), undefined);
+    LocalLogFeed$ReventlessLocal.start(undefined, logPort => LocalPlatformRegistry$ReventlessLocal.publishLogPort(domainPort, logPort, undefined), undefined);
     Plugin_Helpers$ReventlessCore.firePlatformDeployedHook({
       name: "local",
       environment: Pulumi.getStack(),
@@ -3333,6 +3351,8 @@ function Make($star) {
     };
     registerAdminItemsAndIndexResolvers(queryResolvers, true);
     platformGraphQL.registerQueries(baseParts.queries, queryResolvers);
+    LocalPlatformObserve$ReventlessLocal.registerGraphQL(platformGraphQL);
+    LocalPlatformObserve$ReventlessLocal.registerMcp(platformMCP);
     let argId = args => Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d["id"]), Stdlib_JSON.Decode.string), "");
     let currentVersionOf = pluginName => {
       let scanAll = Bus.getQueryDbScan(PluginsReadModelSpec$ReventlessCore.name);

package/src/adapter/DcbEventLog/DcbEventLogStorage_InMemory.res

@@ -128,6 +128,39 @@ let makeStorage = (~name as _name, ~indexes as _, ~partitionTag as _, ~opts as _
     }
   }
 
+  // Newest first, for the read across every log.
+  LocalEventLogRead.register(~log=_name, ~kind=Dcb, async (~bound, ~limit, ~correlationId) => {
+    let out = []
+    let i = ref(events.contents->Array.length - 1)
+    while i.contents >= 0 && out->Array.length < limit {
+      let ev = events.contents->Array.getUnsafe(i.contents)
+      let position = ev.position->posToInt->Int.toFloat
+      let inBound = switch bound {
+      | Some(LocalEventLogRead.Below(p)) => position < p
+      | Some(AtMost(p)) => position <= p
+      | None => true
+      }
+      let inFlow = correlationId->Option.mapOr(true, id => ev.meta.correlationId == id)
+      if inBound && inFlow {
+        out->Array.push(
+          (
+            {
+              log: _name,
+              position,
+              eventType: ev.eventType,
+              tags: ev.tags,
+              payload: ev.data,
+              meta: ev.meta->Reventless.Util_Sury.toJson(Reventless.Message.metaSchema),
+              recordedAt: ev.recordedAt,
+            }: LocalEventLogRead.stored
+          ),
+        )
+      }
+      i := i.contents - 1
+    }
+    out
+  })
+
   let read = async (~query, ~after=?) => {
     let filtered = matchingEvents(~query, ~after)
     let headPosition =
@@ -165,6 +198,11 @@ let makeStorage = (~name as _name, ~indexes as _, ~partitionTag as _, ~opts as _
           recordedAt: Message.nowAsISOString(),
         }
         indexEvent(base + j, stored)
+        LocalEventLogRead.note(
+          ~log=_name,
+          ~msgId=event.meta.msgId,
+          ~position=position.contents->Int.toFloat,
+        )
         stored
       })
       events := events.contents->Array.concat(storedEvents)

package/src/adapter/DcbEventLog/DcbEventLogStorage_InMemory.res.mjs

@@ -6,7 +6,10 @@ 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 Pulumi from "@pulumi/pulumi";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as LocalEventLogRead$ReventlessLocal from "../LocalEventLogRead.res.mjs";
 
 function posToInt(pos) {
   return Stdlib_Option.getOr(Stdlib_Int.fromString(pos, undefined), 0);
@@ -130,6 +133,31 @@ function makeStorage(_name, param, param$1, param$2) {
       });
     }
   };
+  LocalEventLogRead$ReventlessLocal.register(_name, "Dcb", async (bound, limit, correlationId) => {
+    let out = [];
+    let i = events.contents.length - 1 | 0;
+    while (i >= 0 && out.length < limit) {
+      let ev = events.contents[i];
+      let position = posToInt(ev.position);
+      let inBound = bound !== undefined ? (
+          bound.TAG === "Below" ? position < bound._0 : position <= bound._0
+        ) : true;
+      let inFlow = Stdlib_Option.mapOr(correlationId, true, id => ev.meta.correlationId === id);
+      if (inBound && inFlow) {
+        out.push({
+          log: _name,
+          position: position,
+          eventType: ev.eventType,
+          tags: ev.tags,
+          payload: ev.data,
+          meta: Util_Sury$Reventless.toJson(ev.meta, Message$Reventless.metaSchema),
+          recordedAt: ev.recordedAt
+        });
+      }
+      i = i - 1 | 0;
+    };
+    return out;
+  });
   let read = async (query, after) => {
     let filtered = matchingEvents(query, after);
     let headPosition = Stdlib_Option.map(events.contents[events.contents.length - 1 | 0], e => e.position);
@@ -164,6 +192,7 @@ function makeStorage(_name, param, param$1, param$2) {
         recordedAt: stored_recordedAt
       };
       indexEvent(base + j | 0, stored);
+      LocalEventLogRead$ReventlessLocal.note(_name, event.meta.msgId, position.contents);
       return stored;
     });
     events.contents = events.contents.concat(storedEvents);

package/src/adapter/DcbEventLog/DcbEventLogStorage_Sqlite.res

@@ -38,6 +38,11 @@ let ensureSchema = (db: SqliteDriver.t) => {
   // IN (...)` batch). The `_by_kv` index leads with tag_key/tag_value, so it
   // cannot answer a position lookup — without this the batch scanned dcb_tag.
   db->SqliteDriver.exec("CREATE INDEX IF NOT EXISTS dcb_tag_by_pos ON dcb_tag(log_name, position)")
+  // Finding every event of one flow in one log. Created on open, so an existing store gains
+  // it; a query must use this exact expression for the index to apply.
+  db->SqliteDriver.exec(
+    "CREATE INDEX IF NOT EXISTS dcb_event_by_correlation ON dcb_event(log_name, json_extract(meta, '$.correlationId'), position)",
+  )
 }
 
 let posToInt = (pos: string) => pos->Int.fromString->Option.getOr(0)
@@ -157,6 +162,81 @@ let buildQuerySql = (~logName: string, ~query: DcbTag.query, ~after: option<int>
   )
 }
 
+/** The SQL of one backwards read, and its parameters. */
+let readBackSql = (
+  ~name: string,
+  ~bound: option<LocalEventLogRead.bound>,
+  ~limit: int,
+  ~correlationId: option<string>,
+): (string, array<JSON.t>) => {
+  let parts = ["log_name = ?"]
+  let params = [JSON.Encode.string(name)]
+  switch bound {
+  | Some(LocalEventLogRead.Below(p)) =>
+    parts->Array.push("position < ?")
+    params->Array.push(JSON.Encode.float(p))
+  | Some(AtMost(p)) =>
+    parts->Array.push("position <= ?")
+    params->Array.push(JSON.Encode.float(p))
+  | None => ()
+  }
+  switch correlationId {
+  | Some(id) =>
+    parts->Array.push("json_extract(meta, '$.correlationId') = ?")
+    params->Array.push(JSON.Encode.string(id))
+  | None => ()
+  }
+  params->Array.push(JSON.Encode.int(limit))
+  (
+    `SELECT position, event_type, data, meta, recorded_at FROM dcb_event WHERE ${parts->Array.join(
+        " AND ",
+      )} ORDER BY position DESC LIMIT ?`,
+    params,
+  )
+}
+
+/** Reads one log newest first by position, with each event's tags. */
+let readBack = (~db: SqliteDriver.t, ~name: string): LocalEventLogRead.readBack =>
+  async (~bound, ~limit, ~correlationId) => {
+    let (sql, params) = readBackSql(~name, ~bound, ~limit, ~correlationId)
+    let rows = db->SqliteDriver.prepare(sql)->SqliteDriver.all(params)
+    let positions =
+      rows->Array.map(row => row->Dict.get("position")->Option.mapOr(0, coercePosition))
+    let tagsByPos: Dict.t<array<DcbTag.tag>> = Dict.make()
+    if positions->Array.length > 0 {
+      let placeholders = positions->Array.map(_ => "?")->Array.join(",")
+      db
+      ->SqliteDriver.prepare(
+        `SELECT position, tag_key, tag_value FROM dcb_tag WHERE log_name = ? AND position IN (${placeholders}) ORDER BY position ASC, rowid ASC`,
+      )
+      ->SqliteDriver.all(
+        [JSON.Encode.string(name)]->Array.concat(positions->Array.map(JSON.Encode.int)),
+      )
+      ->Array.forEach(row => {
+        let k = row->Dict.get("position")->Option.mapOr(0, coercePosition)->Int.toString
+        let str = key => row->Dict.get(key)->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+        let tag: DcbTag.tag = {key: str("tag_key"), value: str("tag_value")}
+        switch tagsByPos->Dict.get(k) {
+        | Some(list) => list->Array.push(tag)
+        | None => tagsByPos->Dict.set(k, [tag])
+        }
+      })
+    }
+    rows->Array.map((row): LocalEventLogRead.stored => {
+      let position = row->Dict.get("position")->Option.mapOr(0, coercePosition)
+      let str = key => row->Dict.get(key)->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+      {
+        log: name,
+        position: position->Int.toFloat,
+        eventType: str("event_type"),
+        tags: tagsByPos->Dict.get(position->Int.toString)->Option.getOr([]),
+        payload: parseDataPayload(str("data")),
+        meta: parseDataPayload(str("meta")),
+        recordedAt: str("recorded_at"),
+      }
+    })
+  }
+
 let makeStorage = (
   ~db: SqliteDriver.t,
   ~name: string,
@@ -165,6 +245,7 @@ let makeStorage = (
   ~opts as _,
 ) => {
   ensureSchema(db)
+  LocalEventLogRead.register(~log=name, ~kind=Dcb, readBack(~db, ~name))
 
   let insertEventStmt =
     db->SqliteDriver.prepare(
@@ -327,6 +408,8 @@ let makeStorage = (
     // each event insert — before the tag inserts move last_insert_rowid() to
     // the dcb_tag table. Registered only after the transaction commits.
     let appended: array<(string, int)> = []
+    // (msgId, position) per inserted event, for the tap line that publishes it.
+    let positionsOf: array<(string, int)> = []
     try {
       db->SqliteDriver.transaction(() => {
         switch condition {
@@ -371,12 +454,16 @@ let makeStorage = (
               ])
             },
           )
+          positionsOf->Array.push((event.meta.msgId, pos))
           lastPos := pos
         })
 
         result := Ok(Int.toString(lastPos.contents))
       })
       ProjectionPending.trackAppended(~axis=ProjectionPending.Dcb, appended)
+      positionsOf->Array.forEach(((msgId, pos)) =>
+        LocalEventLogRead.note(~log=name, ~msgId, ~position=pos->Int.toFloat)
+      )
       result.contents
     } catch {
     // The deliberate append-condition failure throws Failure("conflict: …").