@svelte-vitals/vite 0.29.5 → 0.29.7

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

@@ -130,12 +130,8 @@ function isLoopbackOrigin(origin) {
     return false;
   }
 }
-function isLoopbackHost(host) {
-  return host !== void 0 && isLoopbackOrigin(`http://${host}`);
-}
 
 export {
   parseHtmlHead,
-  isLoopbackOrigin,
-  isLoopbackHost
+  isLoopbackOrigin
 };

package/dist/hooks/index.js

@@ -1,7 +1,7 @@
 import {
   isLoopbackOrigin,
   parseHtmlHead
-} from "../chunk-2LDMPITM.js";
+} from "../chunk-EHCC47NO.js";
 
 // src/hooks/handle.ts
 import { DEV } from "esm-env";
@@ -10,17 +10,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,7 +33,9 @@ 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 {
   }
@@ -44,15 +49,25 @@ async function analyzeAndIngest(html, route, origin, rules, config, lastSignatur
     ];
     const images = [{ route, images: imgs.map((img) => ({ ...img, file: route })) }];
     const project = { hasRobotsTxt: true, hasSitemap: true, htmlLang };
-    const { results: ruleResults } = await runRules(rules, { heads: [head], headings, images, project, config });
+    const { results: ruleResults, failedRules } = await runRules(rules, {
+      heads: [head],
+      headings,
+      images,
+      project,
+      config
+    });
     const results = applyRuleSeverities(ruleResults, config);
-    const signature = findingSignature(results, config);
+    const failedRuleIds = failedRules.map((f) => f.id);
+    if (failedRules.length > 0 && globalThis.process?.env?.SVELTE_VITALS_DEBUG) {
+      for (const f of failedRules) warn(formatFailedRuleWarning(f));
+    }
+    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)}`);
     }
   }
 }

package/dist/index.js

@@ -1,8 +1,7 @@
 import {
-  isLoopbackHost,
   isLoopbackOrigin,
   parseHtmlHead
-} from "./chunk-2LDMPITM.js";
+} from "./chunk-EHCC47NO.js";
 
 // src/plugin.ts
 import { existsSync } from "fs";
@@ -13,6 +12,7 @@ import {
   defaultConfig,
   resolveRuleOptions,
   shouldSkipRangeCheck,
+  terminalSafe,
   validateRuleSetting
 } from "@svelte-vitals/core";
 import { findUnknownRuleIds, knownRuleIds, ruleOptionsSpec } from "svelte-vitals";
@@ -24,6 +24,8 @@ import {
   applyRuleSeverities,
   applyOverrides,
   runRules,
+  withFailedRulesOff,
+  formatFailedRuleWarning,
   computeScore,
   summarize,
   hasFailureAtOrAbove,
@@ -216,7 +218,11 @@ async function analyze(prerenderPagesDir, cwd, options, extraProjectFacts, resol
   };
   const kitModules = await collectKitModuleFacts(cwd, project.kitAliases);
   const selected = selectRules(allRules, config);
-  const { results: rawResults, examined } = await runRules(selected, {
+  const {
+    results: rawResults,
+    examined,
+    failedRules
+  } = await runRules(selected, {
     heads,
     headings,
     images,
@@ -227,15 +233,20 @@ async function analyze(prerenderPagesDir, cwd, options, extraProjectFacts, resol
     sourceFiles
   });
   const results = applyOverrides(applyRuleSeverities(rawResults, config), config);
-  const { score } = computeScore(results, config);
-  const summary = summarize(results, config);
-  const failed = hasFailureAtOrAbove(summary, config.failOn);
+  for (const f of failedRules) warnings.push(formatFailedRuleWarning(f));
+  const scoringConfig = withFailedRulesOff(
+    config,
+    failedRules.map((f) => f.id)
+  );
+  const { score } = computeScore(results, scoringConfig);
+  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.`;
-  const consoleReport = formatConsoleReport(results, config, { mode: "rendered / plugin" }) + "\n" + coverageNote + "\n";
+  const consoleReport = formatConsoleReport(results, scoringConfig, { mode: "rendered / plugin" }) + "\n" + coverageNote + "\n";
   const jsonReport = formatJsonReport(
     results,
-    config,
+    scoringConfig,
     { version: readPackageVersion() },
     selected.map((r) => r.id),
     examined
@@ -248,7 +259,7 @@ Scanned ${components.length} component(s) under src/ for Correctness/Security/Ar
     jsonReport,
     routeCount: heads.length,
     failed,
-    failOn: config.failOn,
+    failOn: scoringConfig.failOn,
     warnings
   };
 }
@@ -274,7 +285,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;
@@ -287,12 +302,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(),
@@ -314,7 +331,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) {
@@ -333,7 +350,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");
@@ -344,9 +361,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 {
         }
@@ -368,7 +386,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 {
@@ -378,7 +396,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 {
@@ -422,6 +440,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;
@@ -430,11 +449,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) {
@@ -454,6 +475,9 @@ function createStore() {
     badges() {
       return composeBadges(staticResults, liveByRoute);
     },
+    failedRuleIds() {
+      return [...new Set([...liveFailedByRoute.values()].flat())].sort();
+    },
     sequence() {
       return seq;
     },
@@ -466,28 +490,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,
@@ -495,7 +512,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 {
@@ -550,6 +570,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;
@@ -630,10 +651,10 @@ 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;
@@ -661,22 +682,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();
@@ -687,7 +712,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.5",
+  "version": "0.29.7",
   "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.0",
-    "svelte-vitals": "0.45.0"
+    "@svelte-vitals/core": "0.42.0",
+    "svelte-vitals": "0.46.0"
   },
   "peerDependencies": {
     "@sveltejs/kit": "^2.70.2",