@higinio/design-mcp 0.1.0

package/dist/cli.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+/**
+ * design-lint — CLI de los validadores puros del MCP (validate_code, validate_motion,
+ * check_slop, checklist_preflight) para correr sobre archivos locales (pre-commit, CI).
+ *
+ * Uso: design-lint --system celeste|nocturna [--lang css|html|js] [--json] <archivos o globs...>
+ *
+ * Exit codes: 0 = sin hallazgos de severidad alta · 1 = hay al menos un hallazgo de
+ * severidad alta (level "error") · 2 = error de uso (argumentos inválidos, sin archivos).
+ *
+ * Excepciones: un comentario `design-lint-ignore: <regla>[, <regla>...]` en la línea
+ * inmediatamente anterior (o en la misma línea) suprime los hallazgos de esas reglas en
+ * esa línea. Los hallazgos a nivel de bloque/archivo (línea 0) no son suprimibles.
+ */
+import { readFileSync, readdirSync, statSync, realpathSync } from "node:fs";
+import { extname, resolve, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadAllSystems } from "./data.js";
+import { resolveToken } from "./tokens.js";
+import { validateCode } from "./validate.js";
+import { auditMotion } from "./motion.js";
+import { checkSlop } from "./slop.js";
+import { checkPreflight } from "./preflight.js";
+const LANG_BY_EXT = {
+    ".css": "css",
+    ".html": "html",
+    ".htm": "html",
+    ".js": "js",
+    ".mjs": "js",
+    ".cjs": "js",
+    ".ts": "js",
+    ".jsx": "js",
+    ".tsx": "js",
+};
+/** Infiere el lenguaje del validador a partir de la extensión del archivo. */
+export function inferLang(file) {
+    return LANG_BY_EXT[extname(file).toLowerCase()] ?? null;
+}
+/** Extrae los `design-lint-ignore: regla[, regla]` por número de línea (base 1). */
+export function collectIgnores(code) {
+    const out = new Map();
+    code.split("\n").forEach((line, i) => {
+        const m = line.match(/design-lint-ignore:\s*([a-z0-9-]+(?:\s*,\s*[a-z0-9-]+)*)/i);
+        if (!m)
+            return;
+        const rules = new Set(m[1].split(",").map((r) => r.trim().toLowerCase()).filter(Boolean));
+        out.set(i + 1, rules);
+    });
+    return out;
+}
+function isIgnored(finding, ignores) {
+    if (finding.line <= 0)
+        return false;
+    const rule = finding.rule.toLowerCase();
+    return ignores.get(finding.line - 1)?.has(rule) === true || ignores.get(finding.line)?.has(rule) === true;
+}
+/** Techo de duración del sistema (--duration-page), igual que la tool validate_motion. */
+function pageDurationMs(sys) {
+    const page = resolveToken(sys.aliases, sys.tokenIndex, "--duration-page");
+    return page ? parseInt(page.value, 10) || 320 : 320;
+}
+/**
+ * Corre los cuatro validadores puros sobre un fragmento de código y aplica las
+ * excepciones `design-lint-ignore`. Para `js` solo aplica validate_motion (los otros
+ * tres validadores son de CSS/HTML).
+ */
+export function lintCode(sys, code, lang) {
+    const findings = [];
+    const add = (tool, violations) => {
+        for (const v of violations)
+            findings.push({ ...v, tool });
+    };
+    if (lang === "css" || lang === "html") {
+        add("validate_code", validateCode(sys, code, lang));
+        add("check_slop", checkSlop(code, lang, sys.meta.mode));
+        add("checklist_preflight", checkPreflight(code, lang));
+    }
+    add("validate_motion", auditMotion(code, lang, pageDurationMs(sys)));
+    const ignores = collectIgnores(code);
+    return findings.filter((f) => !isIgnored(f, ignores));
+}
+const MAGIC = /[*?]/;
+function globToRegExp(pattern) {
+    let out = "";
+    let i = 0;
+    while (i < pattern.length) {
+        if (pattern.startsWith("**/", i)) {
+            out += "(?:[^/]+/)*";
+            i += 3;
+        }
+        else if (pattern.startsWith("**", i)) {
+            out += ".*";
+            i += 2;
+        }
+        else if (pattern[i] === "*") {
+            out += "[^/]*";
+            i += 1;
+        }
+        else if (pattern[i] === "?") {
+            out += "[^/]";
+            i += 1;
+        }
+        else {
+            out += pattern[i].replace(/[.+^${}()|[\]\\]/g, "\\$&");
+            i += 1;
+        }
+    }
+    return new RegExp(`^${out}$`);
+}
+function walk(dir, acc) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        if (name === "node_modules" || name === ".git")
+            continue;
+        const full = join(dir, name);
+        try {
+            const st = statSync(full);
+            if (st.isDirectory())
+                walk(full, acc);
+            else
+                acc.push(full);
+        }
+        catch {
+            /* enlaces rotos, permisos: se ignoran */
+        }
+    }
+}
+/** Expande patrones con `*`/`**` (relativos a cwd) y deja pasar rutas literales. */
+export function expandInputs(patterns, cwd = process.cwd()) {
+    const files = [];
+    for (const raw of patterns) {
+        const pattern = raw.replace(/\\/g, "/");
+        if (!MAGIC.test(pattern)) {
+            files.push(resolve(cwd, pattern));
+            continue;
+        }
+        const staticPrefix = pattern.slice(0, pattern.search(MAGIC));
+        const baseRel = staticPrefix.includes("/") ? staticPrefix.slice(0, staticPrefix.lastIndexOf("/")) : "";
+        const base = resolve(cwd, baseRel || ".");
+        const re = globToRegExp(pattern);
+        const all = [];
+        walk(base, all);
+        for (const f of all) {
+            const rel = relative(cwd, f).replace(/\\/g, "/");
+            if (re.test(rel))
+                files.push(f);
+        }
+    }
+    return [...new Set(files)];
+}
+/** Corre los validadores sobre una lista de archivos ya resuelta. */
+export function lintFiles(store, system, files, langOverride) {
+    const sys = store[system];
+    const reports = [];
+    const totals = { error: 0, warn: 0, info: 0 };
+    for (const file of files) {
+        const lang = langOverride ?? inferLang(file);
+        if (!lang)
+            continue; // extensión no soportada: se omite en silencio
+        const code = readFileSync(file, "utf8");
+        const findings = lintCode(sys, code, lang);
+        for (const f of findings)
+            totals[f.level] += 1;
+        reports.push({ file, lang, findings });
+    }
+    return { system, reports, totals, exitCode: totals.error > 0 ? 1 : 0 };
+}
+/** Formatea el resumen como texto agrupado por archivo. */
+export function formatText(summary) {
+    const lines = [];
+    for (const r of summary.reports) {
+        if (r.findings.length === 0)
+            continue;
+        lines.push(`${r.file} (${r.lang}) — ${r.findings.length} hallazgo${r.findings.length === 1 ? "" : "s"}`);
+        for (const f of r.findings) {
+            const where = f.line > 0 ? `L${f.line}` : "—";
+            lines.push(`  ${where}\t${f.level.toUpperCase()}\t${f.rule}\t[${f.tool}]\t${f.message}`);
+            lines.push(`  \tfix: ${f.fix}`);
+        }
+        lines.push("");
+    }
+    const n = summary.reports.length;
+    lines.push(`${summary.totals.error} errores · ${summary.totals.warn} avisos · ${summary.totals.info} infos ` +
+        `en ${n} archivo${n === 1 ? "" : "s"} (sistema: ${summary.system}).`);
+    return lines.join("\n");
+}
+const USAGE = `Uso: design-lint --system celeste|nocturna [--lang css|html|js] [--json] <archivos o globs...>
+
+Corre validate_code, validate_motion, check_slop y checklist_preflight sobre cada archivo.
+El lenguaje se infiere por extensión (.css / .html|.htm / .js|.mjs|.cjs|.ts|.jsx|.tsx) salvo que se pase --lang.
+
+Exit codes: 0 sin hallazgos de severidad alta · 1 hay errores (level "error") · 2 error de uso.
+Excepciones: comentario "design-lint-ignore: <regla>[, <regla>]" en la línea anterior a la infracción.`;
+/** Parsea argv (sin node ni script). Solo parsea; no toca el filesystem. */
+export function parseArgs(argv) {
+    const opts = { json: false, help: false, patterns: [], errors: [] };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--system")
+            opts.system = argv[++i];
+        else if (a === "--lang")
+            opts.lang = argv[++i];
+        else if (a === "--json")
+            opts.json = true;
+        else if (a === "--help" || a === "-h")
+            opts.help = true;
+        else if (a.startsWith("--"))
+            opts.errors.push(`Flag desconocido: ${a}`);
+        else
+            opts.patterns.push(a);
+    }
+    if (!opts.help) {
+        if (!opts.system)
+            opts.errors.push("Falta --system (celeste|nocturna).");
+        else if (opts.system !== "celeste" && opts.system !== "nocturna")
+            opts.errors.push(`Sistema desconocido: ${opts.system} (usa celeste o nocturna).`);
+        if (opts.lang && !["css", "html", "js"].includes(opts.lang))
+            opts.errors.push(`Lenguaje desconocido: ${opts.lang} (usa css, html o js).`);
+        if (opts.patterns.length === 0)
+            opts.errors.push("Indica al menos un archivo o glob.");
+    }
+    return opts;
+}
+function main() {
+    const opts = parseArgs(process.argv.slice(2));
+    if (opts.help) {
+        console.log(USAGE);
+        process.exit(0);
+    }
+    if (opts.errors.length) {
+        for (const e of opts.errors)
+            console.error(`design-lint: ${e}`);
+        console.error(`\n${USAGE}`);
+        process.exit(2);
+    }
+    const files = expandInputs(opts.patterns);
+    if (files.length === 0) {
+        console.error("design-lint: ningún archivo coincide con los patrones dados.");
+        process.exit(2);
+    }
+    let summary;
+    try {
+        summary = lintFiles(loadAllSystems(), opts.system, files, opts.lang);
+    }
+    catch (err) {
+        console.error(`design-lint: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(2);
+    }
+    console.log(opts.json ? JSON.stringify(summary, null, 2) : formatText(summary));
+    process.exit(summary.exitCode);
+}
+function isMainModule() {
+    if (!process.argv[1])
+        return false;
+    try {
+        return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+    }
+    catch {
+        return false;
+    }
+}
+if (isMainModule())
+    main();

package/dist/data.js

@@ -0,0 +1,33 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SYSTEMS, SYSTEM_IDS } from "./systems.js";
+import { parseDtcgTokens, parseCssAliases } from "./tokens.js";
+import { indexMarkdown } from "./doc.js";
+export const ASSETS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "assets");
+const FILE_NAMES = [
+    "tokens.json",
+    "tokens.css",
+    "tailwind.css",
+    "framework.css",
+    "design-doc.md",
+    "styleguide.html",
+];
+export function loadSystem(id, assetsDir = ASSETS_DIR) {
+    const base = join(assetsDir, id);
+    const files = {};
+    for (const name of FILE_NAMES) {
+        files[name] = readFileSync(join(base, name), "utf8");
+    }
+    const tokens = parseDtcgTokens(JSON.parse(files["tokens.json"]));
+    const tokenIndex = new Map(tokens.map((t) => [t.path, t]));
+    const aliases = parseCssAliases(files["tokens.css"]);
+    const sections = indexMarkdown(files["design-doc.md"]);
+    return { meta: SYSTEMS[id], tokens, tokenIndex, aliases, sections, files };
+}
+export function loadAllSystems(assetsDir = ASSETS_DIR) {
+    const out = {};
+    for (const id of SYSTEM_IDS)
+        out[id] = loadSystem(id, assetsDir);
+    return out;
+}

package/dist/doc.js

@@ -0,0 +1,52 @@
+export function slugify(text) {
+    return text
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/\p{Diacritic}/gu, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/** Divide un Markdown en secciones por encabezado ATX. Ignora encabezados dentro de bloques ```. */
+export function indexMarkdown(md) {
+    const lines = md.replace(/\r\n/g, "\n").split("\n");
+    const heads = [];
+    let inFence = false;
+    lines.forEach((line, i) => {
+        if (/^\s*```/.test(line)) {
+            inFence = !inFence;
+            return;
+        }
+        if (inFence)
+            return;
+        const m = line.match(/^(#{1,6})\s+(.*)$/);
+        if (m)
+            heads.push({ level: m[1].length, heading: m[2].trim(), start: i });
+    });
+    return heads.map((h, idx) => {
+        const end = idx + 1 < heads.length ? heads[idx + 1].start : lines.length;
+        const body = lines.slice(h.start + 1, end).join("\n").trim();
+        return { heading: h.heading, level: h.level, slug: slugify(h.heading), body };
+    });
+}
+function isComponentsHeading(text) {
+    return slugify(text).includes("component");
+}
+/** Nombres de componentes: headings nivel 3 tras una sección "Componentes", hasta el siguiente H2. */
+export function listComponents(sections) {
+    const out = [];
+    let inComponents = false;
+    for (const s of sections) {
+        if (s.level <= 2)
+            inComponents = isComponentsHeading(s.heading);
+        else if (inComponents && s.level === 3)
+            out.push(s.heading);
+    }
+    return out;
+}
+/** Devuelve la sección de un componente por slug exacto o por inclusión. */
+export function getComponentSpec(sections, name) {
+    const target = slugify(name);
+    return (sections.find((s) => s.slug === target) ??
+        sections.find((s) => s.slug.includes(target)) ??
+        null);
+}

package/dist/http.js

@@ -0,0 +1,64 @@
+import express from "express";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { buildServer } from "./server.js";
+function jsonRpcError(code, message) {
+    return { jsonrpc: "2.0", error: { code, message }, id: null };
+}
+/** Arranca un servidor HTTP streamable (stateless) para el MCP. Devuelve el http.Server. */
+export function startHttpServer(store, opts) {
+    const app = express();
+    app.use(express.json({ limit: "4mb" }));
+    const host = opts.host ?? "127.0.0.1";
+    app.get("/health", (_req, res) => {
+        res.json({ status: "ok", server: "design-mcp" });
+    });
+    app.post("/mcp", async (req, res) => {
+        // Protección contra DNS rebinding: valida Host/Origin si hay allowlist configurada.
+        if (opts.allowedHosts?.length) {
+            const reqHost = req.headers.host;
+            if (!reqHost || !opts.allowedHosts.includes(reqHost)) {
+                res.status(403).json(jsonRpcError(-32003, "Host no permitido."));
+                return;
+            }
+        }
+        if (opts.allowedOrigins?.length) {
+            const origin = req.headers.origin;
+            if (origin && !opts.allowedOrigins.includes(origin)) {
+                res.status(403).json(jsonRpcError(-32003, "Origin no permitido."));
+                return;
+            }
+        }
+        // Auth por bearer token (solo si hay token configurado).
+        if (opts.token) {
+            if (req.headers.authorization !== `Bearer ${opts.token}`) {
+                res.status(401).json(jsonRpcError(-32001, "No autorizado: token bearer inválido o ausente."));
+                return;
+            }
+        }
+        // Stateless: un server+transport efímero por request (patrón oficial v1.x).
+        try {
+            const server = buildServer(store);
+            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+            res.on("close", () => {
+                void transport.close();
+                void server.close();
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (err) {
+            if (!res.headersSent) {
+                res.status(500).json(jsonRpcError(-32603, "Error interno del servidor."));
+            }
+        }
+    });
+    const methodNotAllowed = (_req, res) => {
+        res.status(405).json(jsonRpcError(-32000, "Método no permitido: usa POST /mcp."));
+    };
+    app.get("/mcp", methodNotAllowed);
+    app.delete("/mcp", methodNotAllowed);
+    return app.listen(opts.port, host, () => {
+        const mode = opts.token ? "auth: bearer" : "SIN AUTH";
+        console.error(`[design-mcp] HTTP escuchando en ${host}:${opts.port} (POST /mcp · ${mode})`);
+    });
+}

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { buildServer } from "./server.js";
+import { loadAllSystems } from "./data.js";
+import { startHttpServer } from "./http.js";
+const store = loadAllSystems();
+const useHttp = process.env.MCP_TRANSPORT === "http" || !!process.env.PORT;
+function csv(v) {
+    const items = v?.split(",").map((s) => s.trim()).filter(Boolean);
+    return items && items.length ? items : undefined;
+}
+if (useHttp) {
+    const port = Number(process.env.PORT ?? 3000);
+    const token = process.env.MCP_AUTH_TOKEN;
+    const allowNoAuth = process.env.MCP_ALLOW_NO_AUTH === "1";
+    if (!token && !allowNoAuth) {
+        console.error("[design-mcp] ERROR: el modo HTTP requiere MCP_AUTH_TOKEN. " +
+            "Configúralo para exigir 'Authorization: Bearer <token>', " +
+            "o define MCP_ALLOW_NO_AUTH=1 para arrancar sin autenticación (no recomendado).");
+        process.exit(1);
+    }
+    if (!token) {
+        console.error("[design-mcp] ⚠️  Arrancando en HTTP SIN autenticación (MCP_ALLOW_NO_AUTH=1).");
+    }
+    const host = process.env.MCP_BIND ?? "127.0.0.1";
+    startHttpServer(store, {
+        port,
+        host,
+        token,
+        allowedHosts: csv(process.env.MCP_ALLOWED_HOSTS),
+        allowedOrigins: csv(process.env.MCP_ALLOWED_ORIGINS),
+    });
+}
+else {
+    const server = buildServer(store);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[design-mcp] servidor listo (stdio)");
+}

package/dist/motion.js

@@ -0,0 +1,142 @@
+const UTILITY = /\b(dropdown|menu|modal|tooltip|popover|select|overlay)\b/;
+const LOOP_NAME = /(spin|shimmer|skeleton)/;
+const PULSE_NAME = /(pulse|ping|glow|breathe)/;
+function y1OfBezier(s) {
+    const m = s.match(/cubic-bezier\(\s*[-\d.]+\s*,\s*([-\d.]+)/);
+    return m ? parseFloat(m[1]) : null;
+}
+function toMs(n, unit) {
+    return unit === "s" ? n * 1000 : n;
+}
+/** Audita un fragmento de CSS/HTML/JS contra las reglas de motion (§11 del DESIGN.md). */
+export function auditMotion(code, lang, maxMs = 320) {
+    const out = [];
+    const lines = code.split("\n");
+    const lc = code.toLowerCase();
+    lines.forEach((line, i) => {
+        const ln = i + 1;
+        const l = line.toLowerCase();
+        const isMotionLine = /\b(transition|animation)\b/.test(l);
+        if (/transition(-property)?\s*:\s*[^;]*\ball\b/.test(l)) {
+            out.push({ level: "error", rule: "transition-all", line: ln,
+                message: "`transition: all` anima cualquier propiedad, incluidas las costosas.",
+                fix: "Enumera solo lo que cambia: `transition: transform 200ms, opacity 200ms`." });
+        }
+        if (isMotionLine && /\bease-in\b(?!-out)/.test(l)) {
+            out.push({ level: "warn", rule: "ease-in-entrada", line: ln,
+                message: "`ease-in` arranca lento y retrasa el instante que el usuario mira.",
+                fix: "Usa `--ease-out` para entradas; reserva `ease-in` para salidas." });
+        }
+        const transDecl = l.match(/transition(?:-property)?\s*:\s*([^;}]*)/);
+        if (transDecl) {
+            const layoutProps = [...transDecl[1].matchAll(/\b(width|height|top|left|right|bottom|margin|padding|inset)\b/g)].map((m) => m[1]);
+            const hasProgress = /progress/.test(l);
+            const offending = layoutProps.filter((p) => !(p === "width" && hasProgress));
+            if (offending.length) {
+                out.push({ level: "warn", rule: "prop-no-animable", line: ln,
+                    message: "Animar propiedades de layout (width/height/top/left…) provoca reflow.",
+                    fix: "Anima `transform`/`opacity`. Excepciones: width de Progress, grid-template-rows del Accordion." });
+            }
+        }
+        if (/(filter|backdrop-filter)\s*:\s*[^;]*blur\(/.test(l)) {
+            out.push({ level: "warn", rule: "blur-en-motion", line: ln,
+                message: "El blur como recurso visual rompe la regla de fondos planos.",
+                fix: "Quita el blur; usa sombras teñidas de tinta si necesitas profundidad." });
+        }
+        if (isMotionLine && !/\binfinite\b/.test(l) && !LOOP_NAME.test(l)) {
+            for (const d of l.match(/(\d*\.?\d+)\s*(ms|s)\b/g) ?? []) {
+                const m = d.match(/(\d*\.?\d+)\s*(ms|s)/);
+                if (toMs(parseFloat(m[1]), m[2]) > maxMs) {
+                    out.push({ level: "warn", rule: "duracion-excesiva", line: ln,
+                        message: `Duración ${d} supera el techo del sistema (${maxMs}ms) para una interacción.`,
+                        fix: `Recorta a ≤${maxMs}ms; reserva loops solo para carga (spinner, skeleton).` });
+                    break;
+                }
+            }
+        }
+        if (/scale[xyz]?3?d?\(\s*0\s*[,)]/.test(l)) {
+            out.push({ level: "warn", rule: "scale-cero", line: ln,
+                message: "`scale(0)` colapsa el elemento y se siente brusco.",
+                fix: "Arranca en `scale(0.9–0.98)` + `opacity: 0`." });
+        }
+        const y1 = y1OfBezier(l);
+        if (y1 !== null && y1 > 1.6) {
+            out.push({ level: "warn", rule: "overshoot-excesivo", line: ln,
+                message: `Overshoot ${y1} es demasiado marcado para UI sobria.`,
+                fix: "Reduce el rebote (y1 ≤ ~1.4) o usa `--ease-out`." });
+        }
+        if (/@keyframes\s+\w*(pulse|ping|glow|breathe)/i.test(line) ||
+            (/\banimation\b/.test(l) && PULSE_NAME.test(l) && /\binfinite\b/.test(l))) {
+            out.push({ level: "warn", rule: "pulsing", line: ln,
+                message: "Los indicadores que laten (pulse/ping/glow) son ruido de motion genérico.",
+                fix: "Usa un estado estático claro; el spinner solo durante carga real." });
+        }
+    });
+    // Block-level (CSS/HTML): bounce en utilitarios (selector con dropdown/menú/modal/… + overshoot).
+    if (lang !== "js") {
+        // Limitación conocida: esta extracción no maneja llaves anidadas (p. ej. reglas
+        // dentro de @media/@keyframes), así que bloques anidados no se parsean para
+        // bounce-utilitario.
+        for (const b of code.match(/[^{}]*\{[^}]*\}/g) ?? []) {
+            const bl = b.toLowerCase();
+            const sel = bl.slice(0, bl.indexOf("{"));
+            const y = y1OfBezier(bl);
+            const hasSpringAlias = /ease-spring/.test(bl);
+            if (UTILITY.test(sel) && ((y !== null && y > 1) || hasSpringAlias)) {
+                out.push({ level: "warn", rule: "bounce-utilitario", line: 0,
+                    message: "Rebote (spring) en un componente utilitario (dropdown/menú/modal/tooltip).",
+                    fix: "Usa `--ease-out`; el spring se reserva a check y toggle." });
+            }
+        }
+    }
+    // Global aggregates.
+    const blurCount = (lc.match(/blur\(/g) ?? []).length;
+    if (blurCount >= 3) {
+        out.push({ level: "error", rule: "blur-everywhere", line: 0,
+            message: `Hay ${blurCount} usos de blur; el blur no es un recurso de esta marca.`,
+            fix: "Rediseña sin blur (fondos planos)." });
+    }
+    const hoverScale = (code.match(/:hover[^{]*\{[^}]*scale\(/gi) ?? []).length
+        + (lc.match(/whilehover[^}]*scale/g) ?? []).length;
+    if (hoverScale >= 3) {
+        out.push({ level: "info", rule: "hover-scale-en-todo", line: 0,
+            message: `${hoverScale} elementos escalan en hover; se vuelve ruido.`,
+            fix: "Reserva el scale en hover para 1–2 acciones clave." });
+    }
+    // Gating de hover: en touch el tap dispara hovers falsos que se quedan pegados.
+    // Regex a nivel de archivo (no parsea anidamiento): si hay algún :hover que
+    // mueva/eleve y el archivo no contiene ningún @media (hover: hover), se señala.
+    if (lang !== "js") {
+        const hoverConMovimiento = /:hover[^{}]*\{[^}]*(transform\s*:|translate|scale\()/i.test(code);
+        const tieneGating = /@media[^{]*\bhover:\s*hover\b/i.test(code);
+        if (hoverConMovimiento && !tieneGating) {
+            out.push({ level: "info", rule: "hover-sin-gating", line: 0,
+                message: "Hay hover que mueve o eleva (transform/translate/scale) sin gating de puntero; en touch el tap deja el hover pegado.",
+                fix: "Envuelve esos :hover en `@media (hover: hover) and (pointer: fine)`; los hover de solo color/fondo pueden quedar fuera." });
+        }
+    }
+    const stagger = (lc.match(/staggerchildren/g) ?? []).length
+        + (lc.match(/nth-child\([^)]*\)[^{]*\{[^}]*(animation-delay|transition-delay)/g) ?? []).length;
+    if (stagger >= 2) {
+        out.push({ level: "info", rule: "stagger-spam", line: 0,
+            message: "Varias listas con stagger en la misma vista compiten por atención.",
+            fix: "Limita el stagger a una lista por vista (máx. 6 ítems)." });
+    }
+    if ((lc.match(/opacity\s*:\s*0(?!\.?\d)/g) ?? []).length >= 4) {
+        out.push({ level: "info", rule: "uniform-fade", line: 0,
+            message: "Muchas entradas con el mismo fade; el efecto se diluye.",
+            fix: "Varía duración/origen o justifica que compartan entrada." });
+    }
+    const translates = [...lc.matchAll(/translate[xy]?3?d?\([^)]*?(-?\d+)px/g)].map((m) => Math.abs(parseInt(m[1], 10)));
+    if (translates.some((v) => v > 16)) {
+        out.push({ level: "info", rule: "distancia-larga", line: 0,
+            message: "Un desplazamiento de entrada mayor a 16px es largo.",
+            fix: "Usa 4–8px; nada debería volar por la pantalla." });
+    }
+    if (/(@keyframes|\banimation\b)/.test(lc) && !/prefers-reduced-motion/.test(lc)) {
+        out.push({ level: "info", rule: "falta-reduced-motion", line: 0,
+            message: "Hay animación pero no se ve un bloque prefers-reduced-motion.",
+            fix: "Añade el bloque de accesibilidad de §11.5." });
+    }
+    return out;
+}