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

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 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.296 (2026-10-16)
+
+### Bug Fixes
+
+* **core:** a core test names the schedules module directly ([ac459e5](https://github.com/ReventlessDev/reventless-core/commit/ac459e5ece6479086b86f86019ed1176b4471c9b))
+* 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.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))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.295",
+  "version": "3.0.0-alpha.296",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,21 +29,21 @@
     "sury": "11.0.0",
     "uuid": "^13.0.0",
     "@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-node": "2.0.0-alpha.22",
+    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.15",
     "@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-infra": "3.0.0-alpha.192",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.40",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.164"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.165",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.193"
   },
   "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/admin/Platform_ComponentDefinitionsApi.res

@@ -30,7 +30,7 @@ let sdlTypes: array<string> = [
   // def may decline to state them, and a state whose key cannot be resolved has no
   // `idField` to report.
   `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  labelFieldSource: String\n  lifecycleField: String\n  visibility: String\n  chapter: String\n  singleQueryField: String\n  idField: String\n  idFieldSource: String\n  requiredAccess: [String!]\n  ownerField: String\n  retiredField: String\n  retiredValues: [String!]\n  namedWhenRetired: Boolean!\n}`,
-  `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n  targetName: String\n  chapter: String\n}`,
+  `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n  targetName: String\n  chapter: String\n  schedule: String\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n  consumedSources: [String!]\n}`,
   `type Platform_InboundTranslationSliceDef {\n  name: String!\n  commandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
   // The subscriber's half of the port's translation table — see `handledEventDef`.
@@ -170,6 +170,8 @@ let encodeAutomationSliceDef = (a: automationSliceDef): JSON.t =>
     // from the structure rather than from the deploy-time inspector sync.
     ("targetName", JSON.Encode.string(a.targetName)),
     ("chapter", a.chapter->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
+    // The declared time, as its JSON text; null for an automation started by events only.
+    ("schedule", a.schedule->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
   ])->JSON.Encode.object
 
 let encodeOutboundTranslationSliceDef = (o: outboundTranslationSliceDef): JSON.t =>

package/src/admin/Platform_ComponentDefinitionsApi.res.mjs

@@ -11,7 +11,7 @@ let sdlTypes = [
   `type Platform_ErrorDef {\n  name: String!\n  schema: String!\n  references: [Platform_FieldReference!]!\n}`,
   `type Platform_WriteSideDef {\n  name: String!\n  commands: [Platform_CommandDef!]!\n  linkedViews: [String!]!\n  consistencyRead: String\n  producedEventTypes: [String!]!\n  consumedEventTypes: [String!]!\n  events: [Platform_EventDef!]!\n  errors: [Platform_ErrorDef!]!\n  chapter: String\n}`,
   `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  labelFieldSource: String\n  lifecycleField: String\n  visibility: String\n  chapter: String\n  singleQueryField: String\n  idField: String\n  idFieldSource: String\n  requiredAccess: [String!]\n  ownerField: String\n  retiredField: String\n  retiredValues: [String!]\n  namedWhenRetired: Boolean!\n}`,
-  `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n  targetName: String\n  chapter: String\n}`,
+  `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n  targetName: String\n  chapter: String\n  schedule: String\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n  consumedSources: [String!]\n}`,
   `type Platform_InboundTranslationSliceDef {\n  name: String!\n  commandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
   `type Platform_HandledEventDef {\n  name: String!\n  toCommandTypes: [String!]!\n}`,
@@ -278,6 +278,10 @@ function encodeAutomationSliceDef(a) {
     [
       "chapter",
       Stdlib_Option.mapOr(a.chapter, null, prim => prim)
+    ],
+    [
+      "schedule",
+      Stdlib_Option.mapOr(a.schedule, null, prim => prim)
     ]
   ]);
 }

package/src/components/AutomationSlice/AutomationSlice.res

@@ -26,6 +26,8 @@ module type T = {
   module Automation: Reventless.AutomationSlice.Automation with module Spec := Spec
   type component = Component.t<t, outputs, operations>
   let queryDbName: string
+  /** The schedules store's name, for a slice that maps the `Clock`. */
+  let schedulesDbName: option<string>
   /** Names of all sources this slice consumes (deduplicated). Used by
       `Plugin_Builder` for the source-name fail-fast assembly check. */
   let sourceNames: array<string>

package/src/components/AutomationSlice/AutomationSlice_Builder.res

@@ -22,6 +22,10 @@ module Make = (
     let api: unit => QueryDbStorage.api
     let apiRole: unit => QueryDbStorage.role
   },
+  // The platform's schedules of a slice, for the runtime this builder's operations run on.
+  Schedules: {
+    let platformFor: (~slice: string) => ReventlessInfra.AutomationSlice.platformSchedules
+  },
 ) => {
   let finish = EventCollectorRuntimeBuilder.finish
   module Make = (
@@ -39,12 +43,16 @@ module Make = (
     // Names of all sources this slice subscribes to (deduplicated). Multiple
     // mappings can share a source name (e.g., two mappings reading the same
     // Aggregate's events for different reasons).
-    let sourceNames =
+    let mappedSources =
       Automation.mappings
       ->Array.map((module(M: Automation.Mapping)) => M.sourceName)
       ->Belt.Set.String.fromArray
       ->Belt.Set.String.toArray
 
+    // The event-topic sources; `Clock` is delivered by the slice's schedules, not a topic.
+    let sourceNames = mappedSources->Array.filter(name => name != Reventless.Clock.name)
+    let readsClock = mappedSources->Array.includes(Reventless.Clock.name)
+
     // QueryDb for TODO list — stores todoRow keyed by string ID
     module TodoQueryDbSpec = {
       module Id = Reventless.Id.String
@@ -60,6 +68,55 @@ module Make = (
     }
 
     module SpecificQueryDb = QueryDb_Builder.Make(TodoQueryDbSpec, QueryDbStorage, QueryDbResolvers)
+
+    // The schedules store: a row per key, made only for a slice that maps the Clock.
+    let schedulesStoreName = Spec.name ++ "Schedule"
+    let schedulesDbName = readsClock ? Some(schedulesStoreName) : None
+    module SchedulesQueryDbSpec = {
+      module Id = Reventless.Id.String
+      let name = schedulesStoreName
+      let moduleUrl: string = %raw(`import.meta.url`)
+      type state = AutomationSlice_Schedules.row
+      let stateSchema = AutomationSlice_Schedules.rowSchema
+      let config = Reventless.ReadModel.config()
+      let subIdConfig: option<Reventless.ReadModel.subIdConfig<state>> = None
+      type role = Reventless.Role.name
+      let authorization: Reventless.Authorization.rule<role> = AllowAuthenticated
+      let visibility: Reventless.Visibility.t = Public
+    }
+    module SchedulesQueryDb = QueryDb_Builder.Make(
+      SchedulesQueryDbSpec,
+      QueryDbStorage,
+      QueryDbResolvers,
+    )
+
+    // Written whole, and a key the rows no longer hold is deleted.
+    let syncSchedules = async (
+      ops: option<SchedulesQueryDb.operations>,
+      ~stored: ref<array<string>>,
+    ) =>
+      switch ops {
+      | Some(ops) =>
+        let keys = Callback.schedules->Dict.keysToArray
+        for i in 0 to keys->Array.length - 1 {
+          let key = keys->Array.getUnsafe(i)
+          let _ = await ops.save(
+            key->Reventless.Id.String.makeFromString,
+            Callback.schedules->Dict.getUnsafe(key),
+            QueryDb.Overwrite,
+            None,
+          )
+        }
+        let gone = stored.contents->Array.filter(key => !(keys->Array.includes(key)))
+        for i in 0 to gone->Array.length - 1 {
+          let _ = await ops.delete(
+            gone->Array.getUnsafe(i)->Reventless.Id.String.makeFromString,
+            None,
+          )
+        }
+        stored := keys
+      | None => ()
+      }
     module SpecificEventCollector = EventCollector_Builder.Make(
       RuntimeEnvironment,
       EventCollectorChannel,
@@ -116,6 +173,32 @@ module Make = (
         }
       )
 
+      // A `Clock` mapping receives ticks only from a declared schedule, or from one an
+      // event sets through another mapping's `reschedule`.
+      if readsClock && Spec.schedule->Option.isNone && sourceNames->Array.length == 0 {
+        JsError.throwWithMessage(
+          `AutomationSlice "${Spec.name}" maps the Clock source but declares no schedule ` ++
+          `and reads no event that could set one, so no tick will ever reach it. ` ++ `Declare \`let schedule\` on its spec.`,
+        )
+      }
+
+      let schedulesDb = readsClock
+        ? Some(
+            SchedulesQueryDb.make(
+              ~api=Api.api(),
+              ~apiRole=Api.apiRole(),
+              ~owner={kind: ComponentType.AutomationSlice, name: Spec.name},
+              ~opts,
+            ),
+          )
+        : None
+      let schedulesOps: Pulumi.Output.t<option<SchedulesQueryDb.operations>> = switch schedulesDb {
+      | Some(db) => db->Component.operations->Pulumi.Output.apply(ops => Some(ops))
+      | None => Pulumi.Output.make(None)
+      }
+      let platform = Schedules.platformFor(~slice=Spec.name)
+      let storedSchedules = ref([])
+
       // Filter to only the topics this slice consumes from.
       let sourceSet = sourceNames->Belt.Set.String.fromArray
       let eventTopics = allEventTopics->EventTopic.filter(sourceSet)
@@ -127,9 +210,9 @@ module Make = (
       // first event arrival (which silently dropped Phase 2 in the previous
       // shape).
       let eventCollector =
-        (queryDb->Component.operations, publishJsons)
-        ->Pulumi.Output.all2
-        ->Pulumi.Output.apply(((queryDbOps, publishJsonsFn)) => {
+        (queryDb->Component.operations, publishJsons, schedulesOps)
+        ->Pulumi.Output.all3
+        ->Pulumi.Output.apply(((queryDbOps, publishJsonsFn, schedulesOps)) => {
           let ec = SpecificEventCollector.make(
             ~name=Spec.name,
             ~eventTopics,
@@ -148,6 +231,13 @@ module Make = (
                   // Sync the post-phase-1 TODO state so consumers awaiting the
                   // originating publishEvent observe Pending rows immediately.
                   await syncToQueryDb(queryDbOps)
+                  // The schedule rows are stored first, then the platform follows them.
+                  switch Callback.takeScheduleChanges() {
+                  | [] => ()
+                  | changes =>
+                    await syncSchedules(schedulesOps, ~stored=storedSchedules)
+                    await AutomationSlice_Schedules.tell(platform, changes)
+                  }
                   // Phase 2 must NOT be awaited here. Phase 2 publishes commands
                   // whose downstream events get fanned out by the bus to all
                   // subscribers of this same topic — including this very fiber.
@@ -194,15 +284,41 @@ module Make = (
           eventCollector->Pulumi.Output.flatMap(ec => ec->Component.operations),
           publishJsons,
           queryDb->Component.operations,
+          schedulesOps,
         )
-        ->Pulumi.Output.all3
-        ->Pulumi.Output.apply(((ecOps, publishJsonsFn, queryDbOps)) => {
+        ->Pulumi.Output.all4
+        ->Pulumi.Output.apply(((ecOps, publishJsonsFn, queryDbOps, schedulesOps)) => {
+          let processPending = async () => {
+            await Callback.phase2(publishJsonsFn)
+            await syncToQueryDb(queryDbOps)
+          }
+          let reconcileSchedules = async () =>
+            if readsClock {
+              await AutomationSlice_Schedules.reconcile(
+                Callback.schedules,
+                platform,
+                ~declaredTime=Spec.schedule,
+                ~now=Date.now(),
+              )
+              await syncSchedules(schedulesOps, ~stored=storedSchedules)
+            }
           let ops: AutomationSlice.operations = {
             enqueueEvent: ecOps.enqueueEvent,
             // As the AWS sweep does: the rows phase 2 moved are written back.
-            processPending: async () => {
-              await Callback.phase2(publishJsonsFn)
+            processPending,
+            tick: async (~key, ~at) => {
+              Callback.phase1([AutomationSlice_Callback.tickEvent(~key, ~at)], context)
               await syncToQueryDb(queryDbOps)
+              // A once-only schedule's row went when it fired, and a Clock mapping
+              // may change schedules too.
+              await syncSchedules(schedulesOps, ~stored=storedSchedules)
+              await AutomationSlice_Schedules.tell(platform, Callback.takeScheduleChanges())
+              await processPending()
+            },
+            reconcileSchedules,
+            rebuildSchedules: async events => {
+              Callback.rebuildSchedules(events)
+              await reconcileSchedules()
             },
           }
           ops
@@ -217,6 +333,7 @@ module Make = (
       let outputs: AutomationSlice.outputs = {
         resources: aggregatedResources,
         queryDb: queryDb->Component.outputs,
+        schedulesDb: ?(schedulesDb->Option.map(db => db->Component.outputs)),
       }
       self->Component.setOutputs(outputs)
     }

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

@@ -11,6 +11,8 @@ import * as Pulumi from "@pulumi/pulumi";
 import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as Clock$Reventless from "@reventlessdev/reventless-spec/src/components/Clock.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
 import * as Component$ReventlessCore from "../Component.res.mjs";
@@ -22,13 +24,16 @@ import * as AutomationSlice$ReventlessCore from "./AutomationSlice.res.mjs";
 import * as QueryDb_Builder$ReventlessCore from "../QueryDb/QueryDb_Builder.res.mjs";
 import * as EventCollector_Builder$ReventlessCore from "../EventCollector/EventCollector_Builder.res.mjs";
 import * as AutomationSlice_Callback$ReventlessCore from "./AutomationSlice_Callback.res.mjs";
+import * as AutomationSlice_Schedules$ReventlessCore from "./AutomationSlice_Schedules.res.mjs";
 
 function Make(RuntimeEnvironment) {
-  return QueryDbStorage => (QueryDbResolvers => (EventCollectorChannel => (EventCollectorRuntimeBuilder => (Api => {
+  return QueryDbStorage => (QueryDbResolvers => (EventCollectorChannel => (EventCollectorRuntimeBuilder => (Api => (Schedules => {
     let Make = Spec => (Automation => {
       let Callback = AutomationSlice_Callback$ReventlessCore.Make(Spec)(Automation);
       let queryDbName = Spec.name + "Todo";
-      let sourceNames = Belt_SetString.toArray(Belt_SetString.fromArray(Automation.mappings.map(M => M.sourceName)));
+      let mappedSources = Belt_SetString.toArray(Belt_SetString.fromArray(Automation.mappings.map(M => M.sourceName)));
+      let sourceNames = mappedSources.filter(name => name !== Clock$Reventless.name);
+      let readsClock = mappedSources.includes(Clock$Reventless.name);
       let moduleUrl = import.meta.url;
       let config = ReadModel$Reventless.config(undefined, undefined, undefined);
       let SpecificQueryDb = QueryDb_Builder$ReventlessCore.Make({
@@ -41,6 +46,35 @@ function Make(RuntimeEnvironment) {
         authorization: "AllowAuthenticated",
         visibility: "Public"
       })(QueryDbStorage)(QueryDbResolvers);
+      let schedulesStoreName = Spec.name + "Schedule";
+      let schedulesDbName = readsClock ? schedulesStoreName : undefined;
+      let moduleUrl$1 = import.meta.url;
+      let config$1 = ReadModel$Reventless.config(undefined, undefined, undefined);
+      let SchedulesQueryDb = QueryDb_Builder$ReventlessCore.Make({
+        Id: Id$Reventless.$$String,
+        name: schedulesStoreName,
+        moduleUrl: moduleUrl$1,
+        stateSchema: AutomationSlice_Schedules$ReventlessCore.rowSchema,
+        config: config$1,
+        subIdConfig: undefined,
+        authorization: "AllowAuthenticated",
+        visibility: "Public"
+      })(QueryDbStorage)(QueryDbResolvers);
+      let syncSchedules = async (ops, stored) => {
+        if (ops === undefined) {
+          return;
+        }
+        let keys = Object.keys(Callback.schedules);
+        for (let i = 0, i_finish = keys.length; i < i_finish; ++i) {
+          let key = keys[i];
+          await ops.save(Id$Reventless.$$String.makeFromString(key), Callback.schedules[key], "Overwrite", undefined);
+        }
+        let gone = stored.contents.filter(key => !keys.includes(key));
+        for (let i$1 = 0, i_finish$1 = gone.length; i$1 < i_finish$1; ++i$1) {
+          await ops.delete(Id$Reventless.$$String.makeFromString(gone[i$1]), undefined);
+        }
+        stored.contents = keys;
+      };
       let SpecificEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
       let syncToQueryDb = async queryDbOps => {
         let items = Object.entries(Callback.todoItems);
@@ -67,12 +101,26 @@ function Make(RuntimeEnvironment) {
           let availableNames = Object.keys(allEventTopics).toSorted(Primitive_string.compare).join(", ");
           Stdlib_JsError.throwWithMessage(`AutomationSlice "` + Spec.name + `" has a Mapping with sourceName "` + sourceName + `", but no EventTopic with that key exists in allEventTopics. ` + (`Available source names: [` + availableNames + `]. `) + `Check Mapping.Make's first arg matches an Aggregate Spec.name or a DCB source name (typically "<pluginName>DcbEventLog").`);
         });
+        if (readsClock && Stdlib_Option.isNone(Spec.schedule) && sourceNames.length === 0) {
+          Stdlib_JsError.throwWithMessage(`AutomationSlice "` + Spec.name + `" maps the Clock source but declares no schedule and reads no event that could set one, so no tick will ever reach it. Declare \`let schedule\` on its spec.`);
+        }
+        let schedulesDb = readsClock ? Primitive_option.some(SchedulesQueryDb.make(Api.api(), Api.apiRole(), undefined, {
+            kind: "AutomationSlice",
+            name: Spec.name
+          }, opts)) : undefined;
+        let schedulesOps = schedulesDb !== undefined ? Component$ReventlessCore.operations(Primitive_option.valFromOption(schedulesDb)).apply(ops => ops) : Pulumi.output(undefined);
+        let platform = Schedules.platformFor(Spec.name);
+        let storedSchedules = {
+          contents: []
+        };
         let sourceSet = Belt_SetString.fromArray(sourceNames);
         let eventTopics = EventTopic$ReventlessCore.filter(allEventTopics, sourceSet);
         let eventCollector = Pulumi.all([
           Component$ReventlessCore.operations(queryDb),
-          publishJsons
+          publishJsons,
+          schedulesOps
         ]).apply(param => {
+          let schedulesOps = param[2];
           let publishJsonsFn = param[1];
           let queryDbOps = param[0];
           let ec = SpecificEventCollector.make(Spec.name, eventTopics, {
@@ -82,6 +130,11 @@ function Make(RuntimeEnvironment) {
           let jsonEventsHandler = stream => Effect.flatMap(Stream.runCollect(stream), jsons => Effect.promise(async () => {
             Callback.phase1(jsons, context);
             await syncToQueryDb(queryDbOps);
+            let changes = Callback.takeScheduleChanges();
+            if (changes.length !== 0) {
+              await syncSchedules(schedulesOps, storedSchedules);
+              await AutomationSlice_Schedules$ReventlessCore.tell(platform, changes);
+            }
             Stdlib_Promise.$$catch(Callback.phase2(publishJsonsFn).then(() => syncToQueryDb(queryDbOps)), exn => {
               let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
               Effect.runSync(EffectLogger$ReventlessCore.logError(`AutomationSlice(` + Spec.name + `)`, undefined, `detached phase 2 error: ` + errMsg));
@@ -96,23 +149,46 @@ function Make(RuntimeEnvironment) {
         Component$ReventlessCore.setOperations(extra, Pulumi.all([
           Output$Pulumi.flatMap(eventCollector, Component$ReventlessCore.operations),
           publishJsons,
-          Component$ReventlessCore.operations(queryDb)
+          Component$ReventlessCore.operations(queryDb),
+          schedulesOps
         ]).apply(param => {
+          let schedulesOps = param[3];
           let queryDbOps = param[2];
           let publishJsonsFn = param[1];
+          let processPending = async () => {
+            await Callback.phase2(publishJsonsFn);
+            return await syncToQueryDb(queryDbOps);
+          };
+          let reconcileSchedules = async () => {
+            if (readsClock) {
+              await AutomationSlice_Schedules$ReventlessCore.reconcile(Callback.schedules, platform, Spec.schedule, Date.now());
+              return await syncSchedules(schedulesOps, storedSchedules);
+            }
+          };
           return {
             enqueueEvent: param[0].enqueueEvent,
-            processPending: async () => {
-              await Callback.phase2(publishJsonsFn);
-              return await syncToQueryDb(queryDbOps);
+            processPending: processPending,
+            tick: async (key, at) => {
+              Callback.phase1([AutomationSlice_Callback$ReventlessCore.tickEvent(key, at)], context);
+              await syncToQueryDb(queryDbOps);
+              await syncSchedules(schedulesOps, storedSchedules);
+              await AutomationSlice_Schedules$ReventlessCore.tell(platform, Callback.takeScheduleChanges());
+              return await processPending();
+            },
+            reconcileSchedules: reconcileSchedules,
+            rebuildSchedules: async events => {
+              Callback.rebuildSchedules(events);
+              return await reconcileSchedules();
             }
           };
         }));
         let aggregatedResources = Object.values(eventTopics).flatMap(t => t.resources);
         let outputs_queryDb = Component$ReventlessCore.outputs(queryDb);
+        let outputs_schedulesDb = Stdlib_Option.map(schedulesDb, Component$ReventlessCore.outputs);
         let outputs = {
           resources: aggregatedResources,
-          queryDb: outputs_queryDb
+          queryDb: outputs_queryDb,
+          schedulesDb: outputs_schedulesDb
         };
         return Component$ReventlessCore.setOutputs(extra, outputs);
       }, opts);
@@ -120,6 +196,7 @@ function Make(RuntimeEnvironment) {
         Spec: Spec,
         Automation: Automation,
         queryDbName: queryDbName,
+        schedulesDbName: schedulesDbName,
         sourceNames: sourceNames,
         make: make
       };
@@ -128,7 +205,7 @@ function Make(RuntimeEnvironment) {
       finish: EventCollectorRuntimeBuilder.finish,
       Make: Make
     };
-  }))));
+  })))));
 }
 
 export {

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -93,8 +93,35 @@ type runtime = {
   todoItems: Dict.t<todoRow>,
   phase1: phase1,
   phase2: phase2,
+  /** The slice's schedules, by key: what its schedules store holds. */
+  schedules: Dict.t<AutomationSlice_Schedules.row>,
+  /** What phase 1 changed in `schedules` since the last call, for the platform to
+      follow once the rows are stored. */
+  takeScheduleChanges: unit => array<AutomationSlice_Schedules.platformChange>,
+  /** Folds the given events' `reschedule` into empty rows, in order: a rebuild. */
+  rebuildSchedules: array<JSON.t> => unit,
 }
 
+/** A tick as the runtime receives an event: an envelope from the `Clock`
+    source, recorded at the scheduled time. */
+let tickEvent = (~key, ~at) =>
+  JSON.Encode.object(
+    Dict.fromArray([
+      ("id", key->JSON.Encode.string),
+      (
+        "meta",
+        {
+          ...Message.generateMeta(~service=Reventless.Clock.name),
+          time: at->Date.fromTime->Date.toISOString,
+        }->Reventless.Util_Sury.toJson(Reventless.Message.metaSchema),
+      ),
+      (
+        "event",
+        Reventless.Clock.Tick({key, at})->Reventless.Util_Sury.toJson(Reventless.Clock.eventSchema),
+      ),
+    ]),
+  )
+
 module type T = {
   module Spec: Reventless.AutomationSlice.Spec
   module Automation: Reventless.AutomationSlice.Automation with module Spec := Spec
@@ -108,6 +135,10 @@ module type T = {
 
   /** Phase 2: process all pending items, publishing commands via publishJsons. */
   let phase2: phase2
+
+  let schedules: Dict.t<AutomationSlice_Schedules.row>
+  let takeScheduleChanges: unit => array<AutomationSlice_Schedules.platformChange>
+  let rebuildSchedules: array<JSON.t> => unit
 }
 
 module Make = (
@@ -118,6 +149,20 @@ module Make = (
   module Automation = Automation
 
   let todoItems: Dict.t<todoRow> = Dict.make()
+  let schedules: Dict.t<AutomationSlice_Schedules.row> = Dict.make()
+  let scheduleChanges: ref<array<AutomationSlice_Schedules.platformChange>> = ref([])
+
+  let takeScheduleChanges = () => {
+    let changes = scheduleChanges.contents
+    scheduleChanges := []
+    changes
+  }
+
+  // Only a slice that maps the Clock can receive the ticks a schedule sends.
+  let readsClock =
+    Automation.mappings->Array.some((module(M: Automation.Mapping)) =>
+      M.sourceName == Reventless.Clock.name
+    )
 
   let now = () => Date.make()->Date.toISOString
 
@@ -133,6 +178,10 @@ module Make = (
   // the slice here makes the target's own events unmatchable, silently.
   let makeMeta = (): Reventless.Message.meta => Message.generateMeta(~service=Spec.targetName)
 
+  /** How long a row may stay `Processing` before its command is sent again. */
+  let processingTimeoutMs =
+    15. *. 60. *. 1000.
+
   /** Record a failed attempt. The row is marked `Abandoned` at the moment the
       budget runs out rather than being left to fall out of the next pass's
       filter, so a reader never has to compare `retryCount` against a constant
@@ -201,6 +250,32 @@ module Make = (
     )
   }
 
+  let reschedule = (
+    routed: array<AutomationSlice_Route.routed<Spec.todoItem>>,
+    ~setBy,
+    ~recordedAt,
+  ) =>
+    routed->Array.forEach(r =>
+      r.rescheduled->Array.forEach(change =>
+        if !readsClock {
+          EffectLogger.logError(
+            ~comp=`AutomationSlice(${Spec.name})`,
+            `a mapping changed a schedule, but no mapping reads the Clock, so no tick would reach the slice; the change is skipped`,
+          )->Effect.runSync
+        } else {
+          switch schedules->AutomationSlice_Schedules.apply(change, ~setBy, ~recordedAt) {
+          | Ok(platformChange) =>
+            scheduleChanges := scheduleChanges.contents->Array.concat([platformChange])
+          | Error(message) =>
+            EffectLogger.logError(
+              ~comp=`AutomationSlice(${Spec.name})`,
+              `${message}; the change is skipped`,
+            )->Effect.runSync
+          }
+        }
+      )
+    )
+
   let phase1 = (events: array<JSON.t>, sliceCtx: Reventless.AutomationSlice.context) => {
     events->Array.forEach(json => {
       let context = json->Message.decode(Reventless.Message.contextSchema)
@@ -217,8 +292,38 @@ module Make = (
       | None => json
       }
       // Multiple mappings can share a sourceName; all matching dispatches run.
-      Route.route(eventPayload, ~sourceName, ~sourceId=context.id, ctx)->Array.forEach(apply)
+      let routed = Route.route(eventPayload, ~sourceName, ~sourceId=context.id, ctx)
+      routed->Array.forEach(apply)
+      reschedule(
+        routed,
+        ~setBy=context.meta.msgId,
+        ~recordedAt=ctx.recordedAt->Option.getOr(Date.now()),
+      )
+
+      // A tick's envelope is addressed by its key.
+      if sourceName == Reventless.Clock.name {
+        schedules->AutomationSlice_Schedules.fired(~key=context.id)
+      }
+    })
+  }
+
+  let rebuildSchedules = (events: array<JSON.t>) => {
+    schedules->Dict.keysToArray->Array.forEach(key => schedules->Dict.delete(key))
+    events->Array.forEach(json => {
+      let context = json->Message.decode(Reventless.Message.contextSchema)
+      let eventPayload = switch json->JSON.Decode.object {
+      | Some(dict) => dict->Dict.get("event")->Option.getOr(json)
+      | None => json
+      }
+      let recordedAt = recordedAtOf(context.meta.time)->Option.getOr(Date.now())
+      Route.route(
+        eventPayload,
+        ~sourceName=context.meta.service,
+        ~sourceId=context.id,
+        {environment: "", platformName: "", pluginName: "", sliceName: Spec.name, recordedAt},
+      )->reschedule(~setBy=context.meta.msgId, ~recordedAt)
     })
+    scheduleChanges := []
   }
 
   let phase2 = async (publishJsons: ReventlessInfra.CommandTopic.publishJsons) => {
@@ -228,6 +333,22 @@ module Make = (
     // in fact, so say so rather than letting it sit in a status that promises a
     // retry no pass will make.
     let newlyAbandoned: array<string> = []
+    // A command published but never answered leaves its row `Processing`. After
+    // the timeout that counts as a failed attempt, so this pass sends it again
+    // while the budget lasts.
+    todoItems
+    ->Dict.toArray
+    ->Array.forEach(((id, row)) =>
+      switch (row.status, row.processedAt->Option.map(t => Date.fromString(t)->Date.getTime)) {
+      | (Processing, Some(processedAt)) if currentTime -. processedAt >= processingTimeoutMs =>
+        let updated = row->afterFailedAttempt
+        todoItems->Dict.set(id, updated)
+        if updated.status == Abandoned {
+          newlyAbandoned->Array.push(id)
+        }
+      | _ => ()
+      }
+    )
     todoItems
     ->Dict.toArray
     ->Array.forEach(((id, row)) =>