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

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 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.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.318",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -34,19 +34,19 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0",
     "ws": "^8.18.0",
+    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.30",
     "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.29",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.24",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.24",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.25",
     "@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-core": "3.0.0-alpha.326",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.275",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.221",
+    "@reventlessdev/reventless-seed": "1.0.0-alpha.40",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.174",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.192",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.190"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/LocalPlatformRegistry.res

@@ -27,6 +27,9 @@ 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,
 }
 
 // Threaded rather than read at each use, so tests need not move the process.
@@ -159,6 +162,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. */

package/src/LocalPlatformRegistry.res.mjs

@@ -22,7 +22,8 @@ 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))
 }));
 
 function runningDir(cwdOpt, param) {
@@ -152,6 +153,22 @@ function publishTapPort(port, tapPort, cwdOpt) {
   }
 }
 
+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) {
   let path = write(port, endpoint, loginEndpoint, store, tapPort, undefined, undefined);
   process.on("exit", param => removeQuietly(path));
@@ -177,6 +194,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: ({
@@ -1418,6 +1430,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 +2130,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({})
   };
@@ -1169,6 +1178,7 @@ function MakeWithConfig(Config) {
       path: match[1]
     }, undefined);
     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({})
   };
@@ -2958,6 +2975,7 @@ function Make($star) {
       path: match[1]
     }, undefined);
     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: …").

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

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
@@ -13,6 +14,7 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 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 SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
+import * as LocalEventLogRead$ReventlessLocal from "../LocalEventLogRead.res.mjs";
 import * as ProjectionPending$ReventlessLocal from "../ProjectionPending.res.mjs";
 
 function ensureSchema(db) {
@@ -20,6 +22,7 @@ function ensureSchema(db) {
   SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS dcb_tag (log_name TEXT NOT NULL, position INTEGER NOT NULL, tag_key TEXT NOT NULL, tag_value TEXT NOT NULL)");
   SqliteDriver$ReventlessLocal.exec(db, "CREATE INDEX IF NOT EXISTS dcb_tag_by_kv ON dcb_tag(log_name, tag_key, tag_value, position)");
   SqliteDriver$ReventlessLocal.exec(db, "CREATE INDEX IF NOT EXISTS dcb_tag_by_pos ON dcb_tag(log_name, position)");
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE INDEX IF NOT EXISTS dcb_event_by_correlation ON dcb_event(log_name, json_extract(meta, '$.correlationId'), position)");
 }
 
 function posToInt(pos) {
@@ -128,8 +131,73 @@ function buildQuerySql(logName, query, after) {
   ];
 }
 
+function readBackSql(name, bound, limit, correlationId) {
+  let parts = ["log_name = ?"];
+  let params = [name];
+  if (bound !== undefined) {
+    if (bound.TAG === "Below") {
+      parts.push("position < ?");
+      params.push(bound._0);
+    } else {
+      parts.push("position <= ?");
+      params.push(bound._0);
+    }
+  }
+  if (correlationId !== undefined) {
+    parts.push("json_extract(meta, '$.correlationId') = ?");
+    params.push(correlationId);
+  }
+  params.push(limit);
+  return [
+    `SELECT position, event_type, data, meta, recorded_at FROM dcb_event WHERE ` + parts.join(" AND ") + ` ORDER BY position DESC LIMIT ?`,
+    params
+  ];
+}
+
+function readBack(db, name) {
+  return async (bound, limit, correlationId) => {
+    let match = readBackSql(name, bound, limit, correlationId);
+    let rows = SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, match[0]), match[1]);
+    let positions = rows.map(row => Stdlib_Option.mapOr(row["position"], 0, coercePosition));
+    let tagsByPos = {};
+    if (positions.length !== 0) {
+      let placeholders = positions.map(param => "?").join(",");
+      SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, `SELECT position, tag_key, tag_value FROM dcb_tag WHERE log_name = ? AND position IN (` + placeholders + `) ORDER BY position ASC, rowid ASC`), [name].concat(positions.map(prim => prim))).forEach(row => {
+        let k = Stdlib_Option.mapOr(row["position"], 0, coercePosition).toString();
+        let str = key => Stdlib_Option.getOr(Stdlib_Option.flatMap(row[key], Stdlib_JSON.Decode.string), "");
+        let tag_key = str("tag_key");
+        let tag_value = str("tag_value");
+        let tag = {
+          key: tag_key,
+          value: tag_value
+        };
+        let list = tagsByPos[k];
+        if (list !== undefined) {
+          list.push(tag);
+        } else {
+          tagsByPos[k] = [tag];
+        }
+      });
+    }
+    return rows.map(row => {
+      let position = Stdlib_Option.mapOr(row["position"], 0, coercePosition);
+      let str = key => Stdlib_Option.getOr(Stdlib_Option.flatMap(row[key], Stdlib_JSON.Decode.string), "");
+      return {
+        log: name,
+        position: position,
+        eventType: str("event_type"),
+        tags: Stdlib_Option.getOr(tagsByPos[position.toString()], []),
+        payload: parseDataPayload(str("data")),
+        meta: parseDataPayload(str("meta")),
+        recordedAt: str("recorded_at")
+      };
+    });
+  };
+}
+
 function makeStorage(db, name, param, param$1, param$2) {
   ensureSchema(db);
+  LocalEventLogRead$ReventlessLocal.register(name, "Dcb", readBack(db, name));
   let insertEventStmt = SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO dcb_event(log_name, position, event_type, data, meta, recorded_at) VALUES(?,?,?,?,?,?)");
   let lastRowidStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT last_insert_rowid() AS r");
   let insertTagStmt = SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO dcb_tag(log_name, position, tag_key, tag_value) VALUES(?,?,?,?)");
@@ -263,6 +331,7 @@ function makeStorage(db, name, param, param$1, param$2) {
       }
     };
     let appended = [];
+    let positionsOf = [];
     try {
       SqliteDriver$ReventlessLocal.transaction(db, () => {
         if (condition !== undefined) {
@@ -310,6 +379,10 @@ function makeStorage(db, name, param, param$1, param$2) {
             tag.key,
             tag.value
           ]));
+          positionsOf.push([
+            event.meta.msgId,
+            pos
+          ]);
           lastPos.contents = pos;
         });
         result.contents = {
@@ -318,6 +391,7 @@ function makeStorage(db, name, param, param$1, param$2) {
         };
       });
       ProjectionPending$ReventlessLocal.trackAppended("Dcb", appended);
+      positionsOf.forEach(param => LocalEventLogRead$ReventlessLocal.note(name, param[0], param[1]));
       return result.contents;
     } catch (raw_msg) {
       let msg = Primitive_exceptions.internalToException(raw_msg);
@@ -380,6 +454,8 @@ export {
   buildClauseSql,
   buildQueryWhere,
   buildQuerySql,
+  readBackSql,
+  readBack,
   makeStorage,
 }
 /* Stdlib_JsExn Not a pure module */

package/src/adapter/DcbEventLog/LocalDcbEventLogStorage.res

@@ -37,7 +37,14 @@ module Make = (Bus: LocalBus.T) => {
         ~opts,
       )
       Bus.registerDcbEventLogRead(storageName, ops.read)
-      storage
+      LocalPgEventLogRead.registerDcb(~pool, ~name=storageName)
+      {
+        ReventlessCore.DcbEventLog_Adapter.resources: storage.resources,
+        operations: Pulumi.Output.make({
+          ...ops,
+          append: LocalPgEventLogRead.notingDcbAppend(~pool, ~name=storageName, ops.append),
+        }),
+      }
     | (None, None) =>
       let (storageName, read, storage) = DcbEventLogStorage_InMemory.makeStorage(
         ~name,