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

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 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.136 (2026-07-02)
+
+### Bug Fixes
+
+* **core,local:** projection/publisher/bus correctness (plan A5,A7) ([86e27a5](https://github.com/ReventlessDev/reventless-core/commit/86e27a5d68873d7dd9e746f9b4126f4d5bad63c9))
+
+
 # 3.0.0-alpha.135 (2026-06-29)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.135",
+  "version": "3.0.0-alpha.136",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,17 +28,17 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.23",
-    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
     "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.3",
+    "@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-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.21",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.62",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.82"
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.22",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.63"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/Projection.res

@@ -103,8 +103,16 @@ let applyChanges = async (
     `${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
-  switch result {
-  | _ => Ok() // TODO: Error handling
+  // Propagate the first storage failure instead of swallowing it — a failed
+  // delete/save was previously reported as a successful projection.
+  switch result->Array.find(r =>
+    switch r {
+    | Error(_) => true
+    | Ok(_) => false
+    }
+  ) {
+  | Some(err) => err
+  | None => Ok()
   }
 }
 
@@ -236,10 +244,12 @@ let handleAction = async (
     logAction(`DeleteMany(${ids->Array.joinUnsafe(", ")})`)
     await deleteBatch(ids->Array.map(id => (id, None)))
 
-  // TODO: add missing actions
+  // 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: Action not yet supported !")
-    Ok()
+    logAction("Error: projection action not supported")
+    Error(ReventlessInfra.QueryDb.NotSavedToStorage("unsupported projection action"))
   }
 }
 
@@ -285,11 +295,10 @@ let optimizeActions = actions => {
       [action]
     } else {
       let lastAction = optimizedActions->Array.getUnsafe(optimizedActionsCount - 1)
-      let previousActions = if optimizedActionsCount == 1 {
-        []
-      } else {
-        optimizedActions->Array.slice(~start=0, ~end=optimizedActionsCount)
-      }
+      // Everything BEFORE the last action. `~end` is exclusive, so this must be
+      // `count - 1`; using `count` kept `lastAction` in the slice while the merged
+      // action was also appended, applying the last action twice.
+      let previousActions = optimizedActions->Array.slice(~start=0, ~end=optimizedActionsCount - 1)
 
       switch (lastAction, action) {
       // SINGLE STATES

package/src/Projection.res.mjs

@@ -174,14 +174,19 @@ 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());
-  await Promise.all([
+  let result = await Promise.all([
     param.deleteBatch(batchToDelete),
     param.saveBatch(batchToSave)
   ]);
-  return {
-    TAG: "Ok",
-    _0: undefined
-  };
+  let err = result.find(r => r.TAG !== "Ok");
+  if (err !== undefined) {
+    return err;
+  } else {
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
 }
 
 function stateToString(state) {
@@ -369,10 +374,13 @@ async function handleAction(action, operations, subIdConfig) {
         _0: "MissingSubIdConfig"
       };
     default:
-      logAction("Error: Action not yet supported !");
+      logAction("Error: projection action not supported");
       return {
-        TAG: "Ok",
-        _0: undefined
+        TAG: "Error",
+        _0: {
+          TAG: "NotSavedToStorage",
+          _0: "unsupported projection action"
+        }
       };
   }
 }
@@ -456,7 +464,7 @@ function optimizeActions(actions) {
       return [action];
     }
     let lastAction = optimizedActions[optimizedActionsCount - 1 | 0];
-    let previousActions = optimizedActionsCount === 1 ? [] : optimizedActions.slice(0, optimizedActionsCount);
+    let previousActions = optimizedActions.slice(0, optimizedActionsCount - 1 | 0);
     if (typeof lastAction === "object") {
       switch (lastAction.TAG) {
         case "Create" :

package/src/components/Aggregate/Aggregate_Callback.res

@@ -185,11 +185,14 @@ module Make = (
                 ~appendedEventCount=generatedEvents'->Array.length,
               )
               EffectLogger.logInfo(~comp, `append: id=${idStr}`)->Effect.map(_ => Ok(perRef))
-            | Error(msg) if msg->String.includes("conflict") =>
+            | Error(EventLog.Conflict) =>
+              // Signal the outer replay+re-decide retry loop (which matches
+              // Error(_)); the string is an internal marker, no longer a
+              // cross-component substring sentinel.
               EffectLogger.logWarn(~comp, `conflict: id=${idStr}, will retry`)->Effect.map(
-                _ => Error(msg),
+                _ => Error("conflict"),
               )
-            | Error(msg) =>
+            | Error(EventLog.StorageFailure(msg)) =>
               let perRef = reportFinalOutcomes(
                 outcomes,
                 ~entityId=idStr,

package/src/components/Aggregate/Aggregate_Callback.res.mjs

@@ -146,14 +146,15 @@ function Make(Spec) {
               }));
             }
             let msg = appendResult._0;
-            if (msg.includes("conflict")) {
+            if (typeof msg !== "object") {
               return Effect.map(EffectLogger$ReventlessCore.logWarn(comp, undefined, `conflict: id=` + idStr + `, will retry`), () => ({
                 TAG: "Error",
-                _0: msg
+                _0: "conflict"
               }));
             }
-            let perRef$1 = reportFinalOutcomes(outcomes, idStr, false, 0, msg);
-            return Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, `append failed: id=` + idStr + `: ` + msg), () => ({
+            let msg$1 = msg._0;
+            let perRef$1 = reportFinalOutcomes(outcomes, idStr, false, 0, msg$1);
+            return Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, `append failed: id=` + idStr + `: ` + msg$1), () => ({
               TAG: "Ok",
               _0: perRef$1
             }));

package/src/components/EventLog/EventLog.res

@@ -7,7 +7,19 @@ type component<'operations> = Component.t<t, outputs, 'operations>
 
 exception ReplayError(string)
 
-type append<'id, 'event> = (int, 'id, array<'event>) => promise<result<unit, string>>
+// Typed append outcome. `Conflict` is the optimistic-concurrency sentinel — the
+// deliberate append-condition failure (seq_nr/position already taken) that the
+// caller retries by re-reading and re-deciding. Every other failure is a
+// `StorageFailure` carrying its message. This replaces the former string sentinel
+// that was detected by substring-matching a pretty-printed Cause across three
+// layers — a real error whose text happened to contain "conflict" would have
+// been retried as an OCC conflict, and a misclassified conflict would surface as
+// a permanent error.
+type appendError =
+  | Conflict
+  | StorageFailure(string)
+
+type append<'id, 'event> = (int, 'id, array<'event>) => promise<result<unit, appendError>>
 type replay<'id, 'event> = 'id => promise<array<'event>>
 type replayStream<'id, 'event> = 'id => Stream.t<'event, string, unit>
 type appendStream<'id, 'event> = (int, 'id, Stream.t<'event, string, unit>) => Effect.t<unit, string, unit>

package/src/components/EventLog/EventLog_Operations.res

@@ -16,14 +16,21 @@ module type T = {
 // Retry schedule for transient storage errors.
 // Exponential backoff: 100ms, ~200ms, ~400ms, ~800ms, ~1600ms — max 5 retries.
 // Only retries on recognised transient error messages; permanent errors propagate immediately.
-let isTransient = (msg: string) =>
-  msg->String.includes("ThrottlingException") ||
-  msg->String.includes("ProvisionedThroughputExceededException") ||
-  msg->String.includes("ServiceUnavailable") ||
-  msg->String.includes("RequestLimitExceeded") ||
-  msg->String.includes("InternalServerError")
-
-let storageRetrySchedule: Schedule.t<(Duration.t, int), string, unit> =
+// Retry only recognised transient storage failures — never a Conflict (a retry
+// of the same append would just conflict again; the OCC retry happens a layer up
+// via replay+re-decide).
+let isTransient = (e: EventLog.appendError) =>
+  switch e {
+  | EventLog.Conflict => false
+  | StorageFailure(msg) =>
+    msg->String.includes("ThrottlingException") ||
+    msg->String.includes("ProvisionedThroughputExceededException") ||
+    msg->String.includes("ServiceUnavailable") ||
+    msg->String.includes("RequestLimitExceeded") ||
+    msg->String.includes("InternalServerError")
+  }
+
+let storageRetrySchedule: Schedule.t<(Duration.t, int), EventLog.appendError, unit> =
   Schedule.exponential(Duration.millis(100))
   ->Schedule.jittered
   ->Schedule.intersect(Schedule.recurs(5))
@@ -112,44 +119,40 @@ module Make = (Spec: ReventlessInfra.EventLog.T, Ops: Ops with module Spec = Spe
     }
   }
 
-  // append returns result<unit, string> — never throws.
-  // Storage errors are retried with exponential backoff (up to 5 times for transient errors).
-  // After exhausting retries, or on permanent errors, returns Error.
-  let isConflict = (msg: string) => msg->String.includes("conflict")
-
+  // append returns result<unit, EventLog.appendError> — never throws.
+  // Transient storage failures are retried with exponential backoff (up to 5
+  // times); a Conflict is returned immediately (retried a layer up), and other
+  // failures propagate after retries are exhausted.
   let append = async (sequenceNr, id, events') => {
     let eventsJson = events'->encodeEvents'(id, sequenceNr)
     let idStr = id->Spec.Id.toString
-    // Build an Effect that fails with a string on storage error (enabling retry)
+    // A thrown storage error becomes a StorageFailure; a returned Error keeps its
+    // typed variant. The Effect fails with the typed appendError so the schedule
+    // can retry only transient failures, then we collapse the outcome back into a
+    // result (no Cause stringification / substring matching).
     let storageEffect =
       Effect.tryPromise(
-        ~catch=(err: unknown) => Util.Error.messageFromUnknown(err, "storage error"),
+        ~catch=(err: unknown) =>
+          EventLog.StorageFailure(Util.Error.messageFromUnknown(err, "storage error")),
         () => Ops.storage.append(sequenceNr, idStr, eventsJson),
       )
       ->Effect.flatMap(result =>
         switch result {
-        | Ok(_) => Effect.succeed(())
-        | Error(msg) => Effect.fail(msg)
+        | Ok(_) => Effect.succeed()
+        | Error(e) => Effect.fail(e)
         }
       )
       ->Effect.retry(storageRetrySchedule)
-    let exit = await storageEffect->Effect.runPromiseExit
-    if exit->Exit.isSuccess {
-      await publishToEventTopic(id, events', eventsJson)
-    } else {
-      // Retry exhausted — extract the final error message from the Cause.
-      // Use Cause.pretty so defects (uncaught throws) are surfaced too, not
-      // just typed failures from Cause.failures.
-      let failMsg = exit->Exit.match(
-        ~onFailure=cause => cause->Cause.pretty,
-        ~onSuccess=_ => "storage error", // unreachable: we are in the isFailure branch
-      )
-      // Propagate conflict errors without wrapping so callers can detect them
-      if isConflict(failMsg) {
-        Error("conflict")
-      } else {
-        Error(`EventLog: Error: Couldn't append for ${Spec.name}(${idStr}): ${failMsg}`)
-      }
+      ->Effect.map(_ => Ok())
+      ->Effect.catchAll(e => Effect.succeed(Error(e)))
+    switch await storageEffect->Effect.runPromise {
+    | Ok() =>
+      (await publishToEventTopic(id, events', eventsJson))->Result.mapError(msg => EventLog.StorageFailure(
+        msg,
+      ))
+    | Error(EventLog.Conflict) => Error(EventLog.Conflict)
+    | Error(StorageFailure(msg)) =>
+      Error(EventLog.StorageFailure(`EventLog: Error: Couldn't append for ${Spec.name}(${idStr}): ${msg}`))
     }
   }
 

package/src/components/EventLog/EventLog_Operations.res.mjs

@@ -1,12 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Exit from "@reventlessdev/rescript-effect/src/Exit.res.mjs";
 import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
-import * as Exit$1 from "effect/Exit";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
-import * as Cause from "effect/Cause";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Effect$1 from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -18,7 +16,11 @@ import * as Util_Error$ReventlessCore from "../../util/Util_Error.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
 import * as EventPublish_Callback$ReventlessCore from "./EventPublish_Callback.res.mjs";
 
-function isTransient(msg) {
+function isTransient(e) {
+  if (typeof e !== "object") {
+    return false;
+  }
+  let msg = e._0;
   if (msg.includes("ThrottlingException") || msg.includes("ProvisionedThroughputExceededException") || msg.includes("ServiceUnavailable") || msg.includes("RequestLimitExceeded")) {
     return true;
   } else {
@@ -111,27 +113,42 @@ function Make(Spec) {
     let append = async (sequenceNr, id, events$p) => {
       let eventsJson = encodeEvents$p(events$p, id, sequenceNr);
       let idStr = Spec.Id.toString(id);
-      let storageEffect = Effect$1.retry(Effect$1.flatMap(Effect.tryPromise(err => Util_Error$ReventlessCore.messageFromUnknown(err, "storage error"), () => Ops.storage.append(sequenceNr, idStr, eventsJson)), result => {
+      let storageEffect = Effect$1.catchAll(Effect$1.map(Effect$1.retry(Effect$1.flatMap(Effect.tryPromise(err => ({
+        TAG: "StorageFailure",
+        _0: Util_Error$ReventlessCore.messageFromUnknown(err, "storage error")
+      }), () => Ops.storage.append(sequenceNr, idStr, eventsJson)), result => {
         if (result.TAG === "Ok") {
           return Effect$1.succeed();
         } else {
           return Effect$1.fail(result._0);
         }
-      }), storageRetrySchedule);
-      let exit = await Effect$1.runPromiseExit(storageEffect);
-      if (Exit$1.isSuccess(exit)) {
-        return await publishToEventTopic(id, events$p, eventsJson);
+      }), storageRetrySchedule), () => ({
+        TAG: "Ok",
+        _0: undefined
+      })), e => Effect$1.succeed({
+        TAG: "Error",
+        _0: e
+      }));
+      let match = await Effect$1.runPromise(storageEffect);
+      if (match.TAG === "Ok") {
+        return Stdlib_Result.mapError(await publishToEventTopic(id, events$p, eventsJson), msg => ({
+          TAG: "StorageFailure",
+          _0: msg
+        }));
       }
-      let failMsg = Exit.match(exit, cause => Cause.pretty(cause), () => "storage error");
-      if (failMsg.includes("conflict")) {
+      let msg = match._0;
+      if (typeof msg !== "object") {
         return {
           TAG: "Error",
-          _0: "conflict"
+          _0: "Conflict"
         };
       } else {
         return {
           TAG: "Error",
-          _0: `EventLog: Error: Couldn't append for ` + Spec.name + `(` + idStr + `): ` + failMsg
+          _0: {
+            TAG: "StorageFailure",
+            _0: `EventLog: Error: Couldn't append for ` + Spec.name + `(` + idStr + `): ` + msg._0
+          }
         };
       }
     };

package/src/plugin/component/SchemaWalker.res

@@ -38,7 +38,19 @@ let rec describeSchema = (schema: S.t<unknown>): string =>
     | _ => "unknown"
     }
     "array<" ++ itemDesc ++ ">"
-  | Object(_) => "object"
+  | Object({properties}) =>
+    // Recurse into nested records. Rendering every object as the literal
+    // "object" made the structural hash blind to nested field changes — a
+    // nested schema edit produced an identical SHA256, so drift detection
+    // silently missed it. Emit a sorted `{name:type,…}` description instead.
+    let inner =
+      properties
+      ->Dict.toArray
+      ->Array.filter(((name, _)) => name != "TAG")
+      ->Array.toSorted(((a, _), (b, _)) => String.compare(a, b))
+      ->Array.map(((name, s)) => name ++ ":" ++ describeSchema(s))
+      ->Array.join(",")
+    "{" ++ inner ++ "}"
   | _ => "unknown"
   }
 

package/src/plugin/component/SchemaWalker.res.mjs

@@ -23,7 +23,8 @@ function describeSchema(schema) {
       itemDesc = additionalItems === "strip" || additionalItems === "strict" ? "unknown" : describeSchema(additionalItems);
       return "array<" + itemDesc + ">";
     case "object" :
-      return "object";
+      let inner = Object.entries(schema.properties).filter(param => param[0] !== "TAG").toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0])).map(param => param[0] + ":" + describeSchema(param[1])).join(",");
+      return "{" + inner + "}";
     case "union" :
       let nonNull = schema.anyOf.filter(v => {
         switch (v.type) {
@@ -34,9 +35,9 @@ function describeSchema(schema) {
             return true;
         }
       });
-      let inner = nonNull[0];
-      if (inner !== undefined) {
-        return "option<" + describeSchema(inner) + ">";
+      let inner$1 = nonNull[0];
+      if (inner$1 !== undefined) {
+        return "option<" + describeSchema(inner$1) + ">";
       } else {
         return "unknown";
       }

package/src/util/CommandPublisher.res

@@ -63,7 +63,12 @@ module Make = (Spec: Spec, Config: Config) => {
           ~comp="CommandPublisher",
           `send: bufferSize: ${bufferSizeStr}, chunk: ${chunkCountStr}, size: ${sizeStr}`,
         )->Effect.runSync
-        let commandsToSend = buffer->Array.toSpliced(~start=0, ~remove=size, ~insert=[])
+        // Take the first `size` commands and remove them from the buffer.
+        // (`toSpliced` is non-mutating and returns the *remainder*, so the buffer
+        // never drained: send() recursed on the same buffer and published the
+        // wrong slice. `slice` captures the chunk; `splice` drains it in place.)
+        let commandsToSend = buffer->Array.slice(~start=0, ~end=size)
+        buffer->Array.splice(~start=0, ~remove=size, ~insert=[])
         let promise = Config.publishCommands(Spec.name, commandsToSend->toJsons)
         running := Some(promise)
         switch await promise {
@@ -82,7 +87,12 @@ module Make = (Spec: Spec, Config: Config) => {
     | SendAllInOneChunk =>
       let size = buffer->Array.length
       if size > 0 {
-        let commandsToSend = buffer->Array.toSpliced(~start=0, ~remove=size, ~insert=[])
+        // Take the first `size` commands and remove them from the buffer.
+        // (`toSpliced` is non-mutating and returns the *remainder*, so the buffer
+        // never drained: send() recursed on the same buffer and published the
+        // wrong slice. `slice` captures the chunk; `splice` drains it in place.)
+        let commandsToSend = buffer->Array.slice(~start=0, ~end=size)
+        buffer->Array.splice(~start=0, ~remove=size, ~insert=[])
         let promise = Config.publishCommands(Spec.name, commandsToSend->toJsons)
         running := Some(promise)
         switch await promise {
@@ -115,19 +125,19 @@ module Make = (Spec: Spec, Config: Config) => {
 
   let clear = () => {
     EffectLogger.logDebug(~comp="CommandPublisher", "clear")->Effect.runSync
-    let _ = buffer->Array.removeInPlace(0)
+    // Truncate the whole buffer. `removeInPlace(0)` is `splice(0, 1)` — it drops
+    // only the first element, so the rest leaked out on a later publish.
+    buffer->Array.splice(~start=0, ~remove=buffer->Array.length, ~insert=[])
     flush := false
   }
 
   let flush = async () => {
     EffectLogger.logDebug(~comp="CommandPublisher", "flush")->Effect.runSync
     flush := true
-    switch running.contents {
-    | None => await send()
-    | _ =>
-      while running.contents->Option.isNone {
-        await finishRunning()
-      }
-    }
+    // `send` already awaits any in-flight publish (finishRunning) before draining
+    // the buffer, and flush:=true forces a partial final chunk. The previous
+    // in-flight arm looped on `running.contents->Option.isNone` — dead, since this
+    // path only ran when running was Some — so buffered commands were never sent.
+    await send()
   }
 }

package/src/util/CommandPublisher.res.mjs

@@ -54,7 +54,8 @@ function Make(Spec) {
         if (size <= 0) {
           return;
         }
-        let commandsToSend = buffer.toSpliced(0, size);
+        let commandsToSend = buffer.slice(0, size);
+        buffer.splice(0, size);
         let promise = Config.publishCommands(Spec.name, toJsons(commandsToSend));
         running.contents = promise;
         let exit = 0;
@@ -88,7 +89,8 @@ function Make(Spec) {
       let bufferSizeStr = buffer.length.toString();
       let chunkCountStr = chunkCount.contents.toString();
       Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, `send: bufferSize: ` + bufferSizeStr + `, chunk: ` + chunkCountStr + `, size: ` + sizeStr));
-      let commandsToSend$1 = buffer.toSpliced(0, size$1);
+      let commandsToSend$1 = buffer.slice(0, size$1);
+      buffer.splice(0, size$1);
       let promise$1 = Config.publishCommands(Spec.name, toJsons(commandsToSend$1));
       running.contents = promise$1;
       let exit$1 = 0;
@@ -127,19 +129,13 @@ function Make(Spec) {
     };
     let clear = () => {
       Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, "clear"));
-      buffer.splice(0, 1);
+      buffer.splice(0, buffer.length);
       flush.contents = false;
     };
     let flush$1 = async () => {
       Effect.runSync(EffectLogger$ReventlessCore.logDebug("CommandPublisher", undefined, "flush"));
       flush.contents = true;
-      let match = running.contents;
-      if (match === undefined) {
-        return await send();
-      }
-      while (Stdlib_Option.isNone(running.contents)) {
-        await finishRunning();
-      };
+      return await send();
     };
     return {
       buffer: buffer,

package/src/util/Util_Array.res

@@ -1,2 +1,2 @@
 let containsByPredicate: (array<'a>, 'a => bool) => bool = (arr, predicate) =>
-  arr->Array.find(predicate)->Option.isNone
+  arr->Array.find(predicate)->Option.isSome

package/src/util/Util_Array.res.mjs

@@ -3,7 +3,7 @@
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 function containsByPredicate(arr, predicate) {
-  return Stdlib_Option.isNone(arr.find(predicate));
+  return Stdlib_Option.isSome(arr.find(predicate));
 }
 
 export {

package/tests/aggregate/AggregateConflictTest.res

@@ -41,7 +41,7 @@ module TestBehavior = {
 }
 
 type mockEL = {
-  appendFn: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, string>>,
+  appendFn: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, EventLog.appendError>>,
   replayFn: string => promise<array<AggSpec.event>>,
   replayStreamFn: string => Stream.t<AggSpec.event, string, unit>,
   getAll: unit => array<Message.event'<string, AggSpec.event>>,
@@ -61,7 +61,7 @@ let makeMockEL = (): mockEL => {
     appendCount := appendCount.contents + 1
     if failConflictRef.contents > 0 {
       failConflictRef := failConflictRef.contents - 1
-      Error("conflict")
+      Error(EventLog.Conflict)
     } else {
       storedRef := storedRef.contents->Array.concat(newEvents)
       Ok(())
@@ -114,7 +114,7 @@ module TestOps = {
       type event = AggSpec.event
     }
     type operations = {
-      append: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, string>>,
+      append: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, EventLog.appendError>>,
       replay: string => promise<array<AggSpec.event>>,
       replayStream: string => Stream.t<AggSpec.event, string, unit>,
       appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<unit, string, unit>,

package/tests/aggregate/AggregateConflictTest.res.mjs

@@ -87,7 +87,7 @@ function makeMockEL() {
       failConflictRef.contents = failConflictRef.contents - 1 | 0;
       return {
         TAG: "Error",
-        _0: "conflict"
+        _0: "Conflict"
       };
     } else {
       storedRef.contents = storedRef.contents.concat(newEvents);

package/tests/aggregate/AggregateFixtures.res

@@ -60,7 +60,7 @@ module TestBehavior = {
 // ─────────────────────────────────────────────────────────────
 
 type mockEL = {
-  appendFn: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, string>>,
+  appendFn: (int, string, array<Message.event'<string, AggSpec.event>>) => promise<result<unit, EventLog.appendError>>,
   replayFn: string => promise<array<AggSpec.event>>,
   replayStreamFn: string => Stream.t<AggSpec.event, string, unit>,
   getAll: unit => array<Message.event'<string, AggSpec.event>>,
@@ -75,7 +75,7 @@ let makeMockEL = (): mockEL => {
   let appendFn = async (_seqNr, _id, newEvents) =>
     if failRef.contents {
       failRef := false
-      Error("append failed")
+      Error(EventLog.StorageFailure("append failed"))
     } else {
       storedRef := storedRef.contents->Array.concat(newEvents)
       Ok(())
@@ -129,7 +129,7 @@ module TestOps = {
         int,
         string,
         array<Message.event'<string, AggSpec.event>>,
-      ) => promise<result<unit, string>>,
+      ) => promise<result<unit, EventLog.appendError>>,
       replay: string => promise<array<AggSpec.event>>,
       replayStream: string => Stream.t<AggSpec.event, string, unit>,
       appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<unit, string, unit>,

package/tests/aggregate/AggregateFixtures.res.mjs

@@ -129,7 +129,10 @@ function makeMockEL() {
       failRef.contents = false;
       return {
         TAG: "Error",
-        _0: "append failed"
+        _0: {
+          TAG: "StorageFailure",
+          _0: "append failed"
+        }
       };
     } else {
       storedRef.contents = storedRef.contents.concat(newEvents);

package/tests/eventlog/EventLogFixtures.res

@@ -28,10 +28,10 @@ let mockStorage: EventLog_Adapter.operations = {
     appendCallCount := appendCallCount.contents + 1
     if failNextAppend.contents {
       failNextAppend := false
-      Error("mock storage failure")
+      Error(EventLog.StorageFailure("mock storage failure"))
     } else if failNextAppendsWithTransient.contents > 0 {
       failNextAppendsWithTransient := failNextAppendsWithTransient.contents - 1
-      Error("ThrottlingException: Rate exceeded")
+      Error(EventLog.StorageFailure("ThrottlingException: Rate exceeded"))
     } else {
       let existing = storedEvents.contents->Dict.get(id)->Option.getOr([])
       storedEvents.contents->Dict.set(id, existing->Array.concat(jsons))

package/tests/eventlog/EventLogFixtures.res.mjs

@@ -47,14 +47,20 @@ async function mockStorage_append(_seqNr, id, jsons) {
     failNextAppend.contents = false;
     return {
       TAG: "Error",
-      _0: "mock storage failure"
+      _0: {
+        TAG: "StorageFailure",
+        _0: "mock storage failure"
+      }
     };
   }
   if (failNextAppendsWithTransient.contents > 0) {
     failNextAppendsWithTransient.contents = failNextAppendsWithTransient.contents - 1 | 0;
     return {
       TAG: "Error",
-      _0: "ThrottlingException: Rate exceeded"
+      _0: {
+        TAG: "StorageFailure",
+        _0: "ThrottlingException: Rate exceeded"
+      }
     };
   }
   let existing = Stdlib_Option.getOr(storedEvents.contents[id], []);

package/tests/eventlog/EventLogRetryTest.res

@@ -16,36 +16,37 @@ let _ = beforeEach(() => reset())
 
 describe("EventLog_Operations — retry:", () => {
   describe("isTransient predicate:", () => {
+    let transient = msg => EventLog_Operations.isTransient(EventLog.StorageFailure(msg))
     testPromise("ThrottlingException is transient", async () => {
-      expect(EventLog_Operations.isTransient("ThrottlingException: Rate exceeded"))->toBe(true)
+      expect(transient("ThrottlingException: Rate exceeded"))->toBe(true)
     })
 
     testPromise("ProvisionedThroughputExceededException is transient", async () => {
-      expect(
-        EventLog_Operations.isTransient("ProvisionedThroughputExceededException"),
-      )->toBe(true)
+      expect(transient("ProvisionedThroughputExceededException"))->toBe(true)
     })
 
     testPromise("ServiceUnavailable is transient", async () => {
-      expect(EventLog_Operations.isTransient("ServiceUnavailable"))->toBe(true)
+      expect(transient("ServiceUnavailable"))->toBe(true)
     })
 
     testPromise("RequestLimitExceeded is transient", async () => {
-      expect(EventLog_Operations.isTransient("RequestLimitExceeded"))->toBe(true)
+      expect(transient("RequestLimitExceeded"))->toBe(true)
     })
 
     testPromise("InternalServerError is transient", async () => {
-      expect(EventLog_Operations.isTransient("InternalServerError: something went wrong"))->toBe(
-        true,
-      )
+      expect(transient("InternalServerError: something went wrong"))->toBe(true)
     })
 
     testPromise("ValidationException is not transient", async () => {
-      expect(EventLog_Operations.isTransient("ValidationException: invalid field"))->toBe(false)
+      expect(transient("ValidationException: invalid field"))->toBe(false)
     })
 
     testPromise("generic mock storage failure is not transient", async () => {
-      expect(EventLog_Operations.isTransient("mock storage failure"))->toBe(false)
+      expect(transient("mock storage failure"))->toBe(false)
+    })
+
+    testPromise("a Conflict is never transient (retried a layer up, not here)", async () => {
+      expect(EventLog_Operations.isTransient(EventLog.Conflict))->toBe(false)
     })
   })
 

package/tests/eventlog/EventLogRetryTest.res.mjs

@@ -74,25 +74,49 @@ globalThis.beforeEach(() => EventLogFixtures$ReventlessCore.reset());
 globalThis.describe("EventLog_Operations — retry:", () => {
   globalThis.describe("isTransient predicate:", () => {
     globalThis.test("ThrottlingException is transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ThrottlingException: Rate exceeded")).toBe(true);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "ThrottlingException: Rate exceeded"
+      })).toBe(true);
     });
     globalThis.test("ProvisionedThroughputExceededException is transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ProvisionedThroughputExceededException")).toBe(true);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "ProvisionedThroughputExceededException"
+      })).toBe(true);
     });
     globalThis.test("ServiceUnavailable is transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ServiceUnavailable")).toBe(true);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "ServiceUnavailable"
+      })).toBe(true);
     });
     globalThis.test("RequestLimitExceeded is transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("RequestLimitExceeded")).toBe(true);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "RequestLimitExceeded"
+      })).toBe(true);
     });
     globalThis.test("InternalServerError is transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("InternalServerError: something went wrong")).toBe(true);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "InternalServerError: something went wrong"
+      })).toBe(true);
     });
     globalThis.test("ValidationException is not transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("ValidationException: invalid field")).toBe(false);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "ValidationException: invalid field"
+      })).toBe(false);
     });
     globalThis.test("generic mock storage failure is not transient", async () => {
-      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("mock storage failure")).toBe(false);
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient({
+        TAG: "StorageFailure",
+        _0: "mock storage failure"
+      })).toBe(false);
+    });
+    globalThis.test("a Conflict is never transient (retried a layer up, not here)", async () => {
+      globalThis.expect(EventLog_Operations$ReventlessCore.isTransient("Conflict")).toBe(false);
     });
   });
   globalThis.describe("permanent storage failure:", () => {

package/tests/projection/ProjectionOptimizeTest.res

@@ -0,0 +1,38 @@
+// Regression test for Projection.optimizeActions (plan A7 / D2).
+//
+// optimizeActions merges consecutive per-id actions. A non-merging pair (Delete
+// then Update) grows the accumulator to length 2; the next merge (Update+Set)
+// must fold only the last action and keep everything before it exactly once.
+// Before the `~end=count-1` fix, `previousActions` still contained the
+// just-merged action, so the earlier action was duplicated — applied twice.
+
+open JestGlobals
+open Reventless.Projection
+
+describe("Projection.optimizeActions", () => {
+  testSync("does not duplicate the pre-merge action (off-by-one regression)", () => {
+    let optimized = Projection.optimizeActions([Delete("a"), Update("a", x => x + 1), Set("a", 99)])
+    // Was 3 (with a duplicated Update("a")) before the fix.
+    expect(optimized->Array.length)->toBe(2)
+    let sets =
+      optimized->Array.filterMap(a =>
+        switch a {
+        | Set(id, s) => Some((id, s))
+        | _ => None
+        }
+      )
+    expect(sets)->toEqual([("a", 99)])
+  })
+
+  testSync("merges a same-id Create+Update chain into a single Create", () => {
+    let optimized = Projection.optimizeActions([Create("a", 0), Update("a", x => x + 1), Update("a", x => x + 10)])
+    let creates =
+      optimized->Array.filterMap(a =>
+        switch a {
+        | Create(id, s) => Some((id, s))
+        | _ => None
+        }
+      )
+    expect(creates)->toEqual([("a", 11)])
+  })
+})

package/tests/projection/ProjectionOptimizeTest.res.mjs

@@ -0,0 +1,75 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Projection$ReventlessCore from "../../src/Projection.res.mjs";
+
+globalThis.describe("Projection.optimizeActions", () => {
+  globalThis.test("does not duplicate the pre-merge action (off-by-one regression)", () => {
+    let optimized = Projection$ReventlessCore.optimizeActions([
+      {
+        TAG: "Delete",
+        _0: "a"
+      },
+      {
+        TAG: "Update",
+        _0: "a",
+        _1: x => x + 1 | 0
+      },
+      {
+        TAG: "Set",
+        _0: "a",
+        _1: 99
+      }
+    ]);
+    globalThis.expect(optimized.length).toBe(2);
+    let sets = Stdlib_Array.filterMap(optimized, a => {
+      if (typeof a !== "object" || a.TAG !== "Set") {
+        return;
+      } else {
+        return [
+          a._0,
+          a._1
+        ];
+      }
+    });
+    globalThis.expect(sets).toEqual([[
+        "a",
+        99
+      ]]);
+  });
+  globalThis.test("merges a same-id Create+Update chain into a single Create", () => {
+    let optimized = Projection$ReventlessCore.optimizeActions([
+      {
+        TAG: "Create",
+        _0: "a",
+        _1: 0
+      },
+      {
+        TAG: "Update",
+        _0: "a",
+        _1: x => x + 1 | 0
+      },
+      {
+        TAG: "Update",
+        _0: "a",
+        _1: x => x + 10 | 0
+      }
+    ]);
+    let creates = Stdlib_Array.filterMap(optimized, a => {
+      if (typeof a !== "object" || a.TAG !== "Create") {
+        return;
+      } else {
+        return [
+          a._0,
+          a._1
+        ];
+      }
+    });
+    globalThis.expect(creates).toEqual([[
+        "a",
+        11
+      ]]);
+  });
+});
+
+/*  Not a pure module */

package/tests/util/CommandPublisherTest.res

@@ -0,0 +1,56 @@
+// Regression tests for CommandPublisher (plan A7).
+//
+// Two bugs made the buffered publisher silently lose commands:
+//   - send() used the non-mutating `toSpliced`, so the buffer never drained and
+//     the wrong slice was published.
+//   - flush()'s in-flight arm looped on a dead condition and never sent.
+//   - clear() removed only the first buffered command instead of truncating.
+//
+// These tests drive the functor with a capturing publishCommands and assert the
+// buffer flushes in order and clear() empties it.
+
+open JestGlobals
+
+S.enableJson()
+
+let published: ref<array<Reventless.Message.commandJson>> = ref([])
+
+module TestSpec = {
+  @schema let name = "TestCmd"
+  @schema type command = {value: int}
+}
+
+module TestConfig = {
+  let user = "tester"
+  let publishCommands: Task.publishCommands = (_name, cmds) => {
+    published := published.contents->Array.concat(cmds)
+    Promise.resolve()
+  }
+  let mode = CommandPublisher.SendAllInOneChunk
+}
+
+module Pub = CommandPublisher.Make(TestSpec, TestConfig)
+
+describe("CommandPublisher", () => {
+  testPromise("flush sends all buffered commands in order and drains the buffer", async () => {
+    published := []
+    Pub.publish("id1", {value: 1})
+    Pub.publish("id2", {value: 2})
+    await Pub.flush()
+    let ids = published.contents->Array.map((c: Reventless.Message.commandJson) => c.id)
+    expect(ids)->toEqual(["id1", "id2"])
+    // Buffer drained: a second flush sends nothing more.
+    published := []
+    await Pub.flush()
+    expect(published.contents->Array.length)->toBe(0)
+  })
+
+  testPromise("clear truncates the whole buffer so nothing is later published", async () => {
+    published := []
+    Pub.publish("id3", {value: 3})
+    Pub.publish("id4", {value: 4})
+    Pub.clear()
+    await Pub.flush()
+    expect(published.contents->Array.length)->toBe(0)
+  })
+})

package/tests/util/CommandPublisherTest.res.mjs

@@ -0,0 +1,78 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as CommandPublisher$ReventlessCore from "../../src/util/CommandPublisher.res.mjs";
+
+S.enableJson();
+
+let published = {
+  contents: []
+};
+
+let commandSchema = S.schema(s => ({
+  value: s.m(S.int)
+}));
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let TestSpec = {
+  name: "TestCmd",
+  commandSchema: commandSchema,
+  commandAuthorization: commandAuthorization
+};
+
+function publishCommands(_name, cmds) {
+  published.contents = published.contents.concat(cmds);
+  return Promise.resolve();
+}
+
+let TestConfig = {
+  user: "tester",
+  publishCommands: publishCommands,
+  mode: "SendAllInOneChunk"
+};
+
+let Pub = CommandPublisher$ReventlessCore.Make(TestSpec)(TestConfig);
+
+globalThis.describe("CommandPublisher", () => {
+  globalThis.test("flush sends all buffered commands in order and drains the buffer", async () => {
+    published.contents = [];
+    Pub.publish("id1", {
+      value: 1
+    });
+    Pub.publish("id2", {
+      value: 2
+    });
+    await Pub.flush();
+    let ids = published.contents.map(c => c.id);
+    globalThis.expect(ids).toEqual([
+      "id1",
+      "id2"
+    ]);
+    published.contents = [];
+    await Pub.flush();
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+  globalThis.test("clear truncates the whole buffer so nothing is later published", async () => {
+    published.contents = [];
+    Pub.publish("id3", {
+      value: 3
+    });
+    Pub.publish("id4", {
+      value: 4
+    });
+    Pub.clear();
+    await Pub.flush();
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+});
+
+export {
+  published,
+  TestSpec,
+  TestConfig,
+  Pub,
+}
+/*  Not a pure module */