@reventlessdev/reventless-core 3.0.0-alpha.293 → 3.0.0-alpha.295

package/CHANGELOG.md

@@ -3,6 +3,33 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.295 (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))
+* feat!: schedules take a Schedule.time, run on EventBridge Scheduler on AWS ([2d74557](https://github.com/ReventlessDev/reventless-core/commit/2d74557a6304917ded8f2b9f4107af9298c91ac0))
+### Features
+
+* **local:** sweep pending automation items, as AWS does ([96acec0](https://github.com/ReventlessDev/reventless-core/commit/96acec0ba226ee560790bd14b6fd38e44328a47c))
+
+### 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.
+* Schedule.rate is replaced by Schedule.time, and a
+schedule's `rate` field is now `time`. A once-only time already past
+never fires, locally as on AWS.
+
+
+
+# 3.0.0-alpha.294 (2026-10-12)
+
+**Note:** Version bump only for package @reventlessdev/reventless-core
+
+
+
+
+
 # 3.0.0-alpha.293 (2026-10-10)
 
 * feat!: a command's rule is looked up by its name, without a cast ([5f02c40](https://github.com/ReventlessDev/reventless-core/commit/5f02c4081d077bf4a6951d8c9b2b16553a8ca87b))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.293",
+  "version": "3.0.0-alpha.295",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,22 +28,22 @@
   "dependencies": {
     "sury": "11.0.0",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.11",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.34",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.22",
+    "@reventlessdev/rescript-effect": "1.0.0-alpha.0",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.15",
     "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.22",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.12",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.23",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.23",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.22",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.39",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.162",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.190"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.192",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.40",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.164"
   },
   "devDependencies": {
     "rescript": "12.3.1",
     "sury-ppx": "11.0.0",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.99"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.100"
   },
   "peerDependencies": {
     "rescript": "^12.3.1"

package/src/components/AutomationSlice/AutomationSlice_Builder.res

@@ -190,12 +190,20 @@ module Make = (
         })
 
       self->Component.setOperations(
-        (eventCollector->Pulumi.Output.flatMap(ec => ec->Component.operations), publishJsons)
-        ->Pulumi.Output.all2
-        ->Pulumi.Output.apply(((ecOps, publishJsonsFn)) => {
+        (
+          eventCollector->Pulumi.Output.flatMap(ec => ec->Component.operations),
+          publishJsons,
+          queryDb->Component.operations,
+        )
+        ->Pulumi.Output.all3
+        ->Pulumi.Output.apply(((ecOps, publishJsonsFn, queryDbOps)) => {
           let ops: AutomationSlice.operations = {
             enqueueEvent: ecOps.enqueueEvent,
-            processPending: async () => await Callback.phase2(publishJsonsFn),
+            // As the AWS sweep does: the rows phase 2 moved are written back.
+            processPending: async () => {
+              await Callback.phase2(publishJsonsFn)
+              await syncToQueryDb(queryDbOps)
+            },
           }
           ops
         }),

package/src/components/AutomationSlice/AutomationSlice_Builder.res.mjs

@@ -95,12 +95,17 @@ function Make(RuntimeEnvironment) {
         });
         Component$ReventlessCore.setOperations(extra, Pulumi.all([
           Output$Pulumi.flatMap(eventCollector, Component$ReventlessCore.operations),
-          publishJsons
+          publishJsons,
+          Component$ReventlessCore.operations(queryDb)
         ]).apply(param => {
+          let queryDbOps = param[2];
           let publishJsonsFn = param[1];
           return {
             enqueueEvent: param[0].enqueueEvent,
-            processPending: async () => await Callback.phase2(publishJsonsFn)
+            processPending: async () => {
+              await Callback.phase2(publishJsonsFn);
+              return await syncToQueryDb(queryDbOps);
+            }
           };
         }));
         let aggregatedResources = Object.values(eventTopics).flatMap(t => t.resources);

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -168,6 +168,13 @@ module Make = (
 
   module Route = AutomationSlice_Route.Make(Spec, Automation)
 
+  // An event's recorded time, from its envelope's ISO `meta.time`.
+  let recordedAtOf = time =>
+    switch Date.fromString(time)->Date.getTime {
+    | millis if Float.isNaN(millis) => None
+    | millis => Some(millis)
+    }
+
   let apply = ({collected, resolved}: AutomationSlice_Route.routed<Spec.todoItem>) => {
     // Collect — append new items keyed by ID; first writer wins (idempotent).
     collected->Array.forEach(((id, item)) => {
@@ -194,9 +201,13 @@ module Make = (
     )
   }
 
-  let phase1 = (events: array<JSON.t>, ctx: Reventless.AutomationSlice.context) => {
+  let phase1 = (events: array<JSON.t>, sliceCtx: Reventless.AutomationSlice.context) => {
     events->Array.forEach(json => {
       let context = json->Message.decode(Reventless.Message.contextSchema)
+      let ctx = switch recordedAtOf(context.meta.time) {
+      | Some(recordedAt) => {...sliceCtx, recordedAt}
+      | None => sliceCtx
+      }
       let sourceName = context.meta.service
       // Events arrive as `{id, meta, event}` envelopes (see Message.composeEventJson').
       // Per-mapping decoders work on the inner `event` payload (TAG + fields at
@@ -211,6 +222,7 @@ module Make = (
   }
 
   let phase2 = async (publishJsons: ReventlessInfra.CommandTopic.publishJsons) => {
+    let currentTime = await Clock.currentTimeMillis->Effect.runPromise
     // A `Failed` row at or past the ceiling is one an older build left stranded,
     // or one whose Spec lowered `maxRetries` under it. Either way it is abandoned
     // in fact, so say so rather than letting it sit in a status that promises a
@@ -247,7 +259,7 @@ module Make = (
       }
 
       item->Option.forEach(item => {
-        switch Automation.process(id, item) {
+        switch Automation.process(id, item, ~now=currentTime) {
         | Some((targetId, command)) =>
           todoItems->Dict.set(id, {...row, status: Processing, processedAt: now()})
           let commandJson = try command

package/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs

@@ -4,6 +4,7 @@ import * as Sury from "sury";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.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_option from "@rescript/runtime/lib/es6/Primitive_option.js";
@@ -56,6 +57,14 @@ function Make(Spec) {
       return newrecord;
     };
     let Route = AutomationSlice_Route$ReventlessCore.Make(Spec)(Automation);
+    let recordedAtOf = time => {
+      let millis = new Date(time).getTime();
+      if (Number.isNaN(millis)) {
+        return;
+      } else {
+        return millis;
+      }
+    };
     let apply = param => {
       param.collected.forEach(param => {
         let id = param[0];
@@ -82,9 +91,18 @@ function Make(Spec) {
         todoItems[id] = newrecord;
       }));
     };
-    let phase1 = (events, ctx) => {
+    let phase1 = (events, sliceCtx) => {
       events.forEach(json => {
         let context = Message$ReventlessCore.decode(json, Message$Reventless.contextSchema);
+        let recordedAt = recordedAtOf(context.meta.time);
+        let ctx;
+        if (recordedAt !== undefined) {
+          let newrecord = {...sliceCtx};
+          newrecord.recordedAt = recordedAt;
+          ctx = newrecord;
+        } else {
+          ctx = sliceCtx;
+        }
         let sourceName = context.meta.service;
         let dict = Stdlib_JSON.Decode.object(json);
         let eventPayload = dict !== undefined ? Stdlib_Option.getOr(dict["event"], json) : json;
@@ -92,6 +110,7 @@ function Make(Spec) {
       });
     };
     let phase2 = async publishJsons => {
+      let currentTime = await Effect.runPromise(Clock.currentTimeMillis);
       let newlyAbandoned = [];
       Object.entries(todoItems).forEach(param => {
         let row = param[1];
@@ -128,7 +147,7 @@ function Make(Spec) {
           item = undefined;
         }
         Stdlib_Option.forEach(item, item => {
-          let match = Automation.process(id, item);
+          let match = Automation.process(id, item, currentTime);
           if (match === undefined) {
             return;
           }

package/src/plugin/connect/PluginExtensionPoint_Plugin.res

@@ -111,7 +111,7 @@ module Make = (Spec: Spec) => {
     | PluginExtensionPointSpec.CreateDisconnectSchedule(id, timeout) =>
       await createSchedule({
         name: id->disconnectScheduleName,
-        rate: timeout->ScheduleOps.minutesFromNow,
+        time: timeout->ScheduleOps.minutesFromNow,
         payload: {
           Message.id,
           meta: Message.generateMeta(~service=PluginExtensionPointSpec.name, ~user="Scheduler"),

package/src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs

@@ -108,7 +108,7 @@ function Make(Spec) {
         let id = directive._0;
         return await createSchedule({
           name: disconnectScheduleName(id),
-          rate: ScheduleOps$ReventlessCore.minutesFromNow(directive._1),
+          time: ScheduleOps$ReventlessCore.minutesFromNow(directive._1),
           payload: JSON.stringify(Message$ReventlessCore.encodeCommand$p({
             id: id,
             meta: Message$ReventlessCore.generateMeta(PluginExtensionPointSpec$ReventlessInfra.name, undefined, "Scheduler", undefined, undefined, undefined, undefined, undefined),

package/src/util/ScheduleOps.res

@@ -1,63 +1,9 @@
 open Reventless.Schedule
 
-module DateCalc = {
-  /*** Immutable functions to calculate new Dates without mutation the arguments */
-  @new
-  external dateFromDate: Date.t => Date.t = "Date"
-
-  let addMinutes: (Date.t, int) => Date.t = (date, minutes) => {
-    let result = date->dateFromDate
-    result->Date.setUTCMinutes(result->Date.getUTCMinutes + minutes)
-    result
-  }
-
-  let addDays: (Date.t, int) => Date.t = (date, days) => {
-    let result = date->dateFromDate
-    result->Date.setUTCDate(result->Date.getUTCDate + days)
-    result
-  }
-}
-
 let forChannel = (~name, ~channelId, ~resourceNaming: ReventlessInfra.ResourceNaming.operations) =>
   name->resourceNaming.validateName ++ ("-" ++ channelId->String.split("-")->Array.getUnsafe(1))
 
-let minutesFromNow = minutes => {
-  let m = Date.make()->DateCalc.addMinutes(minutes)
-  Single(
-    m->Date.getUTCFullYear,
-    m->Date.getUTCMonth + 1,
-    m->Date.getUTCDate,
-    m->Date.getUTCHours,
-    m->Date.getUTCMinutes,
-  )
-}
-
-let nextTime = (h: hour, m: minute) => {
-  let now = Date.make()
-  let today = {
-    let epoch = Date.make()
-    epoch->Date.setUTCHours(h)
-    epoch->Date.setUTCMinutes(m)
-    epoch->Date.setUTCSeconds(0)
-    epoch
-  }
-  let tomorrow = today->DateCalc.addDays(1)
-  today < now
-    ? Single(
-        tomorrow->Date.getUTCFullYear,
-        tomorrow->Date.getUTCMonth + 1,
-        tomorrow->Date.getUTCDate,
-        tomorrow->Date.getUTCHours,
-        tomorrow->Date.getUTCMinutes,
-      )
-    : Single(
-        today->Date.getUTCFullYear,
-        today->Date.getUTCMonth + 1,
-        today->Date.getUTCDate,
-        today->Date.getUTCHours,
-        today->Date.getUTCMinutes,
-      )
-}
+let minutesFromNow = minutes => Once({moment: After(Minutes(minutes))})
 
 exception ScheduleNotCreated(schedule)
 exception ScheduleNotDeleted(string)

package/src/util/ScheduleOps.res.mjs

@@ -6,72 +6,27 @@ import * as Exit$1 from "effect/Exit";
 import * as Cause from "effect/Cause";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect$1 from "effect/Effect";
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Util_Error$ReventlessCore from "./Util_Error.res.mjs";
 import * as EffectLogger$ReventlessCore from "./EffectLogger.res.mjs";
 
-function addMinutes(date, minutes) {
-  let result = new Date(date);
-  result.setUTCMinutes(result.getUTCMinutes() + minutes | 0);
-  return result;
-}
-
-function addDays(date, days) {
-  let result = new Date(date);
-  result.setUTCDate(result.getUTCDate() + days | 0);
-  return result;
-}
-
-let DateCalc = {
-  addMinutes: addMinutes,
-  addDays: addDays
-};
-
 function forChannel(name, channelId, resourceNaming) {
   return resourceNaming.validateName(name) + ("-" + channelId.split("-")[1]);
 }
 
 function minutesFromNow(minutes) {
-  let m = addMinutes(new Date(), minutes);
   return {
-    TAG: "Single",
-    _0: m.getUTCFullYear(),
-    _1: m.getUTCMonth() + 1 | 0,
-    _2: m.getUTCDate(),
-    _3: m.getUTCHours(),
-    _4: m.getUTCMinutes()
+    TAG: "Once",
+    moment: {
+      TAG: "After",
+      _0: {
+        TAG: "Minutes",
+        _0: minutes
+      }
+    }
   };
 }
 
-function nextTime(h, m) {
-  let now = new Date();
-  let epoch = new Date();
-  epoch.setUTCHours(h);
-  epoch.setUTCMinutes(m);
-  epoch.setUTCSeconds(0);
-  let tomorrow = addDays(epoch, 1);
-  if (Primitive_object.lessthan(epoch, now)) {
-    return {
-      TAG: "Single",
-      _0: tomorrow.getUTCFullYear(),
-      _1: tomorrow.getUTCMonth() + 1 | 0,
-      _2: tomorrow.getUTCDate(),
-      _3: tomorrow.getUTCHours(),
-      _4: tomorrow.getUTCMinutes()
-    };
-  } else {
-    return {
-      TAG: "Single",
-      _0: epoch.getUTCFullYear(),
-      _1: epoch.getUTCMonth() + 1 | 0,
-      _2: epoch.getUTCDate(),
-      _3: epoch.getUTCHours(),
-      _4: epoch.getUTCMinutes()
-    };
-  }
-}
-
 let ScheduleNotCreated = /* @__PURE__ */Primitive_exceptions.create("ScheduleOps-ReventlessCore.ScheduleNotCreated");
 
 let ScheduleNotDeleted = /* @__PURE__ */Primitive_exceptions.create("ScheduleOps-ReventlessCore.ScheduleNotDeleted");
@@ -79,11 +34,11 @@ let ScheduleNotDeleted = /* @__PURE__ */Primitive_exceptions.create("ScheduleOps
 function create(scheduler, channelResources, resourceNaming) {
   return async schedule => {
     let name = resourceNaming.validateName(schedule.name);
-    let schedule_rate = schedule.rate;
+    let schedule_time = schedule.time;
     let schedule_payload = schedule.payload;
     let schedule$1 = {
       name: name,
-      rate: schedule_rate,
+      time: schedule_time,
       payload: schedule_payload
     };
     let createSchedule = scheduler.createSchedule;
@@ -120,10 +75,8 @@ function $$delete(scheduler, channelResources, resourceNaming) {
 }
 
 export {
-  DateCalc,
   forChannel,
   minutesFromNow,
-  nextTime,
   ScheduleNotCreated,
   ScheduleNotDeleted,
   create,

package/src/util/ScheduleTime.res

@@ -0,0 +1,266 @@
+// When a `Schedule.time` fires, read the same way by the local timers and the AWS
+// expression, so the two platforms agree. A calendar time in the hour skipped by
+// daylight saving does not fire that day, as EventBridge Scheduler does.
+open Reventless.Schedule
+
+exception InvalidTime(string)
+
+let utc = "UTC"
+let zoneName = (zone: option<zone>) => zone->Option.getOr(utc)
+
+let zoneOrThrow = name =>
+  switch DateTime.zoneMakeNamed(name) {
+  | Some(zone) => zone
+  | None => throw(InvalidTime(`unknown time zone "${name}"`))
+  }
+
+let minuteMs = 60_000.
+
+let intervalMs = (interval: interval) =>
+  switch interval {
+  | Minutes(n) => n->Int.toFloat *. minuteMs
+  | Hours(n) => n->Int.toFloat *. 60. *. minuteMs
+  | Days(n) => n->Int.toFloat *. 24. *. 60. *. minuteMs
+  | Weeks(n) => n->Int.toFloat *. 7. *. 24. *. 60. *. minuteMs
+  }
+
+let weekdayIndex = (day: weekday) =>
+  switch day {
+  | Sun => 0
+  | Mon => 1
+  | Tue => 2
+  | Wed => 3
+  | Thu => 4
+  | Fri => 5
+  | Sat => 6
+  }
+
+let weekdayName = (day: weekday) =>
+  switch day {
+  | Mon => "MON"
+  | Tue => "TUE"
+  | Wed => "WED"
+  | Thu => "THU"
+  | Fri => "FRI"
+  | Sat => "SAT"
+  | Sun => "SUN"
+  }
+
+let errors = (time: time) => {
+  let errs = []
+  let check = (ok, message) => ok ? () : errs->Array.push(message)
+  let positive = (n, what) => check(n >= 1, `${what} must be at least 1, got ${n->Int.toString}`)
+  let clock = (hour, minute) => {
+    check(hour >= 0 && hour <= 23, `hour must be 0 to 23, got ${hour->Int.toString}`)
+    check(minute >= 0 && minute <= 59, `minute must be 0 to 59, got ${minute->Int.toString}`)
+  }
+  let dayOfMonth = day =>
+    check(day >= 1 && day <= 31, `day must be 1 to 31, got ${day->Int.toString}`)
+  let monthOfYear = month =>
+    check(month >= 1 && month <= 12, `month must be 1 to 12, got ${month->Int.toString}`)
+  let zoneKnown = zone =>
+    zone->Option.forEach(name =>
+      check(DateTime.zoneMakeNamed(name)->Option.isSome, `unknown time zone "${name}"`)
+    )
+  switch time {
+  | Every(Minutes(n) | Hours(n) | Days(n) | Weeks(n)) => positive(n, "an interval")
+  | Calendar({calendar, ?zone}) =>
+    zoneKnown(zone)
+    switch calendar {
+    | Daily({hour, minute}) => clock(hour, minute)
+    | Weekly({days, hour, minute}) =>
+      check(days->Array.length > 0, "a weekly time needs at least one day")
+      clock(hour, minute)
+    | Monthly({day, hour, minute, ?every}) =>
+      dayOfMonth(day)
+      clock(hour, minute)
+      every->Option.forEach(every =>
+        check(every >= 1 && every <= 12, `every must be 1 to 12, got ${every->Int.toString}`)
+      )
+    | Yearly({month, day, hour, minute}) =>
+      monthOfYear(month)
+      dayOfMonth(day)
+      clock(hour, minute)
+    }
+  | Once({moment, ?zone}) =>
+    zoneKnown(zone)
+    switch moment {
+    | At({month, day, hour, minute}) =>
+      monthOfYear(month)
+      dayOfMonth(day)
+      clock(hour, minute)
+    | After(Minutes(n) | Hours(n) | Days(n) | Weeks(n) | Months(n) | Years(n)) =>
+      positive(n, "a period")
+    }
+  }
+  errs
+}
+
+/** Throws `InvalidTime` naming every problem of `time`, for a schedule about to be set. */
+let validate = time =>
+  switch time->errors {
+  | [] => ()
+  | errs => throw(InvalidTime(errs->Array.join("; ")))
+  }
+
+let localTimeOf = (millis, ~zone): localTime => {
+  let parts = DateTime.makeZonedFromMillis(millis, ~zone)->DateTime.toParts
+  {
+    year: parts.year,
+    month: parts.month,
+    day: parts.day,
+    hour: parts.hours,
+    minute: parts.minutes,
+  }
+}
+
+/**
+The moment a period after `from` falls on, in `zone`. Minutes and hours are elapsed time;
+days and longer keep the wall-clock time, and a month from 31 January is the last day
+of February.
+*/
+let afterPeriod = (period: period, ~from, ~zone) => {
+  let start = DateTime.makeZonedFromMillis(from, ~zone)
+  switch period {
+  | Minutes(n) => from +. n->Int.toFloat *. minuteMs
+  | Hours(n) => from +. n->Int.toFloat *. 60. *. minuteMs
+  | Days(n) => start->DateTime.add({days: n})->DateTime.toEpochMillis
+  | Weeks(n) => start->DateTime.add({weeks: n})->DateTime.toEpochMillis
+  | Months(n) => start->DateTime.add({months: n})->DateTime.toEpochMillis
+  | Years(n) => start->DateTime.add({years: n})->DateTime.toEpochMillis
+  }
+}
+
+/** `time` with an `After` turned into the `At` it falls on when counted from `from`. */
+let resolveOnce = (time, ~from) =>
+  switch time {
+  | Once({moment: After(period), ?zone}) =>
+    let tz = zoneOrThrow(zone->zoneName)
+    Once({moment: At(afterPeriod(period, ~from, ~zone=tz)->localTimeOf(~zone=tz)), ?zone})
+  | time => time
+  }
+
+/** The instant an `At` falls on; a time in the skipped hour moves forward by the gap. */
+let instantOf = ({year, month, day, hour, minute}: localTime, ~zone) =>
+  switch DateTime.makeZonedFromParts({year, month, day, hours: hour, minutes: minute}, ~zone) {
+  | Some(dateTime) => dateTime->DateTime.toEpochMillis
+  | None =>
+    throw(
+      InvalidTime(
+        `no such time: ${year->Int.toString}-${month->Int.toString}-${day->Int.toString}`,
+      ),
+    )
+  }
+
+let wallClockOf = (calendar: calendar) =>
+  switch calendar {
+  | Daily({hour, minute})
+  | Weekly({hour, minute})
+  | Monthly({hour, minute})
+  | Yearly({hour, minute}) => (hour, minute)
+  }
+
+let monthsEvery = every =>
+  every <= 1 ? [] : Array.fromInitializer(~length=11 / every + 1, i => 1 + i * every)
+
+let cronOf = (calendar: calendar, ~zone): Cron.t => {
+  let (hour, minute) = calendar->wallClockOf
+  let at = (~days=[], ~months=[], ~weekdays=[]) =>
+    Cron.make({minutes: [minute], hours: [hour], days, months, weekdays, tz: zone})
+  switch calendar {
+  | Daily(_) => at()
+  | Weekly({days}) => at(~weekdays=days->Array.map(weekdayIndex))
+  | Monthly({day, ?every}) => at(~days=[day], ~months=every->Option.getOr(1)->monthsEvery)
+  | Yearly({month, day}) => at(~days=[day], ~months=[month])
+  }
+}
+
+/**
+The first firing of `cron` strictly after `after` whose wall-clock time is
+`hour:minute`: a time the skipped hour moved is passed over.
+*/
+let nextOnWallClock = (cron, ~after, ~hour, ~minute, ~zone) => {
+  let rec loop = (from, tries) => {
+    let next = cron->Cron.next(Date.fromTime(from))->Date.getTime
+    let parts = DateTime.makeZonedFromMillis(next, ~zone)->DateTime.toParts
+    (parts.hours == hour && parts.minutes == minute) || tries >= 8 ? next : loop(next, tries + 1)
+  }
+  loop(after, 0)
+}
+
+/**
+The first firing of `time` strictly after `after`, or `None` when a once-only time is
+already past. For `Every`, `after` is the previous firing, or the moment it was set.
+*/
+let nextFiring = (time, ~after) =>
+  switch time->resolveOnce(~from=after) {
+  | Every(interval) => Some(after +. interval->intervalMs)
+  | Calendar({calendar, ?zone}) =>
+    let tz = zoneOrThrow(zone->zoneName)
+    let (hour, minute) = calendar->wallClockOf
+    Some(calendar->cronOf(~zone=tz)->nextOnWallClock(~after, ~hour, ~minute, ~zone=tz))
+  | Once({moment: At(localTime), ?zone}) =>
+    let at = localTime->instantOf(~zone=zoneOrThrow(zone->zoneName))
+    at > after ? Some(at) : None
+  | Once({moment: After(_)}) => None
+  }
+
+/** What EventBridge Scheduler is given for a time. */
+type awsSchedule = {
+  expression: string,
+  timezone: option<string>,
+  startDate: option<float>,
+  deleteAfterCompletion: bool,
+}
+
+let pad2 = n => n < 10 ? `0${n->Int.toString}` : n->Int.toString
+
+let rateOf = (n, unit) => `rate(${n->Int.toString} ${unit}${n == 1 ? "" : "s"})`
+
+let cronExpressionOf = (calendar: calendar) => {
+  let (hour, minute) = calendar->wallClockOf
+  let fields = switch calendar {
+  | Daily(_) => "* * ? *"
+  | Weekly({days}) => `? * ${days->Array.map(weekdayName)->Array.join(",")} *`
+  | Monthly({day, ?every}) =>
+    let month = switch every {
+    | Some(every) if every > 1 => `1/${every->Int.toString}`
+    | _ => "*"
+    }
+    `${day->Int.toString} ${month} ? *`
+  | Yearly({month, day}) => `${day->Int.toString} ${month->Int.toString} ? *`
+  }
+  `cron(${minute->Int.toString} ${hour->Int.toString} ${fields})`
+}
+
+/**
+The EventBridge Scheduler form of `time`, set at `setAt`. An `Every` starts one interval
+later, as the local timer does; without a start date AWS fires at once.
+*/
+let toAws = (time, ~setAt) =>
+  switch time->resolveOnce(~from=setAt) {
+  | Every(interval) => {
+      expression: switch interval {
+      | Minutes(n) => rateOf(n, "minute")
+      | Hours(n) => rateOf(n, "hour")
+      | Days(n) => rateOf(n, "day")
+      | Weeks(n) => rateOf(n * 7, "day")
+      },
+      timezone: None,
+      startDate: Some(setAt +. interval->intervalMs),
+      deleteAfterCompletion: false,
+    }
+  | Calendar({calendar, ?zone}) => {
+      expression: calendar->cronExpressionOf,
+      timezone: Some(zone->zoneName),
+      startDate: None,
+      deleteAfterCompletion: false,
+    }
+  | Once({moment: At({year, month, day, hour, minute}), ?zone}) => {
+      expression: `at(${year->Int.toString}-${month->pad2}-${day->pad2}T${hour->pad2}:${minute->pad2}:00)`,
+      timezone: Some(zone->zoneName),
+      startDate: None,
+      deleteAfterCompletion: true,
+    }
+  | Once({moment: After(_)}) => throw(InvalidTime("unresolved once-only time"))
+  }