@ethlete/cli 3.0.0-next.25 → 3.0.0-next.27

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

@@ -8,33 +8,79 @@ 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.partOfFile = exports.buildReadyInputsOf = exports.ruleProblemsOf = exports.checkRules = exports.ruleLinesOf = exports.warningProblemsOf = void 0;
 const path_1 = require("path");
+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 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_go_1 = require("./part-go");
+const part_task_1 = require("./part-task");
+const part_ready_1 = require("./part-ready");
+const part_build_ready_1 = require("./part-build-ready");
+const actions_command_1 = require("./actions-command");
+const stale_parts_1 = require("./stale-parts");
+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 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 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 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 view_coverage_1 = require("./rules/view-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 uncommitted_decisions_1 = require("./uncommitted-decisions");
 const RULES = [
     imports_1.importProblemsOf,
     upward_dependency_1.upwardDependenciesOf,
@@ -43,27 +89,162 @@ const RULES = [
     component_copy_1.componentCopiesOf,
     motion_1.scriptedMotionOf,
     motion_1.badMotionsOf,
+    motion_1.badUnreachableOf,
     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,
     utility_css_1.utilityCssOf,
+    orphan_endpoint_1.orphanEndpointProblemsOf,
+    sample_default_1.sampleDefaultProblemsOf,
+    unbound_input_1.unboundInputProblemsOf,
+    glued_interpolation_1.gluedInterpolationsOf,
 ];
+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),
+];
+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; exits 1 on one. */
+const checkRules = (options) => {
+    var _a;
+    const { target, config } = options;
+    let failed = 0;
+    for (const name of options.products) {
+        const entry = (_a = config.products) === null || _a === void 0 ? void 0 : _a[name];
+        if (!entry) {
+            console.error(`NO PRODUCT "${name}" in config.json.`);
+            failed++;
+            continue;
+        }
+        const product = (0, resolve_product_1.resolveProduct)({ target, name, config: entry });
+        const problems = (0, exports.ruleProblemsOf)(product).filter((problem) => !isInBasePart(product, problem.file));
+        problems.forEach((problem) => console.error(lineOf(target, problem)));
+        failed += problems.length;
+    }
+    console.log(failed === 0 ? 'No static design rule finds a problem.' : `${failed} problem(s).`);
+    return failed === 0 ? 0 : 1;
+};
+exports.checkRules = checkRules;
 /** 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, exports.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 = '(product)';
+const APP_CODE = 'app code:';
+/** The key of the part whose folder holds `file`, the innermost one, or `(product)` for a file outside every part. */
+const partOfFile = (product, file) => {
+    var _a, _b;
+    return (_b = (_a = product.parts
+        .map((part) => ({ key: (0, resolve_product_1.partKeyOf)(part), dir: (0, path_1.dirname)(part.file) }))
+        .filter(({ dir }) => !(0, path_1.relative)(dir, file).startsWith('..'))
+        .sort((a, b) => b.dir.length - a.dir.length)[0]) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : PRODUCT_LEVEL;
+};
+exports.partOfFile = partOfFile;
+/** 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, exports.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) => {
@@ -78,82 +259,394 @@ 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 reportSystem = (options) => {
+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 printBaseFindings = (product, rules) => {
     var _a;
+    if (rules.length === 0 || !product.base)
+        return;
+    const counts = new Map();
+    for (const rule of rules)
+        counts.set(rule, ((_a = counts.get(rule)) !== null && _a !== void 0 ? _a : 0) + 1);
+    const perRule = [...counts]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([rule, n]) => `${rule} ${n}`);
+    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, _b;
     const { target, config, products } = options;
     const declared = (_a = config.products) !== null && _a !== void 0 ? _a : {};
     let failed = false;
-    const report = (problem) => {
-        var _a;
-        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;
+        (_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));
-        (0, unused_shared_export_1.unusedSharedExportsOf)(product).forEach((problem) => console.warn(`WARNING ${lineOf(target, problem)}`));
-        (0, stale_replace_1.staleReplacesOf)(product).forEach((problem) => console.warn(`WARNING ${lineOf(target, problem)}`));
-        (0, token_selectors_1.tokenSelectorsOf)(product).forEach((problem) => console.warn(`WARNING ${lineOf(target, problem)}`));
-        (0, exports.ruleProblemsOf)(product).forEach(report);
+        const uncommitted = options.warn ? (0, uncommitted_decisions_1.uncommittedDecisionsWarningOf)(product) : null;
+        if (uncommitted)
+            console.warn(uncommitted);
+        if (!options.part)
+            (0, stale_comment_1.goneSketchCommentWarningsOf)(product).forEach((warning) => console.warn(warning));
+        const isWanted = (problem) => !options.part || (0, exports.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)}`);
+            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
- * generated tsconfig. Prints one line per problem and `ok` when there is none.
+ * generated tsconfig. Prints one line per problem and `ok` when there is none. The problems of a part the
+ * 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 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 }));
+        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;
+        }
+    }
+    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, _b, _c, _d;
+    const { target, config, products, rendered } = options;
+    for (const name of products) {
+        const entry = (_a = config.products) === null || _a === void 0 ? void 0 : _a[name];
+        if (!entry)
+            continue;
+        const product = (0, resolve_product_1.resolveProduct)({ target, name, config: entry });
+        const findings = rendered === null ? {} : yield drawnFindingsFor(Object.assign(Object.assign({}, options), { product, rendered }));
+        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;
+        }
+        (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(', ')}`);
+        yield (0, part_build_ready_1.recordBuildReady)(Object.assign({ 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), (_b = options.tally) === null || _b === void 0 ? void 0 : _b.get(name)) }, (rendered === null
+            ? {}
+            : { actionsOf: (part) => (0, actions_command_1.partActionFailuresOf)({ target, config, product, part }) })));
+        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;
+        }
+        const go = (0, part_go_1.goPartsOf)(product).filter((key) => !options.part || key === options.part);
+        if (go.length > 0)
+            console.log(`GO ${name}: ${go.join(', ')}`);
+        for (const part of go) {
+            const review = (_d = (_c = (0, part_go_1.goMarkOf)({ product, part })) === null || _c === void 0 ? void 0 : _c.review) !== null && _d !== void 0 ? _d : [];
+            if (review.length > 0)
+                console.log((0, accepted_pictures_1.newStatesLineOf)({ product: name, part, states: review }));
+        }
+        (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 renderSystem = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { code, fatal } = reportSystem(Object.assign(Object.assign({}, options), { warn: true }));
+    if (fatal)
+        return { code, rendered: null };
+    const rendered = yield (0, render_check_1.renderIssuesOf)(Object.assign(Object.assign({}, options), { 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 })] : [];
+    });
+    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 { issues } = underGo;
+    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)}`);
+        const counted = tallyOf(options.tally, { product: issue.product, part: (0, render_check_1.ownerPartOf)(issue) });
+        if (counted)
+            counted.warnings += 1;
+    });
+    issues.forEach((issue) => {
+        var _a;
+        console.error((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 ? 1 : 0, rendered: issues, busy: rendered.busy };
+});
 /**
  * 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.
+ * 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 = reportSystem(Object.assign(Object.assign({}, options), { warn: true }));
-    if (code !== 0)
-        return code;
-    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}`);
-    else {
-        rendered.warnings.forEach((issue) => console.warn(`WARNING ${(0, render_check_1.renderIssueLineOf)(issue)}`));
-        rendered.issues.forEach((issue) => console.error((0, render_check_1.renderIssueLineOf)(issue)));
+    var _a, _b, _c, _d, _e, _f;
+    const tally = new Map();
+    const counted = Object.assign(Object.assign({}, options), { tally });
+    for (const line of (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 problems = [];
+        const lines = yield (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));
     }
-    if ('issues' in rendered && rendered.issues.length > 0)
-        return 1;
-    console.log('ok');
-    return 0;
+    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;
+        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, exports.partOfFile)(resolved, problem.file) === options.part;
+        capabilities.warnings.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 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: (_c = options.invocation) !== null && _c !== void 0 ? _c : (0, invocation_1.repoInvocation)({ root: options.target, subcommand: 'design' }) }))),
+            ...capabilities.errors,
+            ...((_d = editProblems.get(name)) !== null && _d !== void 0 ? _d : []),
+        ].filter(isWanted);
+        for (const problem of problems) {
+            console.error(lineOf(options.target, problem));
+            (_e = tallyOf(tally, {
+                product: name,
+                part: tallyKeyOf(options.target, { product: resolved, file: problem.file }),
+            })) === null || _e === void 0 ? void 0 : _e.problems.push(problem.rule);
+        }
+        failed += problems.length;
+    }
+    for (const name of options.products) {
+        const entry = (_f = options.config.products) === null || _f === void 0 ? void 0 : _f[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');
+    (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