@ethlete/cli 3.0.0-next.26 → 3.0.0-next.28

package/src/lib/design/system/check-system.js

@@ -8,38 +8,94 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkSystemRendered = exports.checkSystem = exports.ruleProblemsOf = exports.ruleLinesOf = void 0;
+exports.checkSystemRendered = exports.checkSystem = exports.staleSketchBasesOf = exports.ruleSummaryText = exports.summaryText = exports.buildReadyInputsOf = exports.ruleProblemsOf = exports.uncomparedLinesOf = exports.checkRules = exports.ruleLinesOf = exports.warningProblemsOf = void 0;
 const path_1 = require("path");
+const base_issues_1 = require("./base-issues");
+const design_hash_1 = require("./design-hash");
+const reachable_files_1 = require("./reachable-files");
+const accepted_pictures_1 = require("./accepted-pictures");
 const imports_1 = require("./imports");
 const complete_1 = require("./complete");
+const embedded_actions_1 = require("./embedded-actions");
+const action_lost_1 = require("./action-lost");
+const harness_map_1 = require("./harness-map");
+const stale_cli_dist_1 = require("../stale-cli-dist");
+const capability_place_1 = require("./rules/capability-place");
+const action_undeclared_1 = require("./action-undeclared");
+const bespoke_controls_1 = require("./bespoke-controls");
+const dropped_props_1 = require("./dropped-props");
+const drawn_open_points_1 = require("./drawn-open-points");
 const open_points_1 = require("./open-points");
+const part_task_1 = require("./part-task");
 const part_ready_1 = require("./part-ready");
+const check_record_1 = require("./check-record");
+const actions_command_1 = require("./actions-command");
+const rule_baseline_1 = require("./rule-baseline");
+const slow_checks_1 = require("./slow-checks");
+const stale_parts_1 = require("./stale-parts");
+const rule_skips_1 = require("./rule-skips");
+const stale_dist_1 = require("./stale-dist");
 const read_open_points_1 = require("./read-open-points");
 const resolve_product_1 = require("./resolve-product");
 const canonical_class_1 = require("./rules/canonical-class");
 const component_copy_1 = require("./rules/component-copy");
+const denied_class_1 = require("./rules/denied-class");
+const native_title_1 = require("./rules/native-title");
+const command_text_1 = require("./rules/command-text");
 const render_check_1 = require("./render-check");
 const flow_1 = require("./rules/flow");
 const implements_1 = require("./rules/implements");
+const state_in_component_1 = require("./rules/state-in-component");
+const part_rewrite_1 = require("./rules/part-rewrite");
 const hard_coded_colour_1 = require("./rules/hard-coded-colour");
 const interactions_1 = require("./rules/interactions");
 const kit_outside_pages_1 = require("./rules/kit-outside-pages");
+const inline_ui_in_page_1 = require("./rules/inline-ui-in-page");
 const inline_svg_1 = require("./rules/inline-svg");
+const top_level_await_1 = require("./rules/top-level-await");
+const skips_1 = require("./rules/skips");
 const motion_1 = require("./rules/motion");
 const stale_comment_1 = require("./rules/stale-comment");
+const glued_interpolation_1 = require("./rules/glued-interpolation");
+const undefined_class_1 = require("./rules/undefined-class");
 const undefined_token_1 = require("./rules/undefined-token");
 const token_selectors_1 = require("./rules/token-selectors");
+const sdk_attribute_value_1 = require("./rules/sdk-attribute-value");
+const sdk_private_var_1 = require("./rules/sdk-private-var");
 const upward_dependency_1 = require("./rules/upward-dependency");
 const svg_asset_1 = require("./rules/svg-asset");
 const stale_replace_1 = require("./rules/stale-replace");
+const check_rules_1 = require("./check-rules");
 const unused_shared_export_1 = require("./rules/unused-shared-export");
 const utility_css_1 = require("./rules/utility-css");
+const orphan_endpoint_1 = require("./rules/orphan-endpoint");
+const sample_default_1 = require("./rules/sample-default");
+const unbound_input_1 = require("./rules/unbound-input");
+const pending_state_1 = require("./rules/pending-state");
+const view_coverage_1 = require("./rules/view-coverage");
+const design_coverage_1 = require("./rules/design-coverage");
 const widths_1 = require("./rules/widths");
 const check_sketches_1 = require("./sketch/check-sketches");
 const merged_parts_1 = require("./sketch/merged-parts");
+const stale_base_1 = require("./sketch/stale-base");
 const sketch_1 = require("./sketch/sketch");
 const system_tsconfig_1 = require("./system-tsconfig");
+const invocation_1 = require("../../invocation");
+const leftover_gate_files_1 = require("./leftover-gate-files");
+const uncommitted_decisions_1 = require("./uncommitted-decisions");
+const phase_timing_1 = require("../phase-timing");
 const RULES = [
     imports_1.importProblemsOf,
     upward_dependency_1.upwardDependenciesOf,
@@ -49,28 +105,208 @@ const RULES = [
     motion_1.scriptedMotionOf,
     motion_1.badMotionsOf,
     motion_1.badUnreachableOf,
+    skips_1.badSkipsOf,
     motion_1.hardCodedMotionOf,
     stale_comment_1.staleCommentsOf,
     stale_comment_1.staleNotesOf,
     widths_1.badWidthsOf,
     implements_1.badLinksOf,
+    state_in_component_1.statesNotInComponentOf,
+    part_rewrite_1.partRewritesOf,
     interactions_1.unknownInteractionsOf,
     kit_outside_pages_1.kitOutsidePagesOf,
+    inline_ui_in_page_1.inlineUiInPageProblemsOf,
     flow_1.flowProblemsOf,
     svg_asset_1.badSvgAssetsOf,
     inline_svg_1.inlineSvgsOf,
+    top_level_await_1.topLevelAwaitsOf,
     canonical_class_1.canonicalClassesOf,
+    undefined_class_1.undefinedClassesOf,
+    denied_class_1.deniedClassesOf,
+    native_title_1.nativeTitlesOf,
+    command_text_1.commandTextOf,
     utility_css_1.utilityCssOf,
+    orphan_endpoint_1.orphanEndpointProblemsOf,
+    sample_default_1.sampleDefaultProblemsOf,
+    unbound_input_1.unboundInputProblemsOf,
+    glued_interpolation_1.gluedInterpolationsOf,
+    sdk_attribute_value_1.sdkAttributeValuesOf,
+    sdk_private_var_1.sdkPrivateVarsOf,
+];
+const warningProblemsOf = (product) => [
+    ...(0, unused_shared_export_1.unusedSharedExportsOf)(product),
+    ...(0, stale_replace_1.staleReplacesOf)(product),
+    ...(0, token_selectors_1.tokenSelectorsOf)(product),
+    ...(0, orphan_endpoint_1.orphanEndpointWarningsOf)(product),
+    ...(0, sample_default_1.sampleDefaultWarningsOf)(product),
+    ...(0, unbound_input_1.unboundInputWarningsOf)(product),
+    ...(0, inline_ui_in_page_1.inlineUiInPageWarningsOf)(product),
+    ...(0, pending_state_1.pendingStateWarningsOf)(product),
 ];
+exports.warningProblemsOf = warningProblemsOf;
 const ruleLinesOf = (target, product) => (0, exports.ruleProblemsOf)(product).map((problem) => lineOf(target, problem));
 exports.ruleLinesOf = ruleLinesOf;
+/**
+ * Runs only the static rules of `products` - no draw, no tsc - and prints each problem a product's own files hold
+ * that its rule baseline does not list, and each baselined hit; exits 1 on a problem. With `base`, it also flags each app file changed since `base` that moved since its part's implemented record.
+ * Prints one line per rule that did not run; under `CI` a rule skipped for a missing input, such as no `base`, fails.
+ */
+const checkRules = (options) => {
+    var _a, _b;
+    const { target, config, base } = options;
+    const changed = base === undefined ? [] : (0, part_task_1.gitDiffFilesOf)({ root: target, range: base });
+    const invocation = (_a = options.invocation) !== null && _a !== void 0 ? _a : (0, invocation_1.repoInvocation)({ root: target, subcommand: 'design' });
+    const ci = (0, rule_skips_1.isCiEnv)();
+    let failed = 0;
+    const failing = [];
+    for (const name of options.products) {
+        const entry = (_b = config.products) === null || _b === void 0 ? void 0 : _b[name];
+        if (!entry) {
+            console.error(`NO PRODUCT "${name}" in config.json.`);
+            failed++;
+            failing.push(name);
+            continue;
+        }
+        const product = (0, resolve_product_1.resolveProduct)({ target, name, config: entry });
+        const isStatic = (rule) => !(0, slow_checks_1.isSlowRule)(rule) && !render_check_1.BASELINED_RENDER_RULES.has(rule) && rule !== stale_parts_1.UNCOMPARED_RULE;
+        const { result: own, skips } = (0, rule_skips_1.collectingSkips)(() => (0, exports.ruleProblemsOf)(product).filter((problem) => !isInBasePart(product, problem.file)));
+        const baselined = (0, rule_baseline_1.ruleBaselineOf)({ product, problems: own, checked: isStatic });
+        const problems = [
+            ...baselined.problems.filter((problem) => !isInBasePart(product, problem.file)),
+            ...uncomparedOf({ product, changed, invocation }),
+        ];
+        const allSkips = [
+            ...skips,
+            ...(base === undefined
+                ? [{ rule: stale_parts_1.UNCOMPARED_RULE, product: name, kind: 'missing-input', reason: 'no --base given' }]
+                : []),
+        ];
+        const failingSkips = allSkips.filter((skip) => (0, rule_skips_1.isFailingSkip)(skip, ci));
+        [...baselined.lines, ...(0, rule_baseline_1.ruleBaselineLinesOf)(product, (rule) => !isStatic(rule))].forEach((line) => console.log(line));
+        allSkips.filter((skip) => !(0, rule_skips_1.isFailingSkip)(skip, ci)).forEach((skip) => console.log((0, rule_skips_1.skipLineOf)(skip, ci)));
+        problems.forEach((problem) => console.error(lineOf(target, problem)));
+        failingSkips.forEach((skip) => console.error((0, rule_skips_1.skipLineOf)(skip, ci)));
+        failed += problems.length + failingSkips.length;
+        if (problems.length + failingSkips.length > 0)
+            failing.push(name);
+    }
+    console.log(failed === 0 ? 'No static design rule finds a problem.' : `${failed} problem(s) in ${failing.join(', ')}.`);
+    return failed === 0 ? 0 : 1;
+};
+exports.checkRules = checkRules;
+const uncomparedOf = (options) => (options.changed.length > 0 ? (0, stale_parts_1.uncomparedAppProblemsOf)(options) : []).filter((problem) => !isInBasePart(options.product, problem.file));
+/**
+ * The IMPLEMENTATION-UNCOMPARED lines `check --rules --base` prints for `products`, limited to the files in `changed`,
+ * without the other rules, and the uncompared parts they name.
+ */
+const uncomparedLinesOf = (options) => {
+    var _a;
+    const { target, config, changed } = options;
+    const invocation = (_a = options.invocation) !== null && _a !== void 0 ? _a : (0, invocation_1.repoInvocation)({ root: target, subcommand: 'design' });
+    const files = new Set(changed.map((file) => (0, path_1.resolve)(target, file)));
+    return options.products.flatMap((name) => {
+        var _a;
+        const entry = (_a = config.products) === null || _a === void 0 ? void 0 : _a[name];
+        if (!entry)
+            return [];
+        const product = (0, resolve_product_1.resolveProduct)({ target, name, config: entry });
+        const problems = uncomparedOf({ product, changed, invocation, onlyChanged: true }).filter((problem) => files.has((0, path_1.resolve)(target, problem.file)));
+        const parts = [...new Set(problems.flatMap((problem) => (problem.part ? [problem.part] : [])))].sort();
+        return problems.length > 0
+            ? [{ product: name, lines: problems.map((problem) => lineOf(target, problem)), parts }]
+            : [];
+    });
+};
+exports.uncomparedLinesOf = uncomparedLinesOf;
 /** Every problem the rules find in a resolved product, its resolution problems first. */
 const ruleProblemsOf = (product) => [
     ...product.problems,
     ...RULES.flatMap((rule) => rule(product)),
 ];
 exports.ruleProblemsOf = ruleProblemsOf;
+/** Build-ready inputs from the open points of `points`, read without a draw by default, and the static rules. */
+const buildReadyInputsOf = (product, points = (0, read_open_points_1.readOpenPoints)(product)) => {
+    const problems = (0, exports.ruleProblemsOf)(product);
+    return {
+        pointsOf: (part) => (0, read_open_points_1.partPointsOf)(points, part),
+        problemsOf: (part) => problems.filter((problem) => (0, resolve_product_1.partOfFile)(product, problem.file) === part),
+    };
+};
+exports.buildReadyInputsOf = buildReadyInputsOf;
+const withTalliedProblems = (inputs, tally) => (Object.assign(Object.assign({}, inputs), { problemsOf: (part) => {
+        var _a, _b;
+        const own = inputs.problemsOf(part);
+        const ruled = new Set(own.map((problem) => problem.rule));
+        const tallied = [...new Set((_b = (_a = tally === null || tally === void 0 ? void 0 : tally.get(part)) === null || _a === void 0 ? void 0 : _a.problems) !== null && _b !== void 0 ? _b : [])].filter((rule) => !ruled.has(rule));
+        return [...own, ...tallied.map((rule) => ({ rule, file: '', message: 'found by design check' }))];
+    } }));
 const lineOf = (target, problem) => `${problem.rule} ${(0, path_1.relative)(target, problem.file)}: ${problem.message}`;
+const PRODUCT_LEVEL = resolve_product_1.PRODUCT_PART_KEY;
+const APP_CODE = 'app code:';
+/** The tally key of `file`: its part, `(product)` for a design file outside every part, or `app code:<file>` for app code. */
+const tallyKeyOf = (target, { product, file }) => {
+    var _a;
+    const part = (0, resolve_product_1.partOfFile)(product, file);
+    const inDesign = [product.dir, (_a = product.base) === null || _a === void 0 ? void 0 : _a.dir].some((dir) => dir && !(0, path_1.relative)(dir, file).startsWith('..'));
+    return part !== PRODUCT_LEVEL || inDesign ? part : `${APP_CODE}${(0, path_1.relative)(target, file) || '.'}`;
+};
+const tallyOf = (tally, at) => {
+    var _a, _b;
+    const { product, part } = at;
+    if (!tally)
+        return null;
+    const parts = (_a = tally.get(product)) !== null && _a !== void 0 ? _a : new Map();
+    const entry = (_b = parts.get(part)) !== null && _b !== void 0 ? _b : { problems: [], warnings: 0, open: 0 };
+    tally.set(product, parts);
+    parts.set(part, entry);
+    return entry;
+};
+const countText = (count, noun) => `${count} ${noun}${count === 1 ? '' : 's'}`;
+/**
+ * One line per part with findings, then one line with the count of clean parts; with `only`, one line for that part
+ * even when it is clean.
+ */
+const summaryText = (options) => {
+    var _a, _b, _c;
+    const found = (_a = options.tally.get(options.product)) !== null && _a !== void 0 ? _a : new Map();
+    const keys = options.only ? [options.only] : [...new Set([...options.parts, ...found.keys()])];
+    const lineOf = (key) => {
+        var _a;
+        const entry = found.get(key);
+        const rules = [...new Set((_a = entry === null || entry === void 0 ? void 0 : entry.problems) !== null && _a !== void 0 ? _a : [])].join(', ');
+        const items = [
+            ...((entry === null || entry === void 0 ? void 0 : entry.problems.length) ? [`${countText(entry.problems.length, 'problem')} (${rules})`] : []),
+            ...((entry === null || entry === void 0 ? void 0 : entry.warnings) ? [countText(entry.warnings, 'warning')] : []),
+            ...((entry === null || entry === void 0 ? void 0 : entry.open) ? [countText(entry.open, 'open point')] : []),
+        ];
+        if (items.length === 0)
+            return null;
+        return key.startsWith(APP_CODE)
+            ? `APP CODE ${options.product} ${key.slice(APP_CODE.length)}: ${items.join(', ')}`
+            : `PART ${options.product} ${key}: ${items.join(', ')}`;
+    };
+    const lines = keys.map((key) => ({ key, line: lineOf(key) }));
+    if (options.only)
+        return [(_c = (_b = lines[0]) === null || _b === void 0 ? void 0 : _b.line) !== null && _c !== void 0 ? _c : `PART ${options.product} ${options.only}: clean`];
+    const clean = lines.filter(({ key, line }) => line === null && key !== PRODUCT_LEVEL && !key.startsWith(APP_CODE)).length;
+    return [
+        ...lines.flatMap(({ line }) => (line ? [line] : [])),
+        `PARTS ${options.product}: ${clean} of ${options.parts.length} clean`,
+        ...(options.done === undefined ? [] : [`DONE ${options.product}: ${options.done} of ${options.parts.length}`]),
+    ];
+};
+exports.summaryText = summaryText;
+/** One line per rule with how many problems this run found, zeros included, rules outside `CHECK_RULES` after them. */
+const ruleSummaryText = (tally) => {
+    var _a;
+    const counts = new Map(check_rules_1.CHECK_RULES.map((rule) => [rule, 0]));
+    for (const parts of tally.values())
+        for (const { problems } of parts.values())
+            for (const rule of problems)
+                counts.set(rule, ((_a = counts.get(rule)) !== null && _a !== void 0 ? _a : 0) + 1);
+    return [...counts].map(([rule, n]) => `${rule} ${n}`);
+};
+exports.ruleSummaryText = ruleSummaryText;
 const typecheckOpenSketches = (options) => (0, sketch_1.listSketches)({ productDir: options.product.dir, product: options.product.name }).flatMap((sketch) => typeof sketch === 'string'
     ? []
     : sketch.variants.flatMap((variant) => {
@@ -85,13 +321,39 @@ const typecheckOpenSketches = (options) => (0, sketch_1.listSketches)({ productD
                 },
             ];
     }));
+/**
+ * One SKETCH-BASE-STALE problem, with its printed line, per undiscarded sketch (open or picked) whose base changed since it was drawn or
+ * rebased; with `parts`, only the sketches where one of those parts changed; with `targets`, only the sketches on those targets.
+ */
+const staleSketchBasesOf = (options) => {
+    const { product, invocation, parts, targets } = options;
+    return (0, sketch_1.listSketches)({ productDir: product.dir, product: product.name }).flatMap((sketch) => {
+        var _a;
+        if (typeof sketch === 'string' || ((_a = sketch.decision) === null || _a === void 0 ? void 0 : _a.kind) === 'discard')
+            return [];
+        if (targets && !targets.has(sketch.target))
+            return [];
+        const changed = (0, stale_base_1.staleBaseOf)({ product, sketch });
+        if (!(changed === null || changed === void 0 ? void 0 : changed.length) || (parts && !changed.some((part) => parts.has(part))))
+            return [];
+        const message = `${changed.join(', ')} changed since the sketch was drawn - bring each variant up to date, then run ${invocation} sketch rebase ${sketch.target} --product ${product.name} --by <model id>`;
+        return [
+            {
+                rule: 'SKETCH-BASE-STALE',
+                file: sketch.dir,
+                message,
+                line: `SKETCH-BASE-STALE ${product.name} ${sketch.target}: ${message}`,
+            },
+        ];
+    });
+};
+exports.staleSketchBasesOf = staleSketchBasesOf;
 const warnChangedOutsideSketch = (product) => {
     for (const part of (0, merged_parts_1.changedOutsideSketchOf)(product))
         console.warn(`WARNING ${product.name} ${part} changed outside a sketch - every change to a merged part goes through a sketch, with one variant when there is no choice`);
 };
 const isInBasePart = (product, file) => product.parts.some((part) => part.origin === 'base' && !(0, path_1.relative)((0, path_1.dirname)(part.file), file).startsWith('..'));
 const isBasePartKey = (product, key) => { var _a; return ((_a = product.parts.find((part) => (0, resolve_product_1.partKeyOf)(part) === key)) === null || _a === void 0 ? void 0 : _a.origin) === 'base'; };
-const ownerPartOf = (issue) => { var _a, _b; return (_b = (_a = [...issue.path.matchAll(/\[data-et-part=([^\]]+)\]/gu)].pop()) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : issue.part; };
 const printBaseFindings = (product, rules) => {
     var _a;
     if (rules.length === 0 || !product.base)
@@ -105,49 +367,78 @@ const printBaseFindings = (product, rules) => {
     console.log(`${rules.length} finding${rules.length === 1 ? '' : 's'} in base product ${product.base.name} (${perRule.join(', ')}) - they do not block this product; run et design check --product ${product.base.name} for the base's own`);
 };
 const reportSystem = (options) => {
-    var _a;
+    var _a, _b;
     const { target, config, products } = options;
     const declared = (_a = config.products) !== null && _a !== void 0 ? _a : {};
     let failed = false;
-    const report = (problem) => {
-        var _a, _b;
-        const line = lineOf(target, problem);
-        if ((_a = options.known) === null || _a === void 0 ? void 0 : _a.includes(line)) {
+    const report = (problem, product) => {
+        var _a, _b, _c;
+        const line = (_a = problem.line) !== null && _a !== void 0 ? _a : lineOf(target, problem);
+        if ((_b = options.known) === null || _b === void 0 ? void 0 : _b.includes(line)) {
             console.warn(`NOTE (was there before) ${line}`);
             return;
         }
         console.error(line);
         failed = true;
-        (_b = options.blocking) === null || _b === void 0 ? void 0 : _b.push(problem.rule);
+        (_c = tallyOf(options.tally, {
+            product: product.name,
+            part: tallyKeyOf(target, { product, file: problem.file }),
+        })) === null || _c === void 0 ? void 0 : _c.problems.push(problem.rule);
     };
     for (const name of products) {
         const entry = declared[name];
         if (!entry) {
             console.error(`NO PRODUCT "${name}" - config.json declares ${Object.keys(declared).join(', ') || 'none'}.`);
-            return 1;
+            return { code: 1, fatal: true };
         }
         const product = (0, resolve_product_1.resolveProduct)({ target, name, config: entry });
-        if (options.warn)
+        if (options.part && !product.parts.some((part) => (0, resolve_product_1.partKeyOf)(part) === options.part)) {
+            console.error(`NO PART "${options.part}" in product ${name}.`);
+            return { code: 1, fatal: true };
+        }
+        if (options.warn && !options.part)
             warnChangedOutsideSketch(product);
-        (0, stale_comment_1.goneSketchCommentWarningsOf)(product).forEach((warning) => console.warn(warning));
-        const isOwn = (problem) => !isInBasePart(product, problem.file);
-        const warnings = [...(0, unused_shared_export_1.unusedSharedExportsOf)(product), ...(0, stale_replace_1.staleReplacesOf)(product), ...(0, token_selectors_1.tokenSelectorsOf)(product)];
+        const uncommitted = options.warn ? (0, uncommitted_decisions_1.uncommittedDecisionsWarningOf)(product) : null;
+        if (uncommitted)
+            console.warn(uncommitted);
+        const leftover = options.warn ? (0, leftover_gate_files_1.leftoverGateFilesWarningOf)(product) : null;
+        if (leftover)
+            console.warn(leftover);
+        if (!options.part)
+            (0, stale_comment_1.goneSketchCommentWarningsOf)(product).forEach((warning) => console.warn(warning));
+        const isWanted = (problem) => !options.part || (0, resolve_product_1.partOfFile)(product, problem.file) === options.part;
+        const isOwn = (problem) => !isInBasePart(product, problem.file) && isWanted(problem);
+        const warnings = (0, exports.warningProblemsOf)(product);
         const problems = (0, exports.ruleProblemsOf)(product);
-        warnings.filter(isOwn).forEach((problem) => console.warn(`WARNING ${lineOf(target, problem)}`));
-        problems.filter(isOwn).forEach(report);
-        printBaseFindings(product, problems.filter((problem) => !isOwn(problem)).map((problem) => problem.rule));
+        warnings.filter(isOwn).forEach((problem) => {
+            console.warn(`WARNING ${lineOf(target, problem)}`);
+            const counted = tallyOf(options.tally, {
+                product: name,
+                part: tallyKeyOf(target, { product, file: problem.file }),
+            });
+            if (counted)
+                counted.warnings += 1;
+        });
+        problems.filter(isOwn).forEach((problem) => report(problem, product));
+        if (!options.part)
+            printBaseFindings(product, problems.filter((problem) => !isOwn(problem)).map((problem) => problem.rule));
         (0, system_tsconfig_1.writeEditorTsconfig)({ target, product });
         const result = (0, system_tsconfig_1.typecheckProduct)({ target, product });
         if (result.kind === 'unavailable') {
             console.error(result.message);
-            return 1;
+            return { code: 1, fatal: true };
         }
         if (result.kind === 'failed')
-            report({ rule: 'TYPE-ERROR', file: product.dir, message: `\n${result.output}` });
-        if (options.warn)
-            typecheckOpenSketches({ target, product }).forEach(report);
+            report({ rule: 'TYPE-ERROR', file: product.dir, message: `\n${result.output}` }, product);
+        if (options.warn && !options.part)
+            typecheckOpenSketches({ target, product }).forEach((problem) => report(problem, product));
+        if (options.warn && !options.part)
+            (0, exports.staleSketchBasesOf)({
+                product,
+                invocation: (_b = options.invocation) !== null && _b !== void 0 ? _b : (0, invocation_1.repoInvocation)({ root: target, subcommand: 'design' }),
+            }).forEach((problem) => report(problem, product));
     }
-    return failed ? 1 : 0;
+    return { code: failed ? 1 : 0, fatal: false };
 };
 /**
  * Checks the design system of each named product: the rules, then `tsc --noEmit` over its
@@ -155,24 +446,45 @@ const reportSystem = (options) => {
  * product takes from its base are counted in one line and do not fail it.
  */
 const checkSystem = (options) => {
-    const code = reportSystem(options);
+    const { code } = reportSystem(options);
     if (code === 0)
         console.log('ok');
     return code;
 };
 exports.checkSystem = checkSystem;
-const drawnMissingStatesOf = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    const parts = options.product.parts
-        .filter((part) => part.layer !== 'pages' && part.layer !== 'foundations')
-        .map(resolve_product_1.partKeyOf);
-    const checked = yield (0, complete_1.partsCompletenessOf)(Object.assign(Object.assign({}, options), { parts }));
-    if ('unavailable' in checked) {
-        console.log(`COMPLETE CHECK SKIPPED - ${checked.unavailable}`);
-        return [];
+const cannotDrawLine = (options) => `CANNOT DRAW ${options.product} ${options.line} - et design ready refuses the part until it draws`;
+const countCannotDraw = (options) => {
+    for (const part of (0, drawn_open_points_1.statefulPartsOf)(options.product, options.part ? [options.part] : null)) {
+        console.log(cannotDrawLine({ product: options.product.name, line: `${part}: ${options.why}` }));
+        const counted = tallyOf(options.tally, { product: options.product.name, part });
+        if (counted)
+            counted.open += 1;
+    }
+};
+const drawnFindingsFor = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { product, rendered, busy } = options;
+    const stateful = (0, drawn_open_points_1.statefulPartsOf)(product, options.part ? [options.part] : null);
+    let gaps = null;
+    if (stateful.length > 0) {
+        const checked = yield (0, complete_1.partsCompletenessOf)(Object.assign(Object.assign({}, options), { parts: stateful, cached: true }));
+        if ('unavailable' in checked) {
+            console.log(`COMPLETE CHECK SKIPPED - ${checked.unavailable}`);
+            countCannotDraw(Object.assign(Object.assign({}, options), { why: checked.unavailable }));
+        }
+        else {
+            for (const hint of [...checked.hints.values()].flat())
+                console.log(hint);
+            gaps = checked.gaps;
+        }
     }
-    for (const hint of [...checked.hints.values()].flat())
-        console.log(hint);
-    return (0, read_open_points_1.missingStatesOf)(checked.gaps);
+    const _a = (0, drawn_open_points_1.drawnFindingsFrom)({ product, issues: rendered, busy, gaps, stateful }), { failed } = _a, findings = __rest(_a, ["failed"]);
+    for (const line of failed) {
+        console.log(cannotDrawLine({ product: product.name, line }));
+        const counted = tallyOf(options.tally, { product: product.name, part: line.slice(0, line.indexOf(':')) });
+        if (counted)
+            counted.open += 1;
+    }
+    return findings;
 });
 const printOpenPoints = (options) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
@@ -184,58 +496,325 @@ const printOpenPoints = (options) => __awaiter(void 0, void 0, void 0, function*
         const product = (0, resolve_product_1.resolveProduct)({ target, name, config: entry });
         const findings = rendered === null
             ? {}
-            : {
-                contrasts: (0, read_open_points_1.contrastsOf)(rendered.filter((issue) => issue.product === name && issue.sketch === null)),
-                missingStates: options.complete ? yield drawnMissingStatesOf(Object.assign(Object.assign({}, options), { product })) : undefined,
-            };
-        (0, open_points_1.openPointsText)(name, (0, read_open_points_1.readOpenPoints)(product, findings)).forEach((line) => console.log(line));
-        const ready = (0, part_ready_1.readyPartsOf)(product);
-        if (ready.length > 0)
-            console.log(`READY ${name}: ${ready.join(', ')}`);
+            : yield (0, phase_timing_1.timedPhase)('completeness', () => drawnFindingsFor(Object.assign(Object.assign({}, options), { product, rendered })));
+        yield (0, phase_timing_1.timedPhase)('open-points', () => printProductOpenPoints(Object.assign(Object.assign({}, options), { product, findings })));
     }
 });
-const countsOf = (values) => [...new Set(values)].map((value) => `${value} ${values.filter((other) => other === value).length}`).join(', ');
-const blockedRenderLineOf = (blocking) => `RENDER CHECK NOT RUN - ${blocking.length} problem${blocking.length === 1 ? '' : 's'} above stop it (${countsOf(blocking)}); the open points list no contrasts or missing states until they are fixed`;
-const renderSystem = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    const blocking = [];
-    const code = reportSystem(Object.assign(Object.assign({}, options), { warn: true, blocking }));
-    if (code !== 0) {
-        if (blocking.length > 0)
-            console.error(blockedRenderLineOf(blocking));
-        return { code, rendered: null };
+const printProductOpenPoints = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const { target, config, rendered, product, findings } = options;
+    const name = product.name;
+    if (rendered === null && options.notDrawn)
+        countCannotDraw(Object.assign(Object.assign({}, options), { product, why: options.notDrawn }));
+    const allPoints = (0, read_open_points_1.readOpenPoints)(product, findings);
+    const points = allPoints.filter(({ part }) => !options.part || part === options.part);
+    for (const { part, points: ofPart } of points) {
+        const counted = tallyOf(options.tally, { product: name, part });
+        if (counted)
+            counted.open += ofPart.length;
     }
-    const rendered = yield (0, render_check_1.renderIssuesOf)(Object.assign(Object.assign({}, options), { jobs: options.products.map((product) => ({ product, sketch: null, parts: null })) }));
-    if ('unavailable' in rendered) {
-        console.log(`RENDER CHECK SKIPPED - ${rendered.unavailable}`);
-        return { code: 0, rendered: null };
+    (0, open_points_1.openPointsText)(name, points).forEach((line) => console.log(line));
+    if (!options.part)
+        (0, view_coverage_1.uncoveredViewsText)(name, (0, view_coverage_1.uncoveredViewsOf)(product)).forEach((line) => console.log(line));
+    const unlinked = (0, read_open_points_1.unlinkedPartsOf)(product).filter((part) => !options.part || part === options.part);
+    if (unlinked.length > 0)
+        console.log(`UNLINKED ${name}: ${unlinked.join(', ')}`);
+    (0, read_open_points_1.instantLinesOf)(product, options.part
+        ? [options.part]
+        : product.parts.filter((part) => part.origin !== 'base').map((part) => (0, resolve_product_1.partKeyOf)(part))).forEach((line) => console.log(line));
+    const upgraded = (0, stale_parts_1.upgradeLegacyMarksOf)({ product, only: options.part });
+    if (upgraded.length > 0)
+        console.log(`REHASHED ${name}: ${upgraded.map(({ part, marks }) => `${part} (${marks.join(', ')})`).join(', ')}`);
+    const recorded = yield (0, check_record_1.recordCheckedBuildReady)(Object.assign(Object.assign({ target,
+        config, settle: options.part && rendered !== null ? [options.part] : [], product, parts: options.part
+            ? [options.part]
+            : product.parts.filter((part) => part.origin !== 'base').map((part) => (0, resolve_product_1.partKeyOf)(part)), inputs: withTalliedProblems((0, exports.buildReadyInputsOf)(product, allPoints), (_a = options.tally) === null || _a === void 0 ? void 0 : _a.get(name)) }, (rendered === null
+        ? {}
+        : {
+            actionsOf: (part) => (0, actions_command_1.partActionFailuresOf)(Object.assign({ target, config, product, part }, (options.part ? { onNote: console.log } : {}))),
+            declaredActionsOf: (part) => __awaiter(void 0, void 0, void 0, function* () {
+                const declared = yield (0, action_lost_1.declaredPartActionsOf)({ target, config, product, part, warm: options.warm });
+                if (typeof declared === 'string')
+                    console.log(`ACTIONS NOT RECORDED ${name} ${part}: ${declared}`);
+                return declared;
+            }),
+        })), (options.part ? { onNoRecord: (line) => console.log(line) } : {})));
+    const waiting = [...recorded.values()].filter((result) => !result.ready && result.blockers.some((blocker) => blocker.kind === 'pending')).length;
+    if (waiting > 0)
+        console.log((0, check_record_1.slowWaitingLineOf)({ product: name, count: waiting }));
+    const ready = (0, part_ready_1.readyPartsOf)(product).filter((key) => !options.part || key === options.part);
+    if (ready.length > 0)
+        console.log(`READY ${name}: ${ready.join(', ')}`);
+    for (const part of ready) {
+        const embedded = (0, part_ready_1.actionsRerunOf)({ product, part });
+        if (embedded.length === 0)
+            continue;
+        console.log((0, embedded_actions_1.actionsRerunLineOf)({ product: name, part, embedded }));
+        const counted = tallyOf(options.tally, { product: name, part });
+        if (counted)
+            counted.open += 1;
+    }
+    (0, stale_parts_1.stalePartsOf)({ product, only: options.part }).forEach((stale) => console.log((0, stale_parts_1.staleLineOf)(name, stale)));
+});
+const notCheckedLineOf = (options) => `NOT CHECKED ${options.product} render rules on ${options.parts} - ${options.why}`;
+const printUndrawn = (issues) => {
+    for (const product of new Set(issues.map((issue) => issue.product))) {
+        const own = issues.filter((issue) => issue.product === product);
+        const parts = [...new Set(own.filter(drawn_open_points_1.isPartUndrawn).map((issue) => issue.part))];
+        const states = [
+            ...new Set(own
+                .filter((issue) => (0, drawn_open_points_1.isStateUndrawn)(issue) && !parts.includes(issue.part))
+                .map((issue) => `${issue.part} state ${issue.state}`)),
+        ];
+        if (parts.length > 0)
+            console.log(notCheckedLineOf({
+                product,
+                parts: `${countText(parts.length, 'part')}: ${parts.join(', ')}`,
+                why: `${parts.length === 1 ? 'it' : 'they'} did not draw, see RENDER above`,
+            }));
+        states.forEach((state) => console.log(notCheckedLineOf({ product, parts: state, why: 'it did not draw, see RENDER above' })));
+    }
+};
+const RENDER_INPUTS_OUTSIDE_PARTS = ['libs/', 'package.json', 'yarn.lock'];
+const oldIssuesOfRun = (options) => {
+    try {
+        return new Set(options.resolved.flatMap((product) => {
+            const root = (0, reachable_files_1.repoRootOf)(product);
+            const parts = product.parts
+                .filter((part) => part.origin !== 'base' && (!options.part || (0, resolve_product_1.partKeyOf)(part) === options.part))
+                .filter((part) => !options.undrawn.has((0, resolve_product_1.partKeyOf)(part)))
+                .map((part) => ({
+                part: (0, resolve_product_1.partKeyOf)(part),
+                inputs: [
+                    ...Object.keys((0, design_hash_1.designHashOf)({ product, part }).files),
+                    `${(0, path_1.relative)(root, (0, path_1.dirname)(part.file)).split(path_1.sep).join('/')}/`,
+                    ...RENDER_INPUTS_OUTSIDE_PARTS,
+                ],
+            }));
+            return [
+                ...(0, base_issues_1.oldRenderIssuesOf)({
+                    root,
+                    file: (0, base_issues_1.baseIssuesFileOf)(product),
+                    parts,
+                    issues: options.issues.filter((issue) => issue.product === product.name),
+                }),
+            ];
+        }));
     }
+    catch (_a) {
+        return new Set();
+    }
+};
+const renderSystem = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { code, fatal } = (0, phase_timing_1.timedPhase)('static', () => reportSystem(Object.assign(Object.assign({}, options), { warn: true })));
+    if (fatal)
+        return { code, rendered: null };
+    const rendered = yield (0, phase_timing_1.timedPhase)('render-inspect', () => (0, render_check_1.renderIssuesOf)(Object.assign(Object.assign({}, options), { cached: true, onProgress: (line) => console.log(line), jobs: options.products.map((product) => ({ product, sketch: null, parts: options.part ? [options.part] : null })) })));
     const resolved = options.products.flatMap((name) => {
         var _a;
         const entry = (_a = options.config.products) === null || _a === void 0 ? void 0 : _a[name];
         return entry ? [(0, resolve_product_1.resolveProduct)({ target: options.target, name, config: entry })] : [];
     });
-    const isInBase = (issue) => resolved.some((product) => product.name === issue.product && isBasePartKey(product, ownerPartOf(issue)));
-    const issues = rendered.issues.filter((issue) => !isInBase(issue));
+    if ('unavailable' in rendered) {
+        const ci = Boolean(process.env['CI']);
+        if (ci)
+            console.log(`RENDER CHECK SKIPPED - ${rendered.unavailable}`);
+        else
+            console.log(`RENDER CHECK FAILED - no usable browser: ${rendered.unavailable}`);
+        for (const product of resolved) {
+            const parts = product.parts
+                .filter((part) => part.origin !== 'base')
+                .map(resolve_product_1.partKeyOf)
+                .filter((key) => !options.part || key === options.part);
+            if (parts.length > 0)
+                console.log(notCheckedLineOf({
+                    product: product.name,
+                    parts: parts.length === 1 ? `1 part: ${parts[0]}` : `all ${parts.length} parts`,
+                    why: rendered.unavailable,
+                }));
+        }
+        return { code: ci ? code : 1, rendered: null, notDrawn: rendered.unavailable };
+    }
+    const isInBase = (issue) => resolved.some((product) => product.name === issue.product && isBasePartKey(product, (0, render_check_1.ownerPartOf)(issue)));
+    const underGo = (0, action_undeclared_1.actionUndeclaredUnderGoOf)({
+        issues: rendered.issues.filter((issue) => !isInBase(issue)),
+        isGo: ({ product, part }) => {
+            const found = resolved.find((candidate) => candidate.name === product);
+            return found !== undefined && (0, part_ready_1.readyMarkOf)({ product: found, part }) !== null;
+        },
+    });
+    const baselined = resolved.map((product) => {
+        const own = underGo.issues.filter((issue) => issue.product === product.name && render_check_1.BASELINED_RENDER_RULES.has(issue.rule));
+        const undrawn = new Set(underGo.issues
+            .filter((issue) => issue.product === product.name && ((0, drawn_open_points_1.isPartUndrawn)(issue) || (0, drawn_open_points_1.isStateUndrawn)(issue)))
+            .map((issue) => issue.part));
+        const problemOf = new Map(own.map((issue) => [(0, rule_baseline_1.renderProblemOf)(product, issue), issue]));
+        const result = (0, rule_baseline_1.ruleBaselineOf)({
+            product,
+            problems: [...problemOf.keys()],
+            checked: (rule, part) => render_check_1.BASELINED_RENDER_RULES.has(rule) && !undrawn.has(part) && (!options.part || part === options.part),
+        });
+        return {
+            product,
+            own,
+            lines: result.lines,
+            failing: result.problems.flatMap((problem) => { var _a; return (_a = problemOf.get(problem)) !== null && _a !== void 0 ? _a : []; }),
+            problems: result.problems.filter((problem) => !problemOf.has(problem)),
+        };
+    });
+    const passed = new Set(baselined.flatMap(({ own, failing }) => own.filter((issue) => !failing.includes(issue))));
+    const issues = underGo.issues.filter((issue) => !passed.has(issue));
+    const baselineProblems = baselined.flatMap(({ product, problems }) => problems.map((problem) => ({ product, problem })));
+    baselined.forEach(({ lines }) => lines.forEach((line) => console.log(line)));
+    baselineProblems.forEach(({ product, problem }) => {
+        var _a;
+        console.error(lineOf(options.target, problem));
+        (_a = tallyOf(options.tally, {
+            product: product.name,
+            part: tallyKeyOf(options.target, { product, file: problem.file }),
+        })) === null || _a === void 0 ? void 0 : _a.problems.push(problem.rule);
+    });
+    underGo.warnings.forEach(({ product, part, line }) => {
+        console.warn(line);
+        const counted = tallyOf(options.tally, { product, part });
+        if (counted)
+            counted.warnings += 1;
+    });
     rendered.warnings
         .filter((issue) => !isInBase(issue))
-        .forEach((issue) => console.warn(`WARNING ${(0, render_check_1.renderIssueLineOf)(issue)}`));
-    issues.forEach((issue) => console.error((0, render_check_1.renderIssueLineOf)(issue)));
-    for (const product of resolved)
-        printBaseFindings(product, rendered.issues.filter((issue) => issue.product === product.name && isInBase(issue)).map((issue) => issue.rule));
-    return { code: issues.length > 0 ? 1 : 0, rendered: issues };
+        .forEach((issue) => {
+        console.warn(`WARNING ${(0, render_check_1.renderIssueLineOf)(issue)}`);
+        const counted = tallyOf(options.tally, { product: issue.product, part: (0, render_check_1.ownerPartOf)(issue) });
+        if (counted)
+            counted.warnings += 1;
+    });
+    const old = oldIssuesOfRun({
+        resolved,
+        part: options.part,
+        issues: rendered.issues.filter((issue) => !isInBase(issue)),
+        undrawn: new Set(issues.filter(drawn_open_points_1.isPartUndrawn).map((issue) => issue.part)),
+    });
+    issues.forEach((issue) => {
+        var _a;
+        console.error(old.has(issue) ? `OLD ${(0, render_check_1.renderIssueLineOf)(issue)}` : (0, render_check_1.renderIssueLineOf)(issue));
+        (_a = tallyOf(options.tally, { product: issue.product, part: (0, render_check_1.ownerPartOf)(issue) })) === null || _a === void 0 ? void 0 : _a.problems.push(issue.rule);
+    });
+    printUndrawn(issues.filter((issue) => (0, drawn_open_points_1.isPartUndrawn)(issue) || (0, drawn_open_points_1.isStateUndrawn)(issue)));
+    if (!options.part)
+        for (const product of resolved)
+            printBaseFindings(product, rendered.issues.filter((issue) => issue.product === product.name && isInBase(issue)).map((issue) => issue.rule));
+    return {
+        code: code !== 0 || issues.length > 0 || baselineProblems.length > 0 ? 1 : 0,
+        rendered: issues,
+        busy: rendered.busy,
+    };
+});
+const checkProductTail = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { tally, name, entry } = options;
+    const resolved = (0, resolve_product_1.resolveProduct)({ target: options.target, name, config: entry });
+    const capabilities = yield (0, capability_place_1.capabilityPlaceOf)(Object.assign(Object.assign({}, options), { product: resolved }));
+    const isWanted = (problem) => !options.part || (0, resolve_product_1.partOfFile)(resolved, problem.file) === options.part;
+    const coverage = yield (0, design_coverage_1.designCoverageOf)(Object.assign(Object.assign({}, options), { product: resolved }));
+    [...capabilities.warnings, ...coverage].filter(isWanted).forEach((warning) => {
+        console.warn(`WARNING ${lineOf(options.target, warning)}`);
+        const counted = tallyOf(tally, {
+            product: name,
+            part: tallyKeyOf(options.target, { product: resolved, file: warning.file }),
+        });
+        if (counted)
+            counted.warnings += 1;
+    });
+    const drawn = (0, rule_baseline_1.ruleBaselineOf)({
+        product: resolved,
+        problems: [
+            ...(yield (0, dropped_props_1.droppedPropProblemsOf)(Object.assign(Object.assign({}, options), { product: resolved }))),
+            ...(yield (0, bespoke_controls_1.bespokeControlProblemsOf)(Object.assign(Object.assign({}, options), { product: resolved }))),
+            ...(yield (0, action_lost_1.actionLostProblemsOf)(Object.assign(Object.assign({}, options), { product: resolved, invocation: (_a = options.invocation) !== null && _a !== void 0 ? _a : (0, invocation_1.repoInvocation)({ root: options.target, subcommand: 'design' }) }))),
+        ].filter(isWanted),
+        checked: (rule, part) => (0, slow_checks_1.isDrawRule)(rule) && (!options.part || part === options.part),
+    });
+    drawn.lines.forEach((line) => console.log(line));
+    const problems = [...drawn.problems, ...capabilities.errors, ...options.problemsOfEdits].filter(isWanted);
+    for (const problem of problems) {
+        console.error(lineOf(options.target, problem));
+        (_b = tallyOf(tally, {
+            product: name,
+            part: tallyKeyOf(options.target, { product: resolved, file: problem.file }),
+        })) === null || _b === void 0 ? void 0 : _b.problems.push(problem.rule);
+    }
+    return problems.length;
 });
 /**
  * Checks as `checkSystem` does, then draws every state in a headless browser and prints one line per
- * render rule a drawing breaks, and warns of each merged part that changed outside a sketch. Without a browser it prints one skip line and passes on the other checks.
- * It then lists the open points of each product's parts, with the contrasts the drawing found and, with `complete`,
- * the missing states of each component part as `design complete` draws them; they do not change the exit code.
+ * render rule a drawing breaks, also when a static rule failed, and warns of each merged part that changed outside a sketch. A part that does not
+ * draw, each state that does not draw, or every part without a browser, gets one `NOT CHECKED` line; without a browser it passes on the other checks.
+ * It then lists the open points of each product's parts, with the contrasts the drawing found and the missing states
+ * of each component part as `design complete` draws them, the blockers `design ready` refuses on; they do not change
+ * the exit code.
  */
 const checkSystemRendered = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    const { code, rendered } = yield renderSystem(options);
-    yield printOpenPoints(Object.assign(Object.assign({}, options), { rendered }));
-    if (code === 0)
+    var _a, _b;
+    const tally = new Map();
+    const counted = Object.assign(Object.assign({}, options), { tally });
+    for (const line of (0, phase_timing_1.timedPhase)('stale-dist', () => (0, stale_dist_1.staleDistWarningsOf)(options)))
+        console.warn(line);
+    const editProblems = new Map();
+    for (const name of options.products) {
+        const entry = (_a = options.config.products) === null || _a === void 0 ? void 0 : _a[name];
+        if (!entry)
+            continue;
+        const product = (0, resolve_product_1.resolveProduct)({ target: options.target, name, config: entry });
+        const refreshed = (0, phase_timing_1.timedPhase)('harness-map', () => (0, harness_map_1.refreshHarnessMap)({ target: options.target, product }));
+        if (typeof refreshed === 'string')
+            console.log(`HARNESS MAP STALE ${name}: ${refreshed}`);
+        if (refreshed === true)
+            console.log(`REGENERATED ${name}: the stale harness map`);
+        const problems = [];
+        const lines = yield (0, phase_timing_1.timedPhase)('auto-accept', () => (0, accepted_pictures_1.autoAcceptOf)(Object.assign(Object.assign({}, options), { product, only: options.part, draw: options.drawPictures, problems })));
+        editProblems.set(name, problems);
+        lines.forEach((line) => console.log(line));
+    }
+    const { code, rendered, busy, notDrawn } = yield renderSystem(counted);
+    yield printOpenPoints(Object.assign(Object.assign({}, counted), { rendered, busy, notDrawn }));
+    let failed = 0;
+    let partsTotal = 0;
+    for (const name of options.products) {
+        const entry = (_b = options.config.products) === null || _b === void 0 ? void 0 : _b[name];
+        if (!entry)
+            continue;
+        failed += yield (0, phase_timing_1.timedPhase)('tail', () => { var _a; return checkProductTail(Object.assign(Object.assign({}, options), { tally, name, entry, problemsOfEdits: (_a = editProblems.get(name)) !== null && _a !== void 0 ? _a : [] })); });
+    }
+    (0, phase_timing_1.timedPhase)('summary', () => {
+        var _a;
+        const staleCli = (0, stale_cli_dist_1.runningCliStaleWarning)();
+        if (staleCli)
+            console.log(staleCli);
+        for (const name of options.products) {
+            const entry = (_a = options.config.products) === null || _a === void 0 ? void 0 : _a[name];
+            if (!entry)
+                continue;
+            const resolved = (0, resolve_product_1.resolveProduct)({ target: options.target, name, config: entry });
+            const parts = resolved.parts.filter((part) => part.origin !== 'base').map(resolve_product_1.partKeyOf);
+            partsTotal += options.part ? parts.filter((key) => key === options.part).length : parts.length;
+            (0, exports.summaryText)({
+                product: name,
+                parts,
+                tally,
+                only: options.part,
+                done: (0, part_task_1.doneParts)({ product: resolved, parts }).length,
+            }).forEach((line) => console.log(line));
+        }
+    });
+    const exit = code !== 0 || failed > 0 ? 1 : 0;
+    if (exit === 0)
         console.log('ok');
-    return code;
+    (0, exports.ruleSummaryText)(tally).forEach((line) => console.log(line));
+    const findings = [...tally.values()]
+        .flatMap((found) => [...found.values()])
+        .reduce((n, e) => n + e.problems.length, 0);
+    console.log(`check complete: ${countText(partsTotal, 'part')}, ${countText(findings, 'finding')}`);
+    return exit;
 });
 exports.checkSystemRendered = checkSystemRendered;
 //# sourceMappingURL=check-system.js.map