@svelte-vitals/core 0.36.0 → 0.37.0

package/dist/index.d.ts

@@ -956,6 +956,14 @@ interface RuleContext {
     sourceFiles?: string[];
     project: Project;
     config: Config;
+    /**
+     * Report per-declaration counts of places this rule examined. The engine supplies it and keys the
+     * result by rule id; a rule that does not call it gets no entry, which is distinct from an entry of
+     * zeros. Absent in contexts a caller builds directly. Silent last-write-wins: calling it more than
+     * once keeps only the most recent map, with no merge and no error — call it once, with the complete
+     * counts, at the end of `check()`.
+     */
+    recordExamined?: (counts: Record<string, number>) => void;
 }
 interface Rule {
     id: string;
@@ -995,7 +1003,10 @@ declare function isPenalized(detection: Detection, treatDynamicAs: TreatDynamicA
  * Rules are independent, so they run concurrently; results are flattened in
  * rule order for stable output.
  */
-declare function runRules(rules: Rule[], ctx: RuleContext): Promise<Result[]>;
+declare function runRules(rules: Rule[], ctx: RuleContext): Promise<{
+    results: Result[];
+    examined: Record<string, Record<string, number>>;
+}>;
 
 /**
  * seo/title-presence — every route should resolve a non-empty <title> (design §11).
@@ -1554,15 +1565,22 @@ interface JsonReport {
      * and floors that sum once, so adding this map's already-floored entries and re-dividing can disagree.
      */
     inventories: Record<string, number>;
+    /**
+     * Per-rule, per-declaration counts of places examined. Unlike `rules`, this describes the analysis
+     * rather than the report: `--diff`, `--baseline` and suppressions do not narrow it. Three states: a
+     * rule that reports no counts has no entry; a rule that counts but whose configuration declares
+     * nothing has an empty entry; a declaration that judged nothing has an entry of `0`.
+     */
+    examined?: Record<string, 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: {
     version: string;
-}, ruleIds?: readonly string[]): JsonReport;
+}, ruleIds?: readonly string[], examined?: Record<string, Record<string, number>>): JsonReport;
 /** Render results as the documented JSON report string (design §7). */
 declare function formatJsonReport(results: Result[], config: Config, meta: {
     version: string;
-}, ruleIds?: readonly string[]): string;
+}, ruleIds?: readonly string[], examined?: Record<string, Record<string, number>>): string;
 
 /** Render failing findings as an agent-actionable Markdown remediation document (issue #18). */
 declare function formatAgentReport(results: Result[], config: Config): string;

package/dist/index.js

@@ -2444,8 +2444,11 @@ function isPenalized(detection, treatDynamicAs) {
 
 // src/engine.ts
 async function runRules(rules, ctx) {
-  const perRule = await Promise.all(rules.map((rule) => rule.check(ctx)));
-  return perRule.flat();
+  const examined = {};
+  const perRule = await Promise.all(
+    rules.map((rule) => rule.check({ ...ctx, recordExamined: (counts) => void (examined[rule.id] = counts) }))
+  );
+  return { results: perRule.flat(), examined };
 }
 
 // src/rules/seo/title-presence.ts
@@ -5470,20 +5473,17 @@ var architectureReservedNamePlacement = {
     const emptyNames = /* @__PURE__ */ new Map();
     for (const map of Object.keys(globalMaps)) {
       for (const [name, value] of Object.entries(globalMaps[map])) {
-        const globs2 = globsOf(value);
-        if (globs2.length === 0) {
+        const globs = globsOf(value);
+        if (globs.length === 0) {
           emptyNames.set(`${map}.${name}`, "names no position at all");
           continue;
         }
-        for (const glob of globs2) globalAlternatives.set(label(map, name, glob), { map, glob });
+        for (const glob of globs) globalAlternatives.set(label(map, name, glob), { map, glob });
       }
     }
     const usedAlternatives = /* @__PURE__ */ new Set();
-    const excludedDirs = [];
-    const nonUnitParents = {
-      capitalisedUnitPlacements: [],
-      anyCaseUnitPlacements: []
-    };
+    const examinedCounts = {};
+    for (const key of globalAlternatives.keys()) examinedCounts[key] = 0;
     const allDirs = [...dirs].sort();
     for (const dir of allDirs) {
       const o = resolveRuleOptions(ID7, OPTIONS6, ctx.config, { route: dir, file: dir }, compiledOverrides);
@@ -5506,17 +5506,24 @@ var architectureReservedNamePlacement = {
       const parent = parentOf(dir);
       if (parent === void 0) continue;
       if (isExcluded(dir, ancestorDirs2(dir), excluded)) {
-        if (isExcluded(parent, ancestorDirs2(parent), excluded)) excludedDirs.push(parent);
         continue;
       }
+      const judged = /* @__PURE__ */ new Set();
+      const resolvedValues = [
+        ["placements", placements[name]],
+        ["capitalisedUnitPlacements", capUnits[name]],
+        ["anyCaseUnitPlacements", anyUnits[name]]
+      ];
+      for (const [map, value] of resolvedValues) {
+        if (value === void 0) continue;
+        for (const glob of globsOf(value)) judged.add(label(map, name, glob));
+      }
+      for (const key of judged) if (globalAlternatives.has(key)) examinedCounts[key] = (examinedCounts[key] ?? 0) + 1;
       const record = (map, value, qualifies) => {
         if (value === void 0) return false;
         const { matched } = matchKeys(parent, compile(globsOf(value), true));
         if (matched.length === 0) return false;
-        if (!qualifies) {
-          if (map !== "placements") nonUnitParents[map].push(parent);
-          return false;
-        }
+        if (!qualifies) return false;
         for (const glob of matched) usedAlternatives.add(label(map, name, glob));
         return true;
       };
@@ -5544,23 +5551,27 @@ var architectureReservedNamePlacement = {
     const notes = new Map(emptyNames);
     const unusedLabels = [...globalAlternatives.keys()].filter((k) => !usedAlternatives.has(k));
     const globOf = (key) => globalAlternatives.get(key)?.glob;
-    for (const map of ["capitalisedUnitPlacements", "anyCaseUnitPlacements"]) {
-      const inMap = unusedLabels.filter((k) => globalAlternatives.get(k)?.map === map);
-      const hit = keysMatchingAny(inMap.map(globOf), nonUnitParents[map], compile);
-      for (const k of inMap) {
-        if (hit.has(globOf(k))) notes.set(k, "matched directories but never a unit");
-      }
-    }
     const stillUnused = unusedLabels.filter((k) => !notes.has(k));
-    const globs = [...new Set(stillUnused.map(globOf))];
-    const reasons = classifyUnusedKeys(globs, excludedDirs, compile);
-    const reachable = keysMatchingAny(globs, allDirs, compile);
-    for (const k of stillUnused) {
-      const glob = globOf(k);
-      if (reasons.get(glob) === "only-excluded") {
-        notes.set(k, "matched only excluded directories");
-      } else if (!reachable.has(glob)) {
-        notes.set(k, "matched no directory");
+    if (stillUnused.length > 0) {
+      const globalExcluded = compile(listOption(globalOptions, "exclude"));
+      const liveDirs = allDirs.filter((d) => !isExcluded(d, ancestorDirs2(d), globalExcluded));
+      const liveUnits = {
+        capitalisedUnitPlacements: liveDirs.filter((d) => isUnitDir(d, filesIn)),
+        anyCaseUnitPlacements: liveDirs.filter((d) => isAnyCaseUnitDir(d, filesIn))
+      };
+      const globs = [...new Set(stillUnused.map(globOf))];
+      const reachesAny = keysMatchingAny(globs, allDirs, compile);
+      const reachesLive = keysMatchingAny(globs, liveDirs, compile);
+      for (const k of stillUnused) {
+        const glob = globOf(k);
+        if (!reachesAny.has(glob)) notes.set(k, "matched no directory");
+        else if (!reachesLive.has(glob)) notes.set(k, "matched only excluded directories");
+      }
+      for (const map of ["capitalisedUnitPlacements", "anyCaseUnitPlacements"]) {
+        const inMap = stillUnused.filter((k) => !notes.has(k) && globalAlternatives.get(k)?.map === map);
+        const inMapGlobs = [...new Set(inMap.map(globOf))];
+        const reachesUnit = keysMatchingAny(inMapGlobs, liveUnits[map], compile);
+        for (const k of inMap) if (!reachesUnit.has(globOf(k))) notes.set(k, "reaches no unit");
       }
     }
     const reported = [...notes.keys()].sort();
@@ -5576,6 +5587,7 @@ var architectureReservedNamePlacement = {
         docsUrl: docsUrl11
       });
     }
+    ctx.recordExamined?.(examinedCounts);
     return out;
   }
 };
@@ -6263,7 +6275,7 @@ function ruleEvidence(results, config, ruleIds) {
   }
   return out;
 }
-function buildJsonReport(results, config, meta, ruleIds) {
+function buildJsonReport(results, config, meta, ruleIds, examined) {
   const { health, categories: byCat, weights } = computeHealth(results, config);
   const summary = summarize(results, config);
   const rules = ruleEvidence(results, config, ruleIds);
@@ -6293,10 +6305,21 @@ function buildJsonReport(results, config, meta, ruleIds) {
   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 };
+  return {
+    version: meta.version,
+    score: health,
+    weights,
+    categories,
+    summary,
+    rules,
+    routes,
+    siteIssues,
+    inventories,
+    ...examined && Object.keys(examined).length > 0 ? { examined } : {}
+  };
 }
-function formatJsonReport(results, config, meta, ruleIds) {
-  return JSON.stringify(buildJsonReport(results, config, meta, ruleIds), null, 2);
+function formatJsonReport(results, config, meta, ruleIds, examined) {
+  return JSON.stringify(buildJsonReport(results, config, meta, ruleIds, examined), null, 2);
 }
 
 // src/reporter/agent.ts

package/package.json

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