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

package/src/plugin/component/Plugin_SubscriptionSchema.res

@@ -24,9 +24,10 @@ open ReventlessInfra.Api
 // CommandAccepted | CommandRejected | CommandPending). AppSync requires the
 // subscription return type to be a strict subset of the linked mutation's
 // return type, so the subscription field has to declare CommandResult as well.
-let sourceCFields = (
-  ~mutationEntries: array<mutationSchemaEntry>,
-): (array<string>, array<GraphQL_Stitcher.subscriptionSource>) => {
+let sourceCFields = (~mutationEntries: array<mutationSchemaEntry>): (
+  array<string>,
+  array<GraphQL_Stitcher.subscriptionSource>,
+) => {
   let fields: array<string> = []
   let sources: array<GraphQL_Stitcher.subscriptionSource> = []
   let pushField = (fieldName: string) => {
@@ -77,9 +78,10 @@ let sourceCFields = (
 // Returns (subscriptionFields, supportingTypes) — the supporting type is the
 // {DisplayName}EventLogEvent type that carries position, eventType, and payload.
 
-let sourceAFieldsAndTypes = (
-  ~eventLogEntries: array<eventLogSchemaEntry>,
-): (array<string>, array<string>) => {
+let sourceAFieldsAndTypes = (~eventLogEntries: array<eventLogSchemaEntry>): (
+  array<string>,
+  array<string>,
+) => {
   let seen: Set.t<string> = Set.make()
   let fields: array<string> = []
   let types: array<string> = []

package/src/plugin/component/SchemaWalker.res

@@ -160,22 +160,21 @@ let walkSchema = (typeName: string, schema: S.t<unknown>): typeSchema =>
       // It's an optional/nullable scalar at the top level, treat as unknown.
       {typeName, kind: "unknown", fields: [], structuralHash: ""}
     } else {
-      let constructors =
-        anyOf->Array.filterMap(variantSchema =>
-          switch variantSchema {
-          | Object({properties}) =>
-            tagConstOf(properties)->Option.map(name => {
-              name,
-              fields: extractFields(properties),
-            })
-          | _ => None
-          }
-        )
+      let constructors = anyOf->Array.filterMap(variantSchema =>
+        switch variantSchema {
+        | Object({properties}) =>
+          tagConstOf(properties)->Option.map(name => {
+            name,
+            fields: extractFields(properties),
+          })
+        | _ => None
+        }
+      )
       {
         typeName,
         kind: "variant",
         fields: [],
-        constructors: constructors,
+        constructors,
         structuralHash: hashConstructors(constructors),
       }
     }

package/src/plugin/connect/PluginConnectExtension_Mapping.res

@@ -27,63 +27,58 @@ module type Spec = {
 }
 
 module Make = (Spec: Spec) => {
-  module ConnectPluginMapping = ExtensionMapping.Make(
-    {
-      module ExtensionPoint = PluginExtensionPointSpec
-      module Delegate = ReventlessInfra.ExtensionMapping.NoDelegate
+  module ConnectPluginMapping = ExtensionMapping.Make({
+    module ExtensionPoint = PluginExtensionPointSpec
+    module Delegate = ReventlessInfra.ExtensionMapping.NoDelegate
 
-      // Unused by ExtensionMapping.Make (it reads Delegate.moduleUrl, not the
-      // arg's); present only to satisfy the input module type. The actually
-      // dynamic-imported specifier is the file-level `moduleUrl` (@@reventless.spec
-      // injected, move-safe) referenced from Plugin_Helpers.
-      let moduleUrl = PluginExtensionPointSpec.moduleUrl
+    // Unused by ExtensionMapping.Make (it reads Delegate.moduleUrl, not the
+    // arg's); present only to satisfy the input module type. The actually
+    // dynamic-imported specifier is the file-level `moduleUrl` (@@reventless.spec
+    // injected, move-safe) referenced from Plugin_Helpers.
+    let moduleUrl = PluginExtensionPointSpec.moduleUrl
 
-      let delegateModuleUrl = Delegate.moduleUrl
+    let delegateModuleUrl = Delegate.moduleUrl
 
-      let mapIncomingEvent: ReventlessInfra.ExtensionMapping.mapIncomingEvent<
-        PluginExtensionPointSpec.event,
-        Delegate.command,
-        PluginExtensionPointSpec.command,
-        PluginExtensionPointSpec.directive,
-      > = (pluginId, event, _meta, _pluginDef, _queryEngine) => {
-        let pluginDefinition = Spec.pluginDefinition
-        let id = pluginDefinition.id
+    let mapIncomingEvent: ReventlessInfra.ExtensionMapping.mapIncomingEvent<
+      PluginExtensionPointSpec.event,
+      Delegate.command,
+      PluginExtensionPointSpec.command,
+      PluginExtensionPointSpec.directive,
+    > = (pluginId, event, _meta, _pluginDef, _queryEngine) => {
+      let pluginDefinition = Spec.pluginDefinition
+      let id = pluginDefinition.id
 
-        switch event {
-        // Answer the handshake, and — when this plugin ships a UI-fragment manifest — register
-        // it with the admin UiFragmentRegistry slice in the same step (the admin EP's
-        // UI-fragment mapping routes RegisterUiFragment to the slice). Nested switch (not
-        // Array.concat) so the outer branch's expected type disambiguates the bare
-        // PublishExtensionPointCommand constructor.
-        | PluginExtensionPointSpec.UnknownPluginDetected if pluginId == id =>
-          switch Spec.uiFragments {
-          | Some(manifest) => [
-              PublishExtensionPointCommand(
-                id,
-                PluginExtensionPointSpec.ConnectPlugin(pluginDefinition),
-              ),
-              PublishExtensionPointCommand(
-                id,
-                PluginExtensionPointSpec.RegisterUiFragment(manifest),
-              ),
-            ]
-          | None => [
-              PublishExtensionPointCommand(
-                id,
-                PluginExtensionPointSpec.ConnectPlugin(pluginDefinition),
-              ),
-            ]
-          }
-        // A peer's PluginConnected / PluginDeactivated used to subscribe or
-        // unsubscribe this plugin's own queue to peer EP topics. Admin owns that
-        // now (manageSubscriptions), so these drop to no-ops.
-        | _ => []
+      switch event {
+      // Answer the handshake, and — when this plugin ships a UI-fragment manifest — register
+      // it with the admin UiFragmentRegistry slice in the same step (the admin EP's
+      // UI-fragment mapping routes RegisterUiFragment to the slice). Nested switch (not
+      // Array.concat) so the outer branch's expected type disambiguates the bare
+      // PublishExtensionPointCommand constructor.
+      | PluginExtensionPointSpec.UnknownPluginDetected if pluginId == id =>
+        switch Spec.uiFragments {
+        | Some(manifest) => [
+            PublishExtensionPointCommand(
+              id,
+              PluginExtensionPointSpec.ConnectPlugin(pluginDefinition),
+            ),
+            PublishExtensionPointCommand(id, PluginExtensionPointSpec.RegisterUiFragment(manifest)),
+          ]
+        | None => [
+            PublishExtensionPointCommand(
+              id,
+              PluginExtensionPointSpec.ConnectPlugin(pluginDefinition),
+            ),
+          ]
         }
+      // A peer's PluginConnected / PluginDeactivated used to subscribe or
+      // unsubscribe this plugin's own queue to peer EP topics. Admin owns that
+      // now (manageSubscriptions), so these drop to no-ops.
+      | _ => []
       }
+    }
 
-      let mapOutgoingEvent = None
-    },
-  )
+    let mapOutgoingEvent = None
+  })
 
   module ConnectPluginMappings = {
     module Spec = PluginExtensionPointSpec

package/src/plugin/lifecycle/PluginBehavior.res

@@ -54,9 +54,7 @@ let highestConnected = (known: dict<knownVersion>): option<version> =>
   )
 
 // Highest Connected version other than `exclude`.
-let highestConnectedExcluding = (known: dict<knownVersion>, exclude: version): option<
-  version,
-> =>
+let highestConnectedExcluding = (known: dict<knownVersion>, exclude: version): option<version> =>
   known
   ->Dict.toArray
   ->Array.reduce(None, (acc, (v, kv)) =>
@@ -150,7 +148,8 @@ let decide = (state, command) =>
     // definition (e.g. a newly added `kind`, updated protocols) re-emit
     // VersionConnected to overwrite the stored def and re-project the row. The version
     // is already current, so connectEvents' supersede stays empty — a bare refresh.
-    | Some({status: Connected, definition}) => definition == def ? Ok([]) : Ok([VersionConnected(def)])
+    | Some({status: Connected, definition}) =>
+      definition == def ? Ok([]) : Ok([VersionConnected(def)])
     | _ => Ok(connectEvents(state, v, def))
     }
   | Disconnect(v) =>

package/src/plugin/lifecycle/PluginSpec.res

@@ -102,7 +102,6 @@ let commandTransition = (command: command): Reventless.Transition.t<lifecycleSta
   | Disconnect(_) => Moves([Plugins.Connected], Plugins.Disconnected)
   | Activate(_) => Moves([Plugins.Inactive, Plugins.Retired], Plugins.Connected)
   | Deactivate(_) => Moves([Plugins.Connected, Plugins.Disconnected], Plugins.Inactive)
-  | Retire(_) =>
-    Moves([Plugins.Connected, Plugins.Disconnected, Plugins.Inactive], Plugins.Retired)
+  | Retire(_) => Moves([Plugins.Connected, Plugins.Disconnected, Plugins.Inactive], Plugins.Retired)
   }
 }

package/src/plugin/lifecycle/PluginsProjection.res

@@ -24,7 +24,9 @@ module Util = {
   // Every version this row knows to be currently Connected — the `other` set
   // plus the row's own version when its status is Connected.
   let connectedVersions = (state: PluginsReadModelSpec.state): array<Reventless.Plugin.version> =>
-    isConnected(state.status) ? state.otherConnectedVersions->withVersion(state.version) : state.otherConnectedVersions
+    isConnected(state.status)
+      ? state.otherConnectedVersions->withVersion(state.version)
+      : state.otherConnectedVersions
 
   // Highest version (compareVersions) in the set, or None for an empty set.
   let highest = (versions: array<Reventless.Plugin.version>): option<Reventless.Plugin.version> =>
@@ -83,7 +85,7 @@ module PluginMapping = Reventless.Projection.Mapping.Make(
   PluginSpec,
   PluginsReadModelSpec,
   {
-    let project = ({event, id, meta: {time, user: ?user}}) => {
+    let project = ({event, id, meta: {time, ?user}}) => {
       let statusChange = {at: time, by: user->Option.getOr("")}
       switch event {
       // Handshake trigger, supersession record and incompatibility
@@ -133,7 +135,10 @@ module PluginMapping = Reventless.Projection.Mapping.Make(
           state =>
             state.version == def.version
               ? {...state, status: Disconnected, statusChange}
-              : {...state, otherConnectedVersions: state.otherConnectedVersions->Util.without(def.version)},
+              : {
+                  ...state,
+                  otherConnectedVersions: state.otherConnectedVersions->Util.without(def.version),
+                },
         )
       | VersionDeactivated(def) =>
         Reventless.Projection.UpdateWithDefault(
@@ -142,7 +147,10 @@ module PluginMapping = Reventless.Projection.Mapping.Make(
           state =>
             state.version == def.version
               ? {...state, status: Inactive, statusChange}
-              : {...state, otherConnectedVersions: state.otherConnectedVersions->Util.without(def.version)},
+              : {
+                  ...state,
+                  otherConnectedVersions: state.otherConnectedVersions->Util.without(def.version),
+                },
         )
       | VersionRetired(def) =>
         Reventless.Projection.UpdateWithDefault(
@@ -151,7 +159,10 @@ module PluginMapping = Reventless.Projection.Mapping.Make(
           state =>
             state.version == def.version
               ? {...state, status: Retired, statusChange}
-              : {...state, otherConnectedVersions: state.otherConnectedVersions->Util.without(def.version)},
+              : {
+                  ...state,
+                  otherConnectedVersions: state.otherConnectedVersions->Util.without(def.version),
+                },
         )
       }
     }

package/src/plugin/lifecycle/PluginsReadModelSpec.res

@@ -114,5 +114,3 @@ type queryResult = {
   dcbEventLog: option<Reventless.Plugin.dcbEventLogDefinition>,
   kind: option<Reventless.Plugin.pluginKind>,
 }
-
-

package/src/util/CommandPublisher.res

@@ -26,7 +26,10 @@ module Make = (Spec: Spec, Config: Config) => {
       try await promise catch {
       | JsExn(e) =>
         let errMsg = e->JsExn.message->Option.getOr("unknown")
-        EffectLogger.logError(~comp="CommandPublisher", `Couldn't publish commands: ${errMsg}`)->Effect.runSync
+        EffectLogger.logError(
+          ~comp="CommandPublisher",
+          `Couldn't publish commands: ${errMsg}`,
+        )->Effect.runSync
       }
     }
 
@@ -72,7 +75,11 @@ module Make = (Spec: Spec, Config: Config) => {
         let promise = Config.publishCommands(Spec.name, commandsToSend->toJsons)
         running := Some(promise)
         switch await promise {
-        | () => EffectLogger.logDebug(~comp="CommandPublisher", `send: finished chunk ${chunkCountStr}: ${sizeStr}`)->Effect.runSync
+        | () =>
+          EffectLogger.logDebug(
+            ~comp="CommandPublisher",
+            `send: finished chunk ${chunkCountStr}: ${sizeStr}`,
+          )->Effect.runSync
         | exception JsExn(e) =>
           let errorMessage = e->JsExn.message->Option.getOr("unknown Error")
           EffectLogger.logError(

package/src/util/CsvStream.res

@@ -17,7 +17,8 @@
 let parseRows = (~path: string): Stream.t<CSV.row, string, unit> =>
   Queue.unbounded()
   ->Effect.flatMap(queue => {
-    let _ = CSV.parseFile(~path, ~options={headers: CSV.Options.Bool(true)})
+    let _ =
+      CSV.parseFile(~path, ~options={headers: CSV.Options.Bool(true)})
       ->CSV.onData(row => Queue.offer(queue, Ok(row))->Effect.runSyncExit->ignore)
       ->CSV.onEnd(_ => Queue.shutdown(queue)->Effect.runSyncExit->ignore)
       ->CSV.onError(err => {
@@ -29,8 +30,7 @@ let parseRows = (~path: string): Stream.t<CSV.row, string, unit> =>
   })
   ->Stream.fromEffect
   ->Stream.flatMap(queue =>
-    Stream.fromQueue(queue)
-    ->Stream.mapEffect(item =>
+    Stream.fromQueue(queue)->Stream.mapEffect(item =>
       switch item {
       | Ok(row) => Effect.succeed(row)
       | Error(msg) => Effect.fail(msg)

package/src/util/Interstack.res

@@ -1,9 +1,7 @@
 let platformStackReference =
   Pulumi.Config.make(Some("platform"))
   ->Pulumi.Config.get("stack")
-  ->Option.map(stack =>
-    Pulumi.StackReference.makeWithName(stack ++ "-interstack", {"name": stack})
-  )
+  ->Option.map(stack => Pulumi.StackReference.makeWithName(stack ++ "-interstack", {"name": stack}))
 
 // -----------------------------------------------------------------------
 // Typed, validated cross-stack queries using the reventless-interop engine.
@@ -21,11 +19,9 @@ module DefaultTaskQuery = ReventlessInterop.Query.Task.Make({
   let requiredFields = ["name"]
   let optionalFields = ["bucketNames", "sideEffectSources"]
   let fromJson = (json: JSON.t) =>
-    try Ok(json->S.parseOrThrow(~to=ReventlessInterop.Task.resolvedOutputsSchema))
-    catch {
+    try Ok(json->S.parseOrThrow(~to=ReventlessInterop.Task.resolvedOutputsSchema)) catch {
     | exn =>
-      let msg =
-        exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("parse error")
+      let msg = exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("parse error")
       Error(msg)
     }
 })
@@ -35,11 +31,9 @@ module DefaultEventMapperQuery = ReventlessInterop.Query.EventMapper.Make({
   let requiredFields = ["name", "eventCollector"]
   let optionalFields = ["counter"]
   let fromJson = (json: JSON.t) =>
-    try Ok(json->S.parseOrThrow(~to=ReventlessInterop.EventMapper.resolvedOutputsSchema))
-    catch {
+    try Ok(json->S.parseOrThrow(~to=ReventlessInterop.EventMapper.resolvedOutputsSchema)) catch {
     | exn =>
-      let msg =
-        exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("parse error")
+      let msg = exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("parse error")
       Error(msg)
     }
 })
@@ -54,11 +48,9 @@ module DefaultExtensionPointQuery = ReventlessInterop.Query.ExtensionPoint.Make(
   let requiredFields = ["name", "commandTopic", "eventTopic"]
   let optionalFields = []
   let fromJson = (json: JSON.t) =>
-    try Ok(json->S.parseOrThrow(~to=ReventlessInterop.ExtensionPoint.resolvedOutputsSchema))
-    catch {
+    try Ok(json->S.parseOrThrow(~to=ReventlessInterop.ExtensionPoint.resolvedOutputsSchema)) catch {
     | exn =>
-      let msg =
-        exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("parse error")
+      let msg = exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("parse error")
       Error(msg)
     }
 })

package/src/util/Interstack.resi

@@ -20,6 +20,6 @@ let mergeEventMappers: array<ReventlessInterop.EventMapper.resolvedOutputs> => P
   array<ReventlessInterop.EventMapper.resolvedOutputs>,
 >
 
-let mergeExtensionPoints: array<ReventlessInterop.ExtensionPoint.resolvedOutputs> => Pulumi.Output.t<
-  array<ReventlessInterop.ExtensionPoint.resolvedOutputs>,
->
+let mergeExtensionPoints: array<
+  ReventlessInterop.ExtensionPoint.resolvedOutputs,
+> => Pulumi.Output.t<array<ReventlessInterop.ExtensionPoint.resolvedOutputs>>

package/src/util/LogFormat.res

@@ -59,23 +59,21 @@ let truncate = (s: string): string => {
     s
   } else {
     `${s->String.slice(~start=0, ~end=maxValueChars)}…(+${(len - maxValueChars)
-      ->Int.toString} chars)`
+        ->Int.toString} chars)`
   }
 }
 
 // ─── Commands ────────────────────────────────────────────────────────────────
 
 // "Add"  (bold)
-let cmdName = (msg: Message.commandJson): string =>
-  msg.commandJson->Message.variantNameOfJson->bold
+let cmdName = (msg: Message.commandJson): string => msg.commandJson->Message.variantNameOfJson->bold
 
 // "[Add,Remove]"
 let cmdNames = (msgs: array<Message.commandJson>): string =>
   `[${msgs->Array.map(cmdName)->Array.join(",")}]`
 
 // "Add(1)"
-let cmdSummary = (msg: Message.commandJson): string =>
-  `${msg->cmdName}(${msg.id})`
+let cmdSummary = (msg: Message.commandJson): string => `${msg->cmdName}(${msg.id})`
 
 // "[Add(1),Remove(2)]"
 let cmdSummaries = (msgs: array<Message.commandJson>): string =>
@@ -150,8 +148,7 @@ let cmdFulls = (msgs: array<Message.commandJson>): string =>
 // ─── Events (JSON.t event' envelope) ─────────────────────────────────────────
 
 // "Added"  (bold)
-let eventName = (j: JSON.t): string =>
-  j->Message.eventNameOfEvent'Json->bold
+let eventName = (j: JSON.t): string => j->Message.eventNameOfEvent'Json->bold
 
 // "[Added,Removed]"
 let eventNames = (events: array<JSON.t>): string =>
@@ -260,8 +257,7 @@ let commandJsonsToLogMessages: array<Message.commandJson> => array<string> = cmd
     `${idx}/${count}: ${cmdJson->cmdSummary}: ${cmdJson->cmdFull}`
   })
 }
-let event'JsonToLogMessage = (j: JSON.t): string =>
-  `${j->eventSummary}: ${j->eventFull}`
+let event'JsonToLogMessage = (j: JSON.t): string => `${j->eventSummary}: ${j->eventFull}`
 
 // Legacy concise aliases
 let fmtCmd = cmdSummary

package/src/util/Logger.res

@@ -196,8 +196,7 @@ let makeLoggerWith = (shouldLog: level => bool): t => {
 
 // Fixed-level logger — the level is baked at creation. Used by tests that assert
 // a specific minimum regardless of env/platform default.
-let makeLogger = (~minLevel=Info): t =>
-  makeLoggerWith(l => levelToInt(l) >= levelToInt(minLevel))
+let makeLogger = (~minLevel=Info): t => makeLoggerWith(l => levelToInt(l) >= levelToInt(minLevel))
 
 let silent: t = {
   debug: (~comp as _=?, ~data as _=?, _) => (),

package/src/util/Lru.res

@@ -36,7 +36,8 @@ let put = (cache: t<'k, 'v>, key: 'k, value: 'v): unit =>
     if cache.store->Map.size > cache.capacity {
       // Evict the least-recently-used entry = oldest insertion = first key.
       switch cache.store->Map.keys->Array.fromIterator->Array.get(0) {
-      | Some(oldest) => let _ = cache.store->Map.delete(oldest)
+      | Some(oldest) =>
+        let _ = cache.store->Map.delete(oldest)
       | None => ()
       }
     }

package/src/util/Lru.resi

@@ -10,7 +10,6 @@ next same-entity command reads only the delta instead of folding full history.
 `capacity`, `put` evicts the least-recently-used key. A `capacity <= 0` disables
 the cache entirely (`get` always misses, `put` is a no-op) so a slice can opt out.
 */
-
 type t<'k, 'v>
 
 /** Creates an empty cache holding at most `capacity` entries (`<= 0` disables it). */
@@ -26,7 +25,7 @@ let put: (t<'k, 'v>, 'k, 'v) => unit
 let invalidate: (t<'k, 'v>, 'k) => unit
 
 /** Drops every entry. */
-let clear: (t<'k, 'v>) => unit
+let clear: t<'k, 'v> => unit
 
 /** Current number of live entries. */
-let size: (t<'k, 'v>) => int
+let size: t<'k, 'v> => int

package/src/util/ScheduleOps.res

@@ -71,23 +71,20 @@ let create = (
     let name = schedule.name->resourceNaming.validateName
     let schedule = {...schedule, name}
     let createSchedule = scheduler.createSchedule
-    let exit =
-      await Effect.tryPromise(
-        ~catch=err => Util.Error.messageFromUnknown(err, "schedule create"),
-        () => createSchedule(channelResources, schedule),
-      )
-      ->Effect.tap(_ =>
-        EffectLogger.logInfo(
-          ~comp=__MODULE__,
-          `create: created ${schedule->JSON.stringifyAny->Option.getOr("")}`,
-        )
+    let exit = await Effect.tryPromise(
+      ~catch=err => Util.Error.messageFromUnknown(err, "schedule create"),
+      () => createSchedule(channelResources, schedule),
+    )
+    ->Effect.tap(_ =>
+      EffectLogger.logInfo(
+        ~comp=__MODULE__,
+        `create: created ${schedule->JSON.stringifyAny->Option.getOr("")}`,
       )
-      ->Effect.runPromiseExit
+    )
+    ->Effect.runPromiseExit
     if !(exit->Exit.isSuccess) {
-      let errMsg = exit->Exit.match(
-        ~onFailure=cause => cause->Cause.pretty,
-        ~onSuccess=_ => "unknown",
-      )
+      let errMsg =
+        exit->Exit.match(~onFailure=cause => cause->Cause.pretty, ~onSuccess=_ => "unknown")
       EffectLogger.logError(
         ~comp=__MODULE__,
         `create: couldn't create ${schedule
@@ -106,19 +103,19 @@ let delete = (
   async name => {
     let name = name->resourceNaming.validateName
     let deleteSchedule = scheduler.deleteSchedule
-    let exit =
-      await Effect.tryPromise(
-        ~catch=err => Util.Error.messageFromUnknown(err, "schedule delete"),
-        () => deleteSchedule(channelResources, name),
-      )
-      ->Effect.tap(_ => EffectLogger.logInfo(~comp=__MODULE__, `delete: deleted ${name}`))
-      ->Effect.runPromiseExit
+    let exit = await Effect.tryPromise(
+      ~catch=err => Util.Error.messageFromUnknown(err, "schedule delete"),
+      () => deleteSchedule(channelResources, name),
+    )
+    ->Effect.tap(_ => EffectLogger.logInfo(~comp=__MODULE__, `delete: deleted ${name}`))
+    ->Effect.runPromiseExit
     if !(exit->Exit.isSuccess) {
-      let errMsg = exit->Exit.match(
-        ~onFailure=cause => cause->Cause.pretty,
-        ~onSuccess=_ => "unknown",
-      )
-      EffectLogger.logError(~comp=__MODULE__, `delete: couldn't delete ${name}: ${errMsg}`)->Effect.runSync
+      let errMsg =
+        exit->Exit.match(~onFailure=cause => cause->Cause.pretty, ~onSuccess=_ => "unknown")
+      EffectLogger.logError(
+        ~comp=__MODULE__,
+        `delete: couldn't delete ${name}: ${errMsg}`,
+      )->Effect.runSync
       throw(ScheduleNotDeleted(name))
     }
   }

package/src/util/StorePrefixCollision.res

@@ -73,24 +73,21 @@ let collisionMessage = (c: collision): string => {
     | None => ""
     }
   let sites = site(c.first) ++ site(c.second)
-  let where = sites == ""
-    ? `  Both keys appear in the platform's generated capability file, which records each ` ++
-      `declaring component and field as a comment.\n`
-    : sites
+  let where =
+    sites == ""
+      ? `  Both keys appear in the platform's generated capability file, which records each ` ++ `declaring component and field as a comment.\n`
+      : sites
   if c.nested {
     `Object store "${c.first.qualified}" is rooted at "${c.first.prefix}/", which encloses ` ++
     `"${c.second.qualified}" at "${c.second.prefix}/".\n` ++
     where ++
-    `  One store's objects would sit inside the other's — for serving, for upload grants and ` ++
-    `for a store wipe alike. Rename one of them.`
+    `  One store's objects would sit inside the other's — for serving, for upload grants and ` ++ `for a store wipe alike. Rename one of them.`
   } else {
     `Object stores "${c.first.qualified}" and "${c.second.qualified}" both root their objects ` ++
     `at "${c.first.prefix}/".\n` ++
     where ++
     `  A platform serves one cache behavior per prefix and scopes upload grants by prefix, so ` ++
     `two stores cannot share one.\n` ++
-    `  Rename one store, or — if they were meant to be one shared store — qualify the ` ++
-    `\`@storageRef\` annotation with the owning plugin.`
+    `  Rename one store, or — if they were meant to be one shared store — qualify the ` ++ `\`@storageRef\` annotation with the owning plugin.`
   }
 }
-

package/src/util/Util_Promise.res

@@ -52,7 +52,10 @@ let onEndHandler = async (flush, resolve) => {
   let _ = switch await flush() {
   | _res => resolve()
   | exception JsExn(e) =>
-    EffectLogger.logError(~comp=__MODULE__, `${__LOC__}: ${e->JsExn.message->Option.getOr("unknown")}`)->Effect.runSync
+    EffectLogger.logError(
+      ~comp=__MODULE__,
+      `${__LOC__}: ${e->JsExn.message->Option.getOr("unknown")}`,
+    )->Effect.runSync
   }
 }
 

package/src/util/Util_Promise.res.mjs

@@ -70,7 +70,7 @@ async function onEndHandler(flush, resolve) {
   } catch (raw_e) {
     let e = Primitive_exceptions.internalToException(raw_e);
     if (e.RE_EXN_ID === "JsExn") {
-      Effect.runSync(EffectLogger$ReventlessCore.logError("Util_Promise-ReventlessCore", undefined, "File \"Util_Promise.res\", line 55, characters 47-54" + `: ` + Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "unknown")));
+      Effect.runSync(EffectLogger$ReventlessCore.logError("Util_Promise-ReventlessCore", undefined, "File \"Util_Promise.res\", line 57, characters 9-16" + `: ` + Stdlib_Option.getOr(Stdlib_JsExn.message(e._1), "unknown")));
     } else {
       throw e;
     }