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

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Builder.res

@@ -129,8 +129,7 @@ module Make = (
             `OutboundTranslationSlice "${Spec.name}" declares sourceName "${sourceName}", ` ++
             `but no EventTopic with that key exists. ` ++
             `Available source names: [${availableNames}]. ` ++
-            `A source is an Aggregate Spec.name or a DCB source name ` ++
-            `(typically "<pluginName>DcbEventLog"); \`[]\` means this plugin's own DCB log.`,
+            `A source is an Aggregate Spec.name or a DCB source name ` ++ `(typically "<pluginName>DcbEventLog"); \`[]\` means this plugin's own DCB log.`,
           )
         }
       )
@@ -200,18 +199,20 @@ module Make = (
                   let _ =
                     Callback.phase2(publishJsonsFn, ~capabilities=Capabilities.capabilities())
                     ->Promise.then(() => syncToQueryDb(queryDbOps))
-                    ->Promise.catch(exn => {
-                      let errMsg =
-                        exn
-                        ->JsExn.fromException
-                        ->Option.flatMap(JsExn.message)
-                        ->Option.getOr("unknown")
-                      EffectLogger.logError(
-                        ~comp=`OutboundTranslationSlice(${Spec.name})`,
-                        `detached phase 2 error: ${errMsg}`,
-                      )->Effect.runSync
-                      Promise.resolve()
-                    })
+                    ->Promise.catch(
+                      exn => {
+                        let errMsg =
+                          exn
+                          ->JsExn.fromException
+                          ->Option.flatMap(JsExn.message)
+                          ->Option.getOr("unknown")
+                        EffectLogger.logError(
+                          ~comp=`OutboundTranslationSlice(${Spec.name})`,
+                          `detached phase 2 error: ${errMsg}`,
+                        )->Effect.runSync
+                        Promise.resolve()
+                      },
+                    )
                 },
               )
             )

package/src/components/QueryDb/QueryDb_Adapter.res

@@ -25,9 +25,7 @@ module type Storage = {
   let make: storageMaker<api, role>
 }
 
-type queryEngineMaker = dict<QueryDb.outputs> => Pulumi.Output.t<
-  Reventless.QueryEngine.operations,
->
+type queryEngineMaker = dict<QueryDb.outputs> => Pulumi.Output.t<Reventless.QueryEngine.operations>
 
 module type QueryEngineAdapter = {
   let make: queryEngineMaker

package/src/components/QueryDb/QueryDb_Operations.res

@@ -19,8 +19,7 @@ module Make = (ReadModelSpec: Reventless.ReadModel.Spec, Ops: Ops) => {
     }
 
   let loadStream = id =>
-    Ops.jsonOps.loadStream(id->ReadModelSpec.Id.toString)
-    ->Stream.mapEffect(json =>
+    Ops.jsonOps.loadStream(id->ReadModelSpec.Id.toString)->Stream.mapEffect(json =>
       switch decode(id, json) {
       | Ok(s) => Effect.succeed(s)
       | Error(e) => Effect.fail(e)
@@ -32,9 +31,7 @@ module Make = (ReadModelSpec: Reventless.ReadModel.Spec, Ops: Ops) => {
     | result =>
       result->Result.flatMap(states =>
         states->Array.reduce(Ok([]), (acc, state) =>
-          acc->Result.flatMap(arr =>
-            decode(id, state)->Result.map(s => arr->Array.concat([s]))
-          )
+          acc->Result.flatMap(arr => decode(id, state)->Result.map(s => arr->Array.concat([s])))
         )
       )
     }
@@ -51,7 +48,7 @@ module Make = (ReadModelSpec: Reventless.ReadModel.Spec, Ops: Ops) => {
       dict->Dict.get(field)->Option.flatMap(JSON.Decode.string)->Option.getOr("")
     ReadModelSpec.config.indexes->Array.forEach(idx => {
       switch idx.pkFields {
-      | Some(fs) when fs->Array.length > 1 =>
+      | Some(fs) if fs->Array.length > 1 =>
         let sep = idx.pkSep->Option.getOr("/")
         let value = fs->Array.map(getStr)->Array.join(sep)
         let attrName = idx.idField->Option.getOr("_pk")
@@ -59,7 +56,7 @@ module Make = (ReadModelSpec: Reventless.ReadModel.Spec, Ops: Ops) => {
       | _ => ()
       }
       switch idx.skFields {
-      | Some(fs) when fs->Array.length > 1 =>
+      | Some(fs) if fs->Array.length > 1 =>
         let sep = idx.skSep->Option.getOr("/")
         let value = fs->Array.map(getStr)->Array.join(sep)
         let attrName = idx.subIdField->Option.getOr("_sk")
@@ -76,8 +73,9 @@ module Make = (ReadModelSpec: Reventless.ReadModel.Spec, Ops: Ops) => {
   // and left exactly as it was.
   // The union fields this view declares, read once. Empty for most views, and
   // the whole diagnostic below costs nothing when it is.
-  let declaredUnionFields =
-    Reventless.TaggedUnion.fieldsOf(ReadModelSpec.stateSchema->S.castToUnknown)
+  let declaredUnionFields = Reventless.TaggedUnion.fieldsOf(
+    ReadModelSpec.stateSchema->S.castToUnknown,
+  )
 
   // Logged once per instantiation, and unconditionally: "none" has to be
   // distinguishable from "never instantiated", because a schema that resolves no
@@ -104,7 +102,9 @@ module Make = (ReadModelSpec: Reventless.ReadModel.Spec, Ops: Ops) => {
           log.warn(
             ~comp="QueryDb",
             `${ReadModelSpec.name}.${field}: stored a union value with no ${Reventless.TaggedUnion.typenameKey} ` ++
-            `(union ${unionName->Option.getOr("<unnamed>")}). The field will resolve to null and take its ` ++
+            `(union ${unionName->Option.getOr(
+                "<unnamed>",
+              )}). The field will resolve to null and take its ` ++
             `parent with it. Union fields seen on this spec: ${declaredUnionFields
               ->Array.map(((f, _)) => f)
               ->Array.join(", ")}`,

package/src/components/ReadModel/ReadModel.res

@@ -30,9 +30,9 @@ module type T = {
   let finish: unit => unit
 }
 
-let toResolvedOutputs = (
-  outputs: outputs,
-): Pulumi.Output.t<ReventlessInterop.ReadModel.resolvedOutputs> =>
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.ReadModel.resolvedOutputs,
+> =>
   outputs.queryDb.resources
   ->Adapter.resourcesToInterop
   ->Pulumi.Output.apply(queryDbResources => {

package/src/components/ReadModel/ReadModel_Builder.res

@@ -104,8 +104,7 @@ module Make = (
           `ReadModel "${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").`,
+          `Check Mapping.Make's first arg matches an Aggregate Spec.name or a DCB ` ++ `source name (typically "<pluginName>DcbEventLog").`,
         )
       }
     )

package/src/components/ReadModel/ReadModel_Callback.res

@@ -42,7 +42,8 @@ module Make = (
         acc->Effect.flatMap(
           _ => {
             Effect.promise(
-              () => Projection.handleAction(~comp, action, Spec.operations, ReadModelSpec.subIdConfig),
+              () =>
+                Projection.handleAction(~comp, action, Spec.operations, ReadModelSpec.subIdConfig),
             )->Effect.map(_ => ())
           },
         )

package/src/components/SideEffectHandler/SideEffectHandler_Callback.res

@@ -49,7 +49,10 @@ module Make = (Spec: Spec): T => {
       | exception err =>
         let errMsg =
           err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
-        EffectLogger.logError(~comp="SideEffects", `map: Couldn't decode meta: ${errMsg}`)->Effect.runSync
+        EffectLogger.logError(
+          ~comp="SideEffects",
+          `map: Couldn't decode meta: ${errMsg}`,
+        )->Effect.runSync
         None
       | _ =>
         EffectLogger.logError(~comp="SideEffects", "map: Invalid JSON object")->Effect.runSync
@@ -107,7 +110,7 @@ module Make = (Spec: Spec): T => {
               )
             }
           )
-          ->Effect.catchAll(errMsg => EffectLogger.logError(~comp="SideEffectHandler", errMsg))
+          ->Effect.catchAll(errMsg => EffectLogger.logError(~comp="SideEffectHandler", errMsg)),
         )
       | None => Effect.succeed()
       }

package/src/components/StateChangeSlice/StateChangeSlice.res

@@ -5,9 +5,9 @@ type outputs = ReventlessInfra.StateChangeSlice.outputs
 type operations = ReventlessInfra.StateChangeSlice.operations
 type component = Component.t<t, outputs, operations>
 
-let toResolvedOutputs = (
-  outputs: outputs,
-): Pulumi.Output.t<ReventlessInterop.StateChangeSlice.resolvedOutputs> =>
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.StateChangeSlice.resolvedOutputs,
+> =>
   outputs.resources
   ->Adapter.resourcesToInterop
   ->Pulumi.Output.apply(resources => {

package/src/components/StateChangeSlice/StateChangeSlice_Builder.res

@@ -10,7 +10,11 @@ module Make = (
   type component = StateChangeSlice.component
   module Callback = StateChangeSlice_Callback.Make(Spec, Behavior)
 
-  let makeJsonHandler = (~tagKeysByEventType, ~crossPartitionTagKeys, dcbEventLogOps: DcbEventLog.operations) => {
+  let makeJsonHandler = (
+    ~tagKeysByEventType,
+    ~crossPartitionTagKeys,
+    dcbEventLogOps: DcbEventLog.operations,
+  ) => {
     let handler: CommandTopic.jsonCommandsHandler = stream => {
       let decodedStream =
         stream
@@ -35,7 +39,12 @@ module Make = (
           | None => Stream.empty
           }
         )
-      Callback.handleCommands(~tagKeysByEventType, ~crossPartitionTagKeys, dcbEventLogOps, decodedStream)
+      Callback.handleCommands(
+        ~tagKeysByEventType,
+        ~crossPartitionTagKeys,
+        dcbEventLogOps,
+        decodedStream,
+      )
     }
     handler
   }
@@ -55,7 +64,11 @@ module Make = (
       dcbEventLog
       ->Component.operations
       ->Pulumi.Output.apply(dcbEventLogOps => {
-        let jsonHandler = makeJsonHandler(~tagKeysByEventType, ~crossPartitionTagKeys, dcbEventLogOps)
+        let jsonHandler = makeJsonHandler(
+          ~tagKeysByEventType,
+          ~crossPartitionTagKeys,
+          dcbEventLogOps,
+        )
         CommandTopic.registerHandler(
           ~schema=commandSchema,
           ~handler=jsonHandler,
@@ -91,7 +104,13 @@ module Make = (
     Component.make(
       ~componentType=StateChangeSlice.componentType->ComponentType.toString,
       ~name=Spec.name,
-      ~construct=construct(~dcbEventLog, ~publishJsons, ~tagKeysByEventType, ~crossPartitionTagKeys, ...),
+      ~construct=construct(
+        ~dcbEventLog,
+        ~publishJsons,
+        ~tagKeysByEventType,
+        ~crossPartitionTagKeys,
+        ...
+      ),
       ~opts,
     )
 }

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -307,7 +307,9 @@ module Make = (
         }
         EffectLogger.logInfo(
           ~comp,
-          `read${cacheHit ? " (cached, delta)" : ""}: ${reads->Array.length->Int.toString} event(s)${reads->Array.length == 0
+          `read${cacheHit ? " (cached, delta)" : ""}: ${reads
+            ->Array.length
+            ->Int.toString} event(s)${reads->Array.length == 0
               ? ""
               : ` [${reads->Array.join(", ")}]`}`,
         )
@@ -337,8 +339,8 @@ module Make = (
             EffectLogger.logInfo(~comp, "no events produced")->Effect.map(_ => Ok("ok"))
           | Ok(newEvents) =>
             let rawEvents =
-              newEvents->Array.map(e =>
-                encodeEvent(~parentMeta=command'.meta, ~tagKeysByEventType, e)
+              newEvents->Array.map(
+                e => encodeEvent(~parentMeta=command'.meta, ~tagKeysByEventType, e),
               )
             let eventCount = rawEvents->Array.length->Int.toString
             let eventDetails =
@@ -393,7 +395,10 @@ module Make = (
                   // Typed classification (was substring-matching the error string,
                   // which disagreed with the backends' casing).
                   let (errorCode, errDetail) = switch err {
-                  | ReventlessInfra.DcbEventLog.Conflict => ("Conflict", "conflict: condition check failed")
+                  | ReventlessInfra.DcbEventLog.Conflict => (
+                      "Conflict",
+                      "conflict: condition check failed",
+                    )
                   | StorageFailure(msg) => ("AppendFailed", msg)
                   }
                   if retries > 0 {
@@ -413,6 +418,7 @@ module Make = (
                     // Retries exhausted — drop any cached snapshot so the next
                     // command for this entity takes the cold full-read path.
                     cacheInvalidate()
+
                     // A surfaced Conflict means the 3-retry loop could not absorb
                     // the contention — the operator signal for "this slice is hot"
                     // (consider sharding / async — Issue 10, §4 of the analysis).
@@ -465,10 +471,20 @@ module Make = (
 
   // CommandTopic handler — processes each command sequentially through handleSingleCommand,
   // returning Ok(reference) or Error(reference) per command.
-  let handleCommands = (~tagKeysByEventType=Dict.make(), ~crossPartitionTagKeys=[], dcbEventLog, stream) =>
+  let handleCommands = (
+    ~tagKeysByEventType=Dict.make(),
+    ~crossPartitionTagKeys=[],
+    dcbEventLog,
+    stream,
+  ) =>
     stream
     ->Stream.mapEffect(({ReventlessInfra.CommandTopic.reference: reference, command}) =>
-      handleSingleCommand(~tagKeysByEventType, ~crossPartitionTagKeys, dcbEventLog, command)->Effect.map(result =>
+      handleSingleCommand(
+        ~tagKeysByEventType,
+        ~crossPartitionTagKeys,
+        dcbEventLog,
+        command,
+      )->Effect.map(result =>
         switch result {
         | Ok(_) => Ok(reference)
         | Error(_) => Error(reference)

package/src/components/StateTopic.res

@@ -43,9 +43,7 @@ module Make = (
     type state
   },
   Publisher: Adapter.Publisher,
-): (
-  T with module Spec = Spec
-) => {
+): (T with module Spec = Spec) => {
   module Spec = Spec
 
   type constructed

package/src/components/StateViewSlice/StateViewSlice.res

@@ -5,9 +5,9 @@ type outputs = ReventlessInfra.StateViewSlice.outputs
 type operations = ReventlessInfra.StateViewSlice.operations
 type component = Component.t<t, outputs, operations>
 
-let toResolvedOutputs = (
-  outputs: outputs,
-): Pulumi.Output.t<ReventlessInterop.StateViewSlice.resolvedOutputs> =>
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.StateViewSlice.resolvedOutputs,
+> =>
   (
     outputs.resources->Adapter.resourcesToInterop,
     outputs.queryDb.resources->Adapter.resourcesToInterop,
@@ -15,7 +15,7 @@ let toResolvedOutputs = (
   ->Pulumi.Output.all2
   ->Pulumi.Output.apply(((resources, queryDbResources)) => {
     let resolved: ReventlessInterop.StateViewSlice.resolvedOutputs = {
-      resources: resources,
+      resources,
       queryDb: {resources: queryDbResources},
     }
     resolved

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -38,9 +38,15 @@ module Make = (
     }
 
     module SpecificQueryDb = QueryDb_Builder.Make(SvQueryDbSpec, QueryDbStorage, QueryDbResolvers)
-    module SpecificEventCollector = EventCollector_Builder.Make(RuntimeEnvironment, EventCollectorChannel)
-
-    let toProjectionOps = (ops: SpecificQueryDb.operations): QueryDb.operations<string, Spec.state> => {
+    module SpecificEventCollector = EventCollector_Builder.Make(
+      RuntimeEnvironment,
+      EventCollectorChannel,
+    )
+
+    let toProjectionOps = (ops: SpecificQueryDb.operations): QueryDb.operations<
+      string,
+      Spec.state,
+    > => {
       load: id => ops.load(id->Reventless.Id.String.makeFromString),
       loadStream: id => ops.loadStream(id->Reventless.Id.String.makeFromString),
       save: (id, s, sm, ttl) => ops.save(id->Reventless.Id.String.makeFromString, s, sm, ttl),
@@ -94,32 +100,31 @@ module Make = (
             ->Effect.flatMap(events => {
               let total = events->Array.length->Int.toString
               events
-              ->Array.mapWithIndex((json, i) => {
-                let envelopeDict = json->JSON.Decode.object->Option.getOr(Dict.make())
-                let rawEvent = envelopeDict->Dict.get("event")->Option.getOr(json)
-                // Events arrive as `{id, meta, recordedAt, event}` envelopes
-                // (Message.composeEventJson' / ProjectionCheckpoint catch-up).
-                // Surface `meta` + `recordedAt` to the projection as `consumed`;
-                // fall back defensively so a malformed envelope never drops the event.
-                let meta = switch envelopeDict->Dict.get("meta") {
-                | Some(m) =>
-                  switch m->Reventless.Util_Sury.fromJson(Message.metaSchema) {
-                  | parsed => parsed
-                  | exception _ => Message.generateMeta(~service=Spec.name)
+              ->Array.mapWithIndex(
+                (json, i) => {
+                  let envelopeDict = json->JSON.Decode.object->Option.getOr(Dict.make())
+                  let rawEvent = envelopeDict->Dict.get("event")->Option.getOr(json)
+                  // Events arrive as `{id, meta, recordedAt, event}` envelopes
+                  // (Message.composeEventJson' / ProjectionCheckpoint catch-up).
+                  // Surface `meta` + `recordedAt` to the projection as `consumed`;
+                  // fall back defensively so a malformed envelope never drops the event.
+                  let meta = switch envelopeDict->Dict.get("meta") {
+                  | Some(m) =>
+                    switch m->Reventless.Util_Sury.fromJson(Message.metaSchema) {
+                    | parsed => parsed
+                    | exception _ => Message.generateMeta(~service=Spec.name)
+                    }
+                  | None => Message.generateMeta(~service=Spec.name)
                   }
-                | None => Message.generateMeta(~service=Spec.name)
-                }
-                let recordedAt =
-                  envelopeDict
-                  ->Dict.get("recordedAt")
-                  ->Option.flatMap(JSON.Decode.string)
-                  ->Option.getOr("")
-                let (eventType, dataDict) = rawEvent->Message.splitMessage
-                switch decoder.decode(~eventType, ~data=dataDict) {
-                | Some(event) =>
-                  let actions =
-                    try Projection.project({event, meta, recordedAt})
-                    catch {
+                  let recordedAt =
+                    envelopeDict
+                    ->Dict.get("recordedAt")
+                    ->Option.flatMap(JSON.Decode.string)
+                    ->Option.getOr("")
+                  let (eventType, dataDict) = rawEvent->Message.splitMessage
+                  switch decoder.decode(~eventType, ~data=dataDict) {
+                  | Some(event) =>
+                    let actions = try Projection.project({event, meta, recordedAt}) catch {
                     | exn =>
                       let errMsg =
                         exn
@@ -132,46 +137,56 @@ module Make = (
                       )->Effect.runSync
                       []
                     }
-                  let idxStr = (i + 1)->Int.toString
-                  let actionsStr = LogFormat.actionNames(actions)
-                  let eventData = dataDict->JSON.Encode.object
-                  let fieldsStr = {
-                    let f =
-                      dataDict
-                      ->Dict.toArray
-                      ->Array.map(((k, v)) => `${k}:${v->JSON.stringify}`)
-                      ->Array.join(",")
-                    f == "" ? "" : `({${f}})`
+                    let idxStr = (i + 1)->Int.toString
+                    let actionsStr = LogFormat.actionNames(actions)
+                    let eventData = dataDict->JSON.Encode.object
+                    let fieldsStr = {
+                      let f =
+                        dataDict
+                        ->Dict.toArray
+                        ->Array.map(((k, v)) => `${k}:${v->JSON.stringify}`)
+                        ->Array.join(",")
+                      f == "" ? "" : `({${f}})`
+                    }
+                    EffectLogger.logInfo(
+                      ~comp,
+                      ~detail=eventData,
+                      `handling event ${idxStr}/${total}: ${LogFormat.bold(
+                          eventType,
+                        )}${fieldsStr} ${actionsStr}`,
+                    )->Effect.runSync
+                    // A slice's state carries the same synthetic `displayName` the
+                    // ppx injects for a read model's, and the same lifecycle trail.
+                    // Rewritten here rather than at the apply below because the
+                    // trail entry is stamped with this envelope's own time.
+                    actions->Array.map(
+                      FrameworkProjection.rewriteAction(_, ~at=meta.time, Spec.stateSchema),
+                    )
+                  | None => []
                   }
-                  EffectLogger.logInfo(
-                    ~comp,
-                    ~detail=eventData,
-                    `handling event ${idxStr}/${total}: ${LogFormat.bold(eventType)}${fieldsStr} ${actionsStr}`,
-                  )->Effect.runSync
-                  // A slice's state carries the same synthetic `displayName` the
-                  // ppx injects for a read model's, and the same lifecycle trail.
-                  // Rewritten here rather than at the apply below because the
-                  // trail entry is stamped with this envelope's own time.
-                  actions->Array.map(
-                    FrameworkProjection.rewriteAction(_, ~at=meta.time, Spec.stateSchema),
-                  )
-                | None => []
-                }
-              })
+                },
+              )
               ->Array.flat
-              ->Array.reduce(Effect.succeed(), (acc, action) =>
-                acc->Effect.flatMap(_ => {
-                  Effect.promise(() =>
-                    FrameworkProjection.handleAction(~comp, action, projectionOps, Spec.subIdConfig)
-                  )->Effect.map(_ => ())
-                })
+              ->Array.reduce(
+                Effect.succeed(),
+                (acc, action) =>
+                  acc->Effect.flatMap(
+                    _ => {
+                      Effect.promise(
+                        () =>
+                          FrameworkProjection.handleAction(
+                            ~comp,
+                            action,
+                            projectionOps,
+                            Spec.subIdConfig,
+                          ),
+                      )->Effect.map(_ => ())
+                    },
+                  ),
               )
             })
 
-          let handler = SpecificEventCollector.makeHandler(
-            ~eventCollector=ec,
-            ~jsonEventsHandler,
-          )
+          let handler = SpecificEventCollector.makeHandler(~eventCollector=ec, ~jsonEventsHandler)
           let resources = (queryDb->Component.outputs).resources
           ec->EventCollectorRuntimeBuilder.forEventCollector(
             ~handler,
@@ -199,11 +214,7 @@ module Make = (
       self->Component.setOutputs(outputs)
     }
 
-    let make = (
-      ~dcbEventLog,
-      ~runtime=?,
-      ~opts=?,
-    ): StateViewSlice.component =>
+    let make = (~dcbEventLog, ~runtime=?, ~opts=?): StateViewSlice.component =>
       Component.make(
         ~componentType=StateViewSlice.componentType->ComponentType.toString,
         ~name=Spec.name,

package/src/components/StateViewSlice/StateViewSlice_Callback.res

@@ -45,7 +45,9 @@ module Make = (
         EffectLogger.logInfo(
           ~comp,
           ~detail=raw.data,
-          `handling event ${idx.contents->Int.toString}/${count}: ${LogFormat.bold(raw.eventType)}(${id}) ${actionsStr}`,
+          `handling event ${idx.contents->Int.toString}/${count}: ${LogFormat.bold(
+              raw.eventType,
+            )}(${id}) ${actionsStr}`,
         )->Effect.runSync
         allActions->Array.pushMany(
           actions->Array.map(

package/src/components/Task/Task.res

@@ -34,9 +34,9 @@ type maker = (
   ~opts: option<Pulumi.ComponentResource.options>,
 ) => component
 
-let toResolvedOutputs = (
-  outputs: outputs,
-): Pulumi.Output.t<ReventlessInterop.Task.resolvedOutputs> =>
+let toResolvedOutputs = (outputs: outputs): Pulumi.Output.t<
+  ReventlessInterop.Task.resolvedOutputs,
+> =>
   switch (outputs.bucketNames, outputs.sideEffectSources) {
   | (Some(bucketNames), Some(sideEffectSources)) =>
     bucketNames

package/src/components/Task/Task_Adapter.res

@@ -1,4 +1,7 @@
-type bucket<'bucketParts> = {resources: array<ReventlessInfra.Adapter.resource>, parts: 'bucketParts}
+type bucket<'bucketParts> = {
+  resources: array<ReventlessInfra.Adapter.resource>,
+  parts: 'bucketParts,
+}
 
 type connect<'bucketParts, 'runtimeParts> = (
   ~name: string,

package/src/components/Task/Task_Builder.res

@@ -17,8 +17,8 @@ let pascalCase = s =>
 // Split words out of a PascalCase/camelCase run so kebab-casing keeps the word
 // boundaries. Two passes: `aB` splits an ordinary hump, `ABc` splits the tail of
 // an acronym off the word that follows it ("HTTPServer" -> "HTTP-Server").
-let humpBoundary = %re("/([a-z0-9])([A-Z])/g")
-let acronymBoundary = %re("/([A-Z]+)([A-Z][a-z])/g")
+let humpBoundary = /([a-z0-9])([A-Z])/g
+let acronymBoundary = /([A-Z]+)([A-Z][a-z])/g
 
 // Kebab-case an identifier for use in an S3 bucket name: "ImportProducts" and
 // "product-imports" both reduce to "import-products".
@@ -119,7 +119,10 @@ module Make = (
     // Task bucket callbacks default to the platform-supplied task-pod floor (a
     // large envelope for bulk import/export work); a plugin.json `runtime`
     // override raises memory above it and replaces timeout.
-    let memorySize = ReventlessInfra.RuntimeHints.resolveMemory(runtime, ~default=Defaults.memorySize)
+    let memorySize = ReventlessInfra.RuntimeHints.resolveMemory(
+      runtime,
+      ~default=Defaults.memorySize,
+    )
     let timeout = ReventlessInfra.RuntimeHints.resolveTimeout(runtime, ~default=Defaults.timeout)
     let allCommandTopics = allAggregates->Aggregate.allCommandTopics
 
@@ -128,15 +131,14 @@ module Make = (
     // first command-topic resource's `id` — bundled adapters interpret it as
     // their channel address; adapters that don't need it (e.g. in-memory)
     // ignore the dict in their TaskRuntime_Builder.
-    let publishToAggregatesQueueUrls =
-      allAggregates->Dict.mapValues(agg =>
-        agg.commandTopic->Pulumi.Output.flatMap(ct =>
-          switch ct.resources->Array.get(0) {
-          | Some(r) => r.id
-          | None => Pulumi.Output.make("")
-          }
-        )
+    let publishToAggregatesQueueUrls = allAggregates->Dict.mapValues(agg =>
+      agg.commandTopic->Pulumi.Output.flatMap(ct =>
+        switch ct.resources->Array.get(0) {
+        | Some(r) => r.id
+        | None => Pulumi.Output.make("")
+        }
       )
+    )
 
     let publishCommands: Task.publishCommands = (aggregateName, cmdJsons) => {
       (publishToAggregates->Dict.get(aggregateName)->Option.getOrThrow)(cmdJsons)
@@ -218,17 +220,18 @@ module Make = (
     // scheduler's invoker URN. Bundled adapters thread these into the
     // deployed handler so it can talk to the underlying scheduler service;
     // adapters without a real scheduler ignore the dict.
-    let schedulerConfig: option<TaskRuntime_Builder.schedulerConfig> =
-      sideEffectHandler->Option.flatMap(seh => {
-        let sehOutputs = seh->Component.outputs
-        sehOutputs.eventCollector.resources
-        ->Array.get(0)
-        ->Option.map(r => {
-          TaskRuntime_Builder.schedulerRoleUrn: schedulerRoleUrn,
-          targetUrn: r.urn,
-          targetName: r.name,
-        })
+    let schedulerConfig: option<
+      TaskRuntime_Builder.schedulerConfig,
+    > = sideEffectHandler->Option.flatMap(seh => {
+      let sehOutputs = seh->Component.outputs
+      sehOutputs.eventCollector.resources
+      ->Array.get(0)
+      ->Option.map(r => {
+        TaskRuntime_Builder.schedulerRoleUrn,
+        targetUrn: r.urn,
+        targetName: r.name,
       })
+    })
 
     let bucketNames = config.buckets->Option.map(buckets =>
       buckets