@reventlessdev/reventless-spec 3.0.0-alpha.149 → 3.0.0-alpha.150

package/CHANGELOG.md

@@ -3,6 +3,15 @@
 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.150 (2026-09-27)
+
+### Features
+
+* **core,spec:** an identity the plugin declares is information, not a dangling reference ([30d7917](https://github.com/ReventlessDev/reventless-core/commit/30d7917669ff062439f9c65e5274ab63a2e20de0))
+* **ppx,spec:** a view with no lifecycle field places a creating command by its scenarios ([acfc7fe](https://github.com/ReventlessDev/reventless-core/commit/acfc7feeb4d23d40cddaade7ae177fcd627b3d48))
+* **spec:** check-lifecycle says why it cannot build, and what works instead ([73bd527](https://github.com/ReventlessDev/reventless-core/commit/73bd527230b3cadc97c73e3325747e5c5ada4567))
+
+
 # 3.0.0-alpha.149 (2026-09-25)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.149",
+  "version": "3.0.0-alpha.150",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -26,7 +26,7 @@
     "sury": "11.0.0",
     "sury-ppx": "11.0.0",
     "yaml": "^2.8.3",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.15"
+    "@reventlessdev/rescript-node": "2.0.0-alpha.16"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/generator/Codegen.res

@@ -340,6 +340,7 @@ let renderPluginStructureCall = (
   ~extensionPoints: array<Pairing.extensionPointDef>,
   ~componentChapters: array<(string, string)>,
   ~hasLifecycleModel: bool,
+  ~identities: array<string>,
 ): option<array<string>> => {
   // The structure call carries the EP *mapping* files (one per Delegate
   // connection), not the wrapped ExtensionPoint module — Plugin_Structure reads
@@ -431,6 +432,13 @@ let renderPluginStructureCall = (
     if hasLifecycleModel {
       ls->Array.push("    ~lifecycleModel=LifecycleModel.model,")
     }
+
+    // The identities the plugin declares, so one no view lists yet is reported
+    // as information rather than a warning. Omitted when there are none.
+    if identities->Array.length > 0 {
+      let keys = identities->Array.map(m => m ++ ".key")
+      ls->Array.push("    ~identities=[" ++ keys->Array.join(", ") ++ "],")
+    }
     ls->Array.push("  )")
     Some(ls)
   }
@@ -610,6 +618,7 @@ let renderComposition = (
   ~resolved: Pairing.resolved,
   ~componentChapters: array<(string, string)>,
   ~hasLifecycleModel: bool,
+  ~identities: array<string>,
 ): string => {
   let lines: array<string> = []
 
@@ -754,6 +763,7 @@ let renderComposition = (
     ~extensionPoints=resolved.extensionPoints,
     ~componentChapters,
     ~hasLifecycleModel,
+    ~identities,
   )
   let hasPluginStructure = pluginStructureLines->Option.isSome
   switch pluginStructureLines {
@@ -856,6 +866,7 @@ let render = (
   ~resolved: Pairing.resolved,
   ~discovered: array<Discovery.discoveredFile>,
   ~hasLifecycleModel: bool=false,
+  ~identities: array<string>=[],
 ): string => {
   validateUniqueSpecStems(~discovered)
   validateSliceTargets(~resolved)
@@ -881,6 +892,7 @@ let render = (
     )
   switch config.variant {
   | Aws({compositionNamespace}) => renderAwsWrapper(~compositionNamespace)
-  | Composition => renderComposition(~config, ~resolved, ~componentChapters, ~hasLifecycleModel)
+  | Composition =>
+    renderComposition(~config, ~resolved, ~componentChapters, ~hasLifecycleModel, ~identities)
   }
 }

package/src/generator/Codegen.res.mjs

@@ -239,7 +239,7 @@ function renderTaskMakeParam(tasks) {
   return "      ~tasks=[" + entries.join(", ") + "],";
 }
 
-function renderPluginStructureCall(name, aggregates, readModels, stateViewSlices, stateViewSlicesStream, stateChangeSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, extensions, extensionPoints, componentChapters, hasLifecycleModel) {
+function renderPluginStructureCall(name, aggregates, readModels, stateViewSlices, stateViewSlicesStream, stateChangeSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, extensions, extensionPoints, componentChapters, hasLifecycleModel, identities) {
   let epMappingStems = extensionPoints.flatMap(param => param.mappings);
   let hasComponents = aggregates.length !== 0 || readModels.length !== 0 || stateViewSlices.length !== 0 || stateViewSlicesStream.length !== 0 || stateChangeSlices.length !== 0 || automationSlices.length !== 0 || outboundTranslationSlices.length !== 0 || inboundTranslationSlices.length !== 0 || extensions.length !== 0 || epMappingStems.length !== 0;
   if (!hasComponents) {
@@ -298,6 +298,10 @@ function renderPluginStructureCall(name, aggregates, readModels, stateViewSlices
   if (hasLifecycleModel) {
     ls.push("    ~lifecycleModel=LifecycleModel.model,");
   }
+  if (identities.length !== 0) {
+    let keys = identities.map(m => m + ".key");
+    ls.push("    ~identities=[" + keys.join(", ") + "],");
+  }
   ls.push("  )");
   return ls;
 }
@@ -397,7 +401,7 @@ function renderAwsWrapper(compositionNamespace) {
   ].join("\n");
 }
 
-function renderComposition(config, resolved, componentChapters, hasLifecycleModel) {
+function renderComposition(config, resolved, componentChapters, hasLifecycleModel, identities) {
   let lines = [];
   lines.push("// AUTO-GENERATED — do not edit. Run `npm run generate` to update.");
   lines.push("");
@@ -462,7 +466,7 @@ function renderComposition(config, resolved, componentChapters, hasLifecycleMode
     lines.push("  // Extensions");
     push(renderExtensions(resolved.extensions));
   }
-  let pluginStructureLines = renderPluginStructureCall(config.name, resolved.aggregates, resolved.readModels, resolved.stateViewSlices, resolved.stateViewSlicesStream, resolved.stateChangeSlices, resolved.automationSlices, resolved.outboundTranslationSlices, resolved.inboundTranslationSlices, resolved.extensions, resolved.extensionPoints, componentChapters, hasLifecycleModel);
+  let pluginStructureLines = renderPluginStructureCall(config.name, resolved.aggregates, resolved.readModels, resolved.stateViewSlices, resolved.stateViewSlicesStream, resolved.stateChangeSlices, resolved.automationSlices, resolved.outboundTranslationSlices, resolved.inboundTranslationSlices, resolved.extensions, resolved.extensionPoints, componentChapters, hasLifecycleModel, identities);
   let hasPluginStructure = Stdlib_Option.isSome(pluginStructureLines);
   if (pluginStructureLines !== undefined) {
     pluginStructureLines.forEach(l => {
@@ -520,8 +524,9 @@ function renderComposition(config, resolved, componentChapters, hasLifecycleMode
   return lines.join("\n");
 }
 
-function render(config, resolved, discovered, hasLifecycleModelOpt) {
+function render(config, resolved, discovered, hasLifecycleModelOpt, identitiesOpt) {
   let hasLifecycleModel = hasLifecycleModelOpt !== undefined ? hasLifecycleModelOpt : false;
+  let identities = identitiesOpt !== undefined ? identitiesOpt : [];
   validateUniqueSpecStems(discovered);
   validateSliceTargets(resolved);
   let componentStems = [
@@ -537,7 +542,7 @@ function render(config, resolved, discovered, hasLifecycleModelOpt) {
   let componentChapters = Discovery$Reventless.chaptersByStem(discovered).filter(param => componentStems.includes(param[0]));
   let match = config.variant;
   if (typeof match !== "object") {
-    return renderComposition(config, resolved, componentChapters, hasLifecycleModel);
+    return renderComposition(config, resolved, componentChapters, hasLifecycleModel, identities);
   } else {
     return renderAwsWrapper(match.compositionNamespace);
   }

package/src/generator/Discovery.res

@@ -245,3 +245,34 @@ let scan = (~srcDir: string, ~exclude: array<string>): array<discoveredFile> =>
   walkDir(~dir=srcDir, ~relDir="", ~parentComponentType=None, ~epGroup=None, ~exclude, ~acc)
   acc
 }
+
+/** The identity modules the plugin declares in its own `src/`: a `<Name>Id.res`
+    whose source calls `Id.Make(`. Named by module, so the generated call reads
+    each key off the compiled module (`CategoryId.key`) rather than parsing it
+    out of a string. Sorted, so the generated file is stable. */
+let scanIdentities = (~srcDir: string, ~exclude: array<string>): array<string> => {
+  let found = []
+  let rec walk = (~dir, ~relDir) =>
+    Generator_Node.readDir(dir)->Array.forEach(entry => {
+      let name = entry->NodeFs.direntName
+      let relPath = relDir === "" ? name : relDir ++ "/" ++ name
+      let path = NodePath.join([dir, name])
+      if isExcluded(relPath, exclude) {
+        ()
+      } else if entry->NodeFs.isDirectory {
+        if !isAlwaysExcludedDir(name) {
+          walk(~dir=path, ~relDir=relPath)
+        }
+      } else {
+        switch stemOf(name) {
+        | Some(stem)
+          if stem->String.endsWith("Id") &&
+            path->NodeFs.readFileSync->String.includes("Id.Make(") =>
+          found->Array.push(stem)
+        | _ => ()
+        }
+      }
+    })
+  walk(~dir=srcDir, ~relDir="")
+  found->Array.toSorted(String.compare)
+}

package/src/generator/Discovery.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Nodefs from "node:fs";
 import * as Nodepath from "node:path";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as ComponentKind$Reventless from "../components/ComponentKind.res.mjs";
 import * as Generator_Node$Reventless from "./Generator_Node.res.mjs";
 
@@ -180,6 +182,34 @@ function scan(srcDir, exclude) {
   return acc;
 }
 
+function scanIdentities(srcDir, exclude) {
+  let found = [];
+  let walk = (dir, relDir) => {
+    Generator_Node$Reventless.readDir(dir).forEach(entry => {
+      let name = entry.name;
+      let relPath = relDir === "" ? name : relDir + "/" + name;
+      let path = Nodepath.join(dir, name);
+      if (isExcluded(relPath, exclude)) {
+        return;
+      }
+      if (entry.isDirectory()) {
+        if (!isAlwaysExcludedDir(name)) {
+          return walk(path, relPath);
+        } else {
+          return;
+        }
+      }
+      let stem = stemOf(name);
+      if (stem !== undefined && stem.endsWith("Id") && Nodefs.readFileSync(path, "utf8").includes("Id.Make(")) {
+        found.push(stem);
+        return;
+      }
+    });
+  };
+  walk(srcDir, "");
+  return found.toSorted(Primitive_string.compare);
+}
+
 let folderToComponentType = ComponentKind$Reventless.folderToKind;
 
 export {
@@ -194,5 +224,6 @@ export {
   collectFiles,
   walkDir,
   scan,
+  scanIdentities,
 }
-/* node:path Not a pure module */
+/* node:fs Not a pure module */

package/src/generator/PluginGenerator.res

@@ -37,7 +37,8 @@ let main = () =>
     // Sits at the src root rather than in a kind folder, so `Discovery` never
     // sees it and it is not a component. Its presence is the whole question.
     let hasLifecycleModel = NodePath.join([srcDir, "LifecycleModel.res"])->NodeFs.existsSync
-    let source = Codegen.render(~config, ~resolved, ~discovered, ~hasLifecycleModel)
+    let identities = Discovery.scanIdentities(~srcDir, ~exclude=config.exclude)
+    let source = Codegen.render(~config, ~resolved, ~discovered, ~hasLifecycleModel, ~identities)
 
     let outputDir = switch variant {
     | Config.Composition => srcDir

package/src/generator/PluginGenerator.res.mjs

@@ -81,7 +81,8 @@ function main() {
     let discovered = Discovery$Reventless.scan(srcDir, config_exclude);
     let resolved = Pairing$Reventless.resolve(discovered, srcDir);
     let hasLifecycleModel = Nodefs.existsSync(Nodepath.join(srcDir, "LifecycleModel.res"));
-    let source = Codegen$Reventless.render(config, resolved, discovered, hasLifecycleModel);
+    let identities = Discovery$Reventless.scanIdentities(srcDir, config_exclude);
+    let source = Codegen$Reventless.render(config, resolved, discovered, hasLifecycleModel, identities);
     let outputDir;
     outputDir = typeof variant !== "object" ? srcDir : Nodepath.join(process.cwd(), "src");
     let pluginPath = Nodepath.join(outputDir, "Plugin.res");

package/src/lifecycle/CheckLifecycleModel.res

@@ -185,7 +185,9 @@ let sortedUnique = (xs: array<string>): array<string> => {
     slice's setup routinely names other entities, and folding those into this
     row's state is how a scenario about a second order gets read as a scenario
     about the first one's. */
-type element = {name: string, values: array<(string, JSON.t)>}
+/** `opaque` is a step the sidecar could not read (`givenEvents([added])`): it is
+    there, but its name is source text, not an element. */
+type element = {name: string, values: array<(string, JSON.t)>, opaque?: bool}
 
 /** One scenario, reduced to what the harvest reads. `then` carries at most one
     step in every DSL here, so it is a kind and a payload rather than a list. */
@@ -220,12 +222,29 @@ let valuesOf = (step: dict<JSON.t>): array<(string, JSON.t)> =>
 
 let elementsOf = (steps: array<dict<JSON.t>>): array<element> =>
   steps->Array.filterMap(s =>
-    s->getStr("element")->Option.map(name => {name: lastSegment(name), values: valuesOf(s)})
+    s
+    ->getStr("element")
+    ->Option.map(name => {
+      name: lastSegment(name),
+      values: valuesOf(s),
+      opaque: s->getStr("kind") == Some("opaque"),
+    })
   )
 
+let isOpaque = (e: element) => e.opaque == Some(true)
+
 let kindOf = (steps: array<dict<JSON.t>>): string =>
   steps->Array.get(0)->Option.flatMap(s => s->getStr("kind"))->Option.getOr("")
 
+/** A `then` the sidecar could not read still says which kind it asserts:
+    `thenEvent(added)` emitted, though nothing says what. A `when` keeps
+    `opaque`, so no command is named after a variable. */
+let thenKindOf = (steps: array<dict<JSON.t>>): string =>
+  switch steps->Array.get(0) {
+  | Some(s) if s->getStr("kind") == Some("opaque") => s->getStr("of")->Option.getOr("")
+  | _ => kindOf(steps)
+  }
+
 let scenarioOf = (j: JSON.t): option<scenario> =>
   j
   ->asObj
@@ -238,7 +257,7 @@ let scenarioOf = (j: JSON.t): option<scenario> =>
       given: elementsOf(given),
       whenKind: kindOf(when_),
       whenElements: elementsOf(when_),
-      thenKind: kindOf(then_),
+      thenKind: thenKindOf(then_),
       thenElements: elementsOf(then_),
       thenValues: then_->Array.get(0)->Option.map(valuesOf)->Option.getOr([]),
     }
@@ -323,34 +342,68 @@ let checkSidecars = (~pluginDirs: array<string>): result<unit, string> =>
     right for the ordinary invocations — this repository's gate, and `--root .`
     from an app — and wrong for a `--root` pointing somewhere else, which is why
     the caller checks for a corpus afterwards either way rather than trusting
-    that a build it did not target wrote one. */
-let emitSidecars = (~pluginDirs: array<string>): result<unit, string> => {
-  let now = Date.now() /. 1000.0
-  gwtSources(~pluginDirs)->Array.forEach(f => NodeFs.utimesSync(f, now, now))
-
-  let env =
-    NodeProcess.env
-    ->Dict.toArray
-    ->Array.concat([("REVENTLESS_EMIT_SIDECAR", "1")])
-    ->Dict.fromArray
-
-  try {
-    let _ = NodeChildProcess.execFileSync(
+    that a build it did not target wrote one.
+
+    An app laid out as one package per plugin has no root `build`; there the
+    harvest stops before running anything and names the way that does work. */
+let reuseAdvice = "Build the packages with REVENTLESS_EMIT_SIDECAR=1 set, then run check-lifecycle --reuse-sidecars."
+
+let hasBuildScript = (~dir: string): bool => {
+  let path = NodePath.join([dir, "package.json"])
+  NodeFs.existsSync(path) &&
+  switch path
+  ->NodeFs.readFileSync
+  ->JSON.parseOrThrow
+  ->asObj
+  ->Option.flatMap(d => d->Dict.get("scripts"))
+  ->Option.flatMap(asObj) {
+  | Some(scripts) => scripts->getStr("build")->Option.isSome
+  | None => false
+  | exception _ => false
+  }
+}
+
+let lastLines = (output: string, ~count: int): string => {
+  let lines = output->String.trimEnd->String.split("\n")
+  lines->Array.slice(~start=Math.Int.max(0, Array.length(lines) - count))->Array.join("\n")
+}
+
+let emitSidecars = (~pluginDirs: array<string>, ~dir=repoRoot): result<unit, string> =>
+  if !hasBuildScript(~dir) {
+    Error(
+      `${dir} has no "build" script, so there is no build to run with REVENTLESS_EMIT_SIDECAR=1. ${reuseAdvice}`,
+    )
+  } else {
+    let now = Date.now() /. 1000.0
+    gwtSources(~pluginDirs)->Array.forEach(f => NodeFs.utimesSync(f, now, now))
+
+    let env =
+      NodeProcess.env
+      ->Dict.toArray
+      ->Array.concat([("REVENTLESS_EMIT_SIDECAR", "1")])
+      ->Dict.fromArray
+
+    let result = NodeChildProcess.spawnSync(
       "pnpm",
       ["run", "build"],
-      {cwd: repoRoot, env, encoding: "utf8", maxBuffer: 256 * 1024 * 1024},
-    )
-    Ok()
-  } catch {
-  | exn =>
-    Error(
-      exn
-      ->JsExn.fromException
-      ->Option.flatMap(JsExn.message)
-      ->Option.getOr("the build that emits the scenario sidecars failed"),
+      {cwd: dir, env, encoding: "utf8", maxBuffer: 256 * 1024 * 1024},
     )
+    switch (result.error->Nullable.toOption, result.status->Nullable.toOption) {
+    | (None, Some(0)) => Ok()
+    | (Some(err), _) =>
+      Error(
+        `pnpm could not be started to build ${dir}: ${err
+          ->JsExn.message
+          ->Option.getOr("no reason given")}. ${reuseAdvice}`,
+      )
+    | (None, _) =>
+      let output =
+        [result.stdout, result.stderr]
+        ->Array.filterMap(Nullable.toOption)
+        ->Array.join("\n")
+      Error(`The build at ${dir} failed. ${reuseAdvice}\n\n${output->lastLines(~count=20)}`)
+    }
   }
-}
 
 // ── The declared side ───────────────────────────────────────────────────────
 
@@ -543,6 +596,9 @@ type observation = {
   from: string,
   outcome: outcome,
   to: string,
+  /** The setup events about this command's row. Zero is "no row before", which
+      a view with no lifecycle field can still say, having no states to fold. */
+  rowHistory: int,
 }
 
 type derivedCommand = {
@@ -571,8 +627,8 @@ type derivedCommand = {
       carry the model, and that is worth seeing before spending the change. */
   targets: array<string>,
   /** `""` where the corpus cannot say. Without a lifecycle map every history
-      folds to "no row", which would make every command in the plugin look like
-      it creates one — a confident wrong answer where the honest one is silence. */
+      folds to "no row", so the fold cannot answer; an empty history still can,
+      and a command that only ever succeeds on one is `Collection`. */
   level: string,
   scenarios: int,
 }
@@ -637,13 +693,18 @@ let observe = (
       let history = s.given->Array.filter(e => e->sameRow(~idField, ~idValue))
       let from = fold(history)
       let outcome = outcomeOf(s)
-      Some({
-        title: s.title,
-        command: command.name,
-        from,
-        outcome,
-        to: outcome == Emitted ? fold(Array.concat(history, s.thenElements)) : from,
-      })
+      // A history holding a step nobody could read has a from-state nobody
+      // knows; reading it as "no row" makes an update look like a create.
+      history->Array.some(isOpaque)
+        ? None
+        : Some({
+            title: s.title,
+            command: command.name,
+            from,
+            outcome,
+            to: outcome == Emitted ? fold(Array.concat(history, s.thenElements)) : from,
+            rowHistory: Array.length(history),
+          })
     | _ => None
     }
   )
@@ -676,9 +737,12 @@ let deriveCommands = (
       // A command whose every successful scenario starts from no row is creating
       // one. This is what the published metadata guesses at today from the
       // command's name stem, which misreads `Enroll`, `Provision`, `Onboard`.
+      // Without labels only an empty history says "no row"; a non-empty one
+      // cannot tell a live row from events that fold to none, so it says nothing.
       level: switch (labelled, Array.length(effective)) {
-      | (false, _) | (_, 0) => ""
+      | (_, 0) => ""
       | (true, _) => effective->Array.every(o => o.from == noRow) ? "Collection" : "Instance"
+      | (false, _) => effective->Array.every(o => o.rowHistory == 0) ? "Collection" : ""
       },
       scenarios: Array.length(mine),
     }
@@ -715,6 +779,7 @@ type commandOutcomes = {
 
 let shownOutcomeOf = (s: scenario): option<(string, array<string>)> =>
   switch s.thenKind {
+  | "event" | "error" if s.thenElements->Array.some(isOpaque) => None
   | "event" | "error" => Some((s.thenKind, s.thenElements->Array.map(e => e.name)))
   | "noEvent" => Some(("noEvent", []))
   // The empty `then` above, and a `then` that is not about this command's

package/src/lifecycle/CheckLifecycleModel.res.mjs

@@ -9,10 +9,10 @@ import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as CliArgs$Reventless from "../CliArgs.res.mjs";
 import * as Nodechild_process from "node:child_process";
-import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as ComponentKind$Reventless from "../components/ComponentKind.res.mjs";
 import * as LoadPluginStructureMjs from "./loadPluginStructure.mjs";
 
@@ -123,14 +123,28 @@ function valuesOf(step) {
 function elementsOf(steps) {
   return Stdlib_Array.filterMap(steps, s => Stdlib_Option.map(getStr(s, "element"), name => ({
     name: lastSegment(name),
-    values: valuesOf(s)
+    values: valuesOf(s),
+    opaque: Primitive_object.equal(getStr(s, "kind"), "opaque")
   })));
 }
 
+function isOpaque(e) {
+  return Primitive_object.equal(e.opaque, true);
+}
+
 function kindOf(steps) {
   return Stdlib_Option.getOr(Stdlib_Option.flatMap(steps[0], s => getStr(s, "kind")), "");
 }
 
+function thenKindOf(steps) {
+  let s = steps[0];
+  if (s !== undefined && Primitive_object.equal(getStr(s, "kind"), "opaque")) {
+    return Stdlib_Option.getOr(getStr(s, "of"), "");
+  } else {
+    return kindOf(steps);
+  }
+}
+
 function scenarioOf(j) {
   return Stdlib_Option.map(Stdlib_JSON.Decode.object(j), d => {
     let given = getObjs(d, "given");
@@ -141,7 +155,7 @@ function scenarioOf(j) {
       given: elementsOf(given),
       whenKind: kindOf(when_),
       whenElements: elementsOf(when_),
-      thenKind: kindOf(then_),
+      thenKind: thenKindOf(then_),
       thenElements: elementsOf(then_),
       thenValues: Stdlib_Option.getOr(Stdlib_Option.map(then_[0], valuesOf), [])
     };
@@ -218,7 +232,39 @@ function checkSidecars(pluginDirs) {
   }
 }
 
-function emitSidecars(pluginDirs) {
+let reuseAdvice = "Build the packages with REVENTLESS_EMIT_SIDECAR=1 set, then run check-lifecycle --reuse-sidecars.";
+
+function hasBuildScript(dir) {
+  let path = Nodepath.join(dir, "package.json");
+  if (!Nodefs.existsSync(path)) {
+    return false;
+  }
+  let scripts;
+  try {
+    scripts = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(Nodefs.readFileSync(path, "utf8"))), d => d["scripts"]), asObj);
+  } catch (exn) {
+    return false;
+  }
+  if (scripts !== undefined) {
+    return Stdlib_Option.isSome(getStr(scripts, "build"));
+  } else {
+    return false;
+  }
+}
+
+function lastLines(output, count) {
+  let lines = output.trimEnd().split("\n");
+  return lines.slice(Math.max(0, lines.length - count | 0)).join("\n");
+}
+
+function emitSidecars(pluginDirs, dirOpt) {
+  let dir = dirOpt !== undefined ? dirOpt : repoRoot;
+  if (!hasBuildScript(dir)) {
+    return {
+      TAG: "Error",
+      _0: dir + ` has no "build" script, so there is no build to run with REVENTLESS_EMIT_SIDECAR=1. ` + reuseAdvice
+    };
+  }
   let now = Date.now() / 1000.0;
   gwtSources(pluginDirs).forEach(f => {
     Nodefs.utimesSync(f, now, now);
@@ -227,27 +273,43 @@ function emitSidecars(pluginDirs) {
       "REVENTLESS_EMIT_SIDECAR",
       "1"
     ]]));
-  try {
-    Nodechild_process.execFileSync("pnpm", [
-      "run",
-      "build"
-    ], {
-      cwd: repoRoot,
-      encoding: "utf8",
-      env: env,
-      maxBuffer: 268435456
-    });
+  let result = Nodechild_process.spawnSync("pnpm", [
+    "run",
+    "build"
+  ], {
+    cwd: dir,
+    encoding: "utf8",
+    env: env,
+    maxBuffer: 268435456
+  });
+  let match = result.error;
+  let match$1 = result.status;
+  if (!(match == null)) {
     return {
-      TAG: "Ok",
-      _0: undefined
+      TAG: "Error",
+      _0: `pnpm could not be started to build ` + dir + `: ` + Stdlib_Option.getOr(Stdlib_JsExn.message(match), "no reason given") + `. ` + reuseAdvice
     };
-  } catch (raw_exn) {
-    let exn = Primitive_exceptions.internalToException(raw_exn);
+  }
+  if (!(match$1 == null) && match$1 === 0) {
     return {
-      TAG: "Error",
-      _0: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "the build that emits the scenario sidecars failed")
+      TAG: "Ok",
+      _0: undefined
     };
   }
+  let output = Stdlib_Array.filterMap([
+    result.stdout,
+    result.stderr
+  ], prim => {
+    if (prim == null) {
+      return;
+    } else {
+      return Primitive_option.some(prim);
+    }
+  }).join("\n");
+  return {
+    TAG: "Error",
+    _0: `The build at ` + dir + ` failed. ` + reuseAdvice + `\n\n` + lastLines(output, 20)
+  };
 }
 
 function levelOf(d) {
@@ -449,13 +511,18 @@ function observe(scenarios, map, idFieldFor) {
     let history = s.given.filter(e => sameRow(e, idField, idValue));
     let from = fold(history);
     let outcome = outcomeOf(s);
-    return {
-      title: s.title,
-      command: command.name,
-      from: from,
-      outcome: outcome,
-      to: outcome === "Emitted" ? fold(history.concat(s.thenElements)) : from
-    };
+    if (history.some(isOpaque)) {
+      return;
+    } else {
+      return {
+        title: s.title,
+        command: command.name,
+        from: from,
+        outcome: outcome,
+        to: outcome === "Emitted" ? fold(history.concat(s.thenElements)) : from,
+        rowHistory: history.length
+      };
+    }
   });
 }
 
@@ -494,8 +561,12 @@ function deriveCommands(component, observations, labelled) {
           return o.to;
         }
       })),
-      level: labelled && match !== 0 ? (
-          effective.every(o => o.from === noRow) ? "Collection" : "Instance"
+      level: match !== 0 ? (
+          labelled ? (
+              effective.every(o => o.from === noRow) ? "Collection" : "Instance"
+            ) : (
+              effective.every(o => o.rowHistory === 0) ? "Collection" : ""
+            )
         ) : "",
       scenarios: mine.length
     };
@@ -516,10 +587,14 @@ function shownOutcomeOf(s) {
     default:
       return;
   }
-  return [
-    s.thenKind,
-    s.thenElements.map(e => e.name)
-  ];
+  if (s.thenElements.some(isOpaque)) {
+    return;
+  } else {
+    return [
+      s.thenKind,
+      s.thenElements.map(e => e.name)
+    ];
+  }
 }
 
 function byPluginComponentCommand(xs) {
@@ -1149,7 +1224,7 @@ function main() {
       console.error(`no plugins found under ` + roots.map(r => r.dir).join(", ") + ` — a plugin is a directory with both src/Plugin.res and tests/`);
       process.exit(1);
     }
-    let msg = param.reuseSidecars ? checkSidecars(allPluginDirs) : emitSidecars(allPluginDirs);
+    let msg = param.reuseSidecars ? checkSidecars(allPluginDirs) : emitSidecars(allPluginDirs, undefined);
     if (msg.TAG !== "Ok") {
       console.error(msg._0);
       process.exit(1);
@@ -1256,7 +1331,9 @@ export {
   sortedUnique,
   valuesOf,
   elementsOf,
+  isOpaque,
   kindOf,
+  thenKindOf,
   scenarioOf,
   readCorpus,
   filesUnder,
@@ -1264,6 +1341,9 @@ export {
   sidecarOf,
   hasCorpus,
   checkSidecars,
+  reuseAdvice,
+  hasBuildScript,
+  lastLines,
   emitSidecars,
   levelOf,
   declaredCommandOf,