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

package/src/components/EventLog/EventLog_Operations.res

@@ -11,19 +11,28 @@ module type T = {
   let replay: EventLog.replay<Spec.Id.t, Spec.event>
   let replayStream: EventLog.replayStream<Spec.Id.t, Spec.event>
   let appendStream: EventLog.appendStream<Spec.Id.t, Spec.event>
+  let latestSnapshot: EventLog.latestSnapshot<Spec.Id.t>
+  let writeSnapshot: EventLog.writeSnapshot<Spec.Id.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 +121,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}`))
     }
   }
 
@@ -184,12 +189,19 @@ module Make = (Spec: ReventlessInfra.EventLog.T, Ops: Ops with module Spec = Spe
 
   // Lazy streaming replay — wraps decodeEvent in Effect.sync so thrown exceptions
   // surface through the stream's error channel rather than as unhandled exceptions.
-  let replayStream = id =>
-    Ops.storage.replayStream(id->Spec.Id.toString)
+  let replayStream = (id, ~fromSeq=?) =>
+    Ops.storage.replayStream(id->Spec.Id.toString, ~fromSeq=?fromSeq)
     ->Stream.mapEffect(json =>
       Effect.sync(() => decodeEvent(id->Spec.Id.toString, json))
     )
 
+  // Snapshot passthrough — the state stays JSON at this layer; the consumer
+  // (Aggregate_Callback) decodes it against its own state schema and hash-gates
+  // staleness, so a drifted snapshot degrades to full replay, never to an error.
+  let latestSnapshot = id => Ops.storage.latestSnapshot(id->Spec.Id.toString)
+
+  let writeSnapshot = (id, snap) => Ops.storage.writeSnapshot(id->Spec.Id.toString, snap)
+
   // Streaming append — encodes each Spec.event to the {type, data} storage format
   // and writes sequentially via the storage adapter.
   // Accepts Spec.event items (symmetric with replayStream) to enable direct

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
+          }
         };
       }
     };
@@ -169,7 +186,9 @@ function Make(Spec) {
       let id$1 = Spec.Id.toString(id);
       return eventsJson.map(json => decodeEvent(id$1, json));
     };
-    let replayStream = id => Stream.mapEffect(Ops.storage.replayStream(Spec.Id.toString(id)), json => Effect$1.sync(() => decodeEvent(Spec.Id.toString(id), json)));
+    let replayStream = (id, fromSeq) => Stream.mapEffect(Ops.storage.replayStream(Spec.Id.toString(id), fromSeq), json => Effect$1.sync(() => decodeEvent(Spec.Id.toString(id), json)));
+    let latestSnapshot = id => Ops.storage.latestSnapshot(Spec.Id.toString(id));
+    let writeSnapshot = (id, snap) => Ops.storage.writeSnapshot(Spec.Id.toString(id), snap);
     let appendStream = (startingSeqNr, id, stream) => Ops.storage.appendStream(startingSeqNr, Spec.Id.toString(id), Stream.map(stream, event => {
       let json = Message$ReventlessCore.encode(event, Spec.eventSchema);
       let match = Message$ReventlessCore.splitMessage(json);
@@ -189,7 +208,9 @@ function Make(Spec) {
       append: append,
       replay: replay,
       replayStream: replayStream,
-      appendStream: appendStream
+      appendStream: appendStream,
+      latestSnapshot: latestSnapshot,
+      writeSnapshot: writeSnapshot
     };
   };
 }

package/src/components/EventLog/EventPublish_Callback.res

@@ -4,6 +4,13 @@ type publishedEvent = {
   eventCount: int,
   eventsJson: array<JSON.t>,
   meta: Reventless.Message.meta,
+  // Per-event metas, parallel to eventsJson. Populated by publishers whose
+  // eventsJson entries do NOT carry the meta fields inline (DcbEventLog: bare
+  // {TAG, ...data} payloads) so hook consumers can still correlate per event
+  // (e.g. the local projection checkpoint resolves pending appends by msgId).
+  // Aggregate EventLog eventsJson are flat stored events with meta at the top
+  // level, so it omits this field.
+  metas?: array<Reventless.Message.meta>,
 }
 
 type beforePublishHook = publishedEvent => promise<publishedEvent>

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -199,13 +199,33 @@ module Make = (
       Some(Reventless.DcbTag.getCompositePartitionKeyValue(tags, spec))
     }
 
-    let cacheKey = query->JSON.stringifyAny->Option.getOr("")
+    // Fail closed: a query that can't be serialized yields `None`, not the empty
+    // string. The old `""` fallback made every unserializable query collide on
+    // one shared cache slot, so one slice's folded state could seed another's —
+    // a silent correctness bug. `None` simply bypasses the cache (cold read, no
+    // write) for that operation.
+    let cacheKey = query->JSON.stringifyAny
+    let cacheGet = () =>
+      switch cacheKey {
+      | Some(k) => Lru.get(projectionCache, k)
+      | None => None
+      }
+    let cachePut = v =>
+      switch cacheKey {
+      | Some(k) => Lru.put(projectionCache, k, v)
+      | None => ()
+      }
+    let cacheInvalidate = () =>
+      switch cacheKey {
+      | Some(k) => Lru.invalidate(projectionCache, k)
+      | None => ()
+      }
 
     // Working seed across retries: the `(state, head)` the read folds from.
     // Starts from the projection cache (warm) or empty (cold); the conflict
     // branch re-seeds it with the just-read `(state, head)` so each retry reads
     // only the delta the conflicting writer added rather than full history.
-    let seed = ref(Lru.get(projectionCache, cacheKey))
+    let seed = ref(cacheGet())
 
     let rec attempt = (~retries) => {
       let (baseState, afterPos) = switch seed.contents {
@@ -275,7 +295,7 @@ module Make = (
           switch Behavior.decide(state, command'.command) {
           | Ok(newEvents) if newEvents->Array.length == 0 =>
             // No append, but the read snapshot is valid — cache it for the next command.
-            Lru.put(projectionCache, cacheKey, (state, headPosition))
+            cachePut((state, headPosition))
             CommandTopic_Helpers.reportAccepted(
               cmdJson.meta.msgId,
               switch entityId {
@@ -326,7 +346,7 @@ module Make = (
                   // Cache the decided-on state at the read head (NOT including the
                   // events we just appended, and NOT the returned position): the
                   // next command's delta read picks our events up from `headPosition`.
-                  Lru.put(projectionCache, cacheKey, (state, headPosition))
+                  cachePut((state, headPosition))
                   CommandTopic_Helpers.reportAccepted(
                     cmdJson.meta.msgId,
                     switch entityId {
@@ -354,7 +374,7 @@ module Make = (
                   } else {
                     // Retries exhausted — drop any cached snapshot so the next
                     // command for this entity takes the cold full-read path.
-                    Lru.invalidate(projectionCache, cacheKey)
+                    cacheInvalidate()
                     let errorCode = err->String.startsWith("Conflict") ? "Conflict" : "AppendFailed"
                     // A surfaced Conflict means the 3-retry loop could not absorb
                     // the contention — the operator signal for "this slice is hot"
@@ -375,7 +395,7 @@ module Make = (
             )
           | Error(error) =>
             // Business-rule rejection — no append, but the read snapshot is valid; cache it.
-            Lru.put(projectionCache, cacheKey, (state, headPosition))
+            cachePut((state, headPosition))
             let errorJson = error->S.reverseConvertToJsonOrThrow(Spec.errorSchema)
             let errorCode = errorJson->Message.variantNameOfJson
             let (_, payloadDict) = errorJson->Message.splitMessage

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs

@@ -82,9 +82,24 @@ function Make(Spec) {
         let tags = DcbTag$Reventless.extractTags(Spec.commandSchema, command$p.command);
         entityId = DcbTag$Reventless.getCompositePartitionKeyValue(tags, derivedPartitionTag._0);
       }
-      let cacheKey = Stdlib_Option.getOr(JSON.stringify(query), "");
+      let cacheKey = JSON.stringify(query);
+      let cacheGet = () => {
+        if (cacheKey !== undefined) {
+          return Lru$ReventlessCore.get(projectionCache, cacheKey);
+        }
+      };
+      let cachePut = v => {
+        if (cacheKey !== undefined) {
+          return Lru$ReventlessCore.put(projectionCache, cacheKey, v);
+        }
+      };
+      let cacheInvalidate = () => {
+        if (cacheKey !== undefined) {
+          return Lru$ReventlessCore.invalidate(projectionCache, cacheKey);
+        }
+      };
       let seed = {
-        contents: Lru$ReventlessCore.get(projectionCache, cacheKey)
+        contents: cacheGet()
       };
       let attempt = retries => {
         let match = seed.contents;
@@ -150,7 +165,7 @@ function Make(Spec) {
             if (newEvents.TAG === "Ok") {
               let newEvents$1 = newEvents._0;
               if (newEvents$1.length === 0) {
-                Lru$ReventlessCore.put(projectionCache, cacheKey, [
+                cachePut([
                   state,
                   headPosition
                 ]);
@@ -204,7 +219,7 @@ function Make(Spec) {
               };
               return Effect.flatMap(Effect.flatMap(EffectLogger$ReventlessCore.logInfo(comp, eventJsons, `produced ` + eventCount + ` event(s): [` + eventDetails + `]`), () => Effect.promise(() => dcbEventLog.append(rawEvents, condition))), appendResult => {
                 if (appendResult.TAG === "Ok") {
-                  Lru$ReventlessCore.put(projectionCache, cacheKey, [
+                  cachePut([
                     state,
                     headPosition
                   ]);
@@ -228,7 +243,7 @@ function Make(Spec) {
                   Metrics$ReventlessCore.emitCount("AppendRetry", Spec.name, undefined);
                   return Effect.flatMap(EffectLogger$ReventlessCore.logWarn(comp, undefined, `append failed (retrying ` + ((3 - retries | 0) + 1 | 0).toString() + `/` + (3).toString() + `): ` + err), () => attempt(retries - 1 | 0));
                 }
-                Lru$ReventlessCore.invalidate(projectionCache, cacheKey);
+                cacheInvalidate();
                 let errorCode = err.startsWith("Conflict") ? "Conflict" : "AppendFailed";
                 if (errorCode === "Conflict") {
                   Metrics$ReventlessCore.emitCount("AppendConflict", Spec.name, undefined);
@@ -243,7 +258,7 @@ function Make(Spec) {
                 }));
               });
             }
-            Lru$ReventlessCore.put(projectionCache, cacheKey, [
+            cachePut([
               state,
               headPosition
             ]);

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/plugin/lifecycle/PluginBehavior.res

@@ -30,6 +30,12 @@ type state = {
 
 let initialState = {current: None, known: Dict.make()}
 
+// The @@reventless.behavior snapshot injection is gated to Aggregate/ folders;
+// this framework-internal behavior lives under plugin/lifecycle, so the
+// Behavior.T field is satisfied manually. The admin Plugin aggregate's history
+// is short (lifecycle transitions), so persisted snapshots would buy nothing.
+let snapshot = None
+
 let atomicCounter = None
 
 let uiRegisterEvents = (pluginId, manifest) =>

package/src/plugin/lifecycle/PluginBehavior.res.mjs

@@ -366,6 +366,8 @@ function evolve(state, event) {
 
 let Spec;
 
+let snapshot;
+
 let atomicCounter;
 
 let moduleUrl = "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginBehavior.res.mjs";
@@ -376,6 +378,7 @@ export {
   knownVersionSchema,
   stateSchema,
   initialState,
+  snapshot,
   atomicCounter,
   uiRegisterEvents,
   uiDeregisterEvents,

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/Logger.res

@@ -37,6 +37,11 @@ type t = {
   info: logFn,
   warn: logFn,
   error: logFn,
+  // Lazy debug: the message thunk runs only when debug output is actually
+  // enabled. On a hot path (e.g. per-projection-action logging) this avoids
+  // building — and serializing state into — a string that is then dropped at
+  // the default Info level.
+  debugLazy: (~comp: string=?, unit => string) => unit,
 }
 
 type level = Debug | Info | Warn | Error
@@ -172,6 +177,10 @@ let makeLogger = (~minLevel=Info): t => {
     info: (~comp=?, ~data=?, msg) => log(Info, ~comp?, ~data?, msg),
     warn: (~comp=?, ~data=?, msg) => log(Warn, ~comp?, ~data?, msg),
     error: (~comp=?, ~data=?, msg) => log(Error, ~comp?, ~data?, msg),
+    debugLazy: (~comp=?, makeMsg) =>
+      if shouldLog(Debug) {
+        emit(~level=Debug, ~comp?, makeMsg())
+      },
   }
 }
 
@@ -180,6 +189,7 @@ let silent: t = {
   info: (~comp as _=?, ~data as _=?, _) => (),
   warn: (~comp as _=?, ~data as _=?, _) => (),
   error: (~comp as _=?, ~data as _=?, _) => (),
+  debugLazy: (~comp as _=?, _) => (),
 }
 
 // Reads LOG_LEVEL from process.env and returns a configured logger.

package/src/util/Logger.res.mjs

@@ -156,7 +156,12 @@ function makeLogger(minLevelOpt) {
     debug: (comp, data, msg) => log("Debug", comp, data, msg),
     info: (comp, data, msg) => log("Info", comp, data, msg),
     warn: (comp, data, msg) => log("Warn", comp, data, msg),
-    error: (comp, data, msg) => log("Error", comp, data, msg)
+    error: (comp, data, msg) => log("Error", comp, data, msg),
+    debugLazy: (comp, makeMsg) => {
+      if (shouldLog("Debug")) {
+        return emit("Debug", comp, undefined, undefined, undefined, makeMsg());
+      }
+    }
   };
 }
 
@@ -176,11 +181,16 @@ function silent_error(param, param$1, param$2) {
   
 }
 
+function silent_debugLazy(param, param$1) {
+  
+}
+
 let silent = {
   debug: silent_debug,
   info: silent_info,
   warn: silent_warn,
-  error: silent_error
+  error: silent_error,
+  debugLazy: silent_debugLazy
 };
 
 function fromEnv() {

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 {