@svelte-vitals/core 0.34.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;
@@ -1512,6 +1516,8 @@ interface JsonReport {
     categories: Record<string, {
         score: number;
         scoreModel: ScoreModel;
+        keys: number;
+        affectedKeys: number;
     }>;
     summary: Summary;
     rules: Record<string, RuleEvidence>;
@@ -1522,6 +1528,14 @@ interface JsonReport {
         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,7 +5878,13 @@ 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, options = {}) {
   const byCat = /* @__PURE__ */ new Map();
@@ -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) {
@@ -6112,7 +6124,10 @@ function buildJsonReport(results, config, meta, ruleIds) {
     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.34.0",
+  "version": "0.35.0",
   "description": "Shared, runtime-agnostic core for svelte-vitals (types, rule engine, scorer, reporter).",
   "type": "module",
   "license": "MIT",