@svelte-vitals/core 0.33.0 → 0.35.0

package/dist/index.d.ts

@@ -1462,6 +1462,10 @@ interface ScoreResult {
      */
     rawScore: number;
     scoreModel: ScoreModel;
+    /** Keys this result set touched. */
+    keys: number;
+    /** Keys carrying at least one penalized finding. */
+    affectedKeys: number;
 }
 interface ScoreOptions {
     applyCriticalCap?: boolean;
@@ -1471,7 +1475,7 @@ interface ScoreOptions {
 /** Compute the headline score and its breakdown (design §12). */
 declare function computeScore(results: Result[], config: Config, options?: ScoreOptions): ScoreResult;
 /** Compute an independent score per category present in `results` (issue #10). */
-declare function scoresByCategory(results: Result[], config: Config): Partial<Record<Category, ScoreResult>>;
+declare function scoresByCategory(results: Result[], config: Config, options?: ScoreOptions): Partial<Record<Category, ScoreResult>>;
 interface HealthResult {
     /** Weighted overall score across present categories (0–100). */
     health: number;
@@ -1512,15 +1516,26 @@ interface JsonReport {
     categories: Record<string, {
         score: number;
         scoreModel: ScoreModel;
+        keys: number;
+        affectedKeys: number;
     }>;
     summary: Summary;
     rules: Record<string, RuleEvidence>;
     routes: Array<{
         route: string;
         score: number;
+        categories: Record<string, number>;
         issues: JsonIssue[];
     }>;
     siteIssues: JsonIssue[];
+    /**
+     * Floored severity weight per `"<category>::<scope>"` pair. Reproduces a `routes[].categories` entry
+     * (`100 - 100 * failed / inventories[pair]`): a key is either a route id or a source file path, and
+     * those two key spaces never overlap, so a category's results on one key always draw on a single scope.
+     * It does not reproduce `routes[].score`: a route spanning more than one pair sums their *raw* weights
+     * and floors that sum once, so adding this map's already-floored entries and re-dividing can disagree.
+     */
+    inventories: Record<string, number>;
 }
 /** Build the structured JSON report object (design §7). The shape the `json` reporter emits (issue #24). */
 declare function buildJsonReport(results: Result[], config: Config, meta: {

package/dist/index.js

@@ -5823,6 +5823,7 @@ function ruleScopes(rules) {
 
 // src/scoring/score.ts
 var CRITICAL_CAP = 79;
+var INVENTORY_FLOOR = 25;
 function clamp(n) {
   return Math.max(0, Math.min(100, n));
 }
@@ -5848,14 +5849,16 @@ function computeScore(results, config, options = {}) {
     const prev = perRule.get(r.id) ?? 0;
     if (DEDUCTION[sev] > prev) perRule.set(r.id, DEDUCTION[sev]);
   }
+  let affectedKeys = 0;
   let totalDeficit = 0;
   for (const [key, pairs] of observed) {
     let failed = 0;
     for (const d of ruleMax.get(key)?.values() ?? []) failed += d;
+    if (failed > 0) affectedKeys += 1;
     let inventoryWeight = 0;
     for (const p of pairs) inventoryWeight += inventory.get(p) ?? 0;
-    inventoryWeight = Math.max(inventoryWeight, failed);
-    totalDeficit += inventoryWeight === 0 ? 0 : 100 * failed / inventoryWeight;
+    inventoryWeight = Math.max(inventoryWeight, failed, INVENTORY_FLOOR);
+    totalDeficit += 100 * failed / inventoryWeight;
   }
   const keyCount = observed.size;
   const rawRouteAverage = keyCount === 0 ? 100 : 100 - totalDeficit / keyCount;
@@ -5875,9 +5878,15 @@ function computeScore(results, config, options = {}) {
   const capBinds = applyCap && anyCritical && rawUncapped > CRITICAL_CAP;
   const criticalCap = capBinds ? CRITICAL_CAP : null;
   const rawScore = clamp(capBinds ? CRITICAL_CAP : rawUncapped);
-  return { score: Math.floor(rawScore), rawScore, scoreModel: { routeAverage, sitePenalty, criticalCap } };
+  return {
+    score: Math.floor(rawScore),
+    rawScore,
+    scoreModel: { routeAverage, sitePenalty, criticalCap },
+    keys: keyCount,
+    affectedKeys
+  };
 }
-function scoresByCategory(results, config) {
+function scoresByCategory(results, config, options = {}) {
   const byCat = /* @__PURE__ */ new Map();
   for (const r of results) {
     const cat = r.category ?? "seo";
@@ -5886,7 +5895,7 @@ function scoresByCategory(results, config) {
     bucket.push(r);
   }
   const out = {};
-  for (const [cat, rs] of byCat) out[cat] = computeScore(rs, config);
+  for (const [cat, rs] of byCat) out[cat] = computeScore(rs, config, options);
   return out;
 }
 function computeHealth(results, config) {
@@ -6093,7 +6102,10 @@ function buildJsonReport(results, config, meta, ruleIds) {
   const summary = summarize(results, config);
   const rules = ruleEvidence(results, config, ruleIds);
   const categories = Object.fromEntries(
-    Object.entries(byCat).map(([cat, sr]) => [cat, { score: sr.score, scoreModel: sr.scoreModel }])
+    Object.entries(byCat).map(([cat, sr]) => [
+      cat,
+      { score: sr.score, scoreModel: sr.scoreModel, keys: sr.keys, affectedKeys: sr.affectedKeys }
+    ])
   );
   const routeMap = /* @__PURE__ */ new Map();
   for (const r of results) {
@@ -6104,10 +6116,18 @@ function buildJsonReport(results, config, meta, ruleIds) {
   const routes = [...routeMap.values()].sort((a, b) => a.route.localeCompare(b.route)).map(({ route, results: rs }) => ({
     route,
     score: computeScore(rs, config, { applyCriticalCap: false }).score,
+    // Per category, scored against that category's own inventory, so this is not guaranteed to average to
+    // `score` — which is one ratio over the union of the pairs the route touched.
+    categories: Object.fromEntries(
+      Object.entries(scoresByCategory(rs, config, { applyCriticalCap: false })).map(([cat, sr]) => [cat, sr.score])
+    ),
     issues: rs.filter((r) => isPenalized(r.detection, config.treatDynamicAs)).map((r) => ({ ...issueOf(r), severity: effectiveSeverity(r, config) }))
   }));
   const siteIssues = results.filter((r) => r.route === void 0 && isPenalized(r.detection, config.treatDynamicAs)).map((r) => ({ ...issueOf(r), severity: effectiveSeverity(r, config) }));
-  return { version: meta.version, score: health, weights, categories, summary, rules, routes, siteIssues };
+  const inventories = Object.fromEntries(
+    [...buildInventory(config)].map(([pair, weight]) => [pair, Math.max(weight, INVENTORY_FLOOR)])
+  );
+  return { version: meta.version, score: health, weights, categories, summary, rules, routes, siteIssues, inventories };
 }
 function formatJsonReport(results, config, meta, ruleIds) {
   return JSON.stringify(buildJsonReport(results, config, meta, ruleIds), null, 2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svelte-vitals/core",
-  "version": "0.33.0",
+  "version": "0.35.0",
   "description": "Shared, runtime-agnostic core for svelte-vitals (types, rule engine, scorer, reporter).",
   "type": "module",
   "license": "MIT",