@reventlessdev/reventless-core 3.0.0-alpha.294 → 3.0.0-alpha.296

package/tests/admin/AdminApiSchemaDriftTest.res

@@ -120,6 +120,7 @@ let automation: automationSliceDef = {
   producedCommandTypes: ["Restock"],
   targetName: "Product",
   chapter: Some("Replenishment"),
+  schedule: `{"TAG":"Every","_0":{"TAG":"Minutes","_0":15}}`,
 }
 
 let outbound: outboundTranslationSliceDef = {

package/tests/admin/AdminApiSchemaDriftTest.res.mjs

@@ -184,12 +184,15 @@ let automation_producedCommandTypes = ["Restock"];
 
 let automation_chapter = "Replenishment";
 
+let automation_schedule = `{"TAG":"Every","_0":{"TAG":"Minutes","_0":15}}`;
+
 let automation = {
   name: "Restocker",
   consumedEventTypes: automation_consumedEventTypes,
   producedCommandTypes: automation_producedCommandTypes,
   targetName: "Product",
-  chapter: automation_chapter
+  chapter: automation_chapter,
+  schedule: automation_schedule
 };
 
 let outbound_consumedEventTypes = ["OrderPlaced"];

package/tests/automationslice/AutomationSliceSchedulesTest.res

@@ -0,0 +1,143 @@
+// A slice's schedule rows, and how the platform is brought in line with them: the
+// declared time is written unless an event set or cleared the slice-wide key, the
+// platform gets what it is missing and loses what the rows do not hold, and a
+// once-only time already past is not put again.
+
+open JestGlobals
+
+module Schedules = AutomationSlice_Schedules
+
+let at = iso => Date.fromString(iso)->Date.getTime
+let daily6 = Reventless.Schedule.Calendar({calendar: Daily({hour: 6, minute: 0})})
+let daily18 = Reventless.Schedule.Calendar({calendar: Daily({hour: 18, minute: 0})})
+let now = at("2026-10-16T12:00:00Z")
+
+// A platform that holds its schedules in a dict and records what it was told.
+let fakePlatform = (~held: array<string>=[]) => {
+  let schedules = Dict.fromArray(held->Array.map(name => (name, daily6)))
+  let calls = []
+  let platform: ReventlessInfra.AutomationSlice.platformSchedules = {
+    put: async (~key, time) => {
+      calls->Array.push(`put ${key}`)
+      schedules->Dict.set(key, time)
+    },
+    removeName: async name => {
+      calls->Array.push(`remove ${name}`)
+      schedules->Dict.delete(name)
+    },
+    names: async () => schedules->Dict.keysToArray,
+    nameOf: key => key,
+  }
+  (platform, schedules, calls)
+}
+
+let liveKeys = rows =>
+  rows
+  ->Dict.valuesToArray
+  ->Array.filter(row => row.Schedules.time->Option.isSome)
+  ->Array.map(row => row.key)
+  ->Array.toSorted(String.compare)
+
+let set = (rows, key, time, ~recordedAt=now) =>
+  rows->Schedules.apply(Set({key, time}), ~setBy="event", ~recordedAt)
+let clear = (rows, key) => rows->Schedules.apply(Clear({key: key}), ~setBy="event", ~recordedAt=now)
+
+describe("the declared time", () => {
+  testSync("is written when no event has touched the slice-wide key", () => {
+    let rows = Dict.make()
+    rows->Schedules.declare(Some(daily6), ~now)
+    expect(rows->Dict.get("default")->Option.flatMap(Schedules.timeOf))->toEqual(Some(daily6))
+  })
+
+  testSync("does not replace a time an event set", () => {
+    let rows = Dict.make()
+    let _ = rows->set("default", daily18)
+    rows->Schedules.declare(Some(daily6), ~now)
+    expect(rows->Dict.get("default")->Option.flatMap(Schedules.timeOf))->toEqual(Some(daily18))
+  })
+
+  testSync("does not come back after an event cleared it", () => {
+    let rows = Dict.make()
+    rows->Schedules.declare(Some(daily6), ~now)
+    let _ = rows->clear("default")
+    rows->Schedules.declare(Some(daily6), ~now)
+    expect(rows->liveKeys)->toEqual([])
+  })
+
+  testSync("follows a changed declaration, and goes with it", () => {
+    let rows = Dict.make()
+    rows->Schedules.declare(Some(daily6), ~now)
+    rows->Schedules.declare(Some(daily18), ~now)
+    let changed = rows->Dict.get("default")->Option.flatMap(Schedules.timeOf)
+    rows->Schedules.declare(None, ~now)
+    expect((changed, rows->liveKeys))->toEqual((Some(daily18), []))
+  })
+})
+
+describe("a change an event makes", () => {
+  testSync("counts an After from when the event was recorded", () => {
+    let rows = Dict.make()
+    let _ =
+      rows->set("o1", Once({moment: After(Minutes(10))}), ~recordedAt=at("2026-10-16T09:00:00Z"))
+    expect(rows->Dict.get("o1")->Option.flatMap(Schedules.timeOf))->toEqual(
+      Some(
+        Reventless.Schedule.Once({
+          moment: At({year: 2026, month: 10, day: 16, hour: 9, minute: 10}),
+        }),
+      ),
+    )
+  })
+
+  testSync("refuses a time that cannot fire, and changes nothing", () => {
+    let rows = Dict.make()
+    let refused = rows->set("r1", Calendar({calendar: Daily({hour: 25, minute: 0})}))
+    expect((refused->Result.isError, rows->liveKeys))->toEqual((true, []))
+  })
+
+  testSync("removes a once-only schedule when it fires, not a recurring one", () => {
+    let rows = Dict.make()
+    let _ = rows->set("o1", Once({moment: After(Minutes(10))}))
+    let _ = rows->set("r1", daily18)
+    rows->Schedules.fired(~key="o1")
+    rows->Schedules.fired(~key="r1")
+    expect(rows->liveKeys)->toEqual(["r1"])
+  })
+})
+
+describe("the reconcile", () => {
+  testPromise(
+    "puts what the platform is missing and removes what the rows do not hold",
+    async () => {
+      let rows = Dict.make()
+      let _ = rows->set("r1", daily18)
+      let _ = rows->set("r2", daily18)
+      let (platform, held, _) = fakePlatform(~held=["r2", "stray"])
+      await rows->Schedules.reconcile(platform, ~declaredTime=None, ~now)
+      expect(held->Dict.keysToArray->Array.toSorted(String.compare))->toEqual(["r1", "r2"])
+    },
+  )
+
+  testPromise("does not put again a schedule an event set and the platform holds", async () => {
+    let rows = Dict.make()
+    let _ = rows->set("r1", daily18)
+    let (platform, _, calls) = fakePlatform(~held=["r1"])
+    await rows->Schedules.reconcile(platform, ~declaredTime=None, ~now)
+    expect(calls)->toEqual([])
+  })
+
+  testPromise("puts the declared time again, in case it changed", async () => {
+    let rows = Dict.make()
+    let (platform, _, calls) = fakePlatform(~held=["default"])
+    await rows->Schedules.reconcile(platform, ~declaredTime=Some(daily6), ~now)
+    expect(calls)->toEqual(["put default"])
+  })
+
+  testPromise("drops a once-only time already past, from the rows and the platform", async () => {
+    let rows = Dict.make()
+    let _ =
+      rows->set("o1", Once({moment: After(Minutes(10))}), ~recordedAt=at("2026-10-16T09:00:00Z"))
+    let (platform, held, _) = fakePlatform(~held=["o1"])
+    await rows->Schedules.reconcile(platform, ~declaredTime=None, ~now)
+    expect((rows->liveKeys, held->Dict.keysToArray))->toEqual(([], []))
+  })
+})

package/tests/automationslice/AutomationSliceSchedulesTest.res.mjs

@@ -0,0 +1,247 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as AutomationSlice_Schedules$ReventlessCore from "../../src/components/AutomationSlice/AutomationSlice_Schedules.res.mjs";
+
+function at(iso) {
+  return new Date(iso).getTime();
+}
+
+let daily6 = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 6,
+    minute: 0
+  }
+};
+
+let daily18 = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 18,
+    minute: 0
+  }
+};
+
+let now = new Date("2026-10-16T12:00:00Z").getTime();
+
+function fakePlatform(heldOpt) {
+  let held = heldOpt !== undefined ? heldOpt : [];
+  let schedules = Object.fromEntries(held.map(name => [
+    name,
+    daily6
+  ]));
+  let calls = [];
+  let platform_put = async (key, time) => {
+    calls.push(`put ` + key);
+    schedules[key] = time;
+  };
+  let platform_removeName = async name => {
+    calls.push(`remove ` + name);
+    return Stdlib_Dict.$$delete(schedules, name);
+  };
+  let platform_names = async () => Object.keys(schedules);
+  let platform_nameOf = key => key;
+  let platform = {
+    put: platform_put,
+    removeName: platform_removeName,
+    names: platform_names,
+    nameOf: platform_nameOf
+  };
+  return [
+    platform,
+    schedules,
+    calls
+  ];
+}
+
+function liveKeys(rows) {
+  return Object.values(rows).filter(row => Stdlib_Option.isSome(row.time)).map(row => row.key).toSorted(Primitive_string.compare);
+}
+
+function set(rows, key, time, recordedAtOpt) {
+  let recordedAt = recordedAtOpt !== undefined ? recordedAtOpt : now;
+  return AutomationSlice_Schedules$ReventlessCore.apply(rows, {
+    TAG: "Set",
+    key: key,
+    time: time
+  }, "event", recordedAt);
+}
+
+function clear(rows, key) {
+  return AutomationSlice_Schedules$ReventlessCore.apply(rows, {
+    TAG: "Clear",
+    key: key
+  }, "event", now);
+}
+
+globalThis.describe("the declared time", () => {
+  globalThis.test("is written when no event has touched the slice-wide key", () => {
+    let rows = {};
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    globalThis.expect(Stdlib_Option.flatMap(rows["default"], AutomationSlice_Schedules$ReventlessCore.timeOf)).toEqual(daily6);
+  });
+  globalThis.test("does not replace a time an event set", () => {
+    let rows = {};
+    set(rows, "default", daily18, undefined);
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    globalThis.expect(Stdlib_Option.flatMap(rows["default"], AutomationSlice_Schedules$ReventlessCore.timeOf)).toEqual(daily18);
+  });
+  globalThis.test("does not come back after an event cleared it", () => {
+    let rows = {};
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    clear(rows, "default");
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    globalThis.expect(liveKeys(rows)).toEqual([]);
+  });
+  globalThis.test("follows a changed declaration, and goes with it", () => {
+    let rows = {};
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily6, now);
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, daily18, now);
+    let changed = Stdlib_Option.flatMap(rows["default"], AutomationSlice_Schedules$ReventlessCore.timeOf);
+    AutomationSlice_Schedules$ReventlessCore.declare(rows, undefined, now);
+    globalThis.expect([
+      changed,
+      liveKeys(rows)
+    ]).toEqual([
+      daily18,
+      []
+    ]);
+  });
+});
+
+globalThis.describe("a change an event makes", () => {
+  globalThis.test("counts an After from when the event was recorded", () => {
+    let rows = {};
+    set(rows, "o1", {
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: {
+          TAG: "Minutes",
+          _0: 10
+        }
+      }
+    }, new Date("2026-10-16T09:00:00Z").getTime());
+    globalThis.expect(Stdlib_Option.flatMap(rows["o1"], AutomationSlice_Schedules$ReventlessCore.timeOf)).toEqual({
+      TAG: "Once",
+      moment: {
+        TAG: "At",
+        _0: {
+          year: 2026,
+          month: 10,
+          day: 16,
+          hour: 9,
+          minute: 10
+        }
+      }
+    });
+  });
+  globalThis.test("refuses a time that cannot fire, and changes nothing", () => {
+    let rows = {};
+    let refused = set(rows, "r1", {
+      TAG: "Calendar",
+      calendar: {
+        TAG: "Daily",
+        hour: 25,
+        minute: 0
+      }
+    }, undefined);
+    globalThis.expect([
+      Stdlib_Result.isError(refused),
+      liveKeys(rows)
+    ]).toEqual([
+      true,
+      []
+    ]);
+  });
+  globalThis.test("removes a once-only schedule when it fires, not a recurring one", () => {
+    let rows = {};
+    set(rows, "o1", {
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: {
+          TAG: "Minutes",
+          _0: 10
+        }
+      }
+    }, undefined);
+    set(rows, "r1", daily18, undefined);
+    AutomationSlice_Schedules$ReventlessCore.fired(rows, "o1");
+    AutomationSlice_Schedules$ReventlessCore.fired(rows, "r1");
+    globalThis.expect(liveKeys(rows)).toEqual(["r1"]);
+  });
+});
+
+globalThis.describe("the reconcile", () => {
+  globalThis.test("puts what the platform is missing and removes what the rows do not hold", async () => {
+    let rows = {};
+    set(rows, "r1", daily18, undefined);
+    set(rows, "r2", daily18, undefined);
+    let match = fakePlatform([
+      "r2",
+      "stray"
+    ]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], undefined, now);
+    globalThis.expect(Object.keys(match[1]).toSorted(Primitive_string.compare)).toEqual([
+      "r1",
+      "r2"
+    ]);
+  });
+  globalThis.test("does not put again a schedule an event set and the platform holds", async () => {
+    let rows = {};
+    set(rows, "r1", daily18, undefined);
+    let match = fakePlatform(["r1"]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], undefined, now);
+    globalThis.expect(match[2]).toEqual([]);
+  });
+  globalThis.test("puts the declared time again, in case it changed", async () => {
+    let rows = {};
+    let match = fakePlatform(["default"]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], daily6, now);
+    globalThis.expect(match[2]).toEqual(["put default"]);
+  });
+  globalThis.test("drops a once-only time already past, from the rows and the platform", async () => {
+    let rows = {};
+    set(rows, "o1", {
+      TAG: "Once",
+      moment: {
+        TAG: "After",
+        _0: {
+          TAG: "Minutes",
+          _0: 10
+        }
+      }
+    }, new Date("2026-10-16T09:00:00Z").getTime());
+    let match = fakePlatform(["o1"]);
+    await AutomationSlice_Schedules$ReventlessCore.reconcile(rows, match[0], undefined, now);
+    globalThis.expect([
+      liveKeys(rows),
+      Object.keys(match[1])
+    ]).toEqual([
+      [],
+      []
+    ]);
+  });
+});
+
+let Schedules;
+
+export {
+  Schedules,
+  at,
+  daily6,
+  daily18,
+  now,
+  fakePlatform,
+  liveKeys,
+  set,
+  clear,
+}
+/* now Not a pure module */

package/tests/util/ScheduleTimeTest.res

@@ -0,0 +1,256 @@
+// When each shape of a Schedule.time fires, and that the AWS expression of a calendar
+// time names the same firings the local timer waits for.
+
+open JestGlobals
+open Reventless.Schedule
+
+let at = iso => Date.fromString(iso)->Date.getTime
+let iso = millis => millis->Date.fromTime->Date.toISOString
+
+/** The first `n` firings of `time` after `from`, in UTC. */
+let firings = (time, ~from, ~n) => {
+  let out = []
+  let rec loop = after =>
+    switch out->Array.length < n ? ScheduleTime.nextFiring(time, ~after) : None {
+    | Some(next) =>
+      out->Array.push(next->iso)
+      loop(next)
+    | None => ()
+    }
+  loop(from->at)
+  out
+}
+
+describe("ScheduleTime.nextFiring", () => {
+  testSync("Every counts from the previous firing, with no zone", () => {
+    expect(firings(Every(Hours(2)), ~from="2026-03-29T00:30:00Z", ~n=2))->toEqual([
+      "2026-03-29T02:30:00.000Z",
+      "2026-03-29T04:30:00.000Z",
+    ])
+  })
+
+  testSync("Daily is a wall-clock time in its zone, across both daylight-saving changes", () => {
+    let daily = Calendar({calendar: Daily({hour: 6, minute: 0}), zone: "Europe/Berlin"})
+    expect(firings(daily, ~from="2026-03-28T12:00:00Z", ~n=2))->toEqual([
+      "2026-03-29T04:00:00.000Z",
+      "2026-03-30T04:00:00.000Z",
+    ])
+    expect(firings(daily, ~from="2026-10-24T12:00:00Z", ~n=2))->toEqual([
+      "2026-10-25T05:00:00.000Z",
+      "2026-10-26T05:00:00.000Z",
+    ])
+  })
+
+  testSync("a time in the skipped hour does not fire that day; in the repeated hour, once", () => {
+    let night = Calendar({calendar: Daily({hour: 2, minute: 30}), zone: "Europe/Berlin"})
+    expect(firings(night, ~from="2026-03-27T12:00:00Z", ~n=2))->toEqual([
+      "2026-03-28T01:30:00.000Z",
+      "2026-03-30T00:30:00.000Z",
+    ])
+    expect(firings(night, ~from="2026-10-24T12:00:00Z", ~n=2))->toEqual([
+      "2026-10-25T00:30:00.000Z",
+      "2026-10-26T01:30:00.000Z",
+    ])
+  })
+
+  testSync("Weekly fires on its days only", () => {
+    let weekdays = Calendar({calendar: Weekly({days: [Mon, Fri], hour: 7, minute: 30})})
+    expect(firings(weekdays, ~from="2026-10-16T08:00:00Z", ~n=3))->toEqual([
+      "2026-10-19T07:30:00.000Z",
+      "2026-10-23T07:30:00.000Z",
+      "2026-10-26T07:30:00.000Z",
+    ])
+  })
+
+  testSync("Monthly on the 29th to 31st skips the months without that day", () => {
+    let on = day => Calendar({calendar: Monthly({day, hour: 6, minute: 0})})
+    expect(firings(on(29), ~from="2027-01-30T00:00:00Z", ~n=1))->toEqual([
+      "2027-03-29T06:00:00.000Z",
+    ])
+    expect(firings(on(30), ~from="2027-01-31T00:00:00Z", ~n=1))->toEqual([
+      "2027-03-30T06:00:00.000Z",
+    ])
+    expect(firings(on(31), ~from="2026-04-01T00:00:00Z", ~n=2))->toEqual([
+      "2026-05-31T06:00:00.000Z",
+      "2026-07-31T06:00:00.000Z",
+    ])
+  })
+
+  testSync("Monthly with every fires every so many months, from January", () => {
+    let quarterly = Calendar({calendar: Monthly({day: 1, hour: 6, minute: 0, every: 3})})
+    expect(firings(quarterly, ~from="2026-02-15T00:00:00Z", ~n=4))->toEqual([
+      "2026-04-01T06:00:00.000Z",
+      "2026-07-01T06:00:00.000Z",
+      "2026-10-01T06:00:00.000Z",
+      "2027-01-01T06:00:00.000Z",
+    ])
+  })
+
+  testSync("Yearly on 29 February fires in leap years", () => {
+    let leap = Calendar({calendar: Yearly({month: 2, day: 29, hour: 6, minute: 0})})
+    expect(firings(leap, ~from="2026-01-01T00:00:00Z", ~n=2))->toEqual([
+      "2028-02-29T06:00:00.000Z",
+      "2032-02-29T06:00:00.000Z",
+    ])
+  })
+
+  testSync("Once at a local time fires once, read in its zone; once past, never", () => {
+    let newYear = Once({
+      moment: At({year: 2026, month: 12, day: 31, hour: 23, minute: 59}),
+      zone: "Europe/Berlin",
+    })
+    expect(firings(newYear, ~from="2026-10-16T00:00:00Z", ~n=3))->toEqual([
+      "2026-12-31T22:59:00.000Z",
+    ])
+    expect(firings(newYear, ~from="2027-01-01T00:00:00Z", ~n=1))->toEqual([])
+  })
+})
+
+describe("ScheduleTime.resolveOnce", () => {
+  let resolved = (period, ~from, ~zone="UTC") =>
+    switch Once({moment: After(period), zone})->ScheduleTime.resolveOnce(~from=from->at) {
+    | Once({moment: At(localTime)}) => Some(localTime)
+    | _ => None
+    }
+
+  testSync("a month from 31 January is the last day of February", () => {
+    expect(resolved(Months(1), ~from="2026-01-31T09:00:00Z"))->toEqual(
+      Some({year: 2026, month: 2, day: 28, hour: 9, minute: 0}),
+    )
+  })
+
+  testSync("a day keeps the wall-clock time across a daylight-saving change", () => {
+    expect(resolved(Days(1), ~from="2026-03-28T05:00:00Z", ~zone="Europe/Berlin"))->toEqual(
+      Some({year: 2026, month: 3, day: 29, hour: 6, minute: 0}),
+    )
+  })
+
+  testSync("24 hours are elapsed time across the same change", () => {
+    expect(resolved(Hours(24), ~from="2026-03-28T05:00:00Z", ~zone="Europe/Berlin"))->toEqual(
+      Some({year: 2026, month: 3, day: 29, hour: 7, minute: 0}),
+    )
+  })
+
+  testSync("minutes are counted from the moment it is set, to the minute", () => {
+    expect(resolved(Minutes(10), ~from="2026-10-15T14:02:37Z"))->toEqual(
+      Some({year: 2026, month: 10, day: 15, hour: 14, minute: 12}),
+    )
+  })
+})
+
+describe("ScheduleTime.toAws", () => {
+  let setAt = "2026-10-15T14:02:00Z"->at
+
+  testSync("an interval is a rate, starting one interval later", () => {
+    let aws = Every(Weeks(2))->ScheduleTime.toAws(~setAt)
+    expect(aws.expression)->toBe("rate(14 days)")
+    expect(aws.startDate)->toEqual(Some(setAt +. 14. *. 24. *. 60. *. 60_000.))
+    expect(aws.timezone)->toEqual(None)
+    expect((Every(Minutes(1))->ScheduleTime.toAws(~setAt)).expression)->toBe("rate(1 minute)")
+  })
+
+  testSync("a calendar time is a cron with its zone, UTC when it has none", () => {
+    let daily = Calendar({calendar: Daily({hour: 6, minute: 0})})->ScheduleTime.toAws(~setAt)
+    expect(daily.expression)->toBe("cron(0 6 * * ? *)")
+    expect(daily.timezone)->toEqual(Some("UTC"))
+    let weekly = Calendar({
+      calendar: Weekly({days: [Mon, Tue, Wed, Thu, Fri], hour: 7, minute: 30}),
+      zone: "Europe/Berlin",
+    })->ScheduleTime.toAws(~setAt)
+    expect(weekly.expression)->toBe("cron(30 7 ? * MON,TUE,WED,THU,FRI *)")
+    expect(weekly.timezone)->toEqual(Some("Europe/Berlin"))
+    expect(
+      (
+        Calendar({calendar: Monthly({day: 1, hour: 6, minute: 0, every: 3})})->ScheduleTime.toAws(
+          ~setAt,
+        )
+      ).expression,
+    )->toBe("cron(0 6 1 1/3 ? *)")
+    expect(
+      (
+        Calendar({calendar: Yearly({month: 12, day: 24, hour: 18, minute: 0})})->ScheduleTime.toAws(
+          ~setAt,
+        )
+      ).expression,
+    )->toBe("cron(0 18 24 12 ? *)")
+  })
+
+  testSync("a once-only time is an at in its zone, deleted after it fires", () => {
+    let aws = Once({moment: After(Days(3)), zone: "Europe/Berlin"})->ScheduleTime.toAws(~setAt)
+    expect(aws.expression)->toBe("at(2026-10-18T16:02:00)")
+    expect(aws.timezone)->toEqual(Some("Europe/Berlin"))
+    expect(aws.deleteAfterCompletion)->toBe(true)
+  })
+})
+
+describe("the two platforms agree", () => {
+  // The AWS cron, read as the five-field expression Effect parses, and the local
+  // nextFiring give the same next ten firings. Daylight saving is AWS's documented rule.
+  let fromAws = (calendar, ~zone) => {
+    let fields =
+      calendar
+      ->ScheduleTime.cronExpressionOf
+      ->String.slice(~start=5, ~end=-1)
+      ->String.split(" ")
+      ->Array.map(f => f == "?" ? "*" : f)
+    let expression = fields->Array.slice(~start=0, ~end=5)->Array.join(" ")
+    let tz = ScheduleTime.zoneOrThrow(zone)
+    let (hour, minute) = calendar->ScheduleTime.wallClockOf
+    let cron = Cron.parseOrThrow(expression, tz)
+    let out = []
+    let rec loop = after =>
+      if out->Array.length < 10 {
+        let next = cron->ScheduleTime.nextOnWallClock(~after, ~hour, ~minute, ~zone=tz)
+        out->Array.push(next->iso)
+        loop(next)
+      }
+    loop("2026-01-01T00:00:00Z"->at)
+    out
+  }
+
+  let cases: array<(string, calendar, string)> = [
+    ("daily", Daily({hour: 6, minute: 0}), "UTC"),
+    ("daily in the skipped hour", Daily({hour: 2, minute: 30}), "Europe/Berlin"),
+    (
+      "weekdays",
+      Weekly({days: [Mon, Tue, Wed, Thu, Fri], hour: 7, minute: 30}),
+      "America/New_York",
+    ),
+    ("weekends", Weekly({days: [Sat, Sun], hour: 23, minute: 59}), "Australia/Sydney"),
+    ("monthly on the 31st", Monthly({day: 31, hour: 6, minute: 0}), "Europe/Berlin"),
+    ("quarterly", Monthly({day: 15, hour: 9, minute: 15, every: 3}), "Asia/Kolkata"),
+    ("every five months", Monthly({day: 1, hour: 0, minute: 0, every: 5}), "UTC"),
+    ("yearly", Yearly({month: 3, day: 29, hour: 2, minute: 30}), "Europe/London"),
+  ]
+
+  cases->Array.forEach(((label, calendar, zone)) =>
+    testSync(
+      label,
+      () => {
+        expect(fromAws(calendar, ~zone))->toEqual(
+          firings(Calendar({calendar, zone}), ~from="2026-01-01T00:00:00Z", ~n=10),
+        )
+      },
+    )
+  )
+})
+
+describe("ScheduleTime.validate", () => {
+  testSync("names every problem of a time", () => {
+    let message = switch ScheduleTime.validate(
+      Calendar({calendar: Weekly({days: [], hour: 24, minute: 0}), zone: "Mars/Base"}),
+    ) {
+    | () => ""
+    | exception ScheduleTime.InvalidTime(message) => message
+    }
+    expect(
+      message,
+    )->toBe(`unknown time zone "Mars/Base"; a weekly time needs at least one day; hour must be 0 to 23, got 24`)
+  })
+
+  testSync("accepts a time that can fire", () => {
+    expect(
+      ScheduleTime.errors(Once({moment: After(Years(1)), zone: "Pacific/Auckland"})),
+    )->toEqual([])
+  })
+})