@printpractical/cruze 0.0.13 → 0.0.15

package/dist/domain/validation/plan_rules.js

@@ -1,124 +0,0 @@
-import { insideModuleMap } from "../check/check_source.js";
-import { factsOf, isUnbuilt } from "../elements.js";
-import { matchesAny } from "../glob.js";
-import { findIds, kindOf } from "../ids.js";
-                                                  
-                                                  
-import { isPlanned, readScope, readTasks, readTestPlan,                       } from "../project/plan_parts.js";
-                                                              
-import { error, warning,              } from "./problem.js";
-import { planSizeProblems } from "./size_rules.js";
-
-const TEST_KINDS = ["behaviour", "contract", "domain", "smoke"];
-
-/**
- * Rules for one buildable change: its scope names only things that can be built. Once it is
- * planned, every scope ID is proved by a task, every delivered scenario has a behaviour test,
- * and every port a built adapter implements has a contract test.
- */
-export function changePlanProblems(
-  view             ,
-  path        ,
-  doc             ,
-  delta                                    ,
-  available             ,
-)            {
-  const scope = readScope(doc);
-  if (scope === null) return [error(path, undefined, "missing-section", 'the change needs a "## Scope" section')];
-  const problems            = [...scopeTargetProblems(view, path, scope, delta.delta)];
-  if (!isPlanned(doc)) return [...problems, warning(path, undefined, "not-planned", "the change has no test plan or tasks yet; plan fills them")];
-  const { tasks, malformed } = readTasks(doc);
-  for (const line of malformed) {
-    problems.push(error(path, line, "task-format", "task lines read: - T<n>: `<owner>` in `<path>`[, `<path>`], proves <ID>[, <ID>]"));
-  }
-  if (tasks.length === 0 && malformed.length === 0) problems.push(error(path, undefined, "missing-tasks", "the change has no tasks"));
-  problems.push(...planSizeProblems(view, path, tasks.length));
-
-  const proved = new Set(tasks.flatMap((task) => task.proves));
-  const taskPaths = tasks.flatMap((task) => task.paths);
-  for (const task of tasks) {
-    for (const id of task.proves.filter((id) => !available.has(id))) {
-      problems.push(error(path, task.line, "unknown-id", `${task.number} proves ${id}, which is not defined`));
-    }
-  }
-  problems.push(...outsideModuleMap(view, path, tasks, delta));
-  for (const id of [...scope.delivers, ...scope.builds]) {
-    if (kindOf(id) === "MOD") {
-      const modulePaths = modulePathsOf(view, delta.doc, delta.delta, id);
-      if (!taskPaths.some((p) => modulePaths.some((m) => p.startsWith(m)))) {
-        problems.push(error(path, scope.line, "unproved-scope", `${id} is in scope but no task writes inside ${modulePaths.join(" or ") || "its path"}; a module that owns other files, such as a build script, lists each under its Path`));
-      }
-    } else if (kindOf(id) === "REQ") {
-      const scenarios = delta.delta.entries.find((e) => e.element.id === id)?.scenarios.map((s) => s.id) ?? [];
-      if (!proved.has(id) && !scenarios.some((s) => proved.has(s))) problems.push(error(path, scope.line, "unproved-scope", `no task proves ${id} or its scenarios`));
-    } else if (!proved.has(id)) {
-      problems.push(error(path, scope.line, "unproved-scope", `${id} is in scope but no task proves it`));
-    }
-  }
-
-  const rows = readTestPlan(doc);
-  for (const row of rows) {
-    if (!TEST_KINDS.includes(row.kind)) problems.push(error(path, row.line, "test-kind", `test kind must be one of ${TEST_KINDS.join(", ")}`));
-    const subject = findIds(row.subject)[0];
-    if (subject === undefined || !available.has(subject)) problems.push(error(path, row.line, "unknown-id", `test subject "${row.subject}" is not a defined ID`));
-    if (row.file === "") problems.push(error(path, row.line, "test-file", "every test plan row names its test file"));
-  }
-  for (const id of scope.delivers.filter((id) => kindOf(id) === "SCN")) {
-    if (!rows.some((row) => findIds(row.subject)[0] === id && row.kind === "behaviour")) {
-      problems.push(error(path, scope.line, "missing-behaviour-test", `${id} is delivered but has no behaviour row in the test plan`));
-    }
-  }
-  for (const adapter of scope.builds.filter((id) => kindOf(id) === "ADP")) {
-    const ports = (factsOfScoped(view, delta.doc, delta.delta, adapter).get("Implements") ?? []).flatMap(findIds).filter((id) => kindOf(id) === "PORT");
-    for (const port of ports.filter((p) => !rows.some((row) => findIds(row.subject)[0] === p && row.kind === "contract"))) {
-      problems.push(error(path, scope.line, "missing-contract-test", `${adapter} implements ${port} but the test plan has no contract row for ${port}`));
-    }
-  }
-  return problems;
-}
-
-/** Scope IDs must come from the item's deltas or be planned in the living docs. */
-function scopeTargetProblems(view             , path        , scope       , delta       )            {
-  const problems            = [];
-  for (const id of [...scope.delivers, ...scope.builds]) {
-    if (delta.ids.has(id)) continue;
-    const living = view.living.elements.get(id);
-    if (living === undefined) problems.push(error(path, scope.line, "unknown-id", `${id} is in scope but defined nowhere`));
-    else if (!isUnbuilt(living.doc, living.element)) {
-      problems.push(error(path, scope.line, "scope-not-planned", `${id} is already built; change it through a MODIFIED operation in the delta`));
-    }
-  }
-  for (const id of scope.removes) {
-    const removal = delta.entries.find((e) => e.element.id === id && e.element.op === "REMOVED");
-    if (removal === undefined) problems.push(error(path, scope.line, "scope-removes", `${id} is in Removes but the delta has no REMOVED operation for it`));
-  }
-  if (scope.delivers.length + scope.builds.length + scope.removes.length === 0) {
-    problems.push(warning(path, scope.line, "empty-scope", "the scope delivers and builds nothing"));
-  }
-  return problems;
-}
-
-/** An element's facts as this item will build it: from its delta when it has one, else from the living docs. */
-function factsOfScoped(view             , doc             , delta       , id        )                        {
-  const fromDelta = delta.entries.find((e) => e.element.id === id);
-  const living = view.living.elements.get(id);
-  return fromDelta !== undefined ? factsOf(doc, fromDelta.element) : living !== undefined ? factsOf(living.doc, living.element) : new Map                  ();
-}
-
-function modulePathsOf(view             , doc             , delta       , id        )           {
-  return (factsOfScoped(view, doc, delta, id).get("Path") ?? []).flatMap((value) => [...value.matchAll(/`([^`]+)`/g)].map((m) => m[1] ?? "")).filter((p) => p !== "");
-}
-
-/** Task paths that `cruze check` would report as outside every module, caught while the plan can still fix the module map. */
-function outsideModuleMap(view             , path        , tasks        , delta                                    )            {
-  const source = view.config?.config?.source ?? [];
-  const removed = new Set(delta.delta.entries.filter((e) => e.element.op === "REMOVED").map((e) => e.element.id));
-  const modules = new Set([...view.living.elements.keys(), ...delta.delta.entries.map((e) => e.element.id)].filter((id) => kindOf(id) === "MOD" && !removed.has(id)));
-  const modulePaths = [...modules].flatMap((id) => modulePathsOf(view, delta.doc, delta.delta, id));
-  if (modulePaths.length === 0) return [];
-  return tasks.flatMap((task) =>
-    task.paths
-      .filter((file) => matchesAny(file, source) && !insideModuleMap(file, modulePaths))
-      .map((file) => warning(path, task.line, "outside-module-map", `${task.number} writes ${file}, which no module's Path covers; add it to a module's Path or move the file`)),
-  );
-}

package/dist/domain/validation/project_rules.js

@@ -1,115 +0,0 @@
-import { factsOf } from "../elements.js";
-import { matchesAny } from "../glob.js";
-import { findIds } from "../ids.js";
-import { parseMarkdown,                  } from "../markdown.js";
-import { PATHS } from "../project/layout.js";
-import { readRoadmapItems } from "../project/roadmap.js";
-                                                              
-import { error, warning,              } from "./problem.js";
-
-/** Rules that span the project: leftover template guides, the roadmap, the config and the README. */
-
-const GUIDE = /(?<!`)<(?!!--|\/|https?:|br\b)[A-Za-z][^<>\n]*>(?!`)/;
-const PLACEHOLDER = /\{\{[a-z_]+\}\}/;
-
-/**
- * Unfilled `<guides>` and `{{placeholders}}` outside code, in living docs and active work.
- * Managed blocks are skipped: the CLI writes them, and they may quote text such as `<COMMAND>`.
- */
-export function templateLeftovers(view             )            {
-  const paths = [...view.living.docs.keys(), PATHS.roadmap, PATHS.glossary, ...view.items.filter((i) => !i.archived).map((i) => i.path)];
-  return paths.flatMap((path) => {
-    const text = view.snapshot.get(path);
-    if (text === undefined) return [];
-    const doc = parseMarkdown(text);
-    return doc.lines.flatMap((line, i) => {
-      if (doc.inFence[i] || doc.inManaged[i]) return [];
-      const withoutCode = line.replace(/`[^`]*`/g, "");
-      if (GUIDE.test(withoutCode) || PLACEHOLDER.test(withoutCode)) {
-        return [error(path, i, "template-leftover", "replace the template guide or placeholder on this line")];
-      }
-      return [];
-    });
-  });
-}
-
-export function roadmapProblems(view             )            {
-  const text = view.snapshot.get(PATHS.roadmap);
-  if (text === undefined) return [];
-  const doc = parseMarkdown(text);
-  const problems            = [];
-  const items = new Map                                               ();
-  for (const { slug: item, kind, blockedBy, line } of readRoadmapItems(text)) {
-    if (items.has(item)) problems.push(error(PATHS.roadmap, line, "roadmap-item", `item ${item} appears twice`));
-    if (!["feature", "change"].includes(kind)) problems.push(error(PATHS.roadmap, line, "roadmap-item", `item ${item} kind must be feature or change`));
-    items.set(item, { blockedBy, line });
-  }
-  for (const [item, { blockedBy, line }] of items) {
-    for (const blocker of blockedBy.filter((b) => !items.has(b))) problems.push(error(PATHS.roadmap, line, "roadmap-blocker", `${item} is blocked by unknown item ${blocker}`));
-  }
-  const cycle = findCycle(items);
-  if (cycle !== null) problems.push(error(PATHS.roadmap, undefined, "roadmap-cycle", `blocking cycle: ${cycle.join(" -> ")}`));
-  const coverage = doc.lines.join("\n").split(/^## Coverage$/m)[1] ?? "";
-  for (const goal of [...view.living.elements.keys()].filter((id) => id.startsWith("GOAL-"))) {
-    if (!findIds(coverage).includes(goal)) problems.push(warning(PATHS.roadmap, undefined, "goal-uncovered", `${goal} has no items in the coverage table`));
-  }
-  return problems;
-}
-
-function findCycle(items                                      )                  {
-  const state = new Map                             ();
-  const visit = (item        , path          )                  => {
-    if (state.get(item) === "done") return null;
-    if (state.get(item) === "visiting") return [...path.slice(path.indexOf(item)), item];
-    state.set(item, "visiting");
-    for (const next of items.get(item)?.blockedBy ?? []) {
-      const found = visit(next, [...path, item]);
-      if (found !== null) return found;
-    }
-    state.set(item, "done");
-    return null;
-  };
-  for (const item of items.keys()) {
-    const found = visit(item, []);
-    if (found !== null) return found;
-  }
-  return null;
-}
-
-export function configProblems(view             )            {
-  if (view.config === null) return [error(PATHS.config, undefined, "config-missing", "the project has no .cruze/config.yaml; run cruze init")];
-  const problems = view.config.problems.map((message) => error(PATHS.config, undefined, "config", message));
-  const config = view.config.config;
-  const architecture = view.living.docs.get(PATHS.architecture);
-  if (config === null || architecture === undefined || config.layers.length === 0) return problems;
-  for (const { element } of [...view.living.elements.values()].filter((e) => e.id.startsWith("MOD-"))) {
-    for (const path of modulePaths(architecture, element)) {
-      const probe = path.endsWith("/") ? `${path}probe.file` : path;
-      const layers = config.layers.filter((layer) => matchesAny(probe, layer.paths));
-      if (layers.length !== 1) {
-        problems.push(warning(PATHS.config, undefined, "module-layer", `${element.id} path ${path} falls in ${layers.length} layers; it should fall in exactly one`));
-      }
-    }
-  }
-  return problems;
-}
-
-function modulePaths(doc             , element                               )           {
-  return (factsOf(doc, element).get("Path") ?? []).flatMap((value) => [...value.matchAll(/`([^`]+)`/g)].map((m) => m[1] ?? ""));
-}
-
-/**
- * Once the vision is approved, the README says what the project is under its title.
- * Images, badges and HTML lines don't count as that overview.
- */
-export function readmeProblems(view             )            {
-  const text = view.snapshot.get(PATHS.readme);
-  const visionApproved = [...view.approvals.values()].some((file) => file.approvals.some((record) => record.artifact === PATHS.vision));
-  if (text === undefined || !visionApproved) return [];
-  const doc = parseMarkdown(text);
-  const title = doc.lines.findIndex((line) => /^# /.test(line));
-  const next = doc.lines.findIndex((line, i) => i > title && /^#{1,6} /.test(line));
-  const intro = doc.lines.slice(title + 1, next === -1 ? undefined : next);
-  const overview = intro.some((line, i) => !doc.inFence[title + 1 + i] && line.trim() !== "" && !/^\s*(!\[|\[!\[|<)/.test(line));
-  return overview ? [] : [warning(PATHS.readme, Math.max(title, 0), "readme-overview", "add a paragraph under the title saying what the project is, who it is for and why, from docs/vision.md")];
-}

package/dist/domain/validation/size_rules.js

@@ -1,45 +0,0 @@
-import { DEFAULT_CHANGE_LIMITS,                   } from "../config.js";
-import { kindOf } from "../ids.js";
-                                                          
-                                                              
-import { warning,              } from "./problem.js";
-
-/**
- * Every change pays for its own plan review, code review, verifier run and land, so a change
- * should carry enough work to be worth them, and no more than one review and one run can hold.
- */
-export function changeLimits(view             )               {
-  return view.config?.config?.changes ?? DEFAULT_CHANGE_LIMITS;
-}
-
-/** The rules a size warning comes from. An item stays outside the band only with the user's recorded acceptance. */
-export const SIZE_RULES = ["feature-size", "change-too-small", "change-too-large", "plan-too-large"];
-
-/** Whether the user accepted this feature or change outside the band, under `changes.exceptions`. */
-export function sizeAccepted(view             , ref        )          {
-  return changeLimits(view).exceptions.some((exception) => exception.item === ref);
-}
-
-/** A feature's changes not yet landed that fall outside the size band. A feature of one change has nothing to merge into. */
-export function changeRowSizeProblems(view             , feature                               , rows             , landed             )            {
-  const limits = changeLimits(view);
-  const problems            = [];
-  for (const row of rows.filter((r) => !landed.has(r.change) && !sizeAccepted(view, `${feature.ref}/${r.change}`))) {
-    if (rows.length > 1 && row.builds.length < limits.minBuilds) {
-      problems.push(warning(feature.path, row.line, "change-too-small", `${row.change} builds ${row.builds.length} element(s), under ${limits.minBuilds}; merge it into the change it continues, since each change pays for its own plan, review and verify`));
-    }
-    const scenarios = row.delivers.filter((id) => kindOf(id) === "SCN").length;
-    if (scenarios > limits.maxScenarios) {
-      problems.push(warning(feature.path, row.line, "change-too-large", `${row.change} delivers ${scenarios} scenarios, over ${limits.maxScenarios}; split it, since one verifier run has to go through them all`));
-    }
-  }
-  return problems;
-}
-
-/** A plan with more tasks than one code review and one verify can hold. */
-export function planSizeProblems(view             , path        , tasks        )            {
-  const { maxTasks } = changeLimits(view);
-  const ref = view.items.find((item) => item.path === path)?.ref ?? path;
-  if (tasks <= maxTasks || sizeAccepted(view, ref)) return [];
-  return [warning(path, undefined, "plan-too-large", `the plan has ${tasks} tasks, over ${maxTasks}; split the change through rethink at feature level`)];
-}

package/dist/domain/validation/vision_rules.js

@@ -1,41 +0,0 @@
-import { rowElements } from "../elements.js";
-import { findSection } from "../markdown.js";
-import { splitRow } from "../markdown_tables.js";
-import { PATHS } from "../project/layout.js";
-                                                              
-import { error,              } from "./problem.js";
-
-/** The section and the cells after the ID that each long-term row of the vision holds. */
-const INTENT_ROWS                                                       = {
-  PRINCIPLE: { section: "Principles", cells: ["Principle", "Why"] },
-  LATER: { section: "Must stay possible", cells: ["Capability", "Likelihood", "Why", "Leave room for"] },
-};
-
-export const LIKELIHOODS = ["likely", "possible"];
-
-/**
- * The vision's principles and the capabilities that must stay possible are rows, so designs cite
- * them and approvals pin them. One project kept its principles in a seed note and its long-term
- * plans in the user's head: a feature reversed a principle unnoticed, and a later review proposed
- * removing what those plans needed.
- */
-export function visionProblems(view             )            {
-  const doc = view.living.docs.get(PATHS.vision);
-  if (doc === undefined) return [];
-  return rowElements(doc).flatMap((row) => {
-    const shape = INTENT_ROWS[row.kind];
-    if (shape === undefined) return [];
-    const section = findSection(doc, shape.section);
-    if (section === null || row.start < section.start || row.start >= section.end) {
-      return [error(PATHS.vision, row.start, "vision-row", `${row.id} belongs in the table under ## ${shape.section}`)];
-    }
-    const cells = splitRow(doc.lines[row.start] ?? "").slice(1);
-    if (cells.length !== shape.cells.length || cells.some((cell) => cell === "")) {
-      return [error(PATHS.vision, row.start, "vision-row", `${row.id} needs ${shape.cells.join(", ")}, each filled`)];
-    }
-    if (row.kind === "LATER" && !LIKELIHOODS.includes(cells[1] ?? "")) {
-      return [error(PATHS.vision, row.start, "vision-row", `${row.id}'s likelihood must be ${LIKELIHOODS.join(" or ")}`)];
-    }
-    return [];
-  });
-}

package/dist/domain/validation/work_item_rules.js

@@ -1,175 +0,0 @@
-import { isUnbuilt } from "../elements.js";
-import { findIds, kindOf } from "../ids.js";
-import { elementHash } from "../hashing.js";
-import { findSection,                  } from "../markdown.js";
-import { readDelta,            } from "../project/deltas.js";
-import { readChangesTable, readScope } from "../project/plan_parts.js";
-import { readProgress } from "../project/progress.js";
-                                                              
-import { changesOf, featureOf,               } from "../project/work_items.js";
-import { deltaProblems } from "./delta_rules.js";
-import { malformedIdHeadings, lineOf } from "./living_rules.js";
-import { changePlanProblems } from "./plan_rules.js";
-import { error, warning,              } from "./problem.js";
-import { changeRowSizeProblems, sizeAccepted } from "./size_rules.js";
-
-const REQUIRED_SECTIONS                                     = {
-  feature: ["Intent", "Spec delta", "Architecture delta", "Changes"],
-  change: ["Scope", "Test plan", "Tasks"],
-  standalone: ["Intent", "Spec delta", "Architecture delta", "Scope", "Test plan", "Tasks"],
-};
-
-/** Rules for every active feature and change. Archived work is history and is not checked. */
-export function workItemProblems(view             )            {
-  return view.items.filter((item) => !item.archived).flatMap((item) => itemProblems(view, item));
-}
-
-function itemProblems(view             , item          )            {
-  const { path, doc } = item;
-  const problems            = [...malformedIdHeadings(path, doc)];
-  const id = doc.frontmatter?.["id"];
-  if (id !== item.folderName) problems.push(error(path, 0, "frontmatter", `frontmatter id must be "${item.folderName}", the folder name`));
-  const title = doc.frontmatter?.["title"];
-  if (typeof title !== "string" || title.trim() === "") problems.push(error(path, 0, "frontmatter", "frontmatter needs a title"));
-  for (const section of REQUIRED_SECTIONS[item.kind]) {
-    if (findSection(doc, section) === null) problems.push(error(path, undefined, "missing-section", `missing "## ${section}"`));
-  }
-
-  const feature = item.kind === "change" ? featureOf(view.items, item) : undefined;
-  if (item.kind === "change" && feature === undefined) problems.push(error(path, undefined, "orphan-change", "the change's feature.md is missing"));
-  const deltaSource = item.kind === "change" ? feature : item;
-  const delta = deltaSource === undefined ? readDelta(doc) : readDelta(deltaSource.doc);
-  const available = new Set([...view.living.elements.keys(), ...delta.ids]);
-
-  const text = doc.lines.join("\n");
-  for (const cited of findIds(text).filter((cited) => !available.has(cited))) {
-    problems.push(error(path, lineOf(text, cited), "unknown-id", `${cited} is cited but defined neither in the living docs nor in this work's deltas`));
-  }
-  const dropped = droppedScenarios(view, delta);
-  for (const cited of findIds(text).filter((cited) => dropped.has(cited))) {
-    problems.push(error(path, lineOf(text, cited), "cites-dropped", `${cited} is cited, but ${dropped.get(cited)} in this work's delta leaves it out, so it won't exist once the work lands; describe it in words instead`));
-  }
-  if (item.kind !== "change") problems.push(...deltaProblems(view, item));
-  if (item.kind === "feature") problems.push(...featureScopeProblems(view, item, delta));
-  // A landed change is history: its scope named what it built, which is now built.
-  const landed = item.kind !== "feature" && readProgress(doc).landed !== undefined;
-  if (item.kind !== "feature" && deltaSource !== undefined && !landed) {
-    problems.push(...changePlanProblems(view, path, doc, { delta, doc: deltaSource.doc }, available));
-  }
-  if (item.kind === "standalone") problems.push(...coverageProblems(view, path, delta, doc, [{ name: "this change", ids: scopeIds(item) }]));
-  return problems;
-}
-
-/** A feature's Changes table covers its deltas, and each change folder agrees with its row. */
-/** More changes than this, and one design review can't hold the whole feature: contradictions slip through to plan. */
-const MAX_CHANGES = 6;
-
-function featureScopeProblems(view             , feature          , delta       )            {
-  const rows = readChangesTable(feature.doc);
-  if (rows.length === 0) return [warning(feature.path, undefined, "not-designed", "the feature has no changes yet; architect designs and splits it")];
-  const problems            = [];
-  const landedChanges = new Set(
-    [...readProgress(feature.doc).changes].filter(([, state]) => state === "landed").map(([change]) => change),
-  );
-  const names = rows.map((row) => row.change);
-  const extra = rows[MAX_CHANGES];
-  if (extra !== undefined && !sizeAccepted(view, feature.ref)) {
-    problems.push(warning(feature.path, extra.line, "feature-size", `the feature has ${rows.length} changes, over ${MAX_CHANGES}; split it into features a single design review can hold`));
-  }
-  problems.push(...changeRowSizeProblems(view, feature, rows, landedChanges));
-  for (const row of rows) {
-    if (!/^\d\d-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(row.change)) problems.push(error(feature.path, row.line, "change-name", `change "${row.change}" must be named NN-slug`));
-    if (names.indexOf(row.change) !== names.lastIndexOf(row.change)) problems.push(error(feature.path, row.line, "change-name", `change ${row.change} is listed twice`));
-    for (const dependency of row.dependsOn) {
-      const at = names.indexOf(dependency);
-      if (at === -1 || at >= names.indexOf(row.change)) problems.push(error(feature.path, row.line, "change-order", `${row.change} depends on ${dependency}, which must be an earlier change`));
-    }
-    for (const id of landedChanges.has(row.change) ? [] : [...row.delivers, ...row.builds]) {
-      const living = view.living.elements.get(id);
-      const planned = living !== undefined && isUnbuilt(living.doc, living.element);
-      if (!delta.ids.has(id) && !planned) problems.push(error(feature.path, row.line, "scope-not-planned", `${id} must come from this feature's deltas or be planned in the living docs`));
-    }
-  }
-  problems.push(...coverageProblems(view, feature.path, delta, feature.doc, rows.map((row) => ({ name: row.change, ids: [...row.delivers, ...row.builds, ...row.removes], landed: landedChanges.has(row.change) }))));
-
-  for (const change of changesOf(view.items, feature)) {
-    const row = rows.find((r) => r.change === change.folderName);
-    if (row === undefined) {
-      problems.push(error(change.path, undefined, "change-not-listed", `${change.folderName} is not in the feature's Changes table`));
-      continue;
-    }
-    const expected = new Set([...row.delivers, ...row.builds, ...row.removes]);
-    const actual = new Set(scopeIds(change));
-    const differ = [...expected].filter((id) => !actual.has(id)).concat([...actual].filter((id) => !expected.has(id)));
-    if (differ.length > 0) problems.push(error(change.path, readScope(change.doc)?.line, "scope-mismatch", `Scope differs from the feature's Changes row: ${differ.join(", ")}`));
-  }
-  return problems;
-}
-
-/**
- * Every delta ID lands exactly once. A requirement is covered by its own ID or one of its
- * scenarios. A scenario must be covered when it is new or its text changed; an unchanged
- * scenario kept by a MODIFIED requirement may be left out.
- */
-function coverageProblems(
-  view             ,
-  path        ,
-  delta       ,
-  deltaDoc             ,
-  groups                                                          ,
-)            {
-  const coveredBy = new Map                  ();
-  const pendingBy = new Map                  ();
-  for (const group of groups) {
-    for (const id of group.ids) {
-      coveredBy.set(id, [...(coveredBy.get(id) ?? []), group.name]);
-      if (group.landed !== true) pendingBy.set(id, [...(pendingBy.get(id) ?? []), group.name]);
-    }
-  }
-  const problems            = [];
-  // A change that already landed may be followed by one that rebuilds the same element after a rethink.
-  const once = (id        , line        , required         )       => {
-    const pending = pendingBy.get(id) ?? [];
-    if (required && (coveredBy.get(id) ?? []).length === 0) problems.push(error(path, line, "uncovered", `${id} is not in any change's scope`));
-    if (pending.length > 1) problems.push(error(path, line, "covered-twice", `${id} is in the scope of ${pending.join(" and ")}; it must land exactly once`));
-  };
-  for (const { element, scenarios } of delta.entries) {
-    if (kindOf(element.id) !== "REQ") {
-      once(element.id, element.start, true);
-      continue;
-    }
-    once(element.id, element.start, false);
-    if (![element.id, ...scenarios.map((s) => s.id)].some((id) => coveredBy.has(id))) {
-      problems.push(error(path, element.start, "uncovered", `${element.id} is not delivered by any change`));
-    }
-    for (const scenario of scenarios) {
-      const living = view.living.elements.get(scenario.id);
-      const changed = living === undefined || elementHash(living.doc, living.element) !== elementHash(deltaDoc, scenario);
-      once(scenario.id, scenario.start, element.op !== "REMOVED" && changed);
-    }
-  }
-  return problems;
-}
-
-function scopeIds(item          )           {
-  const scope = readScope(item.doc);
-  return scope === null ? [] : [...scope.delivers, ...scope.builds, ...scope.removes];
-}
-
-/**
- * Living scenarios that a MODIFIED requirement in the delta leaves out, each with that requirement.
- * Land drops them, so a citation of one passes validation now and breaks only at land.
- */
-function droppedScenarios(view             , delta       )                      {
-  const dropped = new Map                ();
-  for (const entry of delta.entries.filter((e) => e.element.op === "MODIFIED" && kindOf(e.element.id) === "REQ")) {
-    const living = view.living.elements.get(entry.element.id);
-    if (living === undefined) continue;
-    const kept = new Set(entry.scenarios.map((s) => s.id));
-    for (const scenario of view.living.elements.values()) {
-      const nested = scenario.doc === living.doc && scenario.element.start > living.element.start && scenario.element.start < living.element.end;
-      if (nested && kindOf(scenario.id) === "SCN" && !kept.has(scenario.id) && !delta.ids.has(scenario.id)) dropped.set(scenario.id, entry.element.id);
-    }
-  }
-  return dropped;
-}

package/dist/domain/versions/realign_notes.js

@@ -1,72 +0,0 @@
-import { compareVersions } from "./cruze_version.js";
-
-/**
- * A realign note: one change in what Cruze expects of a project, shipped in
- * `skills/realign/notes/<version>.md` so `realign` can bring existing code up to it.
- */
-                              
-             
-                
-                  
-                                                                                      
-                                
-                                                                    
-               
-                                                                      
-                  
-                                                              
-               
-                   
- 
-
-                              
-                       
-                     
- 
-
-const APPLIES                                           = { "existing code": "existing", "new work only": "new" };
-
-/** Parses one version's notes file. Each note is a `### <id>: <title>` heading with facts under it. */
-export function parseRealignNotes(version        , text        )              {
-  const notes                = [];
-  const problems           = [];
-  const sections = text.split(/^### /m).slice(1);
-  for (const section of sections) {
-    const [heading = "", ...body] = section.split("\n");
-    const match = /^([a-z0-9]+(?:-[a-z0-9]+)*): (.+)$/.exec(heading.trim());
-    if (match === null) {
-      problems.push(`${version}: "### ${heading.trim()}" must read "### <id>: <title>"`);
-      continue;
-    }
-    const [, id = "", title = ""] = match;
-    const fact = (key        )                     => body.map((line) => new RegExp(`^- ${key}: (.+)$`).exec(line)?.[1]?.trim()).find((v) => v !== undefined);
-    const applies = APPLIES[fact("Applies to") ?? ""];
-    const rule = fact("Rule");
-    const detect = fact("Detect")?.replace(/`/g, "");
-    const ask = fact("Ask");
-    const migrate = fact("Migrate");
-    if (applies === undefined) problems.push(`${version} ${id}: "- Applies to:" must be "existing code" or "new work only"`);
-    if (rule === undefined) problems.push(`${version} ${id}: needs "- Rule:"`);
-    if (detect !== undefined && !/^(check|validate):[a-z-]+$/.test(detect)) problems.push(`${version} ${id}: "- Detect:" names a rule as check:<rule> or validate:<rule>`);
-    if (applies === "existing" && detect === undefined && ask === undefined) problems.push(`${version} ${id}: a note for existing code needs "- Detect:" or "- Ask:"`);
-    if (applies === "existing" && migrate === undefined) problems.push(`${version} ${id}: a note for existing code needs "- Migrate:"`);
-    notes.push({
-      id,
-      title,
-      version,
-      appliesTo: applies ?? "new",
-      rule: rule ?? "",
-      ...(detect === undefined ? {} : { detect }),
-      ...(ask === undefined ? {} : { ask }),
-      ...(migrate === undefined ? {} : { migrate }),
-    });
-  }
-  const ids = notes.map((n) => n.id);
-  ids.filter((id, i) => ids.indexOf(id) !== i).forEach((id) => problems.push(`${version}: note ${id} appears twice`));
-  return { notes, problems };
-}
-
-/** Notes after the version the code meets, up to and including the version installed. */
-export function notesBetween(notes               , standards        , target        )                {
-  return notes.filter((n) => compareVersions(n.version, standards) > 0 && compareVersions(n.version, target) <= 0);
-}

package/dist/domain/versions/rule_versions.js

@@ -1,29 +0,0 @@
-import { compareVersions } from "./cruze_version.js";
-
-/** The first release of Cruze. A project that records no `standards:` meets its expectations. */
-export const FIRST_RELEASE = "0.0.1";
-
-/**
- * The release that introduced each rule reporting on existing code, keyed as `<command>:<rule>`.
- * A rule newer than the project's `standards:` still reports, but can't fail CI until the project realigns.
- * Every entry needs a realign note in `skills/realign/notes/<version>.md`; the bundle lint checks it.
- */
-export const RULE_SINCE                         = {
-  "check:test-placement": "0.0.2",
-  "validate:outside-module-map": "0.0.2",
-  "validate:readme-overview": "0.0.2",
-  "validate:feature-size": "0.0.2",
-  "validate:change-too-small": "0.0.5",
-  "validate:change-too-large": "0.0.5",
-  "validate:plan-too-large": "0.0.5",
-  "validate:module-path-glob": "0.0.8",
-  "validate:decision-citation": "0.0.10",
-  "check:decision-citation": "0.0.10",
-  "validate:future-unanchored": "0.0.10",
-};
-
-/** Whether a rule arrived after the version the project's code meets, so it waits for `realign`. */
-export function isPending(command                      , rule        , standards        )          {
-  const since = RULE_SINCE[`${command}:${rule}`];
-  return since !== undefined && compareVersions(since, standards) > 0;
-}

package/dist/domain/versions/scheduled_exceptions.js

@@ -1,41 +0,0 @@
-import { parseDocument,               } from "yaml";
-
-/**
- * `check.exceptions` entries that `realign` adds for findings a prefactor change will fix,
- * and that landing that change removes. Edited through the YAML document, so comments survive.
- */
-
-                            
-               
-               
- 
-
-const scheduledReason = (version        , note        , ref        )         => `realign ${version} (${note}): scheduled in ${ref}`;
-
-/** The config text with an exception for each finding, naming the change that will fix it. */
-export function withScheduledExceptions(configText        , version        , ref        , findings             )         {
-  if (findings.length === 0) return configText;
-  const doc = parseDocument(configText);
-  const listed = new Set(((doc.getIn(["check", "exceptions"])                                                      )?.toJSON() ?? []).map((e) => e.path));
-  for (const finding of findings.filter((f, i) => !listed.has(f.path) && findings.findIndex((o) => o.path === f.path) === i)) {
-    doc.addIn(["check", "exceptions"], doc.createNode({ path: finding.path, reason: scheduledReason(version, finding.note, ref) }));
-  }
-  return render(doc);
-}
-
-/** The config text without the exceptions scheduled in a change, once it lands; unchanged when it had none. */
-export function withoutScheduledExceptions(configText        , ref        )                                      {
-  const doc = parseDocument(configText);
-  const exceptions = doc.getIn(["check", "exceptions"])                                                                                  ;
-  if (exceptions === undefined || !Array.isArray(exceptions.items)) return { text: configText, removed: [] };
-  const suffix = `: scheduled in ${ref}`;
-  const removed = exceptions.items.map((item) => item.toJSON()).filter((e) => e.reason?.endsWith(suffix)).map((e) => e.path ?? "");
-  if (removed.length === 0) return { text: configText, removed: [] };
-  exceptions.items = exceptions.items.filter((item) => !(item.toJSON().reason ?? "").endsWith(suffix));
-  return { text: render(doc), removed };
-}
-
-/** Renders without wrapping long lines or padding flow lists, so an edit changes only what it touches. */
-function render(doc          )         {
-  return doc.toString({ lineWidth: 0, flowCollectionPadding: false });
-}