@reventlessdev/reventless-gwt 1.0.0-alpha.76 → 1.0.0-alpha.77

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 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.77 (2026-07-03)
+
+### Performance Improvements
+
+* **gwt:** affected-set watch re-runs + parent-owned discovery (plan B1) ([e7f4e6b](https://github.com/ReventlessDev/reventless-core/commit/e7f4e6bff8c28fdbcf1b15503005ed2ac613fa06))
+* **gwt:** graph-reload dedup, build-classifier fixes, drop quadratic walks (plan B3) ([aeda1b4](https://github.com/ReventlessDev/reventless-core/commit/aeda1b47aec36373aee788def449959a290042f3))
+
+
 # 1.0.0-alpha.76 (2026-07-02)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.76",
+  "version": "1.0.0-alpha.77",
   "description": "Given-When-Then DSLs and CLI runner for Reventless slice testing",
   "license": "Apache-2.0",
   "bin": {
@@ -22,15 +22,15 @@
     "sury": "11.0.0-alpha.4",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.83",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.136",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.63",
-    "@reventlessdev/reventless-vscode-protocol": "1.0.0-alpha.9"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.137",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.84",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.64",
+    "@reventlessdev/reventless-vscode-protocol": "1.0.0-alpha.10"
   },
   "devDependencies": {
     "rescript": "^12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.48"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.50"
   },
   "peerDependencies": {
     "rescript": "^12.3.0"

package/src/Behavior_GWT.res

@@ -117,6 +117,111 @@ let encodeAppendCondition = (c: Reventless.DcbTag.appendCondition): JSON.t => {
   JSON.Encode.object(d)
 }
 
+// ---------------------------------------------------------------------------
+// Shared assertion core for both Behavior GWT flavours.
+//
+// `Make` (slice/DCB) and `MakeFromAggregate` encode produced events / errors
+// identically and compare them against the expectation the same way — only the
+// DCB append-condition footgun that `Make` layers on top, and the `thenCompare*`
+// custom-equality arms the aggregate flavour adds, differ. Factoring the
+// comparison core out (mirroring `Delegate_GWT`'s `Make`) keeps the two from
+// silently drifting. The `errors` ref is owned here and set by each outer
+// functor's `exec`.
+// ---------------------------------------------------------------------------
+module type CoreSpec = {
+  @schema
+  type event
+  @schema
+  type error
+}
+
+module AssertionCore = (Spec: CoreSpec) => {
+  let errors: ref<array<Spec.error>> = ref([])
+
+  let encEvent = (e: Spec.event) => e->Message.encode(Spec.eventSchema)
+  let encEvents = evs => evs->Array.map(encEvent)
+  let encError = (err: Spec.error) => err->Message.encode(Spec.errorSchema)
+
+  let unexpectedError = (events: array<Spec.event>): Outcome.outcome => {
+    let actual = errors.contents->Array.get(0)->Option.map(encError)
+    Outcome.fail(
+      ErrorMismatch({
+        expected: JSON.Encode.null,
+        actual,
+        actualEvents: events->encEvents,
+      }),
+    )
+  }
+
+  let compareEvents = (events, expectedEvents) =>
+    if errors.contents->Array.length > 0 {
+      unexpectedError(events)
+    } else if events == expectedEvents {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}),
+      )
+    }
+
+  let compareEventsWith = (events, expectedEvents, cmp) =>
+    if errors.contents->Array.length > 0 {
+      unexpectedError(events)
+    } else if (
+      events->Array.length == expectedEvents->Array.length &&
+        Array.zip(events, expectedEvents)->Array.every(((e1, e2)) => cmp(e1, e2))
+    ) {
+      Outcome.pass
+    } else {
+      Outcome.fail(
+        EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}),
+      )
+    }
+
+  let compareNoEvent = events =>
+    if errors.contents->Array.length > 0 {
+      unexpectedError(events)
+    } else if events->Array.length == 0 {
+      Outcome.pass
+    } else {
+      Outcome.fail(NoEventExpected({actual: events->encEvents}))
+    }
+
+  let matchesError = (
+    events: array<Spec.event>,
+    expectedEvents: array<Spec.event>,
+    expectedError: Spec.error,
+  ): Outcome.outcome => {
+    let expectedErrorJson = encError(expectedError)
+    switch errors.contents->Array.get(0) {
+    | None =>
+      Outcome.fail(
+        ErrorMismatch({
+          expected: expectedErrorJson,
+          actual: None,
+          actualEvents: events->encEvents,
+        }),
+      )
+    | Some(actual) if actual != expectedError =>
+      Outcome.fail(
+        ErrorMismatch({
+          expected: expectedErrorJson,
+          actual: Some(encError(actual)),
+          actualEvents: events->encEvents,
+        }),
+      )
+    | Some(_) =>
+      if events == expectedEvents {
+        Outcome.pass
+      } else {
+        Outcome.fail(
+          EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}),
+        )
+      }
+    }
+  }
+}
+
 module Make = (
   Spec: BehaviorSpec,
   Behavior: Behavior with module Spec := Spec,
@@ -132,7 +237,8 @@ module Make = (
   let currentState = consumed =>
     consumed->Array.reduce(Behavior.initialState, Behavior.evolve)
 
-  let errors = ref([])
+  module Core = AssertionCore(Spec)
+  let errors = Core.errors
 
   // DCB append-condition derived inside [whenCmd]; [None] until first call.
   let derivedCondition: ref<option<Reventless.DcbTag.appendCondition>> = ref(None)
@@ -280,37 +386,15 @@ module Make = (
   let givenEvents = consumed => consumed
   let whenCmd = (history, cmd) => history->exec(cmd)
 
-  let encEvent = (e: Spec.event) => e->Message.encode(Spec.eventSchema)
-  let encEvents = evs => evs->Array.map(encEvent)
-  let encError = (err: Spec.error) => err->Message.encode(Spec.errorSchema)
-
   let checkAppendCondition = (): option<Outcome.outcome> =>
     appendConditionFailure.contents->Option.map(m => Outcome.fail(m))
 
-  let unexpectedError = (events: array<Spec.event>): Outcome.outcome => {
-    let actual = errors.contents->Array.get(0)->Option.map(encError)
-    Outcome.fail(
-      ErrorMismatch({
-        expected: JSON.Encode.null,
-        actual,
-        actualEvents: events->encEvents,
-      }),
-    )
-  }
-
+  // The append-condition footgun is surfaced before the shared comparison core
+  // runs; `thenAppends*` below bypass it deliberately.
   let thenEvents = (events, expectedEvents) =>
     switch checkAppendCondition() {
     | Some(o) => o
-    | None =>
-      if errors.contents->Array.length > 0 {
-        unexpectedError(events)
-      } else if events == expectedEvents {
-        Outcome.pass
-      } else {
-        Outcome.fail(
-          EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}),
-        )
-      }
+    | None => Core.compareEvents(events, expectedEvents)
     }
 
   let thenEvent = (events, expectedEvent) => thenEvents(events, [expectedEvent])
@@ -318,66 +402,25 @@ module Make = (
   let thenNoEvent = events =>
     switch checkAppendCondition() {
     | Some(o) => o
-    | None =>
-      if errors.contents->Array.length > 0 {
-        unexpectedError(events)
-      } else if events->Array.length == 0 {
-        Outcome.pass
-      } else {
-        Outcome.fail(NoEventExpected({actual: events->encEvents}))
-      }
+    | None => Core.compareNoEvent(events)
     }
 
-  let matchesError = (
-    events: array<Spec.event>,
-    expectedEvents: array<Spec.event>,
-    expectedError: Spec.error,
-  ): Outcome.outcome => {
-    let expectedErrorJson = encError(expectedError)
-    switch errors.contents->Array.get(0) {
-    | None =>
-      Outcome.fail(
-        ErrorMismatch({
-          expected: expectedErrorJson,
-          actual: None,
-          actualEvents: events->encEvents,
-        }),
-      )
-    | Some(actual) if actual != expectedError =>
-      Outcome.fail(
-        ErrorMismatch({
-          expected: expectedErrorJson,
-          actual: Some(encError(actual)),
-          actualEvents: events->encEvents,
-        }),
-      )
-    | Some(_) =>
-      if events == expectedEvents {
-        Outcome.pass
-      } else {
-        Outcome.fail(
-          EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}),
-        )
-      }
-    }
-  }
-
   let thenError = (events, expectedError) =>
     switch checkAppendCondition() {
     | Some(o) => o
-    | None => matchesError(events, [], expectedError)
+    | None => Core.matchesError(events, [], expectedError)
     }
 
   let thenEventWithError = (events, expectedEvent, expectedError) =>
     switch checkAppendCondition() {
     | Some(o) => o
-    | None => matchesError(events, [expectedEvent], expectedError)
+    | None => Core.matchesError(events, [expectedEvent], expectedError)
     }
 
   let thenEventsWithError = (events, expectedEvents, expectedError) =>
     switch checkAppendCondition() {
     | Some(o) => o
-    | None => matchesError(events, expectedEvents, expectedError)
+    | None => Core.matchesError(events, expectedEvents, expectedError)
     }
 
   let thenAppendsConditionedOn = (_events, expectedQuery: Reventless.DcbTag.query) =>
@@ -489,7 +532,8 @@ module MakeFromAggregate = (
   let currentState = events =>
     events->Array.reduce(Behavior.initialState, Behavior.evolve)
 
-  let errors = ref([])
+  module Core = AssertionCore(Spec)
+  let errors = Core.errors
 
   let exec = (history, command): array<Spec.event> => {
     errors := []
@@ -505,99 +549,21 @@ module MakeFromAggregate = (
   let givenEvents = events => events
   let whenCmd = (history, cmd) => history->exec(cmd)
 
-  let encEvent = (e: Spec.event) => e->Message.encode(Spec.eventSchema)
-  let encEvents = evs => evs->Array.map(encEvent)
-  let encError = (err: Spec.error) => err->Message.encode(Spec.errorSchema)
-
-  let unexpectedError = (events: array<Spec.event>): Outcome.outcome => {
-    let actual = errors.contents->Array.get(0)->Option.map(encError)
-    Outcome.fail(
-      ErrorMismatch({
-        expected: JSON.Encode.null,
-        actual,
-        actualEvents: events->encEvents,
-      }),
-    )
-  }
-
-  let thenEvents = (events, expectedEvents) =>
-    if errors.contents->Array.length > 0 {
-      unexpectedError(events)
-    } else if events == expectedEvents {
-      Outcome.pass
-    } else {
-      Outcome.fail(
-        EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}),
-      )
-    }
-
-  let thenCompareEvents = (events, expectedEvents, cmp) =>
-    if errors.contents->Array.length > 0 {
-      unexpectedError(events)
-    } else if (
-      events->Array.length == expectedEvents->Array.length &&
-        Array.zip(events, expectedEvents)->Array.every(((e1, e2)) => cmp(e1, e2))
-    ) {
-      Outcome.pass
-    } else {
-      Outcome.fail(
-        EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}),
-      )
-    }
-
+  // The aggregate flavour has no append-condition footgun, so the shared core's
+  // comparisons are exposed directly; only `thenCompare*` (custom equality) is
+  // specific to this surface.
+  let thenEvents = Core.compareEvents
+  let thenCompareEvents = Core.compareEventsWith
   let thenEvent = (events, expectedEvent) => thenEvents(events, [expectedEvent])
-
   let thenCompareEvent = (events, expectedEvent, cmp) =>
     thenCompareEvents(events, [expectedEvent], cmp)
+  let thenNoEvent = Core.compareNoEvent
 
-  let thenNoEvent = events =>
-    if errors.contents->Array.length > 0 {
-      unexpectedError(events)
-    } else if events->Array.length == 0 {
-      Outcome.pass
-    } else {
-      Outcome.fail(NoEventExpected({actual: events->encEvents}))
-    }
-
-  let matchesError = (
-    events: array<Spec.event>,
-    expectedEvents: array<Spec.event>,
-    expectedError: Spec.error,
-  ): Outcome.outcome => {
-    let expectedErrorJson = encError(expectedError)
-    switch errors.contents->Array.get(0) {
-    | None =>
-      Outcome.fail(
-        ErrorMismatch({
-          expected: expectedErrorJson,
-          actual: None,
-          actualEvents: events->encEvents,
-        }),
-      )
-    | Some(actual) if actual != expectedError =>
-      Outcome.fail(
-        ErrorMismatch({
-          expected: expectedErrorJson,
-          actual: Some(encError(actual)),
-          actualEvents: events->encEvents,
-        }),
-      )
-    | Some(_) =>
-      if events == expectedEvents {
-        Outcome.pass
-      } else {
-        Outcome.fail(
-          EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}),
-        )
-      }
-    }
-  }
-
-  let thenError = (events, expectedError) => matchesError(events, [], expectedError)
+  let thenError = (events, expectedError) => Core.matchesError(events, [], expectedError)
 
   let thenEventWithError = (events, expectedEvent, expectedError) =>
-    matchesError(events, [expectedEvent], expectedError)
+    Core.matchesError(events, [expectedEvent], expectedError)
 
   let thenEventsWithError = (events, expectedEvents, expectedError) =>
-    matchesError(events, expectedEvents, expectedError)
+    Core.matchesError(events, expectedEvents, expectedError)
 }

package/src/Behavior_GWT.res.mjs

@@ -47,6 +47,102 @@ function encodeAppendCondition(c) {
   return d;
 }
 
+function AssertionCore(Spec) {
+  let errors = {
+    contents: []
+  };
+  let encEvent = e => Message$ReventlessCore.encode(e, Spec.eventSchema);
+  let encEvents = evs => evs.map(encEvent);
+  let encError = err => Message$ReventlessCore.encode(err, Spec.errorSchema);
+  let unexpectedError = events => {
+    let actual = Stdlib_Option.map(errors.contents[0], encError);
+    return Outcome$ReventlessGwt.fail({
+      TAG: "ErrorMismatch",
+      expected: null,
+      actual: actual,
+      actualEvents: events.map(encEvent)
+    });
+  };
+  let compareEvents = (events, expectedEvents) => {
+    if (errors.contents.length !== 0) {
+      return unexpectedError(events);
+    } else if (Primitive_object.equal(events, expectedEvents)) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: expectedEvents.map(encEvent),
+        actual: events.map(encEvent)
+      });
+    }
+  };
+  let compareEventsWith = (events, expectedEvents, cmp) => {
+    if (errors.contents.length !== 0) {
+      return unexpectedError(events);
+    } else if (events.length === expectedEvents.length && Stdlib_Array.zip(events, expectedEvents).every(param => cmp(param[0], param[1]))) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: expectedEvents.map(encEvent),
+        actual: events.map(encEvent)
+      });
+    }
+  };
+  let compareNoEvent = events => {
+    if (errors.contents.length !== 0) {
+      return unexpectedError(events);
+    } else if (events.length === 0) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "NoEventExpected",
+        actual: events.map(encEvent)
+      });
+    }
+  };
+  let matchesError = (events, expectedEvents, expectedError) => {
+    let expectedErrorJson = Message$ReventlessCore.encode(expectedError, Spec.errorSchema);
+    let actual = errors.contents[0];
+    if (actual === undefined) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: expectedErrorJson,
+        actual: undefined,
+        actualEvents: events.map(encEvent)
+      });
+    }
+    let actual$1 = Primitive_option.valFromOption(actual);
+    if (Primitive_object.notequal(actual$1, expectedError)) {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: expectedErrorJson,
+        actual: Message$ReventlessCore.encode(actual$1, Spec.errorSchema),
+        actualEvents: events.map(encEvent)
+      });
+    } else if (Primitive_object.equal(events, expectedEvents)) {
+      return Outcome$ReventlessGwt.pass;
+    } else {
+      return Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: expectedEvents.map(encEvent),
+        actual: events.map(encEvent)
+      });
+    }
+  };
+  return {
+    errors: errors,
+    encEvent: encEvent,
+    encEvents: encEvents,
+    encError: encError,
+    unexpectedError: unexpectedError,
+    compareEvents: compareEvents,
+    compareEventsWith: compareEventsWith,
+    compareNoEvent: compareNoEvent,
+    matchesError: matchesError
+  };
+}
+
 function Make(Spec) {
   return Behavior => {
     S.enableJson();
@@ -54,6 +150,46 @@ function Make(Spec) {
     let errors = {
       contents: []
     };
+    let encEvent = e => Message$ReventlessCore.encode(e, Spec.eventSchema);
+    let encError = err => Message$ReventlessCore.encode(err, Spec.errorSchema);
+    let unexpectedError = events => {
+      let actual = Stdlib_Option.map(errors.contents[0], encError);
+      return Outcome$ReventlessGwt.fail({
+        TAG: "ErrorMismatch",
+        expected: null,
+        actual: actual,
+        actualEvents: events.map(encEvent)
+      });
+    };
+    let matchesError = (events, expectedEvents, expectedError) => {
+      let expectedErrorJson = Message$ReventlessCore.encode(expectedError, Spec.errorSchema);
+      let actual = errors.contents[0];
+      if (actual === undefined) {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "ErrorMismatch",
+          expected: expectedErrorJson,
+          actual: undefined,
+          actualEvents: events.map(encEvent)
+        });
+      }
+      let actual$1 = Primitive_option.valFromOption(actual);
+      if (Primitive_object.notequal(actual$1, expectedError)) {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "ErrorMismatch",
+          expected: expectedErrorJson,
+          actual: Message$ReventlessCore.encode(actual$1, Spec.errorSchema),
+          actualEvents: events.map(encEvent)
+        });
+      } else if (Primitive_object.equal(events, expectedEvents)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "EventsMismatch",
+          expected: expectedEvents.map(encEvent),
+          actual: events.map(encEvent)
+        });
+      }
+    };
     let derivedCondition = {
       contents: undefined
     };
@@ -138,18 +274,7 @@ function Make(Spec) {
       errors.contents = [events._0];
       return [];
     };
-    let encEvent = e => Message$ReventlessCore.encode(e, Spec.eventSchema);
-    let encError = err => Message$ReventlessCore.encode(err, Spec.errorSchema);
     let checkAppendCondition = () => Stdlib_Option.map(appendConditionFailure.contents, Outcome$ReventlessGwt.fail);
-    let unexpectedError = events => {
-      let actual = Stdlib_Option.map(errors.contents[0], encError);
-      return Outcome$ReventlessGwt.fail({
-        TAG: "ErrorMismatch",
-        expected: null,
-        actual: actual,
-        actualEvents: events.map(encEvent)
-      });
-    };
     let thenEvents = (events, expectedEvents) => {
       let o = checkAppendCondition();
       if (o !== undefined) {
@@ -182,35 +307,6 @@ function Make(Spec) {
         });
       }
     };
-    let matchesError = (events, expectedEvents, expectedError) => {
-      let expectedErrorJson = Message$ReventlessCore.encode(expectedError, Spec.errorSchema);
-      let actual = errors.contents[0];
-      if (actual === undefined) {
-        return Outcome$ReventlessGwt.fail({
-          TAG: "ErrorMismatch",
-          expected: expectedErrorJson,
-          actual: undefined,
-          actualEvents: events.map(encEvent)
-        });
-      }
-      let actual$1 = Primitive_option.valFromOption(actual);
-      if (Primitive_object.notequal(actual$1, expectedError)) {
-        return Outcome$ReventlessGwt.fail({
-          TAG: "ErrorMismatch",
-          expected: expectedErrorJson,
-          actual: Message$ReventlessCore.encode(actual$1, Spec.errorSchema),
-          actualEvents: events.map(encEvent)
-        });
-      } else if (Primitive_object.equal(events, expectedEvents)) {
-        return Outcome$ReventlessGwt.pass;
-      } else {
-        return Outcome$ReventlessGwt.fail({
-          TAG: "EventsMismatch",
-          expected: expectedEvents.map(encEvent),
-          actual: events.map(encEvent)
-        });
-      }
-    };
     let thenError = (events, expectedError) => {
       let o = checkAppendCondition();
       if (o !== undefined) {
@@ -303,17 +399,6 @@ function MakeFromAggregate(Spec) {
     let errors = {
       contents: []
     };
-    let givenEvents = events => events;
-    let whenCmd = (history, cmd) => {
-      errors.contents = [];
-      let state = Stdlib_Array.reduce(history, Behavior.initialState, Behavior.evolve);
-      let events = Behavior.decide(state, cmd);
-      if (events.TAG === "Ok") {
-        return events._0;
-      }
-      errors.contents = [events._0];
-      return [];
-    };
     let encEvent = e => Message$ReventlessCore.encode(e, Spec.eventSchema);
     let encError = err => Message$ReventlessCore.encode(err, Spec.errorSchema);
     let unexpectedError = events => {
@@ -325,7 +410,7 @@ function MakeFromAggregate(Spec) {
         actualEvents: events.map(encEvent)
       });
     };
-    let thenEvents = (events, expectedEvents) => {
+    let compareEvents = (events, expectedEvents) => {
       if (errors.contents.length !== 0) {
         return unexpectedError(events);
       } else if (Primitive_object.equal(events, expectedEvents)) {
@@ -338,7 +423,7 @@ function MakeFromAggregate(Spec) {
         });
       }
     };
-    let thenCompareEvents = (events, expectedEvents, cmp) => {
+    let compareEventsWith = (events, expectedEvents, cmp) => {
       if (errors.contents.length !== 0) {
         return unexpectedError(events);
       } else if (events.length === expectedEvents.length && Stdlib_Array.zip(events, expectedEvents).every(param => cmp(param[0], param[1]))) {
@@ -351,9 +436,7 @@ function MakeFromAggregate(Spec) {
         });
       }
     };
-    let thenEvent = (events, expectedEvent) => thenEvents(events, [expectedEvent]);
-    let thenCompareEvent = (events, expectedEvent, cmp) => thenCompareEvents(events, [expectedEvent], cmp);
-    let thenNoEvent = events => {
+    let compareNoEvent = events => {
       if (errors.contents.length !== 0) {
         return unexpectedError(events);
       } else if (events.length === 0) {
@@ -394,6 +477,19 @@ function MakeFromAggregate(Spec) {
         });
       }
     };
+    let givenEvents = events => events;
+    let whenCmd = (history, cmd) => {
+      errors.contents = [];
+      let state = Stdlib_Array.reduce(history, Behavior.initialState, Behavior.evolve);
+      let events = Behavior.decide(state, cmd);
+      if (events.TAG === "Ok") {
+        return events._0;
+      }
+      errors.contents = [events._0];
+      return [];
+    };
+    let thenEvent = (events, expectedEvent) => compareEvents(events, [expectedEvent]);
+    let thenCompareEvent = (events, expectedEvent, cmp) => compareEventsWith(events, [expectedEvent], cmp);
     let thenError = (events, expectedError) => matchesError(events, [], expectedError);
     let thenEventWithError = (events, expectedEvent, expectedError) => matchesError(events, [expectedEvent], expectedError);
     let thenEventsWithError = matchesError;
@@ -405,10 +501,10 @@ function MakeFromAggregate(Spec) {
       whenCmd: whenCmd,
       thenEvent: thenEvent,
       thenCompareEvent: thenCompareEvent,
-      thenNoEvent: thenNoEvent,
+      thenNoEvent: compareNoEvent,
       thenEventWithError: thenEventWithError,
-      thenEvents: thenEvents,
-      thenCompareEvents: thenCompareEvents,
+      thenEvents: compareEvents,
+      thenCompareEvents: compareEventsWith,
       thenEventsWithError: thenEventsWithError,
       thenError: thenError
     };
@@ -420,6 +516,7 @@ export {
   encodeQueryItem,
   encodeQuery,
   encodeAppendCondition,
+  AssertionCore,
   Make,
   MakeFromAggregate,
 }