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

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 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
+
+* **gwt:** record behaviour scenarios as they run, for suites whose source names none ([256b253](https://github.com/ReventlessDev/reventless-core/commit/256b253153ec043105c38ac742a1a3efbde48c87))
+
+
 # 1.0.0-alpha.247 (2026-10-17)
 
 **Note:** Version bump only for package @reventlessdev/reventless-gwt

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.247",
+  "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/rescript-node": "2.0.0-alpha.22",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.299",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.196",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.12",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.168"
+    "@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,16 +436,19 @@ 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
 
   let describe = JestBind.describe
   let todo = JestBind.todo
-  let test = (name, body) => JestBind.test(~slice=Spec.name, name, body)
+  let test = (name, body) =>
+    JestBind.test(~slice=Spec.name, name, () =>
+      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
@@ -604,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]
@@ -614,7 +617,27 @@ module Make = (Spec: BehaviorSpec, Behavior: Behavior with module Spec := Spec):
   }
 
   let givenEvents = consumed => consumed
-  let whenCmd = (history, cmd) => history->exec(cmd)
+  let whenCmd = (history, cmd) => {
+    if ScenarioRecorder.recording() {
+      ScenarioRecorder.given(
+        history->Array.map(e =>
+          e->Message.encode(Spec.consumedEventSchema)->Message.variantNameOfJson
+        ),
+      )
+      ScenarioRecorder.whenCommand(Guard.commandName(cmd))
+    }
+    history->exec(cmd)
+  }
+  // What a test expects, named for the recorded sidecar.
+  let expects = (~events=[], ~error=?) =>
+    if ScenarioRecorder.recording() {
+      ScenarioRecorder.thenEvents(
+        events->Array.map(e => e->Core.encEvent->Message.variantNameOfJson),
+      )
+      error->Option.forEach(err =>
+        ScenarioRecorder.thenError(err->Core.encError->Message.variantNameOfJson)
+      )
+    }
 
   let checkAppendCondition = (): option<Outcome.outcome> =>
     switch appendConditionFailure.contents {
@@ -622,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,
@@ -631,37 +654,49 @@ module Make = (Spec: BehaviorSpec, Behavior: Behavior with module Spec := Spec):
 
   // The append-condition footgun is surfaced before the shared comparison core
   // runs; `thenAppends*` below bypass it deliberately.
-  let thenEvents = (events, expectedEvents) =>
+  let thenEvents = (events, expectedEvents) => {
+    expects(~events=expectedEvents)
     switch checkAppendCondition() {
     | Some(o) => o
     | None => Core.compareEvents(events, expectedEvents)
     }
+  }
 
   let thenEvent = (events, expectedEvent) => thenEvents(events, [expectedEvent])
 
-  let thenNoEvent = events =>
+  let thenNoEvent = events => {
+    if ScenarioRecorder.recording() {
+      ScenarioRecorder.thenNoEvent()
+    }
     switch checkAppendCondition() {
     | Some(o) => o
     | None => Core.compareNoEvent(events)
     }
+  }
 
-  let thenError = (events, expectedError) =>
+  let thenError = (events, expectedError) => {
+    expects(~error=expectedError)
     switch checkAppendCondition() {
     | Some(o) => o
     | None => Core.matchesError(events, [], expectedError)
     }
+  }
 
-  let thenEventWithError = (events, expectedEvent, expectedError) =>
+  let thenEventWithError = (events, expectedEvent, expectedError) => {
+    expects(~events=[expectedEvent], ~error=expectedError)
     switch checkAppendCondition() {
     | Some(o) => o
     | None => Core.matchesError(events, [expectedEvent], expectedError)
     }
+  }
 
-  let thenEventsWithError = (events, expectedEvents, expectedError) =>
+  let thenEventsWithError = (events, expectedEvents, expectedError) => {
+    expects(~events=expectedEvents, ~error=expectedError)
     switch checkAppendCondition() {
     | Some(o) => o
     | None => Core.matchesError(events, expectedEvents, expectedError)
     }
+  }
 
   let thenAppendsConditionedOn = (_events, expectedQuery: Reventless.DcbTag.query) =>
     switch derivedCondition.contents {
@@ -716,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`.
@@ -764,18 +799,21 @@ 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
 
   let describe = JestBind.describe
-  let test = (name, body) => JestBind.test(~slice=Spec.name, name, body)
+  let test = (name, body) =>
+    JestBind.test(~slice=Spec.name, name, () =>
+      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
@@ -799,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]
@@ -809,7 +847,23 @@ module MakeFromAggregate = (Spec: AggregateSpec, Behavior: Behavior.T with modul
   }
 
   let givenEvents = events => events
-  let whenCmd = (history, cmd) => history->exec(cmd)
+  let whenCmd = (history, cmd) => {
+    if ScenarioRecorder.recording() {
+      ScenarioRecorder.given(history->Array.map(e => e->Core.encEvent->Message.variantNameOfJson))
+      ScenarioRecorder.whenCommand(Guard.commandName(cmd))
+    }
+    history->exec(cmd)
+  }
+  // What a test expects, named for the recorded sidecar.
+  let expects = (~events=[], ~error=?) =>
+    if ScenarioRecorder.recording() {
+      ScenarioRecorder.thenEvents(
+        events->Array.map(e => e->Core.encEvent->Message.variantNameOfJson),
+      )
+      error->Option.forEach(err =>
+        ScenarioRecorder.thenError(err->Core.encError->Message.variantNameOfJson)
+      )
+    }
 
   // The aggregate flavour has no append-condition footgun, so the shared core's
   // comparisons are exposed directly once a refusal has been ruled out; only
@@ -819,25 +873,41 @@ module MakeFromAggregate = (Spec: AggregateSpec, Behavior: Behavior.T with modul
     | Some(o) => o
     | None => compare(events)
     }
-  let thenEvents = (events, expected) => events->unlessRefused(Core.compareEvents(_, expected))
-  let thenCompareEvents = (events, expected, cmp) =>
+  let thenEvents = (events, expected) => {
+    expects(~events=expected)
+    events->unlessRefused(Core.compareEvents(_, expected))
+  }
+  let thenCompareEvents = (events, expected, cmp) => {
+    expects(~events=expected)
     events->unlessRefused(Core.compareEventsWith(_, expected, cmp))
+  }
   let thenEvent = (events, expectedEvent) => thenEvents(events, [expectedEvent])
   let thenCompareEvent = (events, expectedEvent, cmp) =>
     thenCompareEvents(events, [expectedEvent], cmp)
-  let thenNoEvent = events => events->unlessRefused(Core.compareNoEvent)
+  let thenNoEvent = events => {
+    if ScenarioRecorder.recording() {
+      ScenarioRecorder.thenNoEvent()
+    }
+    events->unlessRefused(Core.compareNoEvent)
+  }
 
-  let thenError = (events, expectedError) =>
+  let thenError = (events, expectedError) => {
+    expects(~error=expectedError)
     events->unlessRefused(Core.matchesError(_, [], expectedError))
+  }
 
-  let thenEventWithError = (events, expectedEvent, expectedError) =>
+  let thenEventWithError = (events, expectedEvent, expectedError) => {
+    expects(~events=[expectedEvent], ~error=expectedError)
     events->unlessRefused(Core.matchesError(_, [expectedEvent], expectedError))
+  }
 
-  let thenEventsWithError = (events, expectedEvents, expectedError) =>
+  let thenEventsWithError = (events, expectedEvents, expectedError) => {
+    expects(~events=expectedEvents, ~error=expectedError)
     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}

@@ -15,6 +15,7 @@ import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
 import * as Authorization$Reventless from "@reventlessdev/reventless-spec/src/types/Authorization.res.mjs";
 import * as DcbScopeInference$Reventless from "@reventlessdev/reventless-spec/src/components/DcbScopeInference.res.mjs";
+import * as ScenarioRecorder$ReventlessGwt from "./ScenarioRecorder.res.mjs";
 import * as CommandTopic_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
 
 function roleNames(roles) {
@@ -155,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;
@@ -181,7 +182,7 @@ function Acting(Spec) {
     refuses: refuses,
     encRefusal: encRefusal,
     unexpectedRefusal: unexpectedRefusal,
-    thenRefused: thenRefused
+    thenForbidden: thenForbidden
   };
 }
 
@@ -316,8 +317,8 @@ function AssertionCore(Spec) {
 }
 
 function Make(Spec) {
-  return Behavior => {
-    let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+  return Decision => {
+    let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, () => ScenarioRecorder$ReventlessGwt.around(Spec.name, name, body));
     let errors = {
       contents: []
     };
@@ -494,6 +495,10 @@ function Make(Spec) {
     let queryTagsTotal = q => Stdlib_Array.reduce(q, 0, (acc, qi) => acc + Stdlib_Option.mapOr(qi.tags, 0, t => t.length) | 0);
     let givenEvents = consumed => consumed;
     let whenCmd = (history, cmd) => {
+      if (ScenarioRecorder$ReventlessGwt.recording()) {
+        ScenarioRecorder$ReventlessGwt.given(history.map(e => Message$ReventlessCore.variantNameOfJson(Message$ReventlessCore.encode(e, Spec.consumedEventSchema))));
+        ScenarioRecorder$ReventlessGwt.whenCommand(Message$ReventlessCore.variantNameOfJson(Message$ReventlessCore.encode(cmd, commandSchema)));
+      }
       errors.contents = [];
       appendConditionFailure.contents = undefined;
       let query = DcbTag$Reventless.buildQueryFromCommand(consumedEventTypes, Spec.commandSchema, cmd, tagKeysByEventType, crossPartitionTagKeys, payloadTagKeys);
@@ -522,13 +527,20 @@ 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;
       }
       errors.contents = [events._0];
       return [];
     };
+    let expects = (eventsOpt, error) => {
+      let events = eventsOpt !== undefined ? eventsOpt : [];
+      if (ScenarioRecorder$ReventlessGwt.recording()) {
+        ScenarioRecorder$ReventlessGwt.thenEvents(events.map(e => Message$ReventlessCore.variantNameOfJson(Message$ReventlessCore.encode(e, Spec.eventSchema))));
+        return Stdlib_Option.forEach(error, err => ScenarioRecorder$ReventlessGwt.thenError(Message$ReventlessCore.variantNameOfJson(Message$ReventlessCore.encode(err, Spec.errorSchema))));
+      }
+    };
     let checkAppendCondition = () => {
       let m = appendConditionFailure.contents;
       if (m !== undefined) {
@@ -537,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) {
@@ -555,6 +567,7 @@ function Make(Spec) {
       }
     };
     let thenEvents = (events, expectedEvents) => {
+      expects(expectedEvents, undefined);
       let o = checkAppendCondition();
       if (o !== undefined) {
         return o;
@@ -572,6 +585,9 @@ function Make(Spec) {
     };
     let thenEvent = (events, expectedEvent) => thenEvents(events, [expectedEvent]);
     let thenNoEvent = events => {
+      if (ScenarioRecorder$ReventlessGwt.recording()) {
+        ScenarioRecorder$ReventlessGwt.thenNoEvent();
+      }
       let o = checkAppendCondition();
       if (o !== undefined) {
         return o;
@@ -587,6 +603,7 @@ function Make(Spec) {
       }
     };
     let thenError = (events, expectedError) => {
+      expects(undefined, Primitive_option.some(expectedError));
       let o = checkAppendCondition();
       if (o !== undefined) {
         return o;
@@ -595,6 +612,7 @@ function Make(Spec) {
       }
     };
     let thenEventWithError = (events, expectedEvent, expectedError) => {
+      expects([expectedEvent], Primitive_option.some(expectedError));
       let o = checkAppendCondition();
       if (o !== undefined) {
         return o;
@@ -603,6 +621,7 @@ function Make(Spec) {
       }
     };
     let thenEventsWithError = (events, expectedEvents, expectedError) => {
+      expects(expectedEvents, Primitive_option.some(expectedError));
       let o = checkAppendCondition();
       if (o !== undefined) {
         return o;
@@ -667,7 +686,7 @@ function Make(Spec) {
       thenEventWithError: thenEventWithError,
       thenEventsWithError: thenEventsWithError,
       thenError: thenError,
-      thenRefused: thenRefused,
+      thenForbidden: thenForbidden,
       thenAppendsConditionedOn: thenAppendsConditionedOn,
       thenAppendsConditionedOnExactly: thenAppendsConditionedOnExactly
     };
@@ -675,8 +694,8 @@ function Make(Spec) {
 }
 
 function MakeFromAggregate(Spec) {
-  return Behavior => {
-    let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+  return Decision => {
+    let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, () => ScenarioRecorder$ReventlessGwt.around(Spec.name, name, body));
     let errors = {
       contents: []
     };
@@ -810,17 +829,28 @@ function MakeFromAggregate(Spec) {
     }));
     let givenEvents = events => events;
     let whenCmd = (history, cmd) => {
+      if (ScenarioRecorder$ReventlessGwt.recording()) {
+        ScenarioRecorder$ReventlessGwt.given(history.map(e => Message$ReventlessCore.variantNameOfJson(Message$ReventlessCore.encode(e, Spec.eventSchema))));
+        ScenarioRecorder$ReventlessGwt.whenCommand(Message$ReventlessCore.variantNameOfJson(Message$ReventlessCore.encode(cmd, commandSchema)));
+      }
       errors.contents = [];
       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;
       }
       errors.contents = [events._0];
       return [];
     };
+    let expects = (eventsOpt, error) => {
+      let events = eventsOpt !== undefined ? eventsOpt : [];
+      if (ScenarioRecorder$ReventlessGwt.recording()) {
+        ScenarioRecorder$ReventlessGwt.thenEvents(events.map(e => Message$ReventlessCore.variantNameOfJson(Message$ReventlessCore.encode(e, Spec.eventSchema))));
+        return Stdlib_Option.forEach(error, err => ScenarioRecorder$ReventlessGwt.thenError(Message$ReventlessCore.variantNameOfJson(Message$ReventlessCore.encode(err, Spec.errorSchema))));
+      }
+    };
     let unlessRefused = (events, compare) => {
       let o = unexpectedRefusal();
       if (o !== undefined) {
@@ -829,39 +859,59 @@ function MakeFromAggregate(Spec) {
         return compare(events);
       }
     };
-    let thenEvents = (events, expected) => unlessRefused(events, __x => {
-      if (errors.contents.length !== 0) {
-        return unexpectedError(__x);
-      } else if (Primitive_object.equal(__x.map(encEvent), expected.map(encEvent))) {
-        return Outcome$ReventlessGwt.pass;
-      } else {
-        return Outcome$ReventlessGwt.fail({
-          TAG: "EventsMismatch",
-          expected: expected.map(encEvent),
-          actual: __x.map(encEvent)
-        });
-      }
-    });
-    let thenCompareEvents = (events, expected, cmp) => unlessRefused(events, __x => {
-      if (errors.contents.length !== 0) {
-        return unexpectedError(__x);
-      } else if (__x.length === expected.length && Stdlib_Array.zip(__x, expected).every(param => cmp(param[0], param[1]))) {
-        return Outcome$ReventlessGwt.pass;
-      } else {
-        return Outcome$ReventlessGwt.fail({
-          TAG: "EventsMismatch",
-          expected: expected.map(encEvent),
-          actual: __x.map(encEvent)
-        });
-      }
-    });
+    let thenEvents = (events, expected) => {
+      expects(expected, undefined);
+      return unlessRefused(events, __x => {
+        if (errors.contents.length !== 0) {
+          return unexpectedError(__x);
+        } else if (Primitive_object.equal(__x.map(encEvent), expected.map(encEvent))) {
+          return Outcome$ReventlessGwt.pass;
+        } else {
+          return Outcome$ReventlessGwt.fail({
+            TAG: "EventsMismatch",
+            expected: expected.map(encEvent),
+            actual: __x.map(encEvent)
+          });
+        }
+      });
+    };
+    let thenCompareEvents = (events, expected, cmp) => {
+      expects(expected, undefined);
+      return unlessRefused(events, __x => {
+        if (errors.contents.length !== 0) {
+          return unexpectedError(__x);
+        } else if (__x.length === expected.length && Stdlib_Array.zip(__x, expected).every(param => cmp(param[0], param[1]))) {
+          return Outcome$ReventlessGwt.pass;
+        } else {
+          return Outcome$ReventlessGwt.fail({
+            TAG: "EventsMismatch",
+            expected: expected.map(encEvent),
+            actual: __x.map(encEvent)
+          });
+        }
+      });
+    };
     let thenEvent = (events, expectedEvent) => thenEvents(events, [expectedEvent]);
     let thenCompareEvent = (events, expectedEvent, cmp) => thenCompareEvents(events, [expectedEvent], cmp);
-    let thenNoEvent = events => unlessRefused(events, compareNoEvent);
-    let thenError = (events, expectedError) => unlessRefused(events, __x => matchesError(__x, [], expectedError));
-    let thenEventWithError = (events, expectedEvent, expectedError) => unlessRefused(events, __x => matchesError(__x, [expectedEvent], expectedError));
-    let thenEventsWithError = (events, expectedEvents, expectedError) => unlessRefused(events, __x => matchesError(__x, expectedEvents, expectedError));
-    let thenRefused = events => {
+    let thenNoEvent = events => {
+      if (ScenarioRecorder$ReventlessGwt.recording()) {
+        ScenarioRecorder$ReventlessGwt.thenNoEvent();
+      }
+      return unlessRefused(events, compareNoEvent);
+    };
+    let thenError = (events, expectedError) => {
+      expects(undefined, Primitive_option.some(expectedError));
+      return unlessRefused(events, __x => matchesError(__x, [], expectedError));
+    };
+    let thenEventWithError = (events, expectedEvent, expectedError) => {
+      expects([expectedEvent], Primitive_option.some(expectedError));
+      return unlessRefused(events, __x => matchesError(__x, [expectedEvent], expectedError));
+    };
+    let thenEventsWithError = (events, expectedEvents, expectedError) => {
+      expects(expectedEvents, Primitive_option.some(expectedError));
+      return unlessRefused(events, __x => matchesError(__x, expectedEvents, expectedError));
+    };
+    let thenForbidden = events => {
       let decided = Stdlib_Option.map(errors.contents[0], encError);
       let match = refusal.contents;
       if (match !== undefined) {
@@ -894,7 +944,7 @@ function MakeFromAggregate(Spec) {
       thenCompareEvents: thenCompareEvents,
       thenEventsWithError: thenEventsWithError,
       thenError: thenError,
-      thenRefused: thenRefused
+      thenForbidden: thenForbidden
     };
   };
 }