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

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.320 (2026-11-02)
+
+### Features
+
+* a view row knows its last change, and the local platform keeps every change ([1a1fd71](https://github.com/ReventlessDev/reventless-core/commit/1a1fd7117d9837696a7c0080dcd6f0983e57780c))
+* **local:** a platform left running for an editor stops once nothing watches it ([1ccff67](https://github.com/ReventlessDev/reventless-core/commit/1ccff678126053dbce88ee002c6800af1333cac6))
+* **local:** the app's API logs each request and subscription it answers ([31a163c](https://github.com/ReventlessDev/reventless-core/commit/31a163c945d8929e9a604cc0dc8a74939320f85e))
+* **local:** the local platform counts its metrics instead of logging them ([76c6094](https://github.com/ReventlessDev/reventless-core/commit/76c60946fa74520519dccb4ae39fae5880817832))
+* **local:** the local platform keeps every command outcome ([252ed2e](https://github.com/ReventlessDev/reventless-core/commit/252ed2ea46f2634b86851aea402e94af7c371f10))
+
+
+# 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.318",
+  "version": "3.0.0-alpha.320",
   "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.31",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.24",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.25",
+    "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.26",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.328",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.176",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.277",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
-    "@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"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.222",
+    "@reventlessdev/reventless-seed": "1.0.0-alpha.41",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.193",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.192"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/LocalPlatformRegistry.res

@@ -30,6 +30,9 @@ type entry = {
   // 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.
@@ -115,6 +118,7 @@ let write = (
   ~loginEndpoint: string,
   ~store: store,
   ~tapPort: option<int>=?,
+  ~platformEndpoint: option<string>=?,
   ~pid: int=NodeProcess.pid,
   ~cwd: string=NodeProcess.cwd(),
 ): string => {
@@ -128,6 +132,7 @@ let write = (
     store,
     startedAt: Date.make()->Date.toISOString,
     ?tapPort,
+    ?platformEndpoint,
   }
   try {
     NodeFs.mkdirSync(runningDir(~cwd, ()), {recursive: true})
@@ -187,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

@@ -23,7 +23,8 @@ let entrySchema = Sury.$schema(s => ({
   store: s.m(storeSchema),
   startedAt: s.m(Sury.string),
   tapPort: s.m(Sury.$option(Sury.int32)),
-  logPort: s.m(Sury.$option(Sury.int32))
+  logPort: s.m(Sury.$option(Sury.int32)),
+  platformEndpoint: s.m(Sury.$option(Sury.string))
 }));
 
 function runningDir(cwdOpt, param) {
@@ -110,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);
@@ -124,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), {
@@ -169,8 +171,8 @@ function publishLogPort(port, logPort, cwdOpt) {
   }
 }
 
-function register(port, endpoint, loginEndpoint, store, tapPort) {
-  let path = write(port, endpoint, loginEndpoint, store, tapPort, undefined, undefined);
+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);

package/src/Platform.res

@@ -23,6 +23,10 @@ ReventlessCore.EffectLogger.setDefaultMinLevel(ReventlessCore.Logger.Debug)
 // REVENTLESS_LOG_FORMAT still wins.
 Reventless.AnsiStyle.setDefaultFormat(#text)
 
+// Locally nothing collects metric lines, so metrics are counted and served on the
+// platform API instead of written among the log lines.
+LocalMetrics.install()
+
 let log = ReventlessCore.Logger.fromEnv()
 
 // Module-level ref to hold the platform GraphQL server instance in split mode.
@@ -112,11 +116,18 @@ module MakeWithConfig = (
   // 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()
+  // Every row change, kept so a tool that missed one live can read it back.
+  LocalViewChangeLog.install()
+  // And what became of every command, for the same reason.
+  LocalCommandOutcomeLog.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.
   Reventless.Role.provideGroupsFrom(AccountStore.providedGroups)
+  // The administrator reads across every owner, as a deployment's does: the same default the
+  // AWS platform sets, and like it never a forcing over an explicit `setElevatedGroups`.
+  Reventless.OwnerScope.defaultElevatedRoles([Reventless.Role.admin])
   // Activate Pulumi mock mode — must happen before any component creation.
   // Idempotent, so safe to call even if TestRunner.setup() was already called.
   let _ = TestRunner.setup()
@@ -1422,7 +1433,12 @@ 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`,
     )
+    // A platform left running for an editor stops once nothing has watched it for a while.
+    LocalIdleExit.start(~env=NodeProcess.env)
     // 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
     // back. The entry therefore never names a port that is not listening.

package/src/Platform.res.mjs

@@ -39,11 +39,13 @@ import * as AccountStore$ReventlessLocal from "./adapter/Auth/AccountStore.res.m
 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 LocalMetrics$ReventlessLocal from "./adapter/LocalMetrics.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 LocalIdleExit$ReventlessLocal from "./adapter/LocalIdleExit.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";
@@ -72,6 +74,7 @@ import * as ReadModel_Builder$ReventlessLocal from "./components/ReadModel_Build
 import * as UiFragmentRegistry$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChange/UiFragmentRegistry.res.mjs";
 import * as LocalEvents_Server$ReventlessLocal from "./adapter/Api/LocalEvents_Server.res.mjs";
 import * as LocalPlatformStart$ReventlessLocal from "./LocalPlatformStart.res.mjs";
+import * as LocalViewChangeLog$ReventlessLocal from "./adapter/ViewChangeLog/LocalViewChangeLog.res.mjs";
 import * as PlatformMCP_Server$ReventlessLocal from "./adapter/PlatformMCP_Server.res.mjs";
 import * as ResourceAttribution$ReventlessCore from "@reventlessdev/reventless-core/src/ResourceAttribution.res.mjs";
 import * as Auth_GraphqlContext$ReventlessLocal from "./adapter/Auth/Auth_GraphqlContext.res.mjs";
@@ -89,6 +92,7 @@ import * as LocalPlatformRegistry$ReventlessLocal from "./LocalPlatformRegistry.
 import * as UiFragments_Projection$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateView/UiFragments_Projection.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";
+import * as LocalCommandOutcomeLog$ReventlessLocal from "./adapter/CommandOutcomeLog/LocalCommandOutcomeLog.res.mjs";
 import * as PlatformGraphQL_Server$ReventlessLocal from "./adapter/PlatformGraphQL_Server.res.mjs";
 import * as Platform_UIFragmentsApi$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_UIFragmentsApi.res.mjs";
 import * as StateViewSlice_Builder$ReventlessLocal from "./components/StateViewSlice_Builder.res.mjs";
@@ -119,6 +123,8 @@ EffectLogger$ReventlessCore.setDefaultMinLevel("Debug");
 
 AnsiStyle$Reventless.setDefaultFormat("text");
 
+LocalMetrics$ReventlessLocal.install();
+
 let log = Logger$ReventlessCore.fromEnv();
 
 let platformGraphQLRef = {
@@ -152,7 +158,10 @@ function decodeUiFragmentRegistryEventEnvelope(eventJson) {
 function MakeWithConfig(Config) {
   LocalLogFeed$ReventlessLocal.install(undefined);
   LocalTapLines$ReventlessLocal.install();
+  LocalViewChangeLog$ReventlessLocal.install();
+  LocalCommandOutcomeLog$ReventlessLocal.install();
   Role$Reventless.provideGroupsFrom(AccountStore$ReventlessLocal.providedGroups);
+  OwnerScope$Reventless.defaultElevatedRoles([Role$Reventless.admin]);
   TestRunner$ReventlessLocal.setup();
   let match = Config.backend;
   if (typeof match !== "object") {
@@ -1176,7 +1185,8 @@ 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`);
+    LocalIdleExit$ReventlessLocal.start(process.env);
     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({
@@ -1960,7 +1970,10 @@ function Make($star) {
   let backend = Backend$ReventlessLocal.fromEnv();
   LocalLogFeed$ReventlessLocal.install(undefined);
   LocalTapLines$ReventlessLocal.install();
+  LocalViewChangeLog$ReventlessLocal.install();
+  LocalCommandOutcomeLog$ReventlessLocal.install();
   Role$Reventless.provideGroupsFrom(AccountStore$ReventlessLocal.providedGroups);
+  OwnerScope$Reventless.defaultElevatedRoles([Role$Reventless.admin]);
   TestRunner$ReventlessLocal.setup();
   if (typeof backend !== "object") {
     BackendState$ReventlessLocal.setMemory();
@@ -2973,7 +2986,8 @@ 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`);
+    LocalIdleExit$ReventlessLocal.start(process.env);
     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({

package/src/adapter/Api/LocalEvents_Server.res

@@ -48,14 +48,16 @@ type connection = {
   send: string => unit,
   /** subscription id → channel (exact, or ending in a `*` wildcard). */
   subscriptions: dict<string>,
+  /** Who connected, when a token said. */
+  user?: string,
 }
 
 let connections: ref<array<connection>> = ref([])
 let nextConnectionId = ref(0)
 
-let addConnection = (~send: string => unit): connection => {
+let addConnection = (~send: string => unit, ~user: option<string>=?): connection => {
   nextConnectionId.contents = nextConnectionId.contents + 1
-  let conn = {id: nextConnectionId.contents, send, subscriptions: Dict.make()}
+  let conn = {id: nextConnectionId.contents, send, subscriptions: Dict.make(), ?user}
   connections.contents->Array.push(conn)
   conn
 }
@@ -176,6 +178,27 @@ let decodeStringField = (json: JSON.t, field: string): option<string> =>
   ->Option.flatMap(o => o->Dict.get(field))
   ->Option.flatMap(JSON.Decode.string)
 
+/** The line a client's subscribing or unsubscribing is told by. */
+let subscriptionLine = (conn: connection, ~verb: string, ~channel: string) =>
+  `${verb} ${channel}${conn.user->Option.mapOr("", u => ` by ${u}`)}`
+
+let logSubscription = (conn: connection, ~verb: string, ~channel: string) =>
+  if ReventlessCore.Logger.shouldLog(Debug, ~comp="Events:Local", ()) {
+    ReventlessCore.Logger.emit(
+      ~level=Debug,
+      ~comp="Events:Local",
+      ~detail=JSON.Encode.object(
+        Dict.fromArray(
+          [
+            ("channel", JSON.Encode.string(channel)),
+            ("connection", JSON.Encode.int(conn.id)),
+          ]->Array.concat(conn.user->Option.mapOr([], u => [("user", JSON.Encode.string(u))])),
+        ),
+      ),
+      subscriptionLine(conn, ~verb, ~channel),
+    )
+  }
+
 /** Handle one client→server text frame on an established connection. */
 let handleFrame = (conn: connection, text: string): unit => {
   let parsed = try Some(text->JSON.parseOrThrow) catch {
@@ -190,6 +213,7 @@ let handleFrame = (conn: connection, text: string): unit => {
       switch (decodeStringField(json, "id"), decodeStringField(json, "channel")) {
       | (Some(id), Some(channel)) =>
         conn.subscriptions->Dict.set(id, channel)
+        logSubscription(conn, ~verb="subscribe", ~channel)
         conn.send(
           frame([
             ("type", JSON.Encode.string("subscribe_success")),
@@ -201,6 +225,9 @@ let handleFrame = (conn: connection, text: string): unit => {
     | Some("unsubscribe") =>
       switch decodeStringField(json, "id") {
       | Some(id) =>
+        conn.subscriptions
+        ->Dict.get(id)
+        ->Option.forEach(channel => logSubscription(conn, ~verb="unsubscribe", ~channel))
         conn.subscriptions->Dict.delete(id)
         conn.send(
           frame([
@@ -367,7 +394,11 @@ let attach = (~server: YG.httpServer, ~port: int): unit => {
     if tokenIsInvalid(auth) {
       ws->wsClose(4401, "Invalid token")
     } else {
-      let conn = addConnection(~send=f => ws->wsSend(f))
+      let user =
+        auth
+        ->Option.flatMap(t => LocalAuth.Login.verifyAndDecode(stripBearer(t)))
+        ->Option.map(i => i.username)
+      let conn = addConnection(~send=f => ws->wsSend(f), ~user?)
       ws->onMessage(data => handleFrame(conn, data->wsMessageToString("utf8")))
       ws->onSocketClose(() => removeConnection(conn))
     }

package/src/adapter/Api/LocalEvents_Server.res.mjs

@@ -32,14 +32,15 @@ let nextConnectionId = {
   contents: 0
 };
 
-function addConnection(send) {
+function addConnection(send, user) {
   nextConnectionId.contents = nextConnectionId.contents + 1 | 0;
   let conn_id = nextConnectionId.contents;
   let conn_subscriptions = {};
   let conn = {
     id: conn_id,
     send: send,
-    subscriptions: conn_subscriptions
+    subscriptions: conn_subscriptions,
+    user: user
   };
   connections.contents.push(conn);
   return conn;
@@ -127,6 +128,28 @@ function decodeStringField(json, field) {
   return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o[field]), Stdlib_JSON.Decode.string);
 }
 
+function subscriptionLine(conn, verb, channel) {
+  return verb + ` ` + channel + Stdlib_Option.mapOr(conn.user, "", u => ` by ` + u);
+}
+
+function logSubscription(conn, verb, channel) {
+  if (Logger$ReventlessCore.shouldLog("Debug", undefined, "Events:Local", undefined)) {
+    return Logger$ReventlessCore.emit("Debug", "Events:Local", undefined, Object.fromEntries([
+      [
+        "channel",
+        channel
+      ],
+      [
+        "connection",
+        conn.id
+      ]
+    ].concat(Stdlib_Option.mapOr(conn.user, [], u => [[
+        "user",
+        u
+      ]]))), undefined, subscriptionLine(conn, verb, channel));
+  }
+}
+
 function handleFrame(conn, text) {
   let parsed;
   try {
@@ -149,6 +172,7 @@ function handleFrame(conn, text) {
       let match$2 = decodeStringField(parsed, "channel");
       if (match$1 !== undefined && match$2 !== undefined) {
         conn.subscriptions[match$1] = match$2;
+        logSubscription(conn, "subscribe", match$2);
         return conn.send(frame([
           [
             "type",
@@ -165,6 +189,7 @@ function handleFrame(conn, text) {
     case "unsubscribe" :
       let id = decodeStringField(parsed, "id");
       if (id !== undefined) {
+        Stdlib_Option.forEach(conn.subscriptions[id], channel => logSubscription(conn, "unsubscribe", channel));
         Stdlib_Dict.$$delete(conn.subscriptions, id);
         return conn.send(frame([
           [
@@ -320,9 +345,10 @@ function attach(server, port) {
       ws.close(4401, "Invalid token");
       return;
     }
+    let user = Stdlib_Option.map(Stdlib_Option.flatMap(auth, t => LocalAuth$ReventlessLocal.Login.verifyAndDecode(stripBearer(t))), i => i.username);
     let conn = addConnection(f => {
       ws.send(f);
-    });
+    }, user);
     ws.on("message", data => handleFrame(conn, data.toString("utf8")));
     ws.on("close", () => removeConnection(conn));
   });
@@ -352,6 +378,8 @@ export {
   broadcastUiSlotsChanged,
   broadcastStateChange,
   decodeStringField,
+  subscriptionLine,
+  logSubscription,
   handleFrame,
   stripBearer,
   tokenIsInvalid,

package/src/adapter/CommandOutcomeLog/CommandOutcomeLogEntry.res

@@ -0,0 +1,24 @@
+// One stored command outcome: the line the tap sends for it (component, plugin, message id,
+// flow, cause, accepted with its entity and event count or rejected with its code), with the
+// columns a read filters by.
+
+type t = {
+  seq: int,
+  flow?: string,
+  msgId: string,
+  /** The tap's `commandOutcome` line, as JSON. */
+  item: JSON.t,
+}
+
+/** What a read asks for: every field narrows, none reads every outcome. */
+type filter = {correlationId?: string, msgId?: string}
+
+let matches = (f: filter, e: t) =>
+  f.correlationId->Option.mapOr(true, c => e.flow == Some(c)) &&
+    f.msgId->Option.mapOr(true, m => e.msgId == m)
+
+let filterOfJson = (j: option<JSON.t>): filter => {
+  let d = j->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
+  let s = k => d->Dict.get(k)->Option.flatMap(JSON.Decode.string)
+  {correlationId: ?s("correlationId"), msgId: ?s("msgId")}
+}

package/src/adapter/CommandOutcomeLog/CommandOutcomeLogEntry.res.mjs

@@ -0,0 +1,28 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function matches(f, e) {
+  if (Stdlib_Option.mapOr(f.correlationId, true, c => Primitive_object.equal(e.flow, c))) {
+    return Stdlib_Option.mapOr(f.msgId, true, m => e.msgId === m);
+  } else {
+    return false;
+  }
+}
+
+function filterOfJson(j) {
+  let d = Stdlib_Option.getOr(Stdlib_Option.flatMap(j, Stdlib_JSON.Decode.object), {});
+  let s = k => Stdlib_Option.flatMap(d[k], Stdlib_JSON.Decode.string);
+  return {
+    correlationId: s("correlationId"),
+    msgId: s("msgId")
+  };
+}
+
+export {
+  matches,
+  filterOfJson,
+}
+/* No side effect */

package/src/adapter/CommandOutcomeLog/CommandOutcomeLogStorage_InMemory.res

@@ -0,0 +1,26 @@
+// The command outcomes of an in-memory platform, oldest first, for as long as it runs.
+
+type entry = CommandOutcomeLogEntry.t
+
+let entries: array<entry> = []
+
+let append = (e: entry) => entries->Array.push(e)
+
+/** Up to `first` entries matching the filter, newest first, below the `before` sequence number. */
+let read = (~filter: CommandOutcomeLogEntry.filter, ~before: option<int>, ~first: int): array<
+  entry,
+> => {
+  let out = []
+  let i = ref(entries->Array.length - 1)
+  while i.contents >= 0 && out->Array.length < first {
+    let e = entries->Array.getUnsafe(i.contents)
+    if before->Option.mapOr(true, b => e.seq < b) && CommandOutcomeLogEntry.matches(filter, e) {
+      out->Array.push(e)
+    }
+    i := i.contents - 1
+  }
+  out
+}
+
+/** Test seam. */
+let clear = () => entries->Array.splice(~start=0, ~remove=entries->Array.length, ~insert=[])

package/src/adapter/CommandOutcomeLog/CommandOutcomeLogStorage_InMemory.res.mjs

@@ -0,0 +1,35 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as CommandOutcomeLogEntry$ReventlessLocal from "./CommandOutcomeLogEntry.res.mjs";
+
+let entries = [];
+
+function append(e) {
+  entries.push(e);
+}
+
+function read(filter, before, first) {
+  let out = [];
+  let i = entries.length - 1 | 0;
+  while (i >= 0 && out.length < first) {
+    let e = entries[i];
+    if (Stdlib_Option.mapOr(before, true, b => e.seq < b) && CommandOutcomeLogEntry$ReventlessLocal.matches(filter, e)) {
+      out.push(e);
+    }
+    i = i - 1 | 0;
+  };
+  return out;
+}
+
+function clear() {
+  entries.splice(0, entries.length);
+}
+
+export {
+  entries,
+  append,
+  read,
+  clear,
+}
+/* No side effect */

package/src/adapter/CommandOutcomeLog/CommandOutcomeLogStorage_Sqlite.res

@@ -0,0 +1,61 @@
+// The command outcomes of a SQLite platform, kept in its store across restarts.
+
+type entry = CommandOutcomeLogEntry.t
+
+let table = "reventless_command_outcomes"
+
+let ensureSchema = db => {
+  db->SqliteDriver.exec(
+    `CREATE TABLE IF NOT EXISTS ${table} (seq INTEGER PRIMARY KEY AUTOINCREMENT, flow TEXT, msg_id TEXT NOT NULL, item TEXT NOT NULL)`,
+  )
+  db->SqliteDriver.exec(`CREATE INDEX IF NOT EXISTS ${table}_flow ON ${table} (flow, seq)`)
+  db->SqliteDriver.exec(`CREATE INDEX IF NOT EXISTS ${table}_msg ON ${table} (msg_id)`)
+}
+
+let str = JSON.Encode.string
+
+let append = (db, e: entry) =>
+  db
+  ->SqliteDriver.prepare(`INSERT INTO ${table} (flow, msg_id, item) VALUES (?, ?, ?)`)
+  ->SqliteDriver.run([
+    e.flow->Option.mapOr(JSON.Encode.null, str),
+    str(e.msgId),
+    str(e.item->JSON.stringify),
+  ])
+
+let entryOfRow = (row: dict<JSON.t>): option<entry> => {
+  let s = k => row->Dict.get(k)->Option.flatMap(JSON.Decode.string)
+  switch (
+    row->Dict.get("seq")->Option.flatMap(JSON.Decode.float),
+    s("msg_id"),
+    s("item")->Option.flatMap(i =>
+      try Some(JSON.parseOrThrow(i)) catch {
+      | _ => None
+      }
+    ),
+  ) {
+  | (Some(seq), Some(msgId), Some(item)) =>
+    Some({seq: seq->Float.toInt, flow: ?s("flow"), msgId, item})
+  | _ => None
+  }
+}
+
+/** Up to `first` entries matching the filter, newest first, below the `before` sequence number. */
+let read = (db, ~filter: CommandOutcomeLogEntry.filter, ~before: option<int>, ~first: int): array<
+  entry,
+> => {
+  let where = []
+  let params = []
+  let add = (clause, value) => {
+    where->Array.push(clause)
+    params->Array.push(value)
+  }
+  filter.correlationId->Option.forEach(c => add("flow = ?", str(c)))
+  filter.msgId->Option.forEach(m => add("msg_id = ?", str(m)))
+  before->Option.forEach(b => add("seq < ?", JSON.Encode.int(b)))
+  let sql = `SELECT seq, flow, msg_id, item FROM ${table}${where == []
+      ? ""
+      : " WHERE " ++ where->Array.join(" AND ")} ORDER BY seq DESC LIMIT ?`
+  params->Array.push(JSON.Encode.int(first))
+  db->SqliteDriver.prepare(sql)->SqliteDriver.all(params)->Array.filterMap(entryOfRow)
+}