@reventlessdev/reventless-local 3.0.0-alpha.249 → 3.0.0-alpha.250

package/src/ShellConfig.res

@@ -41,11 +41,7 @@ let manifestUrlOf = (config: ReventlessInfra.Platform.bakedManifest): string =>
 // caller matching no declared group gets and what every existing deployment has.
 let journeyManifestsKey = "journeyManifestUrls"
 
-let computedKeys = [
-  "manifestUrl",
-  journeyManifestsKey,
-  ReventlessCore.Platform_UiSlots.configKey,
-]
+let computedKeys = ["manifestUrl", journeyManifestsKey, ReventlessCore.Platform_UiSlots.configKey]
 
 /**
  The overlay this platform puts on top of the shipped `config.json`.
@@ -96,8 +92,9 @@ let overlay = (
     if collisions->Array.length > 0 {
       JsError.throwWithMessage(
         "host UI config.json: shellConfig sets key(s) the platform already computes — " ++
-        collisions->Array.join(", ") ++
-        ". Remove them from shellConfig; a passthrough cannot redirect a computed key.",
+        collisions->Array.join(
+          ", ",
+        ) ++ ". Remove them from shellConfig; a passthrough cannot redirect a computed key.",
       )
     }
     extra->Dict.forEachWithKey((v, k) => out->Dict.set(k, v))
@@ -134,12 +131,10 @@ let emit = (
 ) => {
   let overlay = overlay(~bakedManifest, ~uiSlotsFile?, ~shellConfig)
 
-  switch (
-    switch dir {
-    | Some(_) as given => given
-    | None => HostShellDist.dir()
-    }
-  ) {
+  switch switch dir {
+  | Some(_) as given => given
+  | None => HostShellDist.dir()
+  } {
   | None =>
     // Nothing declared and no shell installed is the ordinary case for a
     // platform nobody points a browser at; only a declaration makes the missing
@@ -148,8 +143,7 @@ let emit = (
       JsError.throwWithMessage(
         `host UI config.json: cannot resolve ${HostShellDist.package} from ${NodeProcess.cwd()} — ` ++
         `the local shell reads its config from that package's dist/, so declaring shell ` ++
-        `config without the package installed would write nothing and leave the shell ` ++
-        `configured as it shipped.`,
+        `config without the package installed would write nothing and leave the shell ` ++ `configured as it shipped.`,
       )
     }
   | Some(dir) =>
@@ -163,8 +157,7 @@ let emit = (
       if !NodeFs.existsSync(path) {
         JsError.throwWithMessage(
           `host UI config.json: ${HostShellDist.package} ships no ${fileName} at ${dir} — ` ++
-          `there is no baseline to overlay, so the shell would boot with only the keys ` ++
-          `declared here and none of the ones it expects.`,
+          `there is no baseline to overlay, so the shell would boot with only the keys ` ++ `declared here and none of the ones it expects.`,
         )
       }
       NodeFs.writeFileSync(baselinePath, NodeFs.readFileSync(path))

package/src/UiHints.res

@@ -50,27 +50,23 @@ let emit = (
     | exception _ =>
       JsError.throwWithMessage(
         `host UI ${fileName}: cannot read the declared uiHintsFile at ${path} — ` ++
-        `the shell fetches this file at boot, so a declaration pointing nowhere ` ++
-        `applies no hints and says nothing about why.`,
+        `the shell fetches this file at boot, so a declaration pointing nowhere ` ++ `applies no hints and says nothing about why.`,
       )
     }
     switch source->JSON.parseOrThrow {
     | _ => ()
     | exception _ =>
       JsError.throwWithMessage(
-        `host UI ${fileName}: the declared uiHintsFile at ${path} is not JSON — ` ++
-        `the shell warns once and applies no hints, which reads as hints that do nothing.`,
+        `host UI ${fileName}: the declared uiHintsFile at ${path} is not JSON — ` ++ `the shell warns once and applies no hints, which reads as hints that do nothing.`,
       )
     }
     source
   })
 
-  switch (
-    switch dir {
-    | Some(_) as given => given
-    | None => HostShellDist.dir()
-    }
-  ) {
+  switch switch dir {
+  | Some(_) as given => given
+  | None => HostShellDist.dir()
+  } {
   | None =>
     // No shell installed is the ordinary case for a platform nobody points a
     // browser at; only a declaration makes the missing package an error.
@@ -78,8 +74,7 @@ let emit = (
       JsError.throwWithMessage(
         `host UI ${fileName}: cannot resolve ${HostShellDist.package} from ${NodeProcess.cwd()} — ` ++
         `the local shell reads its hints from that package's dist/, so declaring a ` ++
-        `uiHintsFile without the package installed would write nothing and leave the ` ++
-        `shell applying whatever the package shipped.`,
+        `uiHintsFile without the package installed would write nothing and leave the ` ++ `shell applying whatever the package shipped.`,
       )
     }
   | Some(dir) =>
@@ -148,8 +143,7 @@ let watch = (
       // away between the two — worth a line, not worth a throw.
       log.warn(
         ~comp="UiHints",
-        `not watching ${base}: ${sourceDir} does not exist, so changes to the declared ` ++
-        `uiHintsFile will need a restart`,
+        `not watching ${base}: ${sourceDir} does not exist, so changes to the declared ` ++ `uiHintsFile will need a restart`,
       )
       None
     } else {

package/src/UiSlots.res

@@ -66,18 +66,15 @@ let emit = (
     | exception _ =>
       JsError.throwWithMessage(
         `host UI ${fileName}: cannot read the declared uiSlotsFile at ${path} — ` ++
-        `the shell imports this file at boot, so a declaration pointing nowhere ` ++
-        `registers no renderers and says nothing about why.`,
+        `the shell imports this file at boot, so a declaration pointing nowhere ` ++ `registers no renderers and says nothing about why.`,
       )
     }
   )
 
-  switch (
-    switch dir {
-    | Some(_) as given => given
-    | None => HostShellDist.dir()
-    }
-  ) {
+  switch switch dir {
+  | Some(_) as given => given
+  | None => HostShellDist.dir()
+  } {
   | None =>
     // No shell installed is the ordinary case for a platform nobody points a
     // browser at; only a declaration makes the missing package an error.
@@ -85,8 +82,7 @@ let emit = (
       JsError.throwWithMessage(
         `host UI ${fileName}: cannot resolve ${HostShellDist.package} from ${NodeProcess.cwd()} — ` ++
         `the local shell imports its slot renderers from that package's dist/, so ` ++
-        `declaring a uiSlotsFile without the package installed would write nothing ` ++
-        `and leave every mode drawing its own regions.`,
+        `declaring a uiSlotsFile without the package installed would write nothing ` ++ `and leave every mode drawing its own regions.`,
       )
     }
   | Some(dir) =>
@@ -132,11 +128,9 @@ let emit = (
  `onReload` runs only after a re-copy actually succeeded, so a subscriber cannot
  be told to re-import a file that did not change.
  */
-let watch = (
-  ~uiSlotsFile: option<string>,
-  ~dir: option<string>=?,
-  ~onReload: unit => unit,
-): option<NodeFs.watcher> =>
+let watch = (~uiSlotsFile: option<string>, ~dir: option<string>=?, ~onReload: unit => unit): option<
+  NodeFs.watcher,
+> =>
   uiSlotsFile->Option.flatMap(path => {
     // Named apart from the `~dir` above, which is where the file is SERVED. This
     // is where it is AUTHORED, and the two are never the same place — letting
@@ -150,8 +144,7 @@ let watch = (
       // away between the two — worth a line, not worth a throw.
       log.warn(
         ~comp="UiSlots",
-        `not watching ${base}: ${sourceDir} does not exist, so changes to the declared ` ++
-        `uiSlotsFile will need a restart`,
+        `not watching ${base}: ${sourceDir} does not exist, so changes to the declared ` ++ `uiSlotsFile will need a restart`,
       )
       None
     } else {

package/src/adapter/Api/LocalEvents_Server.res

@@ -27,8 +27,7 @@ let log = ReventlessCore.Logger.fromEnv()
 
 // Mirrors AppSyncEventsSigner_Ops.pathSegment (aws) and the client's channel
 // normalizer: any char outside [A-Za-z0-9-] becomes `-`.
-let pathSegment = (s: string): string =>
-  s->String.replaceRegExp(/[^A-Za-z0-9-]/g, "-")
+let pathSegment = (s: string): string => s->String.replaceRegExp(/[^A-Za-z0-9-]/g, "-")
 
 let clientChannelPrefix = "/client/"
 
@@ -172,7 +171,10 @@ let broadcastStateChange = (~name: string, ~descriptor: JSON.t): unit => {
 // -- Inbound frames (subscribe side) -----------------------------------------
 
 let decodeStringField = (json: JSON.t, field: string): option<string> =>
-  json->JSON.Decode.object->Option.flatMap(o => o->Dict.get(field))->Option.flatMap(JSON.Decode.string)
+  json
+  ->JSON.Decode.object
+  ->Option.flatMap(o => o->Dict.get(field))
+  ->Option.flatMap(JSON.Decode.string)
 
 /** Handle one client→server text frame on an established connection. */
 let handleFrame = (conn: connection, text: string): unit => {

package/src/adapter/Api/LocalGraphQL_Adapter.res

@@ -7,10 +7,10 @@
 type api = unit
 type role = unit
 
-let makeApiResource = (
-  ~name as _: string,
-  ~opts as _: Pulumi.ComponentResource.options,
-): (Pulumi.Output.t<api>, Pulumi.Output.t<role>) => (Pulumi.Output.make(()), Pulumi.Output.make(()))
+let makeApiResource = (~name as _: string, ~opts as _: Pulumi.ComponentResource.options): (
+  Pulumi.Output.t<api>,
+  Pulumi.Output.t<role>,
+) => (Pulumi.Output.make(), Pulumi.Output.make())
 
 let generateFragment = (
   ~mutationEntries: array<ReventlessInfra.Api.mutationSchemaEntry>,

package/src/adapter/Auth/LocalAuth.res

@@ -33,8 +33,7 @@ let adminUser: Identity.t = {
 // A `dict<Identity.t>` keyed by `username`. A4 hydrates this from
 // `.reventless/users.yaml`; tests inject via `registerUser`.
 
-let initialUsers = () =>
-  Dict.fromArray([("user", defaultUser), ("admin", adminUser)])
+let initialUsers = () => Dict.fromArray([("user", defaultUser), ("admin", adminUser)])
 
 let users: ref<dict<Identity.t>> = ref(initialUsers())
 
@@ -43,8 +42,7 @@ let registerUser = (~username: string, ~identity: Identity.t): unit =>
 
 let resetUsers = (): unit => users := initialUsers()
 
-let lookupUser = (username: string): option<Identity.t> =>
-  users.contents->Dict.get(username)
+let lookupUser = (username: string): option<Identity.t> => users.contents->Dict.get(username)
 
 // ── Header parsing ────────────────────────────────────────────────────────
 
@@ -240,11 +238,10 @@ module Login = {
    `activeRole` narrows the minted token to one of the caller's own roles; unset
    mints exactly what it has always minted.
    */
-  let issue = async (
-    ~username: string,
-    ~password: string,
-    ~activeRole: option<string>=?,
-  ): result<string, string> =>
+  let issue = async (~username: string, ~password: string, ~activeRole: option<string>=?): result<
+    string,
+    string,
+  > =>
     switch store.contents->Dict.get(username) {
     | Some({password: stored, identity}) if stored === password =>
       switch switch activeRole {
@@ -340,7 +337,6 @@ module Login = {
         }
       }
     }
-
 }
 
 // ── Provider implementation ───────────────────────────────────────────────
@@ -354,9 +350,7 @@ let _bearerToken = (header: string): option<string> =>
     None
   }
 
-let authenticate = async (
-  ctx: ReventlessCore.Auth_Adapter.requestContext,
-): Identity.authResult => {
+let authenticate = async (ctx: ReventlessCore.Auth_Adapter.requestContext): Identity.authResult => {
   // Decoding order: Bearer (when signature valid) → X-User/X-Groups → default.
   // A *present* Bearer that fails verification is rejected (AuthError) rather
   // than falling through to defaultUser — otherwise a client whose token was
@@ -402,5 +396,7 @@ let authenticate = async (
   }
 }
 
-let make = (~name as _: string, ~opts as _: option<Pulumi.ComponentResource.options>=?): Pulumi.Output.t<authConfig> =>
-  Pulumi.Output.make()
+let make = (
+  ~name as _: string,
+  ~opts as _: option<Pulumi.ComponentResource.options>=?,
+): Pulumi.Output.t<authConfig> => Pulumi.Output.make()

package/src/adapter/Auth/UserStore.res

@@ -83,11 +83,10 @@ let resolved: ref<bool> = ref(false)
 
 let resetResolution = (): unit => resolved := false
 
-let load = (
-  ~users: option<array<entry>>=?,
-  ~usersFile: option<string>=?,
-  (),
-): result<resolution, string> => {
+let load = (~users: option<array<entry>>=?, ~usersFile: option<string>=?, ()): result<
+  resolution,
+  string,
+> => {
   resolved := true
   switch users {
   | Some(entries) =>
@@ -109,8 +108,7 @@ let load = (
         })
       } else {
         Console.log(
-          "[LocalAuth] no users configured — POST /__inmemory/login will reject all. " ++
-          "Provide ~users / ~usersFile or create .reventless/users.yaml relative to cwd.",
+          "[LocalAuth] no users configured — POST /__inmemory/login will reject all. " ++ "Provide ~users / ~usersFile or create .reventless/users.yaml relative to cwd.",
         )
         Ok(Empty)
       }

package/src/adapter/Backend.res

@@ -30,11 +30,10 @@ let postgres = async (~connection, ~resetOnStart=false) => {
   }
   let initialCount =
     (await ReventlessPostgres.EventLogStorage_Postgres.countAll(pool)) +
-      (await ReventlessPostgres.DcbEventLogStorage_Postgres.countAll(pool))
+    (await ReventlessPostgres.DcbEventLogStorage_Postgres.countAll(pool))
   Postgres({pool, initialCount, connection})
 }
 
-
 // Deletes a file if it exists. No-op if the path is missing.
 
 let removeFileIfExists = (path: string) =>

package/src/adapter/CommandGenerator/CommandGeneratorResolvers_GraphQL.res

@@ -35,15 +35,14 @@ let extractIdentity = (ctx: JSON.t): Reventless.Identity.t => {
 // Returns a `CommandRejected` outcome with a fresh msgId so the GraphQL union
 // resolves consistently — matches the existing CommandResult contract.
 
-let rejectForbidden = (~field: string): JSON.t =>
-  JSON.Object(
-    Dict.fromArray([
-      ("__typename", JSON.String("CommandRejected")),
-      ("msgId", JSON.String(ReventlessCore.Message.uuid())),
-      ("errorCode", JSON.String("Forbidden")),
-      ("errorDetail", JSON.String(`Mutation.${field}: identity is not authorized`)),
-    ]),
-  )
+let rejectForbidden = (~field: string): JSON.t => JSON.Object(
+  Dict.fromArray([
+    ("__typename", JSON.String("CommandRejected")),
+    ("msgId", JSON.String(ReventlessCore.Message.uuid())),
+    ("errorCode", JSON.String("Forbidden")),
+    ("errorDetail", JSON.String(`Mutation.${field}: identity is not authorized`)),
+  ]),
+)
 
 // -- Plugin status gate -------------------------------------------------------
 // Set by the platform after Admin.construct to wire a per-mutation lookup against
@@ -61,15 +60,18 @@ let pluginStatusGate: ref<option<string => option<(string, string)>>> = ref(None
 let setPluginStatusGate = fn => pluginStatusGate := Some(fn)
 let resetPluginStatusGate = () => pluginStatusGate := None
 
-let rejectPluginStatus = (~field: string, ~errorCode: string, ~detail: string): JSON.t =>
-  JSON.Object(
-    Dict.fromArray([
-      ("__typename", JSON.String("CommandRejected")),
-      ("msgId", JSON.String(ReventlessCore.Message.uuid())),
-      ("errorCode", JSON.String(errorCode)),
-      ("errorDetail", JSON.String(`Mutation.${field}: ${detail}`)),
-    ]),
-  )
+let rejectPluginStatus = (
+  ~field: string,
+  ~errorCode: string,
+  ~detail: string,
+): JSON.t => JSON.Object(
+  Dict.fromArray([
+    ("__typename", JSON.String("CommandRejected")),
+    ("msgId", JSON.String(ReventlessCore.Message.uuid())),
+    ("errorCode", JSON.String(errorCode)),
+    ("errorDetail", JSON.String(`Mutation.${field}: ${detail}`)),
+  ]),
+)
 
 let checkPluginStatus = (~field: string): option<JSON.t> =>
   switch pluginStatusGate.contents {
@@ -92,8 +94,7 @@ let checkPluginStatus = (~field: string): option<JSON.t> =>
 let syntheticCommand = (cname: string, ~hasPayload: bool): unknown =>
   hasPayload ? {"TAG": cname}->Obj.magic : cname->Obj.magic
 
-let capitalize = s =>
-  s->String.charAt(0)->String.toUpperCase ++ s->String.slice(~start=1)
+let capitalize = s => s->String.charAt(0)->String.toUpperCase ++ s->String.slice(~start=1)
 
 // -- CommandResult SDL types --------------------------------------------------
 // Source of truth lives in GraphQL_FragmentGenerator.commandResultSdlTypes so
@@ -194,7 +195,10 @@ let register = (
   // Aggregate commands target a specific instance — prepend id: ID!
   let sdlFields = fields->Array.map(field => {
     let variantIndex = variantIndexForField(commandSchema, ~field)
-    let sdl = deriveSdlField(~fieldName=field, extractVariantSchema(commandSchema, ~index=variantIndex))
+    let sdl = deriveSdlField(
+      ~fieldName=field,
+      extractVariantSchema(commandSchema, ~index=variantIndex),
+    )
     if sdl->String.includes("(") {
       sdl->String.replace(`${field}(`, `${field}(id: ID!, `)
     } else {
@@ -214,7 +218,11 @@ let register = (
     | _ => false
     }
     let commandName = extractCommandName(field)
-    let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (_root, args, ctx) => {
+    let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (
+      _root,
+      args,
+      ctx,
+    ) => {
       switch handlerRef.contents {
       | Some(generateCommand) =>
         switch checkPluginStatus(~field) {
@@ -265,19 +273,27 @@ let registerDcb = (
   // non-first constructor of a multi-command slice.
   let constructorNames = Reventless.DcbTag.extractAllVariantNames(commandSchema->Obj.magic)
   let variantIndex = variantIndexForField(commandSchema, ~field=fieldName)
-  let variantSchema = extractVariantSchema(commandSchema, ~index=variantIndex >= 0 ? variantIndex : 0)
+  let variantSchema = extractVariantSchema(
+    commandSchema,
+    ~index=variantIndex >= 0 ? variantIndex : 0,
+  )
   let sdlFields = [deriveSdlField(~fieldName, variantSchema)]
 
   // Extract TAG (variant constructor name) for routing
   let tag =
-    (variantIndex >= 0 ? constructorNames->Array.get(variantIndex) : constructorNames->Array.get(0))
-    ->Option.getOr(fieldName)
+    (
+      variantIndex >= 0 ? constructorNames->Array.get(variantIndex) : constructorNames->Array.get(0)
+    )->Option.getOr(fieldName)
   let hasPayload = Reventless.DcbTag.isVariantPayloadBearing(commandSchema->Obj.magic, tag)
 
   let handlerRef = ref(None)
   handlerRefs->Dict.set(fieldName, handlerRef)
 
-  let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (_root, args, ctx) => {
+  let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (
+    _root,
+    args,
+    ctx,
+  ) => {
     switch handlerRef.contents {
     | Some(generateCommand) =>
       switch checkPluginStatus(~field=fieldName) {

package/src/adapter/CommandGenerator/InboundTranslationResolvers_GraphQL.res

@@ -25,7 +25,11 @@ let pendingQueueRegistry: dict<ref<array<pendingCall>>> = Dict.make()
 // Phase 1: Register SDL + resolver stub synchronously (before server starts).
 // Also pre-registers a queuing forwarder in receiveRegistry so callers can
 // invoke receive immediately; calls are parked until bindReceive drains them.
-let register = (~fieldName: string, ~externalInputSchema: S.t<unknown>, ~server: ReventlessGraphqlServer.GraphQL_ServerInstance.t) => {
+let register = (
+  ~fieldName: string,
+  ~externalInputSchema: S.t<unknown>,
+  ~server: ReventlessGraphqlServer.GraphQL_ServerInstance.t,
+) => {
   // The mutation field returns CommandResult, so its union members must exist in
   // this scope's document. Registered here rather than relying on a plugin's
   // command handlers having registered them first — a plugin whose only mutation
@@ -53,11 +57,17 @@ let register = (~fieldName: string, ~externalInputSchema: S.t<unknown>, ~server:
     })
   receiveRegistry->Dict.set(fieldName, queuingReceive)
 
-  let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (_root, args, _ctx) => {
+  let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (
+    _root,
+    args,
+    _ctx,
+  ) => {
     let inputJson: JSON.t = args->Obj.magic
     let receive = receiveRegistry->Dict.getUnsafe(fieldName)
     let result = await receive(inputJson)
-    result->InboundTranslationSlice_Callback.receiveResultToOutcome->CommandTopic.commandOutcomeToJson
+    result
+    ->InboundTranslationSlice_Callback.receiveResultToOutcome
+    ->CommandTopic.commandOutcomeToJson
   }
 
   let resolvers = Dict.make()

package/src/adapter/CommandTopic/LocalCommandTopicChannel.res

@@ -32,17 +32,14 @@ module Make = (Bus: LocalBus.T) => {
   > = (~name, ~owner as _, ~opts as _=?) => {
     // Captured when handleChannelEvent is called; used by publishJsonsAndWait to
     // run the handler inline and collect typed outcomes without going through the bus.
-    let handleCmdsRef: ref<
-      option<ReventlessCore.CommandTopic.jsonCommandsHandler>,
-    > = ref(None)
+    let handleCmdsRef: ref<option<ReventlessCore.CommandTopic.jsonCommandsHandler>> = ref(None)
 
     let publishJsons: ReventlessInfra.CommandTopic.publishJsons = async jsons => {
-      let _ =
-        await jsons
-        ->Array.map(async (cmdJson: Reventless.Message.commandJson) => {
-          await Bus.dispatchCommand(name, ReventlessCore.CommandTopic.encodeCommandJson(cmdJson))
-        })
-        ->Promise.all
+      let _ = await jsons
+      ->Array.map(async (cmdJson: Reventless.Message.commandJson) => {
+        await Bus.dispatchCommand(name, ReventlessCore.CommandTopic.encodeCommandJson(cmdJson))
+      })
+      ->Promise.all
     }
 
     let publishJsonsStream: ReventlessInfra.CommandTopic.publishJsonsStream = stream =>
@@ -55,18 +52,20 @@ module Make = (Bus: LocalBus.T) => {
       | None =>
         // Handler not yet registered — fall back to fire-and-forget, return Pending
         let _ = await publishJsons(jsons)
-        jsons->Array.map(cmdJson =>
-          ReventlessCore.CommandTopic.Pending({msgId: cmdJson.meta.msgId})
-        )
-      | Some(handleCmds) =>
-        await ReventlessCore.CommandTopic.runInlineAndCollect(jsons, handleCmds)
+        jsons->Array.map(cmdJson => ReventlessCore.CommandTopic.Pending({
+          msgId: cmdJson.meta.msgId,
+        }))
+      | Some(handleCmds) => await ReventlessCore.CommandTopic.runInlineAndCollect(jsons, handleCmds)
       }
     }
 
     let handleChannelEvent = (
       handleCmds: ReventlessCore.CommandTopic.jsonCommandsHandler,
-    ): Pulumi.Output.t<ReventlessCore.Runtime.effectHandler<callbackEvent, 'context, unit, string>> => {
+    ): Pulumi.Output.t<
+      ReventlessCore.Runtime.effectHandler<callbackEvent, 'context, unit, string>,
+    > => {
       handleCmdsRef.contents = Some(handleCmds)
+
       (
         (fullBody: JSON.t, _ctx) => {
           // Pass the full body as `command` — that's what handleJsonCommands decodes
@@ -84,8 +83,7 @@ module Make = (Bus: LocalBus.T) => {
       runtimeParts,
     > = (~name as _, ~channel, ~runtime, ~resources as _, ~opts as _) => {
       Bus.registerCommandHandler(channel.parts.name, async (json, ctx) => {
-        let handler =
-          await runtime.parts.handlerDeferred->Deferred.await_->Effect.runPromise
+        let handler = await runtime.parts.handlerDeferred->Deferred.await_->Effect.runPromise
         await handler(json, ctx)
       })
       []

package/src/adapter/CommandTopic/LocalCommandTopicRemoteChannel.res

@@ -5,28 +5,24 @@ module Make = (Bus: LocalBus.T) => {
   let make: ReventlessCore.CommandTopic_Adapter.remoteChannelMaker = resources => {
     resources,
     remotePublish: async jsons => {
-      let _ =
-        await jsons
-        ->Array.map(async (cmdJson: Reventless.Message.commandJson) => {
-          // Encode the same way LocalCommandTopicChannel does
-          let body = JSON.Encode.object(
-            Dict.fromArray([
-              ("id", JSON.Encode.string(cmdJson.id)),
-              (
-                "meta",
-                cmdJson.meta->Reventless.Util_Sury.toJson(Reventless.Message.metaSchema),
-              ),
-              ("command", cmdJson.commandJson),
-            ]),
-          )
-          // Dispatch to the first resource's name (the channel name)
-          let channelName = switch resources {
-          | [] => ""
-          | resources => (resources->Array.getUnsafe(0)).name
-          }
-          await Bus.dispatchCommand(channelName, body)
-        })
-        ->Promise.all
+      let _ = await jsons
+      ->Array.map(async (cmdJson: Reventless.Message.commandJson) => {
+        // Encode the same way LocalCommandTopicChannel does
+        let body = JSON.Encode.object(
+          Dict.fromArray([
+            ("id", JSON.Encode.string(cmdJson.id)),
+            ("meta", cmdJson.meta->Reventless.Util_Sury.toJson(Reventless.Message.metaSchema)),
+            ("command", cmdJson.commandJson),
+          ]),
+        )
+        // Dispatch to the first resource's name (the channel name)
+        let channelName = switch resources {
+        | [] => ""
+        | resources => (resources->Array.getUnsafe(0)).name
+        }
+        await Bus.dispatchCommand(channelName, body)
+      })
+      ->Promise.all
     },
   }
 }

package/src/adapter/Counter/LocalCounterHandler.res

@@ -20,7 +20,7 @@ let make: Counter_Adapter.handlerMaker = (
   ~publishChannelId as _,
   ~opts as _,
 ) => {
-  addToCounterTarget: async ({ReventlessInfra.Counter.counterId, target, targetRef}) => {
+  addToCounterTarget: async ({ReventlessInfra.Counter.counterId: counterId, target, targetRef}) => {
     let refKey = counterId ++ ":" ++ targetRef
     switch targetRefStore.contents->Dict.get(refKey) {
     | Some(_) => () // Already counted this (counterId, targetRef) pair — skip