@svelte-vitals/vite 0.29.6 → 0.30.0

package/README.md

@@ -4,7 +4,7 @@
 
 Vite/SvelteKit plugin for [svelte-vitals](https://github.com/oekazuma/svelte-vitals). Two things in one package:
 
-- **Build-time gate** — piggybacks on `vite build`, parses the **prerendered HTML's `<head>`**, and runs the same rule engine as the CLI (SEO, Performance, Correctness, Security, Architecture) — library-agnostic, because it inspects the real output. Fails the build when findings reach `failOn`.
+- **Build-time gate** — piggybacks on `vite build`, parses the **prerendered HTML** (head metadata, images, headings, landmarks and ids), and runs the same rule engine as the CLI (SEO, Performance, Correctness, Security, Architecture, Accessibility) — library-agnostic, because it inspects the real output. Fails the build when findings reach `failOn`.
 - **Live dev dashboard** — on by default during `vite dev`: a searchable, filterable code-health dashboard at `/__svelte-vitals/`, covering the whole project from startup via static analysis, refined to real rendered values as you browse.
 
 > **ESM-only** (Node 22.13+). Ships ES modules only; `require()` is unsupported by design.

package/dist/{chunk-2LDMPITM.js → chunk-VLQYXCE6.js}

@@ -1,5 +1,6 @@
 // src/providers/rendered/parse-html.ts
 import { parse } from "node-html-parser";
+import { decodeFragmentId, splitTokens, isTopFragment, LANDMARK_ROLES, IDREF_ATTRS } from "@svelte-vitals/core";
 function attrValue(v) {
   return v !== void 0 && v.trim().length > 0 ? "static" : "absent";
 }
@@ -26,6 +27,49 @@ function isClassicScriptType(type) {
   const normalized = type.trim().toLowerCase();
   return normalized === "" || JS_MIME_TYPES.has(normalized);
 }
+var SECTIONING_TAGS = /* @__PURE__ */ new Set(["article", "aside", "main", "nav", "section"]);
+function collectA11y(root) {
+  const landmarks = [];
+  const nestedLandmarks = [];
+  const ids = [];
+  const idRefs = [];
+  const walk = (el, ctx) => {
+    const tag = el.rawTagName?.toLowerCase();
+    const roleAttr = el.getAttribute("role");
+    let landmark;
+    if (roleAttr !== void 0) {
+      const role = splitTokens(roleAttr)[0];
+      landmark = role && LANDMARK_ROLES.has(role) ? role : void 0;
+    } else if (tag === "main") {
+      landmark = "main";
+    } else if ((tag === "header" || tag === "footer") && ctx.sectioning === 0) {
+      landmark = tag === "header" ? "banner" : "contentinfo";
+    }
+    if (landmark) {
+      landmarks.push(landmark);
+      const within = ctx.landmarks.at(-1);
+      if (within) nestedLandmarks.push({ kind: landmark, within });
+    }
+    const id = el.getAttribute("id");
+    if (id && id.trim()) ids.push(id);
+    const href = el.getAttribute("href");
+    if (href && href.startsWith("#") && href.length > 1) {
+      const fragment = decodeFragmentId(href.slice(1));
+      if (!isTopFragment(fragment)) idRefs.push({ id: fragment, attr: "href" });
+    }
+    for (const attr of IDREF_ATTRS) {
+      for (const token of splitTokens(el.getAttribute(attr) ?? void 0)) idRefs.push({ id: token, attr });
+    }
+    if (tag === "template") return;
+    const nextCtx = {
+      sectioning: ctx.sectioning + (SECTIONING_TAGS.has(tag) ? 1 : 0),
+      landmarks: landmark ? [...ctx.landmarks, landmark] : ctx.landmarks
+    };
+    for (const child of el.children) walk(child, nextCtx);
+  };
+  for (const child of root.children) walk(child, { sectioning: 0, landmarks: [] });
+  return { landmarks, nestedLandmarks, ids, idRefs };
+}
 function parseHtmlHead(html) {
   const root = parse(html);
   const head = root.querySelector("head") ?? root;
@@ -118,7 +162,63 @@ function parseHtmlHead(html) {
     hasSrcset: img.hasAttribute("srcset"),
     line: 0
   }));
-  return { tags, htmlLang, headings, images };
+  const a11y = collectA11y(root);
+  return { tags, htmlLang, headings, images, ...a11y };
+}
+
+// src/providers/rendered/collect.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { glob } from "tinyglobby";
+function toOccurrenceMap(keys, file) {
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const key of keys) (out[key] ??= []).push({ file, line: 0 });
+  return out;
+}
+function deriveRouteFromHtmlPath(relPath) {
+  let p = relPath.replace(/\\/g, "/").replace(/\.html$/, "");
+  if (p === "index") return "/";
+  if (p.endsWith("/index")) p = p.slice(0, -"/index".length);
+  return "/" + p;
+}
+async function collectRenderedHeads(prerenderPagesDir) {
+  const files = (await glob("**/*.html", { cwd: prerenderPagesDir })).sort();
+  const parsedFiles = await Promise.all(
+    files.map(async (rel) => ({ rel, parsed: parseHtmlHead(await readFile(join(prerenderPagesDir, rel), "utf8")) }))
+  );
+  const heads = [];
+  const headings = [];
+  const images = [];
+  const a11y = [];
+  let htmlLang = { presence: "none", value: "absent" };
+  for (const { rel, parsed } of parsedFiles) {
+    if (htmlLang.presence === "none" && parsed.htmlLang.presence === "own") htmlLang = parsed.htmlLang;
+    const route = deriveRouteFromHtmlPath(rel);
+    heads.push({
+      route,
+      source: "rendered",
+      tags: parsed.tags,
+      file: rel
+    });
+    headings.push({
+      route,
+      // Rendered mode does not track source lines (line 0 = unknown); file is the HTML path.
+      headings: parsed.headings.map((level) => ({ level, line: 0, file: rel }))
+    });
+    images.push({ route, images: parsed.images.map((img) => ({ ...img, file: rel })) });
+    a11y.push({
+      route,
+      landmarks: toOccurrenceMap(parsed.landmarks, rel),
+      nestedLandmarks: parsed.nestedLandmarks.map((n) => ({ ...n, file: rel, line: 0 })),
+      ids: toOccurrenceMap(parsed.ids, rel),
+      idRefs: parsed.idRefs.map((r) => ({ ...r, file: rel, line: 0 })),
+      idCandidates: [...new Set(parsed.ids)],
+      // The prerendered document IS the closed world: every id/landmark/reference it can ever
+      // have is already in it, unlike source mode which may hit an unresolved component.
+      fullyResolved: true
+    });
+  }
+  return { heads, headings, images, a11y, htmlLang };
 }
 
 // src/loopback.ts
@@ -130,12 +230,10 @@ function isLoopbackOrigin(origin) {
     return false;
   }
 }
-function isLoopbackHost(host) {
-  return host !== void 0 && isLoopbackOrigin(`http://${host}`);
-}
 
 export {
   parseHtmlHead,
-  isLoopbackOrigin,
-  isLoopbackHost
+  toOccurrenceMap,
+  collectRenderedHeads,
+  isLoopbackOrigin
 };

package/dist/hooks/index.js

@@ -1,7 +1,8 @@
 import {
   isLoopbackOrigin,
-  parseHtmlHead
-} from "../chunk-2LDMPITM.js";
+  parseHtmlHead,
+  toOccurrenceMap
+} from "../chunk-VLQYXCE6.js";
 
 // src/hooks/handle.ts
 import { DEV } from "esm-env";
@@ -10,17 +11,20 @@ import {
   applyRuleSeverities,
   defineConfig,
   effectiveSeverity,
+  formatFailedRuleWarning,
   isPenalized,
   runRules,
-  selectRules
+  selectRules,
+  terminalSafe
 } from "@svelte-vitals/core";
 function findingSignature(results, config) {
   return results.filter((r) => isPenalized(r.detection, config.treatDynamicAs)).map((r) => `${r.id}:${effectiveSeverity(r, config)}:${r.detection.presence}:${r.detection.value}`).sort().join("|");
 }
-async function postIngest(origin, route, results) {
+var warn = (line) => console.warn(terminalSafe(line));
+async function postIngest(origin, route, results, failedRuleIds) {
   if (!isLoopbackOrigin(origin)) {
     if (globalThis.process?.env?.SVELTE_VITALS_DEBUG) {
-      console.warn(
+      warn(
         `[svelte-vitals] live UI ingest skipped for non-loopback origin ${origin} \u2014 open the dashboard via localhost`
       );
     }
@@ -30,38 +34,62 @@ async function postIngest(origin, route, results) {
     await fetch(`${origin}/__svelte-vitals/ingest`, {
       method: "POST",
       headers: { "content-type": "application/json" },
-      body: JSON.stringify({ route, results })
+      // failedRuleIds is always sent, empty array included, so a route that recovers from
+      // a previously-crashing rule clears its stale entry on the receiving store.
+      body: JSON.stringify({ route, results, failedRuleIds })
     });
   } catch {
   }
 }
 async function analyzeAndIngest(html, route, origin, rules, config, lastSignature) {
   try {
-    const { tags, htmlLang, headings: levels, images: imgs } = parseHtmlHead(html);
+    const {
+      tags,
+      htmlLang,
+      headings: levels,
+      images: imgs,
+      landmarks,
+      nestedLandmarks,
+      ids,
+      idRefs
+    } = parseHtmlHead(html);
     const head = { route, source: "rendered", tags, file: route };
     const headings = [
       { route, headings: levels.map((level) => ({ level, line: 0, file: route })) }
     ];
     const images = [{ route, images: imgs.map((img) => ({ ...img, file: route })) }];
+    const a11y = [
+      {
+        route,
+        landmarks: toOccurrenceMap(landmarks, route),
+        nestedLandmarks: nestedLandmarks.map((n) => ({ ...n, file: route, line: 0 })),
+        ids: toOccurrenceMap(ids, route),
+        idRefs: idRefs.map((r) => ({ ...r, file: route, line: 0 })),
+        idCandidates: [...new Set(ids)],
+        fullyResolved: true
+      }
+    ];
     const project = { hasRobotsTxt: true, hasSitemap: true, htmlLang };
     const { results: ruleResults, failedRules } = await runRules(rules, {
       heads: [head],
       headings,
       images,
+      a11y,
       project,
       config
     });
     const results = applyRuleSeverities(ruleResults, config);
+    const failedRuleIds = failedRules.map((f) => f.id);
     if (failedRules.length > 0 && globalThis.process?.env?.SVELTE_VITALS_DEBUG) {
-      for (const f of failedRules) console.warn(`[svelte-vitals] rule ${f.id} failed and was skipped: ${f.message}`);
+      for (const f of failedRules) warn(formatFailedRuleWarning(f));
     }
-    const signature = findingSignature(results, config);
+    const signature = `${findingSignature(results, config)}|failed:${[...failedRuleIds].sort().join(",")}`;
     if (lastSignature.get(route) === signature) return;
     lastSignature.set(route, signature);
-    if (globalThis.process?.env?.SVELTE_VITALS_UI) void postIngest(origin, route, results);
+    if (globalThis.process?.env?.SVELTE_VITALS_UI) void postIngest(origin, route, results, failedRuleIds);
   } catch (err) {
     if (globalThis.process?.env?.SVELTE_VITALS_DEBUG) {
-      console.warn("[svelte-vitals] dev analysis failed:", err);
+      warn(`[svelte-vitals] dev analysis failed: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
 }
@@ -78,15 +106,8 @@ function svelteVitalsHandle(options = {}) {
     return resolve(event, {
       transformPageChunk: ({ html, done }) => {
         buffer += html;
-        if (done)
-          void analyzeAndIngest(
-            buffer,
-            event.route.id ?? event.url.pathname,
-            event.url.origin,
-            rules,
-            config,
-            lastSignature
-          );
+        if (done && event.route.id != null)
+          void analyzeAndIngest(buffer, event.route.id, event.url.origin, rules, config, lastSignature);
         return html;
       }
     });

package/dist/index.js

@@ -1,18 +1,18 @@
 import {
-  isLoopbackHost,
-  isLoopbackOrigin,
-  parseHtmlHead
-} from "./chunk-2LDMPITM.js";
+  collectRenderedHeads,
+  isLoopbackOrigin
+} from "./chunk-VLQYXCE6.js";
 
 // src/plugin.ts
 import { existsSync } from "fs";
 import { writeFile, mkdir } from "fs/promises";
-import { join as join4, isAbsolute, dirname, relative as relative3, basename, sep as sep2 } from "path";
+import { join as join3, isAbsolute, dirname, relative as relative3, basename, sep as sep2 } from "path";
 import {
   CATEGORIES as CATEGORIES2,
   defaultConfig,
   resolveRuleOptions,
   shouldSkipRangeCheck,
+  terminalSafe,
   validateRuleSetting
 } from "@svelte-vitals/core";
 import { findUnknownRuleIds, knownRuleIds, ruleOptionsSpec } from "svelte-vitals";
@@ -25,6 +25,7 @@ import {
   applyOverrides,
   runRules,
   withFailedRulesOff,
+  formatFailedRuleWarning,
   computeScore,
   summarize,
   hasFailureAtOrAbove,
@@ -34,47 +35,9 @@ import {
 } from "@svelte-vitals/core";
 import { loadConfigFile } from "svelte-vitals";
 
-// src/providers/rendered/collect.ts
-import { readFile } from "fs/promises";
-import { join } from "path";
-import { glob } from "tinyglobby";
-function deriveRouteFromHtmlPath(relPath) {
-  let p = relPath.replace(/\\/g, "/").replace(/\.html$/, "");
-  if (p === "index") return "/";
-  if (p.endsWith("/index")) p = p.slice(0, -"/index".length);
-  return "/" + p;
-}
-async function collectRenderedHeads(prerenderPagesDir) {
-  const files = (await glob("**/*.html", { cwd: prerenderPagesDir })).sort();
-  const parsedFiles = await Promise.all(
-    files.map(async (rel) => ({ rel, parsed: parseHtmlHead(await readFile(join(prerenderPagesDir, rel), "utf8")) }))
-  );
-  const heads = [];
-  const headings = [];
-  const images = [];
-  let htmlLang = { presence: "none", value: "absent" };
-  for (const { rel, parsed } of parsedFiles) {
-    if (htmlLang.presence === "none" && parsed.htmlLang.presence === "own") htmlLang = parsed.htmlLang;
-    const route = deriveRouteFromHtmlPath(rel);
-    heads.push({
-      route,
-      source: "rendered",
-      tags: parsed.tags,
-      file: rel
-    });
-    headings.push({
-      route,
-      // Rendered mode does not track source lines (line 0 = unknown); file is the HTML path.
-      headings: parsed.headings.map((level) => ({ level, line: 0, file: rel }))
-    });
-    images.push({ route, images: parsed.images.map((img) => ({ ...img, file: rel })) });
-  }
-  return { heads, headings, images, htmlLang };
-}
-
 // src/providers/rendered/project.ts
-import { access, readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
+import { access, readFile } from "fs/promises";
+import { join } from "path";
 import {
   ROBOTS_SOURCE_PATHS,
   SITEMAP_SOURCE_PATHS,
@@ -92,22 +55,22 @@ async function exists(path) {
   }
 }
 async function existsAny(cwd, paths) {
-  const found = await Promise.all(paths.map((p) => exists(join2(cwd, p))));
+  const found = await Promise.all(paths.map((p) => exists(join(cwd, p))));
   return found.some(Boolean);
 }
 async function robotsRefsSitemap(cwd) {
   try {
-    return /^\s*sitemap:/im.test(await readFile2(join2(cwd, "static/robots.txt"), "utf8"));
+    return /^\s*sitemap:/im.test(await readFile(join(cwd, "static/robots.txt"), "utf8"));
   } catch {
     return void 0;
   }
 }
 async function readFirstConfig(cwd, files) {
   for (const file of files) {
-    const path = join2(cwd, file);
+    const path = join(cwd, file);
     if (!await exists(path)) continue;
     try {
-      return { file, source: await readFile2(path, "utf8") };
+      return { file, source: await readFile(path, "utf8") };
     } catch {
       return void 0;
     }
@@ -135,16 +98,16 @@ async function collectRenderedProject(cwd, htmlLang) {
 }
 
 // src/providers/source/components.ts
-import { readFile as readFile3, access as access2 } from "fs/promises";
-import { join as join3 } from "path";
-import { glob as glob2 } from "tinyglobby";
+import { readFile as readFile2, access as access2 } from "fs/promises";
+import { join as join2 } from "path";
+import { glob } from "tinyglobby";
 import {
   collectComponentFacts as collect,
   collectKitModuleFacts as collectKit,
   collectSourceFiles as collectFiles
 } from "@svelte-vitals/core";
 var nodeRuntime = {
-  readFile: (path) => readFile3(path, "utf8"),
+  readFile: (path) => readFile2(path, "utf8"),
   async exists(path) {
     try {
       await access2(path);
@@ -153,8 +116,8 @@ var nodeRuntime = {
       return false;
     }
   },
-  glob: (pattern, cwd) => glob2(pattern, { cwd, dot: false }),
-  join: (...parts) => join3(...parts)
+  glob: (pattern, cwd) => glob(pattern, { cwd, dot: false }),
+  join: (...parts) => join2(...parts)
 };
 function collectComponentFacts(root) {
   return collect(nodeRuntime, root);
@@ -206,7 +169,7 @@ async function resolveConfig(cwd, options) {
 }
 async function analyze(prerenderPagesDir, cwd, options, extraProjectFacts, resolved) {
   const { config, warnings } = resolved ?? await resolveConfig(cwd, options);
-  const [{ heads, headings, images, htmlLang }, components, sourceFiles] = await Promise.all([
+  const [{ heads, headings, images, a11y, htmlLang }, components, sourceFiles] = await Promise.all([
     collectRenderedHeads(prerenderPagesDir),
     collectComponentFacts(cwd),
     collectSourceFiles(cwd)
@@ -225,6 +188,7 @@ async function analyze(prerenderPagesDir, cwd, options, extraProjectFacts, resol
     heads,
     headings,
     images,
+    a11y,
     project,
     components,
     config,
@@ -232,7 +196,7 @@ async function analyze(prerenderPagesDir, cwd, options, extraProjectFacts, resol
     sourceFiles
   });
   const results = applyOverrides(applyRuleSeverities(rawResults, config), config);
-  for (const f of failedRules) warnings.push(`rule ${f.id} failed and was skipped: ${f.message.split("\n")[0]}`);
+  for (const f of failedRules) warnings.push(formatFailedRuleWarning(f));
   const scoringConfig = withFailedRulesOff(
     config,
     failedRules.map((f) => f.id)
@@ -241,7 +205,7 @@ async function analyze(prerenderPagesDir, cwd, options, extraProjectFacts, resol
   const summary = summarize(results, scoringConfig);
   const failed = hasFailureAtOrAbove(summary, scoringConfig.failOn);
   const coverageNote = `Analyzed ${heads.length} prerendered route(s). SSR/dynamic routes are not covered \u2014 run \`npx svelte-vitals\` for those.
-Scanned ${components.length} component(s) under src/ for Correctness/Security/Architecture/Bundle findings.`;
+Scanned ${components.length} component(s) under src/ for Correctness/Security/Architecture/Accessibility/Bundle findings.`;
   const consoleReport = formatConsoleReport(results, scoringConfig, { mode: "rendered / plugin" }) + "\n" + coverageNote + "\n";
   const jsonReport = formatJsonReport(
     results,
@@ -264,7 +228,7 @@ Scanned ${components.length} component(s) under src/ for Correctness/Security/Ar
 }
 
 // src/minify-flag.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { relative } from "path";
 import { findMinifyDisabled } from "@svelte-vitals/core";
 async function resolveMinifyDisabled(minify, configFile, root) {
@@ -274,7 +238,7 @@ async function resolveMinifyDisabled(minify, configFile, root) {
   const file = rel === "" ? configFile.split("\\").join("/") : rel;
   let line;
   try {
-    line = findMinifyDisabled(await readFile4(configFile, "utf8"))?.line;
+    line = findMinifyDisabled(await readFile3(configFile, "utf8"))?.line;
   } catch {
   }
   return { file, ...line !== void 0 ? { line } : {} };
@@ -284,7 +248,11 @@ async function resolveMinifyDisabled(minify, configFile, root) {
 import { CATEGORIES, renderAppShell } from "@svelte-vitals/core";
 
 // src/ui/snapshot.ts
-import { buildJsonReport, safeHref } from "@svelte-vitals/core";
+import {
+  buildJsonReport,
+  safeHref,
+  withFailedRulesOff as withFailedRulesOff2
+} from "@svelte-vitals/core";
 function sanitizeDocsUrl(issue) {
   if (issue.docsUrl === void 0) return issue;
   if (safeHref(issue.docsUrl) !== null) return issue;
@@ -297,12 +265,14 @@ function sanitizeReport(report) {
     siteIssues: report.siteIssues.map(sanitizeDocsUrl)
   };
 }
-function buildSnapshot(store, config, meta) {
+function buildSnapshot(store, config, meta, staticFailedRuleIds) {
+  const failedRuleIds = [.../* @__PURE__ */ new Set([...staticFailedRuleIds ?? [], ...store.failedRuleIds()])];
+  const scoringConfig = withFailedRulesOff2(config, failedRuleIds);
   return {
     // No rule-id list threaded through: `report.rules` is seeded from `store.snapshot()`
     // alone here, so presence means "produced a result", not "was selected" — unlike the
     // `json` reporter (design doc 2026-08-03-json-rule-evidence-design.md, Not in scope).
-    report: sanitizeReport(buildJsonReport(store.snapshot(), config, meta)),
+    report: sanitizeReport(buildJsonReport(store.snapshot(), scoringConfig, meta)),
     badges: store.badges(),
     analyzing: store.isAnalyzing(),
     sequence: store.sequence(),
@@ -324,7 +294,7 @@ function isResultLike(x) {
   const f = r.fix;
   return typeof r.id === "string" && typeof r.message === "string" && typeof r.severity === "string" && SEVERITIES.has(r.severity) && typeof d === "object" && d !== null && typeof d.presence === "string" && typeof d.value === "string" && (r.category === void 0 || typeof r.category === "string" && CATEGORY_SET.has(r.category)) && isOptionalString(r.location) && isOptionalString(r.recommendation) && isOptionalString(r.docsUrl) && (f === void 0 || typeof f === "object" && f !== null && typeof f.description === "string" && isOptionalString(f.snippet) && isOptionalString(f.lang)) && (r.line === void 0 || typeof r.line === "number") && isOptionalString(r.route);
 }
-function installUiMiddleware(server, config, version, store, coreVersion) {
+function installUiMiddleware(server, config, version, store, coreVersion, getStaticFailedRuleIds) {
   const clients = /* @__PURE__ */ new Set();
   store.subscribe(() => {
     for (const res of clients) {
@@ -343,7 +313,7 @@ function installUiMiddleware(server, config, version, store, coreVersion) {
     const url = req.url ?? "/";
     const origin = req.headers.origin;
     const host = req.headers.host;
-    if (typeof origin === "string" && !isLoopbackOrigin(origin) || !isLoopbackHost(host)) {
+    if (typeof origin === "string" && !isLoopbackOrigin(origin) || host === void 0 || !isLoopbackOrigin(`http://${host}`)) {
       req.resume();
       res.statusCode = 403;
       res.end("svelte-vitals dev UI is only available from localhost");
@@ -354,9 +324,10 @@ function installUiMiddleware(server, config, version, store, coreVersion) {
       req.on("data", (c) => chunks.push(c));
       req.on("end", () => {
         try {
-          const { route, results } = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+          const { route, results, failedRuleIds } = JSON.parse(Buffer.concat(chunks).toString("utf8"));
           if (typeof route === "string" && Array.isArray(results)) {
-            store.set(route, results.filter(isResultLike));
+            const failedIds = Array.isArray(failedRuleIds) ? failedRuleIds.filter((id) => typeof id === "string") : [];
+            store.set(route, results.filter(isResultLike), failedIds);
           }
         } catch {
         }
@@ -378,7 +349,7 @@ function installUiMiddleware(server, config, version, store, coreVersion) {
     }
     if (url.startsWith("/data.json")) {
       try {
-        const snapshot = buildSnapshot(store, config, { version, coreVersion });
+        const snapshot = buildSnapshot(store, config, { version, coreVersion }, getStaticFailedRuleIds?.());
         res.setHeader("Content-Type", "application/json");
         res.end(JSON.stringify(snapshot));
       } catch {
@@ -388,7 +359,7 @@ function installUiMiddleware(server, config, version, store, coreVersion) {
       return;
     }
     try {
-      const html = renderAppShell(buildSnapshot(store, config, { version, coreVersion }));
+      const html = renderAppShell(buildSnapshot(store, config, { version, coreVersion }, getStaticFailedRuleIds?.()));
       res.setHeader("Content-Type", "text/html");
       res.end(html);
     } catch {
@@ -432,6 +403,7 @@ function composeBadges(staticResults, liveByRoute) {
 function createStore() {
   let staticResults = [];
   const liveByRoute = /* @__PURE__ */ new Map();
+  const liveFailedByRoute = /* @__PURE__ */ new Map();
   const subs = /* @__PURE__ */ new Set();
   let analyzing = false;
   let seq = 0;
@@ -440,11 +412,13 @@ function createStore() {
     for (const fn of subs) fn();
   }
   return {
-    set(route, results) {
+    set(route, results, failedRuleIds) {
       liveByRoute.set(
         route,
         results.map((r) => r.route ? r : { ...r, route })
       );
+      if (failedRuleIds && failedRuleIds.length > 0) liveFailedByRoute.set(route, failedRuleIds);
+      else liveFailedByRoute.delete(route);
       notify();
     },
     setStatic(results) {
@@ -464,6 +438,9 @@ function createStore() {
     badges() {
       return composeBadges(staticResults, liveByRoute);
     },
+    failedRuleIds() {
+      return [...new Set([...liveFailedByRoute.values()].flat())].sort();
+    },
     sequence() {
       return seq;
     },
@@ -476,28 +453,21 @@ function createStore() {
 
 // src/ui/analysis.ts
 import { relative as relative2, sep } from "path";
+import { analyzeProject } from "svelte-vitals";
 function createAnalysisRunner(opts) {
   const debounceMs = opts.debounceMs ?? 500;
-  let cachedAnalyze = opts.analyze;
+  const analyze2 = opts.analyze ?? analyzeProject;
   const parseCache = /* @__PURE__ */ new Map();
   let stopped = false;
   let running = false;
   let pending = false;
   let timer;
-  async function getAnalyze() {
-    if (cachedAnalyze) return cachedAnalyze;
-    const mod = await import("svelte-vitals");
-    const fn = (o) => mod.analyzeProject(o);
-    cachedAnalyze = fn;
-    return fn;
-  }
   async function runOnce() {
     if (stopped) return;
     running = true;
     opts.onStatusChange?.(true);
     try {
-      const analyze2 = await getAnalyze();
-      const { results } = await analyze2({
+      const { results, failedRuleIds } = await analyze2({
         cwd: opts.root,
         treatDynamicAs: opts.treatDynamicAs,
         metaComponents: opts.metaComponents,
@@ -505,7 +475,10 @@ function createAnalysisRunner(opts) {
         failOn: opts.failOn,
         parseCache
       });
-      if (!stopped) opts.onResults(results);
+      if (!stopped) {
+        if (failedRuleIds !== void 0) opts.onResults(results, failedRuleIds);
+        else opts.onResults(results);
+      }
     } catch (err) {
       if (!stopped) opts.onError(err);
     } finally {
@@ -560,6 +533,7 @@ var CONFIG_BASENAMES = /* @__PURE__ */ new Set([
   "vite.config.cts"
 ]);
 var IGNORED_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", ".svelte-kit", "build", "dist"]);
+var warn = (line) => console.warn(terminalSafe(line));
 function isRelevant(file, root) {
   const rel = relative3(root, file);
   if (rel === "" || rel.startsWith("..")) return false;
@@ -625,8 +599,8 @@ function svelteVitals(options = {}) {
       if (!config.build.ssr) minifyFlag = { minify: config.build.minify, configFile: config.configFile };
     },
     async closeBundle() {
-      const pagesDir = options.prerenderDir ? options.prerenderDir : join4(root, DEFAULT_PRERENDER_DIR);
-      const resolved = isAbsolute(pagesDir) ? pagesDir : join4(root, pagesDir);
+      const pagesDir = options.prerenderDir ? options.prerenderDir : join3(root, DEFAULT_PRERENDER_DIR);
+      const resolved = isAbsolute(pagesDir) ? pagesDir : join3(root, pagesDir);
       if (!existsSync(resolved)) return;
       const resolvedConfig = await resolveConfig(root, options);
       let result;
@@ -640,17 +614,17 @@ function svelteVitals(options = {}) {
           resolvedConfig
         );
       } catch (err) {
-        console.warn(`svelte-vitals: skipped \u2014 analysis failed: ${err instanceof Error ? err.message : String(err)}`);
+        warn(`svelte-vitals: skipped \u2014 analysis failed: ${err instanceof Error ? err.message : String(err)}`);
         return;
       }
-      for (const w of result.warnings) console.warn(`svelte-vitals: ${w}`);
+      for (const w of result.warnings) warn(`svelte-vitals: ${w}`);
       if (result.routeCount === 0) return;
       if (options.report !== false) {
         const out = options.report === "json" ? result.jsonReport : result.consoleReport;
         console.log(out);
       }
       if (options.outFile) {
-        const outPath = isAbsolute(options.outFile) ? options.outFile : join4(root, options.outFile);
+        const outPath = isAbsolute(options.outFile) ? options.outFile : join3(root, options.outFile);
         await mkdir(dirname(outPath), { recursive: true });
         await writeFile(outPath, result.jsonReport);
       }
@@ -671,22 +645,26 @@ function svelteVitals(options = {}) {
       try {
         ({ config, warnings } = await resolveConfig(uiRoot, options));
       } catch (err) {
-        console.warn(
+        warn(
           `svelte-vitals: config file invalid \u2014 dashboard using plugin options/defaults: ${err instanceof Error ? err.message : String(err)}`
         );
         config = mergeConfig(options, void 0);
         warnings = [];
       }
-      for (const w of warnings) console.warn(`svelte-vitals: ${w}`);
+      for (const w of warnings) warn(`svelte-vitals: ${w}`);
       const store = createStore();
+      let staticFailedRuleIds = [];
       const runner = createAnalysisRunner({
         root: uiRoot,
         treatDynamicAs: options.treatDynamicAs,
         metaComponents: options.metaComponents,
         rules: options.rules,
         failOn: options.failOn,
-        onResults: (results) => store.setStatic(results),
-        onError: (err) => console.warn("[svelte-vitals] dev analysis failed:", err),
+        onResults: (results, failedRuleIds) => {
+          store.setStatic(results);
+          staticFailedRuleIds = failedRuleIds ?? [];
+        },
+        onError: (err) => warn(`[svelte-vitals] dev analysis failed: ${err instanceof Error ? err.message : String(err)}`),
         onStatusChange: (analyzing) => store.setAnalyzing(analyzing)
       });
       runner.start();
@@ -697,7 +675,7 @@ function svelteVitals(options = {}) {
         delete process.env.SVELTE_VITALS_UI;
         runner.stop();
       });
-      installUiMiddleware(server, config, readPackageVersion(), store, readCoreVersion());
+      installUiMiddleware(server, config, readPackageVersion(), store, readCoreVersion(), () => staticFailedRuleIds);
       if (typeof server.printUrls === "function") {
         const printUrls = server.printUrls.bind(server);
         server.printUrls = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svelte-vitals/vite",
-  "version": "0.29.6",
+  "version": "0.30.0",
   "description": "Vite/SvelteKit plugin for svelte-vitals — analyzes prerendered HTML during vite build, plus a live dev dashboard.",
   "type": "module",
   "license": "MIT",
@@ -42,8 +42,8 @@
     "esm-env": "^1.2.2",
     "node-html-parser": "^9.0.1",
     "tinyglobby": "^0.2.17",
-    "@svelte-vitals/core": "0.41.1",
-    "svelte-vitals": "0.45.1"
+    "@svelte-vitals/core": "0.43.0",
+    "svelte-vitals": "0.47.0"
   },
   "peerDependencies": {
     "@sveltejs/kit": "^2.70.2",