@reventlessdev/reventless-spec 3.0.0-alpha.130 → 3.0.0-alpha.131

package/src/lifecycle/CheckLifecycleModel.res.mjs

@@ -0,0 +1,1107 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+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 Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Nodechild_process from "node:child_process";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as LoadPluginStructureMjs from "./loadPluginStructure.mjs";
+
+process.env["REVENTLESS_DECLARED_TRANSITIONS_ONLY"] = "1";
+
+let repoRoot = process.cwd();
+
+let examplesDir = Nodepath.join(repoRoot, "examples");
+
+let update = process.argv.includes("--update");
+
+function flagValues(flag) {
+  let argv = process.argv;
+  let out = [];
+  for (let i = 0, i_finish = argv.length; i < i_finish; ++i) {
+    if (Primitive_object.equal(argv[i], flag)) {
+      let value = argv[i + 1 | 0];
+      if (value !== undefined && !value.startsWith("--")) {
+        out.push(value);
+      }
+    }
+  }
+  return out;
+}
+
+let reuseSidecars = process.argv.includes("--reuse-sidecars");
+
+let json = process.argv.includes("--json");
+
+let noRow = "(none)";
+
+function asObj(j) {
+  return Stdlib_JSON.Decode.object(j);
+}
+
+function getStr(d, k) {
+  return Stdlib_Option.flatMap(d[k], Stdlib_JSON.Decode.string);
+}
+
+function getArr(d, k) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(d[k], Stdlib_JSON.Decode.array), []);
+}
+
+function getObjs(d, k) {
+  return Stdlib_Array.filterMap(getArr(d, k), asObj);
+}
+
+function getStrs(d, k) {
+  return Stdlib_Array.filterMap(getArr(d, k), Stdlib_JSON.Decode.string);
+}
+
+function getStrsOpt(d, k) {
+  let v = d[k];
+  if (v !== undefined) {
+    return Stdlib_Option.map(Stdlib_JSON.Decode.array(v), a => Stdlib_Array.filterMap(a, Stdlib_JSON.Decode.string));
+  }
+}
+
+function last(xs) {
+  return xs[xs.length - 1 | 0];
+}
+
+function lastSegment(name) {
+  let parts = name.split(".");
+  return Stdlib_Option.getOr(last(parts), name);
+}
+
+function sortedUnique(xs) {
+  let out = [];
+  xs.forEach(x => {
+    if (!out.includes(x)) {
+      out.push(x);
+      return;
+    }
+  });
+  return out.toSorted(Primitive_string.compare);
+}
+
+function valuesOf(step) {
+  return Stdlib_Array.filterMap(getArr(step, "values"), v => {
+    let match = Stdlib_JSON.Decode.array(v);
+    if (match === undefined) {
+      return;
+    }
+    if (match.length !== 2) {
+      return;
+    }
+    let name = match[0];
+    let value = match[1];
+    return Stdlib_Option.map(Stdlib_JSON.Decode.string(name), n => [
+      n,
+      value
+    ]);
+  });
+}
+
+function elementsOf(steps) {
+  return Stdlib_Array.filterMap(steps, s => Stdlib_Option.map(getStr(s, "element"), name => ({
+    name: lastSegment(name),
+    values: valuesOf(s)
+  })));
+}
+
+function kindOf(steps) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(steps[0], s => getStr(s, "kind")), "");
+}
+
+function scenarioOf(j) {
+  return Stdlib_Option.map(Stdlib_JSON.Decode.object(j), d => {
+    let given = getObjs(d, "given");
+    let when_ = getObjs(d, "when");
+    let then_ = getObjs(d, "then");
+    return {
+      title: Stdlib_Option.getOr(getStr(d, "title"), ""),
+      given: elementsOf(given),
+      whenKind: kindOf(when_),
+      whenElements: elementsOf(when_),
+      thenKind: kindOf(then_),
+      thenElements: elementsOf(then_),
+      thenValues: Stdlib_Option.getOr(Stdlib_Option.map(then_[0], valuesOf), [])
+    };
+  });
+}
+
+function readCorpus(path) {
+  let d;
+  try {
+    d = Stdlib_JSON.Decode.object(JSON.parse(Nodefs.readFileSync(path, "utf8")));
+  } catch (exn) {
+    return;
+  }
+  if (d === undefined) {
+    return;
+  }
+  let stem = Stdlib_Option.getOr(getStr(d, "stem"), "");
+  return {
+    component: stem.replace("_GWT", ""),
+    path: path,
+    scenarios: Stdlib_Array.filterMap(getArr(d, "scenarios"), scenarioOf)
+  };
+}
+
+function filesUnder(dir, suffix) {
+  let entries;
+  try {
+    entries = Nodefs.readdirSync(dir, {
+      withFileTypes: true
+    });
+  } catch (exn) {
+    return [];
+  }
+  return entries.flatMap(entry => {
+    let name = entry.name;
+    let full = Nodepath.join(dir, name);
+    if (entry.isDirectory()) {
+      if (name === "node_modules" || name === "lib" || name.startsWith(".")) {
+        return [];
+      } else {
+        return filesUnder(full, suffix);
+      }
+    } else if (name.endsWith(suffix)) {
+      return [full];
+    } else {
+      return [];
+    }
+  });
+}
+
+function gwtSources(pluginDirs) {
+  return pluginDirs.flatMap(dir => filesUnder(Nodepath.join(dir, "tests"), "_GWT.res"));
+}
+
+function sidecarOf(gwt) {
+  return gwt.replace("_GWT.res", "_GWT.gwt.json");
+}
+
+function hasCorpus(pluginDirs) {
+  return gwtSources(pluginDirs).some(f => Nodefs.existsSync(f.replace("_GWT.res", "_GWT.gwt.json")));
+}
+
+function checkSidecars(pluginDirs) {
+  if (hasCorpus(pluginDirs)) {
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: "--reuse-sidecars was passed, but no scenario sidecar exists. Build with REVENTLESS_EMIT_SIDECAR=1 first, or drop the flag."
+    };
+  }
+}
+
+function emitSidecars(pluginDirs) {
+  let now = Date.now() / 1000.0;
+  gwtSources(pluginDirs).forEach(f => {
+    Nodefs.utimesSync(f, now, now);
+  });
+  let env = Object.fromEntries(Object.entries(process.env).concat([[
+      "REVENTLESS_EMIT_SIDECAR",
+      "1"
+    ]]));
+  try {
+    Nodechild_process.execFileSync("pnpm", [
+      "run",
+      "build"
+    ], {
+      cwd: repoRoot,
+      encoding: "utf8",
+      env: env,
+      maxBuffer: 268435456
+    });
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    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")
+    };
+  }
+}
+
+function levelOf(d) {
+  let match = d["level"];
+  if (match === undefined) {
+    return "";
+  }
+  if (match === null || Array.isArray(match)) {
+    return "";
+  }
+  switch (typeof match) {
+    case "string" :
+      return match;
+    case "object" :
+      return Stdlib_Option.getOr(getStr(match, "TAG"), "");
+    default:
+      return "";
+  }
+}
+
+function declaredCommandOf(d) {
+  return Stdlib_Option.map(getStr(d, "name"), command => ({
+    command: command,
+    level: levelOf(d),
+    aggregateIdField: getStr(d, "aggregateIdField"),
+    allowedStates: getStrsOpt(d, "allowedStates"),
+    targetState: getStr(d, "targetState"),
+    allowedStatesSource: getStr(d, "allowedStatesSource")
+  }));
+}
+
+function declaredOf(structure) {
+  return Stdlib_Option.map(Stdlib_JSON.Decode.object(structure), s => {
+    let writablesFrom = key => Stdlib_Array.filterMap(getObjs(s, key), w => Stdlib_Option.map(getStr(w, "name"), name => ({
+      name: name,
+      linkedViews: getStrs(w, "linkedViews"),
+      commands: Stdlib_Array.filterMap(getObjs(w, "commands"), declaredCommandOf)
+    })));
+    let viewsFrom = key => Stdlib_Array.filterMap(getObjs(s, key), v => Stdlib_Option.map(getStr(v, "name"), name => ({
+      name: name,
+      lifecycleField: getStr(v, "lifecycleField")
+    })));
+    return {
+      writables: writablesFrom("aggregates").concat(writablesFrom("stateChangeSlices")),
+      views: viewsFrom("readModels").concat(viewsFrom("stateViewSlices"))
+    };
+  });
+}
+
+function loadPluginStructure(prim) {
+  return LoadPluginStructureMjs.loadPluginStructure(prim);
+}
+
+async function readDeclared(pluginDir) {
+  let raw = await LoadPluginStructureMjs.loadPluginStructure(pluginDir);
+  let d = Stdlib_JSON.Decode.object(raw);
+  if (d === undefined) {
+    return {
+      TAG: "Error",
+      _0: "the structure loader returned something unreadable"
+    };
+  }
+  let match = d["ok"];
+  if (match === true) {
+    let declared = Stdlib_Option.flatMap(d["structure"], declaredOf);
+    if (declared !== undefined) {
+      return {
+        TAG: "Ok",
+        _0: declared
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "the plugin structure could not be read"
+      };
+    }
+  }
+  return {
+    TAG: "Error",
+    _0: Stdlib_Option.getOr(getStr(d, "error"), "the plugin structure could not be loaded")
+  };
+}
+
+function lifecycleValue(values, field) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(values.find(param => param[0] === field), param => Stdlib_JSON.Decode.object(param[1])), v => {
+    let match = getStr(v, "kind");
+    if (match === undefined) {
+      return;
+    }
+    switch (match) {
+      case "enum" :
+      case "string" :
+        return Stdlib_Option.map(getStr(v, "value"), lastSegment);
+      default:
+        return;
+    }
+  });
+}
+
+function lifecycleMapFor(scenarios, field, ambiguities, view) {
+  let map = {};
+  let fold = events => Stdlib_Array.reduce(events, noRow, (current, event) => {
+    let value = map[event.name];
+    if (value !== undefined) {
+      return value;
+    } else {
+      return current;
+    }
+  });
+  let changed = true;
+  let rounds = 0;
+  while (changed && rounds < 8) {
+    changed = false;
+    rounds = rounds + 1 | 0;
+    let before = Object.keys(map).length;
+    scenarios.forEach(s => {
+      if (s.whenKind !== "event" || s.thenKind !== "state") {
+        return;
+      }
+      let match = last(s.whenElements);
+      let match$1 = lifecycleValue(s.thenValues, field);
+      if (match !== undefined && match$1 !== undefined && (s.given.length === 0 || fold(s.given) !== match$1)) {
+        let event = match.name;
+        let title = s.title;
+        let existing = map[event];
+        if (existing !== undefined) {
+          if (existing !== match$1) {
+            ambiguities.push([
+              view,
+              view + `: ` + event + ` is projected as both "` + existing + `" and "` + match$1 + `" ` + (`(seen in "` + title + `") — the harvest keeps "` + existing + `"`)
+            ]);
+            return;
+          } else {
+            return;
+          }
+        } else {
+          map[event] = match$1;
+          return;
+        }
+      }
+    });
+    if (Object.keys(map).length !== before) {
+      changed = true;
+    }
+  };
+  return map;
+}
+
+function outcomeOf(s) {
+  let match = s.thenKind;
+  switch (match) {
+    case "error" :
+      return "Refused";
+    case "event" :
+      return "Emitted";
+    default:
+      return "NoChange";
+  }
+}
+
+function valueOf(values, field) {
+  return Stdlib_Option.map(values.find(param => param[0] === field), param => param[1]);
+}
+
+function sameRow(event, idField, idValue) {
+  if (idField === undefined) {
+    return true;
+  }
+  if (idValue === undefined) {
+    return true;
+  }
+  let actual = valueOf(event.values, idField);
+  if (actual !== undefined) {
+    return Primitive_object.equal(actual, idValue);
+  } else {
+    return true;
+  }
+}
+
+function observe(scenarios, map, idFieldFor) {
+  let fold = events => Stdlib_Array.reduce(events, noRow, (current, event) => {
+    let value = map[event.name];
+    if (value !== undefined) {
+      return value;
+    } else {
+      return current;
+    }
+  });
+  return Stdlib_Array.filterMap(scenarios, s => {
+    let command = s.whenElements[0];
+    if (command === undefined) {
+      return;
+    }
+    if (s.whenKind !== "command") {
+      return;
+    }
+    let idField = idFieldFor(command.name);
+    let idValue = Stdlib_Option.flatMap(idField, field => valueOf(command.values, field));
+    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
+    };
+  });
+}
+
+function deriveCommands(component, observations, labelled) {
+  let names = sortedUnique(observations.map(o => o.command));
+  return names.map(command => {
+    let mine = observations.filter(o => o.command === command);
+    let effective = mine.filter(o => o.outcome === "Emitted");
+    let match = effective.length;
+    return {
+      component: component,
+      command: command,
+      allowedStates: sortedUnique(Stdlib_Array.filterMap(effective, o => {
+        if (o.from === noRow) {
+          return;
+        } else {
+          return o.from;
+        }
+      })),
+      inertStates: sortedUnique(Stdlib_Array.filterMap(mine, o => {
+        if (o.outcome === "Emitted" || o.from === noRow) {
+          return;
+        } else {
+          return o.from;
+        }
+      })),
+      targets: sortedUnique(Stdlib_Array.filterMap(effective, o => {
+        if (o.to === o.from || o.to === noRow) {
+          return;
+        } else {
+          return o.to;
+        }
+      })),
+      level: labelled && match !== 0 ? (
+          effective.every(o => o.from === noRow) ? "Collection" : "Instance"
+        ) : "",
+      scenarios: mine.length
+    };
+  });
+}
+
+function allUnverified(cmd, add, why) {
+  let states = cmd.allowedStates;
+  if (states !== undefined && states.length !== 0) {
+    add("unverified", states, `the switch names ` + states.join(", ") + `, and ` + why);
+  }
+  let target = cmd.targetState;
+  if (target !== undefined) {
+    return add("unverified", [target], `the switch targets "` + target + `", and ` + why);
+  }
+}
+
+function compare(plugin, writable, derived, findings) {
+  let where = plugin + `/` + writable.name + `.` + derived.command;
+  let add = (severity, states, message) => {
+    findings.push({
+      severity: severity,
+      plugin: plugin,
+      component: writable.name,
+      command: derived.command,
+      states: states,
+      message: where + `: ` + message
+    });
+  };
+  let declared = writable.commands.find(c => c.command === derived.command);
+  if (declared === undefined) {
+    return;
+  }
+  let states = declared.allowedStates;
+  if (states !== undefined) {
+    states.forEach(state => {
+      if (derived.allowedStates.includes(state)) {
+        return;
+      } else if (derived.inertStates.includes(state)) {
+        return add("contradicted", [state], `the switch names "` + state + `", and a scenario from "` + state + `" shows it refused or producing nothing`);
+      } else {
+        return add("unverified", [state], `the switch names "` + state + `", and no scenario starts there`);
+      }
+    });
+    derived.allowedStates.forEach(state => {
+      if (!states.includes(state)) {
+        return add("contradicted", [state], `a scenario shows it taking effect from "` + state + `", which its declared ` + (`from-set (` + states.join(", ") + `) excludes`));
+      }
+    });
+    if (states.length !== 0 && derived.allowedStates.length === 0) {
+      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`));
+  } else if (derived.allowedStates.length !== 0) {
+    add("undeclared", derived.allowedStates, `scenarios show it taking effect from ` + derived.allowedStates.join(", ") + `, and it declares no edge`);
+  }
+  let match = declared.targetState;
+  let match$1 = derived.targets;
+  if (match !== undefined) {
+    if (match$1.length !== 0) {
+      if (!match$1.includes(match)) {
+        add("contradicted", [match], `the switch targets "` + match + `", and scenarios land in ` + match$1.join(", "));
+      }
+      match$1.forEach(state => {
+        if (state !== match) {
+          return add("contradicted", [
+            match,
+            state
+          ], `the switch targets "` + match + `", and a scenario lands in "` + state + `" — the published targetState carries one state, so this edge cannot be expressed`);
+        }
+      });
+    } else {
+      add("unverified", [match], `the switch targets "` + match + `", and no scenario shows an edge`);
+    }
+  }
+  if (derived.level !== "" && declared.level !== "" && derived.level !== declared.level) {
+    return add("level", [], `scenarios make it ` + derived.level + `-level; the published metadata says ` + declared.level);
+  }
+}
+
+function pluginDirsIn(exampleDir) {
+  let entries;
+  try {
+    entries = Nodefs.readdirSync(exampleDir, {
+      withFileTypes: true
+    });
+  } catch (exn) {
+    return [];
+  }
+  return entries.filter(e => e.isDirectory()).map(e => Nodepath.join(exampleDir, e.name)).filter(dir => {
+    if (Nodefs.existsSync(Nodepath.join(dir, "src", "Plugin.res"))) {
+      return Nodefs.existsSync(Nodepath.join(dir, "tests"));
+    } else {
+      return false;
+    }
+  });
+}
+
+if (process.argv.includes("--root") && flagValues("--root").length === 0) {
+  console.error("--root needs a directory after it");
+  process.exit(1);
+}
+
+let given = flagValues("--root");
+
+let roots;
+
+if (given.length !== 0) {
+  roots = given.map(given => {
+    let dir = Nodepath.resolve(given);
+    return {
+      label: Nodepath.basename(dir),
+      dir: dir
+    };
+  });
+} else {
+  let exit = 0;
+  let entries;
+  try {
+    entries = Nodefs.readdirSync(examplesDir, {
+      withFileTypes: true
+    });
+    exit = 1;
+  } catch (exn) {
+    roots = [];
+  }
+  if (exit === 1) {
+    roots = entries.filter(e => e.isDirectory()).map(e => e.name).toSorted(Primitive_string.compare).map(name => ({
+      label: name,
+      dir: Nodepath.join(examplesDir, name)
+    }));
+  }
+}
+
+function isViewPath(path) {
+  return [
+    "/ReadModel/",
+    "/ReadModelStream/",
+    "/StateViewSlice/",
+    "/StateViewSliceStream/"
+  ].some(seg => path.includes(seg));
+}
+
+function isWritablePath(path) {
+  return [
+    "/Aggregate/",
+    "/StateChangeSlice/"
+  ].some(seg => path.includes(seg));
+}
+
+async function runPlugin(plugin, pluginDir, findings, opaque) {
+  let msg = await readDeclared(pluginDir);
+  if (msg.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: msg._0
+    };
+  }
+  let declared = msg._0;
+  let corpora = Stdlib_Array.filterMap(filesUnder(Nodepath.join(pluginDir, "tests"), ".gwt.json"), readCorpus);
+  corpora.forEach(c => {
+    let unreadable = c.scenarios.filter(s => s.whenElements.length === 0);
+    if (unreadable.length !== 0) {
+      opaque.push({
+        plugin: plugin,
+        component: c.component,
+        path: c.path,
+        scenarios: c.scenarios.length,
+        unreadable: unreadable.length
+      });
+      return;
+    }
+  });
+  let mapsByView = {};
+  let ambiguities = [];
+  corpora.forEach(c => {
+    if (!isViewPath(c.path)) {
+      return;
+    }
+    let match = declared.views.find(v => v.name === c.component);
+    if (match === undefined) {
+      return;
+    }
+    let field = match.lifecycleField;
+    if (field !== undefined) {
+      mapsByView[c.component] = lifecycleMapFor(c.scenarios, field, ambiguities, c.component);
+      return;
+    }
+  });
+  ambiguities.forEach(param => {
+    findings.push({
+      severity: "ambiguous",
+      plugin: plugin,
+      component: param[0],
+      command: "",
+      states: [],
+      message: param[1]
+    });
+  });
+  let derived = [];
+  corpora.forEach(c => {
+    if (!isWritablePath(c.path)) {
+      return;
+    }
+    let writable = declared.writables.find(w => w.name === c.component);
+    if (writable === undefined) {
+      return;
+    }
+    let map = {};
+    writable.linkedViews.forEach(view => {
+      let m = mapsByView[view];
+      if (m !== undefined) {
+        return Stdlib_Dict.forEachWithKey(m, (value, event) => {
+          map[event] = value;
+        });
+      }
+    });
+    let labelled = Object.keys(map).length !== 0;
+    let idFieldFor = command => Stdlib_Option.flatMap(writable.commands.find(c => c.command === command), c => c.aggregateIdField);
+    let observations = observe(c.scenarios, map, idFieldFor);
+    let commands = deriveCommands(c.component, observations, labelled);
+    commands.forEach(d => {
+      if (labelled) {
+        compare(plugin, writable, d, findings);
+      }
+      derived.push(d);
+    });
+    let why = labelled ? "no scenario exercises the command" : writable.linkedViews.join(", ") + ` declares no lifecycle field, so its scenarios cannot be labelled`;
+    writable.commands.forEach(cmd => {
+      if (labelled && commands.some(d => d.command === cmd.command)) {
+        return;
+      } else {
+        return allUnverified(cmd, (severity, states, message) => {
+          findings.push({
+            severity: severity,
+            plugin: plugin,
+            component: writable.name,
+            command: cmd.command,
+            states: states,
+            message: plugin + `/` + writable.name + `.` + cmd.command + `: ` + message
+          });
+        }, why);
+      }
+    });
+  });
+  return {
+    TAG: "Ok",
+    _0: derived
+  };
+}
+
+function byComponentThenCommand(derived) {
+  return derived.toSorted((a, b) => {
+    let c = Primitive_string.compare(a.component, b.component);
+    if (c !== 0) {
+      return c;
+    } else {
+      return Primitive_string.compare(a.command, b.command);
+    }
+  });
+}
+
+function goldenJson(derived) {
+  let entries = byComponentThenCommand(derived).map(d => Object.fromEntries([
+    [
+      "component",
+      d.component
+    ],
+    [
+      "command",
+      d.command
+    ],
+    [
+      "level",
+      d.level
+    ],
+    [
+      "allowedStates",
+      d.allowedStates.map(prim => prim)
+    ],
+    [
+      "targets",
+      d.targets.map(prim => prim)
+    ],
+    [
+      "scenarios",
+      d.scenarios
+    ]
+  ]));
+  return JSON.stringify(entries, undefined, 2) + "\n";
+}
+
+function goldenPath(root) {
+  return Nodepath.join(root.dir, "schema", "lifecycle-model.json");
+}
+
+function reportJson(findings, opaque, derived, failures) {
+  let findingJson = f => Object.fromEntries([
+    [
+      "verdict",
+      f.severity
+    ],
+    [
+      "plugin",
+      f.plugin
+    ],
+    [
+      "component",
+      f.component
+    ],
+    [
+      "command",
+      f.command
+    ],
+    [
+      "states",
+      f.states.map(prim => prim)
+    ],
+    [
+      "message",
+      f.message
+    ]
+  ]);
+  let commandJson = param => {
+    let d = param[1];
+    return Object.fromEntries([
+      [
+        "plugin",
+        param[0]
+      ],
+      [
+        "component",
+        d.component
+      ],
+      [
+        "command",
+        d.command
+      ],
+      [
+        "level",
+        d.level
+      ],
+      [
+        "allowedStates",
+        d.allowedStates.map(prim => prim)
+      ],
+      [
+        "inertStates",
+        d.inertStates.map(prim => prim)
+      ],
+      [
+        "targets",
+        d.targets.map(prim => prim)
+      ],
+      [
+        "scenarios",
+        d.scenarios
+      ]
+    ]);
+  };
+  let opaqueJson = o => Object.fromEntries([
+    [
+      "plugin",
+      o.plugin
+    ],
+    [
+      "component",
+      o.component
+    ],
+    [
+      "path",
+      o.path
+    ],
+    [
+      "scenarios",
+      o.scenarios
+    ],
+    [
+      "unreadable",
+      o.unreadable
+    ]
+  ]);
+  return JSON.stringify(Object.fromEntries([
+    [
+      "version",
+      1
+    ],
+    [
+      "findings",
+      findings.map(findingJson)
+    ],
+    [
+      "commands",
+      derived.map(commandJson)
+    ],
+    [
+      "opaque",
+      opaque.map(opaqueJson)
+    ],
+    [
+      "unreadable",
+      failures.map(prim => prim)
+    ]
+  ]), undefined, 2) + "\n";
+}
+
+function modelSource(plugin, derived) {
+  let saysSomething = d => {
+    if (d.level !== "" || d.allowedStates.length !== 0) {
+      return true;
+    } else {
+      return d.targets.length !== 0;
+    }
+  };
+  let quoted = xs => "[" + xs.map(s => `"` + s + `"`).join(", ") + "]";
+  let entries = byComponentThenCommand(derived.filter(saysSomething)).map(d => {
+    let match = d.level;
+    let level;
+    switch (match) {
+      case "Collection" :
+      case "Instance" :
+        level = `level: Reventless.Plugin.` + d.level + `, `;
+        break;
+      default:
+        level = "";
+    }
+    return `  {component: "` + d.component + `", command: "` + d.command + `", ` + level + (`allowedStates: ` + quoted(d.allowedStates) + `, targets: ` + quoted(d.targets) + `},`);
+  });
+  return [
+    [
+      `// AUTO-GENERATED — do not edit. Run \`pnpm run check:lifecycle:update\` to update.`,
+      `//`,
+      `// What ` + plugin + `'s own given/when/then scenarios say about each command: the`,
+      `// states one shows it taking effect from, the states those land in, and whether`,
+      `// it brings a row into existence. \`Plugin_Structure\` prefers this to the`,
+      `// \`@transition\` annotation where it says anything, and falls back to the`,
+      `// annotation where it is silent.`,
+      ``,
+      `let model: array<Reventless.Plugin.derivedEdge> = [`
+    ],
+    entries,
+    [
+      "]",
+      ""
+    ]
+  ].flat().join("\n");
+}
+
+function modelPath(pluginDir) {
+  return Nodepath.join(pluginDir, "src", "LifecycleModel.res");
+}
+
+function writeOrCompare(path, actual, label, drifted) {
+  let existed = Nodefs.existsSync(path);
+  if (update || !existed) {
+    Nodefs.writeFileSync(path, actual, "utf8");
+    console.log((
+      existed ? "updated" : "wrote"
+    ) + ` ` + label);
+    return;
+  } else if (Nodefs.readFileSync(path, "utf8") !== actual) {
+    drifted.push(label);
+    console.error(`\ndrift in ` + label);
+    return;
+  } else {
+    return;
+  }
+}
+
+async function main() {
+  let findings = [];
+  let opaque = [];
+  let failures = [];
+  let drifted = [];
+  let allDerived = [];
+  let allPluginDirs = roots.flatMap(root => pluginDirsIn(root.dir));
+  if (allPluginDirs.length === 0) {
+    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 = reuseSidecars ? checkSidecars(allPluginDirs) : emitSidecars(allPluginDirs);
+  if (msg.TAG !== "Ok") {
+    console.error(msg._0);
+    process.exit(1);
+  }
+  if (!hasCorpus(allPluginDirs)) {
+    console.error(`no scenario sidecar exists under ` + roots.map(r => r.dir).join(", ") + ` after the build. Build that tree with REVENTLESS_EMIT_SIDECAR=1 and pass --reuse-sidecars.`);
+    process.exit(1);
+  }
+  for (let i = 0, i_finish = roots.length; i < i_finish; ++i) {
+    let root = roots[i];
+    if (root !== undefined) {
+      let example = root.label;
+      let exampleDir = root.dir;
+      let derived = [];
+      let dirs = pluginDirsIn(exampleDir);
+      for (let j = 0, j_finish = dirs.length; j < j_finish; ++j) {
+        let pluginDir = dirs[j];
+        if (pluginDir !== undefined) {
+          let plugin = Nodepath.basename(pluginDir);
+          let qualified = example + `/` + plugin;
+          let commands = await runPlugin(qualified, pluginDir, findings, opaque);
+          if (commands.TAG === "Ok") {
+            let commands$1 = commands._0;
+            commands$1.forEach(c => {
+              derived.push(c);
+              allDerived.push([
+                qualified,
+                c
+              ]);
+            });
+            if (!json) {
+              writeOrCompare(modelPath(pluginDir), modelSource(plugin, commands$1), example + `/` + plugin + `/src/LifecycleModel.res`, drifted);
+            }
+          } else {
+            failures.push(example + `/` + plugin + `: ` + commands._0);
+          }
+        }
+      }
+      if (dirs.length !== 0 && !json) {
+        let dir = Nodepath.join(exampleDir, "schema");
+        if (!Nodefs.existsSync(dir)) {
+          Nodefs.mkdirSync(dir, {
+            recursive: true
+          });
+        }
+        writeOrCompare(goldenPath(root), goldenJson(derived), example + `/schema/lifecycle-model.json`, drifted);
+        console.log(`ok ` + example + ` — ` + derived.length.toString() + ` commands derived from scenarios`);
+      }
+    }
+  }
+  let of_ = severity => findings.filter(f => f.severity === severity);
+  let contradicted = of_("contradicted");
+  if (json) {
+    console.log(reportJson(findings, opaque, allDerived, failures));
+  } else {
+    [
+      "contradicted",
+      "unverified",
+      "undeclared",
+      "level",
+      "ambiguous"
+    ].forEach(severity => {
+      let group = of_(severity);
+      if (group.length !== 0) {
+        console.log(`\n` + severity + ` (` + group.length.toString() + `)`);
+        group.forEach(f => {
+          console.log(`  ` + f.message);
+        });
+        return;
+      }
+    });
+  }
+  if (failures.length !== 0 && !json) {
+    console.error(`\ncould not read:`);
+    failures.forEach(f => {
+      console.error(`  ` + f);
+    });
+  }
+  if (drifted.length !== 0) {
+    console.error(`\n` + drifted.length.toString() + ` lifecycle artifact(s) changed. If the change is intended, re-run with --update and commit them alongside the change that moved them.`);
+  }
+  if (contradicted.length !== 0 || drifted.length !== 0 || failures.length !== 0) {
+    process.exit(1);
+    return;
+  }
+}
+
+main();
+
+export {
+  repoRoot,
+  examplesDir,
+  update,
+  flagValues,
+  reuseSidecars,
+  json,
+  noRow,
+  asObj,
+  getStr,
+  getArr,
+  getObjs,
+  getStrs,
+  getStrsOpt,
+  last,
+  lastSegment,
+  sortedUnique,
+  valuesOf,
+  elementsOf,
+  kindOf,
+  scenarioOf,
+  readCorpus,
+  filesUnder,
+  gwtSources,
+  sidecarOf,
+  hasCorpus,
+  checkSidecars,
+  emitSidecars,
+  levelOf,
+  declaredCommandOf,
+  declaredOf,
+  loadPluginStructure,
+  readDeclared,
+  lifecycleValue,
+  lifecycleMapFor,
+  outcomeOf,
+  valueOf,
+  sameRow,
+  observe,
+  deriveCommands,
+  allUnverified,
+  compare,
+  pluginDirsIn,
+  roots,
+  isViewPath,
+  isWritablePath,
+  runPlugin,
+  byComponentThenCommand,
+  goldenJson,
+  goldenPath,
+  reportJson,
+  modelSource,
+  modelPath,
+  writeOrCompare,
+  main,
+}
+/*  Not a pure module */