@reventlessdev/reventless-local 3.0.0-alpha.200 → 3.0.0-alpha.201

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 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.201 (2026-08-05)
+
+### Features
+
+* **local,aws:** carry the changed row in the live-update descriptor ([9272e2e](https://github.com/ReventlessDev/reventless-core/commit/9272e2e18e9e1d740f9a2c5aa83eccbcb41feff7))
+* **local:** offload large pluginDefinition fields to the object store ([84c5fab](https://github.com/ReventlessDev/reventless-core/commit/84c5fab339856b5d64f0c05110b1fa7f38646f5e))
+* **local:** persist the object store beside the SQLite database ([f37e4a1](https://github.com/ReventlessDev/reventless-core/commit/f37e4a1ad3191a97f14f3db7e2ead0e2b27b46c2))
+* **local:** scoped seed:reset for the local platform ([a4dd003](https://github.com/ReventlessDev/reventless-core/commit/a4dd0033b7d01be23be91bac3f01d38ebeab7d45))
+
+
 # 3.0.0-alpha.200 (2026-08-04)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.200",
+  "version": "3.0.0-alpha.201",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -37,15 +37,16 @@
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.1",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.26",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.212",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.60",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.159",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.76",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.100",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.126"
+    "@reventlessdev/rescript-node": "2.0.0-alpha.2",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.213",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.61",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.127",
+    "@reventlessdev/reventless-seed": "1.0.0-alpha.9",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.160",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.101",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.77"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/rescript.json

@@ -35,7 +35,8 @@
     "@reventlessdev/reventless-spec",
     "@reventlessdev/reventless-core",
     "@reventlessdev/reventless-gwt",
-    "@reventlessdev/reventless-postgres"
+    "@reventlessdev/reventless-postgres",
+    "@reventlessdev/reventless-seed"
   ],
   "compiler-flags": [],
   "suffix": ".res.mjs"

package/src/Platform.res

@@ -118,6 +118,14 @@ module MakeWithConfig = (
     }
     let db = SqliteDriver.openDb(~path)
     BackendState.setSqlite(~db, ~path)
+    // The object store persists beside the database under this backend (see
+    // LocalObjectStore), so a reset that wipes the events wipes the bytes they
+    // reference too — otherwise the session starts with orphaned uploads and
+    // offload payloads no event points at. Runs after setSqlite because the
+    // store reads the active backend to find its root.
+    if resetOnStart {
+      LocalObjectStore.reset()
+    }
     // Persistent stores keep their event numbering across restarts and app
     // switches: seed the in-memory event-tap counter from the rows already on
     // disk so the timeline's #N continues instead of restarting at 1. (After a
@@ -837,6 +845,20 @@ module MakeWithConfig = (
   type mcpSupported = | @as(true) McpSupported | @as(false) McpNotSupported
   let mcpSupported = McpSupported
 
+  // Content-address the two large pluginDefinition fields into the process-local
+  // object store, exactly as the AWS platform does into its offload bucket. Local
+  // has no bucket, but it does have an object store — and leaving the fields
+  // inline here meant every connect handshake carried a whole plugin structure
+  // through the command log, and that local never exercised the offload path the
+  // deployed platform takes. Registered once at platform setup, before any plugin
+  // is built, since the hook fires during graph construction.
+  ReventlessCore.Plugin_Helpers.registerOffload((~store, ~bytes) => {
+    let hash = NodeCrypto.sha256Hex(bytes)
+    let key = "sha256/" ++ hash
+    LocalObjectStore.putOffload(~key, ~bytes)
+    {Reventless.Offload.store, key, hash, bytes: bytes->String.length}
+  })
+
   // ---------------------------------------------------------------------------
   // Shared helpers — used by both makePlatform and deployPlugin.
   // ---------------------------------------------------------------------------
@@ -852,6 +874,10 @@ module MakeWithConfig = (
   // In-memory store for plugin structures, keyed by plugin ID.
   let pluginStructuresStore: ref<dict<Reventless.Plugin.pluginStructure>> = ref(Dict.make())
 
+  // The object stores a plugin's fields declared, as `{plugin}.{store}` keys.
+  let declaredStoresOf = (structure: Reventless.Plugin.pluginStructure) =>
+    structure.requiredStores->Option.getOr([])
+
   let seedPluginStructuresStore = (~pluginComponents: array<ReventlessCore.Plugin.component>) => {
     pluginComponents->Array.forEach(plugin => {
       let outputs: ReventlessInfra.Plugin.outputs = plugin->ReventlessCore.Component.outputs
@@ -860,45 +886,42 @@ module MakeWithConfig = (
         ->Pulumi.Output.all2
         ->Pulumi.Output.apply(((id, ps)) => {
           switch ps {
-          | Some(def) => pluginStructuresStore.contents->Dict.set(id, def)
+          | Some(def) =>
+            pluginStructuresStore.contents->Dict.set(id, def)
+            // Inside the apply, not after the forEach: the structure only exists
+            // once the Output resolves, so anything reading
+            // `pluginStructuresStore` synchronously below reads an empty dict.
+            declaredStoresOf(def)->Array.forEach(qualified =>
+              // Registering the store is what lets an uploaded object be attributed
+              // to the plugin that declared it, the way an S3 key's prefix does —
+              // under the served `uploads/` prefix locally, for the reason
+              // LocalObjectStore.localPrefixFor gives.
+              LocalObjectStore.registerStore(
+                ~qualified,
+                ~prefix=LocalObjectStore.localPrefixFor(~qualified),
+              )
+            )
+            // Two plugins declaring one store name is refused by the deployed
+            // platform before it provisions anything. Local provisions no stores, so
+            // nothing here breaks — but this is the only place a developer meets the
+            // rule while the fix is still free: once a store has deployed, its minted
+            // refs are in an append-only event log and renaming it strands them.
+            // Hence a warning at composition, and the authoritative refusal at deploy.
+            //
+            // Checked against every store registered so far rather than this
+            // plugin's own, since a collision is by definition between two plugins.
+            ReventlessCore.StorePrefixCollision.collisionsFor(
+              ~stores=LocalObjectStore.declaredStoreList()->Array.map(((qualified, prefix)) => {
+                ReventlessCore.StorePrefixCollision.qualified,
+                prefix,
+              }),
+            )->Array.forEach(c =>
+              log.warn(~comp="Platform:plugins", ReventlessCore.StorePrefixCollision.collisionMessage(c))
+            )
           | None => ()
           }
         })
     })
-
-    // Two plugins declaring one store name is refused by the deployed platform
-    // before it provisions anything. Local provisions no stores, so nothing here
-    // breaks — but this is the only place a developer meets the rule while the
-    // fix is still free: once a store has deployed, its minted refs are in an
-    // append-only event log and renaming it strands them. Hence a warning at
-    // composition, and the authoritative refusal at deploy.
-    let declared =
-      pluginStructuresStore.contents
-      ->Dict.valuesToArray
-      ->Array.flatMap(structure =>
-        structure.requiredStores
-        ->Option.getOr([])
-        ->Array.map(qualified => {
-          ReventlessCore.StorePrefixCollision.qualified,
-          // Local provisions no stores, so it has no prefix of its own — it
-          // restates the deployed rule (`{plugin}/{store}`) so the warning it
-          // gives matches the refusal a deploy would give. Reporting a collision
-          // the deployed platform does not have would be worse than silence.
-          prefix: switch qualified->String.indexOfOpt(".") {
-          | Some(i) =>
-            qualified->String.slice(~start=0, ~end=i) ++
-            "/" ++
-            qualified->String.slice(~start=i + 1, ~end=qualified->String.length)
-          | None => qualified
-          },
-        })
-      )
-    ReventlessCore.StorePrefixCollision.collisionsFor(~stores=declared)->Array.forEach(c =>
-      log.warn(
-        ~comp="Platform:plugins",
-        ReventlessCore.StorePrefixCollision.collisionMessage(c),
-      )
-    )
   }
 
   // Bus keys for the admin Plugin aggregate (name-keyed). ComponentType.toName maps
@@ -1113,9 +1136,19 @@ module MakeWithConfig = (
               },
             ),
             extensionProtocols: [],
-            apiSchemaFragment: apiSchemaFragment->Option.map(f => Reventless.Offload.Inline(f)),
+            apiSchemaFragment: apiSchemaFragment->Option.map(f =>
+              f->ReventlessCore.Plugin_Helpers.offloadPayload(
+                ~schema=Reventless.Plugin.apiSchemaFragmentSchema,
+                ~store="pluginApiFragments",
+              )
+            ),
             apiTarget: None,
-            structure: pluginStructure->Option.map(s => Reventless.Offload.Inline(s)),
+            structure: pluginStructure->Option.map(s =>
+              s->ReventlessCore.Plugin_Helpers.offloadPayload(
+                ~schema=Reventless.Plugin.pluginStructureSchema,
+                ~store="pluginStructures",
+              )
+            ),
             dcbEventLog: None,
             kind: Domain,
           }

package/src/Platform.res.mjs

@@ -2,6 +2,7 @@
 
 import * as S from "sury/src/S.res.mjs";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as NodeCrypto from "@reventlessdev/rescript-node/src/NodeCrypto.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Stdlib_Bool from "@rescript/runtime/lib/es6/Stdlib_Bool.js";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
@@ -40,6 +41,7 @@ import * as LocalPluginSpec$ReventlessLocal from "./adapter/LocalPluginSpec.res.
 import * as NoEventMappings$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/NoEventMappings.res.mjs";
 import * as DomainMCP_Server$ReventlessLocal from "./adapter/DomainMCP_Server.res.mjs";
 import * as ExtensionMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionMapping.res.mjs";
+import * as LocalObjectStore$ReventlessLocal from "./adapter/ObjectStore/LocalObjectStore.res.mjs";
 import * as LocalQueryEngine$ReventlessLocal from "./adapter/QueryEngine/LocalQueryEngine.res.mjs";
 import * as Platform_AdminApi$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_AdminApi.res.mjs";
 import * as PluginsProjection$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsProjection.res.mjs";
@@ -127,12 +129,16 @@ function MakeWithConfig(Config) {
   if (typeof match !== "object") {
     BackendState$ReventlessLocal.setMemory();
   } else if (match.TAG === "Sqlite") {
+    let resetOnStart = match.resetOnStart;
     let path = match.path;
-    if (match.resetOnStart) {
+    if (resetOnStart) {
       Backend$ReventlessLocal.removeFileIfExists(path);
     }
     let db = SqliteDriver$ReventlessLocal.openDb(path);
     BackendState$ReventlessLocal.setSqlite(db, path);
+    if (resetOnStart) {
+      LocalObjectStore$ReventlessLocal.reset();
+    }
     LocalBus$ReventlessLocal.seedEventTapSeq(EventLogStorage_Sqlite$ReventlessLocal.countAll(db) + DcbEventLogStorage_Sqlite$ReventlessLocal.countAll(db) | 0);
     ProjectionPending$ReventlessLocal.enableTracking();
     EventPublish_Callback$ReventlessCore.registerAfterPublish(async publishedEvent => {
@@ -810,6 +816,17 @@ function MakeWithConfig(Config) {
   let domainMcpPort = resolvePort("REVENTLESS_DOMAIN_MCP_PORT", 3001);
   let platformPort = resolvePort("REVENTLESS_PLATFORM_PORT", 4001);
   let platformMcpPort = resolvePort("REVENTLESS_PLATFORM_MCP_PORT", 3002);
+  Plugin_Helpers$ReventlessCore.registerOffload((store, bytes) => {
+    let hash = NodeCrypto.sha256Hex(bytes);
+    let key = "sha256/" + hash;
+    LocalObjectStore$ReventlessLocal.putOffload(key, bytes);
+    return {
+      store: store,
+      key: key,
+      hash: hash,
+      bytes: bytes.length
+    };
+  });
   let pluginStructuresStore = {
     contents: {}
   };
@@ -823,18 +840,15 @@ function MakeWithConfig(Config) {
         let ps = param[1];
         if (ps !== undefined) {
           pluginStructuresStore.contents[param[0]] = ps;
+          Stdlib_Option.getOr(ps.requiredStores, []).forEach(qualified => LocalObjectStore$ReventlessLocal.registerStore(qualified, LocalObjectStore$ReventlessLocal.localPrefixFor(qualified)));
+          StorePrefixCollision$ReventlessCore.collisionsFor(LocalObjectStore$ReventlessLocal.declaredStoreList().map(param => ({
+            qualified: param[0],
+            prefix: param[1]
+          }))).forEach(c => log.warn("Platform:plugins", undefined, StorePrefixCollision$ReventlessCore.collisionMessage(c)));
           return;
         }
       });
     });
-    let declared = Object.values(pluginStructuresStore.contents).flatMap(structure => Stdlib_Option.getOr(structure.requiredStores, []).map(qualified => {
-      let i = Stdlib_String.indexOfOpt(qualified, ".");
-      return {
-        qualified: qualified,
-        prefix: i !== undefined ? qualified.slice(0, i) + "/" + qualified.slice(i + 1 | 0, qualified.length) : qualified
-      };
-    }));
-    StorePrefixCollision$ReventlessCore.collisionsFor(declared).forEach(c => log.warn("Platform:plugins", undefined, StorePrefixCollision$ReventlessCore.collisionMessage(c)));
   };
   let pluginCmdTopicKey = PluginSpec$ReventlessCore.name + "AggrCmdTopic";
   let pluginEventTopicKey = PluginSpec$ReventlessCore.name + "AggrEventTopic";
@@ -971,15 +985,9 @@ function MakeWithConfig(Config) {
           }),
           eventCollector: param[2].name,
           extensionProtocols: [],
-          apiSchemaFragment: Stdlib_Option.map(param[5], f => ({
-            TAG: "Inline",
-            _0: f
-          })),
+          apiSchemaFragment: Stdlib_Option.map(param[5], f => Plugin_Helpers$ReventlessCore.offloadPayload(f, Plugin$Reventless.apiSchemaFragmentSchema, "pluginApiFragments")),
           apiTarget: undefined,
-          structure: Stdlib_Option.map(param[7], s => ({
-            TAG: "Inline",
-            _0: s
-          })),
+          structure: Stdlib_Option.map(param[7], s => Plugin_Helpers$ReventlessCore.offloadPayload(s, Plugin$Reventless.pluginStructureSchema, "pluginStructures")),
           dcbEventLog: undefined,
           kind: "Domain"
         };
@@ -1823,12 +1831,16 @@ function Make($star) {
   if (typeof backend !== "object") {
     BackendState$ReventlessLocal.setMemory();
   } else if (backend.TAG === "Sqlite") {
+    let resetOnStart = backend.resetOnStart;
     let path = backend.path;
-    if (backend.resetOnStart) {
+    if (resetOnStart) {
       Backend$ReventlessLocal.removeFileIfExists(path);
     }
     let db = SqliteDriver$ReventlessLocal.openDb(path);
     BackendState$ReventlessLocal.setSqlite(db, path);
+    if (resetOnStart) {
+      LocalObjectStore$ReventlessLocal.reset();
+    }
     LocalBus$ReventlessLocal.seedEventTapSeq(EventLogStorage_Sqlite$ReventlessLocal.countAll(db) + DcbEventLogStorage_Sqlite$ReventlessLocal.countAll(db) | 0);
     ProjectionPending$ReventlessLocal.enableTracking();
     EventPublish_Callback$ReventlessCore.registerAfterPublish(async publishedEvent => {
@@ -2500,6 +2512,17 @@ function Make($star) {
   let domainMcpPort = resolvePort("REVENTLESS_DOMAIN_MCP_PORT", 3001);
   let platformPort = resolvePort("REVENTLESS_PLATFORM_PORT", 4001);
   let platformMcpPort = resolvePort("REVENTLESS_PLATFORM_MCP_PORT", 3002);
+  Plugin_Helpers$ReventlessCore.registerOffload((store, bytes) => {
+    let hash = NodeCrypto.sha256Hex(bytes);
+    let key = "sha256/" + hash;
+    LocalObjectStore$ReventlessLocal.putOffload(key, bytes);
+    return {
+      store: store,
+      key: key,
+      hash: hash,
+      bytes: bytes.length
+    };
+  });
   let pluginStructuresStore = {
     contents: {}
   };
@@ -2513,18 +2536,15 @@ function Make($star) {
         let ps = param[1];
         if (ps !== undefined) {
           pluginStructuresStore.contents[param[0]] = ps;
+          Stdlib_Option.getOr(ps.requiredStores, []).forEach(qualified => LocalObjectStore$ReventlessLocal.registerStore(qualified, LocalObjectStore$ReventlessLocal.localPrefixFor(qualified)));
+          StorePrefixCollision$ReventlessCore.collisionsFor(LocalObjectStore$ReventlessLocal.declaredStoreList().map(param => ({
+            qualified: param[0],
+            prefix: param[1]
+          }))).forEach(c => log.warn("Platform:plugins", undefined, StorePrefixCollision$ReventlessCore.collisionMessage(c)));
           return;
         }
       });
     });
-    let declared = Object.values(pluginStructuresStore.contents).flatMap(structure => Stdlib_Option.getOr(structure.requiredStores, []).map(qualified => {
-      let i = Stdlib_String.indexOfOpt(qualified, ".");
-      return {
-        qualified: qualified,
-        prefix: i !== undefined ? qualified.slice(0, i) + "/" + qualified.slice(i + 1 | 0, qualified.length) : qualified
-      };
-    }));
-    StorePrefixCollision$ReventlessCore.collisionsFor(declared).forEach(c => log.warn("Platform:plugins", undefined, StorePrefixCollision$ReventlessCore.collisionMessage(c)));
   };
   let pluginCmdTopicKey = PluginSpec$ReventlessCore.name + "AggrCmdTopic";
   let pluginEventTopicKey = PluginSpec$ReventlessCore.name + "AggrEventTopic";
@@ -2661,15 +2681,9 @@ function Make($star) {
           }),
           eventCollector: param[2].name,
           extensionProtocols: [],
-          apiSchemaFragment: Stdlib_Option.map(param[5], f => ({
-            TAG: "Inline",
-            _0: f
-          })),
+          apiSchemaFragment: Stdlib_Option.map(param[5], f => Plugin_Helpers$ReventlessCore.offloadPayload(f, Plugin$Reventless.apiSchemaFragmentSchema, "pluginApiFragments")),
           apiTarget: undefined,
-          structure: Stdlib_Option.map(param[7], s => ({
-            TAG: "Inline",
-            _0: s
-          })),
+          structure: Stdlib_Option.map(param[7], s => Plugin_Helpers$ReventlessCore.offloadPayload(s, Plugin$Reventless.pluginStructureSchema, "pluginStructures")),
           dcbEventLog: undefined,
           kind: "Domain"
         };

package/src/adapter/BackendState.res

@@ -37,3 +37,16 @@ let getPostgresPool = () =>
   | Postgres({pool}) => Some(pool)
   | Memory | Sqlite(_) => None
   }
+
+// Directory the object store persists under, derived from the SQLite file's own
+// directory (`./.reventless/local.db` → `./.reventless`) so uploaded bytes and
+// offloaded payloads live and die with the events that reference them. None for
+// the backends with nothing durable on this disk: Memory, an in-process
+// `:memory:` SQLite, and Postgres — durable, but off-machine, and a connection
+// string names no local directory to anchor to, so its object store stays
+// in-process.
+let getObjectStoreRoot = () =>
+  switch current.contents {
+  | Sqlite({path}) if path != ":memory:" => Some(NodePath.dirname(path))
+  | Sqlite(_) | Memory | Postgres(_) => None
+  }

package/src/adapter/BackendState.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Nodepath from "node:path";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
 let current = {
@@ -43,6 +44,20 @@ function getPostgresPool() {
   }
 }
 
+function getObjectStoreRoot() {
+  let match = current.contents;
+  if (typeof match !== "object") {
+    return;
+  }
+  if (match.TAG !== "Sqlite") {
+    return;
+  }
+  let path = match.path;
+  if (path !== ":memory:") {
+    return Nodepath.dirname(path);
+  }
+}
+
 export {
   current,
   setMemory,
@@ -50,5 +65,6 @@ export {
   setPostgres,
   getSqliteDb,
   getPostgresPool,
+  getObjectStoreRoot,
 }
-/* No side effect */
+/* node:path Not a pure module */

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

@@ -32,4 +32,4 @@ function Make(Bus) {
 export {
   Make,
 }
-/* DcbEventLogStorage_Sqlite-ReventlessLocal Not a pure module */
+/* BackendState-ReventlessLocal Not a pure module */

package/src/adapter/DomainGraphQL_Server.res

@@ -27,7 +27,7 @@ type nodeResponse
 @send external end_: (nodeResponse, string) => unit = "end"
 @send external endEmpty: (nodeResponse, @as(json`null`) _) => unit = "end"
 // Binary response body — the served-object GET streams stored bytes verbatim.
-@send external endBuf: (nodeResponse, LocalObjectStore.buffer) => unit = "end"
+@send external endBuf: (nodeResponse, NodeBuffer.t) => unit = "end"
 
 // Streaming body collector — request data fires once per chunk, end once at EOF.
 @send external _onData: (nodeRequest, @as("data") _, string => unit) => unit = "on"
@@ -35,7 +35,7 @@ type nodeResponse
 @send external _setEncoding: (nodeRequest, string) => unit = "setEncoding"
 // Binary chunk stream — used by the served-object PUT so raw bytes aren't
 // mangled by utf8 decoding (setEncoding is deliberately NOT called).
-@send external _onDataBuf: (nodeRequest, @as("data") _, LocalObjectStore.buffer => unit) => unit = "on"
+@send external _onDataBuf: (nodeRequest, @as("data") _, NodeBuffer.t => unit) => unit = "on"
 
 
 let readBody = (req: nodeRequest, onBody: string => unit): unit => {
@@ -47,10 +47,10 @@ let readBody = (req: nodeRequest, onBody: string => unit): unit => {
 
 // Binary body collector — accumulates raw Buffer chunks and concatenates once
 // at EOF. Kept separate from `readBody` (utf8) so file uploads stay byte-exact.
-let readBodyBuf = (req: nodeRequest, onBody: LocalObjectStore.buffer => unit): unit => {
-  let chunks: array<LocalObjectStore.buffer> = []
+let readBodyBuf = (req: nodeRequest, onBody: NodeBuffer.t => unit): unit => {
+  let chunks: array<NodeBuffer.t> = []
   req->_onDataBuf(chunk => chunks->Array.push(chunk))
-  req->_onEnd(() => onBody(LocalObjectStore.concatBuffers(chunks)))
+  req->_onEnd(() => onBody(NodeBuffer.concat(chunks)))
 }
 
 type requestHandler = (nodeRequest, nodeResponse) => unit

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -17,7 +17,7 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as LocalAuth$ReventlessLocal from "./Auth/LocalAuth.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
-import * as LocalObjectStore$ReventlessLocal from "./LocalObjectStore.res.mjs";
+import * as LocalObjectStore$ReventlessLocal from "./ObjectStore/LocalObjectStore.res.mjs";
 import * as LocalEvents_Server$ReventlessLocal from "./Api/LocalEvents_Server.res.mjs";
 import * as Auth_GraphqlContext$ReventlessLocal from "./Auth/Auth_GraphqlContext.res.mjs";
 

package/src/adapter/EventLog/LocalEventLogStorage.res.mjs

@@ -32,4 +32,4 @@ function Make(Bus) {
 export {
   Make,
 }
-/* EventLogStorage_Sqlite-ReventlessLocal Not a pure module */
+/* BackendState-ReventlessLocal Not a pure module */

package/src/adapter/LocalBus.res

@@ -47,48 +47,9 @@ type queuedEvent = {
   done_: Effect.t<unit, unit, unit>,
 }
 
-// ── State-change descriptor helper ───────────────────────────────────────────
-// Mirrors the JSON shape produced by the AWS StateTopic Lambda (Phase 2):
-// `{ changeKind, id, sortKeyValue? }`. Storage adapters call this and pass
-// the result to `publishStateChange(~descriptor)` so dev and prod subscribers
-// see the same payload.
-
-let pickSortKeyValue = (state: JSON.t): option<string> =>
-  switch state->JSON.Decode.object {
-  | Some(obj) =>
-    switch obj->Dict.get("updatedAt") {
-    | Some(JSON.String(v)) => Some(v)
-    | _ =>
-      switch obj->Dict.get("createdAt") {
-      | Some(JSON.String(v)) => Some(v)
-      | _ => None
-      }
-    }
-  | None => None
-  }
-
-/** Build a state-change descriptor.
-    - `changeKind`: one of "Added" | "Updated" | "Removed". save() emits "Added"
-      when no visible row held the key and "Updated" otherwise; delete() emits
-      "Removed".
-    - `id`: entity key. Single-key projections: the partition-key value.
-      Composite projections: `partition ++ "-" ++ subKey`.
-    - `state`: present for save() (for `sortKeyValue` extraction);
-      `None` for delete() — descriptor will omit `sortKeyValue`. */
-let makeStateChangeDescriptor = (
-  ~changeKind: string,
-  ~id: string,
-  ~state: option<JSON.t>,
-): JSON.t => {
-  let descriptor = Dict.make()
-  descriptor->Dict.set("changeKind", JSON.Encode.string(changeKind))
-  descriptor->Dict.set("id", JSON.Encode.string(id))
-  switch state->Option.flatMap(pickSortKeyValue) {
-  | Some(v) => descriptor->Dict.set("sortKeyValue", JSON.Encode.string(v))
-  | None => ()
-  }
-  descriptor->JSON.Encode.object
-}
+// The state-change descriptor itself lives in `LocalStateChangeDescriptor` —
+// it is one of three implementations of a shared wire format and is covered by
+// its own parity test, so it stays out of the bus.
 
 // Opt-in NDJSON domain-event tap for the VS Code local platform runner (features
 // plan Phase 9). Enabled when REVENTLESS_EVENT_TAP is set; off by default so normal
@@ -205,16 +166,15 @@ module type T = {
   //
   // Source B (state changes): QueryDbStorage_InMemory calls publishStateChange after
   //   every save/delete so subscription listeners receive a change descriptor matching
-  //   the AWS StateTopic Lambda output (Phase 2): {changeKind, id, sortKeyValue?}.
+  //   the AWS StateTopic Lambda output: {changeKind, id, sortKeyValue?, seq, state?}.
   //   ~name is the QueryDb/ReadModel Spec.name; ~descriptor is built via
-  //   `makeStateChangeDescriptor` below.
+  //   `LocalStateChangeDescriptor.make`.
   //
   //   `changeKind` matches AWS, which reads it off the DynamoDB stream eventName:
   //   save() checks whether a visible row already held the key and emits "Added"
   //   or "Updated" accordingly, `delete()` emits "Removed". Without the "Added"
   //   arm a list view drops every row it doesn't already hold, so seeding into an
-  //   empty read model looked like live updates were broken. `position` is
-  //   omitted (Phase 3 deferred).
+  //   empty read model looked like live updates were broken.
   let publishStateChange: (~name: string, ~descriptor: JSON.t) => unit
   let subscribeToStateChanges: (string, JSON.t => unit) => unit
   // All-changes variant: receives every publishStateChange with its read-model

package/src/adapter/LocalBus.res.mjs

@@ -2,7 +2,6 @@
 
 import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
-import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Queue from "effect/Queue";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect$1 from "effect/Effect";
@@ -12,32 +11,6 @@ import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Deferred from "effect/Deferred";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
-function pickSortKeyValue(state) {
-  let obj = Stdlib_JSON.Decode.object(state);
-  if (obj === undefined) {
-    return;
-  }
-  let match = obj["updatedAt"];
-  if (typeof match === "string") {
-    return match;
-  }
-  let match$1 = obj["createdAt"];
-  if (typeof match$1 === "string") {
-    return match$1;
-  }
-}
-
-function makeStateChangeDescriptor(changeKind, id, state) {
-  let descriptor = {};
-  descriptor["changeKind"] = changeKind;
-  descriptor["id"] = id;
-  let v = Stdlib_Option.flatMap(state, pickSortKeyValue);
-  if (v !== undefined) {
-    descriptor["sortKeyValue"] = v;
-  }
-  return descriptor;
-}
-
 function eventTapEnabled() {
   return Stdlib_Option.isSome(process.env["REVENTLESS_EVENT_TAP"]);
 }
@@ -1187,8 +1160,6 @@ function MakeBounded(C) {
 }
 
 export {
-  pickSortKeyValue,
-  makeStateChangeDescriptor,
   eventTapEnabled,
   eventTapSeq,
   seedEventTapSeq,