@reventlessdev/reventless-core 3.0.0-alpha.299 → 3.0.0-alpha.301

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -1,6 +1,6 @@
 module type T = {
   module Spec: Reventless.StateChangeSlice.Spec
-  module Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec
+  module Decision: Reventless.StateChangeSlice.Decision with module Spec := Spec
   let handleCommands: (
     ~tagKeysByEventType: Dict.t<array<string>>=?,
     ~crossPartitionTagKeys: array<string>=?,
@@ -21,10 +21,10 @@ module type T = {
 
 module Make = (
   Spec: Reventless.StateChangeSlice.Spec,
-  Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec,
-): (T with module Spec = Spec and module Behavior := Behavior) => {
+  Decision: Reventless.StateChangeSlice.Decision with module Spec := Spec,
+): (T with module Spec = Spec and module Decision := Decision) => {
   module Spec = Spec
-  module Behavior = Behavior
+  module Decision = Decision
 
   let comp = `StateChangeSlice(${Spec.name})`
 
@@ -164,7 +164,7 @@ module Make = (
   // sees the event that recorded them.
   let projectionCache: Lru.t<
     string,
-    (Behavior.state, option<Reventless.DcbTag.sequencePosition>, array<string>),
+    (Decision.state, option<Reventless.DcbTag.sequencePosition>, array<string>),
   > = Lru.make(~capacity=projectionCacheCapacity)
 
   let resetCache = () => projectionCache->Lru.clear
@@ -174,7 +174,7 @@ module Make = (
   //      model — seeded from the projection cache when warm, so only events after
   //      the cached head are read (delta), else the full history (cold)
   //   2. Decodes raw events using consumedEventSchema
-  //   3. Calls Behavior.decide to produce new events
+  //   3. Calls Decision.decide to produce new events
   //   4. Encodes produced events to raw and appends with a condition
   //   5. On conflict, retries from step 1 (up to maxRetries)
   let handleSingleCommand = (
@@ -303,7 +303,7 @@ module Make = (
     let rec attempt = (~retries) => {
       let (baseState, afterPos, baseOwners) = switch seed.contents {
       | Some((state, head, owners)) => (state, head, owners)
-      | None => (Behavior.initialState, None, [])
+      | None => (Decision.initialState, None, [])
       }
       let cacheHit = seed.contents->Option.isSome
 
@@ -347,7 +347,7 @@ module Make = (
         (dm, _pos, reads, owners),
         (event, position, eventType, eventId, (ownerFields, data)),
       ) => (
-        Behavior.evolve(dm, event),
+        Decision.evolve(dm, event),
         Some(position),
         reads->Array.concat([
           switch eventId {
@@ -406,7 +406,7 @@ module Make = (
               isDefect ? EffectLogger.logError(~comp, line) : EffectLogger.logWarn(~comp, line)
             )->Effect.map(_ => Ok("rejected"))
           | None =>
-            switch Behavior.decide(state, command'.command) {
+            switch Decision.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.
               cachePut((state, headPosition, owners))

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

@@ -21,7 +21,7 @@ import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
 import * as CommandTopic_Helpers$ReventlessCore from "../CommandTopic/CommandTopic_Helpers.res.mjs";
 
 function Make(Spec) {
-  return Behavior => {
+  return Decision => {
     let comp = `StateChangeSlice(` + Spec.name + `)`;
     let decoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
     let queryEventTypes = decoder.eventTypes;
@@ -155,7 +155,7 @@ function Make(Spec) {
             match[1],
             match[2]
           ] : [
-            Behavior.initialState,
+            Decision.initialState,
             undefined,
             []
           ];
@@ -202,7 +202,7 @@ function Make(Spec) {
           let eventId = param$1[3];
           let eventType = param$1[2];
           return [
-            Behavior.evolve(param[0], param$1[0]),
+            Decision.evolve(param[0], param$1[0]),
             param$1[1],
             param[2].concat([eventId !== undefined ? LogFormat$ReventlessCore.bold(eventType) + `(` + eventId + `)` : LogFormat$ReventlessCore.bold(eventType)]),
             OwnerScope$Reventless.recordOwners(param[3], match[0], match[1])
@@ -237,7 +237,7 @@ function Make(Spec) {
                 _0: "rejected"
               }));
             }
-            let newEvents = Behavior.decide(state, command$p.command);
+            let newEvents = Decision.decide(state, command$p.command);
             if (newEvents.TAG === "Ok") {
               let newEvents$1 = newEvents._0;
               if (newEvents$1.length === 0) {

package/src/plugin/component/Plugin_Structure.res

@@ -74,7 +74,7 @@ type retiredCheck =
 // says whether that name is a case of the field's enum). A name the enum does not
 // declare is a failure — the predicate then matches no row and every row stays
 // visible. A `value` on a field that is not the lifecycle is only a warning: a
-// modelling judgement rather than a wrong name.
+// modeling judgement rather than a wrong name.
 let checkRetiredValue = (~entityName: string, stateSchema: S.t<unknown>): retiredCheck =>
   switch retiredFromStateSchema(stateSchema) {
   // The boolean form names no state, so there is nothing to compare. Not a skip.

package/src/plugin/lifecycle/{PluginBehavior.res → PluginDecision.res}

@@ -1,4 +1,4 @@
-@@reventless.behavior(PluginSpec)
+@@reventless.decision(PluginSpec)
 
 open Reventless.Plugin
 
@@ -30,9 +30,9 @@ 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
+// The @@reventless.decision snapshot injection is gated to Aggregate/ folders;
+// this framework-internal decision lives under plugin/lifecycle, so the
+// Decision.T field is satisfied manually. The admin Plugin aggregate's history
 // is short (lifecycle transitions), so persisted snapshots would buy nothing.
 let snapshot = None
 

package/src/plugin/lifecycle/{PluginBehavior.res.mjs → PluginDecision.res.mjs}

@@ -382,7 +382,7 @@ let snapshot;
 
 let atomicCounter;
 
-let moduleUrl = "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginBehavior.res.mjs";
+let moduleUrl = "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginDecision.res.mjs";
 
 export {
   Spec,

package/tests/aggregate/AggregateCacheTest.res

@@ -33,14 +33,14 @@ module AggSpec = {
   let moduleUrl: string = %raw(`import.meta.url`)
 }
 
-module TestBehavior = {
+module TestDecision = {
   module Spec = AggSpec
   type state = {names: array<string>}
 
   let initialState = {names: []}
 
-  // Hand-written behavior (no @@reventless.behavior PPX) — satisfy the
-  // Behavior.T snapshot field manually.
+  // Hand-written decision (no @@reventless.decision PPX) — satisfy the
+  // Decision.T snapshot field manually.
   let snapshot = None
 
   let moduleUrl: string = %raw(`import.meta.url`)
@@ -176,7 +176,7 @@ module TestOps = {
   }
 }
 
-module TestHandler = Aggregate_Callback.Make(AggSpec, TestBehavior, TestOps)
+module TestHandler = Aggregate_Callback.Make(AggSpec, TestDecision, TestOps)
 
 let makeTopicItem = (reference, command): CommandTopic.topicItem<
   Message.command'<string, AggSpec.command>,

package/tests/aggregate/AggregateCacheTest.res.mjs

@@ -98,7 +98,7 @@ function decide(state, command) {
   }
 }
 
-let TestBehavior = {
+let TestDecision = {
   Spec: undefined,
   initialState: initialState,
   snapshot: undefined,
@@ -430,7 +430,7 @@ let OuterEventLog;
 
 export {
   AggSpec,
-  TestBehavior,
+  TestDecision,
   testMeta,
   makeMockEL,
   mock,

package/tests/aggregate/AggregateCallbackTest.res

@@ -40,11 +40,11 @@ describe("Aggregate_Callback.handleCommands:", () => {
     )
   })
 
-  describe("behavior returns no events", () => {
+  describe("decision returns no events", () => {
     testPromise(
       "Rename on new aggregate returns Ok with no event stored",
       async () => {
-        // Rename on empty history: Behavior.decide(NotCreated, Rename) returns Error(NotFound)
+        // Rename on empty history: Decision.decide(NotCreated, Rename) returns Error(NotFound)
         let results = await Stream.fromIterable([
           makeTopicItem("ref-1", AggSpec.Rename({newName: "Gadget"})),
         ])

package/tests/aggregate/AggregateCallbackTest.res.mjs

@@ -50,7 +50,7 @@ globalThis.describe("Aggregate_Callback.handleCommands:", () => {
       ]);
     });
   });
-  globalThis.describe("behavior returns no events", () => {
+  globalThis.describe("decision returns no events", () => {
     globalThis.test("Rename on new aggregate returns Ok with no event stored", async () => {
       let results = await Effect.runPromise(AggregateFixtures$ReventlessCore.TestHandler.handleCommands(Stream.fromIterable([AggregateFixtures$ReventlessCore.makeTopicItem(undefined, "ref-1", {
           TAG: "Rename",

package/tests/aggregate/AggregateConflictTest.res

@@ -19,14 +19,14 @@ module AggSpec = {
   let moduleUrl: string = %raw(`import.meta.url`)
 }
 
-module TestBehavior = {
+module TestDecision = {
   module Spec = AggSpec
   type state = {name: string}
 
   let initialState = {name: ""}
 
-  // Hand-written behavior (no @@reventless.behavior PPX) — satisfy the
-  // Behavior.T snapshot field manually.
+  // Hand-written decision (no @@reventless.decision PPX) — satisfy the
+  // Decision.T snapshot field manually.
   let snapshot = None
 
   let moduleUrl: string = %raw(`import.meta.url`)
@@ -151,7 +151,7 @@ module TestOps = {
   }
 }
 
-module TestHandler = Aggregate_Callback.Make(AggSpec, TestBehavior, TestOps)
+module TestHandler = Aggregate_Callback.Make(AggSpec, TestDecision, TestOps)
 
 let testMeta: Message.meta = {
   service: "ConflictTestAggregate",

package/tests/aggregate/AggregateConflictTest.res.mjs

@@ -66,7 +66,7 @@ function decide(_state, command) {
   };
 }
 
-let TestBehavior = {
+let TestDecision = {
   Spec: undefined,
   initialState: initialState,
   snapshot: undefined,
@@ -384,7 +384,7 @@ let OuterEventLog;
 
 export {
   AggSpec,
-  TestBehavior,
+  TestDecision,
   makeMockEL,
   mock,
   OuterEventLog,

package/tests/aggregate/AggregateFixtures.res

@@ -25,10 +25,10 @@ module AggSpec = {
 }
 
 // ─────────────────────────────────────────────────────────────
-// Behavior
+// Decision
 // ─────────────────────────────────────────────────────────────
 
-module TestBehavior = {
+module TestDecision = {
   module Spec = AggSpec
 
   @schema
@@ -36,8 +36,8 @@ module TestBehavior = {
 
   let initialState = NotCreated
 
-  // Hand-written behavior (no @@reventless.behavior PPX) — satisfy the
-  // Behavior.T snapshot field manually.
+  // Hand-written decision (no @@reventless.decision PPX) — satisfy the
+  // Decision.T snapshot field manually.
   let snapshot = None
 
   let moduleUrl: string = %raw(`import.meta.url`)
@@ -167,7 +167,7 @@ module TestOps = {
 // Callback handler under test
 // ─────────────────────────────────────────────────────────────
 
-module TestHandler = Aggregate_Callback.Make(AggSpec, TestBehavior, TestOps)
+module TestHandler = Aggregate_Callback.Make(AggSpec, TestDecision, TestOps)
 
 // ─────────────────────────────────────────────────────────────
 // Test helpers

package/tests/aggregate/AggregateFixtures.res.mjs

@@ -114,7 +114,7 @@ function decide(state, command) {
   }
 }
 
-let TestBehavior = {
+let TestDecision = {
   Spec: undefined,
   stateSchema: stateSchema,
   initialState: "NotCreated",
@@ -306,7 +306,7 @@ let OuterEventLog;
 
 export {
   AggSpec,
-  TestBehavior,
+  TestDecision,
   makeMockEL,
   mock,
   OuterEventLog,

package/tests/aggregate/AggregateRejectionTest.res

@@ -1,5 +1,5 @@
 // Tests for the Aggregate decide-rejection propagation path.
-// Verifies that domain rejections from Behavior.decide:
+// Verifies that domain rejections from Decision.decide:
 //   1. Surface to producers via CommandTopic_Helpers.rejectedResultChannel (with errorCode + detail)
 //   2. Return Ok(reference) so async (SQS) consumers delete the message — domain rejections don't redeliver
 //   3. Don't cancel surviving commands inside the same batch

package/tests/aggregate/AggregateSnapshotTest.res

@@ -1,5 +1,5 @@
 // Step 5 of docs/plans/done/aggregate-snapshotting.md — the Aggregate_Callback
-// snapshot wiring: a snapshot-enabled behavior seeds cold replays from the
+// snapshot wiring: a snapshot-enabled decision seeds cold replays from the
 // latest persisted snapshot (hash-gated) and writes a fresh one every
 // `interval` events, fire-and-forget. Snapshots never affect correctness — the
 // OCC append is the only consistency primitive — so a drifted/absent snapshot
@@ -28,7 +28,7 @@ module AggSpec = {
   let moduleUrl: string = %raw(`import.meta.url`)
 }
 
-module TestBehavior = {
+module TestDecision = {
   module Spec = AggSpec
 
   @schema
@@ -205,11 +205,11 @@ module MakeOps = (
 module TestOps = MakeOps({
   let name = "SnapshotMockEventLog"
 })
-module TestHandler = Aggregate_Callback.Make(AggSpec, TestBehavior, TestOps)
+module TestHandler = Aggregate_Callback.Make(AggSpec, TestDecision, TestOps)
 
-// A second behavior with snapshots DISABLED, sharing the same mock, to prove
+// A second decision with snapshots DISABLED, sharing the same mock, to prove
 // disabled aggregates do zero snapshot traffic.
-module PlainBehavior = {
+module PlainDecision = {
   module Spec = AggSpec
 
   @schema
@@ -233,7 +233,7 @@ module PlainBehavior = {
 module PlainOps = MakeOps({
   let name = "PlainMockEventLog"
 })
-module PlainHandler = Aggregate_Callback.Make(AggSpec, PlainBehavior, PlainOps)
+module PlainHandler = Aggregate_Callback.Make(AggSpec, PlainDecision, PlainOps)
 
 let makeItem = (~id="agg-1", reference, command): CommandTopic.topicItem<
   Message.command'<string, AggSpec.command>,
@@ -318,7 +318,7 @@ describe("Aggregate_Callback — snapshots:", () => {
     | Some(snap) =>
       expect(snap.seqNr)->toBe(20)
       // 20 items folded through the seeded state — no double-count, no gap.
-      let decoded = snap.state->Reventless.Util_Sury.fromJson(TestBehavior.stateSchema)
+      let decoded = snap.state->Reventless.Util_Sury.fromJson(TestDecision.stateSchema)
       expect(decoded.items->Array.length)->toBe(20)
     | None => expect("expected snapshot at 20")->toBe("none")
     }

package/tests/aggregate/AggregateSnapshotTest.res.mjs

@@ -88,7 +88,7 @@ function decide(_state, command) {
   }
 }
 
-let TestBehavior = {
+let TestDecision = {
   Spec: undefined,
   stateSchema: stateSchema,
   initialState: initialState,
@@ -369,7 +369,7 @@ function decide$1(_state, command) {
   }
 }
 
-let PlainBehavior = {
+let PlainDecision = {
   Spec: undefined,
   stateSchema: stateSchema$1,
   initialState: initialState$1,
@@ -642,7 +642,7 @@ let OuterEventLog;
 
 export {
   AggSpec,
-  TestBehavior,
+  TestDecision,
   testMeta,
   makeMockEL,
   mock,
@@ -650,7 +650,7 @@ export {
   MakeOps,
   TestOps,
   TestHandler,
-  PlainBehavior,
+  PlainDecision,
   PlainOps,
   PlainHandler,
   makeItem,

package/tests/api/PsInternalFieldsReadModel.res

@@ -4,7 +4,7 @@
 //
 // A spec file rather than a module inside the test, and named `*ReadModel*`
 // deliberately: the annotation machinery runs under `@@reventless.spec` AND only
-// for a file the PPX recognises as a read model or state view. That is also the
+// for a file the PPX recognizes as a read model or state view. That is also the
 // honest scope for `@internal` — it describes a read model's state.
 
 @@reventless.spec("InternalFieldsReadModel")

package/tests/api/TaggedUnionSchemaTest.res

@@ -129,7 +129,7 @@ describe("GraphQL_FragmentGenerator emits a union", () => {
     expect(row->String.includes("history: [Geolocation!]!"))->toBe(true)
   })
 
-  // Unchanged behaviour, pinned: without a name there is no type to emit, and
+  // Unchanged behavior, pinned: without a name there is no type to emit, and
   // inventing one would publish a contract nothing can stamp a `__typename` for.
   testSync("an unnamed union stays a String", () => {
     let unnamed = fragmentFor(

package/tests/commandgenerator/CommandGeneratorCallbackTest.res

@@ -207,7 +207,7 @@ describe("CommandGenerator_Callback.generateCommand:", () => {
       },
     )
 
-    // The control the drop is modelled on: absent and explicitly-null must
+    // The control the drop is modeled on: absent and explicitly-null must
     // reach the domain as the same command.
     testPromise(
       "and one simply omitted produce the same command",

package/tests/commandgenerator/CommandGeneratorFixtures.res

@@ -26,10 +26,10 @@ module CmdGenAggSpec = {
 }
 
 // ─────────────────────────────────────────────────────────────
-// Behavior
+// Decision
 // ─────────────────────────────────────────────────────────────
 
-module CmdGenBehavior = {
+module CmdGenDecision = {
   module Spec = CmdGenAggSpec
   type state = unit
 

package/tests/commandgenerator/CommandGeneratorFixtures.res.mjs

@@ -80,7 +80,7 @@ function decide(_state, command) {
   }
 }
 
-let CmdGenBehavior = {
+let CmdGenDecision = {
   Spec: undefined,
   moduleUrl: moduleUrl$1,
   initialState: undefined,
@@ -212,7 +212,7 @@ function reset() {
 
 export {
   CmdGenAggSpec,
-  CmdGenBehavior,
+  CmdGenDecision,
   capturedCmds,
   MockPublishSpec,
   TestGenerator,

package/tests/commandgenerator/OwnerActingTest.res

@@ -54,7 +54,7 @@ module OrderSlice = {
     | OrderNotFound
 }
 
-module OrderBehavior = {
+module OrderDecision = {
   type state = {placed: bool, cancelled: bool}
   let initialState = {placed: false, cancelled: false}
   let moduleUrl = OrderSlice.moduleUrl
@@ -83,7 +83,7 @@ module OrderBehavior = {
     }
 }
 
-module OrderHandler = StateChangeSlice_Callback.Make(OrderSlice, OrderBehavior)
+module OrderHandler = StateChangeSlice_Callback.Make(OrderSlice, OrderDecision)
 
 let dcbMock = DcbFixtures.makeMockStorage()
 
@@ -128,7 +128,7 @@ module AccountSpec = {
   let moduleUrl: string = %raw(`import.meta.url`)
 }
 
-module AccountBehavior = {
+module AccountDecision = {
   module Spec = AccountSpec
 
   @schema
@@ -210,7 +210,7 @@ module AccountOps = {
   }
 }
 
-module AccountHandler = Aggregate_Callback.Make(AccountSpec, AccountBehavior, AccountOps)
+module AccountHandler = Aggregate_Callback.Make(AccountSpec, AccountDecision, AccountOps)
 
 // ─── Callers ────────────────────────────────────────────────────────────────
 

package/tests/commandgenerator/OwnerActingTest.res.mjs

@@ -175,7 +175,7 @@ function decide(state, command) {
   }
 }
 
-let OrderBehavior = {
+let OrderDecision = {
   initialState: initialState,
   moduleUrl: moduleUrl,
   evolve: evolve,
@@ -352,7 +352,7 @@ function decide$1(state, command) {
   }
 }
 
-let AccountBehavior = {
+let AccountDecision = {
   Spec: undefined,
   stateSchema: stateSchema,
   initialState: "NotOpen",
@@ -978,7 +978,7 @@ let OuterEventLog;
 
 export {
   OrderSlice,
-  OrderBehavior,
+  OrderDecision,
   OrderHandler,
   dcbMock,
   DcbOps,
@@ -986,7 +986,7 @@ export {
   dcbEventLog,
   orderPartition,
   AccountSpec,
-  AccountBehavior,
+  AccountDecision,
   accountEvents,
   snapshotReads,
   OuterEventLog,

package/tests/commandgenerator/OwnerStampingTest.res

@@ -224,7 +224,7 @@ describe("the schema a generator is built with must answer for its commands:", (
     let _ = await permissive(
       placeOrder(~customerId="cust-B", ~identity=cognito(~userId="cust-A", ~groups=["User"])),
     )->Effect.runPromise
-    // Not the behaviour we want anywhere — recorded so that a change making the
+    // Not the behavior we want anywhere — recorded so that a change making the
     // permissive path stamp correctly is a deliberate one, and so the contrast
     // with the case below cannot be read as incidental.
     expect(lastPublished()->fieldOf("customerId"))->toEqual(Some(str("cust-B")))

package/tests/commandtopic/CommandOutcomeHookTest.res

@@ -25,7 +25,7 @@ let dcbEventLog: DcbEventLog.operations = {
   appendStream: EventLogOps.appendStream,
 }
 
-module SliceBehavior = {
+module SliceDecision = {
   type state = DcbFixtures.TestCommandSpec.state
   let initialState = DcbFixtures.TestCommandSpec.initialState
   let evolve = DcbFixtures.TestCommandSpec.evolve
@@ -33,7 +33,7 @@ module SliceBehavior = {
   let moduleUrl = DcbFixtures.TestCommandSpec.moduleUrl
 }
 
-module SliceHandler = StateChangeSlice_Callback.Make(DcbFixtures.TestCommandSpec, SliceBehavior)
+module SliceHandler = StateChangeSlice_Callback.Make(DcbFixtures.TestCommandSpec, SliceDecision)
 
 let sliceItem = (reference, command): CommandTopic.topicItem<
   Message.command'<Reventless.Id.String.t, DcbFixtures.TestCommandSpec.command>,

package/tests/commandtopic/CommandOutcomeHookTest.res.mjs

@@ -49,7 +49,7 @@ let decide = DcbFixtures$ReventlessCore.TestCommandSpec.decide;
 
 let moduleUrl = DcbFixtures$ReventlessCore.TestCommandSpec.moduleUrl;
 
-let SliceBehavior = {
+let SliceDecision = {
   initialState: initialState,
   evolve: evolve,
   decide: decide,
@@ -67,7 +67,7 @@ let SliceHandler = StateChangeSlice_Callback$ReventlessCore.Make({
   commandTransition: DcbFixtures$ReventlessCore.TestCommandSpec.commandTransition,
   traits: DcbFixtures$ReventlessCore.TestCommandSpec.traits,
   readConsistency: DcbFixtures$ReventlessCore.TestCommandSpec.readConsistency
-})(SliceBehavior);
+})(SliceDecision);
 
 function sliceItem(reference, command) {
   return {
@@ -373,7 +373,7 @@ export {
   TestDcbOps,
   EventLogOps,
   dcbEventLog,
-  SliceBehavior,
+  SliceDecision,
   SliceHandler,
   sliceItem,
   runSlice,

package/tests/dcb/DcbStateChangeSliceTest.res

@@ -18,7 +18,7 @@ let testDcbEventLog: DcbEventLog.operations = {
   appendStream: EventLogOps.appendStream,
 }
 
-module TestCommandBehavior = {
+module TestCommandDecision = {
   type state = DcbFixtures.TestCommandSpec.state
   let initialState = DcbFixtures.TestCommandSpec.initialState
   let evolve = DcbFixtures.TestCommandSpec.evolve
@@ -27,10 +27,10 @@ module TestCommandBehavior = {
 }
 module TestHandler = StateChangeSlice_Callback.Make(
   DcbFixtures.TestCommandSpec,
-  TestCommandBehavior,
+  TestCommandDecision,
 )
 
-// Per-slice `readConsistency` overrides: same types/behavior as TestCommandSpec,
+// Per-slice `readConsistency` overrides: same types/decision as TestCommandSpec,
 // only the build-time consistency mode differs. The default (TestCommandSpec) is
 // `EscalateOnRetry`; these force strong / eventual on every attempt.
 module StrongSpec = {
@@ -41,8 +41,8 @@ module EventualSpec = {
   include DcbFixtures.TestCommandSpec
   let readConsistency = Reventless.ReadConsistency.AlwaysEventual
 }
-module StrongHandler = StateChangeSlice_Callback.Make(StrongSpec, TestCommandBehavior)
-module EventualHandler = StateChangeSlice_Callback.Make(EventualSpec, TestCommandBehavior)
+module StrongHandler = StateChangeSlice_Callback.Make(StrongSpec, TestCommandDecision)
+module EventualHandler = StateChangeSlice_Callback.Make(EventualSpec, TestCommandDecision)
 
 let makeTopicItem = (reference, command): CommandTopic.topicItem<
   Message.command'<Reventless.Id.String.t, DcbFixtures.TestCommandSpec.command>,