tempest-react-sdk 0.31.1 → 0.32.0

package/bin/lib/design/scan.mjs

@@ -0,0 +1,229 @@
+// The rules. Each one answers a question from docs/design — "is this file too
+// big to read whole", "does this component fetch", "is an error being swallowed"
+// — and each one is measured on the mask, never on the raw text.
+import { finding, LIMITS } from "./findings.mjs";
+import { findFunctions, findPropsTypes } from "./functions.mjs";
+import { countCodeLines, lineAt, maskSource } from "./mask.mjs";
+import { isWaived, parseMarkers } from "./markers.mjs";
+
+/** `any` in a type position. `unknown`, `anyOf` and `Company` must not match. */
+const ANY_TYPE = /(?<![\w$])any(?![\w$])/g;
+
+/** A `catch` block whose body is empty once comments are masked away. */
+const EMPTY_CATCH = /catch\s*(?:\([^)]*\))?\s*\{\s*\}/g;
+
+/** `fetch(`/`axios` — transport inside a component file. */
+const TRANSPORT = /\b(?:fetch\s*\(|axios\b)/g;
+
+/**
+ * An inline `style={{ … }}` carrying a literal colour. Matched on the raw source,
+ * not the mask: the colour lives inside a string, and the mask exists to hide
+ * exactly that.
+ */
+const INLINE_STYLE_COLOR = /style\s*=\s*\{\{[^}]*#[0-9a-fA-F]{3,8}\b/g;
+
+/**
+ * Whether a masked slice looks like a type annotation rather than a value.
+ * Filters `[key: string]: any` (a real finding) from `anyOf` and from the string
+ * `"any"` — already masked — while skipping `as any` casts, counted separately.
+ *
+ * @param {string} masked
+ * @param {number} index - Offset of the `any` token.
+ * @returns {boolean}
+ */
+function isTypePosition(masked, index) {
+    const before = masked.slice(Math.max(0, index - 24), index);
+    return /[:<|&(,[]\s*$|\bas\s+$/.test(before);
+}
+
+/**
+ * Analyze one already-read source file.
+ *
+ * @param {object} params
+ * @param {string} params.file - Project-relative path, used verbatim in findings.
+ * @param {string} params.source - Raw contents.
+ * @param {object} [params.limits] - Overrides for {@link LIMITS}.
+ * @returns {{ findings: object[], waivers: Array<{ code: string, reason: string }>,
+ *   codeLines: number }}
+ */
+export function scanFile({ file, source, limits = {} }) {
+    const max = { ...LIMITS, ...limits };
+    const { masked, commentText } = maskSource(source);
+    const markers = parseMarkers(commentText);
+    const isTsx = file.endsWith(".tsx");
+    const isTest = /\.(test|spec)\./.test(file);
+    const findings = [];
+
+    const push = (code, line, message) => {
+        if (isWaived(markers, code)) return;
+        findings.push(finding(code, { file, line, message }));
+    };
+
+    for (const id of markers.unexplained) {
+        findings.push(
+            finding("marker-without-reason", {
+                file,
+                line: 1,
+                message: `@tempest-limits ${id} has no reason — write why the limit does not fit here`,
+            }),
+        );
+    }
+
+    const codeLines = countCodeLines(masked);
+    if (!isTest) {
+        const fileMax = isTsx ? max.componentFileLines : max.moduleFileLines;
+        if (codeLines > fileMax) {
+            push(
+                "file-lines",
+                1,
+                `${codeLines} lines of code (limit ${fileMax}) — extract a sub-component, a hook or a pure function`,
+            );
+        }
+    }
+
+    const propsTypes = findPropsTypes(masked);
+    for (const [name, info] of propsTypes) {
+        if (info.count > max.props) {
+            push(
+                "props-count",
+                info.line,
+                `${name} has ${info.count} props (limit ${max.props}) — likely two components in one`,
+            );
+        }
+    }
+
+    if (!isTest) {
+        for (const fn of findFunctions(masked, { isTsx })) {
+            const bodyMax = fn.kind === "hook" ? max.hookLines : max.functionLines;
+            const code = fn.kind === "hook" ? "hook-lines" : "function-lines";
+            if (fn.bodyLines > bodyMax) {
+                push(
+                    code,
+                    fn.line,
+                    `${fn.name} body is ${fn.bodyLines} lines (limit ${bodyMax}) — ${
+                        fn.kind === "hook"
+                            ? "split into smaller hooks"
+                            : "extract a pure function or a hook"
+                    }`,
+                );
+            }
+            if (fn.exported && fn.params.length > max.params) {
+                push(
+                    "param-count",
+                    fn.line,
+                    `${fn.name} takes ${fn.params.length} parameters (limit ${max.params}) — pass one named object`,
+                );
+            }
+            if (fn.kind === "component" && fn.destructuredProps > max.props) {
+                push(
+                    "props-count",
+                    fn.line,
+                    `${fn.name} destructures ${fn.destructuredProps} props (limit ${max.props}) — likely two components in one`,
+                );
+            }
+        }
+    }
+
+    findings.push(...typeEscapes({ file, source, masked, commentText, markers, isTest }));
+    findings.push(...behaviourRules({ file, source, masked, markers, isTsx, isTest }));
+
+    const waivers = [...markers.reasons].map(([code, reason]) => ({ code, reason }));
+    return { findings: findings.filter(Boolean), waivers, codeLines };
+}
+
+/**
+ * Whether an `eslint-disable` for `no-explicit-any` already covers a line.
+ *
+ * Re-reporting what the author waived through the standard mechanism is the
+ * fastest way to make a tool ignorable, so the existing pragma wins. The
+ * `@tempest-limits` marker exists for the same reason at file scope.
+ *
+ * @param {string[]} lines - Raw source lines.
+ * @param {number} line - 1-based line of the `any` token.
+ * @returns {boolean}
+ */
+function hasEslintWaiver(lines, line) {
+    const own = lines[line - 1] ?? "";
+    const previous = lines[line - 2] ?? "";
+    const pragma = /eslint-disable(?:-next-line|-line)?[^\n]*no-explicit-any/;
+    return pragma.test(own) || pragma.test(previous);
+}
+
+/**
+ * `any` and `@ts-ignore` — the two ways to turn the compiler off. Reported in
+ * test files too: a type hole in a test is a test that proves less than it looks.
+ *
+ * @returns {object[]}
+ */
+function typeEscapes({ file, source, masked, commentText, markers, isTest }) {
+    const out = [];
+    if (!isWaived(markers, "explicit-any")) {
+        const lines = source.split("\n");
+        for (const match of masked.matchAll(ANY_TYPE)) {
+            if (!isTypePosition(masked, match.index)) continue;
+            const line = lineAt(masked, match.index);
+            if (hasEslintWaiver(lines, line)) continue;
+            out.push(
+                finding("explicit-any", {
+                    file,
+                    line,
+                    message: isTest
+                        ? "`any` in a test — the mock proves less than it looks"
+                        : "`any` turns the compiler off — use `unknown` plus validation",
+                    extra: isTest ? { severity: "info" } : {},
+                }),
+            );
+        }
+    }
+    if (!isWaived(markers, "ts-ignore") && /@ts-(?:ignore|nocheck)/.test(commentText)) {
+        out.push(
+            finding("ts-ignore", {
+                file,
+                line: 1,
+                message: "@ts-ignore hides the error instead of fixing it — narrow the type",
+            }),
+        );
+    }
+    return out;
+}
+
+/**
+ * The three anti-patterns cheap enough to detect reliably: transport in a
+ * component, a swallowed error, and a colour hardcoded in an inline style.
+ *
+ * @returns {object[]}
+ */
+function behaviourRules({ file, source, masked, markers, isTsx, isTest }) {
+    const out = [];
+    const add = (code, index, message, text = masked) => {
+        if (isWaived(markers, code)) return;
+        out.push(finding(code, { file, line: lineAt(text, index), message }));
+    };
+
+    if (isTsx && !isTest) {
+        for (const match of masked.matchAll(TRANSPORT)) {
+            add(
+                "fetch-in-component",
+                match.index,
+                "a component must not call the network — move it to a service and read it with useQuery",
+            );
+            break;
+        }
+    }
+    for (const match of masked.matchAll(EMPTY_CATCH)) {
+        add(
+            "empty-catch",
+            match.index,
+            "empty catch swallows the error — handle it or let it reach the ErrorBoundary",
+        );
+    }
+    for (const match of source.matchAll(INLINE_STYLE_COLOR)) {
+        add(
+            "inline-style-literal",
+            match.index,
+            "hardcoded colour in an inline style — use a --tempest-* token in a CSS Module",
+            source,
+        );
+    }
+    return out;
+}

package/bin/lib/design/scan.test.mjs

@@ -0,0 +1,218 @@
+import { describe, expect, it } from "vitest";
+
+import { scanFile } from "./scan.mjs";
+
+const codes = (result) => result.findings.map((f) => f.code);
+
+const bigComponent = (lines) =>
+    [
+        "export function Big() {",
+        ...Array.from({ length: lines }, (_, i) => `  const v${i} = ${i};`),
+        "  return null;",
+        "}",
+    ].join("\n");
+
+describe("scanFile — size", () => {
+    it("reports a .tsx over the component limit", () => {
+        const result = scanFile({ file: "src/Big.tsx", source: bigComponent(200) });
+        expect(codes(result)).toContain("file-lines");
+    });
+
+    it("uses the larger limit for a .ts module", () => {
+        const source = Array.from({ length: 180 }, (_, i) => `export const v${i} = ${i};`).join(
+            "\n",
+        );
+        expect(codes(scanFile({ file: "src/tokens.ts", source }))).not.toContain("file-lines");
+    });
+
+    it("does not size-check a test file", () => {
+        const result = scanFile({ file: "src/Big.test.tsx", source: bigComponent(200) });
+        expect(codes(result)).not.toContain("file-lines");
+    });
+
+    it("reports a function body over the limit", () => {
+        const result = scanFile({
+            file: "src/util.ts",
+            source: bigComponent(120),
+            limits: { moduleFileLines: 10_000 },
+        });
+        expect(codes(result)).toContain("function-lines");
+    });
+
+    it("gives a hook its own, larger limit", () => {
+        const source = [
+            "export function useThing() {",
+            ...Array.from({ length: 120 }, (_, i) => `  const v${i} = ${i};`),
+            "  return null;",
+            "}",
+        ].join("\n");
+        const result = scanFile({
+            file: "src/use-thing.ts",
+            source,
+            limits: { moduleFileLines: 10_000 },
+        });
+        expect(codes(result)).toContain("hook-lines");
+        expect(codes(result)).not.toContain("function-lines");
+    });
+
+    it("honours a limit override", () => {
+        const source = bigComponent(20);
+        expect(codes(scanFile({ file: "src/A.tsx", source }))).not.toContain("file-lines");
+        expect(
+            codes(scanFile({ file: "src/A.tsx", source, limits: { componentFileLines: 5 } })),
+        ).toContain("file-lines");
+    });
+});
+
+describe("scanFile — shape", () => {
+    it("reports a Props type with too many members", () => {
+        const source = `interface CardProps {\n${Array.from({ length: 9 }, (_, i) => `  p${i}: string;`).join("\n")}\n}`;
+        const result = scanFile({ file: "src/Card.tsx", source });
+        expect(codes(result)).toContain("props-count");
+        expect(result.findings[0].message).toContain("CardProps has 9 props");
+    });
+
+    it("reports a component destructuring too many props", () => {
+        const source =
+            "export function Card({ a, b, c, d, e, f, g, h, className, ...rest }: P) {\n  return null;\n}";
+        expect(codes(scanFile({ file: "src/Card.tsx", source }))).toContain("props-count");
+    });
+
+    it("does not count plumbing towards the props limit", () => {
+        const source =
+            "export function Card({ a, b, c, className, children, style, id, ...rest }: P) {\n  return null;\n}";
+        expect(codes(scanFile({ file: "src/Card.tsx", source }))).not.toContain("props-count");
+    });
+
+    it("reports an exported function with too many parameters", () => {
+        const source = "export function f(a, b, c, d) {\n  return a;\n}";
+        expect(codes(scanFile({ file: "src/f.ts", source }))).toContain("param-count");
+    });
+
+    it("leaves a private helper's parameter list alone", () => {
+        const source = "function inner(a, b, c, d, e) {\n  return a;\n}";
+        expect(codes(scanFile({ file: "src/f.ts", source }))).not.toContain("param-count");
+    });
+});
+
+describe("scanFile — type escapes", () => {
+    it("reports an explicit any", () => {
+        const result = scanFile({
+            file: "src/f.ts",
+            source: "export function f(x: any) {\n  return x;\n}",
+        });
+        expect(codes(result)).toContain("explicit-any");
+    });
+
+    it("reports an as-any cast", () => {
+        expect(codes(scanFile({ file: "src/f.ts", source: "const v = raw as any;" }))).toContain(
+            "explicit-any",
+        );
+    });
+
+    it("does not match a word that merely contains any", () => {
+        const source = "const v: Company = { anyOf: 1 };\nlet u: unknown;";
+        expect(codes(scanFile({ file: "src/f.ts", source }))).not.toContain("explicit-any");
+    });
+
+    it("does not match the word any inside a comment or a string", () => {
+        const source = '// accepts any shape\nconst s = "any";';
+        expect(codes(scanFile({ file: "src/f.ts", source }))).not.toContain("explicit-any");
+    });
+
+    it("respects an existing eslint-disable for no-explicit-any", () => {
+        const source =
+            "// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype K = (...args: any[]) => void;";
+        expect(codes(scanFile({ file: "src/f.ts", source }))).not.toContain("explicit-any");
+    });
+
+    it("downgrades any in a test file to info", () => {
+        const result = scanFile({ file: "src/f.test.ts", source: "const m = {} as any;" });
+        expect(result.findings.find((f) => f.code === "explicit-any").severity).toBe("info");
+    });
+
+    it("reports @ts-ignore once", () => {
+        const source = "// @ts-ignore\nconst v = 1;\n// @ts-ignore\nconst u = 2;";
+        expect(
+            codes(scanFile({ file: "src/f.ts", source })).filter((c) => c === "ts-ignore"),
+        ).toHaveLength(1);
+    });
+});
+
+describe("scanFile — behaviour", () => {
+    it("reports fetch inside a component file", () => {
+        const source = "export function List() {\n  fetch('/api');\n  return null;\n}";
+        expect(codes(scanFile({ file: "src/List.tsx", source }))).toContain("fetch-in-component");
+    });
+
+    it("leaves fetch in a service alone", () => {
+        const source = "export async function list() {\n  return fetch('/api');\n}";
+        expect(codes(scanFile({ file: "src/list.service.ts", source }))).not.toContain(
+            "fetch-in-component",
+        );
+    });
+
+    it("reports an empty catch, comment or not", () => {
+        const bare = "try {\n  go();\n} catch {}";
+        const commented = "try {\n  go();\n} catch (e) {\n  // ignore\n}";
+        expect(codes(scanFile({ file: "src/a.ts", source: bare }))).toContain("empty-catch");
+        expect(codes(scanFile({ file: "src/a.ts", source: commented }))).toContain("empty-catch");
+    });
+
+    it("leaves a catch that does something alone", () => {
+        const source = "try {\n  go();\n} catch (e) {\n  report(e);\n}";
+        expect(codes(scanFile({ file: "src/a.ts", source }))).not.toContain("empty-catch");
+    });
+
+    it("reports a hardcoded colour in an inline style", () => {
+        const source = 'export function A() {\n  return <div style={{ color: "#2563eb" }} />;\n}';
+        expect(codes(scanFile({ file: "src/A.tsx", source }))).toContain("inline-style-literal");
+    });
+});
+
+describe("scanFile — waivers", () => {
+    it("suppresses a waived rule and records the reason", () => {
+        const source = [
+            "/**",
+            " * Cropper.",
+            " *",
+            " * @tempest-limits file-lines — drag, zoom and canvas export share one piece",
+            " * of geometry state.",
+            " */",
+            bigComponent(200),
+        ].join("\n");
+        const result = scanFile({ file: "src/Crop.tsx", source });
+        expect(codes(result)).not.toContain("file-lines");
+        expect(result.waivers).toEqual([
+            { code: "file-lines", reason: expect.stringContaining("geometry state") },
+        ]);
+    });
+
+    it("reports a waiver with no reason", () => {
+        const result = scanFile({
+            file: "src/Crop.tsx",
+            source: `// @tempest-limits file-lines\n${bigComponent(200)}`,
+        });
+        expect(codes(result)).toContain("marker-without-reason");
+        expect(codes(result)).not.toContain("file-lines");
+    });
+});
+
+describe("scanFile — clean input", () => {
+    it("finds nothing in a well-shaped component", () => {
+        const source = [
+            "import { Badge } from 'tempest-react-sdk';",
+            "",
+            "interface RowProps {",
+            "  label: string;",
+            "  tone: 'ok' | 'bad';",
+            "}",
+            "",
+            "/** One row of the orders table. */",
+            "export function Row({ label, tone }: RowProps) {",
+            "  return <Badge variant={tone}>{label}</Badge>;",
+            "}",
+        ].join("\n");
+        expect(scanFile({ file: "src/Row.tsx", source }).findings).toEqual([]);
+    });
+});

package/bin/lib/doctor/doctor.e2e.test.mjs

@@ -37,8 +37,8 @@ function installed(name, version, extra = {}) {
  * that matters most — it decides whether a project "fails" the audit. Only running
  * it the way a user does tests that.
  */
-function doctor() {
-    const result = spawnSync(process.execPath, [CLI, "doctor"], {
+function doctor(...args) {
+    const result = spawnSync(process.execPath, [CLI, "doctor", ...args], {
         cwd: root,
         encoding: "utf8",
         env: { ...process.env, NO_COLOR: "1", FORCE_COLOR: "0" },
@@ -288,3 +288,80 @@ describe("tempest doctor — a project that does use the SDK", () => {
         expect(code).toBe(0);
     });
 });
+
+describe("tempest doctor — design analysis", () => {
+    beforeEach(thirdPartyApp);
+
+    it("reports nothing about design for a well-shaped app", () => {
+        const { out, code } = doctor();
+        expect(out).toContain("Design");
+        expect(out).toContain("no design problems found");
+        expect(code).toBe(0);
+    });
+
+    it("names the file and the line of each finding", () => {
+        write(
+            "src/pages/Bad.tsx",
+            ["export function Bad() {", "  fetch('/api/orders');", "  return null;", "}"].join(
+                "\n",
+            ),
+        );
+        const { out } = doctor();
+        expect(out).toContain("src/pages/Bad.tsx:2");
+        expect(out).toContain("must not call the network");
+    });
+
+    it("warns without failing the audit — the limits are heuristics", () => {
+        write(
+            "src/Big.tsx",
+            [
+                "export function Big() {",
+                ...Array.from({ length: 200 }, (_, i) => `  const v${i} = ${i};`),
+                "  return null;",
+                "}",
+            ].join("\n"),
+        );
+        const { out, code } = doctor();
+        expect(out).toContain("lines of code (limit 150)");
+        expect(code).toBe(0);
+    });
+
+    it("honours a written @tempest-limits waiver and says how many there are", () => {
+        write(
+            "src/Big.tsx",
+            [
+                "/**",
+                " * Cropper.",
+                " *",
+                " * @tempest-limits file-lines — drag, zoom and canvas export share one",
+                " * piece of geometry state.",
+                " */",
+                "export function Big() {",
+                ...Array.from({ length: 200 }, (_, i) => `  const v${i} = ${i};`),
+                "  return null;",
+                "}",
+            ].join("\n"),
+        );
+        const { out } = doctor();
+        expect(out).not.toContain("lines of code (limit 150)");
+        expect(out).toContain("1 limit(s) waived with a written reason");
+    });
+
+    it("reports a waiver that carries no reason", () => {
+        write("src/Big.tsx", "// @tempest-limits file-lines\nexport const a = 1;");
+        expect(doctor().out).toContain("has no reason");
+    });
+
+    it("skips the whole pass with --no-design", () => {
+        write("src/pages/Bad.tsx", "export function Bad() {\n  fetch('/x');\n  return null;\n}");
+        const { out } = doctor("--no-design");
+        expect(out).not.toContain("must not call the network");
+        expect(out).not.toMatch(/^Design$/m);
+    });
+
+    it("skips the CSS pass with --no-css", () => {
+        write("src/app.css", "a { colr: red; }");
+        const { out } = doctor("--no-css");
+        expect(out).not.toMatch(/^Stylesheets$/m);
+    });
+});

package/bin/tempest.mjs

@@ -2,6 +2,7 @@
 // tempest — project CLI shipped inside tempest-react-sdk.
 //
 //   tempest doctor          health-check the current project (à la flutter doctor)
+//                           [--no-css] [--no-design] skip an analysis pass
 //   tempest lint [paths…]    run ESLint (report only)
 //   tempest fix [paths…]     alias imports (../ → @/) + ESLint --fix + Prettier
 //   tempest format [paths…]  Prettier --write
@@ -15,6 +16,7 @@ import { aliasImports } from "./lib/alias/index.mjs";
 import { describeTypeScript, loadTypeScript } from "./lib/alias/typescript.mjs";
 import { readTsconfig } from "./lib/alias/tsconfig.mjs";
 import { analyzeCss, applyCssFixes, applyExtraction, planExtraction } from "./lib/css/index.mjs";
+import { analyzeDesign } from "./lib/design/index.mjs";
 import { checkLucide } from "./lib/doctor/lucide.mjs";
 import { generateRegistry, loadIconTables } from "./lib/icons/generate.mjs";
 import { generate } from "./lib/openapi/generate.mjs";
@@ -319,7 +321,77 @@ function cssChecks(limit = 6) {
     return rows;
 }
 
-function doctor() {
+/**
+ * Doctor rows for the design analysis — the limits and anti-patterns documented
+ * under docs/design.
+ *
+ * Every row is a warning or a note, never a failure: the limits are heuristics
+ * with a written escape hatch (`@tempest-limits <rule> — reason`), and failing the
+ * exit code on a heuristic is how a tool gets silenced. The hard gates stay with
+ * ESLint (`no-explicit-any`) and `tsc --noEmit`.
+ *
+ * Findings are capped per severity for the same reason as the CSS pass: a report
+ * nobody reads to the end hides its own first line. The cap is stated, and the
+ * pointer to the full list goes with it.
+ *
+ * @param {number} [limit] - Findings shown per severity.
+ * @returns {Array<[status: string, label: string, detail?: string]>} Check rows.
+ */
+function designChecks(limit = 6) {
+    let analysis;
+    try {
+        analysis = analyzeDesign({ root: ROOT });
+    } catch (err) {
+        return [["warn", "design analysis failed", String(err?.message ?? err)]];
+    }
+    if (analysis.stats.files === 0) return [];
+
+    const { files, codeLines, medianLines, largest } = analysis.stats;
+    const rows = [["section", "Design"]];
+    rows.push([
+        "info",
+        `${files} source file(s) · ${codeLines} lines of code · median ${medianLines}`,
+        largest ? `largest: ${largest.file} (${largest.lines})` : "",
+    ]);
+    if (analysis.truncated) {
+        rows.push(["info", "file cap reached", "only the first 1200 source files were analyzed"]);
+    }
+
+    let hidden = 0;
+    for (const severity of ["warn", "info"]) {
+        const group = analysis.findings.filter((f) => f.severity === severity);
+        for (const f of group.slice(0, limit)) {
+            rows.push([severity === "warn" ? "warn" : "info", `${f.file}:${f.line}`, f.message]);
+        }
+        hidden += Math.max(0, group.length - limit);
+    }
+    if (hidden > 0) {
+        rows.push([
+            "info",
+            `${hidden} more design finding(s) not shown`,
+            "the limits and the escape hatch are documented at /design/limits/",
+        ]);
+    }
+    if (analysis.findings.length === 0) {
+        rows.push(["ok", "no design problems found"]);
+    }
+    if (analysis.waivers.length > 0) {
+        rows.push([
+            "info",
+            `${analysis.waivers.length} limit(s) waived with a written reason`,
+            "@tempest-limits markers — nothing to do",
+        ]);
+    }
+    return rows;
+}
+
+/**
+ * Health-check the project.
+ *
+ * @param {string[]} [args] - Argv tail. `--no-css` and `--no-design` skip a pass.
+ * @returns {number} Exit code: 1 when a check failed, 0 otherwise.
+ */
+function doctor(args = []) {
     const checks = [];
     const pkg = readJSON(join(ROOT, "package.json"));
 
@@ -666,7 +738,10 @@ function doctor() {
     }
 
     // ── Stylesheets ───────────────────────────────────────────────────────────
-    checks.push(...cssChecks());
+    if (!args.includes("--no-css")) checks.push(...cssChecks());
+
+    // ── Design ────────────────────────────────────────────────────────────────
+    if (!args.includes("--no-design")) checks.push(...designChecks());
 
     // ── Tooling ────────────────────────────────────────────────────────────────
     checks.push(["section", "Tooling"]);
@@ -1250,6 +1325,11 @@ ${c.bold}Commands${c.reset}
   ${c.bold}gen icons${c.reset}         Write a static icon registry from the slugs your source uses
                     (e.g. tempest gen icons --out src/icons.generated.ts --dir src)
 
+${c.bold}doctor options${c.reset}
+  --no-css          Skip the CSS analysis
+  --no-design       Skip the design analysis (file/function size, props count,
+                    \`any\`, transport in a component, swallowed errors)
+
 ${c.bold}fix options${c.reset}
   --dry-run         List every CSS finding and the imports that would be rewritten;
                     write nothing
@@ -1281,7 +1361,7 @@ if (!cmd || cmd === "-h" || cmd === "--help" || cmd === "help") {
 }
 
 const commands = {
-    doctor: () => doctor(),
+    doctor: () => doctor(rest),
     lint: () => lint(rest),
     fix: () => fix(rest),
     format: () => format(rest),

package/dist/imaging/canvas.cjs

@@ -0,0 +1,2 @@
+const e=require("./exceptions.cjs");function t(t,n){let r=Math.max(1,Math.round(t)),i=Math.max(1,Math.round(n));if(typeof OffscreenCanvas<`u`)return new OffscreenCanvas(r,i);if(typeof document<`u`){let e=document.createElement(`canvas`);return e.width=r,e.height=i,e}throw new e.ImagingUnavailableError(`No canvas is available here. This module needs a browser (or a worker with OffscreenCanvas); it does not run under plain Node.`)}function n(t,n){let r=t.getContext(`2d`);if(r===null)throw new e.ImagingUnavailableError(`Could not get a 2-D context from the canvas.`);return r.imageSmoothingEnabled=!0,r.imageSmoothingQuality=`high`,n!==void 0&&(r.fillStyle=n,r.fillRect(0,0,t.width,t.height)),r}function r(e,t,r,i){n(t,i).drawImage(e,r.x,r.y,r.width,r.height)}exports.createSurface=t,exports.drawScaled=r,exports.getContext=n;
+//# sourceMappingURL=canvas.cjs.map

package/dist/imaging/canvas.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas.cjs","names":[],"sources":["../../src/imaging/canvas.ts"],"sourcesContent":["/**\n * The drawing surface, and the one thing everyone gets wrong on it.\n *\n * **JPEG has no alpha.** Encoding a transparent PNG as JPEG paints the\n * transparent pixels black. Filling the surface first is the difference\n * between a photo on a white background and one with a black hole in it.\n *\n * What is *not* here is worth recording. The received wisdom for downscaling\n * on a canvas is to halve repeatedly, because a single `drawImage` into a\n * much smaller box was said to alias. That was implemented here, and then\n * measured: on a 512 px checkerboard reduced to 32 px, the stepwise result\n * and the single high-quality draw were **pixel-identical** (standard\n * deviation 0.0 on both) in Chromium and Firefox — while stepwise cost\n * **39.19 ms against 0.13 ms** on a 4000x3000 photo, 300 times more, and\n * allocated three intermediate canvases on a device that may not have the\n * memory. Modern engines honour `imageSmoothingQuality = \"high\"`, which is\n * what this module sets. The halving was deleted rather than kept \"just in\n * case\": unmeasurable benefit at 300x the cost is not insurance, it is\n * ballast.\n */\n\nimport { ImagingUnavailableError } from \"./exceptions\";\n\n/** A canvas this module can draw on, on the main thread or in a worker. */\nexport type Surface = OffscreenCanvas | HTMLCanvasElement;\n\n/** A 2-D context from either surface kind. */\nexport type SurfaceContext = OffscreenCanvasRenderingContext2D | CanvasRenderingContext2D;\n\n/**\n * Create a drawing surface, preferring `OffscreenCanvas`.\n *\n * `OffscreenCanvas` works inside a worker, which is where a PWA wants this\n * running: resizing a 12-megapixel photo on the main thread blocks the UI\n * for tens of milliseconds per image.\n *\n * @param width Surface width in pixels.\n * @param height Surface height in pixels.\n * @returns The surface.\n * @throws {@link ImagingUnavailableError} when neither kind exists — a\n *   server render, or a test environment without a canvas.\n */\nexport function createSurface(width: number, height: number): Surface {\n    const safeWidth = Math.max(1, Math.round(width));\n    const safeHeight = Math.max(1, Math.round(height));\n\n    if (typeof OffscreenCanvas !== \"undefined\") {\n        return new OffscreenCanvas(safeWidth, safeHeight);\n    }\n    if (typeof document !== \"undefined\") {\n        const canvas = document.createElement(\"canvas\");\n        canvas.width = safeWidth;\n        canvas.height = safeHeight;\n        return canvas;\n    }\n    throw new ImagingUnavailableError(\n        \"No canvas is available here. This module needs a browser (or a worker \" +\n            \"with OffscreenCanvas); it does not run under plain Node.\",\n    );\n}\n\n/**\n * Get a 2-D context configured for image work.\n *\n * `imageSmoothingQuality = \"high\"` is the setting that makes a steep\n * downscale average its source pixels instead of sampling them sparsely.\n *\n * @param surface The surface to draw on.\n * @param background Optional fill painted before anything else.\n * @returns The context.\n * @throws {@link ImagingUnavailableError} when the context cannot be created.\n */\nexport function getContext(surface: Surface, background?: string): SurfaceContext {\n    const context = surface.getContext(\"2d\") as SurfaceContext | null;\n    if (context === null) {\n        throw new ImagingUnavailableError(\"Could not get a 2-D context from the canvas.\");\n    }\n    context.imageSmoothingEnabled = true;\n    context.imageSmoothingQuality = \"high\";\n    if (background !== undefined) {\n        context.fillStyle = background;\n        context.fillRect(0, 0, surface.width, surface.height);\n    }\n    return context;\n}\n\n/**\n * Draw a bitmap into a surface with high-quality filtering.\n *\n * @param bitmap The source pixels.\n * @param target Destination surface.\n * @param box Where to draw inside the destination.\n * @param background Fill painted before drawing.\n */\nexport function drawScaled(\n    bitmap: ImageBitmap,\n    target: Surface,\n    box: { x: number; y: number; width: number; height: number },\n    background?: string,\n): void {\n    const context = getContext(target, background);\n    context.drawImage(bitmap, box.x, box.y, box.width, box.height);\n}\n"],"mappings":"oCA0CA,SAAgB,EAAc,EAAe,EAAyB,CAClE,IAAM,EAAY,KAAK,IAAI,EAAG,KAAK,MAAM,CAAK,CAAC,EACzC,EAAa,KAAK,IAAI,EAAG,KAAK,MAAM,CAAM,CAAC,EAEjD,GAAI,OAAO,gBAAoB,IAC3B,OAAO,IAAI,gBAAgB,EAAW,CAAU,EAEpD,GAAI,OAAO,SAAa,IAAa,CACjC,IAAM,EAAS,SAAS,cAAc,QAAQ,EAG9C,MAFA,GAAO,MAAQ,EACf,EAAO,OAAS,EACT,CACX,CACA,MAAM,IAAI,EAAA,wBACN,gIAEJ,CACJ,CAaA,SAAgB,EAAW,EAAkB,EAAqC,CAC9E,IAAM,EAAU,EAAQ,WAAW,IAAI,EACvC,GAAI,IAAY,KACZ,MAAM,IAAI,EAAA,wBAAwB,8CAA8C,EAQpF,MANA,GAAQ,sBAAwB,GAChC,EAAQ,sBAAwB,OAC5B,IAAe,IAAA,KACf,EAAQ,UAAY,EACpB,EAAQ,SAAS,EAAG,EAAG,EAAQ,MAAO,EAAQ,MAAM,GAEjD,CACX,CAUA,SAAgB,EACZ,EACA,EACA,EACA,EACI,CAEJ,EAD2B,EAAQ,CACnC,CAAA,CAAQ,UAAU,EAAQ,EAAI,EAAG,EAAI,EAAG,EAAI,MAAO,EAAI,MAAM,CACjE"}