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

package/CHANGELOG.md

@@ -3,6 +3,39 @@
 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.135 (2026-09-11)
+
+### Bug Fixes
+
+* **spec:** a command that declines to act is not a command that was refused ([0b3d8a4](https://github.com/ReventlessDev/reventless-core/commit/0b3d8a40092ce7ed7801a2aae5d4d7bbed03c179))
+* feat(spec)!: a secret is a capability, so a test can know it in advance ([71507c6](https://github.com/ReventlessDev/reventless-core/commit/71507c6459b49178746f00c5040cb479d7fdade8))
+* feat(spec)!: making a principal is a capability, so the provider is replaceable ([3e59b9b](https://github.com/ReventlessDev/reventless-core/commit/3e59b9b665cc7e4b6b6f156b63b1b6bd0c6181ca))
+### Features
+
+* **aws:** the first administrator is one command, not the console ([5f1a846](https://github.com/ReventlessDev/reventless-core/commit/5f1a84603b21a9feb691a08a148751c6c6e8eca8))
+* **aws:** the rest of the cast is a file, not a comment ([aa23581](https://github.com/ReventlessDev/reventless-core/commit/aa23581f09948a47fb451ec2ecf2fc2bdd8e6ee6))
+* **spec:** preparing a manifest is not an AWS errand ([bd7f8e2](https://github.com/ReventlessDev/reventless-core/commit/bd7f8e2f6132c0cacac2ab839165f21fe91eaf6c))
+
+### BREAKING CHANGES
+
+* Capabilities.t gains a secrets member. A platform that builds
+the record literally no longer compiles until it supplies one;
+Capabilities.none.secrets is the refusing value. Code that spreads
+Capabilities.none is unaffected.
+* Capabilities.t gains an identityProvider member. A platform
+that builds the record literally no longer compiles until it supplies one;
+Capabilities.none.identityProvider is the refusing value to pass while no
+backend exists. Code that spreads Capabilities.none is unaffected.
+
+
+
+# 3.0.0-alpha.134 (2026-09-09)
+
+### Bug Fixes
+
+* **spec:** let the formatter settle the lifecycle model's layout ([09e1742](https://github.com/ReventlessDev/reventless-core/commit/09e17429c24d3b84ee6d324b0641d62db4f0d9f9))
+
+
 # 3.0.0-alpha.133 (2026-09-08)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.133",
+  "version": "3.0.0-alpha.135",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -9,7 +9,8 @@
     "graft-trait": "./run-graft-trait.mjs",
     "certify-trait": "./run-certify-trait.mjs",
     "trait-manifest": "./run-trait-manifest.mjs",
-    "check-lifecycle": "./run-check-lifecycle.mjs"
+    "check-lifecycle": "./run-check-lifecycle.mjs",
+    "prepare-accounts": "./run-prepare-accounts.mjs"
   },
   "jest": {
     "testMatch": [
@@ -25,7 +26,7 @@
     "sury": "11.0.0-rc.2",
     "sury-ppx": "11.0.0-rc.2",
     "yaml": "^2.8.3",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.10"
+    "@reventlessdev/rescript-node": "2.0.0-alpha.11"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/run-check-lifecycle.mjs

@@ -1,2 +1,3 @@
 #!/usr/bin/env node
-import "./src/lifecycle/CheckLifecycleModel.res.mjs"
+import { main } from "./src/lifecycle/CheckLifecycleModel.res.mjs"
+await main()

package/run-prepare-accounts.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from "./src/types/PrepareAccounts.res.mjs"
+await main()

package/src/AnsiStyle.res

@@ -7,7 +7,6 @@
     depend on it, so the sink decision lives here as the single source of
     truth. `useAnsi()` ⇒ TTY text mode (colour/bold); `isJsonSink()` ⇒
     structured JSON for any non-TTY collector (CloudWatch, Datadog, …). */
-
 @val external _isTty: option<bool> = "process.stdout.isTTY"
 @val external _logFormat: option<string> = "process.env.REVENTLESS_LOG_FORMAT"
 

package/src/LogPrefix.res

@@ -18,10 +18,9 @@ Resolution priority for a comp string like `"Kind(Name)"`:
 `Plugin_Builder` registers every component (and the plugin's self-name) when
 constructing a plugin, so all transformation candidates resolve to a
 real plugin name. */
-
-// Ambient plugin name. Set inside `Plugin_Builder.Make.construct` so
+let // Ambient plugin name. Set inside `Plugin_Builder.Make.construct` so
 // synchronous logs during construction carry a `[Name]` prefix.
-let currentPluginName: ref<option<string>> = ref(None)
+currentPluginName: ref<option<string>> = ref(None)
 
 // Registry: component name → owning plugin name. Populated at construct time.
 let componentPluginRegistry: ref<dict<string>> = ref(Dict.make())
@@ -40,14 +39,7 @@ let hashStr = (s: string): int => {
 }
 
 // Foreground colors that don't collide with level indicators (cyan / yellow / red).
-let pluginColors = [
-  "\x1b[32m", // green
-  "\x1b[34m", // blue
-  "\x1b[35m", // magenta
-  "\x1b[92m", // bright green
-  "\x1b[94m", // bright blue
-  "\x1b[95m", // bright magenta
-]
+let pluginColors = ["\x1b[32m", "\x1b[34m", "\x1b[35m", "\x1b[92m", "\x1b[94m", "\x1b[95m"] // green // blue // magenta // bright green // bright blue // bright magenta
 
 let pluginColor = (name: string): string =>
   pluginColors->Array.getUnsafe(mod(hashStr(name), pluginColors->Array.length))
@@ -99,8 +91,7 @@ let lastDotSegment = (s: string): option<string> => {
   }
 }
 
-let lookup = (name: string): option<string> =>
-  componentPluginRegistry.contents->Dict.get(name)
+let lookup = (name: string): option<string> => componentPluginRegistry.contents->Dict.get(name)
 
 // Last-resort candidate: the inner name is a registered component name carrying a
 // component-kind suffix (`Customers` + `ReadModel` → `CustomersReadModel`), which is

package/src/components/AutomationSlice.res

@@ -42,7 +42,6 @@ let maxRetries = 3
 let heartbeatInterval = 60
 ```
 */
-
 /**
 The lean Spec for an AutomationSlice — types, identity, schemas, sweep config.
 
@@ -196,9 +195,7 @@ module type Automation = {
   + `module type Mapping = M.Mapping` produces exactly this shape; legacy
   3-file files re-export it via `module type Mapping = <Stem>_Mappings.Mapping`.
   */
-  module type Mapping = Mapping
-    with type todoItem = Spec.todoItem
-    and type command = Spec.command
+  module type Mapping = Mapping with type todoItem = Spec.todoItem and type command = Spec.command
 
   /**
   The per-source mappings registered with this slice. Each entry is a first-class
@@ -318,4 +315,3 @@ module Mappings = {
       and type command = Target.command
   }
 }
-

package/src/components/CapabilityManifest.res

@@ -12,7 +12,6 @@ spell one fact differently.
 The platform generator unions these files across a deployment's plugins and
 emits the platform's capability list from them.
 */
-
 @schema
 type kind =
   | ObjectStore
@@ -22,6 +21,9 @@ type kind =
   /** Sending a message, reached through `Capabilities.messaging`. Slice-declared
       like `Geocoding`, and for the same reason carries no `field`. */
   | Messaging
+  /** Making, grouping and unmaking principals, reached through
+      `Capabilities.identityProvider`. Slice-declared, so no `field`. */
+  | IdentityProvider
 
 /** The declaration site: the component's spec name, and — for a store — the field
     carrying the `@storageRef` annotation plus the store exactly as that field
@@ -81,10 +83,11 @@ let fromStructure = (structure: Plugin.pluginStructure): t => {
       kind: switch need {
       | Geocoding => Geocoding
       | Messaging => Messaging
+      | IdentityProvider => IdentityProvider
       },
       key,
-      declaredBy: needs->Array.filterMap(d =>
-        d.capability == key ? Some({component: d.component}) : None
+      declaredBy: needs->Array.filterMap(
+        d => d.capability == key ? Some({component: d.component}) : None,
       ),
     })
   )

package/src/components/CapabilityManifest.res.mjs

@@ -10,7 +10,8 @@ import * as CapabilityNeed$Reventless from "../semantic/CapabilityNeed.res.mjs";
 let kindSchema = Sury.union([
   Sury.literal("ObjectStore"),
   Sury.literal("Geocoding"),
-  Sury.literal("Messaging")
+  Sury.literal("Messaging"),
+  Sury.literal("IdentityProvider")
 ]);
 
 let provenanceSchema = Sury.$schema(s => ({
@@ -48,7 +49,17 @@ function fromStructure(structure) {
   let capabilityKeys = Belt_SetString.toArray(Belt_SetString.fromArray(needs.map(d => d.capability)));
   let capabilities = Stdlib_Array.filterMap(capabilityKeys, key => Stdlib_Option.map(CapabilityNeed$Reventless.fromString(key), need => {
     let tmp;
-    tmp = need === "Geocoding" ? "Geocoding" : "Messaging";
+    switch (need) {
+      case "Geocoding" :
+        tmp = "Geocoding";
+        break;
+      case "Messaging" :
+        tmp = "Messaging";
+        break;
+      case "IdentityProvider" :
+        tmp = "IdentityProvider";
+        break;
+    }
     return {
       kind: tmp,
       key: key,

package/src/components/DcbDecode.res

@@ -59,13 +59,17 @@ external unsafeCast: 'a => 'b = "%identity"
 // Build a map of TAG name -> constructed payload-less variant value
 // by encoding each payload-less variant through sury and storing the result.
 // This is done once per schema, not per event.
-let buildPayloadLessConstructors = (schema: S.t<'event>, lookup: dict<variantKind>): dict<'event> => {
+let buildPayloadLessConstructors = (schema: S.t<'event>, lookup: dict<variantKind>): dict<
+  'event,
+> => {
   let constructors = Dict.make()
   // For payload-less variants, we need to figure out what ReScript value
   // corresponds to each TAG name. sury's schema for a union with payload-less
   // variants encodes them as bare strings. So `| ItemCreated` serializes to
   // JSON string "ItemCreated". We can use Util_Sury.fromJson with the string.
-  lookup->Dict.toArray->Array.forEach(((tagName, kind)) =>
+  lookup
+  ->Dict.toArray
+  ->Array.forEach(((tagName, kind)) =>
     switch kind {
     | PayloadLess =>
       try {

package/src/components/DcbScopeInference.res

@@ -29,7 +29,6 @@ The three rules (over the representation):
    on `ProductAdded`) are payload ⇒ not indexed ⇒ the sibling-leak GSI write never
    happens.
 */
-
 /** A `*Id` / `*Ids`-shaped field, identified by name only (no schema, no tag flag). */
 type idField = {name: string, isList: bool}
 
@@ -210,15 +209,19 @@ let infer = (slices: array<sliceShape>): derived => {
           partitionBlockers(s)
           ->Array.map(((key, arms)) => `${arms->Array.join("/")} declares ${key}`)
           ->Array.join("; ")
-        let _ = ambiguities->Array.push((
-          s.sliceName,
-          `no own partition key — every produced *Id is read from a foreign producer (${blame}). If that field is this slice's own partition, remove it from the consumed arm; if the slice really is a pure join, add an explicit @partitionTag`,
-        ))
+        let _ =
+          ambiguities->Array.push((
+            s.sliceName,
+            `no own partition key — every produced *Id is read from a foreign producer (${blame}). If that field is this slice's own partition, remove it from the consumed arm; if the slice really is a pure join, add an explicit @partitionTag`,
+          ))
       | many =>
-        let _ = ambiguities->Array.push((
-          s.sliceName,
-          `multiple candidate partition keys (${many->Array.join(", ")}) — add an explicit @partitionTag`,
-        ))
+        let _ =
+          ambiguities->Array.push((
+            s.sliceName,
+            `multiple candidate partition keys (${many->Array.join(
+                ", ",
+              )}) — add an explicit @partitionTag`,
+          ))
       }
     }
   })
@@ -247,7 +250,9 @@ let infer = (slices: array<sliceShape>): derived => {
   slices->Array.forEach(s => {
     let own = partitionBySlice->Dict.get(s.sliceName)
     let scalar = commandScalarKeys(s)
-    s->consumedKeys->Array.forEach(k =>
+    s
+    ->consumedKeys
+    ->Array.forEach(k =>
       if ownedPartitionKeys->Set.has(k) && Some(k) != own && scalar->Array.includes(k) {
         crossKeys->Set.add(k)
       }
@@ -275,8 +280,7 @@ let infer = (slices: array<sliceShape>): derived => {
     let own = partitionBySlice->Dict.get(s.sliceName)
     s.produced->Array.forEach(e => {
       let readKeys = readKeysByEventType->Dict.get(e.eventType)->Option.getOr([])
-      let indexed =
-        e->keysOfEvent->Array.filter(k => Some(k) == own || readKeys->Array.includes(k))
+      let indexed = e->keysOfEvent->Array.filter(k => Some(k) == own || readKeys->Array.includes(k))
       tagKeysByEventType->Dict.set(e.eventType, dedupSorted(indexed))
     })
   })

package/src/components/DcbTag.res

@@ -91,7 +91,10 @@ type appendCondition = {
 let dcbTagId: S.Metadata.Id.t<bool> = S.Metadata.Id.make(~namespace="dcb", ~name="tag")
 
 /** Internal sury metadata ID used to mark the partition tag field. */
-let dcbPartitionTagId: S.Metadata.Id.t<bool> = S.Metadata.Id.make(~namespace="dcb", ~name="partitionTag")
+let dcbPartitionTagId: S.Metadata.Id.t<bool> = S.Metadata.Id.make(
+  ~namespace="dcb",
+  ~name="partitionTag",
+)
 
 /**
 Internal sury metadata ID marking a tag field as *cross-partition* — readable
@@ -101,22 +104,27 @@ partition-scoped behaviour. The scope is a property of the tag *key* and must
 agree across every event type that carries it (the fence-scope half depends on
 it). See `docs/analysis/dcb-consistency-check-issues.md` Issue 13.
 */
-let dcbCrossPartitionId: S.Metadata.Id.t<bool> =
-  S.Metadata.Id.make(~namespace="dcb", ~name="crossPartition")
+let dcbCrossPartitionId: S.Metadata.Id.t<bool> = S.Metadata.Id.make(
+  ~namespace="dcb",
+  ~name="crossPartition",
+)
 
 /** Metadata value for a composite partition member field. */
 type compositePartitionMemberMeta = {position: int, sep: string}
 
 /** Internal sury metadata ID used to mark a composite partition member field. */
-let dcbCompositePartitionMemberId: S.Metadata.Id.t<compositePartitionMemberMeta> =
-  S.Metadata.Id.make(~namespace="dcb", ~name="compositePartitionMember")
+let dcbCompositePartitionMemberId: S.Metadata.Id.t<
+  compositePartitionMemberMeta,
+> = S.Metadata.Id.make(~namespace="dcb", ~name="compositePartitionMember")
 
 /**
 Internal sury metadata ID carrying an explicit tag-key override. When present,
 tag extraction uses the stored string as the tag `key` instead of the field name.
 */
-let dcbTagKeyOverrideId: S.Metadata.Id.t<string> =
-  S.Metadata.Id.make(~namespace="dcb", ~name="tagKeyOverride")
+let dcbTagKeyOverrideId: S.Metadata.Id.t<string> = S.Metadata.Id.make(
+  ~namespace="dcb",
+  ~name="tagKeyOverride",
+)
 
 /**
 A sury string schema annotated as a DCB tag field.
@@ -139,7 +147,8 @@ and array element types.
     })
 ```
 */
-let string: S.t<string> = S.string->S.Metadata.set(~id=dcbTagId, true)
+let string: S.t<string> =
+  S.string->S.Metadata.set(~id=dcbTagId, true)
 
 /**
 A sury string schema annotated as a DCB tag field with an explicit tag-key override.
@@ -169,7 +178,8 @@ let stringForKey = (~key: string): S.t<string> =>
 A sury int schema annotated as a DCB tag field.
 Use with `@s.matches(DcbTag.int)` on integer fields that should be extracted as tags.
 */
-let int: S.t<int> = S.int->S.Metadata.set(~id=dcbTagId, true)
+let int: S.t<int> =
+  S.int->S.Metadata.set(~id=dcbTagId, true)
 
 /**
 A sury string schema annotated as both a DCB tag field AND the partition key.
@@ -518,12 +528,15 @@ let extractTagsFromJson = (schema: S.t<unknown>, json: JSON.t): array<tag> =>
   | AnyOf({anyOf}) =>
     switch json->JSON.Decode.object {
     | Some(jsonDict) =>
-      let jsonTag = jsonDict->Dict.get("TAG")->Option.flatMap(j =>
-        switch j {
-        | JSON.String(s) => Some(s)
-        | _ => None
-        }
-      )
+      let jsonTag =
+        jsonDict
+        ->Dict.get("TAG")
+        ->Option.flatMap(j =>
+          switch j {
+          | JSON.String(s) => Some(s)
+          | _ => None
+          }
+        )
       anyOf->Array.reduce([], (acc, variantSchema) =>
         if acc->Array.length > 0 {
           acc
@@ -674,10 +687,7 @@ Fields holding records are descended into on the same terms as in
 `extractTagsFromProperties` — the two walks agree there and differ only on scalar
 arrays; see that function.
 */
-let extractTagsFromPropertiesExpanded = (
-  properties: dict<S.t<unknown>>,
-  jsonDict: dict<JSON.t>,
-) =>
+let extractTagsFromPropertiesExpanded = (properties: dict<S.t<unknown>>, jsonDict: dict<JSON.t>) =>
   properties
   ->Dict.toArray
   ->Array.flatMap(((fieldName, fieldSchema)) =>
@@ -705,12 +715,15 @@ let extractTagsFromJsonExpanded = (schema: S.t<unknown>, json: JSON.t): array<ta
   | AnyOf({anyOf}) =>
     switch json->JSON.Decode.object {
     | Some(jsonDict) =>
-      let jsonTag = jsonDict->Dict.get("TAG")->Option.flatMap(j =>
-        switch j {
-        | JSON.String(s) => Some(s)
-        | _ => None
-        }
-      )
+      let jsonTag =
+        jsonDict
+        ->Dict.get("TAG")
+        ->Option.flatMap(j =>
+          switch j {
+          | JSON.String(s) => Some(s)
+          | _ => None
+          }
+        )
       anyOf->Array.reduce([], (acc, variantSchema) =>
         if acc->Array.length > 0 {
           acc
@@ -873,8 +886,7 @@ let narrowEventTypesForTags = (
   eventTypes->Array.filter(eventType =>
     switch tagKeysByEventType->Dict.get(eventType) {
     | None => true
-    | Some(producedKeys) =>
-      tags->Array.every(tag => producedKeys->Array.includes(tag.key))
+    | Some(producedKeys) => tags->Array.every(tag => producedKeys->Array.includes(tag.key))
     }
   )
 
@@ -922,7 +934,8 @@ let buildQueryFromCommand = (
   ~tagKeysByEventType: dict<array<string>>=Dict.make(),
   ~crossPartitionTagKeys: array<string>=[],
 ): query => {
-  let typesForTags = clauseTags => narrowEventTypesForTags(eventTypes, clauseTags, tagKeysByEventType)
+  let typesForTags = clauseTags =>
+    narrowEventTypesForTags(eventTypes, clauseTags, tagKeysByEventType)
   if hasTaggedArrayFields(schema) {
     // Array fields already fan out per element into single-tag clauses, so a
     // cross-partition array tag is already its own clause (the adapter routes it
@@ -940,8 +953,7 @@ let buildQueryFromCommand = (
     // must read "all of the course" AND "all of the student" as two single-tag
     // reads — a composite read of the exact `{course, student}` pair is neither.
     // Without a cross-partition tag the default composite clause is preserved.
-    let hasCrossPartition =
-      tags->Array.some(tag => crossPartitionTagKeys->Array.includes(tag.key))
+    let hasCrossPartition = tags->Array.some(tag => crossPartitionTagKeys->Array.includes(tag.key))
     if hasCrossPartition && tags->Array.length > 1 {
       tags->Array.map(tag => {
         let clauseTags = [{key: tag.key, value: tag.value}]
@@ -1347,9 +1359,9 @@ type compositePartitionFieldInfo = {name: string, position: int, sep: string}
 Extracts all composite partition member fields from a single object-variant schema.
 Returns an array sorted by `position`.
 */
-let extractCompositePartitionFieldsFromProperties = (
-  properties: dict<S.t<unknown>>,
-): array<compositePartitionFieldInfo> =>
+let extractCompositePartitionFieldsFromProperties = (properties: dict<S.t<unknown>>): array<
+  compositePartitionFieldInfo,
+> =>
   properties
   ->Dict.toArray
   ->Array.filterMap(((fieldName, fieldSchema)) =>
@@ -1396,7 +1408,15 @@ let getCompositePartitionKeyValue = (tags: array<tag>, spec: compositePartitionS
   spec.keys
   ->Array.mapWithIndex((fieldName, i) => {
     let v =
-      tags->Array.findMap(t => if t.key == fieldName {Some(t.value)} else {None})->Option.getOr("")
+      tags
+      ->Array.findMap(t =>
+        if t.key == fieldName {
+          Some(t.value)
+        } else {
+          None
+        }
+      )
+      ->Option.getOr("")
     if i == 0 {
       v
     } else {
@@ -1450,7 +1470,9 @@ let derivePartitionTag = (
 
   let allPartitionFields = {
     let seen = Set.make()
-    schemas->Array.flatMap(schema => extractPartitionTagFields(schema))->Array.filter(f => {
+    schemas
+    ->Array.flatMap(schema => extractPartitionTagFields(schema))
+    ->Array.filter(f => {
       if seen->Set.has(f) {
         false
       } else {
@@ -1461,27 +1483,28 @@ let derivePartitionTag = (
   }
 
   if hasComposite && allPartitionFields->Array.length > 0 {
-    JsError.throwWithMessage(
-      `DCB spec mixes @compositePartitionTag and @partitionTag — use one strategy per schema`,
-    )
+    JsError.throwWithMessage(`DCB spec mixes @compositePartitionTag and @partitionTag — use one strategy per schema`)
   }
 
   if hasComposite {
     if allCompositeFields->Array.length < 2 {
       JsError.throwWithMessage(
-        `@compositePartitionTag requires at least 2 annotated fields — only ${allCompositeFields->Array.length->Int.toString} found`,
+        `@compositePartitionTag requires at least 2 annotated fields — only ${allCompositeFields
+          ->Array.length
+          ->Int.toString} found`,
       )
     }
     let sorted = allCompositeFields->Array.toSorted((a, b) => Int.compare(a.position, b.position))
     let keys = sorted->Array.map(info => info.name)
-    let seps = sorted->Array.slice(~start=0, ~end=sorted->Array.length - 1)->Array.map(info =>
-      info.sep
-    )
+    let seps =
+      sorted->Array.slice(~start=0, ~end=sorted->Array.length - 1)->Array.map(info => info.sep)
     Composite({keys, seps})
   } else {
     let allTaggedFields = {
       let seen = Set.make()
-      schemas->Array.flatMap(schema => extractTaggedFields(schema))->Array.filter(f => {
+      schemas
+      ->Array.flatMap(schema => extractTaggedFields(schema))
+      ->Array.filter(f => {
         if seen->Set.has(f) {
           false
         } else {
@@ -1492,7 +1515,8 @@ let derivePartitionTag = (
     }
 
     switch allTaggedFields {
-    | [] => JsError.throwWithMessage("DCB spec has no tagged fields — cannot derive partition tag")
+    | [] =>
+      JsError.throwWithMessage("DCB spec has no tagged fields — cannot derive partition tag")
     | [singleField] => Simple({key: singleField})
     | multipleFields => {
         let needsExplicitPartition = schemas->Array.some(schema => hasMultiTagVariant(schema))
@@ -1514,11 +1538,15 @@ let derivePartitionTag = (
           | [singlePartition] => Simple({key: singlePartition})
           | [] =>
             JsError.throwWithMessage(
-              `DCB spec has variants with multiple tagged fields (${multipleFields->Array.join(", ")}) but none is annotated with @partitionTag — affected: ${context} — mark one field as the partition key`,
+              `DCB spec has variants with multiple tagged fields (${multipleFields->Array.join(
+                  ", ",
+                )}) but none is annotated with @partitionTag — affected: ${context} — mark one field as the partition key`,
             )
           | multiplePartitions =>
             JsError.throwWithMessage(
-              `DCB spec has multiple fields annotated with @partitionTag (${multiplePartitions->Array.join(", ")}) — only one is allowed — affected: ${context}`,
+              `DCB spec has multiple fields annotated with @partitionTag (${multiplePartitions->Array.join(
+                  ", ",
+                )}) — only one is allowed — affected: ${context}`,
             )
           }
         } else {