@reventlessdev/reventless-spec 3.0.0-alpha.133 → 3.0.0-alpha.134

package/src/generator/Codegen.res

@@ -20,40 +20,35 @@ let renderSlices = (
   stems: array<string>,
 ): array<string> =>
   stems->Array.map(stem =>
-    "  module "
-    ++ stem
-    ++ suffix
-    ++ " = Platform."
-    ++ platformFactory
-    ++ ".Make("
-    ++ stem
-    ++ ", "
-    ++ stem
-    ++ implSuffix
-    ++ ")"
+    "  module " ++
+    stem ++
+    suffix ++
+    " = Platform." ++
+    platformFactory ++
+    ".Make(" ++
+    stem ++
+    ", " ++
+    stem ++
+    implSuffix ++ ")"
   )
 
 // StateChangeSlices opt into async dispatch via `@@reventless.async` on the
 // spec file; the rendered factory becomes MakeAsync (CommandPending response).
-let renderStateChangeSlices = (
-  stems: array<string>,
-  asyncStems: Dict.t<bool>,
-): array<string> =>
+let renderStateChangeSlices = (stems: array<string>, asyncStems: Dict.t<bool>): array<string> =>
   stems->Array.map(stem => {
     let factory = switch Dict.get(asyncStems, stem) {
     | Some(true) => "MakeAsync"
     | _ => "Make"
     }
-    "  module "
-    ++ stem
-    ++ "Slice = Platform.StateChangeSlice."
-    ++ factory
-    ++ "("
-    ++ stem
-    ++ ", "
-    ++ stem
-    ++ Pairing.implSuffixForStateChange
-    ++ ")"
+    "  module " ++
+    stem ++
+    "Slice = Platform.StateChangeSlice." ++
+    factory ++
+    "(" ++
+    stem ++
+    ", " ++
+    stem ++
+    Pairing.implSuffixForStateChange ++ ")"
   })
 
 // AutomationSlice — 2-arg form. The merged `_Automation.res` shape exposes
@@ -63,13 +58,12 @@ let renderStateChangeSlices = (
 // from the sibling `_Mappings.res`.
 let renderAutomationSlices = (stems: array<string>): array<string> =>
   stems->Array.map(stem =>
-    "  module "
-    ++ stem
-    ++ "Slice = Platform.AutomationSlice.Make("
-    ++ stem
-    ++ ", "
-    ++ stem
-    ++ "_Automation)"
+    "  module " ++
+    stem ++
+    "Slice = Platform.AutomationSlice.Make(" ++
+    stem ++
+    ", " ++
+    stem ++ "_Automation)"
   )
 
 let renderAggregates = (aggregates: array<Pairing.aggregateDef>): array<string> =>
@@ -99,14 +93,19 @@ let renderReadModels = (readModels: array<Pairing.readModelDef>): array<string>
     // platform wires a StateTopic Lambda for AppSync Events (Source B) live updates.
     let factory = stream ? "Platform.ReadModelStream.Make" : "Platform.ReadModel.Make"
     [
-      "  module " ++ wrapperName ++ " = " ++ factory ++ "(" ++ readModel ++ ", " ++ projections ++ ")",
+      "  module " ++
+      wrapperName ++
+      " = " ++
+      factory ++
+      "(" ++
+      readModel ++
+      ", " ++
+      projections ++ ")",
     ]
   })
 
 let renderTasks = (tasks: array<string>): array<string> =>
-  tasks->Array.map(stem =>
-    "  module " ++ stem ++ "Task = Platform.Task.Make(" ++ stem ++ ")"
-  )
+  tasks->Array.map(stem => "  module " ++ stem ++ "Task = Platform.Task.Make(" ++ stem ++ ")")
 
 let renderExtensionPoints = (extensionPoints: array<Pairing.extensionPointDef>): array<string> =>
   extensionPoints->Array.flatMap(({group, mappings}) => {
@@ -118,8 +117,7 @@ let renderExtensionPoints = (extensionPoints: array<Pairing.extensionPointDef>):
     }
     switch count {
     | 0 => []
-    | 1 =>
-      ["  module " ++ moduleName ++ " = Platform.ExtensionPoint.Make(" ++ firstMapping ++ ")"]
+    | 1 => ["  module " ++ moduleName ++ " = Platform.ExtensionPoint.Make(" ++ firstMapping ++ ")"]
     | 2 =>
       let m2 = mappings->Array.getUnsafe(1)
       [
@@ -140,8 +138,7 @@ let renderExtensionPoints = (extensionPoints: array<Pairing.extensionPointDef>):
       ]
     | _ =>
       // MakeMulti — inline module expression
-      let mappingLines =
-        mappings->Array.map(m => "      module(" ++ m ++ "),")
+      let mappingLines = mappings->Array.map(m => "      module(" ++ m ++ "),")
       Array.flat([
         [
           "  module " ++ moduleName ++ " = Platform.ExtensionPoint.MakeMulti({",
@@ -152,10 +149,7 @@ let renderExtensionPoints = (extensionPoints: array<Pairing.extensionPointDef>):
           "    let mappings: array<module(Mapping)> = [",
         ],
         mappingLines,
-        [
-          "    ]",
-          "  })",
-        ],
+        ["    ]", "  })"],
       ])
     }
   })
@@ -172,11 +166,9 @@ let renderExtensions = (extensions: array<string>): array<string> =>
 
 // ── make() call ──────────────────────────────────────────────────────────────
 
-let renderMakeParam = (
-  ~param: string,
-  ~items: array<string>,
-  ~moduleSuffix: string,
-): option<string> =>
+let renderMakeParam = (~param: string, ~items: array<string>, ~moduleSuffix: string): option<
+  string,
+> =>
   if items->Array.length === 0 {
     None
   } else {
@@ -184,10 +176,9 @@ let renderMakeParam = (
     Some("      ~" ++ param ++ "=[" ++ entries->Array.join(", ") ++ "],")
   }
 
-let renderStateViewSlicesMakeParam = (
-  slices: array<string>,
-  streamSlices: array<string>,
-): option<string> => {
+let renderStateViewSlicesMakeParam = (slices: array<string>, streamSlices: array<string>): option<
+  string,
+> => {
   let entries = Array.flat([
     slices->Array.map(s => "module(" ++ s ++ "Slice)"),
     streamSlices->Array.map(s => "module(" ++ s ++ "StreamSlice)"),
@@ -314,9 +305,7 @@ let validateComponentRuntimeKeys = (
   )
 }
 
-let renderComponentRuntimeParam = (
-  componentRuntime: dict<Config.runtimeHints>,
-): option<string> => {
+let renderComponentRuntimeParam = (componentRuntime: dict<Config.runtimeHints>): option<string> => {
   let entries = componentRuntime->Dict.toArray
   if entries->Array.length === 0 {
     None
@@ -419,6 +408,7 @@ let renderPluginStructureCall = (
       let entries = epMappingStems->Array.map(s => "module(" ++ s ++ ")")
       ls->Array.push("    ~extensionPoints=[" ++ entries->Array.join(", ") ++ "],")
     }
+
     // Chapter grouping bands per component, captured from the source folder layout.
     // Only emitted when at least one component lives under a chapter folder, so
     // plugins with a flat `src/` keep a byte-identical generated Plugin.res.
@@ -427,8 +417,11 @@ let renderPluginStructureCall = (
         componentChapters->Array.map(((stem, chapter)) =>
           "(\"" ++ stem ++ "\", \"" ++ chapter ++ "\")"
         )
-      ls->Array.push("    ~componentChapters=Dict.fromArray([" ++ entries->Array.join(", ") ++ "]),")
+      ls->Array.push(
+        "    ~componentChapters=Dict.fromArray([" ++ entries->Array.join(", ") ++ "]),",
+      )
     }
+
     // What the plugin's own scenarios say about each command's lifecycle edge.
     // Written by `check:lifecycle:update`, not here: the sidecars it harvests are
     // produced by the build this generator runs *before*, so a generator-written
@@ -463,7 +456,18 @@ let validateUniqueSpecStems = (~discovered: array<Discovery.discoveredFile>) =>
   ->Dict.toArray
   ->Array.forEach(((stem, paths)) => {
     if paths->Array.length > 1 {
-      let pathList = paths->Array.toSorted((a, b) => if a < b {-1.0} else if a > b {1.0} else {0.0})->Array.join("\n  - ")
+      let pathList =
+        paths
+        ->Array.toSorted((a, b) =>
+          if a < b {
+            -1.0
+          } else if a > b {
+            1.0
+          } else {
+            0.0
+          }
+        )
+        ->Array.join("\n  - ")
       JsError.throwWithMessage(
         "Generator: stem `" ++
         stem ++
@@ -493,7 +497,7 @@ let validateSliceTargets = (~resolved: Pairing.resolved) => {
         "` is missing `let targetName = \"...\"`. Valid targets: " ++
         knownReceivers->Array.join(", "),
       )
-    | Some(t) when !(knownReceivers->Array.includes(t)) =>
+    | Some(t) if !(knownReceivers->Array.includes(t)) =>
       JsError.throwWithMessage(
         "Generator: " ++
         kind ++
@@ -526,7 +530,7 @@ let validateSliceTargets = (~resolved: Pairing.resolved) => {
   // OutboundTranslationSlice: only validate when targetName = Some(name) (None = fire-and-forget)
   resolved.outboundTranslationSlices->Array.forEach(stem => {
     switch resolved.outboundTranslationSliceTargets->Dict.get(stem)->Option.getOr(None) {
-    | Some(t) when !(knownReceivers->Array.includes(t)) =>
+    | Some(t) if !(knownReceivers->Array.includes(t)) =>
       JsError.throwWithMessage(
         "Generator: OutboundTranslationSlice `" ++
         stem ++
@@ -616,9 +620,9 @@ let renderComposition = (
   lines->Array.push("")
   lines->Array.push(
     "@val external uiBundleUrl: option<string> = \"process.env." ++
-    pluginNameToEnvBase(config.name) ++
-    "_UI_BUNDLE_URL\"",
+    pluginNameToEnvBase(config.name) ++ "_UI_BUNDLE_URL\"",
   )
+
   // The DCB boundary's slices as schemas, outside `Make` because the scope they
   // determine is a property of the specs and not of any platform. Emitted rather
   // than hand-listed so a slice added tomorrow is in it: this is the only value
@@ -651,10 +655,7 @@ let renderComposition = (
   // StateChangeSlices — per-stem MakeAsync opt-in via @@reventless.async
   if resolved.stateChangeSlices->Array.length > 0 {
     lines->Array.push("  // StateChangeSlices")
-    renderStateChangeSlices(
-      resolved.stateChangeSlices,
-      resolved.asyncStateChangeSlices,
-    )->push
+    renderStateChangeSlices(resolved.stateChangeSlices, resolved.asyncStateChangeSlices)->push
   }
 
   // StateViewSlices
@@ -794,9 +795,17 @@ let renderComposition = (
     renderAggregateMakeParam(resolved.aggregates),
     renderReadModelMakeParam(resolved.readModels),
     renderTaskMakeParam(resolved.tasks),
-    renderMakeParam(~param="stateChangeSlices", ~items=resolved.stateChangeSlices, ~moduleSuffix="Slice"),
+    renderMakeParam(
+      ~param="stateChangeSlices",
+      ~items=resolved.stateChangeSlices,
+      ~moduleSuffix="Slice",
+    ),
     renderStateViewSlicesMakeParam(resolved.stateViewSlices, resolved.stateViewSlicesStream),
-    renderMakeParam(~param="automationSlices", ~items=resolved.automationSlices, ~moduleSuffix="Slice"),
+    renderMakeParam(
+      ~param="automationSlices",
+      ~items=resolved.automationSlices,
+      ~moduleSuffix="Slice",
+    ),
     renderMakeParam(
       ~param="outboundTranslationSlices",
       ~items=resolved.outboundTranslationSlices,

package/src/generator/Discovery.res

@@ -18,7 +18,12 @@ type componentType = ComponentKind.t =
   | Extension
 
 // relPath: path relative to srcDir (e.g. "ReadModel/ProductsProjections.res")
-type discoveredFile = {stem: string, componentType: componentType, epGroup: option<string>, relPath: string}
+type discoveredFile = {
+  stem: string,
+  componentType: componentType,
+  epGroup: option<string>,
+  relPath: string,
+}
 
 let folderToComponentType = ComponentKind.folderToKind
 
@@ -32,6 +37,7 @@ let folderToComponentType = ComponentKind.folderToKind
 // docs/plans/done/deployed-chapter-grouping.md.
 let chapterOf = (relPath: string): option<string> => {
   let segments = relPath->String.split("/")
+
   // Need at least one directory segment before the filename.
   if segments->Array.length < 2 {
     None
@@ -76,7 +82,7 @@ let isAlwaysExcludedDir = (name: string): bool =>
 let matchesGlob = (path: string, pattern: string): bool =>
   if pattern === "**" {
     true
-  } else if not(pattern->String.includes("*")) {
+  } else if !(pattern->String.includes("*")) {
     // Exact file match or directory prefix
     path === pattern || path->String.startsWith(pattern ++ "/")
   } else if pattern->String.endsWith("/**") {
@@ -85,9 +91,11 @@ let matchesGlob = (path: string, pattern: string): bool =>
   } else if pattern->String.endsWith("/*") {
     let prefix = pattern->String.slice(~start=0, ~end=pattern->String.length - 2)
     path->String.startsWith(prefix ++ "/") &&
-      !(path
-      ->String.slice(~start=prefix->String.length + 1, ~end=path->String.length)
-      ->String.includes("/"))
+      !(
+        path
+        ->String.slice(~start=prefix->String.length + 1, ~end=path->String.length)
+        ->String.includes("/")
+      )
   } else {
     path === pattern
   }
@@ -103,14 +111,14 @@ let stemOf = (filename: string): option<string> =>
   }
 
 let isSkipped = (stem: string): bool =>
-  stem->String.endsWith("Test")
-  || stem->String.endsWith("Fixtures")
+  stem->String.endsWith("Test") ||
+  stem->String.endsWith("Fixtures") ||
   // `_EventMappings` and `_Mappings` files in per-entity Aggregate/ folders
   // are picked up by the dedicated [Pairing.findEventMappings] walker;
   // treating them as Aggregate specs would hunt for a non-existent
   // `_EventMappingsBehavior` / `_MappingsBehavior`.
-  || stem->String.endsWith("_EventMappings")
-  || stem->String.endsWith("_Mappings")
+  stem->String.endsWith("_EventMappings") ||
+  stem->String.endsWith("_Mappings")
 
 // Collect .res files directly in dir (non-recursive) into acc.
 let collectFiles = (
@@ -124,7 +132,11 @@ let collectFiles = (
   Generator_Node.readDir(dir)->Array.forEach(entry => {
     if entry->NodeFs.isFile {
       let filename = entry->NodeFs.direntName
-      let relPath = if relDir === "" {filename} else {relDir ++ "/" ++ filename}
+      let relPath = if relDir === "" {
+        filename
+      } else {
+        relDir ++ "/" ++ filename
+      }
       if !isExcluded(relPath, exclude) {
         switch stemOf(filename) {
         | Some(stem) if !isSkipped(stem) => acc->Array.push({stem, componentType, epGroup, relPath})
@@ -145,7 +157,11 @@ let rec walkDir = (
 ): unit =>
   Generator_Node.readDir(dir)->Array.forEach(entry => {
     let entryName = entry->NodeFs.direntName
-    let relPath = if relDir === "" {entryName} else {relDir ++ "/" ++ entryName}
+    let relPath = if relDir === "" {
+      entryName
+    } else {
+      relDir ++ "/" ++ entryName
+    }
 
     if isExcluded(relPath, exclude) {
       ()
@@ -215,7 +231,8 @@ let rec walkDir = (
         let filename = entryName
         if !isExcluded(relPath, exclude) {
           switch stemOf(filename) {
-          | Some(stem) if !isSkipped(stem) => acc->Array.push({stem, componentType: ct, epGroup, relPath})
+          | Some(stem) if !isSkipped(stem) =>
+            acc->Array.push({stem, componentType: ct, epGroup, relPath})
           | _ => ()
           }
         }

package/src/generator/GraftTrait.res

@@ -157,8 +157,7 @@ let main = async () => {
           | _ =>
             fail(
               `${traitPackage} ships no scaffold (looked for ${specifier}).\n` ++
-              `  Not every trait has one — a trait whose graft is all patches has nothing to write.\n` ++
-              `  Write the graft by hand instead; its README says what the host must declare.`,
+              `  Not every trait has one — a trait whose graft is all patches has nothing to write.\n` ++ `  Write the graft by hand instead; its README says what the host must declare.`,
             )
             %raw(`undefined`)
           }
@@ -177,11 +176,14 @@ let main = async () => {
           )
           ["into", "tests", "dry-run"]->Array.forEach(k => raw->Dict.delete(k))
 
-          let config = try raw->JSON.Encode.object->Util_Sury.fromJson(scaffold.configSchema) catch {
+          let config = try raw
+          ->JSON.Encode.object
+          ->Util_Sury.fromJson(scaffold.configSchema) catch {
           | exn => {
               fail(
-                `${traitPackage} refused this config: ${Util_Sury.exnMessage(exn)}\n` ++
-                `  Every --key is a field of the trait's own config; it decides what it needs.`,
+                `${traitPackage} refused this config: ${Util_Sury.exnMessage(
+                    exn,
+                  )}\n` ++ `  Every --key is a field of the trait's own config; it decides what it needs.`,
               )
               %raw(`undefined`)
             }
@@ -191,7 +193,12 @@ let main = async () => {
 
           files->Array.forEach(({path, contents}) =>
             if dryRun {
-              Console.log(`Would write: ${path} (${contents->String.split("\n")->Array.length->Int.toString} lines)`)
+              Console.log(
+                `Would write: ${path} (${contents
+                  ->String.split("\n")
+                  ->Array.length
+                  ->Int.toString} lines)`,
+              )
             } else if NodeFs.existsSync(path) {
               // Never overwrite. From the moment a graft lands it is the host's
               // source, edited with the policy the trait deliberately does not
@@ -207,7 +214,9 @@ let main = async () => {
 
           if patches->Array.length > 0 {
             Console.log("")
-            Console.log("── Paste these; they go into files you already own ──────────────")
+            Console.log(
+              "── Paste these; they go into files you already own ──────────────",
+            )
             patches->Array.forEach(({into, at, contents}) => {
               Console.log("")
               Console.log(`# ${into} — ${at}`)
@@ -216,8 +225,7 @@ let main = async () => {
             Console.log("")
             Console.log(
               "Printed rather than written: placing an arm in an existing ordered `switch`\n" ++
-              "is an AST operation, and a text splice into the wrong arm is a bug the\n" ++
-              "compiler cannot see.",
+              "is an AST operation, and a text splice into the wrong arm is a bug the\n" ++ "compiler cannot see.",
             )
           }
 

package/src/generator/Pairing.res

@@ -21,11 +21,11 @@ let implSuffixForTranslation = "_Translation"
 let mappingsSuffixForAutomation = "_Mappings"
 
 let isImplStem = (stem: string): bool =>
-  stem->String.endsWith(implSuffixForStateChange)
-  || stem->String.endsWith(implSuffixForStateView)
-  || stem->String.endsWith(implSuffixForAutomation)
-  || stem->String.endsWith(implSuffixForTranslation)
-  || stem->String.endsWith(mappingsSuffixForAutomation)
+  stem->String.endsWith(implSuffixForStateChange) ||
+  stem->String.endsWith(implSuffixForStateView) ||
+  stem->String.endsWith(implSuffixForAutomation) ||
+  stem->String.endsWith(implSuffixForTranslation) ||
+  stem->String.endsWith(mappingsSuffixForAutomation)
 
 type aggregateDef = {spec: string, behavior: string, eventMappings: option<string>, isAsync: bool}
 // readModelDef pairs a ReadModel spec with its sibling `_Projections.res`
@@ -119,7 +119,15 @@ let findEventMappings = (~srcDir: string): Dict.t<string> => {
 }
 
 let sortedStems = (stems: array<string>): array<string> =>
-  stems->Array.toSorted((a, b) => if a < b {-1.0} else if a > b {1.0} else {0.0})
+  stems->Array.toSorted((a, b) =>
+    if a < b {
+      -1.0
+    } else if a > b {
+      1.0
+    } else {
+      0.0
+    }
+  )
 
 // Read a slice spec file and extract the value of `let targetName = ...`.
 // Returns Some(name) for string literals (including inside Some("...")),
@@ -128,7 +136,9 @@ let extractTargetName = (filePath: string): option<string> => {
   try {
     let content = NodeFs.readFileSync(filePath)
     let result = ref(None)
-    content->String.split("\n")->Array.forEach(line => {
+    content
+    ->String.split("\n")
+    ->Array.forEach(line => {
       let trimmed = line->String.trimStart
       if trimmed->String.startsWith("let targetName = ") {
         let firstQuote = trimmed->String.indexOf("\"")
@@ -153,8 +163,11 @@ let hasFileAttribute = (filePath: string, ~attr: string): bool => {
   try {
     let content = NodeFs.readFileSync(filePath)
     let found = ref(false)
-    content->String.split("\n")->Array.forEach(line => {
+    content
+    ->String.split("\n")
+    ->Array.forEach(line => {
       let trimmed = line->String.trimStart
+
       // Match the bare attribute and tolerate a payload arg in the future.
       if (
         trimmed->String.startsWith(attr ++ " ") ||
@@ -189,7 +202,9 @@ let effectiveSpecName = (filePath: string, ~stem: string): string => {
   try {
     let content = NodeFs.readFileSync(filePath)
     let name = ref(None)
-    content->String.split("\n")->Array.forEach(line => {
+    content
+    ->String.split("\n")
+    ->Array.forEach(line => {
       let trimmed = line->String.trimStart
       if trimmed->String.startsWith("@@reventless.spec(") {
         let firstQuote = trimmed->String.indexOf("\"")
@@ -356,7 +371,14 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
           isAsync,
         })
       | None =>
-        Console.warn("Generator: Aggregate spec `" ++ spec ++ "` has no matching `" ++ underscored ++ "` or `" ++ bare ++ "` — skipping")
+        Console.warn(
+          "Generator: Aggregate spec `" ++
+          spec ++
+          "` has no matching `" ++
+          underscored ++
+          "` or `" ++
+          bare ++ "` — skipping",
+        )
         None
       }
     })
@@ -377,10 +399,14 @@ let resolve = (discovered: array<Discovery.discoveredFile>, ~srcDir: string): re
     let underscoredProj = baseName ++ "_Projections"
     switch Dict.get(projectionsByRelPath, underscoredProj) {
     | None =>
-      Console.warn("Generator: ReadModel `" ++ rm ++ "` has no matching `" ++ underscoredProj ++ ".res` — skipping")
+      Console.warn(
+        "Generator: ReadModel `" ++
+        rm ++
+        "` has no matching `" ++
+        underscoredProj ++ ".res` — skipping",
+      )
       None
-    | Some(_) =>
-      Some({readModel: rm, projections: underscoredProj, stream})
+    | Some(_) => Some({readModel: rm, projections: underscoredProj, stream})
     }
   }
   let readModels = Array.concat(

package/src/generator/PlatformCodegen.res

@@ -44,16 +44,20 @@ let union = (manifests: array<pluginManifest>): array<unionEntry> => {
   let byKey: dict<unionEntry> = Dict.make()
   manifests->Array.forEach(({pluginName, manifest}) =>
     manifest.capabilities->Array.forEach(entry => {
-      let sites =
-        entry.declaredBy->Array.map(site => {
+      let sites = entry.declaredBy->Array.map(
+        site => {
           pluginName,
           component: site.component,
           field: site.field,
           annotation: site.annotation,
-        })
+        },
+      )
       switch byKey->Dict.get(entry.key) {
       | Some(existing) =>
-        byKey->Dict.set(entry.key, {...existing, declaredBy: existing.declaredBy->Array.concat(sites)})
+        byKey->Dict.set(
+          entry.key,
+          {...existing, declaredBy: existing.declaredBy->Array.concat(sites)},
+        )
       | None => byKey->Dict.set(entry.key, {kind: entry.kind, key: entry.key, declaredBy: sites})
       }
     })
@@ -71,10 +75,7 @@ let quote = (s: string): string => s->JSON.Encode.string->JSON.stringify
 let splitKey = (key: string): option<(string, string)> =>
   key
   ->String.indexOfOpt(".")
-  ->Option.map(i => (
-    key->String.slice(~start=0, ~end=i),
-    key->String.slice(~start=i + 1),
-  ))
+  ->Option.map(i => (key->String.slice(~start=0, ~end=i), key->String.slice(~start=i + 1)))
 
 // The provenance comment names the store as the field spells it — taken from
 // the manifest, which recorded it at the one place the owning plugin was
@@ -109,7 +110,9 @@ let renderEntry = (entry: unionEntry): result<array<string>, string> =>
     switch splitKey(entry.key) {
     | None =>
       Error(
-        `malformed capability key ${quote(entry.key)} — expected "{plugin}.{store}" (is the plugin's capabilities.json hand-edited?)`,
+        `malformed capability key ${quote(
+            entry.key,
+          )} — expected "{plugin}.{store}" (is the plugin's capabilities.json hand-edited?)`,
       )
     | Some((plugin, store)) =>
       Ok(
@@ -176,8 +179,7 @@ let duplicatePluginMessage = ((plugin, claimants): (string, array<string>)): str
     )}.\n` ++
   `  A platform keys its plugin registry by name, so the second registration is read as a new ` ++
   `VERSION of the first and supersedes it.\n` ++
-  `  Give each deployable's plugin a distinct name (plugin.json), or — if these were meant to be ` ++
-  `one plugin — deploy only one of them.`
+  `  Give each deployable's plugin a distinct name (plugin.json), or — if these were meant to be ` ++ `one plugin — deploy only one of them.`
 
 let header = [
   "// AUTO-GENERATED — do not edit. Run `pnpm run generate:platform` to update.",

package/src/generator/PlatformManifests.res

@@ -75,9 +75,7 @@ let scriptsOf = (pkg: dict<JSON.t>): array<string> =>
   pkg
   ->Dict.get("scripts")
   ->Option.flatMap(asObject)
-  ->Option.mapOr([], scripts =>
-    scripts->Dict.valuesToArray->Array.filterMap(JSON.Decode.string)
-  )
+  ->Option.mapOr([], scripts => scripts->Dict.valuesToArray->Array.filterMap(JSON.Decode.string))
 
 // The composition `src/` an `-aws` root is generated from, read off the script
 // that performs the generation.

package/src/generator/PluginGenerator.res

@@ -2,7 +2,6 @@
 // Usage: generate-plugin <srcDir>
 //        generate-plugin --aws <Namespace> <srcDir>
 
-
 let () = {
   let argv2 = NodeProcess.argv->Array.get(2)->Option.getOr("")
   let argv3 = NodeProcess.argv->Array.get(3)->Option.getOr("")

package/src/generator/TraitManifestCli.res

@@ -48,7 +48,9 @@ let moduleBase = (traitPackage: string) =>
 
 let resolveFrom = (specifier: string) =>
   try Some(
-    NodeModule.createRequire(NodeProcess.cwd() ++ "/index.js")->NodeModule.requireResolve(specifier),
+    NodeModule.createRequire(NodeProcess.cwd() ++ "/index.js")->NodeModule.requireResolve(
+      specifier,
+    ),
   ) catch {
   | _ => None
   }
@@ -80,8 +82,7 @@ let main = async () => {
       let packageJson = switch resolveFrom(`${traitPackage}/package.json`) {
       | None =>
         fail(
-          `${traitPackage} is not installed here. A manifest is derived from the trait, so ` ++
-          `the trait has to be resolvable.`,
+          `${traitPackage} is not installed here. A manifest is derived from the trait, so ` ++ `the trait has to be resolvable.`,
         )
         JSON.Encode.null
       | Some(path) => NodeFs.readFileSync(path)->JSON.parseOrThrow
@@ -95,8 +96,7 @@ let main = async () => {
       | None =>
         fail(
           `${traitPackage} exports no ${base} module, so its capability needs cannot be read.\n` ++
-          `  A trait states them as a value — an empty array if it brokers nothing — because ` ++
-          `an unstated need fails silently at run time.`,
+          `  A trait states them as a value — an empty array if it brokers nothing — because ` ++ `an unstated need fails silently at run time.`,
         )
         %raw(`undefined`)
       | Some(path) => await dynImport(NodeUrl.pathToFileURL(path)["href"])
@@ -127,8 +127,8 @@ let main = async () => {
       NodeFs.writeFileSync(out, manifest->TraitManifest.render)
       Console.log(
         `trait-manifest: ${manifest.trait}@${manifest.version} — ` ++
-        `${(manifest.capabilities->Array.length)->Int.toString} capabilit(ies), ` ++
-        `${(manifest.config->Array.length)->Int.toString} config field(s)`,
+        `${manifest.capabilities->Array.length->Int.toString} capabilit(ies), ` ++
+        `${manifest.config->Array.length->Int.toString} config field(s)`,
       )
       Console.log(`Wrote: ${out}`)
     }