@reventlessdev/reventless-core 3.0.0-alpha.260 → 3.0.0-alpha.261

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 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.261 (2026-09-09)
+
+**Note:** Version bump only for package @reventlessdev/reventless-core
+
+
+
+
+
 # 3.0.0-alpha.260 (2026-09-08)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.260",
+  "version": "3.0.0-alpha.261",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,17 +28,17 @@
   "dependencies": {
     "sury": "11.0.0-rc.2",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.10",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.33",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.11",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.11",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.10",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.10",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.20",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.161",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.35",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.133"
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.11",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.162",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.36",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.134"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Behavior.res

@@ -12,7 +12,4 @@ module type Spec = {
 }
 
 type evolve<'state, 'event> = ('state, 'event) => 'state
-type decide<'state, 'command, 'event, 'error> = (
-  'state,
-  'command,
-) => result<array<'event>, 'error>
+type decide<'state, 'command, 'event, 'error> = ('state, 'command) => result<array<'event>, 'error>

package/src/Message.res

@@ -83,7 +83,11 @@ let encodeCommand' = (command', idSchema, commandSchema) =>
 let uuid = Uuid.v4
 
 let log: ('a, string) => 'a = (value, str) => {
-  logger.debug(~comp="Message", ~data=value->JSON.stringifyAny->Option.getOr("")->JSON.Encode.string, str)
+  logger.debug(
+    ~comp="Message",
+    ~data=value->JSON.stringifyAny->Option.getOr("")->JSON.Encode.string,
+    str,
+  )
   value
 }
 
@@ -205,7 +209,6 @@ let hrtimeToString: (~hrtime: hrtime, ~now: float) => string = (~hrtime, ~now) =
   now->Float.toString ++ ("-" ++ (String.repeat("0", 9 - milLength) ++ milString))
 }
 
-
 let generateMeta = (
   ~service,
   ~ip=?,
@@ -222,12 +225,12 @@ let generateMeta = (
     time: nowAsISOString(),
     msgId,
     correlationId: correlationId->Option.getOr(msgId),
-    ip: ?ip,
-    user: ?user,
-    causationId: ?causationId,
-    traceparent: ?traceparent,
-    schemaVersion: ?schemaVersion,
-    headers: ?headers,
+    ?ip,
+    ?user,
+    ?causationId,
+    ?traceparent,
+    ?schemaVersion,
+    ?headers,
   }
 }
 
@@ -332,13 +335,13 @@ let storedEventToFlatJson = (
 }
 
 /** Decode the flat on-disk JSON shape into a typed `StoredEvent`. */
-let flatJsonToStoredEvent = (
-  json: JSON.t,
-  idSchema: S.t<'id>,
-): Reventless.StoredEvent.storedEvent<'id> => {
+let flatJsonToStoredEvent = (json: JSON.t, idSchema: S.t<'id>): Reventless.StoredEvent.storedEvent<
+  'id,
+> => {
   let dict = json->JSON.Decode.object->Option.getOrThrow
   let id = dict->Dict.get("id")->Option.getOrThrow->Reventless.Util_Sury.fromJson(idSchema)
-  let position = dict->Dict.get("position")->Option.getOrThrow->JSON.Decode.string->Option.getOrThrow
+  let position =
+    dict->Dict.get("position")->Option.getOrThrow->JSON.Decode.string->Option.getOrThrow
   let event = dict->Dict.get("event")->Option.getOrThrow->JSON.Decode.string->Option.getOrThrow
   let data = dict->Dict.get("data")->Option.getOrThrow
   let recordedAt =
@@ -348,7 +351,7 @@ let flatJsonToStoredEvent = (
     dict
     ->Dict.get("tags")
     ->Option.map(t => t->Reventless.Util_Sury.fromJson(S.array(Reventless.DcbTag.tagSchema)))
-  {id, position, event, data, recordedAt, meta, tags: ?tags}
+  {id, position, event, data, recordedAt, meta, ?tags}
 }
 
 // type decoder<'a> = JSON.t => result<'a, Decco.decodeError>

package/src/Projection.res

@@ -101,8 +101,7 @@ let rewriteActionWith = (
   // `Set` opens a trail rather than extending one: it replaces the whole row,
   // the trail included, so there is no prior value left to compare against.
   let created = state => apply(state, ~overlays, ~priorLifecycle=None)
-  let updated = (fn, state) =>
-    apply(fn(state), ~overlays, ~priorLifecycle=priorLifecycleOf(state))
+  let updated = (fn, state) => apply(fn(state), ~overlays, ~priorLifecycle=priorLifecycleOf(state))
   let labelled = state => apply(state, ~overlays={...overlays, trail: None}, ~priorLifecycle=None)
   switch action {
   | Create(id, state) => Create(id, created(state))
@@ -127,11 +126,10 @@ let rewriteActionWith = (
   }
 }
 
-let rewriteAction = (
-  action: action<'id, 'state>,
-  ~at: string,
-  stateSchema: S.t<'state>,
-): action<'id, 'state> =>
+let rewriteAction = (action: action<'id, 'state>, ~at: string, stateSchema: S.t<'state>): action<
+  'id,
+  'state,
+> =>
   switch overlaysFor(stateSchema->S.castToUnknown) {
   | None => action
   | Some(overlays) =>
@@ -156,11 +154,10 @@ The rewrite a test harness applies: the trail and nothing else. `displayName`
 lives in the state schema and not in the record, so composing it would produce a
 state no expectation can spell.
 */
-let rewriteTrail = (
-  action: action<'id, 'state>,
-  ~at: string,
-  stateSchema: S.t<'state>,
-): action<'id, 'state> =>
+let rewriteTrail = (action: action<'id, 'state>, ~at: string, stateSchema: S.t<'state>): action<
+  'id,
+  'state,
+> =>
   switch trailOverlays(Some(stateSchema->S.castToUnknown)) {
   | None => action
   | Some(overlays) =>
@@ -186,7 +183,12 @@ let rewriteJsonAction = (
   switch trailOverlays(stateSchema) {
   | None => action
   | Some(overlays) =>
-    action->rewriteActionWith(~overlays, ~at, ~toDict=JSON.Decode.object, ~fromDict=JSON.Encode.object)
+    action->rewriteActionWith(
+      ~overlays,
+      ~at,
+      ~toDict=JSON.Decode.object,
+      ~fromDict=JSON.Encode.object,
+    )
   }
 
 let applyChanges = async (
@@ -219,8 +221,7 @@ let applyChanges = async (
   )
   let changedCount = changedStates->Array.length
 
-  let batchToSave =
-    changedStates->Array.concat(addedStates)->Array.map(state => (id, state, None))
+  let batchToSave = changedStates->Array.concat(addedStates)->Array.map(state => (id, state, None))
 
   let deletedSubIds = beforeSubIds->Set.diff(afterSubIds)->Set.toArray
   let batchToDelete = deletedSubIds->Array.map(subId => (id, Some((subIdField, subId))))
@@ -472,39 +473,60 @@ let optimizeActions = actions => {
           UpdateWithDefault(id1, g(defaultState1), state => g(f(state))),
         ])
       | (UpdateWithDefault(id1, defaultState1, f), Create(id2, _state2)) if id1 == id2 =>
-        log.warn(~comp="Projection", `optimizing Create after UpdateWithDefault for id=${id1}, ignoring the Create`)
+        log.warn(
+          ~comp="Projection",
+          `optimizing Create after UpdateWithDefault for id=${id1}, ignoring the Create`,
+        )
         previousActions->Array.concat([UpdateWithDefault(id1, defaultState1, f)])
       | (Create(id1, state1), Create(id2, state2)) if id1 == id2 =>
         log.warn(
           ~comp="Projection",
-          `optimizing 2 sequential Create for id=${id1}, ignoring second: ${state2->JSON.stringifyAny->Option.getOr("?")}`,
+          `optimizing 2 sequential Create for id=${id1}, ignoring second: ${state2
+            ->JSON.stringifyAny
+            ->Option.getOr("?")}`,
         )
         previousActions->Array.concat([Create(id1, state1)])
       | (Create(id1, state1), Delete(id2)) if id1 == id2 =>
         log.warn(
           ~comp="Projection",
-          `optimizing Delete after Create for id=${id1}, ignoring Create: ${state1->JSON.stringifyAny->Option.getOr("?")}`,
+          `optimizing Delete after Create for id=${id1}, ignoring Create: ${state1
+            ->JSON.stringifyAny
+            ->Option.getOr("?")}`,
         )
         previousActions->Array.concat([Delete(id1)])
       | (Update(id1, _f), Delete(id2)) if id1 == id2 =>
-        log.warn(~comp="Projection", `optimizing Delete after Update for id=${id1}, ignoring the Update`)
+        log.warn(
+          ~comp="Projection",
+          `optimizing Delete after Update for id=${id1}, ignoring the Update`,
+        )
         previousActions->Array.concat([Delete(id1)])
       | (UpdateWithDefault(id1, _defaultState1, _f), Delete(id2)) if id1 == id2 =>
-        log.warn(~comp="Projection", `optimizing Delete after UpdateWithDefault for id=${id1}, ignoring the UpdateWithDefault`)
+        log.warn(
+          ~comp="Projection",
+          `optimizing Delete after UpdateWithDefault for id=${id1}, ignoring the UpdateWithDefault`,
+        )
         previousActions->Array.concat([Delete(id1)])
       | (Delete(id1), Create(id2, state2)) if id1 == id2 =>
         previousActions->Array.concat([Set(id1, state2)])
       | (Create(id1, state1), Set(id2, state2)) if id1 == id2 =>
         log.warn(
           ~comp="Projection",
-          `optimizing Set after Create for id=${id1}, ignoring Create: ${state1->JSON.stringifyAny->Option.getOr("?")}`,
+          `optimizing Set after Create for id=${id1}, ignoring Create: ${state1
+            ->JSON.stringifyAny
+            ->Option.getOr("?")}`,
         )
         previousActions->Array.concat([Set(id1, state2)])
       | (Update(id1, _f), Set(id2, state2)) if id1 == id2 =>
-        log.warn(~comp="Projection", `optimizing Set after Update for id=${id1}, ignoring the Update`)
+        log.warn(
+          ~comp="Projection",
+          `optimizing Set after Update for id=${id1}, ignoring the Update`,
+        )
         previousActions->Array.concat([Set(id1, state2)])
       | (UpdateWithDefault(id1, _defaultState1, _f), Set(id2, state2)) if id1 == id2 =>
-        log.warn(~comp="Projection", `optimizing Set after UpdateWithDefault for id=${id1}, ignoring the UpdateWithDefault`)
+        log.warn(
+          ~comp="Projection",
+          `optimizing Set after UpdateWithDefault for id=${id1}, ignoring the UpdateWithDefault`,
+        )
         previousActions->Array.concat([Set(id1, state2)])
       // MULTI STATES
       /*
@@ -542,7 +564,9 @@ let optimizeActions = actions => {
         // any other action will be just appended
         log.warn(
           ~comp="Projection",
-          `actions not optimized: ${lastAction->JSON.stringifyAny->Option.getOr("?")} + ${action->JSON.stringifyAny->Option.getOr("?")}`,
+          `actions not optimized: ${lastAction->JSON.stringifyAny->Option.getOr("?")} + ${action
+            ->JSON.stringifyAny
+            ->Option.getOr("?")}`,
         )
         optimizedActions->Array.concat([action])
       }
@@ -571,7 +595,9 @@ let handleActions = async (~comp="Projection", actions, operations, subIdConfig)
       | Error(err) =>
         log.error(
           ~comp,
-          `storage error: ${err->Message.encode(ReventlessInfra.QueryDb.storageErrorSchema)->JSON.stringify}`,
+          `storage error: ${err
+            ->Message.encode(ReventlessInfra.QueryDb.storageErrorSchema)
+            ->JSON.stringify}`,
         )
       }
       await action->handleAction(~comp, operations, subIdConfig)

package/src/RequestContext.res

@@ -56,11 +56,11 @@ let make = (
   ~claims=Dict.make(),
 ): t => {
   correlationId,
-  causationId: ?causationId,
-  component: ?component,
-  pluginName: ?pluginName,
-  timestamp: ?timestamp,
-  retryCount: ?retryCount,
+  ?causationId,
+  ?component,
+  ?pluginName,
+  ?timestamp,
+  ?retryCount,
   identity,
   claims,
 }
@@ -90,8 +90,7 @@ let fromOptions = (o: options): t =>
     ~retryCount=?o.retryCount,
   )
 
-let getClaim = (ctx: t, key: string): option<string> =>
-  ctx.claims->Dict.get(key)
+let getClaim = (ctx: t, key: string): option<string> => ctx.claims->Dict.get(key)
 
 let withClaim = (ctx: t, key: string, value: string): t => {
   let next = ctx.claims->Dict.toArray->Dict.fromArray
@@ -107,8 +106,8 @@ let test = (
   ~claims=Dict.make(),
 ): t => {
   correlationId,
-  timestamp: ?timestamp,
-  retryCount: ?retryCount,
+  ?timestamp,
+  ?retryCount,
   identity,
   claims,
 }

package/src/ResourceAttribution.res

@@ -24,9 +24,12 @@ neither derives from the other.
 /** The level a resource is attributed to. */
 module Scope = {
   type t =
-    | /** owned by one model component */ Component
-    | /** shared substrate within a plugin (DcbEventLog, plugin DLQ, …) */ Plugin
-    | /** shared substrate across the platform (API, auth, hosting, …) */ Platform
+    /** owned by one model component */
+    | Component
+    /** shared substrate within a plugin (DcbEventLog, plugin DLQ, …) */
+    | Plugin
+    /** shared substrate across the platform (API, auth, hosting, …) */
+    | Platform
 
   let toString = scope =>
     switch scope {
@@ -50,17 +53,28 @@ module Role = {
     | EventLogSubscription
     | EventCollector
     | QueryDb
-    | /** the execution unit that runs a component's handler */ Runtime
-    | /** queue/topic receiving messages that exhausted processing */ DeadLetter
-    | /** scheduled invocation (heartbeat, task scheduler) */ Scheduler
-    | /** log storage and log-derived metrics */ Logs
-    | /** execution identity and its policies */ Identity
-    | /** the GraphQL API surface and its resolvers */ Api
-    | /** identity provider / user pools */ Auth
-    | /** static-site hosting, CDN, certificates, DNS */ Hosting
-    | /** VPC and its network plumbing */ Network
-    | /** transport wiring between a source and a runtime */ EventSourceMapping
-    | /** bulk data movement (cloner, migrations) */ DataTransfer
+    /** the execution unit that runs a component's handler */
+    | Runtime
+    /** queue/topic receiving messages that exhausted processing */
+    | DeadLetter
+    /** scheduled invocation (heartbeat, task scheduler) */
+    | Scheduler
+    /** log storage and log-derived metrics */
+    | Logs
+    /** execution identity and its policies */
+    | Identity
+    /** the GraphQL API surface and its resolvers */
+    | Api
+    /** identity provider / user pools */
+    | Auth
+    /** static-site hosting, CDN, certificates, DNS */
+    | Hosting
+    /** VPC and its network plumbing */
+    | Network
+    /** transport wiring between a source and a runtime */
+    | EventSourceMapping
+    /** bulk data movement (cloner, migrations) */
+    | DataTransfer
     | Other(string)
 
   let toString = role =>

package/src/adapter/Adapter.res

@@ -38,7 +38,18 @@ let resourcesOutputToResource: Pulumi.Output.t<array<ReventlessInfra.Adapter.res
   }
 
 let resolvedToResource = (
-  {id, name, urn, resourceInfo, service, role, region, resourceType, configuration, tags}: resolvedResource,
+  {
+    id,
+    name,
+    urn,
+    resourceInfo,
+    service,
+    role,
+    region,
+    resourceType,
+    configuration,
+    tags,
+  }: resolvedResource,
 ): ReventlessInfra.Adapter.resource => {
   id: id->Pulumi.Output.make,
   name: name->Pulumi.Output.make,
@@ -124,7 +135,18 @@ let urns = resources => resources->Array.map((resource: resolvedResource) => res
 // ---------------------------------------------------------------------------
 
 let toInteropResource = (
-  {name, id, urn, resourceInfo, service, role, region, resourceType, configuration, tags}: resolvedResource,
+  {
+    name,
+    id,
+    urn,
+    resourceInfo,
+    service,
+    role,
+    region,
+    resourceType,
+    configuration,
+    tags,
+  }: resolvedResource,
 ): ReventlessInterop.Resource.t => {
   name,
   id,
@@ -144,7 +166,18 @@ let resourcesToInterop = (resources: array<ReventlessInfra.Adapter.resource>) =>
   ->Pulumi.Output.apply(rs => rs->Array.map(toInteropResource))
 
 let fromInteropResolved = (
-  {name, id, urn, resourceInfo, service, role, region, resourceType, configuration, tags}: ReventlessInterop.Resource.t,
+  {
+    name,
+    id,
+    urn,
+    resourceInfo,
+    service,
+    role,
+    region,
+    resourceType,
+    configuration,
+    tags,
+  }: ReventlessInterop.Resource.t,
 ): resolvedResource => {
   name,
   id,
@@ -159,7 +192,18 @@ let fromInteropResolved = (
 }
 
 let fromInteropResource = (
-  {name, id, urn, resourceInfo, service, role, region, resourceType, configuration, tags}: ReventlessInterop.Resource.t,
+  {
+    name,
+    id,
+    urn,
+    resourceInfo,
+    service,
+    role,
+    region,
+    resourceType,
+    configuration,
+    tags,
+  }: ReventlessInterop.Resource.t,
 ): ReventlessInfra.Adapter.resource => {
   id: id->Pulumi.Output.make,
   name: name->Pulumi.Output.make,

package/src/adapter/EventLogProvisioning/EventLogProvisioning.res

@@ -22,7 +22,6 @@ internals into every deployment's stack outputs.
 
 See `docs/plans/done/event-log-provisioned-seam.md`.
 */
-
 /**
 Which event-log family provisioned the log. The two differ in what a reader finds
 on the wire — a classic log is per-aggregate and its rows carry an aggregate id;
@@ -30,8 +29,10 @@ a DCB log is per-plugin and its rows carry tags — so a backend that decodes
 records needs to know which it is looking at before it looks.
 */
 type logStyle =
-  | /** per-aggregate log behind `EventLog_Builder` */ Classic
-  | /** per-plugin tagged log behind `DcbEventLog_Builder` */ Dcb
+  /** per-aggregate log behind `EventLog_Builder` */
+  | Classic
+  /** per-plugin tagged log behind `DcbEventLog_Builder` */
+  | Dcb
 
 /**
 An event-log backend, registered by an extension (a deploy program) before the
@@ -124,8 +125,7 @@ let use = (b: module(Backend)) => {
     JsError.throwWithMessage(
       "EventLogProvisioning.use called twice: only one event-log backend can be registered. " ++
       "A DynamoDB stream supports two readers per shard and core's event collector already holds one, " ++
-      "so a second backend would throttle the first. Compose the two backends into one, or fan out " ++
-      "behind a single registration.",
+      "so a second backend would throttle the first. Compose the two backends into one, or fan out " ++ "behind a single registration.",
     )
   }
   registered := true

package/src/adapter/Messaging/Messaging_Log_Backend.res

@@ -40,8 +40,7 @@ deployment does. SMS and push are absent for the same reason they are absent
 there — no transport — and answer `UnsupportedChannel`, which is settled rather
 than retried.
 */
-let channels = (~sender: string): array<Reventless.Messaging.channel> =>
-  sender == "" ? [] : [Email]
+let channels = (~sender: string): array<Reventless.Messaging.channel> => sender == "" ? [] : [Email]
 
 /** The message as it would have gone out, headers and all.
 
@@ -91,8 +90,12 @@ let send = async (
   }
 
 /** The port, closed over the sender this platform was given. What a platform's
-    capability record carries when logging is the chosen transport. */
-let provider = (~sender: string): Reventless.Messaging.provider => {
-  channels: channels(~sender),
-  send: (~recipient, ~message) => send(~sender, ~recipient, ~message),
-}
+    capability record carries when logging is the chosen transport.
+
+    No push service, so `makeProvider` publishes no `Push` channel — the same
+    empty answer this transport gives for SMS, and for the same reason. */
+let provider = (~sender: string): Reventless.Messaging.provider =>
+  Reventless.Messaging.makeProvider(~emailAndSms=channels(~sender), ~pushServices=[], ~send=(
+    ~recipient,
+    ~message,
+  ) => send(~sender, ~recipient, ~message))

package/src/adapter/Messaging/Messaging_Log_Backend.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Messaging$Reventless from "@reventlessdev/reventless-spec/src/semantic/Messaging.res.mjs";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
@@ -69,10 +70,7 @@ async function send(sender, recipient, message) {
 }
 
 function provider(sender) {
-  return {
-    channels: channels(sender),
-    send: (recipient, message) => send(sender, recipient, message)
-  };
+  return Messaging$Reventless.makeProvider(channels(sender), [], (recipient, message) => send(sender, recipient, message));
 }
 
 export {

package/src/adapter/Monitoring/Monitoring.res

@@ -12,7 +12,6 @@ listener.
 
 See `docs/plans/done/monitoring-hook-seam.md`.
 */
-
 /**
 The ROLE of a provisioned execution unit, not its mechanism. What "failure"
 means for a unit is provider-specific (a Lambda `Errors` metric vs. container
@@ -23,27 +22,27 @@ hatch for support units and future roles (same pattern as the protocol's
 `OtherKind`).
 */
 type unitKind =
-  | /** aggregates, state-change slices, extension points — failure = writes
+  /** aggregates, state-change slices, extension points — failure = writes
        rejected/dropped (the silent-freeze class) */
-  CommandHandler
-  | /** state-view slices, read models — failure = silently stale reads */
-  Projection
-  | /** automation slices, side-effect handlers, translations — failure = missed
+  | CommandHandler
+  /** state-view slices, read models — failure = silently stale reads */
+  | Projection
+  /** automation slices, side-effect handlers, translations — failure = missed
        side effects at boundaries */
-  Reactor
-  | /** cross-plugin/admin event ingestion — failure = event flow between plugins
+  | Reactor
+  /** cross-plugin/admin event ingestion — failure = event flow between plugins
        stops */
-  EventCollector
-  | /** scheduled task runners */
-  Task
-  | /** heartbeat/keep-alive — failure = lifecycle detection AND any staleness
+  | EventCollector
+  /** scheduled task runners */
+  | Task
+  /** heartbeat/keep-alive — failure = lifecycle detection AND any staleness
        watchdog go blind (monitoring's own pulse) */
-  Scheduler
-  | /** receives messages that exhausted processing */
-  DeadLetterSink
-  | /** support units (counters, change-feed relays, migration runners, query
+  | Scheduler
+  /** receives messages that exhausted processing */
+  | DeadLetterSink
+  /** support units (counters, change-feed relays, migration runners, query
        resolvers, …) — providers pass their name */
-  Other(string)
+  | Other(string)
 
 /**
 A monitoring backend, registered by an extension (a deploy program) before the

package/src/adapter/QueryInterception/QueryInterception.res

@@ -51,7 +51,6 @@ not.
 
 See `docs/plans/done/query-interception-provisioning.md`.
 */
-
 let enabled = ref(false)
 
 /**

package/src/adapter/Runtime/AggregateRuntime_Builder_Common.res

@@ -172,13 +172,18 @@ module Make = (
         (infos, handler)
         ->Pulumi.Output.all2
         ->Pulumi.Output.apply(((infos, handler)) => {
-          let infoStrs = infos->Array.filterMap(ri => switch ri {
-            | ReventlessInfra.Adapter.ApiResolver({typeName, fieldName}) => Some(`${typeName}.${fieldName}`)
+          let infoStrs = infos->Array.filterMap(ri =>
+            switch ri {
+            | ReventlessInfra.Adapter.ApiResolver({typeName, fieldName}) =>
+              Some(`${typeName}.${fieldName}`)
             | _ => None
-          })
+            }
+          )
           log.debug(
             ~comp="AggregateRuntime",
-            `forCommandGenerator ${commandGeneratorName}: set handler for ${infoStrs->Array.join(", ")}`,
+            `forCommandGenerator ${commandGeneratorName}: set handler for ${infoStrs->Array.join(
+                ", ",
+              )}`,
           )
           infoStrs->Array.map(info => commandGeneratorHandlers->Dict.set(info, handler))
         })
@@ -260,7 +265,9 @@ module Make = (
             let handlers = eventCollectorHandlers->Dict.get(urn)->Option.getOr([])
             eventCollectorHandlers->Dict.set(
               urn,
-              handlers->Array.concat([{comp, handler: handler->RuntimeEnvironment.asEffectHandler}]),
+              handlers->Array.concat([
+                {comp, handler: handler->RuntimeEnvironment.asEffectHandler},
+              ]),
             )
           })
         })