@reventlessdev/reventless-local 3.0.0-alpha.181 → 3.0.0-alpha.183

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.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
+
+
+
+
+
 # 3.0.0-alpha.181 (2026-07-30)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.181",
+  "version": "3.0.0-alpha.183",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -34,17 +34,17 @@
     "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-jest": "1.0.0-alpha.9",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.20",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.31",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.193",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.140",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.41",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.57",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.111",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.86"
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.20",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.195",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.142",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.59",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.88",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.43",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.113"
   },
   "devDependencies": {
     "rescript": "12.3.0",

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/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);
@@ -210,10 +210,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/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/tests/adapter/BackendParityTest.res

@@ -168,6 +168,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/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/*"}`);