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

package/tests/aggregate/AggregateCallbackTest.res.mjs

@@ -4,7 +4,10 @@ import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as AggregateFixtures$ReventlessCore from "./AggregateFixtures.res.mjs";
 
-globalThis.beforeEach(() => AggregateFixtures$ReventlessCore.mock.reset());
+globalThis.beforeEach(() => {
+  AggregateFixtures$ReventlessCore.mock.reset();
+  AggregateFixtures$ReventlessCore.TestHandler.resetCache();
+});
 
 globalThis.describe("Aggregate_Callback.handleCommands:", () => {
   globalThis.describe("single command — new aggregate", () => {

package/tests/aggregate/AggregateCausationTest.res

@@ -8,7 +8,10 @@
 open JestGlobals
 open AggregateFixtures
 
-let _ = beforeEach(() => mock.reset())
+let _ = beforeEach(() => {
+  mock.reset()
+  TestHandler.resetCache()
+})
 
 describe("Aggregate_Callback causation propagation:", () => {
   testPromise("event.meta.causationId = command.meta.msgId", async () => {

package/tests/aggregate/AggregateCausationTest.res.mjs

@@ -4,7 +4,10 @@ import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as AggregateFixtures$ReventlessCore from "./AggregateFixtures.res.mjs";
 
-globalThis.beforeEach(() => AggregateFixtures$ReventlessCore.mock.reset());
+globalThis.beforeEach(() => {
+  AggregateFixtures$ReventlessCore.mock.reset();
+  AggregateFixtures$ReventlessCore.TestHandler.resetCache();
+});
 
 globalThis.describe("Aggregate_Callback causation propagation:", () => {
   globalThis.test("event.meta.causationId = command.meta.msgId", async () => {

package/tests/aggregate/AggregateConflictTest.res

@@ -27,6 +27,10 @@ module TestBehavior = {
 
   let initialState = {name: ""}
 
+  // Hand-written behavior (no @@reventless.behavior PPX) — satisfy the
+  // Behavior.T snapshot field manually.
+  let snapshot = None
+
   let moduleUrl: string = %raw(`import.meta.url`)
 
   let evolve = (_state: state, event: AggSpec.event): state =>
@@ -41,7 +45,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 +65,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,10 +118,12 @@ 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>,
+      replayStream: (string, ~fromSeq: int=?) => Stream.t<AggSpec.event, string, unit>,
       appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<unit, string, unit>,
+      latestSnapshot: string => promise<result<option<EventLog.snapshot>, string>>,
+      writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
     let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
@@ -125,8 +131,10 @@ module TestOps = {
   let eventLog: EventLog.operations = {
     append: mock.appendFn,
     replay: mock.replayFn,
-    replayStream: mock.replayStreamFn,
+    replayStream: (id, ~fromSeq as _=?) => mock.replayStreamFn(id),
     appendStream: (_startingSeqNr, _id, stream) => stream->Stream.runDrain,
+    latestSnapshot: async _ => Ok(None),
+    writeSnapshot: async (_, _) => Ok(),
   }
 }
 
@@ -152,7 +160,10 @@ let makeTopicItem = (reference, command): CommandTopic.topicItem<
   reference,
 }
 
-let _ = beforeEach(() => mock.reset())
+let _ = beforeEach(() => {
+  mock.reset()
+  TestHandler.resetCache()
+})
 
 describe("Aggregate_Callback — conflict retry:", () => {
   testPromise("1 conflict retries and succeeds", async () => {

package/tests/aggregate/AggregateConflictTest.res.mjs

@@ -63,6 +63,7 @@ function decide(_state, command) {
 let TestBehavior = {
   Spec: undefined,
   initialState: initialState,
+  snapshot: undefined,
   moduleUrl: moduleUrl$1,
   evolve: evolve,
   decide: decide
@@ -87,7 +88,7 @@ function makeMockEL() {
       failConflictRef.contents = failConflictRef.contents - 1 | 0;
       return {
         TAG: "Error",
-        _0: "conflict"
+        _0: "Conflict"
       };
     } else {
       storedRef.contents = storedRef.contents.concat(newEvents);
@@ -145,17 +146,35 @@ let eventLog_append = mock.appendFn;
 
 let eventLog_replay = mock.replayFn;
 
-let eventLog_replayStream = mock.replayStreamFn;
+function eventLog_replayStream(id, param) {
+  return mock.replayStreamFn(id);
+}
 
 function eventLog_appendStream(_startingSeqNr, _id, stream) {
   return Stream.runDrain(stream);
 }
 
+async function eventLog_latestSnapshot(param) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function eventLog_writeSnapshot(param, param$1) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
 let eventLog = {
   append: eventLog_append,
   replay: eventLog_replay,
   replayStream: eventLog_replayStream,
-  appendStream: eventLog_appendStream
+  appendStream: eventLog_appendStream,
+  latestSnapshot: eventLog_latestSnapshot,
+  writeSnapshot: eventLog_writeSnapshot
 };
 
 let TestOps = {
@@ -182,6 +201,7 @@ let TestHandler = Aggregate_Callback$ReventlessCore.Make({
   initialState: initialState,
   evolve: evolve,
   decide: decide,
+  snapshot: undefined,
   moduleUrl: moduleUrl$1
 })({
   Spec: {
@@ -236,7 +256,10 @@ function makeTopicItem(reference, command) {
   };
 }
 
-globalThis.beforeEach(() => mock.reset());
+globalThis.beforeEach(() => {
+  mock.reset();
+  TestHandler.resetCache();
+});
 
 globalThis.describe("Aggregate_Callback — conflict retry:", () => {
   globalThis.test("1 conflict retries and succeeds", async () => {

package/tests/aggregate/AggregateFixtures.res

@@ -38,6 +38,10 @@ module TestBehavior = {
 
   let initialState = NotCreated
 
+  // Hand-written behavior (no @@reventless.behavior PPX) — satisfy the
+  // Behavior.T snapshot field manually.
+  let snapshot = None
+
   let moduleUrl: string = %raw(`import.meta.url`)
 
   let evolve = (_state: state, event: AggSpec.event): state =>
@@ -60,7 +64,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 +79,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,10 +133,12 @@ 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>,
+      replayStream: (string, ~fromSeq: int=?) => Stream.t<AggSpec.event, string, unit>,
       appendStream: (int, string, Stream.t<AggSpec.event, string, unit>) => Effect.t<unit, string, unit>,
+      latestSnapshot: string => promise<result<option<EventLog.snapshot>, string>>,
+      writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
     // Never called — satisfies module type only
@@ -141,8 +147,10 @@ module TestOps = {
   let eventLog: EventLog.operations = {
     append: mock.appendFn,
     replay: mock.replayFn,
-    replayStream: mock.replayStreamFn,
+    replayStream: (id, ~fromSeq as _=?) => mock.replayStreamFn(id),
     appendStream: (_startingSeqNr, _id, stream) => stream->Stream.runDrain,
+    latestSnapshot: async _ => Ok(None),
+    writeSnapshot: async (_, _) => Ok(),
   }
 }
 

package/tests/aggregate/AggregateFixtures.res.mjs

@@ -112,6 +112,7 @@ let TestBehavior = {
   Spec: undefined,
   stateSchema: stateSchema,
   initialState: "NotCreated",
+  snapshot: undefined,
   moduleUrl: moduleUrl$1,
   evolve: evolve,
   decide: decide
@@ -129,7 +130,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);
@@ -177,17 +181,35 @@ let eventLog_append = mock.appendFn;
 
 let eventLog_replay = mock.replayFn;
 
-let eventLog_replayStream = mock.replayStreamFn;
+function eventLog_replayStream(id, param) {
+  return mock.replayStreamFn(id);
+}
 
 function eventLog_appendStream(_startingSeqNr, _id, stream) {
   return Stream.runDrain(stream);
 }
 
+async function eventLog_latestSnapshot(param) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function eventLog_writeSnapshot(param, param$1) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
 let eventLog = {
   append: eventLog_append,
   replay: eventLog_replay,
   replayStream: eventLog_replayStream,
-  appendStream: eventLog_appendStream
+  appendStream: eventLog_appendStream,
+  latestSnapshot: eventLog_latestSnapshot,
+  writeSnapshot: eventLog_writeSnapshot
 };
 
 let TestOps = {
@@ -214,6 +236,7 @@ let TestHandler = Aggregate_Callback$ReventlessCore.Make({
   initialState: "NotCreated",
   evolve: evolve,
   decide: decide,
+  snapshot: undefined,
   moduleUrl: moduleUrl$1
 })({
   Spec: {

package/tests/aggregate/AggregateRejectionTest.res

@@ -7,7 +7,10 @@
 open JestGlobals
 open AggregateFixtures
 
-let _ = beforeEach(() => mock.reset())
+let _ = beforeEach(() => {
+  mock.reset()
+  TestHandler.resetCache()
+})
 
 // Captures whatever flows through CommandTopic_Helpers.reportRejected during a test.
 let capturedRejections: ref<array<(string, CommandTopic_Helpers.rejectedResult)>> = ref([])

package/tests/aggregate/AggregateRejectionTest.res.mjs

@@ -5,7 +5,10 @@ import * as Stream from "effect/Stream";
 import * as AggregateFixtures$ReventlessCore from "./AggregateFixtures.res.mjs";
 import * as CommandTopic_Helpers$ReventlessCore from "../../src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
 
-globalThis.beforeEach(() => AggregateFixtures$ReventlessCore.mock.reset());
+globalThis.beforeEach(() => {
+  AggregateFixtures$ReventlessCore.mock.reset();
+  AggregateFixtures$ReventlessCore.TestHandler.resetCache();
+});
 
 let capturedRejections = {
   contents: []

package/tests/eventlog/EventLogFixtures.res

@@ -17,6 +17,7 @@ module ItemEventLogSpec = {
 // ─────────────────────────────────────────────────────────────
 
 let storedEvents: ref<dict<array<JSON.t>>> = ref(Dict.make())
+let storedSnapshots: ref<dict<EventLog.snapshot>> = ref(Dict.make())
 let failNextAppend = ref(false)
 // Inject N transient failures: each call decrements the counter and returns ThrottlingException
 let failNextAppendsWithTransient: ref<int> = ref(0)
@@ -28,10 +29,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))
@@ -41,8 +42,12 @@ let mockStorage: EventLog_Adapter.operations = {
   replay: async id => {
     storedEvents.contents->Dict.get(id)->Option.getOr([])
   },
-  replayStream: id =>
-    storedEvents.contents->Dict.get(id)->Option.getOr([])->Stream.fromIterable,
+  replayStream: (id, ~fromSeq=0) =>
+    storedEvents.contents
+    ->Dict.get(id)
+    ->Option.getOr([])
+    ->Array.slice(~start=fromSeq)
+    ->Stream.fromIterable,
   appendStream: (_startingSeqNr, id, stream) =>
     stream->Stream.runForEach(json =>
       Effect.sync(() => {
@@ -50,6 +55,11 @@ let mockStorage: EventLog_Adapter.operations = {
         storedEvents.contents->Dict.set(id, existing->Array.concat([json]))
       })
     ),
+  latestSnapshot: async id => Ok(storedSnapshots.contents->Dict.get(id)),
+  writeSnapshot: async (id, snap) => {
+    storedSnapshots.contents->Dict.set(id, snap)
+    Ok()
+  },
 }
 
 // ─────────────────────────────────────────────────────────────
@@ -106,6 +116,7 @@ let makeEvent' = (id, event) => {
 
 let reset = () => {
   storedEvents := Dict.make()
+  storedSnapshots := Dict.make()
   failNextAppend := false
   failNextAppendsWithTransient := 0
   appendCallCount := 0

package/tests/eventlog/EventLogFixtures.res.mjs

@@ -29,6 +29,10 @@ let storedEvents = {
   contents: {}
 };
 
+let storedSnapshots = {
+  contents: {}
+};
+
 let failNextAppend = {
   contents: false
 };
@@ -47,14 +51,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], []);
@@ -69,8 +79,9 @@ async function mockStorage_replay(id) {
   return Stdlib_Option.getOr(storedEvents.contents[id], []);
 }
 
-function mockStorage_replayStream(id) {
-  return Stream.fromIterable(Stdlib_Option.getOr(storedEvents.contents[id], []));
+function mockStorage_replayStream(id, fromSeqOpt) {
+  let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
+  return Stream.fromIterable(Stdlib_Option.getOr(storedEvents.contents[id], []).slice(fromSeq));
 }
 
 function mockStorage_appendStream(_startingSeqNr, id, stream) {
@@ -80,11 +91,28 @@ function mockStorage_appendStream(_startingSeqNr, id, stream) {
   }));
 }
 
+async function mockStorage_latestSnapshot(id) {
+  return {
+    TAG: "Ok",
+    _0: storedSnapshots.contents[id]
+  };
+}
+
+async function mockStorage_writeSnapshot(id, snap) {
+  storedSnapshots.contents[id] = snap;
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
 let mockStorage = {
   append: mockStorage_append,
   replay: mockStorage_replay,
   replayStream: mockStorage_replayStream,
-  appendStream: mockStorage_appendStream
+  appendStream: mockStorage_appendStream,
+  latestSnapshot: mockStorage_latestSnapshot,
+  writeSnapshot: mockStorage_writeSnapshot
 };
 
 let capturedPublishes = {
@@ -143,6 +171,7 @@ function makeEvent$p(id, event) {
 
 function reset() {
   storedEvents.contents = {};
+  storedSnapshots.contents = {};
   failNextAppend.contents = false;
   failNextAppendsWithTransient.contents = 0;
   appendCallCount.contents = 0;
@@ -152,6 +181,7 @@ function reset() {
 export {
   ItemEventLogSpec,
   storedEvents,
+  storedSnapshots,
   failNextAppend,
   failNextAppendsWithTransient,
   appendCallCount,

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/logger/LoggerLazyTest.res

@@ -0,0 +1,36 @@
+// Unit tests for Logger.debugLazy (B6): the message thunk must run only when
+// debug output is actually enabled, so hot paths (per-projection-action logging)
+// don't pay to build/serialize a string that is dropped at Info level.
+
+open JestGlobals
+
+describe("Logger.debugLazy", () => {
+  testSync("does NOT invoke the thunk at the default Info level", () => {
+    let called = ref(false)
+    let log = Logger.makeLogger(~minLevel=Logger.Info)
+    log.debugLazy(~comp="Test", () => {
+      called := true
+      "should never be built"
+    })
+    expect(called.contents)->toEqual(false)
+  })
+
+  testSync("invokes the thunk when debug output is enabled", () => {
+    let called = ref(false)
+    let log = Logger.makeLogger(~minLevel=Logger.Debug)
+    log.debugLazy(~comp="Test", () => {
+      called := true
+      "built"
+    })
+    expect(called.contents)->toEqual(true)
+  })
+
+  testSync("the silent logger never invokes the thunk", () => {
+    let called = ref(false)
+    Logger.silent.debugLazy(~comp="Test", () => {
+      called := true
+      "x"
+    })
+    expect(called.contents)->toEqual(false)
+  })
+})

package/tests/logger/LoggerLazyTest.res.mjs

@@ -0,0 +1,40 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Logger$ReventlessCore from "../../src/util/Logger.res.mjs";
+
+globalThis.describe("Logger.debugLazy", () => {
+  globalThis.test("does NOT invoke the thunk at the default Info level", () => {
+    let called = {
+      contents: false
+    };
+    let log = Logger$ReventlessCore.makeLogger("Info");
+    log.debugLazy("Test", () => {
+      called.contents = true;
+      return "should never be built";
+    });
+    globalThis.expect(called.contents).toEqual(false);
+  });
+  globalThis.test("invokes the thunk when debug output is enabled", () => {
+    let called = {
+      contents: false
+    };
+    let log = Logger$ReventlessCore.makeLogger("Debug");
+    log.debugLazy("Test", () => {
+      called.contents = true;
+      return "built";
+    });
+    globalThis.expect(called.contents).toEqual(true);
+  });
+  globalThis.test("the silent logger never invokes the thunk", () => {
+    let called = {
+      contents: false
+    };
+    Logger$ReventlessCore.silent.debugLazy("Test", () => {
+      called.contents = true;
+      return "x";
+    });
+    globalThis.expect(called.contents).toEqual(false);
+  });
+});
+
+/*  Not a pure module */