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

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 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))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.286",
+  "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": {
@@ -35,23 +35,23 @@
     "sury": "11.0.0",
     "ws": "^8.18.0",
     "@reventlessdev/rescript-effect": "1.0.0-alpha.0",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.29",
-    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.23",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.12",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.23",
     "@reventlessdev/rescript-node": "2.0.0-alpha.22",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.295",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.143",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.243",
+    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.29",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.23",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.192",
+    "@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.164",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.159"
+    "@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

@@ -9,44 +9,7 @@
 // and pass the resulting component to Plugin_Builder or Task_Builder.
 
 module Make = (Bus: LocalBus.T) => {
-  type timerHandle
-
-  @val
-  external setTimeoutJs: (unit => unit, float) => timerHandle = "setTimeout"
-  @val
-  external clearTimerJs: timerHandle => unit = "clearTimeout"
-
-  let activeTimers: ref<dict<timerHandle>> = 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 = name =>
-    switch activeTimers.contents->Dict.get(name) {
-    | Some(handle) =>
-      clearTimerJs(handle)
-      activeTimers.contents->Dict.delete(name)
-    | None => ()
-    }
-
-  let rec waitUntil = (name, at, fire) => {
-    let delay = at -. Date.now()
-    let handle =
-      delay > maxWaitMs
-        ? setTimeoutJs(() => waitUntil(name, at, fire), maxWaitMs)
-        : setTimeoutJs(fire, Math.max(delay, 0.))
-    activeTimers.contents->Dict.set(name, handle)
-  }
-
-  let rec arm = (name, time, ~after, ~publish) =>
-    switch ReventlessCore.ScheduleTime.nextFiring(time, ~after) {
-    | None => activeTimers.contents->Dict.delete(name)
-    | Some(at) =>
-      waitUntil(name, at, () => {
-        publish()
-        arm(name, time, ~after=at, ~publish)
-      })
-    }
+  let timers = LocalTimers.make()
 
   let scheduleMeta: ReventlessCore.Message.meta = {
     service: "Scheduler",
@@ -62,7 +25,6 @@ module Make = (Bus: LocalBus.T) => {
       channelResources,
       schedule,
     ) => {
-      ReventlessCore.ScheduleTime.validate(schedule.time)
       let topicName = switch channelResources {
       | [] => ""
       | resources => (resources->Array.getUnsafe(0)).name
@@ -71,19 +33,13 @@ module Make = (Bus: LocalBus.T) => {
       | json => json
       | exception _ => schedule.payload->JSON.Encode.string
       }
-      let publish = () =>
+      timers->LocalTimers.start(schedule.name, schedule.time, ~setAt=Date.now(), ~fire=_ =>
         Bus.publishEvent(topicName, "Scheduler", scheduleMeta, payloadJson)->ignore
-      let setAt = Date.now()
-      stop(schedule.name)
-      arm(
-        schedule.name,
-        schedule.time->ReventlessCore.ScheduleTime.resolveOnce(~from=setAt),
-        ~after=setAt,
-        ~publish,
       )
     }
 
-    let deleteSchedule: ReventlessInfra.Scheduler.deleteSchedule = async (_, name) => stop(name)
+    let deleteSchedule: ReventlessInfra.Scheduler.deleteSchedule = async (_, name) =>
+      timers->LocalTimers.stop(name)
 
     {
       resource: ReventlessInfra.Adapter.make(
@@ -102,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,38 +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 ScheduleTime$ReventlessCore from "@reventlessdev/reventless-core/src/util/ScheduleTime.res.mjs";
+import * as LocalTimers$ReventlessLocal from "./LocalTimers.res.mjs";
 
 function Make(Bus) {
-  let activeTimers = {
-    contents: {}
-  };
-  let stop = name => {
-    let handle = activeTimers.contents[name];
-    if (handle !== undefined) {
-      clearTimeout(Primitive_option.valFromOption(handle));
-      return Stdlib_Dict.$$delete(activeTimers.contents, name);
-    }
-  };
-  let waitUntil = (name, at, fire) => {
-    let delay = at - Date.now();
-    let handle = delay > 86400000 ? setTimeout(() => waitUntil(name, at, fire), 86400000) : setTimeout(fire, Math.max(delay, 0));
-    activeTimers.contents[name] = handle;
-  };
-  let arm = (name, time, after, publish) => {
-    let at = ScheduleTime$ReventlessCore.nextFiring(time, after);
-    if (at !== undefined) {
-      return waitUntil(name, at, () => {
-        publish();
-        arm(name, time, at, publish);
-      });
-    } else {
-      return Stdlib_Dict.$$delete(activeTimers.contents, name);
-    }
-  };
+  let timers = LocalTimers$ReventlessLocal.make();
   let scheduleMeta = {
     service: "Scheduler",
     time: "",
@@ -43,7 +16,6 @@ function Make(Bus) {
   };
   let make = (param, param$1) => {
     let createSchedule = async (channelResources, schedule) => {
-      ScheduleTime$ReventlessCore.validate(schedule.time);
       let topicName = channelResources.length !== 0 ? channelResources[0].name : "";
       let payloadJson;
       try {
@@ -51,14 +23,11 @@ function Make(Bus) {
       } catch (exn) {
         payloadJson = schedule.payload;
       }
-      let publish = () => {
+      return LocalTimers$ReventlessLocal.start(timers, schedule.name, schedule.time, Date.now(), param => {
         Bus.publishEvent(topicName, "Scheduler", scheduleMeta, payloadJson);
-      };
-      let setAt = Date.now();
-      stop(schedule.name);
-      return arm(schedule.name, ScheduleTime$ReventlessCore.resolveOnce(schedule.time, setAt), setAt, publish);
+      });
     };
-    let deleteSchedule = async (param, name) => stop(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({
@@ -67,18 +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,
-    maxWaitMs: 86400000,
-    stop: stop,
-    waitUntil: waitUntil,
-    arm: arm,
+    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,6 +1,6 @@
 // In-memory AutomationSlice builder.
 // Wires in-memory adapters and delegates to the core ReventlessCore.AutomationSlice_Builder;
-// each slice it makes joins the local automation sweep.
+// each slice it makes joins the local automation sweep, and its schedules start.
 
 module Make = (Bus: LocalBus.T) => {
   module RuntimeEnvironment = LocalRuntimeEnvironment
@@ -25,6 +25,7 @@ module Make = (Bus: LocalBus.T) => {
     EventCollectorChannel,
     EventCollectorRuntimeBuilder,
     Api,
+    LocalAutomationSchedules,
   )
 
   module Make = (
@@ -36,13 +37,33 @@ 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 = (~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 component->ReventlessCore.Component.operations->TestRunner.resolve
+        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,11 +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";
@@ -34,7 +40,9 @@ 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) => {
@@ -43,12 +51,21 @@ function Make(Bus) {
         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: make
     };
@@ -68,4 +85,4 @@ function Make(Bus) {
 export {
   Make,
 }
-/* Component-ReventlessCore 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 */

package/src/test/TestRunner.res

@@ -45,6 +45,7 @@ let resetGraphQLServer = () => DomainGraphQL_Server.reset()
 // Call in afterAll when using Plugin_Builder with LocalHeartbeatRunner.
 let resetHeartbeatRunner = () => LocalHeartbeatRunner.reset()
 let resetAutomationSweep = () => LocalAutomationSweep.reset()
+let resetAutomationSchedules = () => LocalAutomationSchedules.reset()
 
 // ─────────────────────────────────────────────────────────────
 // Bus test utilities

package/src/test/TestRunner.res.mjs

@@ -4,6 +4,7 @@ import * as Pulumi from "@pulumi/pulumi";
 import * as DomainGraphQL_Server$ReventlessLocal from "../adapter/DomainGraphQL_Server.res.mjs";
 import * as LocalAutomationSweep$ReventlessLocal from "../components/LocalAutomationSweep.res.mjs";
 import * as LocalHeartbeatRunner$ReventlessLocal from "../adapter/Heartbeat/LocalHeartbeatRunner.res.mjs";
+import * as LocalAutomationSchedules$ReventlessLocal from "../components/LocalAutomationSchedules.res.mjs";
 
 function setup() {
   Pulumi.runtime.setMocks({
@@ -35,6 +36,10 @@ function resetAutomationSweep() {
   LocalAutomationSweep$ReventlessLocal.reset();
 }
 
+function resetAutomationSchedules() {
+  LocalAutomationSchedules$ReventlessLocal.reset();
+}
+
 function collectNEvents(subscribeToEvents, topicName, n) {
   if (n <= 0) {
     return Promise.resolve([]);
@@ -72,6 +77,7 @@ export {
   resetGraphQLServer,
   resetHeartbeatRunner,
   resetAutomationSweep,
+  resetAutomationSchedules,
   collectNEvents,
 }
 /* @pulumi/pulumi Not a pure module */