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

package/src/lifecycle/CheckLifecycleModel.res

@@ -60,7 +60,6 @@ check-lifecycle --root . --reuse-sidecars --json
 check-lifecycle --root . --update     # write this app's models and golden
 ```
 */
-
 // The model this script writes is folded into `pluginStructure`, so by the time
 // it runs again the "declared" side it reads back would be its own last answer —
 // every edge confirmed, and a real disagreement between an annotation and the
@@ -103,7 +102,8 @@ type appRoot = {label: string, dir: string}
     corpus is on disk; a second pass over a warm tree buys nothing and costs the
     multi-root build chain's habit of cleaning artifacts outside the root it is
     building, which lands intermittently on a stale `.cmi`. */
-let reuseSidecars = NodeProcess.argv->Array.includes("--reuse-sidecars")
+let reuseSidecars =
+  NodeProcess.argv->Array.includes("--reuse-sidecars")
 
 /** Report the run as one JSON document on stdout instead of the grouped prose.
 
@@ -117,7 +117,8 @@ let reuseSidecars = NodeProcess.argv->Array.includes("--reuse-sidecars")
     repository says it said — nor fail because the two have drifted, which is a
     fact about the repository rather than about the corpus it was asked to
     report. A contradiction still exits non-zero, so this composes with a gate. */
-let json = NodeProcess.argv->Array.includes("--json")
+let json =
+  NodeProcess.argv->Array.includes("--json")
 
 /** The label a state carries when no row exists yet. Not a lifecycle case — no
     enum declares it — so it is spelled in a way no constructor can name, and a
@@ -295,8 +296,7 @@ let checkSidecars = (~pluginDirs: array<string>): result<unit, string> =>
   hasCorpus(~pluginDirs)
     ? Ok()
     : Error(
-        "--reuse-sidecars was passed, but no scenario sidecar exists. Build with " ++
-        "REVENTLESS_EMIT_SIDECAR=1 first, or drop the flag.",
+        "--reuse-sidecars was passed, but no scenario sidecar exists. Build with " ++ "REVENTLESS_EMIT_SIDECAR=1 first, or drop the flag.",
       )
 
 /** Sidecars are gitignored build artifacts, so the harvest produces its own
@@ -405,11 +405,13 @@ let declaredOf = (structure: JSON.t): option<declared> =>
       getObjs(s, key)->Array.filterMap(w =>
         w
         ->getStr("name")
-        ->Option.map(name => {
-          name,
-          linkedViews: getStrs(w, "linkedViews"),
-          commands: getObjs(w, "commands")->Array.filterMap(declaredCommandOf),
-        })
+        ->Option.map(
+          name => {
+            name,
+            linkedViews: getStrs(w, "linkedViews"),
+            commands: getObjs(w, "commands")->Array.filterMap(declaredCommandOf),
+          },
+        )
       )
     let viewsFrom = key =>
       getObjs(s, key)->Array.filterMap(v =>
@@ -647,9 +649,7 @@ let deriveCommands = (
         effective->Array.filterMap(o => o.from == noRow ? None : Some(o.from)),
       ),
       inertStates: sortedUnique(
-        mine->Array.filterMap(o =>
-          o.outcome == Emitted || o.from == noRow ? None : Some(o.from)
-        ),
+        mine->Array.filterMap(o => o.outcome == Emitted || o.from == noRow ? None : Some(o.from)),
       ),
       targets: sortedUnique(
         effective->Array.filterMap(o => o.to == o.from || o.to == noRow ? None : Some(o.to)),
@@ -764,8 +764,7 @@ let compare = (
         add(
           "contradicted",
           [state],
-          `the switch declares it legal in every state, and a scenario from "${state}" ` ++
-          `shows it refused or producing nothing`,
+          `the switch declares it legal in every state, and a scenario from "${state}" ` ++ `shows it refused or producing nothing`,
         )
       )
     | None =>
@@ -773,8 +772,9 @@ let compare = (
         add(
           "undeclared",
           derived.allowedStates,
-          `scenarios show it taking effect from ${derived.allowedStates->Array.join(", ")}, ` ++
-          `and it declares no edge`,
+          `scenarios show it taking effect from ${derived.allowedStates->Array.join(
+              ", ",
+            )}, ` ++ `and it declares no edge`,
         )
       }
     | Some(states) =>
@@ -785,8 +785,7 @@ let compare = (
           add(
             "contradicted",
             [state],
-            `the switch names "${state}", and a scenario from "${state}" shows it ` ++
-            `refused or producing nothing`,
+            `the switch names "${state}", and a scenario from "${state}" shows it ` ++ `refused or producing nothing`,
           )
         } else {
           add("unverified", [state], `the switch names "${state}", and no scenario starts there`)
@@ -806,8 +805,9 @@ let compare = (
         add(
           "unverified",
           states,
-          `the switch declares ${Array.length(states)->Int.toString} state(s) and ` ++
-          `no scenario shows the command taking effect anywhere`,
+          `the switch declares ${Array.length(
+              states,
+            )->Int.toString} state(s) and ` ++ `no scenario shows the command taking effect anywhere`,
         )
       }
     }
@@ -830,8 +830,7 @@ let compare = (
           add(
             "contradicted",
             [target, state],
-            `the switch targets "${target}", and a scenario lands in "${state}" — ` ++
-            `the published targetState carries one state, so this edge cannot be expressed`,
+            `the switch targets "${target}", and a scenario lands in "${state}" — ` ++ `the published targetState carries one state, so this edge cannot be expressed`,
           )
         }
       )
@@ -933,107 +932,111 @@ let runPlugin = async (
   switch await readDeclared(~pluginDir) {
   | Error(msg) => Error(msg)
   | Ok(declared) =>
-      let corpora =
-        filesUnder(NodePath.join([pluginDir, "tests"]), ~suffix=".gwt.json")->Array.filterMap(
-          readCorpus,
-        )
-
-      // Every corpus, not only the ones the walk goes on to use: the kinds that
-      // are unreadable in full — extension points, automation and translation
-      // slices — are exactly the ones that sit outside the view/writable folders
-      // below, and they are the ones a coverage UI would otherwise slander.
-      corpora->Array.forEach(c => {
-        let unreadable = c.scenarios->Array.filter(s => Array.length(s.whenElements) == 0)
-        if Array.length(unreadable) > 0 {
-          opaque
-          ->Array.push({
-            plugin,
-            component: c.component,
-            path: c.path,
-            scenarios: Array.length(c.scenarios),
-            unreadable: Array.length(unreadable),
-          })
-          ->ignore
-        }
-      })
-
-      // Views first: a command's history cannot be labelled until the events in
-      // it have somewhere to land.
-      let mapsByView = Dict.make()
-      let ambiguities = []
-      corpora->Array.forEach(c =>
-        if isViewPath(c.path) {
-          switch declared.views->Array.find(v => v.name == c.component) {
-          | Some({lifecycleField: Some(field)}) =>
-            mapsByView->Dict.set(
-              c.component,
-              lifecycleMapFor(~scenarios=c.scenarios, ~field, ~ambiguities, ~view=c.component),
-            )
-          // A view with no lifecycle field labels nothing, and that is ordinary
-          // — most views have no lifecycle at all.
-          | _ => ()
-          }
-        }
+    let corpora =
+      filesUnder(NodePath.join([pluginDir, "tests"]), ~suffix=".gwt.json")->Array.filterMap(
+        readCorpus,
       )
-      ambiguities->Array.forEach(((view, message)) =>
-        findings
+
+    // Every corpus, not only the ones the walk goes on to use: the kinds that
+    // are unreadable in full — extension points, automation and translation
+    // slices — are exactly the ones that sit outside the view/writable folders
+    // below, and they are the ones a coverage UI would otherwise slander.
+    corpora->Array.forEach(c => {
+      let unreadable = c.scenarios->Array.filter(s => Array.length(s.whenElements) == 0)
+      if Array.length(unreadable) > 0 {
+        opaque
         ->Array.push({
-          severity: "ambiguous",
           plugin,
-          component: view,
-          command: "",
-          states: [],
-          message,
+          component: c.component,
+          path: c.path,
+          scenarios: Array.length(c.scenarios),
+          unreadable: Array.length(unreadable),
         })
         ->ignore
-      )
+      }
+    })
 
-      let derived = []
-      corpora->Array.forEach(c =>
-        if isWritablePath(c.path) {
-          switch declared.writables->Array.find(w => w.name == c.component) {
-          | None => ()
-          | Some(writable) =>
-            // The union of the maps of every view this writable feeds. A union
-            // rather than a single view for the reason the platform's own name
-            // check uses one: a slice feeding two views is not claiming which of
-            // them a state belongs to.
-            let map = Dict.make()
-            writable.linkedViews->Array.forEach(view =>
-              switch mapsByView->Dict.get(view) {
-              | Some(m) => m->Dict.forEachWithKey((value, event) => map->Dict.set(event, value))
-              | None => ()
-              }
-            )
-            let labelled = Array.length(map->Dict.keysToArray) > 0
-            let idFieldFor = command =>
-              writable.commands
-              ->Array.find(c => c.command == command)
-              ->Option.flatMap(c => c.aggregateIdField)
-            let observations = observe(~scenarios=c.scenarios, ~map, ~idFieldFor)
-            let commands = deriveCommands(~component=c.component, ~observations, ~labelled)
-
-            commands->Array.forEach(d => {
-              // Without a lifecycle map every history folds to "no row", so
-              // there is nothing to confirm a claim against and nothing to
-              // contradict it with. Reporting the claim as unverified is the
-              // honest answer; running the comparison would manufacture
-              // contradictions out of a missing map.
-              if labelled {
-                compare(~plugin, ~writable, ~derived=d, ~findings)
-              }
-              derived->Array.push(d)
-            })
+    // Views first: a command's history cannot be labelled until the events in
+    // it have somewhere to land.
+    let mapsByView = Dict.make()
+    let ambiguities = []
+    corpora->Array.forEach(c =>
+      if isViewPath(c.path) {
+        switch declared.views->Array.find(v => v.name == c.component) {
+        | Some({lifecycleField: Some(field)}) =>
+          mapsByView->Dict.set(
+            c.component,
+            lifecycleMapFor(~scenarios=c.scenarios, ~field, ~ambiguities, ~view=c.component),
+          )
+        // A view with no lifecycle field labels nothing, and that is ordinary
+        // — most views have no lifecycle at all.
+        | _ => ()
+        }
+      }
+    )
+    ambiguities->Array.forEach(((view, message)) =>
+      findings
+      ->Array.push({
+        severity: "ambiguous",
+        plugin,
+        component: view,
+        command: "",
+        states: [],
+        message,
+      })
+      ->ignore
+    )
+
+    let derived = []
+    corpora->Array.forEach(c =>
+      if isWritablePath(c.path) {
+        switch declared.writables->Array.find(w => w.name == c.component) {
+        | None => ()
+        | Some(writable) =>
+          // The union of the maps of every view this writable feeds. A union
+          // rather than a single view for the reason the platform's own name
+          // check uses one: a slice feeding two views is not claiming which of
+          // them a state belongs to.
+          let map = Dict.make()
+          writable.linkedViews->Array.forEach(view =>
+            switch mapsByView->Dict.get(view) {
+            | Some(m) => m->Dict.forEachWithKey((value, event) => map->Dict.set(event, value))
+            | None => ()
+            }
+          )
+          let labelled = Array.length(map->Dict.keysToArray) > 0
+          let idFieldFor = command =>
+            writable.commands
+            ->Array.find(c => c.command == command)
+            ->Option.flatMap(c => c.aggregateIdField)
+          let observations = observe(~scenarios=c.scenarios, ~map, ~idFieldFor)
+          let commands = deriveCommands(~component=c.component, ~observations, ~labelled)
+
+          commands->Array.forEach(d => {
+            // Without a lifecycle map every history folds to "no row", so
+            // there is nothing to confirm a claim against and nothing to
+            // contradict it with. Reporting the claim as unverified is the
+            // honest answer; running the comparison would manufacture
+            // contradictions out of a missing map.
+            if labelled {
+              compare(~plugin, ~writable, ~derived=d, ~findings)
+            }
+            derived->Array.push(d)
+          })
 
-            let why = labelled
-              ? "no scenario exercises the command"
-              : `${writable.linkedViews->Array.join(", ")} declares no lifecycle field, so its ` ++
-                `scenarios cannot be labelled`
-            writable.commands->Array.forEach(cmd =>
-              if labelled && commands->Array.some(d => d.command == cmd.command) {
-                ()
-              } else {
-                allUnverified(~cmd, ~why, ~add=(severity, states, message) =>
+          let why = labelled
+            ? "no scenario exercises the command"
+            : `${writable.linkedViews->Array.join(
+                  ", ",
+                )} declares no lifecycle field, so its ` ++ `scenarios cannot be labelled`
+          writable.commands->Array.forEach(cmd =>
+            if labelled && commands->Array.some(d => d.command == cmd.command) {
+              ()
+            } else {
+              allUnverified(
+                ~cmd,
+                ~why,
+                ~add=(severity, states, message) =>
                   findings
                   ->Array.push({
                     severity,
@@ -1043,14 +1046,14 @@ let runPlugin = async (
                     states,
                     message: `${plugin}/${writable.name}.${cmd.command}: ${message}`,
                   })
-                  ->ignore
-                )
-              }
-            )
-          }
+                  ->ignore,
+              )
+            }
+          )
         }
-      )
-      Ok(derived)
+      }
+    )
+    Ok(derived)
   }
 
 // ── The golden ──────────────────────────────────────────────────────────────
@@ -1160,6 +1163,19 @@ let reportJson = (
 
 // ── The value structure assembly reads ──────────────────────────────────────
 
+/** The emitted file is committed ReScript, so it faces the tree's format gate
+    like any other source. Laying the text out by hand would put this script and
+    the formatter in a standing argument only one of them can win — so it emits
+    whatever reads clearly and lets the formatter settle the layout. Raising
+    beats falling back: unformatted source would satisfy this check and fail the
+    format gate, which is the stand-off the call exists to end. */
+let formatted = (source: string): string =>
+  NodeChildProcess.execFileSync(
+    "pnpm",
+    ["exec", "rescript", "format", "--stdin", ".res"],
+    {cwd: repoRoot, encoding: "utf8", input: source},
+  )
+
 /** The same derivation as a committed ReScript value, so `buildStructure` gets
     the model as data. It cannot read the corpus itself: tests are not published
     with a plugin package, and metadata that read them would make deleting a test
@@ -1173,19 +1189,22 @@ let reportJson = (
 let modelSource = (~plugin: string, ~derived: array<derivedCommand>): string => {
   let saysSomething = (d: derivedCommand) =>
     d.level != "" || Array.length(d.allowedStates) > 0 || Array.length(d.targets) > 0
-  let quoted = (xs: array<string>) =>
-    "[" ++ xs->Array.map(s => `"${s}"`)->Array.join(", ") ++ "]"
-  let entries = derived->Array.filter(saysSomething)->byComponentThenCommand->Array.map(d => {
-    // Omitted rather than written as an absent value: `level` is an optional
-    // field, and a corpus that could not label this command's histories has
-    // nothing to say about it.
-    let level = switch d.level {
-    | "Collection" | "Instance" => `level: Reventless.Plugin.${d.level}, `
-    | _ => ""
-    }
-    `  {component: "${d.component}", command: "${d.command}", ${level}` ++
-    `allowedStates: ${quoted(d.allowedStates)}, targets: ${quoted(d.targets)}},`
-  })
+  let quoted = (xs: array<string>) => "[" ++ xs->Array.map(s => `"${s}"`)->Array.join(", ") ++ "]"
+  let entries =
+    derived
+    ->Array.filter(saysSomething)
+    ->byComponentThenCommand
+    ->Array.map(d => {
+      // Omitted rather than written as an absent value: `level` is an optional
+      // field, and a corpus that could not label this command's histories has
+      // nothing to say about it.
+      let level = switch d.level {
+      | "Collection" | "Instance" => `level: Reventless.Plugin.${d.level}, `
+      | _ => ""
+      }
+      `  {component: "${d.component}", command: "${d.command}", ${level}` ++
+      `allowedStates: ${quoted(d.allowedStates)}, targets: ${quoted(d.targets)}},`
+    })
   Array.flat([
     [
       `// AUTO-GENERATED — do not edit. Run \`pnpm run check:lifecycle:update\` to update.`,
@@ -1200,7 +1219,9 @@ let modelSource = (~plugin: string, ~derived: array<derivedCommand>): string =>
     ],
     entries,
     ["]", ""],
-  ])->Array.join("\n")
+  ])
+  ->Array.join("\n")
+  ->formatted
 }
 
 let modelPath = (~pluginDir: string) => NodePath.join([pluginDir, "src", "LifecycleModel.res"])
@@ -1234,8 +1255,9 @@ let main = async () => {
   // an app with no plugins, and reporting "ok" for it is how that typo survives.
   if Array.length(allPluginDirs) == 0 {
     Console.error(
-      `no plugins found under ${roots->Array.map(r => r.dir)->Array.join(", ")} — a plugin is a ` ++
-      `directory with both src/Plugin.res and tests/`,
+      `no plugins found under ${roots
+        ->Array.map(r => r.dir)
+        ->Array.join(", ")} — a plugin is a ` ++ `directory with both src/Plugin.res and tests/`,
     )
     NodeProcess.exit(1)
   }
@@ -1256,8 +1278,11 @@ let main = async () => {
   // refusing outright.
   if !hasCorpus(~pluginDirs=allPluginDirs) {
     Console.error(
-      `no scenario sidecar exists under ${roots->Array.map(r => r.dir)->Array.join(", ")} after ` ++
-      `the build. Build that tree with REVENTLESS_EMIT_SIDECAR=1 and pass --reuse-sidecars.`,
+      `no scenario sidecar exists under ${roots
+        ->Array.map(r => r.dir)
+        ->Array.join(
+          ", ",
+        )} after ` ++ `the build. Build that tree with REVENTLESS_EMIT_SIDECAR=1 and pass --reuse-sidecars.`,
     )
     NodeProcess.exit(1)
   }
@@ -1308,7 +1333,9 @@ let main = async () => {
           ~drifted,
         )
         Console.log(
-          `ok ${example} — ${Array.length(derived)->Int.toString} commands derived from scenarios`,
+          `ok ${example} — ${Array.length(
+              derived,
+            )->Int.toString} commands derived from scenarios`,
         )
       }
     }
@@ -1336,8 +1363,9 @@ let main = async () => {
 
   if Array.length(drifted) > 0 {
     Console.error(
-      `\n${Array.length(drifted)->Int.toString} lifecycle artifact(s) changed. If the change is ` ++
-      `intended, re-run with --update and commit them alongside the change that moved them.`,
+      `\n${Array.length(
+          drifted,
+        )->Int.toString} lifecycle artifact(s) changed. If the change is ` ++ `intended, re-run with --update and commit them alongside the change that moved them.`,
     )
   }
 

package/src/lifecycle/CheckLifecycleModel.res.mjs

@@ -910,6 +910,20 @@ function reportJson(findings, opaque, derived, failures) {
   ]), undefined, 2) + "\n";
 }
 
+function formatted(source) {
+  return Nodechild_process.execFileSync("pnpm", [
+    "exec",
+    "rescript",
+    "format",
+    "--stdin",
+    ".res"
+  ], {
+    cwd: repoRoot,
+    encoding: "utf8",
+    input: source
+  });
+}
+
 function modelSource(plugin, derived) {
   let saysSomething = d => {
     if (d.level !== "" || d.allowedStates.length !== 0) {
@@ -932,7 +946,7 @@ function modelSource(plugin, derived) {
     }
     return `  {component: "` + d.component + `", command: "` + d.command + `", ` + level + (`allowedStates: ` + quoted(d.allowedStates) + `, targets: ` + quoted(d.targets) + `},`);
   });
-  return [
+  return formatted([
     [
       `// AUTO-GENERATED — do not edit. Run \`pnpm run check:lifecycle:update\` to update.`,
       `//`,
@@ -949,7 +963,7 @@ function modelSource(plugin, derived) {
       "]",
       ""
     ]
-  ].flat().join("\n");
+  ].flat().join("\n"));
 }
 
 function modelPath(pluginDir) {
@@ -1126,6 +1140,7 @@ export {
   goldenJson,
   goldenPath,
   reportJson,
+  formatted,
   modelSource,
   modelPath,
   writeOrCompare,

package/src/semantic/Bytes.res

@@ -13,7 +13,6 @@ a JSON number either way.
 }
 ```
 */
-
 /** The count's representation. Transparent `float`; see the note above on why
     it is not `int`. */
 type t = float

package/src/semantic/CalendarDate.res

@@ -31,7 +31,6 @@ type state = {
 }
 ```
 */
-
 /** The day's representation. Transparent `string`, like the rest of the branded
     scalars: the marker refines an existing field rather than replacing it. */
 type t = string
@@ -52,7 +51,8 @@ let fromString = (raw: string): result<t, string> =>
 
 /** The sury schema for a calendar-date field. Write the field's type as
     `Reventless.CalendarDate.t` and sury-ppx resolves it. */
-let schema: S.t<t> = S.string->Semantic.refined(~id=Semantic.Id.date, ~check=fromString)
+let schema: S.t<t> =
+  S.string->Semantic.refined(~id=Semantic.Id.date, ~check=fromString)
 
 /** Whether a field schema carries the calendar-date marker. */
 let isCalendarDate = (fieldSchema: S.t<unknown>) => fieldSchema->Semantic.has(~id=Semantic.Id.date)

package/src/semantic/Capabilities.res

@@ -50,10 +50,8 @@ let none: t = {
   // `UnsupportedChannel` because a caller that got this far is looking at a
   // deployment gap, not at a fact about the recipient, and abandoning the message
   // would record the second.
-  messaging: {
-    channels: [],
-    send: async (~recipient as _, ~message as _) => Error(
-      Unavailable("no messaging provider is configured for this platform"),
-    ),
-  },
+  messaging: Messaging.makeProvider(~emailAndSms=[], ~pushServices=[], ~send=async (
+    ~recipient as _,
+    ~message as _,
+  ) => Error(Unavailable("no messaging provider is configured for this platform"))),
 }

package/src/semantic/Capabilities.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Messaging$Reventless from "./Messaging.res.mjs";
 
 async function none_geocode(param) {
   return {
@@ -11,16 +12,13 @@ async function none_geocode(param) {
   };
 }
 
-let none_messaging = {
-  channels: [],
-  send: async (param, param$1) => ({
-    TAG: "Error",
-    _0: {
-      TAG: "Unavailable",
-      _0: "no messaging provider is configured for this platform"
-    }
-  })
-};
+let none_messaging = Messaging$Reventless.makeProvider([], [], async (param, param$1) => ({
+  TAG: "Error",
+  _0: {
+    TAG: "Unavailable",
+    _0: "no messaging provider is configured for this platform"
+  }
+}));
 
 let none = {
   geocode: none_geocode,
@@ -30,4 +28,4 @@ let none = {
 export {
   none,
 }
-/* No side effect */
+/* none Not a pure module */

package/src/semantic/CapabilityNeed.res

@@ -18,12 +18,12 @@ rather than a string a README repeats.
 */
 type t =
   | Geocoding
-  | /** Sending a message to a person, reached through `Capabilities.messaging`.
+  /** Sending a message to a person, reached through `Capabilities.messaging`.
         One need however many channels the platform provisions — which channels
         those are is a runtime answer the provider publishes, not a second
         declaration, because a plugin that named `Sms` would fail a deploy it
         could have run on email. */
-  Messaging
+  | Messaging
 
 /** The spelling carried in `pluginStructure` and in `capabilities.json`.
     Persisted structures hold strings, not enum members, so a plugin built
@@ -62,7 +62,7 @@ unprovisioned capability it never named degrades exactly as it always has, which
 is the modelled outcome for a deployment that simply does not have one.
 */
 let unmet = (~declared: array<(string, string)>, ~provisioned: array<t>): array<unmet> =>
-  declared->Array.filterMap((((capability, component))) =>
+  declared->Array.filterMap(((capability, component)) =>
     switch fromString(capability) {
     | Some(need) if !(provisioned->Array.includes(need)) => Some({need, component})
     | _ => None
@@ -77,5 +77,4 @@ let unmetMessage = (unmet: array<unmet>): string =>
     ->Array.map(u => `${toString(u.need)} (${u.component})`)
     ->Array.join(", ")}.\n` ++
   `  Provision them in the platform stack and redeploy the platform first.\n` ++
-  `  Without it every call answers Unavailable, the slice exhausts its retries, and a ` ++
-  `permanent verdict is recorded against data that is fine — no error anywhere.`
+  `  Without it every call answers Unavailable, the slice exhausts its retries, and a ` ++ `permanent verdict is recorded against data that is fine — no error anywhere.`

package/src/semantic/CaptionedImage.res

@@ -59,7 +59,6 @@ value depicts, not in how a reference to it is written. It would carry no
 }
 ```
 */
-
 /** The record itself. No `@schema`: the derived schema would have to name a
     store, and the store is the host field's — so `forField` is the only way to
     a schema, and a field the ppx did not reach fails to compile rather than

package/src/semantic/Color.res

@@ -26,7 +26,6 @@ full triplet, and the triplet with alpha. Case is not significant.
     })
 ```
 */
-
 /** The colour's representation. Transparent `string`; see `Email.t`. */
 type t = string