@reventlessdev/reventless-gwt 1.0.0-alpha.242 → 1.0.0-alpha.244

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 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.244 (2026-10-16)
+
+* feat!(automation): schedules set by events ([53bc436](https://github.com/ReventlessDev/reventless-core/commit/53bc4363dffce81ef36475728bf0dae704716021))
+* feat!(automation): declared schedules tick an automation ([420acd2](https://github.com/ReventlessDev/reventless-core/commit/420acd2233aadf700141a31d9d3e0fdc8074bef7))
+
+### BREAKING CHANGES
+
+* a hand-written AutomationSlice.Mapping.Make the PPX does
+not see must define `let reschedule = _ => []`.
+* a hand-written AutomationSlice spec the PPX does not see must
+declare `let schedule = None`.
+
+
+
+# 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-gwt",
-  "version": "1.0.0-alpha.242",
+  "version": "1.0.0-alpha.244",
   "description": "Given-When-Then DSLs and test harness for Reventless slice testing",
   "license": "Apache-2.0",
   "jest": {
@@ -14,17 +14,17 @@
   },
   "dependencies": {
     "sury": "11.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.35",
+    "@reventlessdev/rescript-effect": "1.0.0-alpha.0",
     "@reventlessdev/rescript-node": "2.0.0-alpha.22",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.294",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.191",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.296",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.193",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.12",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.163"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.165"
   },
   "devDependencies": {
     "rescript": "12.3.1",
     "sury-ppx": "11.0.0",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.100"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.101"
   },
   "peerDependencies": {
     "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,13 +226,19 @@ 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)>,
     commands: array<(string, Spec.command)>,
+    /** The slice's schedule rows after the events, by key. */
+    schedules: dict<AutomationSlice_Schedules.row>,
   }
 
   let encTodos = (arr: array<(string, Spec.todoItem)>) =>
@@ -248,19 +263,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 +299,66 @@ 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
-  let routeAll = (events: array<sourced>, context) =>
-    events->Array.flatMap(e =>
-      Route.route(e.payload, ~sourceName=e.sourceName, ~sourceId=e.sourceId, context)
+  /** 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 routeEach = (events: array<sourced>, context) =>
+    events->Array.map(e => (
+      e,
+      Route.route(
+        e.payload,
+        ~sourceName=e.sourceName,
+        ~sourceId=e.sourceId,
+        context->withRecordedAt(e.recordedAt),
+      ),
+    ))
+  let routeAll = (events: array<sourced>, context) =>
+    routeEach(events, context)->Array.flatMap(((_, routed)) => routed)
+
+  /** Folds the events' `reschedule` into the rows as the runtime does; a tick
+      removes the once-only schedule it fired. A time that cannot fire changes
+      nothing, as at run time. */
+  let foldSchedules = (
+    rows,
+    routedEvents: array<(sourced, array<AutomationSlice_Route.routed<Spec.todoItem>>)>,
+    ~now,
+  ) =>
+    routedEvents->Array.forEach(((e, routed)) => {
+      let recordedAt = e.recordedAt->Option.getOr(now)
+      routed->Array.forEach(r =>
+        r.rescheduled->Array.forEach(
+          change => {
+            let _ = rows->AutomationSlice_Schedules.apply(change, ~setBy="scenario", ~recordedAt)
+          },
+        )
+      )
+      if e.sourceName == Reventless.Clock.name {
+        rows->AutomationSlice_Schedules.fired(~key=e.sourceId)
+      }
+    })
+
+  // The declared time is in the rows before any event, as a deploy put it there.
+  let declaredRows = (~now) => {
+    let rows = Dict.make()
+    rows->AutomationSlice_Schedules.declare(Spec.schedule, ~now)
+    rows
+  }
   /** 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,
+    ~schedules=declaredRows(~now),
+  ) => {
     let rows: array<(string, Spec.todoItem, ref<bool>)> = []
     routed->Array.forEach(r => {
       r.collected->Array.forEach(((id, item)) =>
@@ -306,9 +376,34 @@ 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)),
+      schedules,
+    }
+  }
+  let whenSweep = (events, ~context=testContext, ~now=?) => {
+    let now = switch (now, latestRecorded(events)) {
+    | (Some(now), _) | (None, Some(now)) => now
+    | (None, None) => clockNow()
+    }
+    let routedEvents = routeEach(events, context)
+    let schedules = declaredRows(~now)
+    schedules->foldSchedules(routedEvents, ~now)
+    sweep(routedEvents->Array.flatMap(((_, routed)) => routed), ~now, ~schedules)
   }
-  let whenSweep = (events, ~context=testContext) => sweep(routeAll(events, context))
+  /** A tick from one of the slice's schedules, as the `Clock` source delivers it:
+      `key` defaults to the declared schedule's. */
+  let tick = (~key=Reventless.Clock.defaultKey, at) => {
+    sourceName: Reventless.Clock.name,
+    sourceId: key,
+    payload: Reventless.Clock.Tick({key, at})->Message.encode(Reventless.Clock.eventSchema),
+    recordedAt: Some(at),
+  }
+  /** The given events, then a tick at `at`, swept at `at`: what the slice does when its
+      schedule comes due. A tick delivered twice makes one item. */
+  let whenTick = (events, ~key=?, ~at, ~context=testContext) =>
+    whenSweep(events->Array.concat([tick(~key?, at)]), ~context, ~now=at)
   let thenCommands = (scenario, expected) =>
     scenario.commands == expected
       ? Outcome.pass
@@ -319,8 +414,37 @@ module FromSlice = (
           }),
         )
   let andThenEvents = (scenario, events, ~context=testContext) => {
-    let resolved = routeAll(events, context)->Array.filterMap(r => r.resolved)
-    {...scenario, todos: scenario.todos->Array.filter(((id, _)) => !(resolved->Array.includes(id)))}
+    let routedEvents = routeEach(events, context)
+    let resolved =
+      routedEvents->Array.flatMap(((_, routed)) => routed)->Array.filterMap(r => r.resolved)
+    let schedules = scenario.schedules->Dict.copy
+    schedules->foldSchedules(routedEvents, ~now=latestRecorded(events)->Option.getOr(clockNow()))
+    {
+      ...scenario,
+      todos: scenario.todos->Array.filter(((id, _)) => !(resolved->Array.includes(id))),
+      schedules,
+    }
+  }
+  /** The slice's schedules after the scenario, by key: the declared time unless an
+      event replaced or cleared it, and every time an event set. An `After` an event
+      set is counted from when the event was recorded. */
+  let thenSchedules = (scenario, expected: array<(string, Reventless.Schedule.time)>) => {
+    let enc = ((key, time)) =>
+      JSON.Encode.object(
+        Dict.fromArray([
+          ("key", key->JSON.Encode.string),
+          ("time", time->Message.encode(Reventless.Schedule.timeSchema)),
+        ]),
+      )
+    let byKey = rows => rows->Array.toSorted(((a, _), (b, _)) => String.compare(a, b))
+    let actual =
+      scenario.schedules
+      ->Dict.valuesToArray
+      ->Array.filterMap(row => row->AutomationSlice_Schedules.timeOf->Option.map(t => (row.key, t)))
+      ->byKey
+      ->Array.map(enc)
+    let expected = expected->byKey->Array.map(enc)
+    actual == expected ? Outcome.pass : Outcome.fail(QueryRowsMismatch({expected, actual}))
   }
   let thenScenarioTodos = (scenario, expected) => thenTodos(scenario.todos, expected)
 }

package/src/Automation_GWT.res.mjs

@@ -1,13 +1,31 @@
 // 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 Clock$Reventless from "@reventlessdev/reventless-spec/src/components/Clock.res.mjs";
 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 Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Schedule$Reventless from "@reventlessdev/reventless-spec/src/types/Schedule.res.mjs";
 import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
 import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
 import * as AutomationSlice_Route$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Route.res.mjs";
+import * as AutomationSlice_Schedules$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Schedules.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);
@@ -53,7 +71,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 +116,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 +184,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 +226,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 +252,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 +278,56 @@ 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 routeEach = (events, context) => events.map(e => [
+      e,
+      Route.route(e.payload, e.sourceName, e.sourceId, withRecordedAt(context, e.recordedAt))
+    ]);
+    let routeAll = (events, context) => routeEach(events, context).flatMap(param => param[1]);
+    let foldSchedules = (rows, routedEvents, now) => {
+      routedEvents.forEach(param => {
+        let e = param[0];
+        let recordedAt = Stdlib_Option.getOr(e.recordedAt, now);
+        param[1].forEach(r => {
+          r.rescheduled.forEach(change => {
+            AutomationSlice_Schedules$ReventlessCore.apply(rows, change, "scenario", recordedAt);
+          });
+        });
+        if (e.sourceName === Clock$Reventless.name) {
+          return AutomationSlice_Schedules$ReventlessCore.fired(rows, e.sourceId);
+        }
+      });
+    };
+    let declaredRows = now => {
+      let rows = {};
+      AutomationSlice_Schedules$ReventlessCore.declare(rows, Spec.schedule, now);
+      return rows;
+    };
+    let sweep = (routed, now, schedulesOpt) => {
+      let schedules = schedulesOpt !== undefined ? schedulesOpt : declaredRows(now);
       let rows = [];
       routed.forEach(r => {
         r.collected.forEach(param => {
@@ -291,12 +364,37 @@ 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)),
+        schedules: schedules
+      };
+    };
+    let whenSweep = (events, contextOpt, now) => {
+      let context = contextOpt !== undefined ? contextOpt : testContext;
+      let match = latestRecorded(events);
+      let now$1 = now !== undefined ? now : (
+          match !== undefined ? match : Effect.runSync(Clock.currentTimeMillis)
+        );
+      let routedEvents = routeEach(events, context);
+      let schedules = declaredRows(now$1);
+      foldSchedules(schedules, routedEvents, now$1);
+      return sweep(routedEvents.flatMap(param => param[1]), now$1, schedules);
+    };
+    let tick = (keyOpt, at) => {
+      let key = keyOpt !== undefined ? keyOpt : Clock$Reventless.defaultKey;
+      return {
+        sourceName: Clock$Reventless.name,
+        sourceId: key,
+        payload: Message$ReventlessCore.encode({
+          TAG: "Tick",
+          key: key,
+          at: at
+        }, Clock$Reventless.eventSchema),
+        recordedAt: at
       };
     };
-    let whenSweep = (events, contextOpt) => {
+    let whenTick = (events, key, at, contextOpt) => {
       let context = contextOpt !== undefined ? contextOpt : testContext;
-      return sweep(routeAll(events, context));
+      return whenSweep(events.concat([tick(key, at)]), context, at);
     };
     let thenCommands = (scenario, expected) => {
       if (Primitive_object.equal(scenario.commands, expected)) {
@@ -311,18 +409,50 @@ function FromSlice(Spec) {
     };
     let andThenEvents = (scenario, events, contextOpt) => {
       let context = contextOpt !== undefined ? contextOpt : testContext;
-      let resolved = Stdlib_Array.filterMap(routeAll(events, context), r => r.resolved);
+      let routedEvents = routeEach(events, context);
+      let resolved = Stdlib_Array.filterMap(routedEvents.flatMap(param => param[1]), r => r.resolved);
+      let schedules = Object.assign({}, scenario.schedules);
+      foldSchedules(schedules, routedEvents, Stdlib_Option.getOr(latestRecorded(events), Effect.runSync(Clock.currentTimeMillis)));
       return {
         todos: scenario.todos.filter(param => !resolved.includes(param[0])),
-        commands: scenario.commands
+        commands: scenario.commands,
+        schedules: schedules
       };
     };
+    let thenSchedules = (scenario, expected) => {
+      let enc = param => Object.fromEntries([
+        [
+          "key",
+          param[0]
+        ],
+        [
+          "time",
+          Message$ReventlessCore.encode(param[1], Schedule$Reventless.timeSchema)
+        ]
+      ]);
+      let byKey = rows => rows.toSorted((param, param$1) => Primitive_string.compare(param[0], param$1[0]));
+      let actual = byKey(Stdlib_Array.filterMap(Object.values(scenario.schedules), row => Stdlib_Option.map(AutomationSlice_Schedules$ReventlessCore.timeOf(row), t => [
+        row.key,
+        t
+      ]))).map(enc);
+      let expected$1 = byKey(expected).map(enc);
+      if (Primitive_object.equal(actual, expected$1)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "QueryRowsMismatch",
+          expected: expected$1,
+          actual: actual
+        });
+      }
+    };
     let thenScenarioTodos = (scenario, expected) => thenTodos(scenario.todos, expected);
     return {
       Route: Route,
       describe: JestBind$ReventlessGwt.describe,
       test: test,
       testContext: testContext,
+      withRecordedAt: withRecordedAt,
       encTodos: encTodos,
       encPair: encPair,
       thenTodos: thenTodos,
@@ -334,18 +464,28 @@ function FromSlice(Spec) {
       thenCommand: thenCommand,
       thenNoCommand: thenNoCommand,
       givenEvents: givenEvents,
+      atTime: atTime,
+      latestRecorded: latestRecorded,
+      routeEach: routeEach,
       routeAll: routeAll,
+      foldSchedules: foldSchedules,
+      declaredRows: declaredRows,
       sweep: sweep,
       whenSweep: whenSweep,
+      tick: tick,
+      whenTick: whenTick,
       thenCommands: thenCommands,
       andThenEvents: andThenEvents,
+      thenSchedules: thenSchedules,
       thenScenarioTodos: thenScenarioTodos
     };
   };
 }
 
 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(), undefined);
       return {
         log: s.log,
         outcome: s.outcome,