@reventlessdev/reventless-local 3.0.0-alpha.182 → 3.0.0-alpha.184

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.184 (2026-07-31)
+
+**Note:** Version bump only for package @reventlessdev/reventless-local
+
+
+
+
+
+# 3.0.0-alpha.183 (2026-07-30)
+
+### Bug Fixes
+
+* **local:** a row saved for the first time is Added, not Updated ([6947253](https://github.com/ReventlessDev/reventless-core/commit/6947253a94f9e5fdfeb42fd9268795c948871803))
+* **local:** publish live descriptors on the list-field channel clients subscribe to ([912940d](https://github.com/ReventlessDev/reventless-core/commit/912940dbd5d180b4b3222e5cb954362be2671594))
+
+
 # 3.0.0-alpha.182 (2026-07-30)
 
 **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.182",
+  "version": "3.0.0-alpha.184",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -34,17 +34,18 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0-alpha.4",
     "ws": "^8.18.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.25",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.20",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.194",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.141",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.42",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.112",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.87",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.58"
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
+    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.26",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.0",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.196",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.143",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.44",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.60",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.114",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.89"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/rescript.json

@@ -24,6 +24,7 @@
   ],
   "dependencies": [
     "sury",
+    "@reventlessdev/rescript-node",
     "@reventlessdev/rescript-jest",
     "@reventlessdev/rescript-effect",
     "@reventlessdev/rescript-pulumi-pulumi",

package/src/EmitCapabilities.res

@@ -20,21 +20,6 @@
 // Usage: emit-capabilities <srcDir> [<compositionModule>]
 //   (run from the plugin package, after `rescript build`)
 
-// ── Node ─────────────────────────────────────────────────────────────────────
-
-@module("node:fs") external existsSync: string => bool = "existsSync"
-@module("node:fs") external writeFileSync: (string, string, @as("utf8") _) => unit = "writeFileSync"
-
-@module("node:path") @variadic external join: array<string> => string = "join"
-@module("node:path") @variadic external resolve: array<string> => string = "resolve"
-@module("node:path") @val external sep: string = "sep"
-
-@module("node:url") external pathToFileURL: string => {"href": string} = "pathToFileURL"
-
-@val @scope("process") external argv: array<string> = "argv"
-@val @scope("process") external env: Dict.t<string> = "env"
-@val external processExit: int => unit = "process.exit"
-
 // Emitted by ReScript as a literal `import(...)` expression — the composition
 // root's path is only known at run time, so it cannot be a static binding.
 @val external dynImport: string => promise<'a> = "import"
@@ -56,11 +41,11 @@ type compositionExports = {"Make": platform => builtPlugin}
 let compositionModulePath = (~srcDir: string, ~moduleArg: option<string>): string => {
   let withExtension = name => name->String.endsWith(".mjs") ? name : name ++ ".res.mjs"
   switch moduleArg {
-  | None | Some("") => join([srcDir, "Plugin.res.mjs"])
+  | None | Some("") => NodePath.join([srcDir, "Plugin.res.mjs"])
   | Some(name) =>
-    name->String.includes("/") || name->String.includes(sep)
-      ? resolve([withExtension(name)])
-      : join([srcDir, withExtension(name)])
+    name->String.includes("/") || name->String.includes(NodePath.sep)
+      ? NodePath.resolve([withExtension(name)])
+      : NodePath.join([srcDir, withExtension(name)])
   }
 }
 
@@ -68,25 +53,25 @@ let compositionModulePath = (~srcDir: string, ~moduleArg: option<string>): strin
 
 let fail = (message: string) => {
   Console.error("emit-capabilities: " ++ message)
-  processExit(1)
+  NodeProcess.exit(1)
 }
 
 let main = async () => {
   // The local platform defaults to Debug-level logging; a build step should not.
-  switch env->Dict.get("LOG_LEVEL") {
+  switch NodeProcess.env->Dict.get("LOG_LEVEL") {
   | Some(_) => ()
-  | None => env->Dict.set("LOG_LEVEL", "warn")
+  | None => NodeProcess.env->Dict.set("LOG_LEVEL", "warn")
   }
 
-  switch argv->Array.get(2) {
+  switch NodeProcess.argv->Array.get(2) {
   | None | Some("") => {
       Console.error("Usage: emit-capabilities <srcDir> [<compositionModule>]")
-      processExit(1)
+      NodeProcess.exit(1)
     }
   | Some(srcDirArg) => {
-      let srcDir = resolve([srcDirArg])
-      let modulePath = compositionModulePath(~srcDir, ~moduleArg=argv->Array.get(3))
-      if !existsSync(modulePath) {
+      let srcDir = NodePath.resolve([srcDirArg])
+      let modulePath = compositionModulePath(~srcDir, ~moduleArg=NodeProcess.argv->Array.get(3))
+      if !NodeFs.existsSync(modulePath) {
         fail(`${modulePath} not found — run \`rescript build\` first.`)
       }
 
@@ -95,11 +80,11 @@ let main = async () => {
       let platformModule: localPlatformExports = await dynImport("./Platform.res.mjs")
       let platform = platformModule["Make"]()
 
-      let composition: compositionExports = await dynImport(pathToFileURL(modulePath)["href"])
+      let composition: compositionExports = await dynImport(NodeUrl.pathToFileURL(modulePath)["href"])
       let built = composition["Make"](platform)
 
-      let manifestPath = join([srcDir, "capabilities.json"])
-      writeFileSync(
+      let manifestPath = NodePath.join([srcDir, "capabilities.json"])
+      NodeFs.writeFileSync(
         manifestPath,
         Reventless.CapabilityManifest.renderForStructure(built["pluginStructure"]),
       )
@@ -107,7 +92,7 @@ let main = async () => {
 
       // Applying the platform functor wires in-process infrastructure; exit
       // explicitly so no lingering handle keeps the build step alive.
-      processExit(0)
+      NodeProcess.exit(0)
     }
   }
 }

package/src/Platform.res

@@ -821,15 +821,14 @@ module MakeWithConfig = (
     component->ReventlessCore.Component.operations
   }
 
-  @val external processEnv: dict<string> = "process.env"
-  let graphqlDebug = processEnv->Dict.get("GRAPHQL_DEBUG")->Option.isSome
+  let graphqlDebug = NodeProcess.env->Dict.get("GRAPHQL_DEBUG")->Option.isSome
 
   // Per-session server ports for the VS Code local platform runner (features
   // plan Phase 9). The runner spawns one platform child per app folder; default
   // ports (4000/4001/3001/3002) collide when several run, so each is overridable
   // via env. Defaults preserve today's behaviour for all non-runner callers.
   let resolvePort = (key, fallback) =>
-    processEnv->Dict.get(key)->Option.flatMap(v => Int.fromString(v))->Option.getOr(fallback)
+    NodeProcess.env->Dict.get(key)->Option.flatMap(v => Int.fromString(v))->Option.getOr(fallback)
   let domainPort = resolvePort("REVENTLESS_DOMAIN_PORT", 4000)
   let domainMcpPort = resolvePort("REVENTLESS_DOMAIN_MCP_PORT", 3001)
   let platformPort = resolvePort("REVENTLESS_PLATFORM_PORT", 4001)

package/src/adapter/Api/LocalEvents_Server.res

@@ -111,7 +111,18 @@ let broadcastStateChange = (~name: string, ~descriptor: JSON.t): unit => {
     ->Option.flatMap(JSON.Decode.string)
     ->Option.getOr("")
   if entityKey != "" {
-    let channel = `/default/${pathSegment(name)}/${pathSegment(entityKey)}`
+    // Channel root MUST equal what the host-shell subscribes to. AutoLive uses
+    // `queryField = listFieldName` (plural, plugin-qualified, e.g.
+    // "Catalog_Products"), not the read-model store name ("Products"). Translate
+    // through the same registry the AWS StateTopic wiring uses (aws/Platform.res)
+    // — publishing on the raw store name lands descriptors on a channel no client
+    // listens to, so the socket stays Open but no view ever refreshes.
+    let topicName =
+      ReventlessCore.Plugin_Helpers.queryFieldNamesRegistry
+      ->Dict.get(name)
+      ->Option.map(qn => qn.listFieldName)
+      ->Option.getOr(name)
+    let channel = `/default/${pathSegment(topicName)}/${pathSegment(entityKey)}`
     broadcast(~channel, ~event=descriptor->JSON.stringify)
   }
 }

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

@@ -6,6 +6,7 @@ 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 Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as LocalAuth$ReventlessLocal from "../Auth/LocalAuth.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
 
@@ -99,7 +100,8 @@ function broadcastStateChange(name, descriptor) {
   if (entityKey === "") {
     return;
   }
-  let channel = `/default/` + pathSegment(name) + `/` + pathSegment(entityKey);
+  let topicName = Stdlib_Option.getOr(Stdlib_Option.map(Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[name], qn => qn.listFieldName), name);
+  let channel = `/default/` + pathSegment(topicName) + `/` + pathSegment(entityKey);
   broadcast(channel, JSON.stringify(descriptor));
 }
 

package/src/adapter/Auth/LocalAuth.res

@@ -95,24 +95,15 @@ module Login = {
   // after a backend reload. When unset, falls back to a random per-process
   // secret — secure for ephemeral test runs but invalidates every previously
   // issued token on every restart.
-  type buf
-  @module("node:crypto") external _randomBytes: int => buf = "randomBytes"
-  @send external _bufToString: (buf, string) => string = "toString"
-  type hmac
-  @module("node:crypto") external _createHmac: (string, string) => hmac = "createHmac"
-  @send external _update: (hmac, string) => hmac = "update"
-  @send external _digest: (hmac, string) => string = "digest"
-
-  @val external _processEnv: Dict.t<string> = "process.env"
 
   let _secret: ref<option<string>> = ref(None)
   let _getSecret = (): string =>
     switch _secret.contents {
     | Some(s) => s
     | None =>
-      let s = switch _processEnv->Dict.get("REVENTLESS_INMEMORY_TOKEN_SECRET") {
+      let s = switch NodeProcess.env->Dict.get("REVENTLESS_INMEMORY_TOKEN_SECRET") {
       | Some(envSecret) if String.length(envSecret) >= 16 => envSecret
-      | _ => _randomBytes(32)->_bufToString("hex")
+      | _ => NodeCrypto.randomBytes(32)->NodeCrypto.bufferToString("hex")
       }
       _secret := Some(s)
       s
@@ -121,7 +112,9 @@ module Login = {
   let setTokenSecret = (s: string): unit => _secret := Some(s)
 
   let _sign = (payload: string): string =>
-    _createHmac("sha256", _getSecret())->_update(payload)->_digest("base64url")
+    NodeCrypto.createHmac("sha256", _getSecret())
+    ->NodeCrypto.hmacUpdate(payload)
+    ->NodeCrypto.hmacDigest("base64url")
 
   // base64url over arbitrary JSON strings: btoa-encode + URL-safe alphabet,
   // strip `=` padding. Avoids pulling in Buffer for a single-line conversion.

package/src/adapter/Auth/UserStore.res

@@ -26,10 +26,6 @@ type entry = {
 // ── YAML parsing (eemeli/yaml) ──────────────────────────────────────────────
 
 @module("yaml") external _yamlParse: string => unknown = "parse"
-@module("node:fs") external _readFileSync: (string, string) => string = "readFileSync"
-@module("node:fs") external _existsSync: string => bool = "existsSync"
-@module("node:path") external _join: (string, string) => string = "join"
-@val external _processCwd: unit => string = "process.cwd"
 
 let _entriesSchema = S.array(entrySchema)
 
@@ -46,7 +42,7 @@ let parseString = (yamlText: string): result<array<entry>, string> =>
 /** Reads + parses a YAML file. */
 let parseFile = (path: string): result<array<entry>, string> =>
   try {
-    let text = _readFileSync(path, "utf8")
+    let text = NodeFs.readFileSync(path)
     parseString(text)
   } catch {
   | JsExn(err) => Error(JsExn.message(err)->Option.getOr(`Cannot read ${path}`))
@@ -66,7 +62,7 @@ let _registerEntries = (entries: array<entry>): unit =>
     LocalAuth.Login.setCredentials(~username, ~password, ~identity=id)
   })
 
-let _defaultPath = (): string => _join(_processCwd(), ".reventless/users.yaml")
+let _defaultPath = (): string => NodePath.join([NodeProcess.cwd(), ".reventless/users.yaml"])
 
 /**
  * Hydrates the Login store. Returns the resolution path actually used
@@ -106,7 +102,7 @@ let load = (
       })
     | None =>
       let defaultPath = _defaultPath()
-      if _existsSync(defaultPath) {
+      if NodeFs.existsSync(defaultPath) {
         parseFile(defaultPath)->Result.map(entries => {
           _registerEntries(entries)
           DefaultFile(defaultPath)

package/src/adapter/Auth/UserStore.res.mjs

@@ -106,7 +106,7 @@ function load(users, usersFile, param) {
       };
     });
   }
-  let defaultPath = Nodepath.join(process.cwd(), ".reventless/users.yaml");
+  let defaultPath = _defaultPath();
   if (Nodefs.existsSync(defaultPath)) {
     return Stdlib_Result.map(parseFile(defaultPath), entries => {
       _registerEntries(entries);

package/src/adapter/Backend.res

@@ -34,13 +34,11 @@ let postgres = async (~connection, ~resetOnStart=false) => {
   Postgres({pool, initialCount, connection})
 }
 
-@val external processEnv: dict<string> = "process.env"
 
 // Deletes a file if it exists. No-op if the path is missing.
-@module("node:fs") external _unlinkSync: string => unit = "unlinkSync"
 
 let removeFileIfExists = (path: string) =>
-  try _unlinkSync(path) catch {
+  try NodeFs.unlinkSync(path) catch {
   | _ => ()
   }
 
@@ -50,7 +48,7 @@ let removeFileIfExists = (path: string) =>
 //   memory                   — explicit Memory selector
 // Anything else (including unset) yields Memory.
 let fromEnv = () =>
-  switch processEnv->Dict.get("REVENTLESS_LOCAL_BACKEND") {
+  switch NodeProcess.env->Dict.get("REVENTLESS_LOCAL_BACKEND") {
   | None => Memory
   | Some(raw) =>
     let trimmed = raw->String.trim

package/src/adapter/DomainGraphQL_Server.res

@@ -37,7 +37,6 @@ type nodeResponse
 // mangled by utf8 decoding (setEncoding is deliberately NOT called).
 @send external _onDataBuf: (nodeRequest, @as("data") _, LocalObjectStore.buffer => unit) => unit = "on"
 
-@module("crypto") external randomUUID: unit => string = "randomUUID"
 
 let readBody = (req: nodeRequest, onBody: string => unit): unit => {
   let buf = ref("")
@@ -155,7 +154,7 @@ let handleUploadPresign = (req: nodeRequest, res: nodeResponse): unit =>
       }
     let fileName =
       parsed->Dict.get("fileName")->Option.flatMap(JSON.Decode.string)->Option.getOr("upload")
-    let ref = `/${LocalObjectStore.defaultUploadPrefix}/${randomUUID()}/${fileName}`
+    let ref = `/${LocalObjectStore.defaultUploadPrefix}/${NodeCrypto.randomUUID()}/${fileName}`
     _writeJson(
       res,
       ~status=200,
@@ -496,8 +495,7 @@ let buildNodeResolver = (): option<(string, resolverFn)> =>
 
 // -- Server lifecycle ------------------------------------------------------
 
-@val external processEnv: dict<string> = "process.env"
-let debug = processEnv->Dict.get("GRAPHQL_DEBUG")->Option.isSome
+let debug = NodeProcess.env->Dict.get("GRAPHQL_DEBUG")->Option.isSome
 
 let activeServer: ref<option<YG.httpServer>> = ref(None)
 let activeSchema: ref<option<YG.schema>> = ref(None)

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -2,11 +2,11 @@
 
 import * as S from "sury/src/S.res.mjs";
 import * as Http from "http";
-import * as Crypto from "crypto";
 import * as Graphql from "graphql";
 import * as GraphqlYoga from "@reventlessdev/rescript-graphql-yoga/src/GraphqlYoga.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 Nodecrypto from "node:crypto";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as GraphqlYoga$1 from "graphql-yoga";
@@ -117,7 +117,7 @@ function handleUploadPresign(req, res) {
       parsed = {};
     }
     let fileName = Stdlib_Option.getOr(Stdlib_Option.flatMap(parsed["fileName"], Stdlib_JSON.Decode.string), "upload");
-    let ref = `/` + LocalObjectStore$ReventlessLocal.defaultUploadPrefix + `/` + Crypto.randomUUID() + `/` + fileName;
+    let ref = `/` + LocalObjectStore$ReventlessLocal.defaultUploadPrefix + `/` + Nodecrypto.randomUUID() + `/` + fileName;
     _writeJson(res, 200, Object.fromEntries([
       [
         "uploadUrl",

package/src/adapter/DomainMCP_Server.res

@@ -132,8 +132,7 @@ let registerEventHistoryResourcesFromEntries = (
 
 let activeServer: ref<option<McpSdk.httpServer>> = ref(None)
 
-@val external processEnv: dict<string> = "process.env"
-let debug = processEnv->Dict.get("MCP_DEBUG")->Option.isSome
+let debug = NodeProcess.env->Dict.get("MCP_DEBUG")->Option.isSome
 
 // Extract identity from an HTTP IncomingMessage via the X-Identity header.
 // Falls back to Identity.anonymous when the header is absent or malformed.

package/src/adapter/LocalBus.res

@@ -68,9 +68,9 @@ let pickSortKeyValue = (state: JSON.t): option<string> =>
   }
 
 /** Build a state-change descriptor.
-    - `changeKind`: one of "Added" | "Updated" | "Removed". In-memory adapters
-      typically emit "Updated" for save() (no Added detection — see module-type
-      docstring) and "Removed" for delete().
+    - `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);
@@ -98,10 +98,9 @@ let makeStateChangeDescriptor = (
 // so the runner's line parser can pick it out of the platform's ANSI log noise on
 // stdout. The emit is a plain Console.log, so it never perturbs publishEvent's
 // subscriber-countdown delivery semantics.
-@val external tapProcessEnv: dict<string> = "process.env"
 // Read per publish (not once at import) so the runner can toggle it live and so
 // hermetic tests can flip it between cases. The cost is one dict lookup per event.
-let eventTapEnabled = () => tapProcessEnv->Dict.get("REVENTLESS_EVENT_TAP")->Option.isSome
+let eventTapEnabled = () => NodeProcess.env->Dict.get("REVENTLESS_EVENT_TAP")->Option.isSome
 let eventTapSeq = ref(0)
 // Seed the in-memory tap counter from a persistent store's existing event count
 // so the timeline's #N continues across process restarts / app switches instead
@@ -210,10 +209,12 @@ module type T = {
   //   ~name is the QueryDb/ReadModel Spec.name; ~descriptor is built via
   //   `makeStateChangeDescriptor` below.
   //
-  //   In-memory degradation vs AWS: `changeKind` for save() is always "Updated"
-  //   (AWS distinguishes "Added" via DynamoDB streams' INSERT eventName; the
-  //   in-memory adapter doesn't cheaply track first-insert). `delete()` emits
-  //   "Removed". `position` is omitted (Phase 3 deferred).
+  //   `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).
   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/MCP_ServerInstance.res

@@ -51,8 +51,7 @@ type t = {
   printDiagnostics: unit => unit,
 }
 
-@val external processEnv: dict<string> = "process.env"
-let debug = processEnv->Dict.get("MCP_DEBUG")->Option.isSome
+let debug = NodeProcess.env->Dict.get("MCP_DEBUG")->Option.isSome
 
 let make = (~label: string="MCP"): t => {
   let tools: ref<dict<registeredTool>> = ref(Dict.make())

package/src/adapter/QueryDb/QueryDbStorage_InMemory.res

@@ -146,6 +146,24 @@ module Make = (Bus: LocalBus.T) => {
       }
     }
 
+    // First-insert detection, mirroring the SQLite arm's `existsStmt`. Expiry is
+    // purged lazily, so a key can still be in the store while no reader can see
+    // it — that counts as absent, or an aged-out row would come back as an
+    // Updated nobody has a row for.
+    let entryIsLive = (id: string, subKey: string): bool =>
+      switch store.contents->Dict.get(id) {
+      | None => false
+      | Some(subMap) =>
+        subMap->Dict.get(subKey)->Option.isSome &&
+          expiries.contents
+          ->Dict.get(id)
+          ->Option.flatMap(m => m->Dict.get(subKey))
+          ->Option.mapOr(true, exp => exp > nowSecs())
+      }
+
+    let saveKind = (id: string, subKey: string): string =>
+      entryIsLive(id, subKey) ? "Updated" : "Added"
+
     let getOrCreateSubMap = (partitionKey: string): dict<JSON.t> =>
       switch store.contents->Dict.get(partitionKey) {
       | Some(m) => m
@@ -173,10 +191,10 @@ module Make = (Bus: LocalBus.T) => {
       | None => id
       }
 
-    let publishUpdated = (id: string, state: JSON.t) => {
+    let publishSaved = (~changeKind: string, id: string, state: JSON.t) => {
       let subKey = getSubKey(state, subIdField)
       let descriptor = LocalBus.makeStateChangeDescriptor(
-        ~changeKind="Updated",
+        ~changeKind,
         ~id=entityKeyFor(id, subKey),
         ~state=Some(state),
       )
@@ -194,24 +212,31 @@ module Make = (Bus: LocalBus.T) => {
 
     let save: QueryDb.save<string, JSON.t> = async (id, state, _saveMode, ttl) => {
       let subKey = getSubKey(state, subIdField)
+      let changeKind = saveKind(id, subKey)
       let subMap = getOrCreateSubMap(id)
       subMap->Dict.set(subKey, state)
       recordExpiry(id, subKey, ttl)
       syncAll()
-      publishUpdated(id, state)
+      publishSaved(~changeKind, id, state)
       Ok()
     }
 
     let saveBatch: QueryDb.saveBatch<string, JSON.t> = async batch => {
-      batch->Array.forEach(((id, state, ttl)) => {
+      // Each kind is read immediately before its own write, so a batch that
+      // touches one key twice reports Added then Updated.
+      let kinds = batch->Array.map(((id, state, ttl)) => {
         let subKey = getSubKey(state, subIdField)
+        let changeKind = saveKind(id, subKey)
         let subMap = getOrCreateSubMap(id)
         subMap->Dict.set(subKey, state)
         recordExpiry(id, subKey, ttl)
+        changeKind
       })
       syncAll()
       // Notify subscribers for each saved item
-      batch->Array.forEach(((id, state, _)) => publishUpdated(id, state))
+      batch->Array.forEachWithIndex(((id, state, _), i) =>
+        publishSaved(~changeKind=kinds->Array.get(i)->Option.getOr("Updated"), id, state)
+      )
       Ok()
     }
 
@@ -221,6 +246,9 @@ module Make = (Bus: LocalBus.T) => {
     // previous `Ok(inc)` echoed the increment and never touched the store, so the
     // running total was wrong and `loadStream` never reflected the counter.
     let count: QueryDb.count<string> = async (id, fieldName, inc) => {
+      // Read before `getOrCreateSubMap` materialises the partition — a counter's
+      // very first increment creates its row, and that is an Added like any other.
+      let changeKind = saveKind(id, "")
       let subMap = getOrCreateSubMap(id)
       let existing = subMap->Dict.get("")->Option.flatMap(JSON.Decode.object)
       let current =
@@ -239,7 +267,7 @@ module Make = (Bus: LocalBus.T) => {
       let newItem = JSON.Encode.object(obj)
       subMap->Dict.set("", newItem)
       syncAll()
-      publishUpdated(id, newItem)
+      publishSaved(~changeKind, id, newItem)
       Ok(next)
     }
 

package/src/adapter/QueryDb/QueryDbStorage_InMemory.res.mjs

@@ -123,6 +123,21 @@ function Make(Bus) {
         return;
       }
     };
+    let entryIsLive = (id, subKey) => {
+      let subMap = store.contents[id];
+      if (subMap !== undefined && Stdlib_Option.isSome(subMap[subKey])) {
+        return Stdlib_Option.mapOr(Stdlib_Option.flatMap(expiries.contents[id], m => m[subKey]), true, exp => exp > Date.now() / 1000.0);
+      } else {
+        return false;
+      }
+    };
+    let saveKind = (id, subKey) => {
+      if (entryIsLive(id, subKey)) {
+        return "Updated";
+      } else {
+        return "Added";
+      }
+    };
     let getOrCreateSubMap = partitionKey => {
       let m = store.contents[partitionKey];
       if (m !== undefined) {
@@ -150,9 +165,9 @@ function Make(Bus) {
         return id;
       }
     };
-    let publishUpdated = (id, state) => {
+    let publishSaved = (changeKind, id, state) => {
       let subKey = getSubKey(state, subIdField);
-      let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Updated", entityKeyFor(id, subKey), state);
+      let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor(changeKind, entityKeyFor(id, subKey), state);
       Bus.publishStateChange(name, descriptor);
     };
     let publishRemoved = (id, subKey) => {
@@ -161,33 +176,37 @@ function Make(Bus) {
     };
     let save = async (id, state, _saveMode, ttl) => {
       let subKey = getSubKey(state, subIdField);
+      let changeKind = saveKind(id, subKey);
       let subMap = getOrCreateSubMap(id);
       subMap[subKey] = state;
       recordExpiry(id, subKey, ttl);
       dirty.contents = true;
-      publishUpdated(id, state);
+      publishSaved(changeKind, id, state);
       return {
         TAG: "Ok",
         _0: undefined
       };
     };
     let saveBatch = async batch => {
-      batch.forEach(param => {
+      let kinds = batch.map(param => {
         let state = param[1];
         let id = param[0];
         let subKey = getSubKey(state, subIdField);
+        let changeKind = saveKind(id, subKey);
         let subMap = getOrCreateSubMap(id);
         subMap[subKey] = state;
         recordExpiry(id, subKey, param[2]);
+        return changeKind;
       });
       dirty.contents = true;
-      batch.forEach(param => publishUpdated(param[0], param[1]));
+      batch.forEach((param, i) => publishSaved(Stdlib_Option.getOr(kinds[i], "Updated"), param[0], param[1]));
       return {
         TAG: "Ok",
         _0: undefined
       };
     };
     let count = async (id, fieldName, inc) => {
+      let changeKind = saveKind(id, "");
       let subMap = getOrCreateSubMap(id);
       let existing = Stdlib_Option.flatMap(subMap[""], Stdlib_JSON.Decode.object);
       let current = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(existing, o => o[fieldName]), Stdlib_JSON.Decode.float), 0, prim => prim | 0);
@@ -202,7 +221,7 @@ function Make(Bus) {
       obj[fieldName] = next;
       subMap[""] = obj;
       dirty.contents = true;
-      publishUpdated(id, obj);
+      publishSaved(changeKind, id, obj);
       return {
         TAG: "Ok",
         _0: next

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res

@@ -181,6 +181,15 @@ let makeStorage = (
   let scanAllStmt = db->SqliteDriver.prepare(
     `SELECT partition_key, sub_key, item FROM ${table} WHERE ${notExpiredClause} ORDER BY partition_key, sub_key`,
   )
+  // First-insert detection. DynamoDB streams hand the AWS StateTopic Lambda an
+  // eventName that separates INSERT from MODIFY; an upsert reports neither, so
+  // ask the table before writing. Carries `notExpiredClause` because that is what
+  // a reader sees: a row aged past its TTL is invisible to them, so overwriting
+  // it is an insert — the same descriptor pair (Removed, then Added) DynamoDB
+  // emits when a TTL delete is followed by a fresh Put.
+  let existsStmt = db->SqliteDriver.prepare(
+    `SELECT 1 FROM ${table} WHERE partition_key = ? AND sub_key = ? AND ${notExpiredClause} LIMIT 1`,
+  )
 
   let rowsFor = (id: string): array<JSON.t> =>
     selectByPartitionStmt
@@ -246,16 +255,28 @@ let makeStorage = (
     | None => id
     }
 
-  let publishUpdated = (id: string, state: JSON.t) => {
+  let publishSaved = (~changeKind: string, id: string, state: JSON.t) => {
     let subKey = computeSubKey(state, subIdField)
     let descriptor = LocalBus.makeStateChangeDescriptor(
-      ~changeKind="Updated",
+      ~changeKind,
       ~id=entityKeyFor(id, subKey),
       ~state=Some(state),
     )
     bus.publishStateChange(~name, ~descriptor)
   }
 
+  // Must be called BEFORE the write — afterwards every row exists.
+  let saveKind = (id: string, state: JSON.t): string => {
+    let present =
+      existsStmt
+      ->SqliteDriver.get([
+        JSON.Encode.string(id),
+        JSON.Encode.string(computeSubKey(state, subIdField)),
+      ])
+      ->Option.isSome
+    present ? "Updated" : "Added"
+  }
+
   let publishRemoved = (id: string, subKey: string) => {
     let descriptor = LocalBus.makeStateChangeDescriptor(
       ~changeKind="Removed",
@@ -277,16 +298,25 @@ let makeStorage = (
     )
 
   let save: QueryDb.save<string, JSON.t> = async (id, state, _saveMode, ttl) => {
+    let changeKind = saveKind(id, state)
     saveOne(id, state, ttl)
-    publishUpdated(id, state)
+    publishSaved(~changeKind, id, state)
     Ok()
   }
 
   let saveBatch: QueryDb.saveBatch<string, JSON.t> = async batch => {
+    // Kinds are decided inside the transaction, each immediately before its own
+    // write, so a batch that touches one key twice reports Added then Updated.
+    let kinds = []
     db->SqliteDriver.transaction(() =>
-      batch->Array.forEach(((id, state, ttl)) => saveOne(id, state, ttl))
+      batch->Array.forEach(((id, state, ttl)) => {
+        kinds->Array.push(saveKind(id, state))
+        saveOne(id, state, ttl)
+      })
+    )
+    batch->Array.forEachWithIndex(((id, state, _), i) =>
+      publishSaved(~changeKind=kinds->Array.get(i)->Option.getOr("Updated"), id, state)
     )
-    batch->Array.forEach(((id, state, _)) => publishUpdated(id, state))
     Ok()
   }
 
@@ -310,8 +340,11 @@ let makeStorage = (
     obj->Dict.set("id", JSON.Encode.string(id))
     obj->Dict.set(fieldName, JSON.Encode.int(next))
     let newItem = JSON.Encode.object(obj)
+    // `existing` already answered the first-insert question — a counter's very
+    // first increment creates its row, and that is an Added like any other.
+    let changeKind = existing->Option.isSome ? "Updated" : "Added"
     saveOne(id, newItem, None)
-    publishUpdated(id, newItem)
+    publishSaved(~changeKind, id, newItem)
     Ok(next)
   }
 

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res.mjs

@@ -147,6 +147,7 @@ function makeStorage(db, bus, name, indexes, subIdField) {
   let deleteByPartitionStmt = SqliteDriver$ReventlessLocal.prepare(db, `DELETE FROM ` + table + ` WHERE partition_key = ?`);
   let deleteBySubKeyStmt = SqliteDriver$ReventlessLocal.prepare(db, `DELETE FROM ` + table + ` WHERE partition_key = ? AND sub_key = ?`);
   let scanAllStmt = SqliteDriver$ReventlessLocal.prepare(db, `SELECT partition_key, sub_key, item FROM ` + table + ` WHERE ` + notExpiredClause + ` ORDER BY partition_key, sub_key`);
+  let existsStmt = SqliteDriver$ReventlessLocal.prepare(db, `SELECT 1 FROM ` + table + ` WHERE partition_key = ? AND sub_key = ? AND ` + notExpiredClause + ` LIMIT 1`);
   let rowsFor = id => SqliteDriver$ReventlessLocal.all(selectByPartitionStmt, [id]).map(decodeItem);
   let rowToItem = row => {
     let item = decodeItem(row);
@@ -191,11 +192,22 @@ function makeStorage(db, bus, name, indexes, subIdField) {
       return id;
     }
   };
-  let publishUpdated = (id, state) => {
+  let publishSaved = (changeKind, id, state) => {
     let subKey = computeSubKey(state, subIdField);
-    let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Updated", entityKeyFor(id, subKey), state);
+    let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor(changeKind, entityKeyFor(id, subKey), state);
     bus.publishStateChange(name, descriptor);
   };
+  let saveKind = (id, state) => {
+    let present = Stdlib_Option.isSome(SqliteDriver$ReventlessLocal.get(existsStmt, [
+      id,
+      computeSubKey(state, subIdField)
+    ]));
+    if (present) {
+      return "Updated";
+    } else {
+      return "Added";
+    }
+  };
   let publishRemoved = (id, subKey) => {
     let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Removed", entityKeyFor(id, subKey), undefined);
     bus.publishStateChange(name, descriptor);
@@ -209,18 +221,25 @@ function makeStorage(db, bus, name, indexes, subIdField) {
     }
   });
   let save = async (id, state, _saveMode, ttl) => {
+    let changeKind = saveKind(id, state);
     saveOne(id, state, ttl);
-    publishUpdated(id, state);
+    publishSaved(changeKind, id, state);
     return {
       TAG: "Ok",
       _0: undefined
     };
   };
   let saveBatch = async batch => {
+    let kinds = [];
     SqliteDriver$ReventlessLocal.transaction(db, () => {
-      batch.forEach(param => saveOne(param[0], param[1], param[2]));
+      batch.forEach(param => {
+        let state = param[1];
+        let id = param[0];
+        kinds.push(saveKind(id, state));
+        saveOne(id, state, param[2]);
+      });
     });
-    batch.forEach(param => publishUpdated(param[0], param[1]));
+    batch.forEach((param, i) => publishSaved(Stdlib_Option.getOr(kinds[i], "Updated"), param[0], param[1]));
     return {
       TAG: "Ok",
       _0: undefined
@@ -238,8 +257,9 @@ function makeStorage(db, bus, name, indexes, subIdField) {
     }
     obj["id"] = id;
     obj[fieldName] = next;
+    let changeKind = Stdlib_Option.isSome(existing) ? "Updated" : "Added";
     saveOne(id, obj, undefined);
-    publishUpdated(id, obj);
+    publishSaved(changeKind, id, obj);
     return {
       TAG: "Ok",
       _0: next

package/src/adapter/SqliteDriver.res

@@ -7,10 +7,6 @@ type statement
 @module("node:sqlite") @new
 external openDatabaseSync: string => t = "DatabaseSync"
 
-@module("node:path") external dirname: string => string = "dirname"
-type mkdirOpts = {recursive: bool}
-@module("node:fs") external mkdirSync: (string, mkdirOpts) => unit = "mkdirSync"
-
 @send external _close: t => unit = "close"
 @send external _exec: (t, string) => unit = "exec"
 @send external _prepare: (t, string) => statement = "prepare"
@@ -25,7 +21,7 @@ let _iterateApply: (statement, array<JSON.t>) => Iterator.t<dict<JSON.t>> = %raw
 
 let openDb = (~path) => {
   if path !== ":memory:" {
-    mkdirSync(dirname(path), {recursive: true})
+    NodeFs.mkdirSync(NodePath.dirname(path), {recursive: true})
   }
   let db = openDatabaseSync(path)
   // Connection pragmas. WAL lets readers proceed concurrently with a writer and

package/tests/adapter/BackendParityTest.res

@@ -10,13 +10,12 @@
 
 open JestGlobals
 
-@val external processEnv: dict<string> = "process.env"
 
 let _ = TestRunner.setup()
 let opts: Pulumi.CustomResourceOptions.t = {}
 
 let pgPool =
-  processEnv
+  NodeProcess.env
   ->Dict.get("PG_URL")
   ->Option.map(url => ReventlessPostgres.PgDriver.makePool({connectionString: url}))
 
@@ -168,6 +167,100 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     await runUnderSqlite(scenario)
   })
 
+  testPromise("QueryDb: a first save is Added and a second is Updated under both", async () => {
+    let scenario = async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = LocalQueryDbStorage.Make(TestBus)
+      let s = Storage.make(~name="parity-kind", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+      let ops = await s.operations->TestRunner.resolve
+
+      let kinds = []
+      TestBus.subscribeToStateChanges("parity-kind", descriptor =>
+        descriptor
+        ->JSON.Decode.object
+        ->Option.flatMap(o => o->Dict.get("changeKind"))
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.forEach(k => kinds->Array.push(k))
+      )
+
+      let item = (k, v) =>
+        JSON.Encode.object(
+          Dict.fromArray([("id", JSON.Encode.string(k)), ("v", JSON.Encode.string(v))]),
+        )
+
+      // The distinction a list view depends on: a row it has never seen arrives
+      // as Added (and is inserted), a row it holds arrives as Updated.
+      let _ = await ops.save("p1", item("p1", "one"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("p1", item("p1", "two"), ReventlessCore.QueryDb.Any, None)
+      // A distinct key is its own first insert, not an update of the store.
+      let _ = await ops.save("p2", item("p2", "one"), ReventlessCore.QueryDb.Any, None)
+      // Deleting frees the key, so saving it again is an insert once more.
+      let _ = await ops.delete("p1", None)
+      let _ = await ops.save("p1", item("p1", "three"), ReventlessCore.QueryDb.Any, None)
+
+      expect(kinds)->toEqual(["Added", "Updated", "Added", "Removed", "Added"])
+    }
+
+    await runUnderMemory(scenario)
+    await runUnderSqlite(scenario)
+  })
+
+  testPromise("QueryDb: saveBatch reports Added then Updated for a repeated key under both", async () => {
+    let scenario = async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = LocalQueryDbStorage.Make(TestBus)
+      let s = Storage.make(~name="parity-batch", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+      let ops = await s.operations->TestRunner.resolve
+
+      let kinds = []
+      TestBus.subscribeToStateChanges("parity-batch", descriptor =>
+        descriptor
+        ->JSON.Decode.object
+        ->Option.flatMap(o => o->Dict.get("changeKind"))
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.forEach(k => kinds->Array.push(k))
+      )
+
+      let item = k => JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string(k))]))
+      let _ = await ops.saveBatch([
+        ("a", item("a"), None),
+        ("b", item("b"), None),
+        ("a", item("a"), None),
+      ])
+
+      expect(kinds)->toEqual(["Added", "Added", "Updated"])
+    }
+
+    await runUnderMemory(scenario)
+    await runUnderSqlite(scenario)
+  })
+
+  testPromise("QueryDb: a counter's first increment is Added under both", async () => {
+    let scenario = async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = LocalQueryDbStorage.Make(TestBus)
+      let s = Storage.make(~name="parity-ckind", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+      let ops = await s.operations->TestRunner.resolve
+
+      let kinds = []
+      TestBus.subscribeToStateChanges("parity-ckind", descriptor =>
+        descriptor
+        ->JSON.Decode.object
+        ->Option.flatMap(o => o->Dict.get("changeKind"))
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.forEach(k => kinds->Array.push(k))
+      )
+
+      let _ = await ops.count("prod-1", "orderCount", 1)
+      let _ = await ops.count("prod-1", "orderCount", 1)
+
+      expect(kinds)->toEqual(["Added", "Updated"])
+    }
+
+    await runUnderMemory(scenario)
+    await runUnderSqlite(scenario)
+  })
+
   testPromise("EventLog: conflict detection works under both", async () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()

package/tests/adapter/BackendParityTest.res.mjs

@@ -137,6 +137,102 @@ globalThis.describe("Backend parity (Memory vs Sqlite)", () => {
     await runUnderMemory(scenario);
     return await runUnderSqlite(scenario);
   });
+  globalThis.test("QueryDb: a first save is Added and a second is Updated under both", async () => {
+    let scenario = async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = LocalQueryDbStorage$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("parity-kind", [], undefined, undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let kinds = [];
+      TestBus.subscribeToStateChanges("parity-kind", descriptor => Stdlib_Option.forEach(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(descriptor), o => o["changeKind"]), Stdlib_JSON.Decode.string), k => {
+        kinds.push(k);
+      }));
+      let item = (k, v) => Object.fromEntries([
+        [
+          "id",
+          k
+        ],
+        [
+          "v",
+          v
+        ]
+      ]);
+      await ops.save("p1", item("p1", "one"), "Any", undefined);
+      await ops.save("p1", item("p1", "two"), "Any", undefined);
+      await ops.save("p2", item("p2", "one"), "Any", undefined);
+      await ops.delete("p1", undefined);
+      await ops.save("p1", item("p1", "three"), "Any", undefined);
+      globalThis.expect(kinds).toEqual([
+        "Added",
+        "Updated",
+        "Added",
+        "Removed",
+        "Added"
+      ]);
+    };
+    await runUnderMemory(scenario);
+    return await runUnderSqlite(scenario);
+  });
+  globalThis.test("QueryDb: saveBatch reports Added then Updated for a repeated key under both", async () => {
+    let scenario = async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = LocalQueryDbStorage$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("parity-batch", [], undefined, undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let kinds = [];
+      TestBus.subscribeToStateChanges("parity-batch", descriptor => Stdlib_Option.forEach(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(descriptor), o => o["changeKind"]), Stdlib_JSON.Decode.string), k => {
+        kinds.push(k);
+      }));
+      let item = k => Object.fromEntries([[
+          "id",
+          k
+        ]]);
+      await ops.saveBatch([
+        [
+          "a",
+          item("a"),
+          undefined
+        ],
+        [
+          "b",
+          item("b"),
+          undefined
+        ],
+        [
+          "a",
+          item("a"),
+          undefined
+        ]
+      ]);
+      globalThis.expect(kinds).toEqual([
+        "Added",
+        "Added",
+        "Updated"
+      ]);
+    };
+    await runUnderMemory(scenario);
+    return await runUnderSqlite(scenario);
+  });
+  globalThis.test("QueryDb: a counter's first increment is Added under both", async () => {
+    let scenario = async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = LocalQueryDbStorage$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("parity-ckind", [], undefined, undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let kinds = [];
+      TestBus.subscribeToStateChanges("parity-ckind", descriptor => Stdlib_Option.forEach(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(descriptor), o => o["changeKind"]), Stdlib_JSON.Decode.string), k => {
+        kinds.push(k);
+      }));
+      await ops.count("prod-1", "orderCount", 1);
+      await ops.count("prod-1", "orderCount", 1);
+      globalThis.expect(kinds).toEqual([
+        "Added",
+        "Updated"
+      ]);
+    };
+    await runUnderMemory(scenario);
+    return await runUnderSqlite(scenario);
+  });
   globalThis.test("EventLog: conflict detection works under both", async () => {
     let scenario = async () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});

package/tests/adapter/EventTapTest.res

@@ -17,7 +17,6 @@ let defaultMeta: Reventless.Message.meta = {
   correlationId: "",
 }
 
-@val external processEnv: Dict.t<string> = "process.env"
 
 type consoleObj = {mutable log: string => unit}
 @val external console: consoleObj = "console"
@@ -48,7 +47,7 @@ let tapLines = (logs: array<string>): array<string> =>
 
 describe("LocalBus event tap (Phase 9)", () => {
   // Each test owns the env flag; always clear it afterwards so cases don't leak.
-  let clearEnv = () => processEnv->Dict.delete("REVENTLESS_EVENT_TAP")
+  let clearEnv = () => NodeProcess.env->Dict.delete("REVENTLESS_EVENT_TAP")
 
   testPromise("tap off → no sentinel line is emitted", async () => {
     clearEnv()
@@ -60,7 +59,7 @@ describe("LocalBus event tap (Phase 9)", () => {
   })
 
   testPromise("tap on → one well-formed line per published event", async () => {
-    processEnv->Dict.set("REVENTLESS_EVENT_TAP", "ndjson")
+    NodeProcess.env->Dict.set("REVENTLESS_EVENT_TAP", "ndjson")
     module TestBus = LocalBus.MakeSilent()
     let logs = await captureLogs(async () => {
       await TestBus.publishEvent(
@@ -90,7 +89,7 @@ describe("LocalBus event tap (Phase 9)", () => {
   })
 
   testPromise("tap emits even when the topic has no subscribers", async () => {
-    processEnv->Dict.set("REVENTLESS_EVENT_TAP", "ndjson")
+    NodeProcess.env->Dict.set("REVENTLESS_EVENT_TAP", "ndjson")
     module TestBus = LocalBus.MakeSilent()
     let logs = await captureLogs(async () => {
       // No subscribeToEvents call — the tap fires before the subscriber-count gate.

package/tests/adapter/LocalAuthUserStoreTest.res

@@ -4,11 +4,6 @@
 
 open JestGlobals
 
-@module("node:fs") external _writeFileSync: (string, string, string) => unit = "writeFileSync"
-@module("node:fs") external _mkdtempSync: string => string = "mkdtempSync"
-@module("node:fs") external _rmSync: (string, {..}) => unit = "rmSync"
-@module("node:path") external _join: (string, string) => string = "join"
-@module("node:os") external _tmpdir: unit => string = "tmpdir"
 
 let resetAll = () => {
   LocalAuth.resetUsers()
@@ -17,9 +12,9 @@ let resetAll = () => {
 }
 
 let _writeYamlFile = (contents: string): string => {
-  let dir = _mkdtempSync(_join(_tmpdir(), "reventless-userstore-"))
-  let path = _join(dir, "users.yaml")
-  _writeFileSync(path, contents, "utf8")
+  let dir = NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "reventless-userstore-"]))
+  let path = NodePath.join([dir, "users.yaml"])
+  NodeFs.writeFileSync(path, contents)
   path
 }
 
@@ -102,7 +97,7 @@ testPromise("load(~usersFile) reads a YAML file from disk", async () => {
   | Ok(_) => ()
   | Error(msg) => JsError.throwWithMessage("issue rejected file-loaded credentials: " ++ msg)
   }
-  _rmSync(path, {"force": true})
+  NodeFs.rmSync(path, {force: true})
 })
 
 testPromise("load(~usersFile) returns Error when the file is missing", async () => {
@@ -152,7 +147,7 @@ testPromise("inline users win over a file path", async () => {
   | Some(_) => ()
   | None => JsError.throwWithMessage("inline-user missing from registry")
   }
-  _rmSync(path, {"force": true})
+  NodeFs.rmSync(path, {force: true})
 })
 
 testPromise("autoLoadOnce is a no-op after an explicit load", async () => {

package/tests/adapter/LocalEvents_ServerTest.res

@@ -120,6 +120,36 @@ describe("LocalEvents_Server", () => {
       expect(sentFrames.contents->Array.length)->toBe(2)
     })
 
+    testSync("publishes on the plugin-qualified list field, not the store name", () => {
+      // The channel root the client subscribes on is the read model's
+      // `listFieldName` ("Catalog_Products"), not its store name ("Products").
+      // The publish must translate through the same registry the AWS StateTopic
+      // wiring uses — otherwise the descriptor lands on a channel no one listens
+      // to and the socket stays Open while no view refreshes.
+      let registry = ReventlessCore.Plugin_Helpers.queryFieldNamesRegistry
+      registry->Dict.set(
+        "Products",
+        {
+          ReventlessCore.Api_Naming.singleFieldName: "Catalog_Product",
+          listFieldName: "Catalog_Products",
+          returnTypeName: "Catalog_Product",
+          pluralTypeName: "Catalog_Products",
+          includeIdParam: false,
+          connectionSpec: true,
+        },
+      )
+      let conn = makeConn()
+      LocalEvents_Server.handleFrame(
+        conn,
+        `{"type":"subscribe","id":"s","channel":"/default/Catalog-Products/*"}`,
+      )
+      LocalEvents_Server.broadcastStateChange(~name="Products", ~descriptor=descriptor(~id="SKU-1"))
+      // subscribe_success + a data frame ⇒ the descriptor reached the client's channel
+      expect(sentFrames.contents->Array.length)->toBe(2)
+      expect(sentFrames.contents->Array.getUnsafe(1)->frameField("type"))->toEqual(Some("data"))
+      registry->Dict.delete("Products")
+    })
+
     testSync("unsubscribe stops delivery", () => {
       let conn = makeConn()
       LocalEvents_Server.handleFrame(

package/tests/adapter/LocalEvents_ServerTest.res.mjs

@@ -1,8 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+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 Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 import * as LocalEvents_Server$ReventlessLocal from "../../src/adapter/Api/LocalEvents_Server.res.mjs";
 
 TestRunner$ReventlessLocal.setup();
@@ -85,6 +87,22 @@ globalThis.describe("LocalEvents_Server", () => {
       LocalEvents_Server$ReventlessLocal.broadcastStateChange("My.Model", descriptor("order#1@2026"));
       globalThis.expect(sentFrames.contents.length).toBe(2);
     });
+    globalThis.test("publishes on the plugin-qualified list field, not the store name", () => {
+      Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry["Products"] = {
+        singleFieldName: "Catalog_Product",
+        listFieldName: "Catalog_Products",
+        returnTypeName: "Catalog_Product",
+        pluralTypeName: "Catalog_Products",
+        includeIdParam: false,
+        connectionSpec: true
+      };
+      let conn = makeConn();
+      LocalEvents_Server$ReventlessLocal.handleFrame(conn, `{"type":"subscribe","id":"s","channel":"/default/Catalog-Products/*"}`);
+      LocalEvents_Server$ReventlessLocal.broadcastStateChange("Products", descriptor("SKU-1"));
+      globalThis.expect(sentFrames.contents.length).toBe(2);
+      globalThis.expect(frameField(sentFrames.contents[1], "type")).toEqual("data");
+      Stdlib_Dict.$$delete(Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry, "Products");
+    });
     globalThis.test("unsubscribe stops delivery", () => {
       let conn = makeConn();
       LocalEvents_Server$ReventlessLocal.handleFrame(conn, `{"type":"subscribe","id":"sub-1","channel":"/default/Product/*"}`);

package/tests/adapter/PgProjectionCatchupTest.res

@@ -10,7 +10,6 @@
 
 open JestGlobals
 
-@val external processEnv: dict<string> = "process.env"
 let opts: Pulumi.CustomResourceOptions.t = {}
 
 // Flat stored aggregate event — the exact shape EventLog_Operations.encodeEvent'
@@ -58,7 +57,7 @@ let recorder = () => {
   (received, handler)
 }
 
-switch processEnv->Dict.get("PG_URL") {
+switch NodeProcess.env->Dict.get("PG_URL") {
 | None => testSync("Postgres projection catch-up (skipped — set PG_URL)", () => expect(true)->toBe(true))
 | Some(url) =>
   let pool = ReventlessPostgres.PgDriver.makePool({connectionString: url})

package/tests/adapter/SqliteDriverTest.res

@@ -64,23 +64,23 @@ describe("SqliteDriver", () => {
 
   testPromise("Backend.fromEnv parses sqlite path and reset flag", async () => {
     let originalEnv =
-      Backend.processEnv->Dict.get("REVENTLESS_LOCAL_BACKEND")
+      NodeProcess.env->Dict.get("REVENTLESS_LOCAL_BACKEND")
 
-    Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", "sqlite:./local.db")
+    NodeProcess.env->Dict.set("REVENTLESS_LOCAL_BACKEND", "sqlite:./local.db")
     let parsed = Backend.fromEnv()
     expect(parsed)->toEqual(Backend.Sqlite({path: "./local.db", resetOnStart: false}))
 
-    Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", "sqlite:./local.db?reset")
+    NodeProcess.env->Dict.set("REVENTLESS_LOCAL_BACKEND", "sqlite:./local.db?reset")
     let parsedReset = Backend.fromEnv()
     expect(parsedReset)->toEqual(Backend.Sqlite({path: "./local.db", resetOnStart: true}))
 
-    Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", "memory")
+    NodeProcess.env->Dict.set("REVENTLESS_LOCAL_BACKEND", "memory")
     let parsedMem = Backend.fromEnv()
     expect(parsedMem)->toEqual(Backend.Memory)
 
     switch originalEnv {
-    | Some(v) => Backend.processEnv->Dict.set("REVENTLESS_LOCAL_BACKEND", v)
-    | None => Backend.processEnv->Dict.delete("REVENTLESS_LOCAL_BACKEND")
+    | Some(v) => NodeProcess.env->Dict.set("REVENTLESS_LOCAL_BACKEND", v)
+    | None => NodeProcess.env->Dict.delete("REVENTLESS_LOCAL_BACKEND")
     }
   })
 })