@svelte-vitals/core 0.29.0 → 0.31.0

package/dist/index.js

@@ -4,6 +4,7 @@ var defaultProject = {
   hasSitemap: false,
   htmlLang: { presence: "none", value: "absent" }
 };
+var CATEGORIES = ["seo", "performance", "correctness", "security", "architecture"];
 var defaultConfig = {
   treatDynamicAs: "pass",
   metaComponents: [],
@@ -17,6 +18,11 @@ function defineConfig(config = {}) {
 // src/component-parse.ts
 import { parse } from "svelte/compiler";
 
+// src/base-path.ts
+function isRootRelativePath(value) {
+  return value.startsWith("/") && !value.startsWith("//");
+}
+
 // src/svelte-ast.ts
 var CHILD_NODE_KEYS = [
   "fragment",
@@ -264,6 +270,12 @@ function scopeIntroducedNames(node) {
   } else if (node.type === "AwaitBlock") {
     if (node.value) addBoundNames(node.value, introduced);
     if (node.error) addBoundNames(node.error, introduced);
+  } else if (node.type === "Fragment") {
+    for (const child of node.nodes ?? []) {
+      if (child?.type === "ConstTag" || child?.type === "DeclarationTag") {
+        for (const d of child.declaration?.declarations ?? []) addBoundNames(d.id, introduced);
+      }
+    }
   }
   return introduced;
 }
@@ -671,6 +683,7 @@ function bodyIsEmpty(fn) {
   return false;
 }
 var URL_ATTRS = ["href", "src", "action", "formaction"];
+var CHECKABLE_INPUT_TYPES = /* @__PURE__ */ new Set(["checkbox", "radio"]);
 function collectSecurityFacts(node, source, htmlTags, jsUrls) {
   if (Array.isArray(node)) {
     for (const child of node) collectSecurityFacts(child, source, htmlTags, jsUrls);
@@ -692,6 +705,59 @@ function collectSecurityFacts(node, source, htmlTags, jsUrls) {
     if (key in node) collectSecurityFacts(node[key], source, htmlTags, jsUrls);
   }
 }
+function collectCheckableBindValues(node, source, acc) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectCheckableBindValues(child, source, acc);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "RegularElement" && node.name === "input" && Array.isArray(node.attributes)) {
+    const typeAttr = findAttr(node.attributes, "type");
+    const typeValue = typeAttr ? attrTextOf(typeAttr) : void 0;
+    if (typeValue && CHECKABLE_INPUT_TYPES.has(typeValue)) {
+      const bindValue = node.attributes.find((a) => a?.type === "BindDirective" && a.name === "value");
+      if (bindValue) {
+        acc.push({
+          kind: typeValue,
+          line: lineOf(source, bindValue.start ?? node.start)
+        });
+      }
+    }
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectCheckableBindValues(node[key], source, acc);
+  }
+}
+function collectHrefLinks(node, source, acc) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectHrefLinks(child, source, acc);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "RegularElement" && node.name === "a" && Array.isArray(node.attributes)) {
+    const attr = findAttr(node.attributes, "href");
+    const value = attr ? attrTextOf(attr) : void 0;
+    if (value !== void 0 && isRootRelativePath(value)) {
+      acc.push({ kind: "href", path: value, line: lineOf(source, attr?.start ?? node.start) });
+    }
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectHrefLinks(node[key], source, acc);
+  }
+}
+var GOTO_NAMES = /* @__PURE__ */ new Set(["goto"]);
+function collectGotoLinks(locals, roots, source, acc) {
+  if (locals.size === 0) return;
+  for (const root of roots) {
+    if (!root) continue;
+    walkEstree(root, (n) => {
+      if (n.type !== "CallExpression" || n.callee?.type !== "Identifier" || !locals.has(n.callee.name)) return;
+      const arg = n.arguments?.[0];
+      if (arg?.type !== "Literal" || typeof arg.value !== "string" || !isRootRelativePath(arg.value)) return;
+      acc.push({ kind: "goto", path: arg.value, line: lineOf(source, n.start) });
+    });
+  }
+}
 function isPropsCall(node) {
   return node?.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "$props";
 }
@@ -791,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 } : {}
+      });
     }
   });
 }
@@ -977,20 +1052,25 @@ var BROWSER_GLOBALS = /* @__PURE__ */ new Set([
   "confirm",
   "prompt"
 ]);
-function collectBrowserGuardImports(program) {
+function collectNamedImportAliases(program, moduleSource, names) {
   const out = /* @__PURE__ */ new Set();
   for (const stmt of program.body ?? []) {
-    if (stmt?.type !== "ImportDeclaration" || stmt.importKind === "type" || stmt.source?.value !== "$app/environment")
+    if (stmt?.type !== "ImportDeclaration" || stmt.importKind === "type" || stmt.source?.value !== moduleSource) {
       continue;
+    }
     for (const s of stmt.specifiers ?? []) {
       if (s?.importKind === "type" || s?.local?.type !== "Identifier") continue;
-      if (s.type === "ImportSpecifier" && s.imported?.type === "Identifier" && s.imported.name === "browser") {
+      if (s.type === "ImportSpecifier" && s.imported?.type === "Identifier" && names.has(s.imported.name)) {
         out.add(s.local.name);
       }
     }
   }
   return out;
 }
+var BROWSER_GUARD_NAMES = /* @__PURE__ */ new Set(["browser"]);
+function collectBrowserGuardImports(program) {
+  return collectNamedImportAliases(program, "$app/environment", BROWSER_GUARD_NAMES);
+}
 function collectProgramBindings(program) {
   const bound = /* @__PURE__ */ new Set();
   for (const stmt of program.body ?? []) {
@@ -1168,6 +1248,14 @@ function parseModuleFacts(source, filename) {
   const orphanLifecycleCalls = program ? collectOrphanLifecycleCalls(program, wrapped).map((f) => ({ ...f, line: shift(f.line) })) : [];
   const browserGlobalRefs = program ? collectBrowserGlobalRefs(program, wrapped).map((r) => ({ ...r, line: shift(r.line), context: "module" })) : [];
   const moduleStateDecls = program ? collectModuleStateDecls(program, wrapped).map((d) => ({ ...d, line: shift(d.line) })) : [];
+  const basePathLinks = [];
+  if (program) {
+    const locals = collectNamedImportAliases(program, "$app/navigation", GOTO_NAMES);
+    const raw = [];
+    collectGotoLinks(locals, [program], wrapped, raw);
+    for (const l of raw) basePathLinks.push({ ...l, line: shift(l.line) });
+    basePathLinks.sort((a, b) => a.line - b.line);
+  }
   return {
     eachBlocks: [],
     effects: [],
@@ -1183,6 +1271,8 @@ function parseModuleFacts(source, filename) {
     stalePropDerivations: [],
     rawableStates: [],
     nonreactiveBuiltinStates: [],
+    checkableBindValues: [],
+    basePathLinks,
     suppressions: collectSuppressions(source),
     orphanEffects,
     orphanLifecycleCalls,
@@ -1198,6 +1288,18 @@ function parseComponentFacts(source, filename) {
   const htmlTags = [];
   const javascriptUrls = [];
   collectSecurityFacts(ast.fragment ?? ast, source, htmlTags, javascriptUrls);
+  const checkableBindValues = [];
+  collectCheckableBindValues(ast.fragment ?? ast, source, checkableBindValues);
+  const basePathLinks = [];
+  collectHrefLinks(ast.fragment ?? ast, source, basePathLinks);
+  const gotoPrograms = [ast.module?.content, ast.instance?.content].filter(Boolean);
+  const gotoLocals = /* @__PURE__ */ new Set();
+  for (const p of gotoPrograms)
+    for (const n of collectNamedImportAliases(p, "$app/navigation", GOTO_NAMES)) {
+      gotoLocals.add(n);
+    }
+  collectGotoLinks(gotoLocals, [...gotoPrograms, ast.fragment], source, basePathLinks);
+  basePathLinks.sort((a, b) => a.line - b.line);
   const loc = countLines(source);
   const suppressions = collectSuppressions(source);
   const moduleProgram = ast.module?.content;
@@ -1372,6 +1474,8 @@ function parseComponentFacts(source, filename) {
     stalePropDerivations,
     rawableStates,
     nonreactiveBuiltinStates,
+    checkableBindValues,
+    basePathLinks,
     orphanEffects,
     orphanLifecycleCalls,
     browserGlobalRefs,
@@ -1398,6 +1502,8 @@ function emptyComponentFacts(file) {
     stalePropDerivations: [],
     rawableStates: [],
     nonreactiveBuiltinStates: [],
+    checkableBindValues: [],
+    basePathLinks: [],
     orphanEffects: [],
     orphanLifecycleCalls: [],
     browserGlobalRefs: [],
@@ -1419,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",
@@ -1534,6 +1646,22 @@ function collectAwaits(node, out = []) {
   }
   return out;
 }
+var REDIRECT_NAMES = /* @__PURE__ */ new Set(["redirect"]);
+function collectRedirectCalls(node, locals, out = []) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectRedirectCalls(child, locals, out);
+    return out;
+  }
+  if (!node || typeof node !== "object" || typeof node.type !== "string") return out;
+  if (node.type === "CallExpression" && node.callee?.type === "Identifier" && locals.has(node.callee.name)) {
+    out.push(node);
+  }
+  for (const key of Object.keys(node)) {
+    if (WALK_IGNORED_KEYS.has(key)) continue;
+    collectRedirectCalls(node[key], locals, out);
+  }
+  return out;
+}
 function isParentCall(arg) {
   const e = unwrapTs(arg);
   if (e?.type !== "CallExpression") return false;
@@ -1683,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 = [];
@@ -1721,6 +1866,7 @@ function parseKitModuleFacts(source, filename) {
       runesModuleImports,
       lifecycleCalls,
       browserGlobalRefs,
+      basePathLinks: [],
       suppressions
     };
   }
@@ -1736,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();
@@ -1810,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) => {
@@ -1845,6 +1992,15 @@ function parseKitModuleFacts(source, filename) {
     }
   });
   const byLine = (arr) => arr.sort((a, b) => a.line - b.line);
+  const basePathLinks = [];
+  const redirectLocals = collectNamedImportAliases(program, "@sveltejs/kit", REDIRECT_NAMES);
+  if (redirectLocals.size > 0) {
+    for (const call of collectRedirectCalls(program, redirectLocals)) {
+      const arg = call.arguments?.[1];
+      if (arg?.type !== "Literal" || typeof arg.value !== "string" || !isRootRelativePath(arg.value)) continue;
+      basePathLinks.push({ kind: "redirect", path: arg.value, line: line(call.start) });
+    }
+  }
   return {
     moduleStateReassignments: byLine(moduleStateReassignments),
     importedStateWrites: byLine(importedStateWrites),
@@ -1852,6 +2008,7 @@ function parseKitModuleFacts(source, filename) {
     runesModuleImports: byLine(runesModuleImports),
     lifecycleCalls: byLine(lifecycleCalls),
     browserGlobalRefs: byLine(browserGlobalRefs),
+    basePathLinks: byLine(basePathLinks),
     ...ssrOptOut ? { ssrDisabled: { line: Math.max(0, ssrOptOut.line - 1) } } : {},
     ...csrOptOut ? { csrDisabled: { line: Math.max(0, csrOptOut.line - 1) } } : {},
     ...waterfalls.dependentLines.length > 0 || waterfalls.independentLines.length > 0 ? { loadWaterfalls: waterfalls } : {},
@@ -1870,6 +2027,7 @@ function emptyKitModuleFacts(file, kind) {
     runesModuleImports: [],
     lifecycleCalls: [],
     browserGlobalRefs: [],
+    basePathLinks: [],
     suppressions: []
   };
 }
@@ -1877,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}",
@@ -1891,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);
       }
@@ -1899,7 +2057,7 @@ async function collectKitModuleFacts(rt, cwd) {
   );
 }
 
-// src/vite-config-parse.ts
+// src/config-object.ts
 function propOf(obj, name) {
   let found;
   for (const p of obj.properties) {
@@ -1954,6 +2112,8 @@ function resolveConfigObject(program) {
   if (!exported) return void 0;
   return unwrapToObjectExpression(exported, collectTopLevelBindings(program));
 }
+
+// src/vite-config-parse.ts
 function findMinifyDisabled(source) {
   let program;
   let wrapped;
@@ -1974,6 +2134,152 @@ function findMinifyDisabled(source) {
   return { line: Math.max(0, lineOf(wrapped, minify.start) - 1) };
 }
 
+// src/svelte-config-parse.ts
+function basePathOf(kitConfig, bindings) {
+  const paths = propOf(kitConfig, "paths");
+  const pathsObj = paths ? unwrapToObjectExpression(paths.value, bindings) : void 0;
+  if (!pathsObj) return void 0;
+  const base = propOf(pathsObj, "base");
+  if (!base) return void 0;
+  const value = unwrapTs(base.value);
+  if (value.type === "Literal") {
+    return typeof value.value === "string" && value.value !== "" ? { value: value.value } : void 0;
+  }
+  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;
+  } catch {
+    return void 0;
+  }
+}
+function findKitPathsBaseInSvelteConfig(source) {
+  const program = programOf(source, "svelte.config.js");
+  if (!program) return void 0;
+  const config = resolveConfigObject(program);
+  if (!config) return void 0;
+  const bindings = collectTopLevelBindings(program);
+  const kit = propOf(config, "kit");
+  const kitObj = kit ? unwrapToObjectExpression(kit.value, bindings) : void 0;
+  return kitObj ? basePathOf(kitObj, bindings) : void 0;
+}
+function sveltekitLocalNames(program) {
+  const out = collectNamedImportAliases(program, "@sveltejs/kit/vite", /* @__PURE__ */ new Set(["sveltekit"]));
+  if (out.size === 0) out.add("sveltekit");
+  return out;
+}
+function findKitPathsBaseInViteConfig(source) {
+  const none = { kind: "no-plugin-config" };
+  const program = programOf(source, "vite.config.ts");
+  if (!program) return none;
+  const config = resolveConfigObject(program);
+  if (!config) return none;
+  const bindings = collectTopLevelBindings(program);
+  const plugins = propOf(config, "plugins");
+  const pluginsValue = plugins ? unwrapTs(plugins.value) : void 0;
+  if (pluginsValue?.type !== "ArrayExpression") return none;
+  const locals = sveltekitLocalNames(program);
+  for (const el of pluginsValue.elements) {
+    if (!el || el.type === "SpreadElement") continue;
+    const call = unwrapTs(el);
+    if (call.type !== "CallExpression") continue;
+    if (call.callee.type !== "Identifier" || !locals.has(call.callee.name)) continue;
+    const arg = call.arguments[0];
+    if (arg === void 0) return none;
+    const kitConfig = unwrapToObjectExpression(arg, bindings);
+    if (!kitConfig) return { kind: "unresolvable" };
+    const base = basePathOf(kitConfig, bindings);
+    return base ? { kind: "resolved", base } : { kind: "resolved" };
+  }
+  return none;
+}
+function resolveKitPathsBase(viteConfig, svelteConfig) {
+  if (viteConfig) {
+    const result = findKitPathsBaseInViteConfig(viteConfig.source);
+    if (result.kind === "unresolvable") return void 0;
+    if (result.kind === "resolved") {
+      return result.base ? { ...result.base, file: viteConfig.file } : void 0;
+    }
+  }
+  if (!svelteConfig) return void 0;
+  const base = findKitPathsBaseInSvelteConfig(svelteConfig.source);
+  return base ? { ...base, file: svelteConfig.file } : void 0;
+}
+
 // src/project-paths.ts
 var ROBOTS_SOURCE_PATHS = [
   "static/robots.txt",
@@ -1985,6 +2291,15 @@ var SITEMAP_SOURCE_PATHS = [
   "src/routes/sitemap.xml/+server.ts",
   "src/routes/sitemap.xml/+server.js"
 ];
+var VITE_CONFIG_FILES = [
+  "vite.config.js",
+  "vite.config.mjs",
+  "vite.config.ts",
+  "vite.config.cjs",
+  "vite.config.mts",
+  "vite.config.cts"
+];
+var SVELTE_CONFIG_FILES = ["svelte.config.js", "svelte.config.ts"];
 
 // src/rule.ts
 function docsUrlFor(id) {
@@ -2054,7 +2369,7 @@ function detect(head, match) {
   return tag ? { presence: tag.presence, value: tag.value } : { presence: "none", value: "absent" };
 }
 function headTagRule(opts) {
-  const docsUrl7 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   return {
     id: opts.id,
     title: opts.title,
@@ -2077,7 +2392,7 @@ function headTagRule(opts) {
           location: head.file,
           message,
           recommendation: opts.recommendation,
-          docsUrl: docsUrl7,
+          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 } } : {}
@@ -2270,7 +2585,7 @@ var seoHtmlLang = {
 
 // src/rules/perf/image-rule.ts
 function imageRule(opts) {
-  const docsUrl7 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   const category = opts.category ?? "performance";
   return {
     id: opts.id,
@@ -2294,7 +2609,7 @@ function imageRule(opts) {
             route: route.route,
             message: opts.label,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl7
+            docsUrl: docsUrl11
           });
           continue;
         }
@@ -2309,7 +2624,7 @@ function imageRule(opts) {
             ...img.line > 0 ? { line: img.line } : {},
             message: `Missing ${opts.label}`,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl7,
+            docsUrl: docsUrl11,
             ...opts.fix ? { fix: { ...opts.fix } } : {}
           });
         }
@@ -2369,7 +2684,7 @@ var performanceResponsiveImage = imageRule({
 
 // src/rules/perf/link-rule.ts
 function linkRule(opts) {
-  const docsUrl7 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   return {
     id: opts.id,
     title: opts.title,
@@ -2393,7 +2708,7 @@ function linkRule(opts) {
             route: head.route,
             message: opts.label,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl7
+            docsUrl: docsUrl11
           });
           continue;
         }
@@ -2410,7 +2725,7 @@ function linkRule(opts) {
             location: tag.file ?? head.file,
             message: `Missing ${opts.label}`,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl7,
+            docsUrl: docsUrl11,
             ...opts.fix ? { fix: { ...opts.fix } } : {}
           });
         }
@@ -2557,10 +2872,201 @@ var performanceRenderBlockingScript = {
   }
 };
 
+// src/config-apply.ts
+function settingSeverity(setting) {
+  if (setting === void 0) return void 0;
+  if (typeof setting === "string") return setting;
+  return setting.severity;
+}
+function settingOptions(setting) {
+  return setting !== void 0 && typeof setting !== "string" ? setting.options : void 0;
+}
+function selectRules(rules, config) {
+  return rules.filter((rule) => settingSeverity(config.rules[rule.id]) !== "off");
+}
+function applyRuleSeverities(results, config) {
+  return results.map((result) => {
+    const severity = settingSeverity(config.rules[result.id]);
+    return severity !== void 0 && severity !== "off" ? { ...result, severity } : result;
+  });
+}
+function routeGlobToRegExp(pattern) {
+  const body = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").split("\0").join(".*");
+  const source = body.endsWith("/.*") ? `${body.slice(0, -3)}(/.*)?` : body;
+  return new RegExp(`^${source}$`);
+}
+function toPatterns(globs) {
+  if (globs === void 0) return [];
+  return (Array.isArray(globs) ? globs : [globs]).map(routeGlobToRegExp);
+}
+function compileOverrides(config) {
+  return (config.overrides ?? []).map((o) => ({
+    routes: toPatterns(o.route),
+    files: toPatterns(o.files),
+    rules: o.rules
+  }));
+}
+function overrideMatches(o, target) {
+  const { route, file } = target;
+  return route !== void 0 && o.routes.some((p) => p.test(route)) || file !== void 0 && o.files.some((p) => p.test(file));
+}
+function applyOverrides(results, config) {
+  const compiled = compileOverrides(config);
+  if (compiled.length === 0) return results;
+  const out = [];
+  for (const result of results) {
+    let severity;
+    for (const o of compiled) {
+      if (!overrideMatches(o, { route: result.route, file: result.location })) continue;
+      const sev = settingSeverity(o.rules[result.id]) ?? settingSeverity(o.rules[result.category ?? "seo"]);
+      if (sev !== void 0) severity = sev;
+    }
+    if (severity === void 0) out.push(result);
+    else if (severity !== "off") out.push({ ...result, severity });
+  }
+  return out;
+}
+
+// src/rule-options.ts
+var RULE_SETTING_VALUES = ["off", "critical", "warning", "info"];
+function defaultsOf(spec) {
+  const out = {};
+  for (const [key, s] of Object.entries(spec)) {
+    out[key] = s.kind === "integer" ? s.default : s.kind === "string-list" ? [...s.default] : { ...s.default };
+  }
+  return out;
+}
+function intOption(options, key, fallback = 0) {
+  const v = options[key];
+  return typeof v === "number" ? v : fallback;
+}
+function listOption(options, key) {
+  const v = options[key];
+  return Array.isArray(v) ? v : [];
+}
+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);
+  const layers = [settingOptions(config.rules[ruleId])];
+  if (target) {
+    for (const o of compiled ?? compileOverrides(config)) {
+      if (overrideMatches(o, target)) layers.push(settingOptions(o.rules[ruleId]));
+    }
+  }
+  for (const layer of layers) {
+    if (!layer) continue;
+    for (const [key, value] of Object.entries(layer)) {
+      const s = spec[key];
+      if (!s) continue;
+      if (s.kind === "integer") out[key] = value;
+      else if (s.kind === "string-list") out[key] = [...out[key], ...value];
+      else out[key] = { ...out[key], ...value };
+    }
+  }
+  return out;
+}
+function validateRuleOptions(ruleId, spec, options, baseline, skipRangeCheck) {
+  if (!spec) return Object.keys(options).length === 0 ? [] : [`${ruleId} takes no options.`];
+  const errors = [];
+  const badKeys = /* @__PURE__ */ new Set();
+  const isNonEmptyString = (v) => typeof v === "string" && v.length > 0;
+  for (const [key, value] of Object.entries(options)) {
+    const s = spec[key];
+    if (!s) {
+      errors.push(`${ruleId}: unknown option '${key}'. Known options: ${Object.keys(spec).join(", ")}.`);
+      continue;
+    }
+    if (s.kind === "integer") {
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        errors.push(`${ruleId}.${key} must be an integer.`);
+        badKeys.add(key);
+      } else if (s.min !== void 0 && value < s.min) {
+        errors.push(`${ruleId}.${key} must be >= ${s.min}.`);
+        badKeys.add(key);
+      } else if (s.max !== void 0 && value > s.max) {
+        errors.push(`${ruleId}.${key} must be <= ${s.max}.`);
+        badKeys.add(key);
+      }
+    } else if (s.kind === "string-list") {
+      if (!Array.isArray(value) || !value.every(isNonEmptyString)) {
+        errors.push(`${ruleId}.${key} must be an array of non-empty strings.`);
+      }
+    } else if (typeof value !== "object" || value === null || Array.isArray(value) || !Object.values(value).every(isNonEmptyString)) {
+      errors.push(`${ruleId}.${key} must be an object of string \u2192 non-empty string.`);
+    }
+  }
+  const minSpec = spec.min;
+  const maxSpec = spec.max;
+  if (minSpec?.kind === "integer" && maxSpec?.kind === "integer" && !badKeys.has("min") && !badKeys.has("max") && !skipRangeCheck) {
+    const base = baseline ?? defaultsOf(spec);
+    const minVal = "min" in options ? options.min : base.min;
+    const maxVal = "max" in options ? options.max : base.max;
+    if (typeof minVal === "number" && typeof maxVal === "number" && minVal > maxVal) {
+      errors.push(`${ruleId}: min (${minVal}) must be <= max (${maxVal}).`);
+    }
+  }
+  return errors;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function otherOverrideNarrowsOppositeSide(overrides, selfIndex, key, side) {
+  return overrides.some((entry, i) => {
+    if (i === selfIndex || !isPlainObject(entry) || !isPlainObject(entry.rules)) return false;
+    const setting = entry.rules[key];
+    return isPlainObject(setting) && isPlainObject(setting.options) && side in setting.options;
+  });
+}
+function shouldSkipRangeCheck(overrides, selfIndex, key, setting) {
+  if (!isPlainObject(setting) || !isPlainObject(setting.options)) return false;
+  const setsMin = "min" in setting.options;
+  const setsMax = "max" in setting.options;
+  if (setsMin === setsMax) return false;
+  return otherOverrideNarrowsOppositeSide(overrides, selfIndex, key, setsMin ? "max" : "min");
+}
+function validateRuleSetting(label, ruleId, setting, spec, opts) {
+  const expected = RULE_SETTING_VALUES.join("|");
+  if (typeof setting === "string") {
+    return RULE_SETTING_VALUES.includes(setting) ? [] : [`${label}: invalid setting '${setting}'; expected ${expected}.`];
+  }
+  if (!isPlainObject(setting)) {
+    return [`${label}: must be ${expected} or an object with 'severity' and/or 'options'.`];
+  }
+  const errors = [];
+  const unknownKeys = Object.keys(setting).filter((k) => k !== "severity" && k !== "options");
+  if (unknownKeys.length > 0) {
+    errors.push(`${label}: unknown key(s) ${unknownKeys.join(", ")}; expected severity, options.`);
+  }
+  if (setting.severity !== void 0 && !RULE_SETTING_VALUES.includes(setting.severity)) {
+    errors.push(`${label}.severity: invalid setting '${String(setting.severity)}'; expected ${expected}.`);
+  }
+  if (setting.options === void 0) return errors;
+  if (!opts.allowOptions) {
+    errors.push(`${label}: options are not allowed on a category key.`);
+    return errors;
+  }
+  if (!isPlainObject(setting.options)) {
+    errors.push(`${label}.options: must be an object.`);
+    return errors;
+  }
+  const optionErrors = validateRuleOptions(ruleId, spec, setting.options, opts.baseline, opts.skipRangeCheck);
+  if (optionErrors.length > 0) errors.push(`${label}: ${optionErrors.join(" ")}`);
+  return errors;
+}
+
 // src/rules/perf/preconnect.ts
 var docsUrl3 = docsUrlFor("performance/preconnect");
 var recommendation3 = 'Add <link rel="preconnect"> (or dns-prefetch) for the third-party origin so the connection is set up early.';
 var THIRD_PARTY_ORIGINS = /* @__PURE__ */ new Set(["fonts.googleapis.com", "fonts.gstatic.com"]);
+var OPTIONS = { origins: { kind: "string-list", default: [...THIRD_PARTY_ORIGINS] } };
 function hostOf(href) {
   const m = /^(?:https?:)?\/\/([^/?#]+)/i.exec(href);
   return m ? m[1].toLowerCase() : void 0;
@@ -2577,17 +3083,30 @@ var performancePreconnect = {
     snippet: '<link rel="preconnect" href="https://fonts.googleapis.com" />',
     lang: "html"
   },
+  options: OPTIONS,
   async check(ctx) {
     const out = [];
+    const compiled = compileOverrides(ctx.config);
     for (const head of ctx.heads) {
       const referenced = /* @__PURE__ */ new Map();
       const covered = /* @__PURE__ */ new Set();
       for (const tag of head.tags) {
         if (tag.kind !== "link" && tag.kind !== "script" || typeof tag.href !== "string") continue;
         const host = hostOf(tag.href);
-        if (!host || !THIRD_PARTY_ORIGINS.has(host)) continue;
-        if (tag.kind === "link" && (tag.rel === "preconnect" || tag.rel === "dns-prefetch")) covered.add(host);
-        else if (!referenced.has(host)) referenced.set(host, tag.file);
+        if (!host) continue;
+        if (tag.kind === "link" && (tag.rel === "preconnect" || tag.rel === "dns-prefetch")) {
+          covered.add(host);
+          continue;
+        }
+        const o = resolveRuleOptions(
+          "performance/preconnect",
+          OPTIONS,
+          ctx.config,
+          { route: head.route, file: tag.file ?? head.file },
+          compiled
+        );
+        if (!listOption(o, "origins").includes(host)) continue;
+        if (!referenced.has(host)) referenced.set(host, tag.file);
       }
       if (referenced.size === 0) continue;
       const missing = [...referenced].filter(([host]) => !covered.has(host));
@@ -2638,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 docsUrl7 = 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);
@@ -2653,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: docsUrl7,
+        docsUrl: docsUrl11,
         fix: { ...FIX5 }
       });
     }
@@ -2904,7 +3423,7 @@ function jsonldTags(head) {
   return head.tags.filter((t) => t.kind === "jsonld" && typeof t.jsonld === "string");
 }
 function jsonldRule(opts) {
-  const docsUrl7 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   return {
     id: opts.id,
     title: opts.title,
@@ -2932,7 +3451,7 @@ function jsonldRule(opts) {
               location: head.file,
               message: problem,
               recommendation: opts.recommendation,
-              docsUrl: docsUrl7,
+              docsUrl: docsUrl11,
               ...opts.fix ? { fix: { ...opts.fix } } : {}
             } : {
               id: opts.id,
@@ -2942,7 +3461,7 @@ function jsonldRule(opts) {
               route: head.route,
               message: opts.label,
               recommendation: opts.recommendation,
-              docsUrl: docsUrl7
+              docsUrl: docsUrl11
             }
           );
         }
@@ -2966,7 +3485,7 @@ var seoJsonLdValidity = {
     lang: "svelte"
   },
   async check(ctx) {
-    const docsUrl7 = 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)) {
@@ -2985,7 +3504,7 @@ var seoJsonLdValidity = {
             location: head.file,
             message: problem,
             recommendation: "Make the JSON-LD valid JSON with both @context and @type.",
-            docsUrl: docsUrl7,
+            docsUrl: docsUrl11,
             fix: { ...seoJsonLdValidity.fix }
           } : {
             id: "seo/json-ld-validity",
@@ -2995,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: docsUrl7
+            docsUrl: docsUrl11
           }
         );
       }
@@ -3106,7 +3625,11 @@ function visibleLength(s) {
 
 // src/rules/seo/length-rule.ts
 function lengthRule(opts) {
-  const docsUrl7 = 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 }
+  };
   return {
     id: opts.id,
     title: opts.title,
@@ -3114,15 +3637,22 @@ function lengthRule(opts) {
     severity: "info",
     scope: "route",
     rationale: opts.rationale,
+    options: spec,
     async check(ctx) {
       const out = [];
+      const compiled = compileOverrides(ctx.config);
       for (const head of ctx.heads) {
         const tag = head.tags.find(opts.match);
         if (!tag || typeof tag.text !== "string") continue;
+        const location = tag.file ?? head.file;
+        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 recommendation11 = typeof opts.recommendation === "function" ? opts.recommendation(o) : opts.recommendation;
         const len = visibleLength(tag.text);
         let problem;
-        if (len < opts.min) problem = `${opts.noun} is too short (${len} chars; aim for ${opts.min}\u2013${opts.max})`;
-        else if (len > opts.max) problem = `${opts.noun} is too long (${len} chars; aim for ${opts.min}\u2013${opts.max})`;
+        if (len < min) problem = `${opts.noun} is too short (${len} chars; aim for ${min}\u2013${max})`;
+        else if (len > max) problem = `${opts.noun} is too long (${len} chars; aim for ${min}\u2013${max})`;
         out.push(
           problem ? {
             id: opts.id,
@@ -3130,10 +3660,10 @@ function lengthRule(opts) {
             severity: "info",
             detection: PENALIZED,
             route: head.route,
-            location: tag.file ?? head.file,
+            location,
             message: problem,
-            recommendation: opts.recommendation,
-            docsUrl: docsUrl7
+            recommendation: recommendation11,
+            docsUrl: docsUrl11
           } : {
             id: opts.id,
             category: "seo",
@@ -3141,8 +3671,8 @@ function lengthRule(opts) {
             detection: PASS,
             route: head.route,
             message: opts.label,
-            recommendation: opts.recommendation,
-            docsUrl: docsUrl7
+            recommendation: recommendation11,
+            docsUrl: docsUrl11
           }
         );
       }
@@ -3152,28 +3682,32 @@ function lengthRule(opts) {
 }
 
 // src/rules/seo/title-length.ts
+var MIN = 30;
+var MAX = 60;
 var seoTitleLength = lengthRule({
   id: "seo/title-length",
   title: "Title length",
   label: "Title length",
   noun: "Title",
   match: (t) => t.kind === "title",
-  min: 30,
-  max: 60,
-  recommendation: "Aim for a title of 30\u201360 characters so it is not truncated in search results.",
+  min: MIN,
+  max: MAX,
+  recommendation: (o) => `Aim for a title of ${intOption(o, "min", MIN)}\u2013${intOption(o, "max", MAX)} characters so it is not truncated in search results.`,
   rationale: "A title that is too short wastes the strongest on-page signal; one that is too long is truncated in the SERP."
 });
 
 // src/rules/seo/description-length.ts
+var MIN2 = 70;
+var MAX2 = 160;
 var seoDescriptionLength = lengthRule({
   id: "seo/description-length",
   title: "Description length",
   label: "Description length",
   noun: "Description",
   match: (t) => t.kind === "meta" && t.name === "description",
-  min: 70,
-  max: 160,
-  recommendation: "Aim for a meta description of 70\u2013160 characters so it is not truncated in search results.",
+  min: MIN2,
+  max: MAX2,
+  recommendation: (o) => `Aim for a meta description of ${intOption(o, "min", MIN2)}\u2013${intOption(o, "max", MAX2)} characters so it is not truncated in search results.`,
   rationale: "A description that is too short under-uses the SERP snippet; one that is too long is truncated by search engines."
 });
 
@@ -3323,7 +3857,7 @@ var seoSingleH1 = {
 
 // src/rules/seo/uniqueness-rule.ts
 function uniquenessRule(opts) {
-  const docsUrl7 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   return {
     id: opts.id,
     title: opts.title,
@@ -3353,7 +3887,7 @@ function uniquenessRule(opts) {
           location: e.file,
           message: `${opts.noun} is duplicated across ${n} routes`,
           recommendation: opts.recommendation,
-          docsUrl: docsUrl7
+          docsUrl: docsUrl11
         } : {
           id: opts.id,
           category: "seo",
@@ -3362,7 +3896,7 @@ function uniquenessRule(opts) {
           route: e.route,
           message: opts.label,
           recommendation: opts.recommendation,
-          docsUrl: docsUrl7
+          docsUrl: docsUrl11
         };
       });
     }
@@ -3450,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 docsUrl7 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   const severity = opts.severity ?? "warning";
   return {
     id: opts.id,
@@ -3474,7 +4008,7 @@ function kitModuleRule(opts) {
             route: m.file,
             message: opts.label,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl7
+            docsUrl: docsUrl11
           });
           continue;
         }
@@ -3489,7 +4023,7 @@ function kitModuleRule(opts) {
             ...b.line > 0 ? { line: b.line } : {},
             message: b.message,
             recommendation: opts.recommendation,
-            docsUrl: docsUrl7,
+            docsUrl: docsUrl11,
             ...opts.fix ? { fix: { ...opts.fix } } : {}
           });
         }
@@ -3525,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 docsUrl7 = docsUrlFor(opts.id);
+  const docsUrl11 = docsUrlFor(opts.id);
   const severity = opts.severity ?? "warning";
   return {
     id: opts.id,
@@ -3535,11 +4069,15 @@ function componentRule(opts) {
     scope: "component",
     rationale: opts.rationale,
     ...opts.fix ? { fix: opts.fix } : {},
+    ...opts.options ? { options: opts.options } : {},
     async check(ctx) {
       const out = [];
+      const compiled = compileOverrides(ctx.config);
       for (const c of ctx.components ?? []) {
-        if (!opts.applies(c)) continue;
-        const bad = opts.bad(c).filter((b) => !(b.line > 0 && isSuppressed2(c, opts.id, b.line)));
+        const o = resolveRuleOptions(opts.id, opts.options, ctx.config, { route: c.file, file: c.file }, compiled);
+        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,
@@ -3548,8 +4086,8 @@ function componentRule(opts) {
             detection: PASS3,
             route: c.file,
             message: opts.label,
-            recommendation: opts.recommendation,
-            docsUrl: docsUrl7
+            recommendation: recommendation11,
+            docsUrl: docsUrl11
           });
           continue;
         }
@@ -3563,8 +4101,8 @@ function componentRule(opts) {
             location: c.file,
             ...b.line > 0 ? { line: b.line } : {},
             message: b.message,
-            recommendation: opts.recommendation,
-            docsUrl: docsUrl7,
+            recommendation: recommendation11,
+            docsUrl: docsUrl11,
             ...opts.fix ? { fix: { ...opts.fix } } : {}
           });
         }
@@ -3694,6 +4232,25 @@ var correctnessNonreactiveBuiltinState = componentRule({
   }))
 });
 
+// src/rules/correctness/checkable-bind-value.ts
+var correctnessCheckableBindValue = componentRule({
+  id: "correctness/checkable-bind-value",
+  title: "bind:value on a checkable input",
+  category: "correctness",
+  severity: "warning",
+  label: "bind:checked / bind:group on checkable inputs",
+  recommendation: "Replace bind:value with bind:checked (single checkbox) or bind:group (checkbox list / radio group).",
+  rationale: "bind:value binds the DOM value property. A checkbox/radio's user interaction toggles checkedness, which bind:value never observes \u2014 the bound state is frozen at its initial value. Svelte's checked/grouped bindings (bind:checked, bind:group) are built for exactly this.",
+  fix: {
+    description: "For a single checkbox, replace bind:value={x} with bind:checked={x} (x becomes a boolean). For a checkbox list or radio group, replace bind:value={x} with bind:group={x} on every input sharing the group, keeping each input's static value attribute to identify the option."
+  },
+  applies: (c) => c.checkableBindValues.length > 0,
+  bad: (c) => c.checkableBindValues.map((v) => ({
+    line: v.line,
+    message: v.kind === "checkbox" ? "bind:value on a checkbox does not track its checked state \u2014 the bound value silently never updates when the user toggles it. Use bind:checked (single checkbox) or bind:group (checkbox list) instead." : "bind:value on a radio input does not track which option is selected \u2014 the bound value silently never updates when the user picks one. Use bind:group with a shared group variable across the radio inputs instead."
+  }))
+});
+
 // src/rules/correctness/orphan-effect.ts
 var correctnessOrphanEffect = componentRule({
   id: "correctness/orphan-effect",
@@ -3793,24 +4350,35 @@ var correctnessOrphanLifecycle = {
   }
 };
 
-// src/rules/correctness/server-browser-global.ts
+// src/rules/correctness/base-path-navigation.ts
 var PENALIZED5 = { presence: "none", value: "absent" };
 var PASS5 = { presence: "own", value: "static" };
-var ID2 = "correctness/server-browser-global";
+var ID2 = "correctness/base-path-navigation";
 var DOCS_URL2 = docsUrlFor(ID2);
-var LABEL2 = "Server-safe module code";
-var RECOMMENDATION2 = "Move browser-only code into onMount or $effect (they never run on the server), or guard it with browser from $app/environment (or a typeof check).";
-var moduleMessage = (name) => `${name} is accessed at module scope \u2014 it does not exist on the server, so importing this file crashes SSR with "${name} is not defined"`;
+var LABEL2 = "Base-path-aware navigation";
+var RECOMMENDATION2 = "Wrap root-relative paths in resolve() from '$app/paths' so they resolve against kit.paths.base.";
+var FIX7 = {
+  description: "Import { resolve } from '$app/paths' and wrap the path: href={resolve('/about')}, goto(resolve('/about')), redirect(303, resolve('/login'))."
+};
+function messageFor2(link) {
+  if (link.kind === "href") {
+    return `<a href="${link.path}"> is root-relative \u2014 under this project's kit.paths.base it points at the domain root, outside the app, and 404s in production. Use resolve('${link.path}') from '$app/paths'.`;
+  }
+  if (link.kind === "goto") {
+    return `goto('${link.path}') is root-relative \u2014 it navigates outside this project's kit.paths.base and 404s in production. Use goto(resolve('${link.path}')) with resolve from '$app/paths'.`;
+  }
+  return `redirect(\u2026, '${link.path}') is root-relative \u2014 the Location header points outside this project's kit.paths.base and 404s in production. Use resolve('${link.path}') from '$app/paths'.`;
+}
 function isSuppressed4(suppressions, line) {
   return (suppressions ?? []).some((s) => s.line === line && (!s.ruleIds || s.ruleIds.includes(ID2)));
 }
-function emitFile2(out, file, issues, suppressions) {
-  const bad = issues.filter((b) => !(b.line > 0 && isSuppressed4(suppressions, b.line)));
+function emitFile2(out, file, links, suppressions) {
+  const bad = links.filter((l) => !(l.line > 0 && isSuppressed4(suppressions, l.line)));
   if (bad.length === 0) {
     out.push({
       id: ID2,
       category: "correctness",
-      severity: "critical",
+      severity: "warning",
       detection: PASS5,
       route: file,
       message: LABEL2,
@@ -3819,23 +4387,90 @@ function emitFile2(out, file, issues, suppressions) {
     });
     return;
   }
-  for (const b of bad) {
+  for (const l of bad) {
     out.push({
       id: ID2,
       category: "correctness",
-      severity: "critical",
+      severity: "warning",
       detection: PENALIZED5,
       route: file,
       location: file,
+      ...l.line > 0 ? { line: l.line } : {},
+      message: messageFor2(l),
+      recommendation: RECOMMENDATION2,
+      docsUrl: DOCS_URL2,
+      fix: { ...FIX7 }
+    });
+  }
+}
+var correctnessBasePathNavigation = {
+  id: ID2,
+  title: "Root-relative navigation under a base path",
+  category: "correctness",
+  severity: "warning",
+  scope: "component",
+  rationale: "A root-relative literal resolves against the domain root, not kit.paths.base, so navigation lands outside an app served from a sub-path. The break only appears once the app is deployed under its base \u2014 locally base is usually empty, so every such link works.",
+  fix: { ...FIX7 },
+  async check(ctx) {
+    if (!ctx.project.kitPathsBase) return [];
+    const out = [];
+    for (const c of ctx.components ?? []) {
+      const links = c.basePathLinks ?? [];
+      if (links.length === 0) continue;
+      emitFile2(out, c.file, links, c.suppressions);
+    }
+    for (const m of ctx.kitModules ?? []) {
+      const links = m.basePathLinks ?? [];
+      if (links.length === 0) continue;
+      emitFile2(out, m.file, links, m.suppressions);
+    }
+    return out;
+  }
+};
+
+// src/rules/correctness/server-browser-global.ts
+var PENALIZED6 = { presence: "none", value: "absent" };
+var PASS6 = { presence: "own", value: "static" };
+var ID3 = "correctness/server-browser-global";
+var DOCS_URL3 = docsUrlFor(ID3);
+var LABEL3 = "Server-safe module code";
+var RECOMMENDATION3 = "Move browser-only code into onMount or $effect (they never run on the server), or guard it with browser from $app/environment (or a typeof check).";
+var moduleMessage = (name) => `${name} is accessed at module scope \u2014 it does not exist on the server, so importing this file crashes SSR with "${name} is not defined"`;
+function isSuppressed5(suppressions, line) {
+  return (suppressions ?? []).some((s) => s.line === line && (!s.ruleIds || s.ruleIds.includes(ID3)));
+}
+function emitFile3(out, file, issues, suppressions) {
+  const bad = issues.filter((b) => !(b.line > 0 && isSuppressed5(suppressions, b.line)));
+  if (bad.length === 0) {
+    out.push({
+      id: ID3,
+      category: "correctness",
+      severity: "critical",
+      detection: PASS6,
+      route: file,
+      message: LABEL3,
+      recommendation: RECOMMENDATION3,
+      docsUrl: DOCS_URL3
+    });
+    return;
+  }
+  for (const b of bad) {
+    out.push({
+      id: ID3,
+      category: "correctness",
+      severity: "critical",
+      detection: PENALIZED6,
+      route: file,
+      location: file,
       ...b.line > 0 ? { line: b.line } : {},
       message: b.message,
-      recommendation: RECOMMENDATION2,
-      docsUrl: DOCS_URL2
+      recommendation: RECOMMENDATION3,
+      docsUrl: DOCS_URL3
     });
   }
 }
 var correctnessServerBrowserGlobal = {
-  id: ID2,
+  id: ID3,
   title: "Browser global in server module code",
   category: "correctness",
   severity: "critical",
@@ -3846,7 +4481,7 @@ var correctnessServerBrowserGlobal = {
     for (const c of ctx.components ?? []) {
       const refs = (c.browserGlobalRefs ?? []).filter((r) => r.context === "module");
       if (refs.length === 0) continue;
-      emitFile2(
+      emitFile3(
         out,
         c.file,
         refs.map((r) => ({ line: r.line, message: moduleMessage(r.name) })),
@@ -3856,7 +4491,7 @@ var correctnessServerBrowserGlobal = {
     for (const m of ctx.kitModules ?? []) {
       const refs = m.browserGlobalRefs ?? [];
       if (refs.length === 0) continue;
-      emitFile2(
+      emitFile3(
         out,
         m.file,
         refs.map((r) => ({
@@ -3972,33 +4607,733 @@ var securitySharedStateImport = kitModuleRule({
 });
 
 // src/rules/architecture/component-size.ts
-var MAX_LOC = 400;
+var MAX_LOC = 200;
 var architectureComponentSize = componentRule({
   id: "architecture/component-size",
   title: "Component size",
   category: "architecture",
   severity: "info",
   label: "Component size",
-  recommendation: `Split components over ${MAX_LOC} lines into smaller, focused pieces.`,
+  options: { max: { kind: "integer", default: MAX_LOC, min: 1 } },
+  recommendation: (o) => `Split components over ${intOption(o, "max", MAX_LOC)} lines into smaller, focused pieces.`,
   rationale: "A very large component is hard to read, test, and reuse, and is a common sign that several responsibilities should be split out.",
   applies: (c) => c.loc > 0,
   // skip unanalyzable files (loc 0 = read/parse failure), don't PASS them
-  bad: (c) => c.loc > MAX_LOC ? [{ line: 1, message: `Component is ${c.loc} lines (over ${MAX_LOC})` }] : []
+  bad: (c, o) => {
+    const max = intOption(o, "max", MAX_LOC);
+    return c.loc > max ? [{ line: 1, message: `Component is ${c.loc} lines (over ${max})` }] : [];
+  }
 });
 
 // src/rules/architecture/prop-count.ts
-var MAX_PROPS = 10;
+var MAX_PROPS = 6;
 var architecturePropCount = componentRule({
   id: "architecture/prop-count",
   title: "Prop count",
   category: "architecture",
   severity: "info",
   label: "Prop count",
-  recommendation: `Group related props into an object, or split the component, when it takes more than ${MAX_PROPS} props.`,
+  options: { max: { kind: "integer", default: MAX_PROPS, min: 1 } },
+  recommendation: (o) => `Group related props into an object, or split the component, when it takes more than ${intOption(o, "max", MAX_PROPS)} props.`,
   rationale: "A component taking many props is usually doing too much; grouping or splitting keeps its API understandable.",
   applies: (c) => c.propCount > 0,
   // only components whose props we could count
-  bad: (c) => c.propCount > MAX_PROPS ? [{ line: 1, message: `Component takes ${c.propCount} props (over ${MAX_PROPS})` }] : []
+  bad: (c, o) => {
+    const max = intOption(o, "max", MAX_PROPS);
+    return c.propCount > max ? [{ line: 1, message: `Component takes ${c.propCount} props (over ${max})` }] : [];
+  }
+});
+
+// src/rules/architecture/private-scope-import.ts
+var docsUrl7 = docsUrlFor("architecture/private-scope-import");
+var recommendation7 = "Move the unit to the directory shared by all of its importers, or import it only from inside its own scope.";
+var OPTIONS2 = { scopes: { kind: "string-list", default: [] } };
+function ancestorDirs(file) {
+  const segments = file.split("/");
+  const out = [];
+  for (let i = segments.length - 1; i > 0; i--) out.push(segments.slice(0, i).join("/"));
+  return out;
+}
+function privateScopeOf(target, patterns) {
+  for (const dir of ancestorDirs(target)) {
+    if (!patterns.some((p) => p.test(dir))) continue;
+    const cut = dir.lastIndexOf("/");
+    return cut === -1 ? "" : dir.slice(0, cut);
+  }
+  return void 0;
+}
+function isInside(file, boundary) {
+  return boundary === "" || file.startsWith(`${boundary}/`);
+}
+var architecturePrivateScopeImport = {
+  id: "architecture/private-scope-import",
+  title: "Private-scope import",
+  category: "architecture",
+  severity: "info",
+  scope: "component",
+  rationale: "A unit placed inside a private directory is written for one owner; importing it from elsewhere couples two parts of the tree that were meant to move independently, and the unit belongs higher up instead.",
+  fix: {
+    description: "Move this unit out of its private scope, to the directory shared by all of its importers, and update this import."
+  },
+  options: OPTIONS2,
+  async check(ctx) {
+    const out = [];
+    const compiled = compileOverrides(ctx.config);
+    const patternCache = /* @__PURE__ */ new Map();
+    const compileScopes = (scopes) => {
+      const key = JSON.stringify(scopes);
+      let patterns = patternCache.get(key);
+      if (patterns === void 0) {
+        patterns = scopes.map((scope) => {
+          const marker = scope.endsWith("/**") ? scope.slice(0, -3) : scope;
+          return routeGlobToRegExp(marker);
+        });
+        patternCache.set(key, patterns);
+      }
+      return patterns;
+    };
+    for (const c of ctx.components ?? []) {
+      const o = resolveRuleOptions(
+        "architecture/private-scope-import",
+        OPTIONS2,
+        ctx.config,
+        { route: c.file, file: c.file },
+        compiled
+      );
+      const scopes = listOption(o, "scopes");
+      if (scopes.length === 0) continue;
+      const patterns = compileScopes(scopes);
+      const spans = c.importSpans ?? c.imports.map((source) => ({ source, line: 0 }));
+      let sawScopedImport = false;
+      const violations = [];
+      for (const { source, line } of spans) {
+        const target = resolveRepoLocalPath(source, c.file, ctx.project.kitAliases);
+        if (target === void 0) continue;
+        const boundary = privateScopeOf(target, patterns);
+        if (boundary === void 0) continue;
+        sawScopedImport = true;
+        if (isInside(c.file, boundary)) continue;
+        violations.push({ line, message: `${target} is private to ${boundary}` });
+      }
+      if (!sawScopedImport) continue;
+      const visible = violations.filter(
+        (v) => !(v.line > 0 && isSuppressed2(c, "architecture/private-scope-import", v.line))
+      );
+      if (visible.length === 0) {
+        out.push({
+          id: "architecture/private-scope-import",
+          category: "architecture",
+          severity: "info",
+          detection: { presence: "own", value: "static" },
+          route: c.file,
+          message: "No private-scope imports",
+          recommendation: recommendation7,
+          docsUrl: docsUrl7
+        });
+        continue;
+      }
+      for (const v of visible) {
+        out.push({
+          id: "architecture/private-scope-import",
+          category: "architecture",
+          severity: "info",
+          detection: { presence: "none", value: "absent" },
+          route: c.file,
+          location: c.file,
+          ...v.line > 0 ? { line: v.line } : {},
+          message: v.message,
+          recommendation: recommendation7,
+          docsUrl: docsUrl7,
+          fix: { ...architecturePrivateScopeImport.fix }
+        });
+      }
+    }
+    return out;
+  }
+};
+
+// 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
@@ -4014,18 +5349,20 @@ var performanceHeavyImport = componentRule({
   label: "No heavy imports",
   recommendation: "Import a submodule or switch to a lighter, tree-shakeable alternative.",
   rationale: "Importing a large, non-tree-shakeable package pulls its whole weight into the bundle even when only a fraction is used, slowing load.",
+  options: { packages: { kind: "string-map", default: HEAVY_PACKAGES } },
   // ComponentFacts is a public @svelte-vitals/core export — an external caller compiled
   // against an older version may still construct one without importSpans. Fall back to the
   // line-less `imports` (line: 0, the pre-fix behavior) instead of crashing on `undefined`.
   applies: (c) => (c.importSpans ?? c.imports).length > 0,
-  bad: (c) => {
+  bad: (c, o) => {
+    const packages = mapOption(o, "packages");
     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(HEAVY_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 ${HEAVY_PACKAGES[src]}` });
+      out.push({ line, message: `Heavy import "${src}" \u2014 ${packages[src]}` });
     }
     return out;
   }
@@ -4055,13 +5392,13 @@ var performanceNamespaceImport = componentRule({
 });
 
 // src/rules/perf/minify-disabled.ts
-var PENALIZED6 = { presence: "none", value: "absent" };
+var PENALIZED7 = { presence: "none", value: "absent" };
 var MINIFY_DISABLED_FIX = {
   description: "Remove the minify: false override from vite.config (Vite minifies with esbuild by default), or scope it to non-production builds.",
   snippet: "export default defineConfig({\n  build: {\n    minify: 'esbuild'\n  }\n});",
   lang: "ts"
 };
-var RECOMMENDATION3 = "Remove build.minify: false from vite.config, or scope it to non-production builds if it is intentional.";
+var RECOMMENDATION4 = "Remove build.minify: false from vite.config, or scope it to non-production builds if it is intentional.";
 var performanceMinifyDisabled = {
   id: "performance/minify-disabled",
   title: "Minification disabled",
@@ -4079,11 +5416,11 @@ var performanceMinifyDisabled = {
         id: "performance/minify-disabled",
         category: "performance",
         severity: "warning",
-        detection: PENALIZED6,
+        detection: PENALIZED7,
         ...hit.file !== void 0 ? { location: hit.file } : {},
         ...hit.line !== void 0 ? { line: hit.line } : {},
         message: "JS/CSS minification is disabled (build.minify: false) \u2014 production bundles ship unminified and several times larger." + provenance,
-        recommendation: RECOMMENDATION3,
+        recommendation: RECOMMENDATION4,
         docsUrl: docsUrlFor("performance/minify-disabled"),
         fix: { ...MINIFY_DISABLED_FIX }
       }
@@ -4197,8 +5534,10 @@ var allRules = [
   correctnessPropMutation,
   correctnessStalePropDerivation,
   correctnessNonreactiveBuiltinState,
+  correctnessCheckableBindValue,
   correctnessOrphanEffect,
   correctnessOrphanLifecycle,
+  correctnessBasePathNavigation,
   correctnessServerBrowserGlobal,
   correctnessInstanceBrowserGlobal,
   securityRawHtml,
@@ -4208,6 +5547,11 @@ var allRules = [
   securitySharedStateImport,
   architectureComponentSize,
   architecturePropCount,
+  architecturePrivateScopeImport,
+  architectureUnitEntryFile,
+  architectureDirectoryNaming,
+  architectureReservedDirectoryNames,
+  architectureRouteComponentImport,
   performanceHeavyImport,
   performanceNamespaceImport,
   performanceMinifyDisabled,
@@ -4215,6 +5559,15 @@ var allRules = [
   performanceSequentialAwaits,
   performanceStateRaw
 ];
+function optionInfos(spec) {
+  return Object.entries(spec).map(([name, s]) => ({
+    name,
+    kind: s.kind,
+    default: s.default,
+    ...s.kind === "integer" && s.min !== void 0 ? { min: s.min } : {},
+    ...s.kind === "integer" && s.max !== void 0 ? { max: s.max } : {}
+  }));
+}
 function explainRule(id) {
   const rule = allRules.find((r) => r.id === id);
   if (!rule) return void 0;
@@ -4225,7 +5578,8 @@ function explainRule(id) {
     severity: rule.severity,
     rationale: rule.rationale,
     docsUrl: docsUrlFor(rule.id),
-    ...rule.fix ? { fix: rule.fix } : {}
+    ...rule.fix ? { fix: rule.fix } : {},
+    ...rule.options ? { options: optionInfos(rule.options) } : {}
   };
 }
 
@@ -5444,61 +6798,26 @@ function safeHref(url) {
   const normalized = url.replace(/\s/g, "").toLowerCase();
   return /^https?:\/\//.test(normalized) ? url : null;
 }
-
-// src/config-apply.ts
-function selectRules(rules, config) {
-  return rules.filter((rule) => config.rules[rule.id] !== "off");
-}
-function applyRuleSeverities(results, config) {
-  return results.map((result) => {
-    const setting = config.rules[result.id];
-    return setting && setting !== "off" ? { ...result, severity: setting } : result;
-  });
-}
-function routeGlobToRegExp(pattern) {
-  const body = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").split("\0").join(".*");
-  const source = body.endsWith("/.*") ? `${body.slice(0, -3)}(/.*)?` : body;
-  return new RegExp(`^${source}$`);
-}
-function toPatterns(globs) {
-  if (globs === void 0) return [];
-  return (Array.isArray(globs) ? globs : [globs]).map(routeGlobToRegExp);
-}
-function applyOverrides(results, config) {
-  const overrides = config.overrides;
-  if (!overrides || overrides.length === 0) return results;
-  const compiled = overrides.map((o) => ({
-    routes: toPatterns(o.route),
-    files: toPatterns(o.files),
-    rules: o.rules
-  }));
-  const out = [];
-  for (const result of results) {
-    const { route, location } = result;
-    let setting;
-    for (const o of compiled) {
-      const matched = route !== void 0 && o.routes.some((p) => p.test(route)) || location !== void 0 && o.files.some((p) => p.test(location));
-      if (!matched) continue;
-      const s = o.rules[result.id] ?? o.rules[result.category ?? "seo"];
-      if (s !== void 0) setting = s;
-    }
-    if (setting === void 0) out.push(result);
-    else if (setting !== "off") out.push({ ...result, severity: setting });
-  }
-  return out;
-}
 export {
   APP_SCRIPT,
   APP_STYLE,
   BAND_COLOR,
+  CATEGORIES,
   CHILD_NODE_KEYS,
   ROBOTS_SOURCE_PATHS,
   SITEMAP_SOURCE_PATHS,
+  SVELTE_CONFIG_FILES,
+  VITE_CONFIG_FILES,
   allRules,
   applyOverrides,
   applyRuleSeverities,
   architectureComponentSize,
+  architectureDirectoryNaming,
+  architecturePrivateScopeImport,
   architecturePropCount,
+  architectureReservedDirectoryNames,
+  architectureRouteComponentImport,
+  architectureUnitEntryFile,
   attrText,
   attrTextOf,
   attrValue,
@@ -5508,8 +6827,12 @@ export {
   classify,
   collectComponentFacts,
   collectKitModuleFacts,
+  collectSourceFiles,
+  compileOverrides,
   computeHealth,
   computeScore,
+  correctnessBasePathNavigation,
+  correctnessCheckableBindValue,
   correctnessEachIndexKey,
   correctnessEachKey,
   correctnessEffectAsDerived,
@@ -5532,6 +6855,9 @@ export {
   escapeHtml,
   explainRule,
   findAttr,
+  findKitAliasesInSvelteConfig,
+  findKitPathsBaseInSvelteConfig,
+  findKitPathsBaseInViteConfig,
   findMinifyDisabled,
   formatAgentReport,
   formatConsoleReport,
@@ -5543,10 +6869,15 @@ export {
   hasFailureAtOrAbove,
   headTagRule,
   imageRule,
+  intOption,
+  isMentionedAnywhere,
   isPenalized,
   lineOf,
   linkRule,
+  listOption,
+  mapOption,
   noColorPalette,
+  overrideMatches,
   parseComponentFacts,
   parseKitModuleFacts,
   performanceFontPreloadCrossorigin,
@@ -5564,6 +6895,9 @@ export {
   performanceSequentialAwaits,
   performanceStateRaw,
   renderAppShell,
+  resolveKitAliases,
+  resolveKitPathsBase,
+  resolveRuleOptions,
   resolveRunesModuleSpecifier,
   runRules,
   safeHref,
@@ -5607,7 +6941,12 @@ export {
   seoTitlePresence,
   seoTwitterCard,
   seoViewport,
+  settingOptions,
+  settingSeverity,
+  shouldSkipRangeCheck,
   summarize,
   textFromNodes,
+  validateRuleOptions,
+  validateRuleSetting,
   valueFromNodes
 };