@reventlessdev/reventless-gwt 1.0.0-alpha.207 → 1.0.0-alpha.209

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 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.209 (2026-09-11)
+
+**Note:** Version bump only for package @reventlessdev/reventless-gwt
+
+
+
+
+
+# 1.0.0-alpha.208 (2026-09-09)
+
+**Note:** Version bump only for package @reventlessdev/reventless-gwt
+
+
+
+
+
 # 1.0.0-alpha.207 (2026-09-08)
 
 **Note:** Version bump only for package @reventlessdev/reventless-gwt

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.207",
+  "version": "1.0.0-alpha.209",
   "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-rc.2",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.33",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.161",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.260",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.10",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.133"
+    "@reventlessdev/rescript-node": "2.0.0-alpha.11",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.262",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.163",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.135"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Automation_GWT.res

@@ -36,10 +36,7 @@ module type T = {
   // Unit combinators — collect
   let givenEvent: Spec.consumedEvent => Spec.consumedEvent
   let whenCollect: Spec.consumedEvent => array<(string, Spec.todoItem)>
-  let thenTodos: (
-    array<(string, Spec.todoItem)>,
-    array<(string, Spec.todoItem)>,
-  ) => Outcome.outcome
+  let thenTodos: (array<(string, Spec.todoItem)>, array<(string, Spec.todoItem)>) => Outcome.outcome
 
   // Unit combinators — resolve
   let whenResolve: Spec.consumedEvent => option<string>
@@ -62,7 +59,6 @@ module type T = {
 module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
   module Spec = Spec
 
-
   let describe = JestBind.describe
   let test = (name, body) => JestBind.test(~slice=Spec.name, name, body)
 
@@ -161,16 +157,12 @@ module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
   let whenSweep = events => {
     // Build the todo list by running collect, then drain any items that are
     // completed by resolve in the same input stream.
-    let collected =
-      events->Array.map(e => e->Spec.collect)->Array.flat
-    let resolvedIds =
-      events->Array.filterMap(e => e->Spec.resolve)
-    let pending =
-      collected->Array.filter(((id, _)) => !Array.includes(resolvedIds, id))
+    let collected = events->Array.map(e => e->Spec.collect)->Array.flat
+    let resolvedIds = events->Array.filterMap(e => e->Spec.resolve)
+    let pending = collected->Array.filter(((id, _)) => !Array.includes(resolvedIds, id))
 
     // Process each pending todo to produce commands.
-    let commands =
-      pending->Array.filterMap(((id, todo)) => Spec.process(id, todo))
+    let commands = pending->Array.filterMap(((id, todo)) => Spec.process(id, todo))
 
     {todos: pending, commands}
   }
@@ -195,10 +187,8 @@ module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
     }
 
   let andThenEvents = (scenario, events) => {
-    let resolvedIds =
-      events->Array.filterMap(e => e->Spec.resolve)
-    let remaining =
-      scenario.todos->Array.filter(((id, _)) => !Array.includes(resolvedIds, id))
+    let resolvedIds = events->Array.filterMap(e => e->Spec.resolve)
+    let remaining = scenario.todos->Array.filter(((id, _)) => !Array.includes(resolvedIds, id))
     {...scenario, todos: remaining}
   }
 

package/src/Behavior_GWT.res

@@ -70,10 +70,7 @@ module type T = {
   let thenError: (array<Spec.event>, Spec.error) => Outcome.outcome
 
   // DCB optimistic-concurrency assertions.
-  let thenAppendsConditionedOn: (
-    array<Spec.event>,
-    Reventless.DcbTag.query,
-  ) => Outcome.outcome
+  let thenAppendsConditionedOn: (array<Spec.event>, Reventless.DcbTag.query) => Outcome.outcome
   let thenAppendsConditionedOnExactly: (
     array<Spec.event>,
     Reventless.DcbTag.appendCondition,
@@ -171,9 +168,7 @@ module AssertionCore = (Spec: CoreSpec) => {
     } else if events->encEvents == expectedEvents->encEvents {
       Outcome.pass
     } else {
-      Outcome.fail(
-        EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}),
-      )
+      Outcome.fail(EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}))
     }
 
   let compareEventsWith = (events, expectedEvents, cmp) =>
@@ -185,9 +180,7 @@ module AssertionCore = (Spec: CoreSpec) => {
     ) {
       Outcome.pass
     } else {
-      Outcome.fail(
-        EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}),
-      )
+      Outcome.fail(EventsMismatch({expected: expectedEvents->encEvents, actual: events->encEvents}))
     }
 
   let compareNoEvent = events =>
@@ -235,19 +228,16 @@ module AssertionCore = (Spec: CoreSpec) => {
   }
 }
 
-module Make = (
-  Spec: BehaviorSpec,
-  Behavior: Behavior with module Spec := Spec,
-): (T with module Spec = Spec) => {
+module Make = (Spec: BehaviorSpec, Behavior: Behavior 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 currentState = consumed =>
-    consumed->Array.reduce(Behavior.initialState, Behavior.evolve)
+  let currentState = consumed => consumed->Array.reduce(Behavior.initialState, Behavior.evolve)
 
   module Core = AssertionCore(Spec)
   let errors = Core.errors
@@ -262,8 +252,7 @@ module Make = (
   // their own checks; [thenAppends*] bypass it.
   let appendConditionFailure: ref<option<Outcome.mismatch>> = ref(None)
 
-  let consumedEventTypes =
-    Reventless.DcbDecode.makeDecoder(Spec.consumedEventSchema).eventTypes
+  let consumedEventTypes = Reventless.DcbDecode.makeDecoder(Spec.consumedEventSchema).eventTypes
 
   // Scope derived from this slice's schemas, mirroring the StateChangeSlice runtime.
   let scopeShape = Reventless.DcbTag.sliceShapeFromSchemas(
@@ -290,8 +279,7 @@ module Make = (
   // Per-event indexed-tag map so a foreign reference key on this slice's *own*
   // emitted event (payload, not a read key) is narrowed out of a cross-partition
   // clause — the same dead-clause removal the runtime threads.
-  let tagKeysByEventType =
-    Reventless.DcbScopeInference.infer([scopeShape]).tagKeysByEventType
+  let tagKeysByEventType = Reventless.DcbScopeInference.infer([scopeShape]).tagKeysByEventType
 
   // Reachability guard inputs. The event types this slice *emits* are its own
   // history — read with composite AND clauses, which is fine. A *foreign* event
@@ -305,10 +293,8 @@ module Make = (
   // carries its productIds over to the cancel event). Flow_GWT catches this
   // because it threads a real tagged log; this lets the per-slice GWT catch it
   // too, rather than folding an unreachable event straight through.
-  let emittedEventTypes =
-    Reventless.DcbDecode.makeDecoder(Spec.eventSchema).eventTypes
-  let consumedTagKeysByType =
-    Reventless.DcbTag.extractTagKeysByEventType(Spec.consumedEventSchema)
+  let emittedEventTypes = Reventless.DcbDecode.makeDecoder(Spec.eventSchema).eventTypes
+  let consumedTagKeysByType = Reventless.DcbTag.extractTagKeysByEventType(Spec.consumedEventSchema)
 
   let queryTagKeys = (query: Reventless.DcbTag.query): array<string> =>
     query->Array.flatMap(qi => qi.tags->Option.mapOr([], tags => tags->Array.map(t => t.key)))
@@ -340,9 +326,7 @@ module Make = (
   }
 
   let queryTagsTotal = (q: Reventless.DcbTag.query): int =>
-    q->Array.reduce(0, (acc, qi) =>
-      acc + qi.tags->Option.mapOr(0, t => t->Array.length)
-    )
+    q->Array.reduce(0, (acc, qi) => acc + qi.tags->Option.mapOr(0, t => t->Array.length))
 
   let exec = (history, command): array<Spec.event> => {
     errors := []
@@ -530,18 +514,15 @@ module type AggregateT = {
   let thenError: (array<Spec.event>, Spec.error) => Outcome.outcome
 }
 
-module MakeFromAggregate = (
-  Spec: AggregateSpec,
-  Behavior: Behavior.T with module Spec = Spec,
-): (AggregateT with module Spec = Spec) => {
+module MakeFromAggregate = (Spec: AggregateSpec, Behavior: Behavior.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 currentState = events =>
-    events->Array.reduce(Behavior.initialState, Behavior.evolve)
+  let currentState = events => events->Array.reduce(Behavior.initialState, Behavior.evolve)
 
   module Core = AssertionCore(Spec)
   let errors = Core.errors

package/src/Delegate_GWT.res

@@ -72,10 +72,8 @@ module type T = {
 module Make = (D: Delegate): (T with type inbound = D.inbound) => {
   type inbound = D.inbound
 
-
   let describe = JestBind.describe
-  let test = (name, ~timeout=?, body) =>
-    JestBind.testPromise(~slice=D.name, name, ~timeout?, body)
+  let test = (name, ~timeout=?, body) => JestBind.testPromise(~slice=D.name, name, ~timeout?, body)
 
   let whenInput = ev => D.run(ev)
 
@@ -134,18 +132,17 @@ module FromExtensionPoint = (M: EPMapping.Mapping) => {
       switch M.mapOutgoingEvent {
       | None => []
       | Some(f) =>
-        let nested =
-          await f("gwt-id", event, StubRuntime.meta, StubRuntime.queryEngine)
-          ->Array.map(async action =>
-            switch action {
-            | EPMapping.PublishEvent(id, ev) => [encPublished(~target=id, encEvent(ev))]
-            | EPMapping.PublishEventAsync(p) =>
-              let (id, ev) = await p
-              [encPublished(~target=id, encEvent(ev))]
-            | EPMapping.HandleDirective(_, dir) => [encDirective(dir)]
-            }
-          )
-          ->Promise.all
+        let nested = await f("gwt-id", event, StubRuntime.meta, StubRuntime.queryEngine)
+        ->Array.map(async action =>
+          switch action {
+          | EPMapping.PublishEvent(id, ev) => [encPublished(~target=id, encEvent(ev))]
+          | EPMapping.PublishEventAsync(p) =>
+            let (id, ev) = await p
+            [encPublished(~target=id, encEvent(ev))]
+          | EPMapping.HandleDirective(_, dir) => [encDirective(dir)]
+          }
+        )
+        ->Promise.all
         nested->Array.flat
       }
   })
@@ -212,40 +209,39 @@ module FromExtension = (M: ExtMapping.Mapping) => {
     let name = M.Delegate.name
     type inbound = M.ExtensionPoint.event
     let run = async (event: M.ExtensionPoint.event) => {
-      let nested =
-        await M.mapIncomingEvent(
-          "gwt-id",
-          event,
-          StubRuntime.meta,
-          StubRuntime.pluginDefinition,
-          StubRuntime.queryEngine,
-        )
-        ->Array.map(async action =>
-          switch action {
-          | ExtMapping.PublishStateChangeSliceCommand(cmd) => [
-              encPublished(~target=M.Delegate.name, encCmd(cmd)),
-            ]
-          | ExtMapping.PublishStateChangeSliceCommandAsync(p) =>
-            let cmd = await p
-            [encPublished(~target=M.Delegate.name, encCmd(cmd))]
-          | ExtMapping.PublishStateChangeSliceCommandsAsync(p) =>
-            (await p)->Array.map(cmd => encPublished(~target=M.Delegate.name, encCmd(cmd)))
-          | ExtMapping.PublishAggregateCommand(id, cmd) => [encPublished(~target=id, encCmd(cmd))]
-          | ExtMapping.PublishAggregateCommandAsync(p) =>
-            let (id, cmd) = await p
-            [encPublished(~target=id, encCmd(cmd))]
-          | ExtMapping.PublishAggregateCommandsAsync(p) =>
-            (await p)->Array.map(((id, cmd)) => encPublished(~target=id, encCmd(cmd)))
-          | ExtMapping.PublishExtensionPointCommand(id, cmd) => [
-              encPublished(~target=id, encEpCmd(cmd)),
-            ]
-          | ExtMapping.ForwardCommand({extensionPointName, id, commandJson}) => [
-              encPublished(~target=`${extensionPointName}:${id}`, commandJson),
-            ]
-          | ExtMapping.HandleDirective(_, dir) => [encDirective(dir)]
-          }
-        )
-        ->Promise.all
+      let nested = await M.mapIncomingEvent(
+        "gwt-id",
+        event,
+        StubRuntime.meta,
+        StubRuntime.pluginDefinition,
+        StubRuntime.queryEngine,
+      )
+      ->Array.map(async action =>
+        switch action {
+        | ExtMapping.PublishStateChangeSliceCommand(cmd) => [
+            encPublished(~target=M.Delegate.name, encCmd(cmd)),
+          ]
+        | ExtMapping.PublishStateChangeSliceCommandAsync(p) =>
+          let cmd = await p
+          [encPublished(~target=M.Delegate.name, encCmd(cmd))]
+        | ExtMapping.PublishStateChangeSliceCommandsAsync(p) =>
+          (await p)->Array.map(cmd => encPublished(~target=M.Delegate.name, encCmd(cmd)))
+        | ExtMapping.PublishAggregateCommand(id, cmd) => [encPublished(~target=id, encCmd(cmd))]
+        | ExtMapping.PublishAggregateCommandAsync(p) =>
+          let (id, cmd) = await p
+          [encPublished(~target=id, encCmd(cmd))]
+        | ExtMapping.PublishAggregateCommandsAsync(p) =>
+          (await p)->Array.map(((id, cmd)) => encPublished(~target=id, encCmd(cmd)))
+        | ExtMapping.PublishExtensionPointCommand(id, cmd) => [
+            encPublished(~target=id, encEpCmd(cmd)),
+          ]
+        | ExtMapping.ForwardCommand({extensionPointName, id, commandJson}) => [
+            encPublished(~target=`${extensionPointName}:${id}`, commandJson),
+          ]
+        | ExtMapping.HandleDirective(_, dir) => [encDirective(dir)]
+        }
+      )
+      ->Promise.all
       nested->Array.flat
     }
   })
@@ -258,7 +254,12 @@ module FromExtension = (M: ExtMapping.Mapping) => {
       switch M.mapOutgoingEvent {
       | None => []
       | Some(f) =>
-        f("gwt-id", event, StubRuntime.meta, StubRuntime.pluginDefinition)->Array.filterMap(action =>
+        f(
+          "gwt-id",
+          event,
+          StubRuntime.meta,
+          StubRuntime.pluginDefinition,
+        )->Array.filterMap(action =>
           switch action {
           | ExtMapping.PublishExtensionPointCommand(id, cmd) =>
             Some(encPublished(~target=id, encEpCmd(cmd)))

package/src/Diff.res

@@ -19,20 +19,16 @@ let joinPath = (prefix, segment) =>
 let rec walk = (~path="", expected: JSON.t, actual: JSON.t, acc: array<entry>) =>
   switch (expected, actual) {
   | (Object(e), Object(a)) =>
-    let keys =
-      Array.concat(e->Dict.keysToArray, a->Dict.keysToArray)
-      ->Array.reduce([], (uniq, k) =>
-        if Array.includes(uniq, k) {
-          uniq
-        } else {
-          Array.concat(uniq, [k])
-        }
-      )
+    let keys = Array.concat(e->Dict.keysToArray, a->Dict.keysToArray)->Array.reduce([], (uniq, k) =>
+      if Array.includes(uniq, k) {
+        uniq
+      } else {
+        Array.concat(uniq, [k])
+      }
+    )
     keys->Array.reduce(acc, (acc, k) => {
-      let childExpected =
-        e->Dict.get(k)->Option.getOr(JSON.Encode.null)
-      let childActual =
-        a->Dict.get(k)->Option.getOr(JSON.Encode.null)
+      let childExpected = e->Dict.get(k)->Option.getOr(JSON.Encode.null)
+      let childActual = a->Dict.get(k)->Option.getOr(JSON.Encode.null)
       walk(~path=joinPath(path, k), childExpected, childActual, acc)
     })
   | (Array(e), Array(a)) =>
@@ -43,16 +39,9 @@ let rec walk = (~path="", expected: JSON.t, actual: JSON.t, acc: array<entry>) =
       if i >= len {
         acc
       } else {
-        let childExpected =
-          e->Array.get(i)->Option.getOr(JSON.Encode.null)
-        let childActual =
-          a->Array.get(i)->Option.getOr(JSON.Encode.null)
-        let acc = walk(
-          ~path=joinPath(path, Int.toString(i)),
-          childExpected,
-          childActual,
-          acc,
-        )
+        let childExpected = e->Array.get(i)->Option.getOr(JSON.Encode.null)
+        let childActual = a->Array.get(i)->Option.getOr(JSON.Encode.null)
+        let acc = walk(~path=joinPath(path, Int.toString(i)), childExpected, childActual, acc)
         loop(i + 1, acc)
       }
     loop(0, acc)
@@ -73,8 +62,7 @@ let rec walk = (~path="", expected: JSON.t, actual: JSON.t, acc: array<entry>) =
     }
   }
 
-let diff = (expected: JSON.t, actual: JSON.t): array<entry> =>
-  walk(expected, actual, [])
+let diff = (expected: JSON.t, actual: JSON.t): array<entry> => walk(expected, actual, [])
 
 let diffArrays = (expected: array<JSON.t>, actual: array<JSON.t>): array<entry> =>
   walk(JSON.Encode.array(expected), JSON.Encode.array(actual), [])
@@ -87,5 +75,4 @@ let toJson = (e: entry): JSON.t => {
   JSON.Encode.object(obj)
 }
 
-let toJsonArray = (entries: array<entry>): JSON.t =>
-  entries->Array.map(toJson)->JSON.Encode.array
+let toJsonArray = (entries: array<entry>): JSON.t => entries->Array.map(toJson)->JSON.Encode.array

package/src/EventMapping_GWT.res

@@ -12,9 +12,7 @@ module Make = (
   SourceBehavior: Behavior.T with module Spec = Source,
   Target: Reventless.Aggregate.Spec,
   TargetBehavior: Behavior.T with module Spec = Target,
-  EventMapping: Reventless.EventMapping.T
-    with module Source = Source
-    and module Target = 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)

package/src/Flow_GWT.res

@@ -81,7 +81,6 @@ type flowState = {
 
 type flow = promise<flowState>
 
-
 let emptyState = {
   log: [],
   outcome: Outcome.pass,
@@ -295,8 +294,7 @@ module CommandStep = (
     )
     Array.fromIterator(set->Set.values)->Array.toSorted((a, b) => String.compare(a, b))
   }
-  let tagKeysByEventType =
-    Reventless.DcbScopeInference.infer([scopeShape]).tagKeysByEventType
+  let tagKeysByEventType = Reventless.DcbScopeInference.infer([scopeShape]).tagKeysByEventType
 
   let whenCommand = async (flowP: flow, command: Spec.command) => {
     let s = await flowP
@@ -477,7 +475,10 @@ module AutomationStep = (Spec: Automation_GWT.SliceSpec) => {
     let resolvedIds = events->Array.filterMap(e => e->Spec.resolve)
     let pending = collected->Array.filter(((id, _)) => !(resolvedIds->Array.includes(id)))
     let commands = pending->Array.filterMap(((id, todo)) => Spec.process(id, todo))
-    {...s, lastCommands: commands->Array.map(((_id, cmd)) => cmd->Message.encode(Spec.commandSchema))}
+    {
+      ...s,
+      lastCommands: commands->Array.map(((_id, cmd)) => cmd->Message.encode(Spec.commandSchema)),
+    }
   }
 
   let thenIssuesCommands = async (flowP: flow, expected: array<Spec.command>) => {
@@ -579,10 +580,9 @@ module ExtensionPointStep = (M: EPMapping.Mapping) => {
   // 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.
-  let runMapping = async (
-    sourceId: string,
-    events: array<M.Delegate.event>,
-  ): array<M.ExtensionPoint.event> =>
+  let runMapping = async (sourceId: string, events: array<M.Delegate.event>): array<
+    M.ExtensionPoint.event,
+  > =>
     switch M.mapOutgoingEvent {
     | None => []
     | Some(f) =>
@@ -590,31 +590,29 @@ module ExtensionPointStep = (M: EPMapping.Mapping) => {
         events
         ->Array.map(ev => f(sourceId, ev, StubRuntime.meta, StubRuntime.queryEngine))
         ->Array.flat
-      let nested =
-        await actions
-        ->Array.map(async action =>
-          switch action {
-          | EPMapping.PublishEvent(_id, e) => [e]
-          | EPMapping.PublishEventAsync(p) =>
-            let (_id, e) = await p
-            [e]
-          | EPMapping.HandleDirective(_, _) => []
-          }
-        )
-        ->Promise.all
+      let nested = await actions
+      ->Array.map(async action =>
+        switch action {
+        | EPMapping.PublishEvent(_id, e) => [e]
+        | EPMapping.PublishEventAsync(p) =>
+          let (_id, e) = await p
+          [e]
+        | EPMapping.HandleDirective(_, _) => []
+        }
+      )
+      ->Promise.all
       nested->Array.flat
     }
 
   let whenPublishedThrough = async (flowP: flow) => {
     let s = await flowP
-    let delegateEvents =
-      s.lastEvents->Array.filterMap(json => {
-        let data = switch json {
-        | Object(d) => d
-        | _ => Dict.make()
-        }
-        delegateDecoder.decode(~eventType=json->Reventless.Message.variantNameOfJson, ~data)
-      })
+    let delegateEvents = s.lastEvents->Array.filterMap(json => {
+      let data = switch json {
+      | Object(d) => d
+      | _ => Dict.make()
+      }
+      delegateDecoder.decode(~eventType=json->Reventless.Message.variantNameOfJson, ~data)
+    })
     let sourceId = s.lastAggregateId->Option.getOr("gwt-id")
     let publicEvents = await runMapping(sourceId, delegateEvents)
     {
@@ -647,14 +645,13 @@ module ExtensionStep = (M: ExtMapping.Mapping) => {
 
   let whenExtensionReacts = async (flowP: flow) => {
     let s = await flowP
-    let epEvents =
-      s.lastPublic->Array.filterMap(json => {
-        let data = switch json {
-        | Object(d) => d
-        | _ => Dict.make()
-        }
-        epDecoder.decode(~eventType=json->Reventless.Message.variantNameOfJson, ~data)
-      })
+    let epEvents = s.lastPublic->Array.filterMap(json => {
+      let data = switch json {
+      | Object(d) => d
+      | _ => Dict.make()
+      }
+      epDecoder.decode(~eventType=json->Reventless.Message.variantNameOfJson, ~data)
+    })
     let actions =
       epEvents
       ->Array.map(ev =>
@@ -667,27 +664,26 @@ module ExtensionStep = (M: ExtMapping.Mapping) => {
         )
       )
       ->Array.flat
-    let nested =
-      await actions
-      ->Array.map(async action =>
-        switch action {
-        | ExtMapping.PublishStateChangeSliceCommand(cmd) => [encCmd(cmd)]
-        | ExtMapping.PublishStateChangeSliceCommandAsync(p) =>
-          let cmd = await p
-          [encCmd(cmd)]
-        | ExtMapping.PublishStateChangeSliceCommandsAsync(p) => (await p)->Array.map(encCmd)
-        | ExtMapping.PublishAggregateCommand(_id, cmd) => [encCmd(cmd)]
-        | ExtMapping.PublishAggregateCommandAsync(p) =>
-          let (_id, cmd) = await p
-          [encCmd(cmd)]
-        | ExtMapping.PublishAggregateCommandsAsync(p) =>
-          (await p)->Array.map(((_id, cmd)) => encCmd(cmd))
-        | ExtMapping.PublishExtensionPointCommand(_, _)
-        | ExtMapping.ForwardCommand(_)
-        | ExtMapping.HandleDirective(_, _) => []
-        }
-      )
-      ->Promise.all
+    let nested = await actions
+    ->Array.map(async action =>
+      switch action {
+      | ExtMapping.PublishStateChangeSliceCommand(cmd) => [encCmd(cmd)]
+      | ExtMapping.PublishStateChangeSliceCommandAsync(p) =>
+        let cmd = await p
+        [encCmd(cmd)]
+      | ExtMapping.PublishStateChangeSliceCommandsAsync(p) => (await p)->Array.map(encCmd)
+      | ExtMapping.PublishAggregateCommand(_id, cmd) => [encCmd(cmd)]
+      | ExtMapping.PublishAggregateCommandAsync(p) =>
+        let (_id, cmd) = await p
+        [encCmd(cmd)]
+      | ExtMapping.PublishAggregateCommandsAsync(p) =>
+        (await p)->Array.map(((_id, cmd)) => encCmd(cmd))
+      | ExtMapping.PublishExtensionPointCommand(_, _)
+      | ExtMapping.ForwardCommand(_)
+      | ExtMapping.HandleDirective(_, _) => []
+      }
+    )
+    ->Promise.all
     {...s, lastCommands: nested->Array.flat}
   }
 

package/src/Hint.res

@@ -111,10 +111,7 @@ let forMismatch = (~slice="<slice>", m: Outcome.mismatch): t =>
 let toJson = (h: t): JSON.t => {
   let obj = Dict.make()
   obj->Dict.set("locus", JSON.Encode.string(h.locus))
-  obj->Dict.set(
-    "branch",
-    h.branch->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
-  )
+  obj->Dict.set("branch", h.branch->Option.mapOr(JSON.Encode.null, JSON.Encode.string))
   obj->Dict.set("message", JSON.Encode.string(h.message))
   JSON.Encode.object(obj)
 }

package/src/InboundTranslation_GWT.res

@@ -33,7 +33,6 @@ module type T = {
 module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
   module Spec = Spec
 
-
   let describe = JestBind.describe
   let test = (name, body) => JestBind.test(~slice=Spec.name, name, body)
 
@@ -54,11 +53,8 @@ module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
     switch result {
     | Ok(actual) if actual == expected => Outcome.pass
     | Ok(actual) =>
-      Outcome.fail(
-        EventsMismatch({expected: encPairs(expected), actual: encPairs(actual)}),
-      )
-    | Error(msg) =>
-      Outcome.fail(TranslateError({expected: "(commands)", actual: Some(msg)}))
+      Outcome.fail(EventsMismatch({expected: encPairs(expected), actual: encPairs(actual)}))
+    | Error(msg) => Outcome.fail(TranslateError({expected: "(commands)", actual: Some(msg)}))
     }
 
   let thenCommand = (result, expectedId, expectedCmd) =>
@@ -68,15 +64,13 @@ module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
     switch result {
     | Ok([]) => Outcome.pass
     | Ok(actual) => Outcome.fail(NoEventExpected({actual: encPairs(actual)}))
-    | Error(msg) =>
-      Outcome.fail(TranslateError({expected: "(no commands)", actual: Some(msg)}))
+    | Error(msg) => Outcome.fail(TranslateError({expected: "(no commands)", actual: Some(msg)}))
     }
 
   let thenTranslateError = (result, expectedMsg) =>
     switch result {
     | Error(actual) if actual == expectedMsg => Outcome.pass
-    | Error(actual) =>
-      Outcome.fail(TranslateError({expected: expectedMsg, actual: Some(actual)}))
+    | Error(actual) => Outcome.fail(TranslateError({expected: expectedMsg, actual: Some(actual)}))
     | Ok(_) => Outcome.fail(TranslateError({expected: expectedMsg, actual: None}))
     }
 }