@reventlessdev/reventless-gwt 1.0.0-alpha.241 → 1.0.0-alpha.243

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 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.243 (2026-10-15)
+
+* feat!: an automation's process takes ~now, and collect the event's recorded time ([8c8f3f5](https://github.com/ReventlessDev/reventless-core/commit/8c8f3f570474b1658b605b726077debc7d6a1dc7))
+
+### BREAKING CHANGES
+
+* a process the PPX does not see — in an Automation module
+written by hand, or a SliceSpec given to the deprecated Automation_GWT.Make
+or Flow_GWT.AutomationStep — must take ~now.
+
+
+
+# 1.0.0-alpha.242 (2026-10-14)
+
+### Bug Fixes
+
+* **gwt:** thenStateWithId checks the rows under its id, not that they are the only ones ([279d298](https://github.com/ReventlessDev/reventless-core/commit/279d298866fec60d976f0f8c8a247f684e600ba2))
+
+
 # 1.0.0-alpha.241 (2026-10-12)
 
 **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.241",
+  "version": "1.0.0-alpha.243",
   "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": "0.1.0-alpha.35",
+    "@reventlessdev/rescript-effect": "1.0.0-alpha.0",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.295",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.12",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.191",
     "@reventlessdev/rescript-node": "2.0.0-alpha.22",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.163",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.294"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.192",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.164"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/Automation_GWT.res

@@ -1,5 +1,13 @@
 open ReventlessCore
 
+// The current time when a scenario fixes none, from Effect's Clock.
+let clockNow = () => Clock.currentTimeMillis->Effect.runSync
+let nowOr = now =>
+  switch now {
+  | Some(now) => now
+  | None => clockNow()
+  }
+
 // Minimal inline spec for AutomationSlice — mirrors the pattern used by
 // the other GWT DSLs so sury-ppx processes the @schema attributes in this
 // compilation unit.
@@ -17,7 +25,7 @@ module type SliceSpec = {
 
   let collect: consumedEvent => array<(string, todoItem)>
   let resolve: consumedEvent => option<string>
-  let process: (string, todoItem) => option<(string, command)>
+  let process: (string, todoItem, ~now: float) => option<(string, command)>
 }
 
 module type T = {
@@ -44,13 +52,13 @@ module type T = {
 
   // Unit combinators — process
   let givenTodo: (string, Spec.todoItem) => (string, Spec.todoItem)
-  let whenProcess: ((string, Spec.todoItem)) => option<(string, Spec.command)>
+  let whenProcess: ((string, Spec.todoItem), ~now: float=?) => option<(string, Spec.command)>
   let thenCommand: (option<(string, Spec.command)>, string, Spec.command) => Outcome.outcome
   let thenNoCommand: option<(string, Spec.command)> => Outcome.outcome
 
   // Scenario combinators — full sweep
   let givenEvents: array<Spec.consumedEvent> => array<Spec.consumedEvent>
-  let whenSweep: array<Spec.consumedEvent> => scenario
+  let whenSweep: (array<Spec.consumedEvent>, ~now: float=?) => scenario
   let thenCommands: (scenario, array<(string, Spec.command)>) => Outcome.outcome
   let andThenEvents: (scenario, array<Spec.consumedEvent>) => scenario
   let thenScenarioTodos: (scenario, array<(string, Spec.todoItem)>) => Outcome.outcome
@@ -111,7 +119,7 @@ module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
 
   // Unit: process
   let givenTodo = (id, todo) => (id, todo)
-  let whenProcess = ((id, todo)) => Spec.process(id, todo)
+  let whenProcess = ((id, todo), ~now=?) => Spec.process(id, todo, ~now=nowOr(now))
   let thenCommand = (actual, expectedId, expectedCmd) =>
     switch actual {
     | Some((id, cmd)) if id == expectedId && cmd == expectedCmd => Outcome.pass
@@ -157,7 +165,8 @@ module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
 
   // Scenario: full sweep
   let givenEvents = es => es
-  let whenSweep = events => {
+  let whenSweep = (events, ~now=?) => {
+    let now = nowOr(now)
     // 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
@@ -165,7 +174,7 @@ module Make = (Spec: SliceSpec): (T with module Spec = Spec) => {
     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, ~now))
 
     {todos: pending, commands}
   }
@@ -217,9 +226,13 @@ module FromSlice = (
     sliceName: Spec.name,
   }
 
-  /** A source event as the runtime receives it: encoded, and addressed by its
-      source's name. Built with `Mapping(M).event`. */
-  type sourced = {sourceName: string, sourceId: string, payload: JSON.t}
+  /** A source event as the runtime receives it: encoded, addressed by its
+      source's name, and recorded at a time when the scenario gives one. Built
+      with `Mapping(M).event`. */
+  type sourced = {sourceName: string, sourceId: string, payload: JSON.t, recordedAt: option<float>}
+
+  let withRecordedAt = (context: Reventless.AutomationSlice.context, recordedAt) =>
+    recordedAt->Option.mapOr(context, recordedAt => {...context, recordedAt})
 
   type scenario = {
     todos: array<(string, Spec.todoItem)>,
@@ -248,19 +261,21 @@ module FromSlice = (
   }
 
   module Mapping = (M: Automation.Mapping) => {
-    let event = (e: M.sourceEvent, ~sourceId="") => {
+    let event = (e: M.sourceEvent, ~sourceId="", ~recordedAt=?) => {
       sourceName: M.sourceName,
       sourceId,
       payload: e->Message.encode(M.sourceEventSchema),
+      recordedAt,
     }
     let givenEvent = (e: M.sourceEvent) => e
-    let whenCollect = (e, ~sourceId="", ~context=testContext) => M.collect(e, ~sourceId, context)
+    let whenCollect = (e, ~sourceId="", ~context=testContext, ~recordedAt=?) =>
+      M.collect(e, ~sourceId, context->withRecordedAt(recordedAt))
     let whenResolve = M.resolve
   }
 
   // Unit: process and abandonment
   let givenTodo = (id: string, item: Spec.todoItem) => (id, item)
-  let whenProcess = ((id, item)) => Automation.process(id, item)
+  let whenProcess = ((id, item), ~now=?) => Automation.process(id, item, ~now=nowOr(now))
   let whenExhausted = ((id, item)) => Automation.onExhausted(id, item)
   let thenCommand = (actual, expectedId, expectedCmd) =>
     switch actual {
@@ -282,13 +297,30 @@ module FromSlice = (
   // Scenario: a sweep routes each event in turn, as phase 1 does, so to-dos keep
   // the order the events produced them.
   let givenEvents = (es: array<sourced>) => es
+  /** The events happened at `time`: each one the scenario gave no time of its
+      own is recorded then. A sweep given no `~now` runs at the latest of them. */
+  let atTime = (events: array<sourced>, time) =>
+    events->Array.map(e => e.recordedAt->Option.isSome ? e : {...e, recordedAt: Some(time)})
+  let latestRecorded = (events: array<sourced>) =>
+    events->Array.reduce(None, (latest, e) =>
+      switch (latest, e.recordedAt) {
+      | (Some(l), Some(r)) => Some(Math.max(l, r))
+      | (None, r) => r
+      | (l, None) => l
+      }
+    )
   let routeAll = (events: array<sourced>, context) =>
     events->Array.flatMap(e =>
-      Route.route(e.payload, ~sourceName=e.sourceName, ~sourceId=e.sourceId, context)
+      Route.route(
+        e.payload,
+        ~sourceName=e.sourceName,
+        ~sourceId=e.sourceId,
+        context->withRecordedAt(e.recordedAt),
+      )
     )
   /** Applies routed events as the runtime's to-do list does: the first writer of
       an id wins, and a resolve completes only a row that already exists. */
-  let sweep = (routed: array<AutomationSlice_Route.routed<Spec.todoItem>>) => {
+  let sweep = (routed: array<AutomationSlice_Route.routed<Spec.todoItem>>, ~now) => {
     let rows: array<(string, Spec.todoItem, ref<bool>)> = []
     routed->Array.forEach(r => {
       r.collected->Array.forEach(((id, item)) =>
@@ -306,9 +338,16 @@ module FromSlice = (
       )
     })
     let todos = rows->Array.filterMap(((id, item, done)) => done.contents ? None : Some((id, item)))
-    {todos, commands: todos->Array.filterMap(((id, item)) => Automation.process(id, item))}
+    {todos, commands: todos->Array.filterMap(((id, item)) => Automation.process(id, item, ~now))}
   }
-  let whenSweep = (events, ~context=testContext) => sweep(routeAll(events, context))
+  let whenSweep = (events, ~context=testContext, ~now=?) =>
+    sweep(
+      routeAll(events, context),
+      ~now=switch (now, latestRecorded(events)) {
+      | (Some(now), _) | (None, Some(now)) => now
+      | (None, None) => clockNow()
+      },
+    )
   let thenCommands = (scenario, expected) =>
     scenario.commands == expected
       ? Outcome.pass

package/src/Automation_GWT.res.mjs

@@ -1,7 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Clock from "effect/Clock";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
@@ -9,6 +11,18 @@ import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
 import * as AutomationSlice_Route$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Route.res.mjs";
 
+function clockNow() {
+  return Effect.runSync(Clock.currentTimeMillis);
+}
+
+function nowOr(now) {
+  if (now !== undefined) {
+    return now;
+  } else {
+    return Effect.runSync(Clock.currentTimeMillis);
+  }
+}
+
 function Make(Spec) {
   let test = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
   let encTodos = arr => arr.map(param => [
@@ -53,7 +67,7 @@ function Make(Spec) {
     id,
     todo
   ];
-  let whenProcess = param => Spec.process(param[0], param[1]);
+  let whenProcess = (param, now) => Spec.process(param[0], param[1], nowOr(now));
   let thenCommand = (actual, expectedId, expectedCmd) => {
     if (actual !== undefined) {
       let cmd = actual[1];
@@ -98,11 +112,12 @@ function Make(Spec) {
     });
   };
   let givenEvents = es => es;
-  let whenSweep = events => {
+  let whenSweep = (events, now) => {
+    let now$1 = nowOr(now);
     let collected = events.map(e => Spec.collect(e)).flat();
     let resolvedIds = Stdlib_Array.filterMap(events, e => Spec.resolve(e));
     let pending = collected.filter(param => !resolvedIds.includes(param[0]));
-    let commands = Stdlib_Array.filterMap(pending, param => Spec.process(param[0], param[1]));
+    let commands = Stdlib_Array.filterMap(pending, param => Spec.process(param[0], param[1], now$1));
     return {
       todos: pending,
       commands: commands
@@ -165,6 +180,11 @@ function FromSlice(Spec) {
       pluginName: "test",
       sliceName: testContext_sliceName
     };
+    let withRecordedAt = (context, recordedAt) => Stdlib_Option.mapOr(recordedAt, context, recordedAt => {
+      let newrecord = {...context};
+      newrecord.recordedAt = recordedAt;
+      return newrecord;
+    });
     let encTodos = arr => arr.map(param => [
       param[0],
       Message$ReventlessCore.encode(param[1], Spec.todoItemSchema)
@@ -202,19 +222,20 @@ function FromSlice(Spec) {
       }
     };
     let Mapping = M => {
-      let event = (e, sourceIdOpt) => {
+      let event = (e, sourceIdOpt, recordedAt) => {
         let sourceId = sourceIdOpt !== undefined ? sourceIdOpt : "";
         return {
           sourceName: M.sourceName,
           sourceId: sourceId,
-          payload: Message$ReventlessCore.encode(e, M.sourceEventSchema)
+          payload: Message$ReventlessCore.encode(e, M.sourceEventSchema),
+          recordedAt: recordedAt
         };
       };
       let givenEvent = e => e;
-      let whenCollect = (e, sourceIdOpt, contextOpt) => {
+      let whenCollect = (e, sourceIdOpt, contextOpt, recordedAt) => {
         let sourceId = sourceIdOpt !== undefined ? sourceIdOpt : "";
         let context = contextOpt !== undefined ? contextOpt : testContext;
-        return M.collect(e, sourceId, context);
+        return M.collect(e, sourceId, withRecordedAt(context, recordedAt));
       };
       return {
         event: event,
@@ -227,7 +248,7 @@ function FromSlice(Spec) {
       id,
       item
     ];
-    let whenProcess = param => Automation.process(param[0], param[1]);
+    let whenProcess = (param, now) => Automation.process(param[0], param[1], nowOr(now));
     let whenExhausted = param => Automation.onExhausted(param[0], param[1]);
     let thenCommand = (actual, expectedId, expectedCmd) => {
       if (actual !== undefined && actual[0] === expectedId && Primitive_object.equal(actual[1], expectedCmd)) {
@@ -253,8 +274,32 @@ function FromSlice(Spec) {
       }
     };
     let givenEvents = es => es;
-    let routeAll = (events, context) => events.flatMap(e => Route.route(e.payload, e.sourceName, e.sourceId, context));
-    let sweep = routed => {
+    let atTime = (events, time) => events.map(e => {
+      if (Stdlib_Option.isSome(e.recordedAt)) {
+        return e;
+      } else {
+        return {
+          sourceName: e.sourceName,
+          sourceId: e.sourceId,
+          payload: e.payload,
+          recordedAt: time
+        };
+      }
+    });
+    let latestRecorded = events => Stdlib_Array.reduce(events, undefined, (latest, e) => {
+      let match = e.recordedAt;
+      if (latest !== undefined) {
+        if (match !== undefined) {
+          return Math.max(latest, match);
+        } else {
+          return latest;
+        }
+      } else {
+        return match;
+      }
+    });
+    let routeAll = (events, context) => events.flatMap(e => Route.route(e.payload, e.sourceName, e.sourceId, withRecordedAt(context, e.recordedAt)));
+    let sweep = (routed, now) => {
       let rows = [];
       routed.forEach(r => {
         r.collected.forEach(param => {
@@ -291,12 +336,15 @@ function FromSlice(Spec) {
       });
       return {
         todos: todos,
-        commands: Stdlib_Array.filterMap(todos, param => Automation.process(param[0], param[1]))
+        commands: Stdlib_Array.filterMap(todos, param => Automation.process(param[0], param[1], now))
       };
     };
-    let whenSweep = (events, contextOpt) => {
+    let whenSweep = (events, contextOpt, now) => {
       let context = contextOpt !== undefined ? contextOpt : testContext;
-      return sweep(routeAll(events, context));
+      let match = latestRecorded(events);
+      return sweep(routeAll(events, context), now !== undefined ? now : (
+          match !== undefined ? match : Effect.runSync(Clock.currentTimeMillis)
+        ));
     };
     let thenCommands = (scenario, expected) => {
       if (Primitive_object.equal(scenario.commands, expected)) {
@@ -323,6 +371,7 @@ function FromSlice(Spec) {
       describe: JestBind$ReventlessGwt.describe,
       test: test,
       testContext: testContext,
+      withRecordedAt: withRecordedAt,
       encTodos: encTodos,
       encPair: encPair,
       thenTodos: thenTodos,
@@ -334,6 +383,8 @@ function FromSlice(Spec) {
       thenCommand: thenCommand,
       thenNoCommand: thenNoCommand,
       givenEvents: givenEvents,
+      atTime: atTime,
+      latestRecorded: latestRecorded,
       routeAll: routeAll,
       sweep: sweep,
       whenSweep: whenSweep,
@@ -345,7 +396,9 @@ function FromSlice(Spec) {
 }
 
 export {
+  clockNow,
+  nowOr,
   Make,
   FromSlice,
 }
-/* Message-ReventlessCore Not a pure module */
+/* effect/Clock Not a pure module */

package/src/Flow_GWT.res

@@ -505,7 +505,8 @@ module AutomationStep = (Spec: Automation_GWT.SliceSpec) => {
     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, _)) => !(resolvedIds->Array.includes(id)))
-    let commands = pending->Array.filterMap(((id, todo)) => Spec.process(id, todo))
+    let now = Automation_GWT.clockNow()
+    let commands = pending->Array.filterMap(((id, todo)) => Spec.process(id, todo, ~now))
     {
       ...s,
       lastCommands: commands->Array.map(((_id, cmd)) => cmd->Message.encode(Spec.commandSchema)),
@@ -628,7 +629,7 @@ module AutomationSlice = (
           d.handle(entry.json, ~sourceId=entry->sourceIdOf, A.testContext)
         )
       )
-    let {commands, _} = A.sweep(routed)
+    let {commands, _} = A.sweep(routed, ~now=Automation_GWT.clockNow())
     {
       ...s,
       lastCommands: commands->Array.map(((_id, cmd)) => cmd->Message.encode(Spec.commandSchema)),

package/src/Flow_GWT.res.mjs

@@ -406,7 +406,8 @@ function AutomationStep(Spec) {
     let collected = events.map(e => Spec.collect(e)).flat();
     let resolvedIds = Stdlib_Array.filterMap(events, e => Spec.resolve(e));
     let pending = collected.filter(param => !resolvedIds.includes(param[0]));
-    let commands = Stdlib_Array.filterMap(pending, param => Spec.process(param[0], param[1]));
+    let now = Automation_GWT$ReventlessGwt.clockNow();
+    let commands = Stdlib_Array.filterMap(pending, param => Spec.process(param[0], param[1], now));
     return {
       log: s.log,
       outcome: s.outcome,
@@ -524,7 +525,7 @@ function AutomationSlice(Spec) {
     let whenReacts = async flowP => {
       let s = await flowP;
       let routed = s.log.flatMap(entry => Stdlib_Array.filterMap(A.Route.dispatches, d => d.handle(entry.json, Stdlib_Option.getOr(entry.aggregateId, ""), A.testContext)));
-      let match = A.sweep(routed);
+      let match = A.sweep(routed, Automation_GWT$ReventlessGwt.clockNow());
       return {
         log: s.log,
         outcome: s.outcome,

package/src/MultiSourceProjection_GWT.res

@@ -250,10 +250,10 @@ module Make = (Projection: Reventless.Projection.Mapping): (
 
   let thenStatesWithId = async (thunk, id, expectedStates) => {
     let store = await thunk()
-    let keys = store->Dict.keysToArray
-    let actualId = keys->Array.get(0)
-    let actualStates = store->Dict.valuesToArray->Array.get(0)->Option.getOr([])
-    if keys->Array.length == 1 && actualId == Some(id) && statesEq(actualStates, expectedStates) {
+
+    // The rows under that id: rows the given events filed under other ids are another
+    // expectation's (`thenAllStates` checks them all).
+    if store->Dict.get(id)->Option.mapOr(false, actual => statesEq(actual, expectedStates)) {
       Outcome.pass
     } else {
       Outcome.fail(

package/src/MultiSourceProjection_GWT.res.mjs

@@ -255,10 +255,7 @@ function Make(Projection) {
   };
   let thenStatesWithId = async (thunk, id, expectedStates) => {
     let store = await thunk();
-    let keys = Object.keys(store);
-    let actualId = keys[0];
-    let actualStates = Stdlib_Option.getOr(Object.values(store)[0], []);
-    if (keys.length === 1 && Primitive_object.equal(actualId, id) && statesEq(actualStates, expectedStates)) {
+    if (Stdlib_Option.mapOr(store[id], false, actual => statesEq(actual, expectedStates))) {
       return Outcome$ReventlessGwt.pass;
     } else {
       return Outcome$ReventlessGwt.fail({

package/src/Projection_GWT.res

@@ -254,10 +254,10 @@ module Make = (Spec: Spec, Projection: Projection with module Spec := Spec): (
 
   let thenStatesWithId = async (thunk, id, expectedStates) => {
     let store = await thunk()
-    let keys = store->Dict.keysToArray
-    let actualId = keys->Array.get(0)
-    let actualStates = store->Dict.valuesToArray->Array.get(0)->Option.getOr([])
-    if keys->Array.length == 1 && actualId == Some(id) && statesEq(actualStates, expectedStates) {
+
+    // The rows under that id: rows the given events filed under other ids are another
+    // expectation's (`thenAllStates` checks them all).
+    if store->Dict.get(id)->Option.mapOr(false, actual => statesEq(actual, expectedStates)) {
       Outcome.pass
     } else {
       Outcome.fail(

package/src/Projection_GWT.res.mjs

@@ -238,10 +238,7 @@ function Make(Spec) {
     };
     let thenStatesWithId = async (thunk, id, expectedStates) => {
       let store = await thunk();
-      let keys = Object.keys(store);
-      let actualId = keys[0];
-      let actualStates = Stdlib_Option.getOr(Object.values(store)[0], []);
-      if (keys.length === 1 && Primitive_object.equal(actualId, id) && statesEq(actualStates, expectedStates)) {
+      if (Stdlib_Option.mapOr(store[id], false, actual => statesEq(actual, expectedStates))) {
         return Outcome$ReventlessGwt.pass;
       } else {
         return Outcome$ReventlessGwt.fail({

package/tests/AutomationDeadlineGwtTest.res

@@ -0,0 +1,111 @@
+// A deadline tested at a fixed time: an order not shipped within three days of
+// being placed is cancelled. `collect` counts the due time from the event's
+// recorded time; `process` compares it with `~now`. `atTime` and `~recordedAt`
+// say when the events happened, `~now` when the sweep runs.
+
+module CancelUnshipped = {
+  let name = "CancelUnshipped"
+  let moduleUrl = ""
+
+  @schema
+  type todoItem = {orderId: string, dueAt: float}
+
+  @schema
+  type command = CancelOrder({orderId: string})
+
+  let maxRetries = 3
+  let heartbeatInterval = 60
+  let targetName = "Order"
+}
+
+let day = 24. *. 60. *. 60. *. 1000.
+let day0 = Date.fromString("2026-10-01T09:00:00Z")->Date.getTime
+
+module CancelUnshipped_Automation = {
+  module M = Reventless.AutomationSlice.Mappings.Make(CancelUnshipped)
+  module type Mapping = M.Mapping
+  let moduleUrl = ""
+
+  module Orders = {
+    module Id = Reventless.Id.String
+    let name = "Orders"
+    @schema
+    type event =
+      | OrderPlaced({orderId: string})
+      | OrderShipped({orderId: string})
+  }
+
+  module FromOrders = Reventless.AutomationSlice.Mapping.Make(
+    Orders,
+    CancelUnshipped,
+    {
+      let collect = (event, ~sourceId as _, ctx: Reventless.AutomationSlice.context) =>
+        switch (event, ctx.recordedAt) {
+        | (Orders.OrderPlaced({orderId}), Some(placedAt)) => [
+            (orderId, ({orderId, dueAt: placedAt +. 3. *. day}: CancelUnshipped.todoItem)),
+          ]
+        | _ => []
+        }
+      let resolve = event =>
+        switch event {
+        | Orders.OrderShipped({orderId}) => Some(orderId)
+        | OrderPlaced(_) => None
+        }
+    },
+  )
+
+  let mappings: array<module(Mapping)> = [module(FromOrders)]
+
+  let process = (id, item: CancelUnshipped.todoItem, ~now) =>
+    now >= item.dueAt ? Some((id, CancelUnshipped.CancelOrder({orderId: item.orderId}))) : None
+  let onExhausted = (_id, _item: CancelUnshipped.todoItem) => None
+}
+
+open CancelUnshipped
+open CancelUnshipped_Automation
+include Automation_GWT.FromSlice(CancelUnshipped, CancelUnshipped_Automation)
+module O = Mapping(FromOrders)
+
+describe("a deadline at a fixed time", () => {
+  test("collect counts the due time from the event's recorded time", () =>
+    O.givenEvent(OrderPlaced({orderId: "o1"}))
+    ->O.whenCollect(~recordedAt=day0)
+    ->thenTodos([("o1", {orderId: "o1", dueAt: day0 +. 3. *. day})])
+  )
+
+  test("not yet due on day 2: no command", () =>
+    givenEvents([O.event(OrderPlaced({orderId: "o1"}))])
+    ->atTime(day0)
+    ->whenSweep(~now=day0 +. 2. *. day)
+    ->thenCommands([])
+  )
+
+  test("due on day 3: CancelOrder", () =>
+    givenEvents([O.event(OrderPlaced({orderId: "o1"}))])
+    ->atTime(day0)
+    ->whenSweep(~now=day0 +. 3. *. day)
+    ->thenCommands([("o1", CancelOrder({orderId: "o1"}))])
+  )
+
+  test("shipped on day 2: nothing on day 3", () =>
+    givenEvents([
+      O.event(OrderPlaced({orderId: "o1"}), ~recordedAt=day0),
+      O.event(OrderShipped({orderId: "o1"}), ~recordedAt=day0 +. 2. *. day),
+    ])
+    ->whenSweep(~now=day0 +. 3. *. day)
+    ->thenCommands([])
+  )
+
+  test("a sweep given no time runs when the events happened", () =>
+    givenEvents([O.event(OrderPlaced({orderId: "o1"}))])
+    ->atTime(day0)
+    ->whenSweep
+    ->thenCommands([])
+  )
+
+  test("process is given the time a scenario fixes", () =>
+    givenTodo("o1", {orderId: "o1", dueAt: day0})
+    ->whenProcess(~now=day0)
+    ->thenCommand("o1", CancelOrder({orderId: "o1"}))
+  )
+})

package/tests/AutomationDeadlineGwtTest.res.mjs

@@ -0,0 +1,267 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as AutomationSlice$Reventless from "@reventlessdev/reventless-spec/src/components/AutomationSlice.res.mjs";
+import * as Automation_GWT$ReventlessGwt from "../src/Automation_GWT.res.mjs";
+
+let todoItemSchema = Sury.$schema(s => ({
+  orderId: s.m(Sury.string),
+  dueAt: s.m(Sury.number)
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "CancelOrder",
+  orderId: s.m(Sury.string)
+}));
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let CancelUnshipped = {
+  name: "CancelUnshipped",
+  moduleUrl: "",
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 3,
+  heartbeatInterval: 60,
+  targetName: "Order",
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+let day = 24 * 60 * 60 * 1000;
+
+let day0 = new Date("2026-10-01T09:00:00Z").getTime();
+
+let M = AutomationSlice$Reventless.Mappings.Make(CancelUnshipped);
+
+let moduleUrl = "";
+
+let name = "Orders";
+
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "OrderShipped",
+    orderId: s.m(Sury.string)
+  }))
+]);
+
+let Orders = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+function collect(event, param, ctx) {
+  let match = ctx.recordedAt;
+  if (event.TAG !== "OrderPlaced") {
+    return [];
+  }
+  if (match === undefined) {
+    return [];
+  }
+  let orderId = event.orderId;
+  return [[
+      orderId,
+      {
+        orderId: orderId,
+        dueAt: match + 3 * day
+      }
+    ]];
+}
+
+function resolve(event) {
+  if (event.TAG === "OrderPlaced") {
+    return;
+  } else {
+    return event.orderId;
+  }
+}
+
+let FromOrders = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})(CancelUnshipped)({
+  collect: collect,
+  resolve: resolve
+});
+
+let mappings = [FromOrders];
+
+function process(id, item, now) {
+  if (now >= item.dueAt) {
+    return [
+      id,
+      {
+        TAG: "CancelOrder",
+        orderId: item.orderId
+      }
+    ];
+  }
+}
+
+function onExhausted(_id, _item) {
+  
+}
+
+let CancelUnshipped_Automation = {
+  M: M,
+  moduleUrl: moduleUrl,
+  Orders: Orders,
+  FromOrders: FromOrders,
+  mappings: mappings,
+  process: process,
+  onExhausted: onExhausted
+};
+
+let include = Automation_GWT$ReventlessGwt.FromSlice(CancelUnshipped)({
+  process: process,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl,
+  mappings: mappings
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let thenTodos = include.thenTodos;
+
+let Mapping = include.Mapping;
+
+let givenTodo = include.givenTodo;
+
+let whenProcess = include.whenProcess;
+
+let thenCommand = include.thenCommand;
+
+let givenEvents = include.givenEvents;
+
+let atTime = include.atTime;
+
+let whenSweep = include.whenSweep;
+
+let thenCommands = include.thenCommands;
+
+let O = Mapping(FromOrders);
+
+describe("a deadline at a fixed time", () => {
+  test("collect counts the due time from the event's recorded time", () => thenTodos(O.whenCollect(O.givenEvent({
+    TAG: "OrderPlaced",
+    orderId: "o1"
+  }), undefined, undefined, day0), [[
+      "o1",
+      {
+        orderId: "o1",
+        dueAt: day0 + 3 * day
+      }
+    ]]));
+  test("not yet due on day 2: no command", () => thenCommands(whenSweep(atTime(givenEvents([O.event({
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }, undefined, undefined)]), day0), undefined, day0 + 2 * day), []));
+  test("due on day 3: CancelOrder", () => thenCommands(whenSweep(atTime(givenEvents([O.event({
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }, undefined, undefined)]), day0), undefined, day0 + 3 * day), [[
+      "o1",
+      {
+        TAG: "CancelOrder",
+        orderId: "o1"
+      }
+    ]]));
+  test("shipped on day 2: nothing on day 3", () => thenCommands(whenSweep(givenEvents([
+    O.event({
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }, undefined, day0),
+    O.event({
+      TAG: "OrderShipped",
+      orderId: "o1"
+    }, undefined, day0 + 2 * day)
+  ]), undefined, day0 + 3 * day), []));
+  test("a sweep given no time runs when the events happened", () => thenCommands(whenSweep(atTime(givenEvents([O.event({
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }, undefined, undefined)]), day0), undefined, undefined), []));
+  test("process is given the time a scenario fixes", () => thenCommand(whenProcess(givenTodo("o1", {
+    orderId: "o1",
+    dueAt: day0
+  }), day0), "o1", {
+    TAG: "CancelOrder",
+    orderId: "o1"
+  }));
+});
+
+let Route = include.Route;
+
+let testContext = include.testContext;
+
+let withRecordedAt = include.withRecordedAt;
+
+let encTodos = include.encTodos;
+
+let encPair = include.encPair;
+
+let thenResolved = include.thenResolved;
+
+let whenExhausted = include.whenExhausted;
+
+let thenNoCommand = include.thenNoCommand;
+
+let latestRecorded = include.latestRecorded;
+
+let routeAll = include.routeAll;
+
+let sweep = include.sweep;
+
+let andThenEvents = include.andThenEvents;
+
+let thenScenarioTodos = include.thenScenarioTodos;
+
+export {
+  CancelUnshipped,
+  day,
+  day0,
+  CancelUnshipped_Automation,
+  Route,
+  describe,
+  test,
+  testContext,
+  withRecordedAt,
+  encTodos,
+  encPair,
+  thenTodos,
+  thenResolved,
+  Mapping,
+  givenTodo,
+  whenProcess,
+  whenExhausted,
+  thenCommand,
+  thenNoCommand,
+  givenEvents,
+  atTime,
+  latestRecorded,
+  routeAll,
+  sweep,
+  whenSweep,
+  thenCommands,
+  andThenEvents,
+  thenScenarioTodos,
+  O,
+}
+/* todoItemSchema Not a pure module */

package/tests/AutomationFromSliceGwtTest.res

@@ -79,7 +79,10 @@ module ShipPaid_Automation = {
 
   let mappings: array<module(Mapping)> = [module(FromOrders), module(FromPayments)]
 
-  let process = (id, _item: ShipPaid.todoItem) => Some((id, ShipPaid.Ship({orderId: id})))
+  let process = (id, _item: ShipPaid.todoItem, ~now as _) => Some((
+    id,
+    ShipPaid.Ship({orderId: id}),
+  ))
   let onExhausted = (id, _item: ShipPaid.todoItem) => Some((id, ShipPaid.GiveUp({orderId: id})))
 }
 

package/tests/AutomationFromSliceGwtTest.res.mjs

@@ -146,7 +146,7 @@ let mappings = [
   FromPayments
 ];
 
-function process(id, _item) {
+function process(id, _item, param) {
   return [
     id,
     {
@@ -221,7 +221,7 @@ describe("Automation_GWT.FromSlice", () => {
   test("collect through one mapping", () => thenTodos(O.whenCollect(O.givenEvent({
     TAG: "OrderPlaced",
     orderId: "o1"
-  }), undefined, undefined), [[
+  }), undefined, undefined, undefined), [[
       "o1",
       {
         orderId: "o1"
@@ -230,7 +230,7 @@ describe("Automation_GWT.FromSlice", () => {
   test("collect keys by the source id where the event does not name it", () => thenTodos(P.whenCollect(P.givenEvent({
     TAG: "Captured",
     amount: 5
-  }), "o2", undefined), [[
+  }), "o2", undefined, undefined), [[
       "o2",
       {
         orderId: "o2"
@@ -242,7 +242,7 @@ describe("Automation_GWT.FromSlice", () => {
   })), "o1"));
   test("process", () => thenCommand(whenProcess(givenTodo("o1", {
     orderId: "o1"
-  })), "o1", {
+  }), undefined), "o1", {
     TAG: "Ship",
     orderId: "o1"
   }));
@@ -256,12 +256,12 @@ describe("Automation_GWT.FromSlice", () => {
     P.event({
       TAG: "Captured",
       amount: 5
-    }, "o2"),
+    }, "o2", undefined),
     O.event({
       TAG: "OrderPlaced",
       orderId: "o1"
-    }, undefined)
-  ]), undefined), [
+    }, undefined, undefined)
+  ]), undefined, undefined), [
     [
       "o2",
       {
@@ -281,20 +281,20 @@ describe("Automation_GWT.FromSlice", () => {
     O.event({
       TAG: "OrderCancelled",
       orderId: "o1"
-    }, undefined),
+    }, undefined, undefined),
     O.event({
       TAG: "OrderPlaced",
       orderId: "o1"
-    }, undefined),
+    }, undefined, undefined),
     O.event({
       TAG: "OrderPlaced",
       orderId: "o3"
-    }, undefined),
+    }, undefined, undefined),
     O.event({
       TAG: "OrderCancelled",
       orderId: "o3"
-    }, undefined)
-  ]), undefined), [[
+    }, undefined, undefined)
+  ]), undefined, undefined), [[
       "o1",
       {
         orderId: "o1"
@@ -303,22 +303,28 @@ describe("Automation_GWT.FromSlice", () => {
   test("andThenEvents drains what later events resolve", () => thenScenarioTodos(andThenEvents(whenSweep(givenEvents([O.event({
       TAG: "OrderPlaced",
       orderId: "o1"
-    }, undefined)]), undefined), [O.event({
+    }, undefined, undefined)]), undefined, undefined), [O.event({
       TAG: "OrderCancelled",
       orderId: "o1"
-    }, undefined)], undefined), []));
+    }, undefined, undefined)], undefined), []));
 });
 
 let Route = include.Route;
 
 let testContext = include.testContext;
 
+let withRecordedAt = include.withRecordedAt;
+
 let encTodos = include.encTodos;
 
 let encPair = include.encPair;
 
 let thenNoCommand = include.thenNoCommand;
 
+let atTime = include.atTime;
+
+let latestRecorded = include.latestRecorded;
+
 let routeAll = include.routeAll;
 
 let sweep = include.sweep;
@@ -330,6 +336,7 @@ export {
   describe,
   test,
   testContext,
+  withRecordedAt,
   encTodos,
   encPair,
   thenTodos,
@@ -341,6 +348,8 @@ export {
   thenCommand,
   thenNoCommand,
   givenEvents,
+  atTime,
+  latestRecorded,
   routeAll,
   sweep,
   whenSweep,

package/tests/AutomationGwtTest.res

@@ -31,7 +31,7 @@ module ShipOrderSlice = {
     | _ => None
     }
 
-  let process = (_id, item) => Some((
+  let process = (_id, item, ~now as _) => Some((
     item.orderId,
     CreateShipment({orderId: item.orderId, address: item.shippingAddress}),
   ))

package/tests/AutomationGwtTest.res.mjs

@@ -49,7 +49,7 @@ function resolve(event) {
   }
 }
 
-function process(_id, item) {
+function process(_id, item, param) {
   return [
     item.orderId,
     {
@@ -139,7 +139,7 @@ describe("ShipOrder AutomationSlice", () => {
   test("process: pending TODO emits CreateShipment", () => thenCommand(whenProcess(givenTodo("o1", {
     orderId: "o1",
     shippingAddress: "1 Main St"
-  })), "o1", {
+  }), undefined), "o1", {
     TAG: "CreateShipment",
     orderId: "o1",
     address: "1 Main St"
@@ -149,7 +149,7 @@ describe("ShipOrder AutomationSlice", () => {
         TAG: "OrderPlaced",
         orderId: "o1",
         shippingAddress: "1 Main St"
-      }]));
+      }]), undefined);
     let commandsOk = thenCommands(s, [[
         "o1",
         {

package/tests/FlowGwtTest.res

@@ -73,7 +73,7 @@ module AutoShipSlice = {
     | OrderPlaced(_) => None
     }
 
-  let process = (id, _todo) => Some((id, ShipOrder({orderId: id})))
+  let process = (id, _todo, ~now as _) => Some((id, ShipOrder({orderId: id})))
   let onExhausted = (_id, _todo) => None
 }
 

package/tests/FlowGwtTest.res.mjs

@@ -122,7 +122,7 @@ function resolve(event) {
   }
 }
 
-function process(id, _todo) {
+function process(id, _todo, param) {
   return [
     id,
     {

package/tests/StateViewSliceGwtTest.res

@@ -50,4 +50,11 @@ describe("CategoriesView StateViewSlice", () => {
     ->whenEvent(CategoryRenamed({categoryId: "c1", name: "Consumer Electronics"}))
     ->thenStateWithId("c1", {categoryId: "c1", name: "Consumer Electronics", archived: false})
   )
+
+  // The rows under that id: another category's row, from a given event, is not this one's.
+  test("a second category gets its own row, the first one's left as it is", () =>
+    givenEvents([CategoryAdded({categoryId: "c1", name: "Electronics"})])
+    ->whenEvent(CategoryAdded({categoryId: "c2", name: "Garden"}))
+    ->thenStateWithId("c2", {categoryId: "c2", name: "Garden", archived: false})
+  )
 })

package/tests/StateViewSliceGwtTest.res.mjs

@@ -131,6 +131,19 @@ describe("CategoriesView StateViewSlice", () => {
     name: "Consumer Electronics",
     archived: false
   }));
+  test("a second category gets its own row, the first one's left as it is", undefined, () => thenStateWithId(whenEvent(givenEvents([{
+      TAG: "CategoryAdded",
+      categoryId: "c1",
+      name: "Electronics"
+    }]), {
+    TAG: "CategoryAdded",
+    categoryId: "c2",
+    name: "Garden"
+  }), "c2", {
+    categoryId: "c2",
+    name: "Garden",
+    archived: false
+  }));
 });
 
 let Spec = include.Spec;