@reventlessdev/reventless-core 3.0.0-alpha.136 → 3.0.0-alpha.137

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 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.137 (2026-07-03)
+
+### Features
+
+* **core,local,aws:** EventLog snapshot storage surface, all backends (aggregate-snapshotting plan, steps 3+4) ([b6e50e2](https://github.com/ReventlessDev/reventless-core/commit/b6e50e2e5fe50b7372e54811f883fa91f6758dd1))
+* **core:** in-process aggregate replay cache (aggregate-snapshotting plan, phase 1) ([89c75f3](https://github.com/ReventlessDev/reventless-core/commit/89c75f33116e929cb8f4208b33498bab42db45e2))
+* **local:** DCB-axis projection checkpoints + startup catch-up (plan B5) ([8f9b11d](https://github.com/ReventlessDev/reventless-core/commit/8f9b11d24627bb6cc105d37af4974745444b80ba))
+### Performance Improvements
+
+* **core:** memoize message schemas, lazy projection logs, fail-closed slice cache (plan B6) ([b9e423c](https://github.com/ReventlessDev/reventless-core/commit/b9e423cb27932c4b6b5a123d3ae80d2239341d61))
+
+
 # 3.0.0-alpha.136 (2026-07-02)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.136",
+  "version": "3.0.0-alpha.137",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,21 +29,21 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
-    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
+    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
-    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
+    "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.83",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.13",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.22",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.63"
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.23",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.64",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.84"
   },
   "devDependencies": {
     "rescript": "^12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.48"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.50"
   },
   "peerDependencies": {
     "rescript": "^12.3.0"

package/src/Message.res

@@ -18,18 +18,51 @@ module type Service = {
 
 include Reventless.Message
 
+// Compose the wrapper schema once per (idSchema, payloadSchema) reference pair.
+// Both are module-level constants per message type, and sury schemas are built
+// to be reused across many parse/serialize calls — so the previous fresh
+// `S.object` on every decode/encode was pure allocation on the hottest path in
+// the framework. The cache is keyed by object identity (nested WeakMaps), so a
+// dropped schema is still collectable. `build` runs only on a miss.
+//
+// The raw closure is typed monomorphically over an opaque type (concrete → no
+// weak-var value-restriction problem); the locally-abstract-typed wrapper below
+// is a syntactic function, so it generalizes and `Obj.magic` bridges the two.
+// This keeps the public `toEventSchema'` / `toCommandSchema'` fully polymorphic.
+type opaqueSchema
+let _rawMemoize: (
+  opaqueSchema,
+  opaqueSchema,
+  (opaqueSchema, opaqueSchema) => opaqueSchema,
+) => opaqueSchema = %raw(`(function(){
+  const outer = new WeakMap();
+  return function(a, b, build){
+    let inner = outer.get(a);
+    if (inner === undefined) { inner = new WeakMap(); outer.set(a, inner); }
+    let v = inner.get(b);
+    if (v === undefined) { v = build(a, b); inner.set(b, v); }
+    return v;
+  };
+})()`)
+let memoizeBySchemaPair = (type a b c, a: a, b: b, build: (a, b) => c): c =>
+  _rawMemoize(Obj.magic(a), Obj.magic(b), Obj.magic(build))->Obj.magic
+
 let toEventSchema' = (idSchema, eventSchema) =>
-  S.object(s => {
-    id: s.field("id", idSchema),
-    meta: s.field("meta", metaSchema),
-    event: s.field("event", eventSchema),
-  })
+  memoizeBySchemaPair(idSchema, eventSchema, (idSchema, eventSchema) =>
+    S.object(s => {
+      id: s.field("id", idSchema),
+      meta: s.field("meta", metaSchema),
+      event: s.field("event", eventSchema),
+    })
+  )
 let toCommandSchema' = (idSchema, commandSchema) =>
-  S.object(s => {
-    id: s.field("id", idSchema),
-    meta: s.field("meta", metaSchema),
-    command: s.field("command", commandSchema),
-  })
+  memoizeBySchemaPair(idSchema, commandSchema, (idSchema, commandSchema) =>
+    S.object(s => {
+      id: s.field("id", idSchema),
+      meta: s.field("meta", metaSchema),
+      command: s.field("command", commandSchema),
+    })
+  )
 
 let decodeEvent' = (json, idSchema, eventSchema) =>
   json->S.parseJsonOrThrow(toEventSchema'(idSchema, eventSchema))

package/src/Message.res.mjs

@@ -12,20 +12,35 @@ import * as Logger$ReventlessCore from "./util/Logger.res.mjs";
 
 let logger = Logger$ReventlessCore.fromEnv();
 
+let _rawMemoize = ((function(){
+  const outer = new WeakMap();
+  return function(a, b, build){
+    let inner = outer.get(a);
+    if (inner === undefined) { inner = new WeakMap(); outer.set(a, inner); }
+    let v = inner.get(b);
+    if (v === undefined) { v = build(a, b); inner.set(b, v); }
+    return v;
+  };
+})());
+
+function memoizeBySchemaPair(a, b, build) {
+  return _rawMemoize(a, b, build);
+}
+
 function toEventSchema$p(idSchema, eventSchema) {
-  return S.object(s => ({
+  return _rawMemoize(idSchema, eventSchema, (idSchema, eventSchema) => S.object(s => ({
     id: s.f("id", idSchema),
     meta: s.f("meta", Message$Reventless.metaSchema),
     event: s.f("event", eventSchema)
-  }));
+  })));
 }
 
 function toCommandSchema$p(idSchema, commandSchema) {
-  return S.object(s => ({
+  return _rawMemoize(idSchema, commandSchema, (idSchema, commandSchema) => S.object(s => ({
     id: s.f("id", idSchema),
     meta: s.f("meta", Message$Reventless.metaSchema),
     command: s.f("command", commandSchema)
-  }));
+  })));
 }
 
 function decodeEvent$p(json, idSchema, eventSchema) {
@@ -385,6 +400,8 @@ export {
   decode,
   encode,
   InvalidEvent,
+  _rawMemoize,
+  memoizeBySchemaPair,
   toEventSchema$p,
   toCommandSchema$p,
   decodeEvent$p,

package/src/Projection.res

@@ -16,7 +16,10 @@ module Mapping = {
   }
 }
 
-let logAction = str => log.debug(~comp="Projection", str)
+// Lazy: the message thunk (and any `stateToString` it triggers) runs only when
+// debug logging is enabled, so projection actions don't serialize state on the
+// hot path at the default Info level.
+let logAction = makeStr => log.debugLazy(~comp="Projection", makeStr)
 
 // ── @displayName overlay ────────────────────────────────────────────────────
 // When a read model's state schema carries DisplayName metadata, every state
@@ -86,10 +89,16 @@ let applyChanges = async (
   let addedStates = afterStates->Array.filter(state => addedSubIds->Set.has(state->getSubId))
   let addedCount = addedStates->Array.length
 
-  let changedStates = beforeStates->Array.filterMap(before => {
-    let beforeSubId = before->getSubId
-    afterStates->Array.find(after => after->getSubId == beforeSubId && after != before)
-  })
+  // Index the after-states by subId once instead of scanning them per
+  // before-state (was O(before × after)).
+  let afterBySubId = Dict.make()
+  afterStates->Array.forEach(after => afterBySubId->Dict.set(after->getSubId, after))
+  let changedStates = beforeStates->Array.filterMap(before =>
+    switch afterBySubId->Dict.get(before->getSubId) {
+    | Some(after) if after != before => Some(after)
+    | _ => None
+    }
+  )
   let changedCount = changedStates->Array.length
 
   let batchToSave =
@@ -99,8 +108,8 @@ let applyChanges = async (
   let batchToDelete = deletedSubIds->Array.map(subId => (id, Some((subIdField, subId))))
   let deletedCount = batchToDelete->Array.length
 
-  logAction(
-    `${action}(${id}): beforeStates:${beforeCount->Int.toString} afterStates:${afterCount->Int.toString} added:${addedCount->Int.toString} changed:${changedCount->Int.toString} deleted:${deletedCount->Int.toString}`,
+  logAction(() =>
+    `${action}(${id}): beforeStates:${beforeCount->Int.toString} afterStates:${afterCount->Int.toString} added:${addedCount->Int.toString} changed:${changedCount->Int.toString} deleted:${deletedCount->Int.toString}`
   )
   let result = await [deleteBatch(batchToDelete), saveBatch(batchToSave)]->Promise.all
   // Propagate the first storage failure instead of swallowing it — a failed
@@ -116,7 +125,10 @@ let applyChanges = async (
   }
 }
 
-let stateToString: 'a => string = state => state->JSON.stringifyAny->Option.getOrThrow
+// Best-effort: a state that can't be JSON-serialized (e.g. carries a function)
+// must not crash the projection just to produce a debug line.
+let stateToString: 'a => string = state =>
+  state->JSON.stringifyAny->Option.getOr("<unserializable>")
 let statesToString: array<'a> => string = states =>
   states->Array.map(stateToString)->Array.joinUnsafe(", ")
 
@@ -140,17 +152,17 @@ let handleAction = async (
     ->Effect.runPromise
   switch action {
   | Ignore =>
-    logAction("Ignore")
+    logAction(() => "Ignore")
     Ok()
 
   | Create(id, state) =>
-    logAction(`Create(${id}, ${state->stateToString})`)
+    logAction(() => `Create(${id}, ${state->stateToString})`)
     await save(id, state, Init, None)
   | CreateMultiState(id, states) =>
-    logAction(
+    logAction(() =>
       `CreateMultiState(${id}, ${states
         ->Array.map(state => state->stateToString)
-        ->Array.joinUnsafe(", ")})`,
+        ->Array.joinUnsafe(", ")})`
     )
     switch states {
     | [] => Ok()
@@ -161,23 +173,23 @@ let handleAction = async (
     }
   | CreateMany(states) =>
     let batch = states->Array.map(((id, state)) => (id, state, None))
-    let statesStr =
-      batch
-      ->Array.map(((id, state, _)) => `(${id},${state->stateToString})`)
-      ->Array.joinUnsafe(", ")
-    logAction(`CreateMany(${statesStr})`)
+    logAction(() =>
+      `CreateMany(${batch
+        ->Array.map(((id, state, _)) => `(${id},${state->stateToString})`)
+        ->Array.joinUnsafe(", ")})`
+    )
     await saveBatch(batch) // TODO: think about using single saves with saveMode Init
 
   | Set(id, state) =>
-    logAction(`Set(${id}, ${state->stateToString})`)
+    logAction(() => `Set(${id}, ${state->stateToString})`)
     await save(id, state, Any, None)
   | SetMany(ids, set) =>
     let batch = ids->Array.map(id => (id, set(id), None))
-    let statesStr =
-      batch
-      ->Array.map(((id, state, _)) => `(${id},${state->stateToString})`)
-      ->Array.joinUnsafe(", ")
-    logAction(`SetMany(${statesStr})`)
+    logAction(() =>
+      `SetMany(${batch
+        ->Array.map(((id, state, _)) => `(${id},${state->stateToString})`)
+        ->Array.joinUnsafe(", ")})`
+    )
     await saveBatch(batch)
 
   | Update(id, update) =>
@@ -185,39 +197,39 @@ let handleAction = async (
     | Ok(states) =>
       switch states {
       | [] =>
-        logAction(`Update Error: No oldState for ${id})`)
+        logAction(() => `Update Error: No oldState for ${id})`)
         Error(ReventlessInfra.QueryDb.StaleState)
       | [oldState] =>
         let newState = oldState->update
-        logAction(`Update(${id}, ${oldState->stateToString} => ${newState->stateToString})`)
+        logAction(() => `Update(${id}, ${oldState->stateToString} => ${newState->stateToString})`)
         await save(id, newState, Overwrite, None)
       | _ =>
-        logAction(`Update Error: Multiple oldStates for ${id})`)
+        logAction(() => `Update Error: Multiple oldStates for ${id})`)
         Error(ReventlessInfra.QueryDb.StaleState)
       }
     | Error(err) => Error(err)
     }
   | UpdateWithDefault(id, default, update) =>
-    log.debug(~comp="Projection", `UpdateWithDefault(${id}, loading ...`)
+    logAction(() => `UpdateWithDefault(${id}, loading ...`)
     switch await loadAtMost(2, id) {
     | Ok(states) =>
       switch states {
       | [] =>
-        logAction(`UpdateWithDefault(${id}, default: ${default->stateToString})`)
+        logAction(() => `UpdateWithDefault(${id}, default: ${default->stateToString})`)
         await save(id, default, Init, None)
       | [oldState] =>
         let newState = oldState->update
-        logAction(
-          `UpdateWithDefault(${id}, ${oldState->stateToString} => ${newState->stateToString})`,
+        logAction(() =>
+          `UpdateWithDefault(${id}, ${oldState->stateToString} => ${newState->stateToString})`
         )
         await save(id, newState, Overwrite, None)
       | _ =>
-        logAction(`UpdateWithDefault Error: Multiple oldStates for ${id})`)
+        logAction(() => `UpdateWithDefault Error: Multiple oldStates for ${id})`)
         Error(ReventlessInfra.QueryDb.StaleState)
       }
     | Error(err) =>
-      logAction(
-        `UpdateWithDefault Error: Couldn't load oldState(s) for ${id}: ${err->QueryDb.storageErrorToString})`,
+      logAction(() =>
+        `UpdateWithDefault Error: Couldn't load oldState(s) for ${id}: ${err->QueryDb.storageErrorToString})`
       )
       Error(err)
     }
@@ -229,26 +241,26 @@ let handleAction = async (
       await applyChanges("UpdateMultiState", id, beforeStates, afterStates, operations, subIdConfig)
 
     | (Error(err), Some(_)) =>
-      logAction(
-        `UpdateMultiState Error: Couldn't load states for ${id}: ${err->QueryDb.storageErrorToString})`,
+      logAction(() =>
+        `UpdateMultiState Error: Couldn't load states for ${id}: ${err->QueryDb.storageErrorToString})`
       )
       Error(err)
     | (_, None) =>
-      logAction("UpdateMultiState Error: Missing SubIdConfig !")
+      logAction(() => "UpdateMultiState Error: Missing SubIdConfig !")
       Error(ReventlessInfra.QueryDb.MissingSubIdConfig)
     }
   | Delete(id) =>
-    logAction(`Delete(${id})`)
+    logAction(() => `Delete(${id})`)
     await delete(id, None)
   | DeleteMany(ids) =>
-    logAction(`DeleteMany(${ids->Array.joinUnsafe(", ")})`)
+    logAction(() => `DeleteMany(${ids->Array.joinUnsafe(", ")})`)
     await deleteBatch(ids->Array.map(id => (id, None)))
 
   // An action reaching here is one this projection engine doesn't implement.
   // Returning Ok() reported the read-model write as done while silently losing
   // it; surface a storage error instead.
   | _ =>
-    logAction("Error: projection action not supported")
+    logAction(() => "Error: projection action not supported")
     Error(ReventlessInfra.QueryDb.NotSavedToStorage("unsupported projection action"))
   }
 }
@@ -271,20 +283,27 @@ let actionsWithId = action =>
 
   // TODO: add missing actions
   | _ =>
-    logAction("Error: Action not yet supported !")
+    logAction(() => "Error: Action not yet supported !")
     []
   }
 
 let groupActionsById = actions => {
   let allActionsWithId = actions->Array.map(action => action->actionsWithId)->Array.flat
-  let ids = allActionsWithId->Array.map(((id, _)) => id)
-  ids
+  // One pass into a dict keyed by id (was O(ids × actions): a filterMap over
+  // every action per unique id). The id ordering is unchanged — still the sorted
+  // Belt.Set order — and each group preserves the actions' original order.
+  let groups = Dict.make()
+  allActionsWithId->Array.forEach(((id, action)) =>
+    switch groups->Dict.get(id) {
+    | Some(arr) => arr->Array.push(action)
+    | None => groups->Dict.set(id, [action])
+    }
+  )
+  groups
+  ->Dict.keysToArray
   ->Belt.Set.String.fromArray
   ->Belt.Set.String.toArray
-  ->Array.map(id => (
-    id,
-    allActionsWithId->Array.filterMap(((actionId, action)) => actionId == id ? Some(action) : None),
-  ))
+  ->Array.map(id => (id, groups->Dict.getUnsafe(id)))
 }
 
 let optimizeActions = actions => {

package/src/Projection.res.mjs

@@ -10,6 +10,7 @@ import * as Stream$1 from "effect/Stream";
 import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Logger$ReventlessCore from "./util/Logger.res.mjs";
 import * as DisplayName$Reventless from "@reventlessdev/reventless-spec/src/components/DisplayName.res.mjs";
 import * as Message$ReventlessCore from "./Message.res.mjs";
@@ -30,8 +31,8 @@ let Mapping = {
   MakeGenericSource: MakeGenericSource
 };
 
-function logAction(str) {
-  log.debug("Projection", undefined, str);
+function logAction(makeStr) {
+  log.debugLazy("Projection", makeStr);
 }
 
 function overlayDisplayName(state, stateSchema, spec) {
@@ -148,15 +149,19 @@ async function applyChanges(action, id, beforeStates, afterStates, param, param$
   let addedSubIds = Belt_SetString.diff(afterSubIds, beforeSubIds);
   let addedStates = afterStates.filter(state => Belt_SetString.has(addedSubIds, getSubId(state)));
   let addedCount = addedStates.length;
+  let afterBySubId = {};
+  afterStates.forEach(after => {
+    afterBySubId[getSubId(after)] = after;
+  });
   let changedStates = Stdlib_Array.filterMap(beforeStates, before => {
-    let beforeSubId = getSubId(before);
-    return afterStates.find(after => {
-      if (getSubId(after) === beforeSubId) {
-        return Primitive_object.notequal(after, before);
-      } else {
-        return false;
-      }
-    });
+    let after = afterBySubId[getSubId(before)];
+    if (after === undefined) {
+      return;
+    }
+    let after$1 = Primitive_option.valFromOption(after);
+    if (Primitive_object.notequal(after$1, before)) {
+      return Primitive_option.some(after$1);
+    }
   });
   let changedCount = changedStates.length;
   let batchToSave = changedStates.concat(addedStates).map(state => [
@@ -173,7 +178,7 @@ async function applyChanges(action, id, beforeStates, afterStates, param, param$
     ]
   ]);
   let deletedCount = batchToDelete.length;
-  logAction(action + `(` + id + `): beforeStates:` + beforeCount.toString() + ` afterStates:` + afterCount.toString() + ` added:` + addedCount.toString() + ` changed:` + changedCount.toString() + ` deleted:` + deletedCount.toString());
+  log.debugLazy("Projection", () => action + `(` + id + `): beforeStates:` + beforeCount.toString() + ` afterStates:` + afterCount.toString() + ` added:` + addedCount.toString() + ` changed:` + changedCount.toString() + ` deleted:` + deletedCount.toString());
   let result = await Promise.all([
     param.deleteBatch(batchToDelete),
     param.saveBatch(batchToSave)
@@ -190,7 +195,7 @@ async function applyChanges(action, id, beforeStates, afterStates, param, param$
 }
 
 function stateToString(state) {
-  return Stdlib_Option.getOrThrow(JSON.stringify(state), undefined);
+  return Stdlib_Option.getOr(JSON.stringify(state), "<unserializable>");
 }
 
 function statesToString(states) {
@@ -216,7 +221,7 @@ async function handleAction(action, operations, subIdConfig) {
     _0: e
   })));
   if (typeof action !== "object") {
-    logAction("Ignore");
+    log.debugLazy("Projection", () => "Ignore");
     return {
       TAG: "Ok",
       _0: undefined
@@ -226,7 +231,7 @@ async function handleAction(action, operations, subIdConfig) {
     case "Create" :
       let state = action._1;
       let id = action._0;
-      logAction(`Create(` + id + `, ` + stateToString(state) + `)`);
+      log.debugLazy("Projection", () => `Create(` + id + `, ` + stateToString(state) + `)`);
       return await save(id, state, "Init", undefined);
     case "CreateMany" :
       let batch = action._0.map(param => [
@@ -234,8 +239,7 @@ async function handleAction(action, operations, subIdConfig) {
         param[1],
         undefined
       ]);
-      let statesStr = batch.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ");
-      logAction(`CreateMany(` + statesStr + `)`);
+      log.debugLazy("Projection", () => `CreateMany(` + batch.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ") + `)`);
       return await saveBatch(batch);
     case "Update" :
       let id$1 = action._0;
@@ -250,13 +254,13 @@ async function handleAction(action, operations, subIdConfig) {
       let len = states$1.length;
       if (len !== 1) {
         if (len !== 0) {
-          logAction(`Update Error: Multiple oldStates for ` + id$1 + `)`);
+          log.debugLazy("Projection", () => `Update Error: Multiple oldStates for ` + id$1 + `)`);
           return {
             TAG: "Error",
             _0: "StaleState"
           };
         } else {
-          logAction(`Update Error: No oldState for ` + id$1 + `)`);
+          log.debugLazy("Projection", () => `Update Error: No oldState for ` + id$1 + `)`);
           return {
             TAG: "Error",
             _0: "StaleState"
@@ -265,35 +269,35 @@ async function handleAction(action, operations, subIdConfig) {
       }
       let oldState = states$1[0];
       let newState = action._1(oldState);
-      logAction(`Update(` + id$1 + `, ` + stateToString(oldState) + ` => ` + stateToString(newState) + `)`);
+      log.debugLazy("Projection", () => `Update(` + id$1 + `, ` + stateToString(oldState) + ` => ` + stateToString(newState) + `)`);
       return await save(id$1, newState, "Overwrite", undefined);
     case "UpdateWithDefault" :
       let $$default = action._1;
       let id$2 = action._0;
-      log.debug("Projection", undefined, `UpdateWithDefault(` + id$2 + `, loading ...`);
+      log.debugLazy("Projection", () => `UpdateWithDefault(` + id$2 + `, loading ...`);
       let states$2 = await loadAtMost(2, id$2);
       if (states$2.TAG === "Ok") {
         let states$3 = states$2._0;
         let len$1 = states$3.length;
         if (len$1 !== 1) {
           if (len$1 !== 0) {
-            logAction(`UpdateWithDefault Error: Multiple oldStates for ` + id$2 + `)`);
+            log.debugLazy("Projection", () => `UpdateWithDefault Error: Multiple oldStates for ` + id$2 + `)`);
             return {
               TAG: "Error",
               _0: "StaleState"
             };
           } else {
-            logAction(`UpdateWithDefault(` + id$2 + `, default: ` + stateToString($$default) + `)`);
+            log.debugLazy("Projection", () => `UpdateWithDefault(` + id$2 + `, default: ` + stateToString($$default) + `)`);
             return await save(id$2, $$default, "Init", undefined);
           }
         }
         let oldState$1 = states$3[0];
         let newState$1 = action._2(oldState$1);
-        logAction(`UpdateWithDefault(` + id$2 + `, ` + stateToString(oldState$1) + ` => ` + stateToString(newState$1) + `)`);
+        log.debugLazy("Projection", () => `UpdateWithDefault(` + id$2 + `, ` + stateToString(oldState$1) + ` => ` + stateToString(newState$1) + `)`);
         return await save(id$2, newState$1, "Overwrite", undefined);
       }
       let err = states$2._0;
-      logAction(`UpdateWithDefault Error: Couldn't load oldState(s) for ` + id$2 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err) + `)`);
+      log.debugLazy("Projection", () => `UpdateWithDefault Error: Couldn't load oldState(s) for ` + id$2 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err) + `)`);
       return {
         TAG: "Error",
         _0: err
@@ -301,7 +305,7 @@ async function handleAction(action, operations, subIdConfig) {
     case "Set" :
       let state$1 = action._1;
       let id$3 = action._0;
-      logAction(`Set(` + id$3 + `, ` + stateToString(state$1) + `)`);
+      log.debugLazy("Projection", () => `Set(` + id$3 + `, ` + stateToString(state$1) + `)`);
       return await save(id$3, state$1, "Any", undefined);
     case "SetMany" :
       let set = action._1;
@@ -310,16 +314,15 @@ async function handleAction(action, operations, subIdConfig) {
         set(id),
         undefined
       ]);
-      let statesStr$1 = batch$1.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ");
-      logAction(`SetMany(` + statesStr$1 + `)`);
+      log.debugLazy("Projection", () => `SetMany(` + batch$1.map(param => `(` + param[0] + `,` + stateToString(param[1]) + `)`).join(", ") + `)`);
       return await saveBatch(batch$1);
     case "Delete" :
       let id$4 = action._0;
-      logAction(`Delete(` + id$4 + `)`);
+      log.debugLazy("Projection", () => `Delete(` + id$4 + `)`);
       return await operations.delete(id$4, undefined);
     case "DeleteMany" :
       let ids = action._0;
-      logAction(`DeleteMany(` + ids.join(", ") + `)`);
+      log.debugLazy("Projection", () => `DeleteMany(` + ids.join(", ") + `)`);
       return await operations.deleteBatch(ids.map(id => [
         id,
         undefined
@@ -327,7 +330,7 @@ async function handleAction(action, operations, subIdConfig) {
     case "CreateMultiState" :
       let states$4 = action._1;
       let id$5 = action._0;
-      logAction(`CreateMultiState(` + id$5 + `, ` + states$4.map(stateToString).join(", ") + `)`);
+      log.debugLazy("Projection", () => `CreateMultiState(` + id$5 + `, ` + states$4.map(stateToString).join(", ") + `)`);
       let len$2 = states$4.length;
       if (len$2 !== 1) {
         if (len$2 === 0) {
@@ -354,27 +357,21 @@ async function handleAction(action, operations, subIdConfig) {
           let afterStates = action._1(states$5);
           return await applyChanges("UpdateMultiState", id$6, states$5, afterStates, operations, subIdConfig);
         }
-        logAction("UpdateMultiState Error: Missing SubIdConfig !");
-        return {
-          TAG: "Error",
-          _0: "MissingSubIdConfig"
-        };
-      }
-      if (subIdConfig !== undefined) {
+      } else if (subIdConfig !== undefined) {
         let err$1 = match._0;
-        logAction(`UpdateMultiState Error: Couldn't load states for ` + id$6 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err$1) + `)`);
+        log.debugLazy("Projection", () => `UpdateMultiState Error: Couldn't load states for ` + id$6 + `: ` + QueryDb$ReventlessCore.storageErrorToString(err$1) + `)`);
         return {
           TAG: "Error",
           _0: err$1
         };
       }
-      logAction("UpdateMultiState Error: Missing SubIdConfig !");
+      log.debugLazy("Projection", () => "UpdateMultiState Error: Missing SubIdConfig !");
       return {
         TAG: "Error",
         _0: "MissingSubIdConfig"
       };
     default:
-      logAction("Error: projection action not supported");
+      log.debugLazy("Projection", () => "Error: projection action not supported");
       return {
         TAG: "Error",
         _0: {
@@ -424,8 +421,7 @@ function actionsWithId(action) {
     case "UpdateManyWithDefault" :
     case "DeleteIf" :
     case "DeleteManyIf" :
-      logAction("Error: Action not yet supported !");
-      return [];
+      break;
     case "UpdateManyMultiStates" :
       let update = action._1;
       return action._0.map(id => [
@@ -442,18 +438,26 @@ function actionsWithId(action) {
           action
         ]];
   }
+  log.debugLazy("Projection", () => "Error: Action not yet supported !");
+  return [];
 }
 
 function groupActionsById(actions) {
   let allActionsWithId = actions.map(actionsWithId).flat();
-  let ids = allActionsWithId.map(param => param[0]);
-  return Belt_SetString.toArray(Belt_SetString.fromArray(ids)).map(id => [
+  let groups = {};
+  allActionsWithId.forEach(param => {
+    let action = param[1];
+    let id = param[0];
+    let arr = groups[id];
+    if (arr !== undefined) {
+      arr.push(action);
+    } else {
+      groups[id] = [action];
+    }
+  });
+  return Belt_SetString.toArray(Belt_SetString.fromArray(Object.keys(groups))).map(id => [
     id,
-    Stdlib_Array.filterMap(allActionsWithId, param => {
-      if (param[0] === id) {
-        return param[1];
-      }
-    })
+    groups[id]
   ]);
 }