@reventlessdev/reventless-gwt 1.0.0-alpha.248 → 1.0.0-alpha.249

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.249 (2026-10-21)
+
+* feat!: the write-side logic module is called the decision, and a codemod moves an app over ([cb573ff](https://github.com/ReventlessDev/reventless-core/commit/cb573ff5b928c7d7f3e75988dfaa65066f8c95eb))
+
+### BREAKING CHANGES
+
+* <Spec>_Behavior.res, @@reventless.behavior,
+Reventless.Behavior.T, StateChangeSlice.Behavior, Behavior_GWT and
+thenRefused no longer exist. Run `npx reventless-rename-to-decision` at an
+app's root, then rebuild; comments are not rewritten. The PPX must be the
+matching release.
+
+
+
 # 1.0.0-alpha.248 (2026-10-19)
 
 ### Features

package/README.md

@@ -21,7 +21,7 @@ the `reventless-dev` CLI discovers and runs those tests across a workspace.
 Every component kind has a functor that produces the same
 `describe / test / given* / when* / then*` combinator surface:
 
-- **`Behavior_GWT`** — event-sourced behavior tests for aggregates and
+- **`Decision_GWT`** — event-sourced decision tests for aggregates and
   StateChangeSlices (`givenEvents → whenCmd → thenEmits`), including DCB
   append-condition assertions.
 - **`Projection_GWT`** / **`MultiSourceProjection_GWT`** — single-source

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.248",
+  "version": "1.0.0-alpha.249",
   "description": "Given-When-Then DSLs and test harness for Reventless slice testing",
   "license": "Apache-2.0",
   "jest": {
@@ -14,12 +14,12 @@
   },
   "dependencies": {
     "sury": "11.0.0",
-    "@reventlessdev/rescript-effect": "1.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.300",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.12",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.197",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.22",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.169"
+    "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.198",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.23",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.301",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.170"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/.gwtignore

@@ -1,6 +1,6 @@
 # Prunes this subtree from reventless-gwt discovery (test tree + component tree).
 #
-# These are the GWT DSL framework modules — `Automation_GWT`, `Behavior_GWT`,
+# These are the GWT DSL framework modules — `Automation_GWT`, `Decision_GWT`,
 # `Mapping_GWT`, etc. — i.e. the `*_GWT.Make` functors the test runner is built
 # from. They are named with the same `_GWT` suffix that marks user test files, so
 # discovery would otherwise list each one as a test, even though loading the

package/src/{Behavior_GWT.res → Decision_GWT.res}

@@ -1,15 +1,15 @@
 open ReventlessCore
 
-// Plan 02 Phase 6b — unified Behavior GWT DSL covering both Aggregate and
+// Plan 02 Phase 6b — unified Decision GWT DSL covering both Aggregate and
 // StateChangeSlice. Two entry points:
 //
-//   * [Make(Spec, Behavior)]              — StateChangeSlice form. [Spec] carries
-//                                            [consumedEvent]; [Behavior.evolve]
+//   * [Make(Spec, Decision)]              — StateChangeSlice form. [Spec] carries
+//                                            [consumedEvent]; [Decision.evolve]
 //                                            consumes it. DCB append-condition
 //                                            checks are wired in.
-//   * [MakeFromAggregate(Spec, Behavior)] — Aggregate adapter. [Spec] is
+//   * [MakeFromAggregate(Spec, Decision)] — Aggregate adapter. [Spec] is
 //                                            [Reventless.Aggregate.Spec],
-//                                            [Behavior] is [Reventless.Behavior.T].
+//                                            [Decision] is [Reventless.Decision.T].
 //                                            No DCB semantics; the simpler
 //                                            [AggregateT] surface is returned.
 //
@@ -19,7 +19,7 @@ open ReventlessCore
 // optimistic-concurrency assertions.
 //
 // Aggregate users *cannot* use [Make] (their Spec doesn't carry [consumedEvent])
-// and slice users *cannot* use [MakeFromAggregate] (their Spec/Behavior shape
+// and slice users *cannot* use [MakeFromAggregate] (their Spec/Decision shape
 // differs). Pick the matching entry point.
 
 // ---------------------------------------------------------------------------
@@ -204,7 +204,7 @@ module Acting = (Spec: ActingSpec) => {
       )
     )
 
-  let thenRefused = (~encEvents, ~decided: option<JSON.t>, events) =>
+  let thenForbidden = (~encEvents, ~decided: option<JSON.t>, events) =>
     switch refusal.contents {
     | Some(_) => Outcome.pass
     | None =>
@@ -224,7 +224,7 @@ module Acting = (Spec: ActingSpec) => {
 // Slice form — replaces the legacy `StateChangeSlice_GWT`.
 // ---------------------------------------------------------------------------
 
-module type BehaviorSpec = {
+module type DecisionSpec = {
   let name: string
 
   @schema
@@ -243,8 +243,8 @@ module type BehaviorSpec = {
   let authorizationOf: string => Reventless.Authorization.rule<role>
 }
 
-module type Behavior = {
-  module Spec: BehaviorSpec
+module type Decision = {
+  module Spec: DecisionSpec
 
   type state
   let initialState: state
@@ -253,7 +253,7 @@ module type Behavior = {
 }
 
 module type T = {
-  module Spec: BehaviorSpec
+  module Spec: DecisionSpec
 
   let describe: (string, unit => unit) => unit
   let todo: string => unit
@@ -275,7 +275,7 @@ module type T = {
   let thenError: (array<Spec.event>, Spec.error) => Outcome.outcome
   // Refused before `decide`: by the command's rule, or because the caller does not
   // own what it acts on.
-  let thenRefused: array<Spec.event> => Outcome.outcome
+  let thenForbidden: array<Spec.event> => Outcome.outcome
 
   // DCB optimistic-concurrency assertions.
   let thenAppendsConditionedOn: (array<Spec.event>, Reventless.DcbTag.query) => Outcome.outcome
@@ -323,7 +323,7 @@ let encodeAppendCondition = (c: Reventless.DcbTag.appendCondition): JSON.t => {
 }
 
 // ---------------------------------------------------------------------------
-// Shared assertion core for both Behavior GWT flavours.
+// Shared assertion core for both Decision GWT flavours.
 //
 // `Make` (slice/DCB) and `MakeFromAggregate` encode produced events / errors
 // identically and compare them against the expectation the same way — only the
@@ -436,7 +436,7 @@ module AssertionCore = (Spec: CoreSpec) => {
   }
 }
 
-module Make = (Spec: BehaviorSpec, Behavior: Behavior with module Spec := Spec): (
+module Make = (Spec: DecisionSpec, Decision: Decision with module Spec := Spec): (
   T with module Spec = Spec
 ) => {
   module Spec = Spec
@@ -448,7 +448,7 @@ module Make = (Spec: BehaviorSpec, Behavior: Behavior with module Spec := Spec):
       ScenarioRecorder.around(~spec=Spec.name, name, body)
     )
 
-  let currentState = consumed => consumed->Array.reduce(Behavior.initialState, Behavior.evolve)
+  let currentState = consumed => consumed->Array.reduce(Decision.initialState, Decision.evolve)
 
   module Core = AssertionCore(Spec)
   let errors = Core.errors
@@ -607,7 +607,7 @@ module Make = (Spec: BehaviorSpec, Behavior: Behavior with module Spec := Spec):
     if Guard.refuses(history, command) {
       []
     } else {
-      switch Behavior.decide(currentState(history), command) {
+      switch Decision.decide(currentState(history), command) {
       | Ok(events) => events
       | Error(error) =>
         errors := [error]
@@ -645,8 +645,8 @@ module Make = (Spec: BehaviorSpec, Behavior: Behavior with module Spec := Spec):
     | None => Guard.unexpectedRefusal()
     }
 
-  let thenRefused = events =>
-    Guard.thenRefused(
+  let thenForbidden = events =>
+    Guard.thenForbidden(
       ~encEvents=Core.encEvents,
       ~decided=errors.contents->Array.get(0)->Option.map(Core.encError),
       events,
@@ -751,7 +751,7 @@ module Make = (Spec: BehaviorSpec, Behavior: Behavior with module Spec := Spec):
 // ---------------------------------------------------------------------------
 
 // Minimal aggregate spec the DSL requires. Declared inline (rather than
-// aliasing `Reventless.Behavior.T`'s inner Spec) because that inner Spec
+// aliasing `Reventless.Decision.T`'s inner Spec) because that inner Spec
 // only carries the three @schema types — no `name` — and ReScript's
 // `with module Spec = X` can only equate the inner Spec to a concrete
 // module, not constrain it to a module type that adds `name`.
@@ -799,10 +799,10 @@ module type AggregateT = {
   let thenError: (array<Spec.event>, Spec.error) => Outcome.outcome
   // Refused before `decide`: by the command's rule, or because the caller does not
   // own what it acts on.
-  let thenRefused: array<Spec.event> => Outcome.outcome
+  let thenForbidden: array<Spec.event> => Outcome.outcome
 }
 
-module MakeFromAggregate = (Spec: AggregateSpec, Behavior: Behavior.T with module Spec = Spec): (
+module MakeFromAggregate = (Spec: AggregateSpec, Decision: Decision.T with module Spec = Spec): (
   AggregateT with module Spec = Spec
 ) => {
   module Spec = Spec
@@ -813,7 +813,7 @@ module MakeFromAggregate = (Spec: AggregateSpec, Behavior: Behavior.T with modul
       ScenarioRecorder.around(~spec=Spec.name, name, body)
     )
 
-  let currentState = events => events->Array.reduce(Behavior.initialState, Behavior.evolve)
+  let currentState = events => events->Array.reduce(Decision.initialState, Decision.evolve)
 
   module Core = AssertionCore(Spec)
   let errors = Core.errors
@@ -837,7 +837,7 @@ module MakeFromAggregate = (Spec: AggregateSpec, Behavior: Behavior.T with modul
     if Guard.refuses(history, command) {
       []
     } else {
-      switch Behavior.decide(currentState(history), command) {
+      switch Decision.decide(currentState(history), command) {
       | Ok(events) => events
       | Error(error) =>
         errors := [error]
@@ -906,8 +906,8 @@ module MakeFromAggregate = (Spec: AggregateSpec, Behavior: Behavior.T with modul
     events->unlessRefused(Core.matchesError(_, expectedEvents, expectedError))
   }
 
-  let thenRefused = events =>
-    Guard.thenRefused(
+  let thenForbidden = events =>
+    Guard.thenForbidden(
       ~encEvents=Core.encEvents,
       ~decided=errors.contents->Array.get(0)->Option.map(Core.encError),
       events,

package/src/{Behavior_GWT.res.mjs → Decision_GWT.res.mjs}

@@ -156,7 +156,7 @@ function Acting(Spec) {
     actual: encRefusal(r),
     actualEvents: []
   }));
-  let thenRefused = (encEvents, decided, events) => {
+  let thenForbidden = (encEvents, decided, events) => {
     let match = refusal.contents;
     if (match !== undefined) {
       return Outcome$ReventlessGwt.pass;
@@ -182,7 +182,7 @@ function Acting(Spec) {
     refuses: refuses,
     encRefusal: encRefusal,
     unexpectedRefusal: unexpectedRefusal,
-    thenRefused: thenRefused
+    thenForbidden: thenForbidden
   };
 }
 
@@ -317,7 +317,7 @@ function AssertionCore(Spec) {
 }
 
 function Make(Spec) {
-  return Behavior => {
+  return Decision => {
     let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, () => ScenarioRecorder$ReventlessGwt.around(Spec.name, name, body));
     let errors = {
       contents: []
@@ -527,7 +527,7 @@ function Make(Spec) {
       if (refuses(history, cmd)) {
         return [];
       }
-      let events = Behavior.decide(Stdlib_Array.reduce(history, Behavior.initialState, Behavior.evolve), cmd);
+      let events = Decision.decide(Stdlib_Array.reduce(history, Decision.initialState, Decision.evolve), cmd);
       if (events.TAG === "Ok") {
         return events._0;
       }
@@ -549,7 +549,7 @@ function Make(Spec) {
         return unexpectedRefusal();
       }
     };
-    let thenRefused = events => {
+    let thenForbidden = events => {
       let decided = Stdlib_Option.map(errors.contents[0], encError);
       let match = refusal.contents;
       if (match !== undefined) {
@@ -686,7 +686,7 @@ function Make(Spec) {
       thenEventWithError: thenEventWithError,
       thenEventsWithError: thenEventsWithError,
       thenError: thenError,
-      thenRefused: thenRefused,
+      thenForbidden: thenForbidden,
       thenAppendsConditionedOn: thenAppendsConditionedOn,
       thenAppendsConditionedOnExactly: thenAppendsConditionedOnExactly
     };
@@ -694,7 +694,7 @@ function Make(Spec) {
 }
 
 function MakeFromAggregate(Spec) {
-  return Behavior => {
+  return Decision => {
     let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, () => ScenarioRecorder$ReventlessGwt.around(Spec.name, name, body));
     let errors = {
       contents: []
@@ -837,7 +837,7 @@ function MakeFromAggregate(Spec) {
       if (refuses(history, cmd)) {
         return [];
       }
-      let events = Behavior.decide(Stdlib_Array.reduce(history, Behavior.initialState, Behavior.evolve), cmd);
+      let events = Decision.decide(Stdlib_Array.reduce(history, Decision.initialState, Decision.evolve), cmd);
       if (events.TAG === "Ok") {
         return events._0;
       }
@@ -911,7 +911,7 @@ function MakeFromAggregate(Spec) {
       expects(expectedEvents, Primitive_option.some(expectedError));
       return unlessRefused(events, __x => matchesError(__x, expectedEvents, expectedError));
     };
-    let thenRefused = events => {
+    let thenForbidden = events => {
       let decided = Stdlib_Option.map(errors.contents[0], encError);
       let match = refusal.contents;
       if (match !== undefined) {
@@ -944,7 +944,7 @@ function MakeFromAggregate(Spec) {
       thenCompareEvents: thenCompareEvents,
       thenEventsWithError: thenEventsWithError,
       thenError: thenError,
-      thenRefused: thenRefused
+      thenForbidden: thenForbidden
     };
   };
 }

package/src/Delegate_GWT.res

@@ -3,7 +3,7 @@ open ReventlessCore
 // Delegate_GWT — GWT for ExtensionPoint mappings and Extension delegates.
 //
 // Both are pure input → published-actions translations and form the one
-// cross-plugin behavioural seam (per `.claude/rules/app-developer.md`). Each
+// cross-plugin behavioral seam (per `.claude/rules/app-developer.md`). Each
 // mapping has TWO directions, and each adapter drives both:
 //
 //   * an ExtensionPoint mapping turns an internal `Delegate` event into public

package/src/EventMapping_GWT.res

@@ -2,20 +2,20 @@ open ReventlessCore
 
 // Stage 5 — `EventMapping_GWT` is now a thin alias over `Mapping_GWT`
 // specialised for the Aggregate → Aggregate case. New tests should use
-// `Mapping_GWT.Make` directly with `Mapping_GWT.FromBehavior` adapters; this
+// `Mapping_GWT.Make` directly with `Mapping_GWT.FromDecision` adapters; this
 // wrapper is retained for migration backward-compat with consumers that were
-// already calling `EventMapping_GWT.Make(Source, SourceBehavior, Target,
-// TargetBehavior, EventMapping)` before Stage 5 landed.
+// already calling `EventMapping_GWT.Make(Source, SourceDecision, Target,
+// TargetDecision, EventMapping)` before Stage 5 landed.
 
 module Make = (
   Source: Reventless.Aggregate.Spec,
-  SourceBehavior: Behavior.T with module Spec = Source,
+  SourceDecision: Decision.T with module Spec = Source,
   Target: Reventless.Aggregate.Spec,
-  TargetBehavior: Behavior.T with module Spec = Target,
+  TargetDecision: Decision.T with module Spec = Target,
   EventMapping: Reventless.EventMapping.T with module Source = Source and module Target = Target,
 ) => {
-  module AdaptedSource = Mapping_GWT.FromBehavior(Source, SourceBehavior)
-  module AdaptedTarget = Mapping_GWT.FromBehavior(Target, TargetBehavior)
+  module AdaptedSource = Mapping_GWT.FromDecision(Source, SourceDecision)
+  module AdaptedTarget = Mapping_GWT.FromDecision(Target, TargetDecision)
 
   module BoundMapping = {
     module Source = AdaptedSource

package/src/EventMapping_GWT.res.mjs

@@ -3,9 +3,9 @@
 import * as Mapping_GWT$ReventlessGwt from "./Mapping_GWT.res.mjs";
 
 function Make(Source) {
-  return SourceBehavior => (Target => (TargetBehavior => (EventMapping => {
-    let AdaptedSource = Mapping_GWT$ReventlessGwt.FromBehavior(Source)(SourceBehavior);
-    let AdaptedTarget = Mapping_GWT$ReventlessGwt.FromBehavior(Target)(TargetBehavior);
+  return SourceDecision => (Target => (TargetDecision => (EventMapping => {
+    let AdaptedSource = Mapping_GWT$ReventlessGwt.FromDecision(Source)(SourceDecision);
+    let AdaptedTarget = Mapping_GWT$ReventlessGwt.FromDecision(Target)(TargetDecision);
     let map = EventMapping.map;
     let BoundMapping = {
       Source: undefined,

package/src/Flow_GWT.res

@@ -13,15 +13,15 @@ open ReventlessCore
 // each step folds the slice's own `decide`/`evolve`/`collect`/`project` over
 // the shared log. The log is JSON-erased (each step (de)serialises through its
 // own spec's schema, exactly as the runtime routes a DCB event log), and each
-// command step honours DCB tag filtering so downstream deciders never see
+// command step honors DCB tag filtering so downstream deciders never see
 // phantom cross-entity events.
 //
 // The chain is built from per-step functors (one per slice), threaded with
 // pipe-first so it reads top-to-bottom:
 //
-//   module Place = Flow_GWT.CommandStep(PlaceOrder, PlaceOrder_Behavior)
+//   module Place = Flow_GWT.CommandStep(PlaceOrder, PlaceOrder_Decision)
 //   module Auto  = Flow_GWT.AutomationSlice(AutoShipOrder, AutoShipOrder_Automation)
-//   module Ship  = Flow_GWT.CommandStep(ShipOrder, ShipOrder_Behavior)
+//   module Ship  = Flow_GWT.CommandStep(ShipOrder, ShipOrder_Decision)
 //   module View  = Flow_GWT.ViewStep(Orders, Orders_Projection)
 //
 //   start
@@ -279,8 +279,8 @@ let thenBoundaryScopeResolves = async (
 // -- CommandStep: a StateChangeSlice / Aggregate decider ---------------------
 
 module CommandStep = (
-  Spec: Behavior_GWT.BehaviorSpec,
-  Behavior: Behavior_GWT.Behavior with module Spec := Spec,
+  Spec: Decision_GWT.DecisionSpec,
+  Decision: Decision_GWT.Decision with module Spec := Spec,
 ) => {
   let consumedDecoder = Reventless.DcbDecode.makeDecoder(Spec.consumedEventSchema)
   let consumedEventTypes = consumedDecoder.eventTypes
@@ -335,8 +335,8 @@ module CommandStep = (
       ~payloadTagKeys,
     )
     let history = decodeMatching(s.log, consumedDecoder, query)
-    let state = history->Array.reduce(Behavior.initialState, Behavior.evolve)
-    switch Behavior.decide(state, command) {
+    let state = history->Array.reduce(Decision.initialState, Decision.evolve)
+    switch Decision.decide(state, command) {
     | Ok(events) => {
         ...s,
         log: s.log->appendEvents(events, Spec.eventSchema),
@@ -390,8 +390,8 @@ module CommandStep = (
 
 // -- AggregateCommandStep: an Aggregate decider partitioned by aggregate-ID --
 //
-// Mirror of `CommandStep` for `Reventless.Behavior.T` (the aggregate-flavor
-// behavior). Differences from the slice form:
+// Mirror of `CommandStep` for `Reventless.Decision.T` (the aggregate-flavor
+// decision). Differences from the slice form:
 //   * No `consumedEvent` distinction — aggregates fold their own `event`
 //     stream; the decoder uses `Spec.eventSchema`.
 //   * No DCB tag inference — `~id` partitions the history. `givenEvents` and
@@ -404,8 +404,8 @@ module CommandStep = (
 // histories isolated (a `Place` on `o2` does not see the events of `o1`).
 
 module AggregateCommandStep = (
-  Spec: Behavior_GWT.AggregateSpec,
-  Behavior: Reventless.Behavior.T with module Spec = Spec,
+  Spec: Decision_GWT.AggregateSpec,
+  Decision: Reventless.Decision.T with module Spec = Spec,
 ) => {
   let aggregateDecoder = Reventless.DcbDecode.makeDecoder(Spec.eventSchema)
 
@@ -422,8 +422,8 @@ module AggregateCommandStep = (
   let whenCommand = async (flowP: flow, ~id: string, command: Spec.command) => {
     let s = await flowP
     let history = decodeAggregateMatching(s.log, ~id, aggregateDecoder)
-    let state = history->Array.reduce(Behavior.initialState, Behavior.evolve)
-    switch Behavior.decide(state, command) {
+    let state = history->Array.reduce(Decision.initialState, Decision.evolve)
+    switch Decision.decide(state, command) {
     | Ok(events) => {
         ...s,
         log: s.log->appendAggregateEvents(~id, events, Spec.eventSchema),
@@ -717,7 +717,7 @@ module ExtensionPointStep = (M: EPMapping.Mapping) => {
   // Aggregate-style EP mappings address the source aggregate's identity via
   // the first arg (e.g. catalog Product → ProductBecameAvailable uses it as
   // `productId`). DCB upstreams don't set `lastAggregateId` and fall back to
-  // the synthetic `gwt-id` so existing DCB Flow tests keep their behaviour.
+  // the synthetic `gwt-id` so existing DCB Flow tests keep their behavior.
   let runMapping = async (sourceId: string, events: array<M.Delegate.event>): array<
     M.ExtensionPoint.event,
   > =>

package/src/Flow_GWT.res.mjs

@@ -171,7 +171,7 @@ async function thenBoundaryScopeResolves(flowP, name, slices) {
 }
 
 function CommandStep(Spec) {
-  return Behavior => {
+  return Decision => {
     let consumedDecoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
     let consumedEventTypes = consumedDecoder.eventTypes;
     let givenEvents = async (flowP, events) => {
@@ -207,8 +207,8 @@ function CommandStep(Spec) {
       let s = await flowP;
       let query = DcbTag$Reventless.buildQueryFromCommand(consumedEventTypes, Spec.commandSchema, command, tagKeysByEventType, crossPartitionTagKeys, payloadTagKeys);
       let history = decodeMatching(s.log, consumedDecoder, query);
-      let state = Stdlib_Array.reduce(history, Behavior.initialState, Behavior.evolve);
-      let events = Behavior.decide(state, command);
+      let state = Stdlib_Array.reduce(history, Decision.initialState, Decision.evolve);
+      let events = Decision.decide(state, command);
       if (events.TAG !== "Ok") {
         return {
           log: s.log,
@@ -288,7 +288,7 @@ function CommandStep(Spec) {
 }
 
 function AggregateCommandStep(Spec) {
-  return Behavior => {
+  return Decision => {
     let aggregateDecoder = DcbDecode$Reventless.makeDecoder(Spec.eventSchema);
     let givenEvents = async (flowP, id, events) => {
       let s = await flowP;
@@ -306,8 +306,8 @@ function AggregateCommandStep(Spec) {
     let whenCommand = async (flowP, id, command) => {
       let s = await flowP;
       let history = decodeAggregateMatching(s.log, id, aggregateDecoder);
-      let state = Stdlib_Array.reduce(history, Behavior.initialState, Behavior.evolve);
-      let events = Behavior.decide(state, command);
+      let state = Stdlib_Array.reduce(history, Decision.initialState, Decision.evolve);
+      let events = Decision.decide(state, command);
       if (events.TAG !== "Ok") {
         return {
           log: s.log,

package/src/Hint.res

@@ -5,7 +5,7 @@
 // See `docs/analysis/given-when-then-specifications.md` §3.2 (locus table)
 // and §3.3 (JSON `hint` field).
 //
-// `locus` is a dotted pointer like "CategoryBehavior.decide" filled in by
+// `locus` is a dotted pointer like "CategoryDecision.decide" filled in by
 // the DSL at `then*` call time when the slice module name is in scope, else a
 // generic pointer. A `StateMismatch` names its fold, so a view's points at
 // `project` rather than `evolve`.

package/src/Mapping_GWT.res

@@ -3,7 +3,7 @@ open ReventlessCore
 // Stage 5 — cross-pattern mapping GWT.
 //
 // Generalises `EventMapping_GWT` so both the source and target of a mapping
-// can be an Aggregate (Behavior) or a StateChangeSlice. Covers all four
+// can be an Aggregate (Decision) or a StateChangeSlice. Covers all four
 // producer/consumer combinations: Aggr→Aggr, Aggr→DCB, DCB→Aggr, DCB→DCB.
 // See `docs/plans/done/reventless-gwt.md` Stage 5 for the migration plan.
 //
@@ -54,20 +54,20 @@ module type Mapping = {
 
 // -- Adapter functors --------------------------------------------------------
 
-// Adapter: any `Aggregate.Spec` + matching `Behavior.T` becomes a `GwtSource`.
+// Adapter: any `Aggregate.Spec` + matching `Decision.T` becomes a `GwtSource`.
 // Aggregates evolve their own events, so `consumedEvent = event`.
-module FromBehavior = (
+module FromDecision = (
   Spec: Reventless.Aggregate.Spec,
-  Behavior: Behavior.T with module Spec = Spec,
+  Decision: Decision.T with module Spec = Spec,
 ) => {
   let name = Spec.name
   module Id = Spec.Id
-  type state = Behavior.state
-  let initialState = Behavior.initialState
+  type state = Decision.state
+  let initialState = Decision.initialState
 
   type consumedEvent = Spec.event
   let consumedEventSchema = Spec.eventSchema
-  let evolve = Behavior.evolve
+  let evolve = Decision.evolve
 
   type command = Spec.command
   let commandSchema = Spec.commandSchema
@@ -78,7 +78,7 @@ module FromBehavior = (
   type error = Spec.error
   let errorSchema = Spec.errorSchema
 
-  let decide = Behavior.decide
+  let decide = Decision.decide
 }
 
 // Adapter: a StateChangeSlice spec becomes a `GwtSource`/`GwtTarget`. DCB

package/src/Mapping_GWT.res.mjs

@@ -9,17 +9,17 @@ import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
 import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
 
-function FromBehavior(Spec) {
-  return Behavior => ({
+function FromDecision(Spec) {
+  return Decision => ({
     name: Spec.name,
     Id: Spec.Id,
-    initialState: Behavior.initialState,
+    initialState: Decision.initialState,
     consumedEventSchema: Spec.eventSchema,
-    evolve: Behavior.evolve,
+    evolve: Decision.evolve,
     commandSchema: Spec.commandSchema,
     eventSchema: Spec.eventSchema,
     errorSchema: Spec.errorSchema,
-    decide: Behavior.decide
+    decide: Decision.decide
   });
 }
 
@@ -313,7 +313,7 @@ function Make(M) {
 }
 
 export {
-  FromBehavior,
+  FromDecision,
   FromStateChangeSlice,
   Make,
 }

package/src/Outcome.res

@@ -8,7 +8,7 @@
 // shape and §3.3 for the JSON rendering. Stage 7 adds sury-aware rendering and
 // structural `fieldDiff`. Stage 4 added `AppendConditionMismatch`.
 
-// The function whose fold produced a state: a behavior's `evolve`, or a view's
+// The function whose fold produced a state: a decision's `evolve`, or a view's
 // `project`. Absent means `Evolve`, so a harness that does not say keeps its hint.
 type fold = Evolve | Project
 

package/src/Query_GWT.res

@@ -12,7 +12,7 @@
 // `subIdConfig`), so both kinds of consumers use the same combinator set.
 // Adapter functors `FromReadModel` and `FromStateViewSlice` lift their
 // respective specs into the shared shape — mirroring how `Mapping_GWT` lifts
-// `Aggregate.Spec`/`StateChangeSlice.Spec` via `FromBehavior`/`FromStateChangeSlice`.
+// `Aggregate.Spec`/`StateChangeSlice.Spec` via `FromDecision`/`FromStateChangeSlice`.
 
 // -- Unified spec shape ------------------------------------------------------
 

package/src/RunnerHook.res

@@ -30,7 +30,7 @@ type sink = {
   ) => unit,
 }
 
-// The currently-registered sink, if any. `None` → plain Jest behaviour.
+// The currently-registered sink, if any. `None` → plain Jest behavior.
 let current: ref<option<sink>> = ref(None)
 
 let register = (s: sink) => current := Some(s)

package/src/ScenarioRecorder.res

@@ -1,4 +1,4 @@
-// Behaviour scenarios as they run, written as sidecars `check-lifecycle` reads.
+// Decision scenarios as they run, written as sidecars `check-lifecycle` reads.
 //
 // The PPX writes a `.gwt.json` sidecar from a `_GWT.res` file's source, so it can only name what
 // the source spells out: a literal constructor in a step. A suite written against a binding (a
@@ -103,7 +103,7 @@ let write = (~path: string, ~file: string, ~spec: string, scenarios: array<scena
       // What `check-lifecycle` takes the file's component from.
       ("stem", JSON.String(spec)),
       ("file", JSON.String(file)),
-      ("componentKind", JSON.String("Behavior")),
+      ("componentKind", JSON.String("Decision")),
       ("recorded", JSON.Boolean(true)),
       (
         "scenarios",

package/src/ScenarioRecorder.res.mjs

@@ -133,7 +133,7 @@ function write(path, file, spec, scenarios) {
     ],
     [
       "componentKind",
-      "Behavior"
+      "Decision"
     ],
     [
       "recorded",