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

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}`)
     }

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 =>
@@ -548,6 +550,18 @@ type derivedCommand = {
       accepted and silent. Kept separately because it is what turns a declared
       state the corpus disagrees with into a contradiction rather than a gap. */
   inertStates: array<string>,
+  /** The strict subset of [inertStates] where the command was *refused* — an
+      error, not an accepted no-op.
+
+      Separate because the two refute different claims. A named from-set says the
+      command **takes effect** from those states, so anything inert there
+      contradicts it. `Unrestricted` says only that the command is **never
+      refused**, which an accepted `Ok([])` agrees with rather than contradicts —
+      returning no events for a command that would change nothing is this
+      codebase's idempotency convention, not evidence the state was illegal.
+      Reading one field for both questions made every idempotent
+      legal-in-every-state command look like a contradiction. */
+  refusedStates: array<string>,
   /** Where the edges land. A relation, not a single value: a command observed
       landing in two states is the signal that the published `targetState` cannot
       carry the model, and that is worth seeing before spending the change. */
@@ -647,9 +661,10 @@ 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)),
+      ),
+      refusedStates: sortedUnique(
+        mine->Array.filterMap(o => o.outcome == Refused && o.from != noRow ? Some(o.from) : None),
       ),
       targets: sortedUnique(
         effective->Array.filterMap(o => o.to == o.from || o.to == noRow ? None : Some(o.to)),
@@ -757,15 +772,24 @@ let compare = (
     // effect somewhere agrees with that rather than narrowing it — the corpus
     // covers the states somebody wrote a scenario for, and silence about the
     // rest is not refusal. What DOES refute the claim is a state the command was
-    // exercised in and did nothing: that is the switch and the behaviour
+    // exercised in and **refused**: that is the switch and the behaviour
     // disagreeing about the same row.
+    //
+    // 🚨 **Refused, not merely inert.** `Unrestricted` claims the command is
+    // never refused — it does not claim the command always emits. A state where a
+    // scenario shows it accepted and silent AGREES with that: returning `Ok([])`
+    // for a command that would change nothing is this codebase's idempotency
+    // convention, required because commands arrive at least once. Reading
+    // `inertStates` here marked every such command contradicted, which is the
+    // opposite of what the corpus showed — a verdict redelivered, or landing
+    // after deactivation, is precisely the case the switch declared legal so that
+    // the reporting slice would not retry forever.
     | None if cmd.allowedStatesSource == Some("unrestricted") =>
-      derived.inertStates->Array.forEach(state =>
+      derived.refusedStates->Array.forEach(state =>
         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`,
         )
       )
     | None =>
@@ -773,8 +797,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 +810,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 +830,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 +855,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 +957,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 +1071,14 @@ let runPlugin = async (
                     states,
                     message: `${plugin}/${writable.name}.${cmd.command}: ${message}`,
                   })
-                  ->ignore
-                )
-              }
-            )
-          }
+                  ->ignore,
+              )
+            }
+          )
         }
-      )
-      Ok(derived)
+      }
+    )
+    Ok(derived)
   }
 
 // ── The golden ──────────────────────────────────────────────────────────────
@@ -1160,6 +1188,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 +1214,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 +1244,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 +1280,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 +1303,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 +1358,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 +1388,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.`,
     )
   }
 
@@ -1350,4 +1403,9 @@ let main = async () => {
   }
 }
 
-let _ = main()
+// 🚨 **No top-level call.** `../../run-check-lifecycle.mjs` invokes [main]; this
+// module only defines it. While the call was here, importing the module *ran the
+// whole check* and then called `NodeProcess.exit`, so nothing in this file could
+// be reached from a test — including [deriveCommands] and [compare], which are
+// pure and are where every verdict is actually decided. That is the same trap
+// `ProvisionIdentity` records having shipped a never-matching guard through.

package/src/lifecycle/CheckLifecycleModel.res.mjs

@@ -469,6 +469,11 @@ function deriveCommands(component, observations, labelled) {
           return o.from;
         }
       })),
+      refusedStates: sortedUnique(Stdlib_Array.filterMap(mine, o => {
+        if (o.outcome === "Refused" && o.from !== noRow) {
+          return o.from;
+        }
+      })),
       targets: sortedUnique(Stdlib_Array.filterMap(effective, o => {
         if (o.to === o.from || o.to === noRow) {
           return;
@@ -531,7 +536,7 @@ function compare(plugin, writable, derived, findings) {
       add("unverified", states, `the switch declares ` + states.length.toString() + ` state(s) and no scenario shows the command taking effect anywhere`);
     }
   } else if (Primitive_object.equal(declared.allowedStatesSource, "unrestricted")) {
-    derived.inertStates.forEach(state => add("contradicted", [state], `the switch declares it legal in every state, and a scenario from "` + state + `" shows it refused or producing nothing`));
+    derived.refusedStates.forEach(state => add("contradicted", [state], `the switch declares it legal in every state, and a scenario from "` + state + `" shows it refused`));
   } else if (derived.allowedStates.length !== 0) {
     add("undeclared", derived.allowedStates, `scenarios show it taking effect from ` + derived.allowedStates.join(", ") + `, and it declares no edge`);
   }
@@ -910,6 +915,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 +951,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 +968,7 @@ function modelSource(plugin, derived) {
       "]",
       ""
     ]
-  ].flat().join("\n");
+  ].flat().join("\n"));
 }
 
 function modelPath(pluginDir) {
@@ -1072,8 +1091,6 @@ async function main() {
   }
 }
 
-main();
-
 export {
   repoRoot,
   examplesDir,
@@ -1126,6 +1143,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)