@svelte-vitals/core 0.30.0 → 0.31.0

package/dist/index.js

@@ -857,10 +857,19 @@ function countLines(source) {
   if (source.length === 0) return 0;
   return source.split("\n").length - (source.endsWith("\n") ? 1 : 0);
 }
+function isTypeOnlyImport(n) {
+  if (n.importKind === "type") return true;
+  const specs = n.specifiers;
+  return Array.isArray(specs) && specs.length > 0 && specs.every((s) => s?.importKind === "type");
+}
 function collectImportSources(program, source, acc) {
   walkEstree(program, (n) => {
     if (n.type === "ImportDeclaration" && typeof n.source?.value === "string") {
-      acc.push({ source: n.source.value, line: lineOf(source, n.start) });
+      acc.push({
+        source: n.source.value,
+        line: lineOf(source, n.start),
+        ...isTypeOnlyImport(n) ? { type: true } : {}
+      });
     }
   });
 }
@@ -1516,6 +1525,12 @@ async function collectComponentFacts(rt, cwd) {
   );
 }
 
+// src/source-files.ts
+async function collectSourceFiles(rt, cwd) {
+  const files = await rt.glob("src/**/*", cwd);
+  return files.slice().sort();
+}
+
 // src/kit-module-parse.ts
 var HANDLER_NAMES = /* @__PURE__ */ new Set([
   "load",
@@ -1796,28 +1811,45 @@ function normalizePosix(path) {
   }
   return out.join("/");
 }
-function resolveRepoLocalPath(spec, importerFile) {
+var DEFAULT_KIT_ALIASES = [{ find: "$lib", replacement: "src/lib", match: "prefix" }];
+function aliasMatches(entry, spec) {
+  if (entry.match === "exact") return spec === entry.find;
+  if (spec.startsWith(`${entry.find}/`)) return true;
+  return entry.match === "prefix" && spec === entry.find;
+}
+function resolveRepoLocalPath(spec, importerFile, aliases = DEFAULT_KIT_ALIASES) {
   let path;
-  if (spec.startsWith("$lib/")) path = `src/lib/${spec.slice("$lib/".length)}`;
-  else if (spec.startsWith("./") || spec.startsWith("../")) {
+  if (spec.startsWith("./") || spec.startsWith("../")) {
     const dir = importerFile.split("/").slice(0, -1).join("/");
     path = `${dir}/${spec}`;
-  } else return void 0;
+  } else {
+    const entry = aliases.find((a) => aliasMatches(a, spec));
+    if (entry?.replacement == null) return void 0;
+    if (entry.replacement.startsWith("/") || /^[A-Za-z]:\//.test(entry.replacement)) return void 0;
+    path = entry.replacement + spec.slice(entry.find.length);
+  }
   return normalizePosix(path);
 }
-function resolveRunesModuleSpecifier(spec, importerFile) {
-  const path = resolveRepoLocalPath(spec, importerFile);
+function resolveRunesModuleSpecifier(spec, importerFile, aliases) {
+  const path = resolveRepoLocalPath(spec, importerFile, aliases);
   if (path === void 0) return void 0;
   if (/\.svelte\.(ts|js)$/.test(path)) return path;
   if (path.endsWith(".svelte")) return `${path}.ts`;
   return void 0;
 }
-function isLocalStateSpecifier(spec, importerFile) {
-  const path = resolveRepoLocalPath(spec, importerFile);
+function libServerRoot(aliases) {
+  const lib = aliases?.find((a) => a.find === "$lib");
+  if (lib && lib.replacement === null) return void 0;
+  return `${lib?.replacement ?? "src/lib"}/server`;
+}
+function isLocalStateSpecifier(spec, importerFile, aliases) {
+  const serverRoot = libServerRoot(aliases);
+  if (serverRoot === void 0) return false;
+  const path = resolveRepoLocalPath(spec, importerFile, aliases);
   if (path === void 0) return false;
-  return path !== "src/lib/server" && !path.startsWith("src/lib/server/");
+  return path !== serverRoot && !path.startsWith(`${serverRoot}/`);
 }
-function parseKitModuleFacts(source, filename) {
+function parseKitModuleFacts(source, filename, aliases) {
   const suppressions = collectSuppressions(source);
   const { program, wrapped } = parseModuleProgram(source, filename);
   const moduleStateReassignments = [];
@@ -1850,7 +1882,7 @@ function parseKitModuleFacts(source, filename) {
       importedSpecifiers.set(s.local.name, spec);
     }
     if (names.length === 0) continue;
-    const resolved = resolveRunesModuleSpecifier(spec, filename);
+    const resolved = resolveRunesModuleSpecifier(spec, filename, aliases);
     if (resolved) runesModuleImports.push({ source: spec, resolved, names, line: line(stmt.start) });
   }
   const moduleLets = /* @__PURE__ */ new Set();
@@ -1924,7 +1956,8 @@ function parseKitModuleFacts(source, filename) {
       const method = n.callee.property?.type === "Identifier" ? n.callee.property.name : void 0;
       if (method === "set" || method === "update") {
         const r = importedRoot(n.callee.object);
-        if (r && isLocalStateSpecifier(importedSpecifiers.get(r), filename)) write = { name: r, via: "set-call" };
+        if (r && isLocalStateSpecifier(importedSpecifiers.get(r), filename, aliases))
+          write = { name: r, via: "set-call" };
       }
     } else if (n.type === "AssignmentExpression" && (n.left?.type === "ObjectPattern" || n.left?.type === "ArrayPattern")) {
       const scanPatternTargets = (pat) => {
@@ -2002,7 +2035,7 @@ function kindOf(file) {
   const base = file.split("/").pop() ?? file;
   return base.includes(".server.") || base.startsWith("+server.") ? "server" : "universal";
 }
-async function collectKitModuleFacts(rt, cwd) {
+async function collectKitModuleFacts(rt, cwd, aliases) {
   const patterns = [
     "src/routes/**/+{page,layout}.server.{ts,js}",
     "src/routes/**/+{page,layout}.{ts,js}",
@@ -2016,7 +2049,7 @@ async function collectKitModuleFacts(rt, cwd) {
       const kind = kindOf(rel);
       try {
         const source = await rt.readFile(rt.join(cwd, rel));
-        return { file: rel, kind, ...parseKitModuleFacts(source, rel) };
+        return { file: rel, kind, ...parseKitModuleFacts(source, rel, aliases) };
       } catch {
         return emptyKitModuleFacts(rel, kind);
       }
@@ -2114,6 +2147,79 @@ function basePathOf(kitConfig, bindings) {
   }
   return {};
 }
+function keyNameOf(p) {
+  if (p.computed) return void 0;
+  if (p.key.type === "Identifier") return p.key.name;
+  if (p.key.type === "Literal" && typeof p.key.value === "string") return p.key.value;
+  return void 0;
+}
+function stringValueOf(p) {
+  const v = unwrapTs(p.value);
+  return v.type === "Literal" && typeof v.value === "string" ? v.value : void 0;
+}
+function aliasEntriesOf(kitConfig, bindings) {
+  const alias = propOf(kitConfig, "alias");
+  if (!alias) return [];
+  const obj = unwrapToObjectExpression(alias.value, bindings);
+  if (!obj) return void 0;
+  const out = [];
+  const at = /* @__PURE__ */ new Map();
+  for (const p of obj.properties) {
+    if (p.type !== "Property") return void 0;
+    const key = keyNameOf(p);
+    if (key === void 0) return void 0;
+    const entry = { key, value: stringValueOf(p) ?? null };
+    const seen = at.get(key);
+    if (seen === void 0) {
+      at.set(key, out.length);
+      out.push(entry);
+    } else out[seen] = entry;
+  }
+  return out;
+}
+function filesLibOf(kitConfig, bindings) {
+  const files = propOf(kitConfig, "files");
+  const obj = files ? unwrapToObjectExpression(files.value, bindings) : void 0;
+  const lib = obj ? propOf(obj, "lib") : void 0;
+  if (!lib) return void 0;
+  return stringValueOf(lib) ?? null;
+}
+function findKitAliasesInSvelteConfig(source) {
+  const program = programOf(source, "svelte.config.js");
+  const config = program ? resolveConfigObject(program) : void 0;
+  if (!program || !config) return { entries: [] };
+  const bindings = collectTopLevelBindings(program);
+  const kit = propOf(config, "kit");
+  const kitObj = kit ? unwrapToObjectExpression(kit.value, bindings) : void 0;
+  if (!kitObj) return { entries: [] };
+  const filesLib = filesLibOf(kitObj, bindings);
+  return { entries: aliasEntriesOf(kitObj, bindings), ...filesLib !== void 0 ? { filesLib } : {} };
+}
+function normalizeAliasValue(value) {
+  const posix = value.replace(/\\/g, "/");
+  const noStar = posix.endsWith("/*") ? posix.slice(0, -2) : posix;
+  return noStar.replace(/\/+$/, "");
+}
+function compileKitAliases(raw) {
+  const filesLib = raw.filesLib === null ? null : normalizeAliasValue(raw.filesLib ?? "src/lib");
+  const out = [{ find: "$lib", replacement: filesLib, match: "prefix" }];
+  const entries = raw.entries ?? [];
+  const declared = new Set(entries.map((e) => e.key));
+  for (const { key, value } of entries) {
+    const star = key.endsWith("/*");
+    out.push({
+      find: star ? key.slice(0, -2) : key,
+      replacement: value === null ? null : normalizeAliasValue(value),
+      match: star ? "contents" : declared.has(`${key}/*`) ? "exact" : "prefix"
+    });
+  }
+  return out;
+}
+function resolveKitAliases(viteConfig, svelteConfig) {
+  if (viteConfig && findKitPathsBaseInViteConfig(viteConfig.source).kind !== "no-plugin-config") return void 0;
+  if (!svelteConfig) return void 0;
+  return compileKitAliases(findKitAliasesInSvelteConfig(svelteConfig.source));
+}
 function programOf(source, filename) {
   try {
     return parseModuleProgram(source, filename).program ?? void 0;
@@ -2263,7 +2369,7 @@ function detect(head, match) {
   return tag ? { presence: tag.presence, value: tag.value } : { presence: "none", value: "absent" };
 }
 function headTagRule(opts) {
-  const docsUrl8 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   return {
     id: opts.id,
     title: opts.title,
@@ -2286,7 +2392,7 @@ function headTagRule(opts) {
           location: head.file,
           message,
           recommendation: opts.recommendation,
-          docsUrl: docsUrl8,
+          docsUrl: docsUrl11,
           // Copy per finding: opts.fix is a rule-level template shared across all
           // results this rule emits; a fresh object keeps findings independent.
           ...opts.fix ? { fix: { ...opts.fix } } : {}
@@ -2479,7 +2585,7 @@ var seoHtmlLang = {
 
 // src/rules/perf/image-rule.ts
 function imageRule(opts) {
-  const docsUrl8 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   const category = opts.category ?? "performance";
   return {
     id: opts.id,
@@ -2503,7 +2609,7 @@ function imageRule(opts) {
             route: route.route,
             message: opts.label,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl8
+            docsUrl: docsUrl11
           });
           continue;
         }
@@ -2518,7 +2624,7 @@ function imageRule(opts) {
             ...img.line > 0 ? { line: img.line } : {},
             message: `Missing ${opts.label}`,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl8,
+            docsUrl: docsUrl11,
             ...opts.fix ? { fix: { ...opts.fix } } : {}
           });
         }
@@ -2578,7 +2684,7 @@ var performanceResponsiveImage = imageRule({
 
 // src/rules/perf/link-rule.ts
 function linkRule(opts) {
-  const docsUrl8 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   return {
     id: opts.id,
     title: opts.title,
@@ -2602,7 +2708,7 @@ function linkRule(opts) {
             route: head.route,
             message: opts.label,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl8
+            docsUrl: docsUrl11
           });
           continue;
         }
@@ -2619,7 +2725,7 @@ function linkRule(opts) {
             location: tag.file ?? head.file,
             message: `Missing ${opts.label}`,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl8,
+            docsUrl: docsUrl11,
             ...opts.fix ? { fix: { ...opts.fix } } : {}
           });
         }
@@ -2842,6 +2948,10 @@ function mapOption(options, key) {
   const v = options[key];
   return typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
 }
+function isMentionedAnywhere(config, ruleId) {
+  if (Object.hasOwn(config.rules, ruleId)) return true;
+  return (config.overrides ?? []).some((entry) => entry.rules !== void 0 && Object.hasOwn(entry.rules, ruleId));
+}
 function resolveRuleOptions(ruleId, spec, config, target, compiled) {
   if (!spec) return {};
   const out = defaultsOf(spec);
@@ -3047,7 +3157,7 @@ var seoIndexability = {
   rationale: "A noindex directive removes the page from search results; an accidental noindex on a public route silently deindexes it.",
   fix: FIX5,
   async check(ctx) {
-    const docsUrl8 = docsUrlFor("seo/indexability");
+    const docsUrl11 = docsUrlFor("seo/indexability");
     const out = [];
     for (const head of ctx.heads) {
       const noindexed = head.tags.some((t) => t.kind === "meta" && t.name === "robots" && t.noindex === true);
@@ -3062,7 +3172,7 @@ var seoIndexability = {
         location: head.file,
         message: "Route is noindex \u2014 verify this is intentional",
         recommendation: 'If this route should be indexed, remove noindex from its <meta name="robots">.',
-        docsUrl: docsUrl8,
+        docsUrl: docsUrl11,
         fix: { ...FIX5 }
       });
     }
@@ -3313,7 +3423,7 @@ function jsonldTags(head) {
   return head.tags.filter((t) => t.kind === "jsonld" && typeof t.jsonld === "string");
 }
 function jsonldRule(opts) {
-  const docsUrl8 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   return {
     id: opts.id,
     title: opts.title,
@@ -3341,7 +3451,7 @@ function jsonldRule(opts) {
               location: head.file,
               message: problem,
               recommendation: opts.recommendation,
-              docsUrl: docsUrl8,
+              docsUrl: docsUrl11,
               ...opts.fix ? { fix: { ...opts.fix } } : {}
             } : {
               id: opts.id,
@@ -3351,7 +3461,7 @@ function jsonldRule(opts) {
               route: head.route,
               message: opts.label,
               recommendation: opts.recommendation,
-              docsUrl: docsUrl8
+              docsUrl: docsUrl11
             }
           );
         }
@@ -3375,7 +3485,7 @@ var seoJsonLdValidity = {
     lang: "svelte"
   },
   async check(ctx) {
-    const docsUrl8 = docsUrlFor("seo/json-ld-validity");
+    const docsUrl11 = docsUrlFor("seo/json-ld-validity");
     const out = [];
     for (const head of ctx.heads) {
       for (const tag of jsonldTags(head)) {
@@ -3394,7 +3504,7 @@ var seoJsonLdValidity = {
             location: head.file,
             message: problem,
             recommendation: "Make the JSON-LD valid JSON with both @context and @type.",
-            docsUrl: docsUrl8,
+            docsUrl: docsUrl11,
             fix: { ...seoJsonLdValidity.fix }
           } : {
             id: "seo/json-ld-validity",
@@ -3404,7 +3514,7 @@ var seoJsonLdValidity = {
             route: head.route,
             message: "JSON-LD validity",
             recommendation: "Make the JSON-LD valid JSON with both @context and @type.",
-            docsUrl: docsUrl8
+            docsUrl: docsUrl11
           }
         );
       }
@@ -3515,7 +3625,7 @@ function visibleLength(s) {
 
 // src/rules/seo/length-rule.ts
 function lengthRule(opts) {
-  const docsUrl8 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   const spec = {
     min: { kind: "integer", default: opts.min, min: 0 },
     max: { kind: "integer", default: opts.max, min: 1 }
@@ -3538,7 +3648,7 @@ function lengthRule(opts) {
         const o = resolveRuleOptions(opts.id, spec, ctx.config, { route: head.route, file: location }, compiled);
         const min = intOption(o, "min", opts.min);
         const max = intOption(o, "max", opts.max);
-        const recommendation8 = typeof opts.recommendation === "function" ? opts.recommendation(o) : opts.recommendation;
+        const recommendation11 = typeof opts.recommendation === "function" ? opts.recommendation(o) : opts.recommendation;
         const len = visibleLength(tag.text);
         let problem;
         if (len < min) problem = `${opts.noun} is too short (${len} chars; aim for ${min}\u2013${max})`;
@@ -3552,8 +3662,8 @@ function lengthRule(opts) {
             route: head.route,
             location,
             message: problem,
-            recommendation: recommendation8,
-            docsUrl: docsUrl8
+            recommendation: recommendation11,
+            docsUrl: docsUrl11
           } : {
             id: opts.id,
             category: "seo",
@@ -3561,8 +3671,8 @@ function lengthRule(opts) {
             detection: PASS,
             route: head.route,
             message: opts.label,
-            recommendation: recommendation8,
-            docsUrl: docsUrl8
+            recommendation: recommendation11,
+            docsUrl: docsUrl11
           }
         );
       }
@@ -3747,7 +3857,7 @@ var seoSingleH1 = {
 
 // src/rules/seo/uniqueness-rule.ts
 function uniquenessRule(opts) {
-  const docsUrl8 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   return {
     id: opts.id,
     title: opts.title,
@@ -3777,7 +3887,7 @@ function uniquenessRule(opts) {
           location: e.file,
           message: `${opts.noun} is duplicated across ${n} routes`,
           recommendation: opts.recommendation,
-          docsUrl: docsUrl8
+          docsUrl: docsUrl11
         } : {
           id: opts.id,
           category: "seo",
@@ -3786,7 +3896,7 @@ function uniquenessRule(opts) {
           route: e.route,
           message: opts.label,
           recommendation: opts.recommendation,
-          docsUrl: docsUrl8
+          docsUrl: docsUrl11
         };
       });
     }
@@ -3874,7 +3984,7 @@ function isSuppressed(m, ruleId, line) {
   return (m.suppressions ?? []).some((s) => s.line === line && (!s.ruleIds || s.ruleIds.includes(ruleId)));
 }
 function kitModuleRule(opts) {
-  const docsUrl8 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   const severity = opts.severity ?? "warning";
   return {
     id: opts.id,
@@ -3898,7 +4008,7 @@ function kitModuleRule(opts) {
             route: m.file,
             message: opts.label,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl8
+            docsUrl: docsUrl11
           });
           continue;
         }
@@ -3913,7 +4023,7 @@ function kitModuleRule(opts) {
             ...b.line > 0 ? { line: b.line } : {},
             message: b.message,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl8,
+            docsUrl: docsUrl11,
             ...opts.fix ? { fix: { ...opts.fix } } : {}
           });
         }
@@ -3949,7 +4059,7 @@ function isSuppressed2(c, ruleId, line) {
   return (c.suppressions ?? []).some((s) => s.line === line && (!s.ruleIds || s.ruleIds.includes(ruleId)));
 }
 function componentRule(opts) {
-  const docsUrl8 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   const severity = opts.severity ?? "warning";
   return {
     id: opts.id,
@@ -3965,9 +4075,9 @@ function componentRule(opts) {
       const compiled = compileOverrides(ctx.config);
       for (const c of ctx.components ?? []) {
         const o = resolveRuleOptions(opts.id, opts.options, ctx.config, { route: c.file, file: c.file }, compiled);
-        const recommendation8 = typeof opts.recommendation === "function" ? opts.recommendation(o) : opts.recommendation;
-        if (!opts.applies(c, o)) continue;
-        const bad = opts.bad(c, o).filter((b) => !(b.line > 0 && isSuppressed2(c, opts.id, b.line)));
+        const recommendation11 = typeof opts.recommendation === "function" ? opts.recommendation(o) : opts.recommendation;
+        if (!opts.applies(c, o, ctx)) continue;
+        const bad = opts.bad(c, o, ctx).filter((b) => !(b.line > 0 && isSuppressed2(c, opts.id, b.line)));
         if (bad.length === 0) {
           out.push({
             id: opts.id,
@@ -3976,8 +4086,8 @@ function componentRule(opts) {
             detection: PASS3,
             route: c.file,
             message: opts.label,
-            recommendation: recommendation8,
-            docsUrl: docsUrl8
+            recommendation: recommendation11,
+            docsUrl: docsUrl11
           });
           continue;
         }
@@ -3991,8 +4101,8 @@ function componentRule(opts) {
             location: c.file,
             ...b.line > 0 ? { line: b.line } : {},
             message: b.message,
-            recommendation: recommendation8,
-            docsUrl: docsUrl8,
+            recommendation: recommendation11,
+            docsUrl: docsUrl11,
             ...opts.fix ? { fix: { ...opts.fix } } : {}
           });
         }
@@ -4597,7 +4707,7 @@ var architecturePrivateScopeImport = {
       let sawScopedImport = false;
       const violations = [];
       for (const { source, line } of spans) {
-        const target = resolveRepoLocalPath(source, c.file);
+        const target = resolveRepoLocalPath(source, c.file, ctx.project.kitAliases);
         if (target === void 0) continue;
         const boundary = privateScopeOf(target, patterns);
         if (boundary === void 0) continue;
@@ -4642,6 +4752,590 @@ var architecturePrivateScopeImport = {
   }
 };
 
+// src/rules/architecture/declarations.ts
+function ancestorDirs2(file) {
+  const segments = file.split("/");
+  const out = [];
+  for (let i = 1; i < segments.length; i++) out.push(segments.slice(0, i).join("/"));
+  return out;
+}
+function baseName(dir) {
+  const cut = dir.lastIndexOf("/");
+  return cut === -1 ? dir : dir.slice(cut + 1);
+}
+function childDirs(dirs) {
+  const out = /* @__PURE__ */ new Map();
+  for (const dir of dirs) {
+    const cut = dir.lastIndexOf("/");
+    if (cut === -1) continue;
+    const parent = dir.slice(0, cut);
+    let kids = out.get(parent);
+    if (kids === void 0) out.set(parent, kids = []);
+    kids.push(dir);
+  }
+  for (const kids of out.values()) kids.sort();
+  return out;
+}
+function childFiles(files) {
+  const out = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const cut = file.lastIndexOf("/");
+    if (cut === -1) continue;
+    const dir = file.slice(0, cut);
+    let own = out.get(dir);
+    if (own === void 0) out.set(dir, own = []);
+    own.push(file.slice(cut + 1));
+  }
+  for (const own of out.values()) own.sort();
+  return out;
+}
+function splitNames(value) {
+  const out = [];
+  for (const raw of value.split("|")) {
+    const token = raw.trim();
+    if (token.length > 0) out.push(token);
+  }
+  return out;
+}
+function keyShape(key) {
+  const parts = key.split("/");
+  let doubleStars = 0;
+  for (const p of parts) if (p === "**") doubleStars++;
+  return { segments: parts.length, doubleStars };
+}
+function createKeyCompiler() {
+  const cache = /* @__PURE__ */ new Map();
+  return (globs, bareGuard = false) => {
+    const cacheKey = JSON.stringify([globs, bareGuard]);
+    let entry = cache.get(cacheKey);
+    if (entry === void 0) {
+      entry = globs.map((key) => ({
+        key,
+        re: routeGlobToRegExp(key),
+        ...keyShape(key),
+        ...bareGuard && key.endsWith("/**") ? { barePrefixRe: routeGlobToRegExp(key.slice(0, -3)) } : {}
+      }));
+      cache.set(cacheKey, entry);
+    }
+    return entry;
+  };
+}
+function matchKeys(dir, compiled) {
+  const matched = [];
+  let best;
+  for (const entry of compiled) {
+    if (entry.barePrefixRe?.test(dir)) continue;
+    if (!entry.re.test(dir)) continue;
+    matched.push(entry.key);
+    if (best === void 0 || moreSpecificShaped(entry, best)) best = entry;
+  }
+  return best === void 0 ? { matched } : { matched, best: best.key };
+}
+function moreSpecificShaped(a, b) {
+  if (a.segments !== b.segments) return a.segments > b.segments;
+  if (a.doubleStars !== b.doubleStars) return a.doubleStars < b.doubleStars;
+  if (a.key.length !== b.key.length) return a.key.length > b.key.length;
+  return a.key < b.key;
+}
+function moreSpecificGlob(a, b) {
+  return moreSpecificShaped({ key: a, ...keyShape(a) }, { key: b, ...keyShape(b) });
+}
+function reportAt(dir, files) {
+  const prefix = `${dir}/`;
+  const under = files.filter((f) => f.startsWith(prefix)).sort();
+  return under.find((f) => !f.slice(prefix.length).includes("/")) ?? under[0];
+}
+function isExcluded(dir, ancestors, excluded) {
+  return excluded.some(({ re }) => re.test(dir) || ancestors.some((a) => re.test(a)));
+}
+function keysMatchingAny(keys, dirs, compile) {
+  const hit = /* @__PURE__ */ new Set();
+  if (keys.length === 0 || dirs.length === 0) return hit;
+  for (const { key, re, barePrefixRe } of compile(keys, true)) {
+    if (dirs.some((d) => !barePrefixRe?.test(d) && re.test(d))) hit.add(key);
+  }
+  return hit;
+}
+function classifyUnusedKeys(unused, excludedDirs, compile) {
+  const out = /* @__PURE__ */ new Map();
+  if (unused.length === 0) return out;
+  const shadowed = keysMatchingAny(unused, excludedDirs, compile);
+  for (const key of unused) out.set(key, shadowed.has(key) ? "only-excluded" : "no-match");
+  return out;
+}
+
+// src/rules/architecture/unit-entry-file.ts
+var ID4 = "architecture/unit-entry-file";
+var docsUrl8 = docsUrlFor(ID4);
+var recommendation8 = "Give every declared unit directory a file named after it, or stop declaring that directory a unit.";
+var OPTIONS3 = {
+  units: { kind: "string-map", default: {} },
+  pascalCaseUnits: { kind: "string-map", default: {} },
+  exclude: { kind: "string-list", default: [] }
+};
+function isPascalCase(name) {
+  const c = name.charCodeAt(0);
+  return c >= 65 && c <= 90;
+}
+var architectureUnitEntryFile = {
+  id: ID4,
+  title: "Unit entry file",
+  category: "architecture",
+  severity: "info",
+  scope: "component",
+  rationale: "A directory named after a unit but missing that unit's entry file is either an incomplete unit or a grouping wearing the wrong name; either way the tree no longer says what it means, and tooling that resolves by convention starts guessing.",
+  fix: {
+    description: "Make the directory and its entry file agree \u2014 add the entry file, or stop declaring this directory a unit."
+  },
+  options: OPTIONS3,
+  async check(ctx) {
+    const files = ctx.sourceFiles;
+    if (files === void 0) return [];
+    if (!isMentionedAnywhere(ctx.config, ID4)) return [];
+    const compiledOverrides = compileOverrides(ctx.config);
+    const dirs = /* @__PURE__ */ new Set();
+    for (const f of files) for (const d of ancestorDirs2(f)) dirs.add(d);
+    const fileSet = new Set(files);
+    const compile = createKeyCompiler();
+    const out = [];
+    const globalOptions = resolveRuleOptions(ID4, OPTIONS3, ctx.config);
+    const globalKeys = /* @__PURE__ */ new Set([
+      ...Object.keys(mapOption(globalOptions, "units")),
+      ...Object.keys(mapOption(globalOptions, "pascalCaseUnits"))
+    ]);
+    const usedKeys = /* @__PURE__ */ new Set();
+    const excludedDirs = [];
+    const matchedSurviving = /* @__PURE__ */ new Set();
+    for (const dir of [...dirs].sort()) {
+      const o = resolveRuleOptions(ID4, OPTIONS3, ctx.config, { route: dir, file: dir }, compiledOverrides);
+      const units = mapOption(o, "units");
+      const pascalUnits = mapOption(o, "pascalCaseUnits");
+      if (Object.keys(units).length === 0 && Object.keys(pascalUnits).length === 0) continue;
+      const excluded = compile(listOption(o, "exclude"));
+      const ancestors = ancestorDirs2(dir);
+      if (isExcluded(dir, ancestors, excluded)) {
+        excludedDirs.push(dir);
+        continue;
+      }
+      const byPath = matchKeys(dir, compile(Object.keys(units), true));
+      const byCasing = matchKeys(dir, compile(Object.keys(pascalUnits), true));
+      for (const k of byPath.matched) if (globalKeys.has(k)) usedKeys.add(k);
+      for (const k of byPath.matched) if (globalKeys.has(k)) matchedSurviving.add(k);
+      for (const k of byCasing.matched) if (globalKeys.has(k)) matchedSurviving.add(k);
+      if (isPascalCase(baseName(dir))) {
+        for (const k of byCasing.matched) if (globalKeys.has(k)) usedKeys.add(k);
+      }
+      let ext = byPath.best === void 0 ? void 0 : units[byPath.best];
+      const viaUnits = ext !== void 0;
+      if (ext === void 0 && isPascalCase(baseName(dir))) {
+        ext = byCasing.best === void 0 ? void 0 : pascalUnits[byCasing.best];
+      }
+      if (ext === void 0) continue;
+      const expected = `${dir}/${baseName(dir)}${ext}`;
+      if (fileSet.has(expected)) {
+        out.push({
+          id: ID4,
+          category: "architecture",
+          severity: "info",
+          detection: { presence: "own", value: "static" },
+          route: expected,
+          message: "Unit entry file",
+          recommendation: recommendation8,
+          docsUrl: docsUrl8
+        });
+        continue;
+      }
+      const at = reportAt(dir, files);
+      if (at === void 0) continue;
+      out.push({
+        id: ID4,
+        category: "architecture",
+        severity: "info",
+        detection: { presence: "none", value: "absent" },
+        route: dir,
+        location: at,
+        message: `${dir} declares a unit but has no ${expected}`,
+        recommendation: recommendation8,
+        docsUrl: docsUrl8,
+        // Which declaration matched decides the wording: a `units` match like functions/getFoo/
+        // is already camelCase, so telling its author to rename it would be nonsense.
+        fix: {
+          description: viaUnits ? `Add ${baseName(dir)}${ext} to this directory, or remove it from the units declaration.` : `Add the same-named entry file, or rename the directory to camelCase if it is a grouping.`
+        }
+      });
+    }
+    const inertKeys = [...globalKeys].filter((key) => !usedKeys.has(key)).sort();
+    if (inertKeys.length > 0) {
+      const shadowed = inertKeys.filter((k) => !matchedSurviving.has(k));
+      const reasons = classifyUnusedKeys(shadowed, excludedDirs, compile);
+      const why = (k) => reasons.get(k) === "only-excluded" ? "matched only excluded directories" : "matched no directory";
+      const message = inertKeys.length === 1 ? `The declaration '${inertKeys[0]}' ${why(inertKeys[0])}, so it checks nothing.` : `These declarations check nothing: ${inertKeys.map((k) => `'${k}' (${why(k)})`).join(", ")}.`;
+      out.push({
+        id: ID4,
+        category: "architecture",
+        severity: "info",
+        detection: { presence: "none", value: "absent" },
+        message,
+        recommendation: "Correct the glob, or remove the declaration.",
+        docsUrl: docsUrl8
+      });
+    }
+    return out;
+  }
+};
+
+// src/rules/architecture/casing.ts
+var CASINGS = {
+  camelCase: /^[a-z][a-zA-Z0-9]*$/,
+  PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
+  "kebab-case": /^[a-z0-9]+(-[a-z0-9]+)*$/,
+  snake_case: /^[a-z0-9]+(_[a-z0-9]+)*$/
+};
+function parseCasings(value) {
+  const known = [];
+  const unknown = [];
+  for (const name of splitNames(value)) {
+    if (Object.hasOwn(CASINGS, name)) known.push(name);
+    else unknown.push(name);
+  }
+  return { known, unknown };
+}
+function decodeSegment(name) {
+  let inner = name;
+  if (inner.length > 2 && inner.startsWith("(") && inner.endsWith(")")) inner = inner.slice(1, -1);
+  else if (inner.length > 4 && inner.startsWith("[[") && inner.endsWith("]]")) inner = inner.slice(2, -2);
+  else if (inner.length > 2 && inner.startsWith("[") && inner.endsWith("]")) inner = inner.slice(1, -1);
+  if (inner.startsWith("...")) inner = inner.slice(3);
+  const eq = inner.indexOf("=");
+  if (eq !== -1) inner = inner.slice(0, eq);
+  if (inner.length === 0 || /[[\]()]/.test(inner)) return void 0;
+  return inner;
+}
+function satisfiesCasing(name, allowed) {
+  if (!/[a-zA-Z]/.test(name)) return true;
+  return allowed.some((c) => Object.hasOwn(CASINGS, c) && CASINGS[c].test(name));
+}
+
+// src/rules/architecture/directory-naming.ts
+var ID5 = "architecture/directory-naming";
+var docsUrl9 = docsUrlFor(ID5);
+var recommendation9 = "Name each directory in the casing its location declares, or narrow the declaration.";
+var OPTIONS4 = {
+  directories: { kind: "string-map", default: {} },
+  exclude: { kind: "string-list", default: [] }
+};
+var architectureDirectoryNaming = {
+  id: ID5,
+  title: "Directory naming",
+  category: "architecture",
+  severity: "info",
+  scope: "component",
+  rationale: "A directory whose name breaks the convention its location declares stops carrying the meaning the convention gave it, and every reader \u2014 human or agent \u2014 has to open the directory to learn what it is.",
+  fix: {
+    description: "Rename the directory to the declared casing, or narrow the declaration that governs it."
+  },
+  options: OPTIONS4,
+  async check(ctx) {
+    const files = ctx.sourceFiles;
+    if (files === void 0) return [];
+    if (!isMentionedAnywhere(ctx.config, ID5)) return [];
+    const compiledOverrides = compileOverrides(ctx.config);
+    const dirs = /* @__PURE__ */ new Set();
+    for (const f of files) for (const d of ancestorDirs2(f)) dirs.add(d);
+    const compile = createKeyCompiler();
+    const parsed = /* @__PURE__ */ new Map();
+    const casingsOf = (value) => {
+      let p = parsed.get(value);
+      if (p === void 0) parsed.set(value, p = parseCasings(value));
+      return p;
+    };
+    const out = [];
+    const globalOptions = resolveRuleOptions(ID5, OPTIONS4, ctx.config);
+    const globalMap = mapOption(globalOptions, "directories");
+    const globalKeys = new Set(Object.keys(globalMap));
+    const usedKeys = /* @__PURE__ */ new Set();
+    const excludedDirs = [];
+    for (const dir of [...dirs].sort()) {
+      const o = resolveRuleOptions(ID5, OPTIONS4, ctx.config, { route: dir, file: dir }, compiledOverrides);
+      const declared = mapOption(o, "directories");
+      if (Object.keys(declared).length === 0) continue;
+      const excluded = compile(listOption(o, "exclude"));
+      if (isExcluded(dir, ancestorDirs2(dir), excluded)) {
+        excludedDirs.push(dir);
+        continue;
+      }
+      const live = Object.keys(declared).filter((k) => casingsOf(declared[k]).known.length > 0);
+      const m = matchKeys(dir, compile(live, true));
+      for (const k of m.matched) if (globalKeys.has(k)) usedKeys.add(k);
+      if (m.best === void 0) continue;
+      const decoded = decodeSegment(baseName(dir));
+      if (decoded === void 0) continue;
+      const allowed = casingsOf(declared[m.best]).known;
+      if (satisfiesCasing(decoded, allowed)) continue;
+      const at = reportAt(dir, files);
+      if (at === void 0) continue;
+      out.push({
+        id: ID5,
+        category: "architecture",
+        severity: "info",
+        detection: { presence: "none", value: "absent" },
+        route: dir,
+        location: at,
+        message: `${dir} must be ${allowed.join(" or ")}.`,
+        recommendation: recommendation9,
+        docsUrl: docsUrl9,
+        fix: { description: "Rename the directory, or narrow the declaration that governs it." }
+      });
+    }
+    const notes = /* @__PURE__ */ new Map();
+    for (const key of globalKeys) {
+      const { known, unknown } = casingsOf(globalMap[key]);
+      if (known.length > 0 && unknown.length === 0) continue;
+      const names = unknown.map((u) => `'${u}'`).join(", ");
+      notes.set(
+        key,
+        known.length === 0 ? unknown.length === 0 ? "the value names no casing at all, so it checks nothing" : `unknown casing name ${names}, so it checks nothing` : `unknown casing name ${names}; the rest of the value still applies`
+      );
+    }
+    const unclassified = [...globalKeys].filter(
+      (key) => !notes.has(key) && !usedKeys.has(key) && casingsOf(globalMap[key]).known.length > 0
+    );
+    const reasons = classifyUnusedKeys(unclassified, excludedDirs, compile);
+    for (const [key, reason] of reasons) {
+      notes.set(key, reason === "only-excluded" ? "matched only excluded directories" : "matched no directory");
+    }
+    const reported = [...notes.keys()].sort();
+    if (reported.length > 0) {
+      const message = reported.length === 1 ? `The declaration '${reported[0]}' does not check what it says: ${notes.get(reported[0])}.` : `These declarations do not check what they say: ${reported.map((k) => `'${k}' (${notes.get(k)})`).join(", ")}.`;
+      out.push({
+        id: ID5,
+        category: "architecture",
+        severity: "info",
+        detection: { presence: "none", value: "absent" },
+        message,
+        recommendation: "Correct the glob or the casing name, or remove the declaration.",
+        docsUrl: docsUrl9
+      });
+    }
+    return out;
+  }
+};
+
+// src/rules/architecture/reserved-directory-names.ts
+var ID6 = "architecture/reserved-directory-names";
+var docsUrl10 = docsUrlFor(ID6);
+var recommendation10 = "Use one of the names this location declares, or add the new name to the declaration.";
+var OPTIONS5 = {
+  scopes: { kind: "string-map", default: {} },
+  unitScopes: { kind: "string-map", default: {} },
+  exclude: { kind: "string-list", default: [] }
+};
+function stem(file) {
+  const dot = file.indexOf(".");
+  return dot === -1 ? file : file.slice(0, dot);
+}
+function isUnitDir(dir, filesIn) {
+  const name = baseName(dir);
+  const first = name.charCodeAt(0);
+  if (!(first >= 65 && first <= 90)) return false;
+  const own = filesIn.get(dir);
+  return own !== void 0 && own.some((f) => stem(f) === name);
+}
+var architectureReservedDirectoryNames = {
+  id: ID6,
+  title: "Reserved directory names",
+  category: "architecture",
+  severity: "info",
+  scope: "component",
+  rationale: "A closed set of directory names is only worth writing down if it stays closed: one directory outside it and the table stops describing the tree, so every reader has to open a directory to learn what it holds.",
+  fix: {
+    description: "Rename the directory to a declared name, move it under one of them, or add its name to the declaration."
+  },
+  options: OPTIONS5,
+  async check(ctx) {
+    const files = ctx.sourceFiles;
+    if (files === void 0) return [];
+    if (!isMentionedAnywhere(ctx.config, ID6)) return [];
+    const compiledOverrides = compileOverrides(ctx.config);
+    const dirs = /* @__PURE__ */ new Set();
+    for (const f of files) for (const d of ancestorDirs2(f)) dirs.add(d);
+    const kids = childDirs(dirs);
+    const filesIn = childFiles(files);
+    const compile = createKeyCompiler();
+    const parsed = /* @__PURE__ */ new Map();
+    const namesOf = (value) => {
+      let n = parsed.get(value);
+      if (n === void 0) parsed.set(value, n = splitNames(value));
+      return n;
+    };
+    const out = [];
+    const globalOptions = resolveRuleOptions(ID6, OPTIONS5, ctx.config);
+    const globalScopes = mapOption(globalOptions, "scopes");
+    const globalUnits = mapOption(globalOptions, "unitScopes");
+    const globalKeys = /* @__PURE__ */ new Set([...Object.keys(globalScopes), ...Object.keys(globalUnits)]);
+    const usedKeys = /* @__PURE__ */ new Set();
+    const excludedDirs = [];
+    const nonUnitDirs = [];
+    const collisions = /* @__PURE__ */ new Set();
+    const noteCollisions = (scopesMap, unitMap) => {
+      for (const key of Object.keys(scopesMap)) {
+        if (!Object.hasOwn(unitMap, key)) continue;
+        if (namesOf(scopesMap[key]).length === 0) continue;
+        if (namesOf(unitMap[key]).length === 0) continue;
+        collisions.add(key);
+      }
+    };
+    noteCollisions(globalScopes, globalUnits);
+    for (const dir of [...dirs].sort()) {
+      const o = resolveRuleOptions(ID6, OPTIONS5, ctx.config, { route: dir, file: dir }, compiledOverrides);
+      const scopes = mapOption(o, "scopes");
+      const unitScopes = mapOption(o, "unitScopes");
+      if (Object.keys(scopes).length === 0 && Object.keys(unitScopes).length === 0) continue;
+      noteCollisions(scopes, unitScopes);
+      const excluded = compile(listOption(o, "exclude"));
+      if (isExcluded(dir, ancestorDirs2(dir), excluded)) {
+        excludedDirs.push(dir);
+        continue;
+      }
+      const liveScopes = Object.keys(scopes).filter((k) => namesOf(scopes[k]).length > 0);
+      const isUnit = isUnitDir(dir, filesIn);
+      const liveUnits = isUnit ? Object.keys(unitScopes).filter((k) => namesOf(unitScopes[k]).length > 0) : [];
+      if (!isUnit) nonUnitDirs.push(dir);
+      const byPosition = matchKeys(dir, compile(liveScopes, true));
+      const byUnit = matchKeys(dir, compile(liveUnits, true));
+      for (const k of byPosition.matched) if (globalKeys.has(k)) usedKeys.add(k);
+      for (const k of byUnit.matched) if (globalKeys.has(k)) usedKeys.add(k);
+      let governing;
+      if (byPosition.best !== void 0 && byUnit.best !== void 0) {
+        governing = moreSpecificGlob(byUnit.best, byPosition.best) ? namesOf(unitScopes[byUnit.best]) : namesOf(scopes[byPosition.best]);
+      } else if (byPosition.best !== void 0) {
+        governing = namesOf(scopes[byPosition.best]);
+      } else if (byUnit.best !== void 0) {
+        governing = namesOf(unitScopes[byUnit.best]);
+      }
+      if (governing === void 0) continue;
+      const allowed = new Set(governing);
+      for (const child of kids.get(dir) ?? []) {
+        if (allowed.has(baseName(child))) continue;
+        if (isExcluded(child, ancestorDirs2(child), excluded)) continue;
+        const childOptions = resolveRuleOptions(
+          ID6,
+          OPTIONS5,
+          ctx.config,
+          { route: child, file: child },
+          compiledOverrides
+        );
+        if (isExcluded(child, ancestorDirs2(child), compile(listOption(childOptions, "exclude")))) continue;
+        const at = reportAt(child, files);
+        if (at === void 0) continue;
+        out.push({
+          id: ID6,
+          category: "architecture",
+          severity: "info",
+          detection: { presence: "none", value: "absent" },
+          route: child,
+          location: at,
+          message: `${child} is not one of the names declared here: ${governing.join(", ")}.`,
+          recommendation: recommendation10,
+          docsUrl: docsUrl10,
+          fix: {
+            description: "Rename it to a declared name, move it under one of them, or add its name to the declaration."
+          }
+        });
+      }
+    }
+    const notes = /* @__PURE__ */ new Map();
+    for (const key of collisions) {
+      notes.set(key, "declared in both scopes and unitScopes, so the scopes entry wins wherever both apply");
+    }
+    for (const key of globalKeys) {
+      if (notes.has(key)) continue;
+      const scopesEmpty = Object.hasOwn(globalScopes, key) && namesOf(globalScopes[key]).length === 0;
+      const unitsEmpty = Object.hasOwn(globalUnits, key) && namesOf(globalUnits[key]).length === 0;
+      if (scopesEmpty || unitsEmpty) {
+        notes.set(key, "names no directory name at all");
+      }
+    }
+    const unused = [...globalKeys].filter((k) => !notes.has(k) && !usedKeys.has(k));
+    const unitOnly = unused.filter((k) => Object.hasOwn(globalUnits, k) && !Object.hasOwn(globalScopes, k));
+    for (const key of keysMatchingAny(unitOnly, nonUnitDirs, compile)) {
+      notes.set(key, "matched directories but never a unit");
+    }
+    for (const [key, reason] of classifyUnusedKeys(
+      unused.filter((k) => !notes.has(k)),
+      excludedDirs,
+      compile
+    )) {
+      notes.set(key, reason === "only-excluded" ? "matched only excluded directories" : "matched no directory");
+    }
+    const reported = [...notes.keys()].sort();
+    if (reported.length > 0) {
+      const message = reported.length === 1 ? `The declaration '${reported[0]}' does not check what it says: ${notes.get(reported[0])}.` : `These declarations do not check what they say: ${reported.map((k) => `'${k}' (${notes.get(k)})`).join(", ")}.`;
+      out.push({
+        id: ID6,
+        category: "architecture",
+        severity: "info",
+        detection: { presence: "none", value: "absent" },
+        message,
+        recommendation: "Correct the glob or the names, or remove the declaration.",
+        docsUrl: docsUrl10
+      });
+    }
+    return out;
+  }
+};
+
+// src/rules/architecture/route-component-import.ts
+var ID7 = "architecture/route-component-import";
+var EXEMPT_IMPORTERS = ["**/*.stories.svelte", "**/*.test.svelte", "**/*.spec.svelte"];
+var ROUTES_DIR = "src/routes/";
+var ROUTE_ENTRY = /^\+(page|layout)(@.*)?\.svelte$/;
+function isRouteEntry(path) {
+  if (!path.startsWith(ROUTES_DIR)) return false;
+  const base = path.slice(path.lastIndexOf("/") + 1);
+  return base === "+error.svelte" || ROUTE_ENTRY.test(base);
+}
+function routeEntryImports(c, ctx) {
+  const out = [];
+  for (const { source, line, type } of c.importSpans ?? []) {
+    if (type) continue;
+    const target = resolveRepoLocalPath(source, c.file, ctx.project.kitAliases);
+    if (target !== void 0 && isRouteEntry(target)) out.push({ line, target });
+  }
+  return out;
+}
+var routeEntryImportsCache = /* @__PURE__ */ new WeakMap();
+function cachedRouteEntryImports(c, ctx) {
+  const cached = routeEntryImportsCache.get(c);
+  if (cached !== void 0 && cached.aliases === ctx.project.kitAliases) return cached.result;
+  const result = routeEntryImports(c, ctx);
+  routeEntryImportsCache.set(c, { aliases: ctx.project.kitAliases, result });
+  return result;
+}
+var architectureRouteComponentImport = componentRule({
+  id: ID7,
+  title: "Route component import",
+  category: "architecture",
+  severity: "info",
+  label: "Route component imports",
+  options: { exemptImporters: { kind: "string-list", default: EXEMPT_IMPORTERS } },
+  recommendation: "Extract the shared markup into a component under $lib and import that from both places, leaving the route entry to SvelteKit.",
+  rationale: "A route entry is written on the assumption that SvelteKit renders it: Kit hands a page its data and params, and an error page its page.error and page.status. Imported from somewhere else it receives none of that and renders against nothing, or against the importing page data standing in for its own.",
+  // Signal present = this file imports a route entry, exempt or not. An exempt file therefore
+  // reaches `bad` and earns a PASS, rather than being called signal-free.
+  // `_o`: this rule's option is read only in `bad`, but `ctx` is the third parameter, so the
+  // second cannot simply be omitted the way every other component rule omits what it does not use.
+  applies: (c, _o, ctx) => cachedRouteEntryImports(c, ctx).length > 0,
+  bad: (c, o, ctx) => {
+    const exempt = listOption(o, "exemptImporters").map(routeGlobToRegExp);
+    if (exempt.some((re) => re.test(c.file))) return [];
+    return cachedRouteEntryImports(c, ctx).map(({ line, target }) => ({
+      line,
+      message: `${target} is a SvelteKit route entry \u2014 imported here it renders without the data Kit would give it`
+    }));
+  }
+});
+
 // src/rules/perf/heavy-import.ts
 var HEAVY_PACKAGES = {
   lodash: "import a submodule (lodash/debounce) or use lodash-es for tree-shaking",
@@ -4665,8 +5359,8 @@ var performanceHeavyImport = componentRule({
     const seen = /* @__PURE__ */ new Set();
     const out = [];
     const spans = c.importSpans ?? c.imports.map((source) => ({ source, line: 0 }));
-    for (const { source: src, line } of spans) {
-      if (!Object.hasOwn(packages, src) || seen.has(src)) continue;
+    for (const { source: src, line, type } of spans) {
+      if (type || !Object.hasOwn(packages, src) || seen.has(src)) continue;
       seen.add(src);
       out.push({ line, message: `Heavy import "${src}" \u2014 ${packages[src]}` });
     }
@@ -4854,6 +5548,10 @@ var allRules = [
   architectureComponentSize,
   architecturePropCount,
   architecturePrivateScopeImport,
+  architectureUnitEntryFile,
+  architectureDirectoryNaming,
+  architectureReservedDirectoryNames,
+  architectureRouteComponentImport,
   performanceHeavyImport,
   performanceNamespaceImport,
   performanceMinifyDisabled,
@@ -6114,8 +6812,12 @@ export {
   applyOverrides,
   applyRuleSeverities,
   architectureComponentSize,
+  architectureDirectoryNaming,
   architecturePrivateScopeImport,
   architecturePropCount,
+  architectureReservedDirectoryNames,
+  architectureRouteComponentImport,
+  architectureUnitEntryFile,
   attrText,
   attrTextOf,
   attrValue,
@@ -6125,6 +6827,7 @@ export {
   classify,
   collectComponentFacts,
   collectKitModuleFacts,
+  collectSourceFiles,
   compileOverrides,
   computeHealth,
   computeScore,
@@ -6152,6 +6855,7 @@ export {
   escapeHtml,
   explainRule,
   findAttr,
+  findKitAliasesInSvelteConfig,
   findKitPathsBaseInSvelteConfig,
   findKitPathsBaseInViteConfig,
   findMinifyDisabled,
@@ -6166,6 +6870,7 @@ export {
   headTagRule,
   imageRule,
   intOption,
+  isMentionedAnywhere,
   isPenalized,
   lineOf,
   linkRule,
@@ -6190,6 +6895,7 @@ export {
   performanceSequentialAwaits,
   performanceStateRaw,
   renderAppShell,
+  resolveKitAliases,
   resolveKitPathsBase,
   resolveRuleOptions,
   resolveRunesModuleSpecifier,