@reventlessdev/reventless-local 3.0.0-alpha.285 → 3.0.0-alpha.287

package/CHANGELOG.md

@@ -3,6 +3,42 @@
 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.287 (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))
+### Features
+
+* **examples:** a marketing digest at the time each customer chooses ([3521b10](https://github.com/ReventlessDev/reventless-core/commit/3521b10c4f3ff64f3e4561e94e051892cdfe5d5f))
+
+### 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`.
+
+
+
+# 3.0.0-alpha.286 (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.285 (2026-10-14)
 
 **Note:** Version bump only for package @reventlessdev/reventless-local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.285",
+  "version": "3.0.0-alpha.287",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -34,24 +34,24 @@
     "graphql-yoga": "^5.21.0",
     "sury": "11.0.0",
     "ws": "^8.18.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.35",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.29",
+    "@reventlessdev/rescript-effect": "1.0.0-alpha.0",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.12",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.22",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.23",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.22",
+    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.29",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.23",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.294",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.142",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.242",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.144",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.296",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.244",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.193",
     "@reventlessdev/reventless-seed": "1.0.0-alpha.34",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.163",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.158",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.191"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.165",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.160"
   },
   "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/adapter/Scheduler/LocalScheduledPublisher.res

@@ -1,42 +1,15 @@
 // In-memory ScheduledPublisher — satisfies Scheduler_Adapter.ScheduledPublisher.
 //
-// createSchedule: sets up a setInterval that fires Bus.publishEvent when the schedule triggers.
-// deleteSchedule: clears the interval.
-//
-// The schedule.payload is published as the event body. For Single(…) schedules a
-// one-shot setTimeout is used; all recurring rates use setInterval.
+// createSchedule waits for each firing `ScheduleTime.nextFiring` names and publishes the
+// payload as an event on the first channel resource; a once-only time fires once, one
+// already past never. A second createSchedule under the same name replaces the first,
+// as on AWS. deleteSchedule stops it.
 //
 // Usage: create a Scheduler with Scheduler_Builder.Make(LocalScheduledPublisher.Make(Bus))
 // and pass the resulting component to Plugin_Builder or Task_Builder.
 
 module Make = (Bus: LocalBus.T) => {
-  type timerHandle
-
-  @val
-  external setIntervalJs: (unit => unit, int) => timerHandle = "setInterval"
-  @val
-  external setTimeoutJs: (unit => unit, int) => timerHandle = "setTimeout"
-  @val
-  external clearTimerJs: timerHandle => unit = "clearTimeout"
-
-  let activeTimers: ref<dict<timerHandle>> = ref(Dict.make())
-
-  let rateToMs = (rate: Reventless.Schedule.rate) =>
-    switch rate {
-    | Minutes(n) => n * 60 * 1000
-    | Hours(n) => n * 60 * 60 * 1000
-    | Days(n) => n * 24 * 60 * 60 * 1000
-    | Daily(_, _) => 24 * 60 * 60 * 1000
-    | Weekdays(_, _) => 24 * 60 * 60 * 1000
-    | WeekdaysAndSaturday(_, _) => 24 * 60 * 60 * 1000
-    | Single(_, _, _, _, _) => 0
-    }
-
-  let isSingleShot = rate =>
-    switch rate {
-    | Reventless.Schedule.Single(_, _, _, _, _) => true
-    | _ => false
-    }
+  let timers = LocalTimers.make()
 
   let scheduleMeta: ReventlessCore.Message.meta = {
     service: "Scheduler",
@@ -60,23 +33,13 @@ module Make = (Bus: LocalBus.T) => {
       | json => json
       | exception _ => schedule.payload->JSON.Encode.string
       }
-      let fire = () => Bus.publishEvent(topicName, "Scheduler", scheduleMeta, payloadJson)->ignore
-      let handle = if schedule.rate->isSingleShot {
-        setTimeoutJs(fire, 0)
-      } else {
-        setIntervalJs(fire, rateToMs(schedule.rate))
-      }
-      activeTimers.contents->Dict.set(schedule.name, handle)
+      timers->LocalTimers.start(schedule.name, schedule.time, ~setAt=Date.now(), ~fire=_ =>
+        Bus.publishEvent(topicName, "Scheduler", scheduleMeta, payloadJson)->ignore
+      )
     }
 
-    let deleteSchedule: ReventlessInfra.Scheduler.deleteSchedule = async (_, name) => {
-      switch activeTimers.contents->Dict.get(name) {
-      | Some(handle) =>
-        clearTimerJs(handle)
-        activeTimers.contents->Dict.delete(name)
-      | None => ()
-      }
-    }
+    let deleteSchedule: ReventlessInfra.Scheduler.deleteSchedule = async (_, name) =>
+      timers->LocalTimers.stop(name)
 
     {
       resource: ReventlessInfra.Adapter.make(
@@ -95,8 +58,5 @@ module Make = (Bus: LocalBus.T) => {
   }
 
   // Clear all active timers — call in afterAll/afterEach for test isolation.
-  let reset = () => {
-    activeTimers.contents->Dict.valuesToArray->Array.forEach(clearTimerJs)
-    activeTimers.contents = Dict.make()
-  }
+  let reset = () => timers->LocalTimers.reset
 }

package/src/adapter/Scheduler/LocalScheduledPublisher.res.mjs

@@ -1,29 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Pulumi from "@pulumi/pulumi";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+import * as LocalTimers$ReventlessLocal from "./LocalTimers.res.mjs";
 
 function Make(Bus) {
-  let activeTimers = {
-    contents: {}
-  };
-  let rateToMs = rate => {
-    switch (rate.TAG) {
-      case "Single" :
-        return 0;
-      case "Minutes" :
-        return (rate._0 * 60 | 0) * 1000 | 0;
-      case "Hours" :
-        return ((rate._0 * 60 | 0) * 60 | 0) * 1000 | 0;
-      case "Days" :
-        return (((rate._0 * 24 | 0) * 60 | 0) * 60 | 0) * 1000 | 0;
-      default:
-        return 86400000;
-    }
-  };
-  let isSingleShot = rate => rate.TAG === "Single";
+  let timers = LocalTimers$ReventlessLocal.make();
   let scheduleMeta = {
     service: "Scheduler",
     time: "",
@@ -41,19 +23,11 @@ function Make(Bus) {
       } catch (exn) {
         payloadJson = schedule.payload;
       }
-      let fire = () => {
+      return LocalTimers$ReventlessLocal.start(timers, schedule.name, schedule.time, Date.now(), param => {
         Bus.publishEvent(topicName, "Scheduler", scheduleMeta, payloadJson);
-      };
-      let handle = isSingleShot(schedule.rate) ? setTimeout(fire, 0) : setInterval(fire, rateToMs(schedule.rate));
-      activeTimers.contents[schedule.name] = handle;
-    };
-    let deleteSchedule = async (param, name) => {
-      let handle = activeTimers.contents[name];
-      if (handle !== undefined) {
-        clearTimeout(Primitive_option.valFromOption(handle));
-        return Stdlib_Dict.$$delete(activeTimers.contents, name);
-      }
+      });
     };
+    let deleteSchedule = async (param, name) => LocalTimers$ReventlessLocal.stop(timers, name);
     return {
       resource: Adapter$ReventlessInfra.make(Pulumi.output(""), Pulumi.output(""), Pulumi.output(""), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined),
       operations: Pulumi.output({
@@ -62,16 +36,9 @@ function Make(Bus) {
       })
     };
   };
-  let reset = () => {
-    Object.values(activeTimers.contents).forEach(prim => {
-      clearTimeout(prim);
-    });
-    activeTimers.contents = {};
-  };
+  let reset = () => LocalTimers$ReventlessLocal.reset(timers);
   return {
-    activeTimers: activeTimers,
-    rateToMs: rateToMs,
-    isSingleShot: isSingleShot,
+    timers: timers,
     scheduleMeta: scheduleMeta,
     make: make,
     reset: reset

package/src/adapter/Scheduler/LocalTimers.res

@@ -0,0 +1,62 @@
+// Timers that wait for each firing of a `Schedule.time`, as `ScheduleTime.nextFiring`
+// names it, and call `fire` with the scheduled time. Shared by the scheduled publisher
+// and the automations' schedules, so both fire when AWS would.
+
+type timerHandle
+
+@val
+external setTimeoutJs: (unit => unit, float) => timerHandle = "setTimeout"
+@val
+external clearTimerJs: timerHandle => unit = "clearTimeout"
+
+/** The pending wait of each timer, by name. */
+type t = ref<dict<timerHandle>>
+
+let make = (): t => ref(Dict.make())
+
+// Node fires a delay above 2^31 - 1 ms at once, so a far firing is reached a day at a time.
+let maxWaitMs = 86_400_000.
+
+let stop = (timers: t, name) =>
+  switch timers.contents->Dict.get(name) {
+  | Some(handle) =>
+    clearTimerJs(handle)
+    timers.contents->Dict.delete(name)
+  | None => ()
+  }
+
+let rec waitUntil = (timers: t, name, at, fire) => {
+  let delay = at -. Date.now()
+  let handle =
+    delay > maxWaitMs
+      ? setTimeoutJs(() => waitUntil(timers, name, at, fire), maxWaitMs)
+      : setTimeoutJs(fire, Math.max(delay, 0.))
+  timers.contents->Dict.set(name, handle)
+}
+
+let rec arm = (timers: t, name, time, ~after, ~fire) =>
+  switch ReventlessCore.ScheduleTime.nextFiring(time, ~after) {
+  | None => timers.contents->Dict.delete(name)
+  | Some(at) =>
+    waitUntil(timers, name, at, () => {
+      fire(at)
+      arm(timers, name, time, ~after=at, ~fire)
+    })
+  }
+
+/**
+Fires `fire(at)` at every firing of `time` after `setAt`, replacing a timer of the
+same name. A once-only time fires once; one already past never. Throws
+`ScheduleTime.InvalidTime` for a time that cannot fire.
+*/
+let start = (timers: t, name, time, ~setAt, ~fire) => {
+  ReventlessCore.ScheduleTime.validate(time)
+  stop(timers, name)
+  arm(timers, name, time->ReventlessCore.ScheduleTime.resolveOnce(~from=setAt), ~after=setAt, ~fire)
+}
+
+/** Clears every timer — call in afterAll/afterEach for test isolation. */
+let reset = (timers: t) => {
+  timers.contents->Dict.valuesToArray->Array.forEach(clearTimerJs)
+  timers.contents = Dict.make()
+}

package/src/adapter/Scheduler/LocalTimers.res.mjs

@@ -0,0 +1,63 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as ScheduleTime$ReventlessCore from "@reventlessdev/reventless-core/src/util/ScheduleTime.res.mjs";
+
+function make() {
+  return {
+    contents: {}
+  };
+}
+
+function stop(timers, name) {
+  let handle = timers.contents[name];
+  if (handle !== undefined) {
+    clearTimeout(Primitive_option.valFromOption(handle));
+    return Stdlib_Dict.$$delete(timers.contents, name);
+  }
+}
+
+function waitUntil(timers, name, at, fire) {
+  let delay = at - Date.now();
+  let handle = delay > 86400000 ? setTimeout(() => waitUntil(timers, name, at, fire), 86400000) : setTimeout(fire, Math.max(delay, 0));
+  timers.contents[name] = handle;
+}
+
+function arm(timers, name, time, after, fire) {
+  let at = ScheduleTime$ReventlessCore.nextFiring(time, after);
+  if (at !== undefined) {
+    return waitUntil(timers, name, at, () => {
+      fire(at);
+      arm(timers, name, time, at, fire);
+    });
+  } else {
+    return Stdlib_Dict.$$delete(timers.contents, name);
+  }
+}
+
+function start(timers, name, time, setAt, fire) {
+  ScheduleTime$ReventlessCore.validate(time);
+  stop(timers, name);
+  arm(timers, name, ScheduleTime$ReventlessCore.resolveOnce(time, setAt), setAt, fire);
+}
+
+function reset(timers) {
+  Object.values(timers.contents).forEach(prim => {
+    clearTimeout(prim);
+  });
+  timers.contents = {};
+}
+
+let maxWaitMs = 86400000;
+
+export {
+  make,
+  maxWaitMs,
+  stop,
+  waitUntil,
+  arm,
+  start,
+  reset,
+}
+/* ScheduleTime-ReventlessCore Not a pure module */

package/src/components/AutomationSlice_Builder.res

@@ -1,5 +1,6 @@
 // In-memory AutomationSlice builder.
-// Wires in-memory adapters and delegates to the core ReventlessCore.AutomationSlice_Builder.
+// Wires in-memory adapters and delegates to the core ReventlessCore.AutomationSlice_Builder;
+// each slice it makes joins the local automation sweep, and its schedules start.
 
 module Make = (Bus: LocalBus.T) => {
   module RuntimeEnvironment = LocalRuntimeEnvironment
@@ -24,6 +25,7 @@ module Make = (Bus: LocalBus.T) => {
     EventCollectorChannel,
     EventCollectorRuntimeBuilder,
     Api,
+    LocalAutomationSchedules,
   )
 
   module Make = (
@@ -35,7 +37,34 @@ module Make = (Bus: LocalBus.T) => {
     module Automation = Automation
     type component = Inner.component
     let queryDbName = Inner.queryDbName
+    let schedulesDbName = Inner.schedulesDbName
     let sourceNames = Inner.sourceNames
-    let make = Inner.make
+    let make = (~allEventTopics, ~publishJsons, ~context, ~runtime=?, ~opts=?) => {
+      let component = Inner.make(~allEventTopics, ~publishJsons, ~context, ~runtime?, ~opts?)
+      let operations = () => component->ReventlessCore.Component.operations->TestRunner.resolve
+      LocalAutomationSweep.register(~name=Spec.name, async () => {
+        let ops = await operations()
+        await ops.processPending()
+      })
+      LocalAutomationSchedules.register(~slice=Spec.name, async (~key, ~at) => {
+        let ops = await operations()
+        await ops.tick(~key, ~at)
+      })
+      // As a deploy does on AWS: the declared time into the rows, the timers to the rows.
+      let _ =
+        operations()
+        ->Promise.then(ops => ops.reconcileSchedules())
+        ->Promise.catch(exn => {
+          ReventlessCore.EffectLogger.logError(
+            ~comp=`AutomationSlice(${Spec.name})`,
+            `the schedules could not be reconciled: ${exn
+              ->JsExn.fromException
+              ->Option.flatMap(JsExn.message)
+              ->Option.getOr("unknown")}`,
+          )->Effect.runSync
+          Promise.resolve()
+        })
+      component
+    }
   }
 }

package/src/components/AutomationSlice_Builder.res.mjs

@@ -1,8 +1,17 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../test/TestRunner.res.mjs";
+import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
 import * as LocalQueryDbStorage$ReventlessLocal from "../adapter/QueryDb/LocalQueryDbStorage.res.mjs";
+import * as LocalAutomationSweep$ReventlessLocal from "./LocalAutomationSweep.res.mjs";
 import * as AutomationSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Builder.res.mjs";
 import * as LocalRuntimeEnvironment$ReventlessLocal from "../adapter/Runtime/LocalRuntimeEnvironment.res.mjs";
+import * as LocalAutomationSchedules$ReventlessLocal from "./LocalAutomationSchedules.res.mjs";
 import * as QueryDbResolvers_GraphQL$ReventlessLocal from "../adapter/QueryDb/QueryDbResolvers_GraphQL.res.mjs";
 import * as LocalEventCollectorChannel$ReventlessLocal from "../adapter/EventCollector/LocalEventCollectorChannel.res.mjs";
 import * as LocalEventCollectorRuntime_Builder$ReventlessLocal from "../adapter/Runtime/LocalEventCollectorRuntime_Builder.res.mjs";
@@ -31,15 +40,34 @@ function Make(Bus) {
     make: QueryDbStorage.make
   })({
     make: QueryDbResolvers.make
-  })(EventCollectorChannel)(EventCollectorRuntimeBuilder)(Api);
+  })(EventCollectorChannel)(EventCollectorRuntimeBuilder)(Api)({
+    platformFor: LocalAutomationSchedules$ReventlessLocal.platformFor
+  });
   let Make$1 = Spec => (Automation => {
     let Inner = CoreMaker.Make(Spec)(Automation);
+    let make = (allEventTopics, publishJsons, context, runtime, opts) => {
+      let component = Inner.make(allEventTopics, publishJsons, context, runtime, opts);
+      LocalAutomationSweep$ReventlessLocal.register(Spec.name, async () => {
+        let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(component));
+        return await ops.processPending();
+      });
+      LocalAutomationSchedules$ReventlessLocal.register(Spec.name, async (key, at) => {
+        let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(component));
+        return await ops.tick(key, at);
+      });
+      Stdlib_Promise.$$catch(TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(component)).then(ops => ops.reconcileSchedules()), exn => {
+        Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `the schedules could not be reconciled: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown")));
+        return Promise.resolve();
+      });
+      return component;
+    };
     return {
       Spec: Spec,
       Automation: Automation,
       queryDbName: Inner.queryDbName,
+      schedulesDbName: Inner.schedulesDbName,
       sourceNames: Inner.sourceNames,
-      make: Inner.make
+      make: make
     };
   });
   return {
@@ -57,4 +85,4 @@ function Make(Bus) {
 export {
   Make,
 }
-/* LocalQueryDbStorage-ReventlessLocal Not a pure module */
+/* Stdlib_JsExn Not a pure module */

package/src/components/LocalAutomationSchedules.res

@@ -0,0 +1,59 @@
+// The local platform's Scheduler for automations: one timer per slice and key, which
+// delivers `Tick({key, at})` to the slice when its time comes, as EventBridge
+// Scheduler does on AWS. A slice registers how it is ticked when it is made; its
+// schedules are put by its rows, through `platformFor`.
+
+let timers = LocalTimers.make()
+
+let ticks: dict<(~key: string, ~at: float) => promise<unit>> = Dict.make()
+
+let timerName = (~slice, ~key) => `${slice}/${key}`
+
+let tickFailed = (~slice, ~key, message) =>
+  ReventlessCore.EffectLogger.logError(
+    ~comp="LocalAutomationSchedules",
+    `tick ${key} of ${slice} failed: ${message}`,
+  )->Effect.runSync
+
+/** How the slice is ticked when one of its schedules comes due. */
+let register = (~slice, tick) => ticks->Dict.set(slice, tick)
+
+let fire = (~slice, ~key, at) =>
+  switch ticks->Dict.get(slice) {
+  | Some(tick) =>
+    let _ = tick(~key, ~at)->Promise.catch(exn => {
+      tickFailed(
+        ~slice,
+        ~key,
+        exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"),
+      )
+      Promise.resolve()
+    })
+  | None => tickFailed(~slice, ~key, "the slice is not registered")
+  }
+
+/** The slice's schedules on the local platform, named by their keys. */
+let platformFor = (~slice): ReventlessInfra.AutomationSlice.platformSchedules => {
+  put: async (~key, time) =>
+    timers->LocalTimers.start(timerName(~slice, ~key), time, ~setAt=Date.now(), ~fire=at =>
+      fire(~slice, ~key, at)
+    ),
+  removeName: async key => timers->LocalTimers.stop(timerName(~slice, ~key)),
+  names: async () => {
+    let prefix = timerName(~slice, ~key="")
+    timers.contents
+    ->Dict.keysToArray
+    ->Array.filterMap(name =>
+      name->String.startsWith(prefix)
+        ? Some(name->String.slice(~start=prefix->String.length))
+        : None
+    )
+  },
+  nameOf: key => key,
+}
+
+/** Stops every schedule and forgets every slice — call in afterAll/afterEach for test isolation. */
+let reset = () => {
+  timers->LocalTimers.reset
+  ticks->Dict.keysToArray->Array.forEach(slice => ticks->Dict.delete(slice))
+}

package/src/components/LocalAutomationSchedules.res.mjs

@@ -0,0 +1,72 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.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 Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
+import * as LocalTimers$ReventlessLocal from "../adapter/Scheduler/LocalTimers.res.mjs";
+
+let timers = LocalTimers$ReventlessLocal.make();
+
+let ticks = {};
+
+function timerName(slice, key) {
+  return slice + `/` + key;
+}
+
+function tickFailed(slice, key, message) {
+  Effect.runSync(EffectLogger$ReventlessCore.logError("LocalAutomationSchedules", undefined, `tick ` + key + ` of ` + slice + ` failed: ` + message));
+}
+
+function register(slice, tick) {
+  ticks[slice] = tick;
+}
+
+function fire(slice, key, at) {
+  let tick = ticks[slice];
+  if (tick !== undefined) {
+    Stdlib_Promise.$$catch(tick(key, at), exn => {
+      tickFailed(slice, key, Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown"));
+      return Promise.resolve();
+    });
+    return;
+  } else {
+    return tickFailed(slice, key, "the slice is not registered");
+  }
+}
+
+function platformFor(slice) {
+  return {
+    put: async (key, time) => LocalTimers$ReventlessLocal.start(timers, timerName(slice, key), time, Date.now(), at => fire(slice, key, at)),
+    removeName: async key => LocalTimers$ReventlessLocal.stop(timers, timerName(slice, key)),
+    names: async () => {
+      let prefix = timerName(slice, "");
+      return Stdlib_Array.filterMap(Object.keys(timers.contents), name => {
+        if (name.startsWith(prefix)) {
+          return name.slice(prefix.length);
+        }
+      });
+    },
+    nameOf: key => key
+  };
+}
+
+function reset() {
+  LocalTimers$ReventlessLocal.reset(timers);
+  Object.keys(ticks).forEach(slice => Stdlib_Dict.$$delete(ticks, slice));
+}
+
+export {
+  timers,
+  ticks,
+  timerName,
+  tickFailed,
+  register,
+  fire,
+  platformFor,
+  reset,
+}
+/* timers Not a pure module */