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

package/CHANGELOG.md

@@ -3,6 +3,39 @@
 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.297 (2026-10-16)
+
+* fix(auth)!: only operators read the framework's own stores ([a2fd202](https://github.com/ReventlessDev/reventless-core/commit/a2fd2022b6876dae855b185df7f8263353fc971d))
+
+### BREAKING CHANGES
+
+* a caller outside the elevated groups is refused the
+framework's to-do, schedule and audit stores. On AWS, a roles-gated
+view's …ByIds, …Refs, …Items and …By<Index> fields refuse callers
+outside its roles.
+
+
+
+# 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.297",
   "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.12",
     "@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-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-infra": "3.0.0-alpha.194",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.166"
   },
   "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.102"
   },
   "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/Api/GraphQL_FragmentGenerator.res

@@ -777,6 +777,21 @@ let mutationArgTypes = (~fieldName: string, variantSchema: S.t<unknown>): option
     out
   })
 
+/** Every query field `generate` emits for an entry, under the same conditions.
+    A platform gating an entry gates each of them: a door left out is open. */
+let queryFieldNamesOf = (entry: querySchemaEntry): array<string> => {
+  let byIds = entry.includeIdParam->Option.getOr(true) && entry.subIdField === None
+  let indexFields =
+    entry.indexQueries
+    ->Option.getOr([])
+    ->Array.filter(ic => !Reventless.ReadModel.isDerivedIndex(ic))
+    ->Array.map(ic => indexQueryFieldName(~singleFieldName=entry.singleFieldName, ~index=ic.index))
+  [entry.singleFieldName, entry.listFieldName]
+  ->Array.concat(byIds ? [entry.listFieldName ++ "ByIds", entry.listFieldName ++ "Refs"] : [])
+  ->Array.concat(entry.subIdField->Option.isSome ? [entry.singleFieldName ++ "Items"] : [])
+  ->Array.concat(indexFields)
+}
+
 // ── Main generate function ─────────────────────────────────────────────────
 
 let generate = (

package/src/components/Api/GraphQL_FragmentGenerator.res.mjs

@@ -529,6 +529,18 @@ function mutationArgTypes(fieldName, variantSchema) {
   });
 }
 
+function queryFieldNamesOf(entry) {
+  let byIds = Stdlib_Option.getOr(entry.includeIdParam, true) && entry.subIdField === undefined;
+  let indexFields = Stdlib_Option.getOr(entry.indexQueries, []).filter(ic => !ReadModel$Reventless.isDerivedIndex(ic)).map(ic => indexQueryFieldName(entry.singleFieldName, ic.index));
+  return [
+    entry.singleFieldName,
+    entry.listFieldName
+  ].concat(byIds ? [
+      entry.listFieldName + "ByIds",
+      entry.listFieldName + "Refs"
+    ] : []).concat(Stdlib_Option.isSome(entry.subIdField) ? [entry.singleFieldName + "Items"] : []).concat(indexFields);
+}
+
 function generate(mutationEntries, queryEntries) {
   let types = [];
   let mutations = [];
@@ -729,6 +741,7 @@ export {
   deriveIndexQueryField,
   deriveMutationFieldFromObject,
   mutationArgTypes,
+  queryFieldNamesOf,
   generate,
 }
 /* log Not a pure module */

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
@@ -55,11 +63,60 @@ module Make = (
       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 authorization: Reventless.Authorization.rule<role> = Reventless.OwnerScope.operators()
       let visibility: Reventless.Visibility.t = Public
     }
 
     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> = Reventless.OwnerScope.operators()
+      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,8 +11,11 @@ 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 OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types/OwnerScope.res.mjs";
 import * as Component$ReventlessCore from "../Component.res.mjs";
 import * as EventTopic$ReventlessCore from "../EventTopic/EventTopic.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
@@ -22,15 +25,19 @@ 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 authorization = OwnerScope$Reventless.operators();
       let SpecificQueryDb = QueryDb_Builder$ReventlessCore.Make({
         Id: Id$Reventless.$$String,
         name: queryDbName,
@@ -38,9 +45,39 @@ function Make(RuntimeEnvironment) {
         stateSchema: AutomationSlice_Callback$ReventlessCore.todoRowSchema,
         config: config,
         subIdConfig: undefined,
-        authorization: "AllowAuthenticated",
+        authorization: authorization,
         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 authorization$1 = OwnerScope$Reventless.operators();
+      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: authorization$1,
+        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 +104,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 +133,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 +152,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 +199,7 @@ function Make(RuntimeEnvironment) {
         Spec: Spec,
         Automation: Automation,
         queryDbName: queryDbName,
+        schedulesDbName: schedulesDbName,
         sourceNames: sourceNames,
         make: make
       };
@@ -128,7 +208,7 @@ function Make(RuntimeEnvironment) {
       finish: EventCollectorRuntimeBuilder.finish,
       Make: Make
     };
-  }))));
+  })))));
 }
 
 export {