@reventlessdev/reventless-infra 3.0.0-alpha.160 → 3.0.0-alpha.162

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 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.162 (2026-09-09)
+
+**Note:** Version bump only for package @reventlessdev/reventless-infra
+
+
+
+
+
+# 3.0.0-alpha.161 (2026-09-08)
+
+**Note:** Version bump only for package @reventlessdev/reventless-infra
+
+
+
+
+
 # 3.0.0-alpha.160 (2026-09-08)
 
 **Note:** Version bump only for package @reventlessdev/reventless-infra

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-infra",
-  "version": "3.0.0-alpha.160",
+  "version": "3.0.0-alpha.162",
   "description": "Infrastructure types for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -16,10 +16,10 @@
     "sury": "11.0.0-rc.2",
     "sury-ppx": "11.0.0-rc.2",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.132"
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.33",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.20",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.134",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/components/Api.res

@@ -4,8 +4,10 @@
 let noApiId: S.Metadata.Id.t<bool> = S.Metadata.Id.make(~namespace="api", ~name="noApi")
 
 /** Internal sury metadata ID used to mark specific variant names excluded from API exposure. */
-let noApiVariantsId: S.Metadata.Id.t<Set.t<string>> =
-  S.Metadata.Id.make(~namespace="api", ~name="noApiVariants")
+let noApiVariantsId: S.Metadata.Id.t<Set.t<string>> = S.Metadata.Id.make(
+  ~namespace="api",
+  ~name="noApiVariants",
+)
 
 /** The same exclusion, carried by the excluded *member* rather than by the union
     it sits in — so it survives a variant spread.
@@ -16,12 +18,13 @@ let noApiVariantsId: S.Metadata.Id.t<Set.t<string>> =
     host publishes a command its author marked internal. A mark on the member
     travels, because the member is what is spliced — the host's union holds the
     same schema object. */
-let noApiVariantId: S.Metadata.Id.t<bool> =
-  S.Metadata.Id.make(~namespace="api", ~name="noApiVariant")
+let noApiVariantId: S.Metadata.Id.t<bool> = S.Metadata.Id.make(
+  ~namespace="api",
+  ~name="noApiVariant",
+)
 
 /** PPX helper: attaches the noApi flag to a command schema. Called by generated code. */
-let markNoApi = (schema: S.t<'a>): S.t<'a> =>
-  schema->S.Metadata.set(~id=noApiId, true)
+let markNoApi = (schema: S.t<'a>): S.t<'a> => schema->S.Metadata.set(~id=noApiId, true)
 
 /** The constructor a union member stands for: the `TAG` literal of a
     payload-bearing variant, or the bare literal a payload-less one compiles to. */

package/src/components/CommandTopic.res

@@ -42,7 +42,11 @@ type publishJsons = array<Reventless.Message.commandJson> => promise<unit>
 Publishes a stream of serialized command envelopes as an `Effect.t`.
 Use this for high-throughput or streaming command pipelines.
 */
-type publishJsonsStream = Stream.t<Reventless.Message.commandJson, string, unit> => Effect.t<unit, string, unit>
+type publishJsonsStream = Stream.t<Reventless.Message.commandJson, string, unit> => Effect.t<
+  unit,
+  string,
+  unit,
+>
 
 /**
 A command together with an idempotency reference string.

package/src/components/Component.res

@@ -25,8 +25,7 @@ let _outputsStore = _makeWeakMap()
 let _operationsStore = _makeWeakMap()
 
 /** Access the deploy-time outputs record for this component. */
-let outputs = (self: t<'component, 'outputs, 'operations>): 'outputs =>
-  _outputsStore->_get(self)
+let outputs = (self: t<'component, 'outputs, 'operations>): 'outputs => _outputsStore->_get(self)
 
 /**
 Access the deploy-time outputs wrapped in an `Output.t` (resolved asynchronously).

package/src/components/DcbEventLog.res

@@ -126,5 +126,9 @@ type component = Component.t<t, outputs, operations>
 
 module type T = {
   type component = component
-  let make: (~name: string, ~indexes: array<string>=?, ~opts: Pulumi.ComponentResource.options=?) => component
+  let make: (
+    ~name: string,
+    ~indexes: array<string>=?,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
 }

package/src/components/DeployBootstrap.res

@@ -14,18 +14,17 @@ Same shape as `ReventlessCore.Monitoring.use`: a module-level registry consulted
 by an emitted call, so deploy-time extension becomes *registration*, not *file
 editing*. See `docs/plans/done/deploy-bootstrap-seam.md`.
 */
-
 /**
 Ordered phases at which bootstrap contributions run during a deploy program.
 */
 type phase =
-  | /** before `deployPlatform` / `deployPlugin` — seam registration and other
+  /** before `deployPlatform` / `deployPlugin` — seam registration and other
        ordering-sensitive activations that must precede the platform/plugin
        graph build */
-  PreDeploy
-  | /** after the platform/plugin graph is registered — exports, cross-stack
+  | PreDeploy
+  /** after the platform/plugin graph is registered — exports, cross-stack
        output emission */
-  PostDeploy
+  | PostDeploy
 
 type contribution = unit => unit
 

package/src/components/EventTopic.res

@@ -48,4 +48,8 @@ type publishJsonStreamItem = {
 Publishes a stream of event items as an `Effect.t`.
 Use this for high-throughput or streaming event pipelines.
 */
-type publishJsonStream = Stream.t<publishJsonStreamItem, string, unit> => Effect.t<unit, string, unit>
+type publishJsonStream = Stream.t<publishJsonStreamItem, string, unit> => Effect.t<
+  unit,
+  string,
+  unit,
+>

package/src/components/Scheduler.res

@@ -10,7 +10,10 @@ Creates a schedule in the underlying scheduling service (e.g. EventBridge Schedu
 - `array<Adapter.resolvedResource>` — resolved scheduler resources (ARNs, etc.)
 - `Reventless.Schedule.schedule` — the schedule definition to create
 */
-type createSchedule = (array<Adapter.resolvedResource>, Reventless.Schedule.schedule) => promise<unit>
+type createSchedule = (
+  array<Adapter.resolvedResource>,
+  Reventless.Schedule.schedule,
+) => promise<unit>
 
 /**
 Deletes a schedule by name from the underlying scheduling service.

package/src/types/ExtensionMapping.res

@@ -145,14 +145,12 @@ module NoDelegate = {
 
   let commandSchema = S.unit
   let moduleUrl: string = %raw(`import.meta.url`)
-  let commandAuthorization = (_: command): Reventless.Authorization.permission =>
-    AllowAuthenticated
+  let commandAuthorization = (_: command): Reventless.Authorization.permission => AllowAuthenticated
   type lifecycleState = unit
   let commandTransition = (_: command): Reventless.Transition.t<lifecycleState> => Unrestricted
   let traits: array<Reventless.Trait.t> = []
 }
 
-
 open PluginExtensionPointSpec
 
 type extensionPointName = string
@@ -268,7 +266,12 @@ module Make = (MappingImpl: Mapping): (
     }
 
     let encodeExtensionPointCommandJson = (commandJson, ~id, ~extensionPointName, ~action) => {
-      compLog(`Extension(${extensionPointName})`, `${action}: ${commandJson->Reventless.Message.variantNameOfJson->Reventless.AnsiStyle.bold}(${id})`)
+      compLog(
+        `Extension(${extensionPointName})`,
+        `${action}: ${commandJson
+          ->Reventless.Message.variantNameOfJson
+          ->Reventless.AnsiStyle.bold}(${id})`,
+      )
       {
         Reventless.Message.id,
         meta: encodeMeta(meta, extensionPointName),
@@ -284,10 +287,7 @@ module Make = (MappingImpl: Mapping): (
     mapIncomingEventImpl(id, event, meta, pluginDef, queryEngine)->Array.map(x =>
       switch x {
       | PublishAggregateCommand(targetId, targetCmd) =>
-        AbstractPublishAggregateCommand(
-          delegateName,
-          targetCmd->encodeTargetCommandJson(targetId),
-        )
+        AbstractPublishAggregateCommand(delegateName, targetCmd->encodeTargetCommandJson(targetId))
       | PublishAggregateCommandAsync(promise) =>
         let toCommandJson = async promise => {
           let (targetId, targetCmd) = await promise
@@ -319,8 +319,7 @@ module Make = (MappingImpl: Mapping): (
             targetCmd->encodeTargetCommandJson(derivePartitionId(targetCmd)),
           ))
         AbstractPublishAggregateCommandsAsync(promise->toCommandJsons)
-      | PublishExtensionPointCommand(id, command)
-        if Spec.name == PluginExtensionPointSpec.name =>
+      | PublishExtensionPointCommand(id, command) if Spec.name == PluginExtensionPointSpec.name =>
         AbstractPublishPluginExtensionPointCommand(
           command->encodeExtensionPointCommand(
             ~id,
@@ -364,17 +363,20 @@ module Make = (MappingImpl: Mapping): (
 
   let doMapOutgoingEvent = (mapOutgoingEventImpl, targetEvent'Json, pluginDef) => {
     let tag = variantTagOfEnvelope(targetEvent'Json)
+
     // Not this mapping's concern — skip without decoding.
     if !(acceptedTags->Array.includes(tag)) {
       []
     } else {
       let {id, meta, event} =
-        targetEvent'Json->Reventless.Message.decodeEvent'(
-          Delegate.Id.schema,
-          Delegate.eventSchema,
-        )
+        targetEvent'Json->Reventless.Message.decodeEvent'(Delegate.Id.schema, Delegate.eventSchema)
       let encodeExtensionPointCommandJson = (commandJson, ~id, ~extensionPointName, ~action) => {
-        compLog(`Extension(${delegateName})`, `${action}: ${commandJson->Reventless.Message.variantNameOfJson->Reventless.AnsiStyle.bold}(${id})`)
+        compLog(
+          `Extension(${delegateName})`,
+          `${action}: ${commandJson
+            ->Reventless.Message.variantNameOfJson
+            ->Reventless.AnsiStyle.bold}(${id})`,
+        )
         {
           Reventless.Message.id,
           meta: encodeMeta(meta, extensionPointName),
@@ -389,8 +391,7 @@ module Make = (MappingImpl: Mapping): (
 
       mapOutgoingEventImpl(id->Delegate.Id.toString, event, meta, pluginDef)->Array.map(x =>
         switch x {
-        | PublishExtensionPointCommand(id, command)
-          if Spec.name == PluginExtensionPointSpec.name =>
+        | PublishExtensionPointCommand(id, command) if Spec.name == PluginExtensionPointSpec.name =>
           AbstractPublishPluginExtensionPointCommand(
             command->encodeExtensionPointCommand(
               ~id,

package/src/types/ExtensionPointMapping.res

@@ -119,7 +119,11 @@ module type T = {
 
   /** Pre-encodes a batch of typed EP commands for the runtime. */
   let mapIncomingCommands: (
-    array<CommandTopic.topicItem<Reventless.Message.command'<Reventless.Id.String.t, ExtensionPoint.command>>>,
+    array<
+      CommandTopic.topicItem<
+        Reventless.Message.command'<Reventless.Id.String.t, ExtensionPoint.command>,
+      >,
+    >,
     Reventless.Schedule.create,
     Reventless.Schedule.delete,
     Reventless.QueryEngine.operations,
@@ -162,12 +166,20 @@ module Make = (MappingImpl: Mapping): (
     queryEngine,
   ) =>
     topicItems
-    ->Array.map(({CommandTopic.reference: reference, command: {Reventless.Message.id: id, command, meta}}) =>
+    ->Array.map(({
+      CommandTopic.reference: reference,
+      command: {Reventless.Message.id: id, command, meta},
+    }) =>
       mapIncomingEventImpl(id->Reventless.Id.String.toString, command, meta)->Array.map(x =>
         switch x {
         | PublishCommand(targetId, targetCmd) =>
           let cmdJson = targetCmd->Reventless.Message.encode(Delegate.commandSchema)
-          compLog(`ExtensionPoint(${extensionPointName})`, `EP→${delegateName}: ${cmdJson->Reventless.Message.variantNameOfJson->Reventless.AnsiStyle.bold}(${targetId})`)
+          compLog(
+            `ExtensionPoint(${extensionPointName})`,
+            `EP→${delegateName}: ${cmdJson
+              ->Reventless.Message.variantNameOfJson
+              ->Reventless.AnsiStyle.bold}(${targetId})`,
+          )
 
           AbstractPublishCommand(
             delegateName,
@@ -211,15 +223,13 @@ module Make = (MappingImpl: Mapping): (
     queryEngine,
   ) => {
     let tag = variantTagOfEnvelope(targetEventJson')
+
     // Not this mapping's concern — skip without decoding.
     if !(acceptedTags->Array.includes(tag)) {
       []
     } else {
       let {id, meta, event} =
-        targetEventJson'->Reventless.Message.decodeEvent'(
-          Delegate.Id.schema,
-          Delegate.eventSchema,
-        )
+        targetEventJson'->Reventless.Message.decodeEvent'(Delegate.Id.schema, Delegate.eventSchema)
       mapOutgoingEventImpl(
         id->Delegate.Id.toString,
         event,
@@ -229,7 +239,12 @@ module Make = (MappingImpl: Mapping): (
         switch eventAction {
         | PublishEvent(id, event) =>
           let eventJson = event->Reventless.Message.encode(Spec.eventSchema)
-          compLog(`ExtensionPoint(${extensionPointName})`, `mapped ${delegateName} → ${eventJson->Reventless.Message.variantNameOfJson->Reventless.AnsiStyle.bold}(${id})`)
+          compLog(
+            `ExtensionPoint(${extensionPointName})`,
+            `mapped ${delegateName} → ${eventJson
+              ->Reventless.Message.variantNameOfJson
+              ->Reventless.AnsiStyle.bold}(${id})`,
+          )
           let meta = {
             ...meta,
             service: Spec.name,
@@ -241,7 +256,12 @@ module Make = (MappingImpl: Mapping): (
           let toEvent' = async promise => {
             let (id, event) = await promise
             let eventJson = event->Reventless.Message.encode(Spec.eventSchema)
-            compLog(`ExtensionPoint(${extensionPointName})`, `mapped ${delegateName} → ${eventJson->Reventless.Message.variantNameOfJson->Reventless.AnsiStyle.bold}(${id}) (async)`)
+            compLog(
+              `ExtensionPoint(${extensionPointName})`,
+              `mapped ${delegateName} → ${eventJson
+                ->Reventless.Message.variantNameOfJson
+                ->Reventless.AnsiStyle.bold}(${id}) (async)`,
+            )
             let eventJson' = Reventless.Message.composeEventJson'(id, meta, eventJson) // TODO: check if meta is correct
             (id, meta, eventJson')
           }
@@ -249,8 +269,8 @@ module Make = (MappingImpl: Mapping): (
         | HandleDirective(handler, directive) =>
           compLog(`ExtensionPoint(${extensionPointName})`, `mapped ${delegateName} → directive`)
 
-          AbstractHandleDirective(() =>
-            handler(createSchedule, deleteSchedule, queryEngine, directive)
+          AbstractHandleDirective(
+            () => handler(createSchedule, deleteSchedule, queryEngine, directive),
           )
         }
       )

package/src/types/Platform.res

@@ -20,6 +20,8 @@
 // remains accessible inside module type T even though T re-declares
 // `module ExtensionPoint` with a different local type, which would otherwise
 // shadow the package-level ExtensionPoint.outputs.
+// Type alias so `deployPlugin` can reference `Plugin.outputs` inside module type T,
+// where `module Plugin: Plugin.T` shadows the package-level Plugin module.
 /**
 Abstract factory interface for creating Reventless components without coupling
 application code to a specific infrastructure provider.
@@ -44,9 +46,6 @@ module Platform = ReventlessAws.Platform.Make(AwsConfig)
 module App = CatalogPlugin.Make(Platform)
 ```
 */
-
-// Type alias so `deployPlugin` can reference `Plugin.outputs` inside module type T,
-// where `module Plugin: Plugin.T` shadows the package-level Plugin module.
 type pluginOutputs = Plugin.outputs
 
 // A storage bucket a deployment declares to be served read-only to the UI under
@@ -286,13 +285,13 @@ module type T = {
       Spec: Reventless.Aggregate.Spec,
       Behavior: Reventless.Behavior.T with module Spec := Spec,
       EventMappings: EventMapper.Mappings with module Target := Spec,
-    ) => Aggregate.T with type api = api
+    ) => (Aggregate.T with type api = api)
     /** Async variant — uses FIFO channel, returns `CommandPending`. */
     module MakeAsync: (
       Spec: Reventless.Aggregate.Spec,
       Behavior: Reventless.Behavior.T with module Spec := Spec,
       EventMappings: EventMapper.Mappings with module Target := Spec,
-    ) => Aggregate.T with type api = api
+    ) => (Aggregate.T with type api = api)
   }
 
   /** Factory for read model (query-side projection) components. */
@@ -300,7 +299,7 @@ module type T = {
     module Make: (
       Spec: Reventless.ReadModel.Spec,
       Mappings: Reventless.Projection.Mappings with module Target := Spec,
-    ) => ReadModel.T with module Spec = Spec and type api = api and type role = role
+    ) => (ReadModel.T with module Spec = Spec and type api = api and type role = role)
   }
 
   /** Factory for stream-enabled read model components — identical to `ReadModel`
@@ -312,29 +311,24 @@ module type T = {
     module Make: (
       Spec: Reventless.ReadModel.Spec,
       Mappings: Reventless.Projection.Mappings with module Target := Spec,
-    ) => ReadModelComponentT with module Spec = Spec and type api = api and type role = role
+    ) => (ReadModelComponentT with module Spec = Spec and type api = api and type role = role)
   }
 
   /** Factory for extension point components (single mapping). */
   module ExtensionPoint: {
-    module Make: (
-      Mapping: ExtensionPointMapping.Mapping,
-    ) => ExtensionPoint.T
+    module Make: (Mapping: ExtensionPointMapping.Mapping) => ExtensionPoint.T
 
     /** Two-mapping variant — merges per-slice EP mappings. */
     module Make2: (
       Mapping1: ExtensionPointMapping.Mapping,
-      Mapping2: ExtensionPointMapping.Mapping
-        with module ExtensionPoint = Mapping1.ExtensionPoint,
+      Mapping2: ExtensionPointMapping.Mapping with module ExtensionPoint = Mapping1.ExtensionPoint,
     ) => ExtensionPoint.T
 
     /** Three-mapping variant — merges per-slice EP mappings. */
     module Make3: (
       Mapping1: ExtensionPointMapping.Mapping,
-      Mapping2: ExtensionPointMapping.Mapping
-        with module ExtensionPoint = Mapping1.ExtensionPoint,
-      Mapping3: ExtensionPointMapping.Mapping
-        with module ExtensionPoint = Mapping1.ExtensionPoint,
+      Mapping2: ExtensionPointMapping.Mapping with module ExtensionPoint = Mapping1.ExtensionPoint,
+      Mapping3: ExtensionPointMapping.Mapping with module ExtensionPoint = Mapping1.ExtensionPoint,
     ) => ExtensionPoint.T
 
     /** Multi-mapping variant with full control over name and mappings array. */
@@ -349,14 +343,12 @@ module type T = {
       using the plugin name for the extension's component name and auto-merging
       blueprints that target the same extension point. */
   module Extension: {
-    module Make: (
-      Mapping: ExtensionMapping.Mapping,
-    ) => Extension.Blueprint
+    module Make: (Mapping: ExtensionMapping.Mapping) => Extension.Blueprint
   }
 
   /** Factory for task (background job / S3 trigger) components. */
   module Task: {
-    module Make: (Spec: Task.Spec) => Task.T with module Spec = Spec
+    module Make: (Spec: Task.Spec) => (Task.T with module Spec = Spec)
   }
 
   /** Ready-to-use counter component (no Make required). */
@@ -367,12 +359,12 @@ module type T = {
     module Make: (
       Spec: Reventless.StateChangeSlice.Spec,
       Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec,
-    ) => StateChangeSlice.T with module Spec = Spec
+    ) => (StateChangeSlice.T with module Spec = Spec)
     /** Async variant — uses FIFO channel, returns `CommandPending`. */
     module MakeAsync: (
       Spec: Reventless.StateChangeSlice.Spec,
       Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec,
-    ) => StateChangeSlice.T with module Spec = Spec
+    ) => (StateChangeSlice.T with module Spec = Spec)
   }
 
   /** Factory for DCB read-side state-view slice components. */
@@ -380,7 +372,7 @@ module type T = {
     module Make: (
       Spec: Reventless.StateViewSlice.Spec,
       Projection: Reventless.StateViewSlice.Projection with module Spec := Spec,
-    ) => StateViewSlice.T with module Spec = Spec
+    ) => (StateViewSlice.T with module Spec = Spec)
   }
 
   /** Factory for stream-enabled state-view slice components (enables Source B subscriptions). */
@@ -388,7 +380,7 @@ module type T = {
     module Make: (
       Spec: Reventless.StateViewSlice.Spec,
       Projection: Reventless.StateViewSlice.Projection with module Spec := Spec,
-    ) => StateViewSliceComponentT with module Spec = Spec
+    ) => (StateViewSliceComponentT with module Spec = Spec)
   }
 
   /** Factory for DCB automation slice components (TODO list pattern). */
@@ -396,7 +388,7 @@ module type T = {
     module Make: (
       Spec: Reventless.AutomationSlice.Spec,
       Automation: Reventless.AutomationSlice.Automation with module Spec := Spec,
-    ) => AutomationSlice.T with module Spec = Spec
+    ) => (AutomationSlice.T with module Spec = Spec)
   }
 
   /** Factory for DCB outbound translation slice components (tracked external calls). */
@@ -404,7 +396,7 @@ module type T = {
     module Make: (
       Spec: Reventless.OutboundTranslationSlice.Spec,
       Translation: Reventless.OutboundTranslationSlice.Translation with module Spec := Spec,
-    ) => OutboundTranslationSlice.T with module Spec = Spec
+    ) => (OutboundTranslationSlice.T with module Spec = Spec)
   }
 
   /** Factory for DCB inbound translation slice components (external input to commands). */
@@ -412,7 +404,7 @@ module type T = {
     module Make: (
       Spec: Reventless.InboundTranslationSlice.Spec,
       Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec,
-    ) => InboundTranslationSlice.T with module Spec = Spec
+    ) => (InboundTranslationSlice.T with module Spec = Spec)
   }
 
   /** Whether this platform supports MCP (Model Context Protocol) for AI agent access.
@@ -536,7 +528,10 @@ module type T = {
       Pass `~apiTarget=Platform` to route the plugin's resolvers and schema to the Platform API.
       Defaults to `Domain`.
       Returns the Pulumi stack outputs dict for use as the ESM `default` export. */
-  let deployPlugin: (~plugin: module(PluginMaker), ~apiTarget: apiTarget=?) => dict<Pulumi.Output.t<JSON.t>>
+  let deployPlugin: (
+    ~plugin: module(PluginMaker),
+    ~apiTarget: apiTarget=?,
+  ) => dict<Pulumi.Output.t<JSON.t>>
 
   /** Start all servers after all makePlatform/deployPlugin calls are complete.
       In split in-memory mode, servers are deferred until this is called so all

package/tests/DeployBootstrapTest.res

@@ -5,68 +5,86 @@ module DB = DeployBootstrap
 describe("DeployBootstrap", () => {
   // The seam holds module-level state, so each case resets first for isolation.
   describe("run with no registrations", () => {
-    testSync("is a no-op that does not throw", () => {
-      DB.reset()
-      DB.run(PreDeploy)
-      DB.run(PostDeploy)
-      expect(true)->toBe(true)
-    })
+    testSync(
+      "is a no-op that does not throw",
+      () => {
+        DB.reset()
+        DB.run(PreDeploy)
+        DB.run(PostDeploy)
+        expect(true)->toBe(true)
+      },
+    )
   })
 
   describe("registration order within a phase", () => {
-    testSync("runs contributions in the order they were registered", () => {
-      DB.reset()
-      let calls = []
-      DB.register(() => calls->Array.push("a"))
-      DB.register(() => calls->Array.push("b"))
-      DB.register(() => calls->Array.push("c"))
-      DB.run(PreDeploy)
-      expect(calls)->toEqual(["a", "b", "c"])
-    })
+    testSync(
+      "runs contributions in the order they were registered",
+      () => {
+        DB.reset()
+        let calls = []
+        DB.register(() => calls->Array.push("a"))
+        DB.register(() => calls->Array.push("b"))
+        DB.register(() => calls->Array.push("c"))
+        DB.run(PreDeploy)
+        expect(calls)->toEqual(["a", "b", "c"])
+      },
+    )
   })
 
   describe("phase isolation", () => {
-    testSync("run(PreDeploy) fires only PreDeploy contributions", () => {
-      DB.reset()
-      let calls = []
-      DB.register(~phase=PreDeploy, () => calls->Array.push("pre"))
-      DB.register(~phase=PostDeploy, () => calls->Array.push("post"))
-      DB.run(PreDeploy)
-      expect(calls)->toEqual(["pre"])
-      DB.run(PostDeploy)
-      expect(calls)->toEqual(["pre", "post"])
-    })
+    testSync(
+      "run(PreDeploy) fires only PreDeploy contributions",
+      () => {
+        DB.reset()
+        let calls = []
+        DB.register(~phase=PreDeploy, () => calls->Array.push("pre"))
+        DB.register(~phase=PostDeploy, () => calls->Array.push("post"))
+        DB.run(PreDeploy)
+        expect(calls)->toEqual(["pre"])
+        DB.run(PostDeploy)
+        expect(calls)->toEqual(["pre", "post"])
+      },
+    )
 
-    testSync("defaults to PreDeploy when no phase is given", () => {
-      DB.reset()
-      let calls = []
-      DB.register(() => calls->Array.push("default"))
-      DB.run(PostDeploy)
-      expect(calls)->toEqual([])
-      DB.run(PreDeploy)
-      expect(calls)->toEqual(["default"])
-    })
+    testSync(
+      "defaults to PreDeploy when no phase is given",
+      () => {
+        DB.reset()
+        let calls = []
+        DB.register(() => calls->Array.push("default"))
+        DB.run(PostDeploy)
+        expect(calls)->toEqual([])
+        DB.run(PreDeploy)
+        expect(calls)->toEqual(["default"])
+      },
+    )
   })
 
   describe("idempotent run per phase", () => {
-    testSync("running an already-run phase does nothing", () => {
-      DB.reset()
-      let count = ref(0)
-      DB.register(() => count := count.contents + 1)
-      DB.run(PreDeploy)
-      DB.run(PreDeploy)
-      DB.run(PreDeploy)
-      expect(count.contents)->toBe(1)
-    })
+    testSync(
+      "running an already-run phase does nothing",
+      () => {
+        DB.reset()
+        let count = ref(0)
+        DB.register(() => count := count.contents + 1)
+        DB.run(PreDeploy)
+        DB.run(PreDeploy)
+        DB.run(PreDeploy)
+        expect(count.contents)->toBe(1)
+      },
+    )
 
-    testSync("a contribution registered after run does not fire", () => {
-      DB.reset()
-      let calls = []
-      DB.register(() => calls->Array.push("before"))
-      DB.run(PreDeploy)
-      DB.register(() => calls->Array.push("after"))
-      DB.run(PreDeploy)
-      expect(calls)->toEqual(["before"])
-    })
+    testSync(
+      "a contribution registered after run does not fire",
+      () => {
+        DB.reset()
+        let calls = []
+        DB.register(() => calls->Array.push("before"))
+        DB.run(PreDeploy)
+        DB.register(() => calls->Array.push("after"))
+        DB.run(PreDeploy)
+        expect(calls)->toEqual(["before"])
+      },
+    )
   })
 })

package/tests/RuntimeHintsTest.res

@@ -12,10 +12,14 @@ describe("RuntimeHints.resolveMemory", () => {
     expect(RH.resolveMemory(None, ~default=1024))->toBe(1024)
   })
   testSync("an override above the default wins", () => {
-    expect(RH.resolveMemory(Some({memorySize: Some(2048), timeout: None}), ~default=1024))->toBe(2048)
+    expect(RH.resolveMemory(Some({memorySize: Some(2048), timeout: None}), ~default=1024))->toBe(
+      2048,
+    )
   })
   testSync("an override below the default is clamped up to the floor", () => {
-    expect(RH.resolveMemory(Some({memorySize: Some(256), timeout: None}), ~default=1024))->toBe(1024)
+    expect(RH.resolveMemory(Some({memorySize: Some(256), timeout: None}), ~default=1024))->toBe(
+      1024,
+    )
   })
   testSync("an absent memorySize field falls through to the default", () => {
     expect(RH.resolveMemory(Some({memorySize: None, timeout: Some(60)}), ~default=1024))->toBe(1024)