@svelte-vitals/core 0.43.1 → 0.45.0

package/dist/internal.js

@@ -0,0 +1,1732 @@
+import {
+  CHILD_NODE_KEYS,
+  IDREF_ATTRS,
+  LANDMARK_ROLES,
+  SEVERITY_RANK,
+  a11yAccessibleName,
+  a11yDoctype,
+  a11yDuplicateLandmark,
+  a11yIdDuplication,
+  a11yInteractiveNesting,
+  a11yInvalidAriaValue,
+  a11yInvalidRole,
+  a11yLabelHasControl,
+  a11yNoMissingIdRef,
+  a11yPlaceholderLabelOption,
+  a11yRequireDatetime,
+  a11yRequiredAriaProps,
+  a11yTopLevelLandmark,
+  a11yUnknownAriaAttribute,
+  a11yUseList,
+  allRules,
+  applyOverrides,
+  applyRuleSeverities,
+  architectureComponentSize,
+  architectureDirectoryNaming,
+  architectureDocLinkTarget,
+  architecturePrivateScopeImport,
+  architecturePropCount,
+  architectureReservedDirectoryNames,
+  architectureReservedNamePlacement,
+  architectureRouteComponentImport,
+  architectureUnitEntryFile,
+  attrText,
+  attrTextOf,
+  attrValue,
+  attrValueOf,
+  buildJsonReport,
+  classify,
+  collectNamedImportAliases,
+  collectTopLevelBindings,
+  compileOverrides,
+  computeHealth,
+  computeScore,
+  correctnessBasePathNavigation,
+  correctnessCheckableBindValue,
+  correctnessEachIndexKey,
+  correctnessEachKey,
+  correctnessEffectAsDerived,
+  correctnessEffectAsOnMount,
+  correctnessInstanceBrowserGlobal,
+  correctnessNonreactiveBuiltinState,
+  correctnessOrphanEffect,
+  correctnessOrphanLifecycle,
+  correctnessPropMutation,
+  correctnessServerBrowserGlobal,
+  correctnessStalePropDerivation,
+  correctnessUnmutatedState,
+  decodeFragmentId,
+  defaultConfig,
+  defaultProject,
+  docsUrlFor,
+  effectiveSeverity,
+  explainRule,
+  findAttr,
+  foldOccurrences,
+  formatFailedRuleWarning,
+  formatGithubReport,
+  formatJsonReport,
+  formatMarkdownReport,
+  hasFailureAtOrAbove,
+  headTagRule,
+  imageRule,
+  intOption,
+  isMentionedAnywhere,
+  isPenalized,
+  isTopFragment,
+  lineOf,
+  linkRule,
+  listOption,
+  mapOption,
+  mdEscape,
+  messageText,
+  overrideMatches,
+  parseComponentFacts,
+  parseInMemoryExports,
+  parseKitModuleFacts,
+  parseModuleProgram,
+  parseSvelte,
+  performanceFontPreloadCrossorigin,
+  performanceHeavyImport,
+  performanceImageDimensions,
+  performanceImageLoadingHint,
+  performanceLcpImage,
+  performanceLoadWaterfall,
+  performanceMinifyDisabled,
+  performanceNamespaceImport,
+  performancePreconnect,
+  performancePreloadMissingAs,
+  performanceRenderBlockingScript,
+  performanceResponsiveImage,
+  performanceSequentialAwaits,
+  performanceStateRaw,
+  resolveRepoLocalPath,
+  resolveRuleOptions,
+  resolveRunesModuleSpecifier,
+  ruleMetaById,
+  scoresByCategory,
+  securityHandlerStateWrite,
+  securityJavascriptUrl,
+  securityRawHtml,
+  securityServerModuleState,
+  securitySharedStateImport,
+  selectRules,
+  seoCanonicalUrl,
+  seoCharset,
+  seoDescriptionLength,
+  seoDescriptionPresence,
+  seoDuplicateDescription,
+  seoDuplicateTitle,
+  seoHeadingLevelSkip,
+  seoHreflang,
+  seoHtmlLang,
+  seoImageAlt,
+  seoIndexability,
+  seoJsonLd,
+  seoJsonLdDateFormat,
+  seoJsonLdDeprecatedType,
+  seoJsonLdPlaceholder,
+  seoJsonLdRelativeUrl,
+  seoJsonLdRequiredProps,
+  seoJsonLdValidity,
+  seoOgDescription,
+  seoOgImage,
+  seoOgTitle,
+  seoOgUrl,
+  seoRobotsTxt,
+  seoSingleH1,
+  seoSitemapInRobots,
+  seoSitemapXml,
+  seoSsrDisabled,
+  seoTitleLength,
+  seoTitlePresence,
+  seoTwitterCard,
+  seoViewport,
+  settingOptions,
+  settingSeverity,
+  severityToSarifLevel,
+  shouldSkipRangeCheck,
+  splitTokens,
+  stripTextDirective,
+  summarize,
+  terminalSafe,
+  textFromNodes,
+  unwrapTs,
+  validateRuleOptions,
+  validateRuleSetting,
+  valueFromNodes,
+  withFailedRulesOff
+} from "./chunk-BCJZO532.js";
+
+// src/component.ts
+function skippedFileWarnings(facts) {
+  const list = (files) => {
+    const shown = files.slice(0, 10);
+    return files.length > shown.length ? `${shown.join(", ")}, \u2026 and ${files.length - shown.length} more` : shown.join(", ");
+  };
+  const names = (pick) => [...new Set(facts.filter(pick).map((f) => f.file))].sort();
+  const unread = names((f) => f.readFailed === true);
+  const unparsed = names((f) => f.parseFailed === true && f.readFailed !== true);
+  const out = [];
+  if (unread.length > 0) {
+    out.push(
+      `skipped ${unread.length} file(s) that could not be read: ${list(unread)}`,
+      "this is an environment problem, not a code one \u2014 check file permissions and the open-file limit (`ulimit -n`)."
+    );
+  }
+  if (unparsed.length > 0) {
+    out.push(
+      `skipped ${unparsed.length} file(s) that could not be parsed: ${list(unparsed)}`,
+      "findings for these files are unavailable until they parse."
+    );
+  }
+  return out;
+}
+
+// src/component-collect.ts
+function emptyComponentFacts(file) {
+  return {
+    file,
+    eachBlocks: [],
+    effects: [],
+    htmlTags: [],
+    javascriptUrls: [],
+    loc: 0,
+    propCount: 0,
+    imports: [],
+    importSpans: [],
+    namespaceImports: [],
+    constableStates: [],
+    mutatedProps: [],
+    stalePropDerivations: [],
+    rawableStates: [],
+    nonreactiveBuiltinStates: [],
+    checkableBindValues: [],
+    basePathLinks: [],
+    orphanEffects: [],
+    orphanLifecycleCalls: [],
+    browserGlobalRefs: [],
+    moduleStateDecls: [],
+    suppressions: [],
+    commentLinks: []
+  };
+}
+async function collectComponentFacts(rt, cwd) {
+  const files = await rt.glob("src/**/*.svelte{,.ts,.js}", cwd);
+  return Promise.all(
+    files.sort().map(async (rel) => {
+      let source;
+      try {
+        source = await rt.readFile(rt.join(cwd, rel));
+      } catch {
+        return { ...emptyComponentFacts(rel), parseFailed: true, readFailed: true };
+      }
+      try {
+        return { file: rel, ...parseComponentFacts(source, rel) };
+      } catch {
+        return { ...emptyComponentFacts(rel), parseFailed: true };
+      }
+    })
+  );
+}
+
+// src/source-files.ts
+async function collectSourceFiles(rt, cwd) {
+  const files = await rt.glob("src/**/*", cwd);
+  return files.slice().sort();
+}
+
+// src/kit-module-collect.ts
+function emptyKitModuleFacts(file, kind) {
+  return {
+    file,
+    kind,
+    moduleStateReassignments: [],
+    importedStateWrites: [],
+    importedStateWritesOutsideHandlers: [],
+    pendingServerStoreWrites: [],
+    runesModuleImports: [],
+    lifecycleCalls: [],
+    browserGlobalRefs: [],
+    basePathLinks: [],
+    suppressions: []
+  };
+}
+function kindOf(file) {
+  const base = file.split("/").pop() ?? file;
+  return base.includes(".server.") || base.startsWith("+server.") ? "server" : "universal";
+}
+async function collectKitModuleFacts(rt, cwd, aliases) {
+  const patterns = [
+    "src/routes/**/+{page,layout}.server.{ts,js}",
+    "src/routes/**/+{page,layout}.{ts,js}",
+    "src/routes/**/+server.{ts,js}",
+    "src/hooks.server.{ts,js}"
+  ];
+  const lists = await Promise.all(patterns.map((p) => rt.glob(p, cwd)));
+  const files = [...new Set(lists.flat())];
+  const facts = await Promise.all(
+    files.sort().map(async (rel) => {
+      const kind = kindOf(rel);
+      let source;
+      try {
+        source = await rt.readFile(rt.join(cwd, rel));
+      } catch {
+        return { ...emptyKitModuleFacts(rel, kind), parseFailed: true, readFailed: true };
+      }
+      try {
+        return { file: rel, kind, ...parseKitModuleFacts(source, rel, aliases) };
+      } catch {
+        return { ...emptyKitModuleFacts(rel, kind), parseFailed: true };
+      }
+    })
+  );
+  return arbitrateServerStoreWrites(rt, cwd, facts);
+}
+function moduleCandidates(repoPath) {
+  if (repoPath.endsWith(".js")) return [repoPath, `${repoPath.slice(0, -3)}.ts`];
+  if (repoPath.endsWith(".ts")) return [repoPath];
+  return [`${repoPath}.ts`, `${repoPath}.js`, `${repoPath}/index.ts`, `${repoPath}/index.js`];
+}
+async function inMemoryExportsOf(rt, cwd, repoPath) {
+  for (const rel of moduleCandidates(repoPath)) {
+    try {
+      if (!await rt.exists(rt.join(cwd, rel))) continue;
+      return parseInMemoryExports(await rt.readFile(rt.join(cwd, rel)), rel);
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  return /* @__PURE__ */ new Set();
+}
+async function arbitrateServerStoreWrites(rt, cwd, facts) {
+  const targets = [...new Set(facts.flatMap((f) => f.pendingServerStoreWrites.map((w) => w.resolved)))];
+  if (targets.length === 0) return facts;
+  const byPath = new Map(
+    await Promise.all(targets.map(async (t) => [t, await inMemoryExportsOf(rt, cwd, t)]))
+  );
+  return facts.map((f) => {
+    const promoted = f.pendingServerStoreWrites.filter((w) => byPath.get(w.resolved)?.has(w.imported)).map((w) => ({ name: w.name, line: w.line, via: "set-call" }));
+    if (promoted.length === 0) return f;
+    return {
+      ...f,
+      importedStateWrites: [...f.importedStateWrites, ...promoted].sort((a, b) => a.line - b.line)
+    };
+  });
+}
+
+// src/config-object.ts
+function propOf(obj, name) {
+  let found;
+  for (const p of obj.properties) {
+    if (p.type === "SpreadElement") {
+      if (found) found = void 0;
+      continue;
+    }
+    if (p.type !== "Property" || p.computed) continue;
+    if (p.key.type === "Identifier" && p.key.name === name) found = p;
+    else if (p.key.type === "Literal" && p.key.value === name) found = p;
+  }
+  return found;
+}
+function unwrapToObjectExpression(expr, bindings) {
+  let current = expr;
+  for (let i = 0; i < 4 && current; i++) {
+    const e = unwrapTs(current);
+    if (e.type === "ObjectExpression") return e;
+    if (e.type === "Identifier") {
+      current = bindings.get(e.name);
+      continue;
+    }
+    if (e.type === "CallExpression") {
+      current = e.arguments[0];
+      continue;
+    }
+    return void 0;
+  }
+  const final = current ? unwrapTs(current) : void 0;
+  return final?.type === "ObjectExpression" ? final : void 0;
+}
+function findExportedExpression(program) {
+  let exported;
+  for (const stmt of program.body) {
+    if (stmt.type === "ExportDefaultDeclaration") exported = stmt.declaration;
+  }
+  if (exported) return exported;
+  let cjsExported;
+  for (const stmt of program.body) {
+    if (stmt.type !== "ExpressionStatement") continue;
+    const expr = stmt.expression;
+    if (expr.type !== "AssignmentExpression" || expr.operator !== "=") continue;
+    const left = expr.left;
+    if (left.type === "MemberExpression" && !left.computed && left.object.type === "Identifier" && left.object.name === "module" && left.property.type === "Identifier" && left.property.name === "exports") {
+      cjsExported = expr.right;
+    }
+  }
+  return cjsExported;
+}
+function resolveConfigObject(program) {
+  const exported = findExportedExpression(program);
+  if (!exported) return void 0;
+  return unwrapToObjectExpression(exported, collectTopLevelBindings(program));
+}
+
+// src/vite-config-parse.ts
+function findMinifyDisabled(source) {
+  let program;
+  let wrapped;
+  try {
+    ({ program, wrapped } = parseModuleProgram(source, "vite.config.ts"));
+  } catch {
+    return void 0;
+  }
+  if (!program) return void 0;
+  const config = resolveConfigObject(program);
+  if (!config) return void 0;
+  const build = propOf(config, "build");
+  const buildValue = build ? unwrapTs(build.value) : void 0;
+  if (buildValue?.type !== "ObjectExpression") return void 0;
+  const minify = propOf(buildValue, "minify");
+  const minifyValue = minify ? unwrapTs(minify.value) : void 0;
+  if (!minify || minifyValue?.type !== "Literal" || minifyValue.value !== false) return void 0;
+  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",
+  "src/routes/robots.txt/+server.ts",
+  "src/routes/robots.txt/+server.js"
+];
+var SITEMAP_SOURCE_PATHS = [
+  "static/sitemap.xml",
+  "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/runtime.ts
+var READ_CONCURRENCY = 64;
+function withReadLimit(readFile, limit = READ_CONCURRENCY) {
+  let active = 0;
+  const waiting = [];
+  const release = () => {
+    active--;
+    waiting.shift()?.();
+  };
+  return async (path) => {
+    if (active >= limit) await new Promise((resolve) => waiting.push(resolve));
+    active++;
+    try {
+      return await readFile(path);
+    } finally {
+      release();
+    }
+  };
+}
+
+// src/engine.ts
+async function runRules(rules, ctx) {
+  const examined = {};
+  const perRule = await Promise.all(
+    rules.map(async (rule) => {
+      try {
+        return await rule.check({ ...ctx, recordExamined: (counts) => void (examined[rule.id] = counts) });
+      } catch (err) {
+        return { id: rule.id, message: err instanceof Error ? err.message : String(err) };
+      }
+    })
+  );
+  const results = [];
+  const failedRules = [];
+  for (const outcome of perRule) {
+    if (Array.isArray(outcome)) results.push(...outcome);
+    else failedRules.push(outcome);
+  }
+  return { results, examined, failedRules };
+}
+
+// src/reporter/palette.ts
+var noColorPalette = {
+  bold: (s) => s,
+  dim: (s) => s,
+  red: (s) => s,
+  yellow: (s) => s,
+  green: (s) => s,
+  cyan: (s) => s
+};
+function scoreColor(p, score) {
+  if (score >= 90) return p.green;
+  if (score >= 70) return p.yellow;
+  return p.red;
+}
+
+// src/reporter/console.ts
+var RULE = "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+var SEVERITY_TITLE = {
+  critical: "Critical",
+  warning: "Warnings",
+  info: "Info"
+};
+var CATEGORY_LABEL = {
+  seo: "SEO",
+  performance: "Performance",
+  correctness: "Correctness",
+  security: "Security",
+  architecture: "Architecture",
+  a11y: "Accessibility"
+};
+var CATEGORY_ORDER = Object.keys(CATEGORY_LABEL);
+var categoryLabel = (c) => CATEGORY_LABEL[c];
+var MAX_RULE_GROUPS_PER_BUCKET = 5;
+function groupByRule(results) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    const bucket = groups.get(r.id);
+    if (bucket) bucket.push(r);
+    else groups.set(r.id, [r]);
+  }
+  return [...groups.entries()].map(([id, rs]) => ({ id, results: rs })).sort((a, b) => b.results.length - a.results.length || a.id.localeCompare(b.id));
+}
+function scoreLine(p, label, { score, scoreModel }) {
+  const parts = [`route avg ${scoreModel.routeAverage}`];
+  if (scoreModel.sitePenalty > 0) parts.push(`site \u2212${scoreModel.sitePenalty}`);
+  if (scoreModel.criticalCap !== null) parts.push(`capped at ${scoreModel.criticalCap}: critical present`);
+  return `${label} Score: ${scoreColor(p, score)(`${score}/100`)}   ${p.dim(`(${parts.join(" \xB7 ")})`)}`;
+}
+var MAX_ROUTES_BY_ROUTE = 10;
+function byRouteTree(p, results, config, verbose) {
+  const routes = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    if (r.route === void 0) continue;
+    if (!routes.has(r.route)) routes.set(r.route, []);
+    routes.get(r.route).push(r);
+  }
+  const scored = [...routes.entries()].map(([route, rs]) => ({
+    route,
+    rs,
+    score: computeScore(rs, config, { applyCriticalCap: false }).score
+  }));
+  scored.sort((a, b) => a.score - b.score || a.route.localeCompare(b.route));
+  const shown = verbose ? scored : scored.slice(0, MAX_ROUTES_BY_ROUTE);
+  const lines = [p.bold("By route"), p.dim(RULE)];
+  for (const { route, rs, score } of shown) {
+    lines.push(`${terminalSafe(route).padEnd(28)} ${scoreColor(p, score)(`${score}`)}`);
+    for (const r of rs.filter((x) => classify(x, config) === "fail")) {
+      lines.push(`    ${p.red("\u2717")} ${r.id}  ${terminalSafe(r.message)}`);
+    }
+  }
+  if (!verbose && scored.length > MAX_ROUTES_BY_ROUTE) {
+    const remaining = scored.slice(MAX_ROUTES_BY_ROUTE);
+    const avgScore = Math.floor(remaining.reduce((sum, r) => sum + r.score, 0) / remaining.length);
+    lines.push(
+      p.dim(
+        `\u2026and ${remaining.length} more route${remaining.length > 1 ? "s" : ""} (avg score ${avgScore}) \u2014 run with --verbose to see all`
+      )
+    );
+  }
+  lines.push("");
+  return lines;
+}
+function formatConsoleReport(results, config, options = {}) {
+  const p = options.palette ?? noColorPalette;
+  const summary = summarize(results, config);
+  const { health, categories: byCat } = computeHealth(results, config);
+  const present = CATEGORY_ORDER.filter((c) => byCat[c] !== void 0);
+  const lines = [];
+  if (!options.omitHeader) {
+    lines.push(
+      p.bold(`Svelte Vitals  \xB7  ${options.mode ?? "static mode"}`),
+      "",
+      `${p.bold("Health:")} ${scoreColor(p, health)(`${health}/100`)}`
+    );
+  }
+  for (const c of present) {
+    lines.push(scoreLine(p, categoryLabel(c), byCat[c]));
+  }
+  lines.push("");
+  const SEVERITY_COLOR = {
+    critical: (s) => p.red(p.bold(s)),
+    warning: (s) => p.yellow(p.bold(s)),
+    info: (s) => p.dim(s)
+  };
+  const failures = results.filter((r) => classify(r, config) === "fail");
+  for (const severity of ["critical", "warning", "info"]) {
+    const bucket = failures.filter((r) => effectiveSeverity(r, config) === severity);
+    if (bucket.length === 0) continue;
+    lines.push(SEVERITY_COLOR[severity](`${SEVERITY_TITLE[severity]} (${bucket.length})`), p.dim(RULE));
+    if (options.verbose) {
+      for (const r of bucket) {
+        lines.push(`${p.red("\u2717")} ${r.id}  ${terminalSafe(r.message)}`);
+        if (r.route) lines.push(p.dim(`            ${terminalSafe(r.route)}`));
+        if (r.location) lines.push(p.dim(`            ${terminalSafe(r.location)}${r.line ? `:${r.line}` : ""}`));
+      }
+    } else {
+      const groups = groupByRule(bucket);
+      const shownGroups = groups.slice(0, MAX_RULE_GROUPS_PER_BUCKET);
+      for (const group of shownGroups) {
+        const r = group.results[0];
+        lines.push(`${p.red("\u2717")} ${r.id}  ${terminalSafe(r.message)}`);
+        if (r.route) lines.push(p.dim(`            ${terminalSafe(r.route)}`));
+        if (r.location) lines.push(p.dim(`            ${terminalSafe(r.location)}${r.line ? `:${r.line}` : ""}`));
+        if (group.results.length > 1) {
+          lines.push(p.dim(`            \u2026and ${group.results.length - 1} more`));
+        }
+      }
+      if (groups.length > MAX_RULE_GROUPS_PER_BUCKET) {
+        const remaining = groups.length - MAX_RULE_GROUPS_PER_BUCKET;
+        lines.push(
+          p.dim(`\u2026and ${remaining} more rule${remaining > 1 ? "s" : ""} affected \u2014 run with --verbose to see all`)
+        );
+      }
+    }
+    lines.push("");
+  }
+  const passed = results.filter((r) => classify(r, config) !== "fail");
+  if (passed.length > 0) {
+    lines.push(p.bold(`Passed (${passed.length})`), p.dim(RULE));
+    if (options.verbose) {
+      for (const r of passed) {
+        const marker = classify(r, config) === "dynamic" ? p.cyan("  \u21AF dynamic") : "";
+        const where = r.location ?? r.route;
+        const suffix = where ? `  ${terminalSafe(where)}` : "";
+        lines.push(`${p.green("\u2713")} ${r.id}  ${terminalSafe(r.message)}${marker}${suffix}`);
+      }
+    }
+    lines.push("");
+  }
+  if (options.byRoute) lines.push(...byRouteTree(p, results, config, options.verbose ?? false));
+  if (options.verbose && summary.dynamic > 0) lines.push(p.dim("\u21AF = set dynamically (verified at runtime)."));
+  return lines.join("\n").replace(/\n+$/, "\n");
+}
+
+// src/reporter/agent.ts
+function formatAgentReport(results, config) {
+  const failing = results.filter((r) => classify(r, config) === "fail");
+  const { health } = computeHealth(results, config);
+  const lines = ["# svelte-vitals \u2014 fixes", "", `Health: ${health}/100`, ""];
+  if (failing.length === 0) {
+    lines.push("No issues to fix.", "");
+    return lines.join("\n").replace(/\n+$/, "\n");
+  }
+  lines.push(
+    `${failing.length} issue(s) to fix, ordered most-severe first. Fix critical issues first; warning and info items improve SEO but do not fail the default build. Apply each fix below, then re-run \`svelte-vitals\` (or the build) to confirm each rule passes. Run \`svelte-vitals explain <rule-id>\` for any rule's rationale and options (works offline).`,
+    ""
+  );
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of failing) {
+    const key = r.location ?? r.route ?? "(project)";
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(r);
+  }
+  const groupSeverity = (rs) => Math.min(...rs.map((r) => SEVERITY_RANK[effectiveSeverity(r, config)]));
+  const orderedGroups = [...groups.entries()].sort(
+    (a, b) => groupSeverity(a[1]) - groupSeverity(b[1]) || a[0].localeCompare(b[0])
+  );
+  for (const [loc, rs] of orderedGroups) {
+    rs.sort(
+      (x, y) => SEVERITY_RANK[effectiveSeverity(x, config)] - SEVERITY_RANK[effectiveSeverity(y, config)] || x.id.localeCompare(y.id)
+    );
+    lines.push(`## ${mdEscape(loc)}`, "");
+    for (const r of rs) {
+      lines.push(`### ${r.id} \xB7 ${mdEscape(r.message)} (${effectiveSeverity(r, config)})`);
+      if (r.fix) {
+        lines.push(`- Fix: ${mdEscape(r.fix.description)}`);
+        if (r.fix.snippet) lines.push("", "```" + (r.fix.lang ?? "svelte"), r.fix.snippet, "```");
+      } else if (r.recommendation) {
+        lines.push(`- Fix: ${mdEscape(r.recommendation)}`);
+      }
+      if (r.docsUrl) lines.push(`- Docs: ${r.docsUrl}`);
+      lines.push(`- Accept: re-run svelte-vitals; ${r.id} passes${r.route ? ` for ${mdEscape(r.route)}` : ""}.`, "");
+    }
+  }
+  return lines.join("\n").replace(/\n+$/, "\n");
+}
+
+// src/reporter/sarif.ts
+function formatSarifReport(results, config, meta) {
+  const penalized = results.filter((r) => isPenalized(r.detection, config.treatDynamicAs));
+  const rules = [];
+  const ruleIndex = /* @__PURE__ */ new Map();
+  const sarifResults = penalized.map((r) => {
+    if (!ruleIndex.has(r.id)) {
+      const m = ruleMetaById(r.id);
+      const name = m?.title ?? r.id;
+      ruleIndex.set(r.id, rules.length);
+      rules.push({
+        id: r.id,
+        name,
+        shortDescription: { text: name },
+        helpUri: r.docsUrl ?? m?.docsUrl ?? docsUrlFor(r.id),
+        defaultConfiguration: { level: severityToSarifLevel(m?.severity ?? r.severity) }
+      });
+    }
+    const result = {
+      ruleId: r.id,
+      ruleIndex: ruleIndex.get(r.id),
+      level: severityToSarifLevel(effectiveSeverity(r, config)),
+      message: { text: messageText(r) },
+      partialFingerprints: {
+        "svelteVitals/v1": `${r.id}:${r.route ?? "project"}${r.line !== void 0 ? `:${r.location ?? ""}:${r.line}` : ""}`
+      }
+    };
+    if (r.location) {
+      result.locations = [
+        {
+          physicalLocation: {
+            artifactLocation: { uri: r.location },
+            ...r.line !== void 0 ? { region: { startLine: r.line } } : {}
+          }
+        }
+      ];
+    }
+    return result;
+  });
+  const log = {
+    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "svelte-vitals",
+            informationUri: "https://oekazuma.github.io/svelte-vitals",
+            version: meta.version,
+            rules
+          }
+        },
+        results: sarifResults
+      }
+    ]
+  };
+  return JSON.stringify(log, null, 2);
+}
+
+// src/reporter/app-shell.ts
+var BAND_COLOR = {
+  good: "#2FA968",
+  warn: "#E8A317",
+  poor: "#E5484D"
+};
+function scoreBand(score) {
+  return score >= 90 ? "good" : score >= 50 ? "warn" : "poor";
+}
+function escapeHtml(s) {
+  return s.replace(
+    /[&<>"']/g,
+    (c) => c === "&" ? "&amp;" : c === "<" ? "&lt;" : c === ">" ? "&gt;" : c === '"' ? "&quot;" : "&#39;"
+  );
+}
+function safeHref(url) {
+  const normalized = url.replace(/\s/g, "").toLowerCase();
+  return /^https?:\/\//.test(normalized) ? url : null;
+}
+function embedJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function sanitizeDocsUrl(issue) {
+  if (issue.docsUrl === void 0) return issue;
+  if (safeHref(issue.docsUrl) !== null) return issue;
+  return { ...issue, docsUrl: void 0 };
+}
+function sanitizeReport(report) {
+  return {
+    ...report,
+    routes: report.routes.map((route) => ({ ...route, issues: route.issues.map(sanitizeDocsUrl) })),
+    siteIssues: report.siteIssues.map(sanitizeDocsUrl)
+  };
+}
+var APP_STYLE = `
+:root{--ground:#f6f7f9;--panel:#fff;--ink:#0c1322;--muted:#5a6472;--faint:#8c95a3;--line:#e4e7ec;--line-strong:#d3d8e0;--accent:#ff3e00;--good:#2fa968;--warn:#e8a317;--poor:#e5484d;--code-bg:#0e1525;--code-ink:#e7ecf4;--active-bg:#0c1322;--active-ink:#fff;--mono:ui-monospace,"SF Mono","JetBrains Mono",Menlo,Consolas,monospace;--sans:system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue",Arial,sans-serif}
+:root[data-theme="dark"]{--ground:#0b0e14;--panel:#12161f;--ink:#e7ecf4;--muted:#9aa4b2;--faint:#6b7484;--line:#232838;--line-strong:#2d3345;--code-bg:#05070c;--code-ink:#e7ecf4;--active-bg:#e7ecf4;--active-ink:#0b0e14}
+@media (prefers-color-scheme:dark){:root:not([data-theme="light"]){--ground:#0b0e14;--panel:#12161f;--ink:#e7ecf4;--muted:#9aa4b2;--faint:#6b7484;--line:#232838;--line-strong:#2d3345;--code-bg:#05070c;--code-ink:#e7ecf4;--active-bg:#e7ecf4;--active-ink:#0b0e14}}
+*{box-sizing:border-box}
+html,body{margin:0;height:100%}
+body{background:var(--ground);color:var(--ink);font-family:var(--sans);line-height:1.5;-webkit-font-smoothing:antialiased}
+.dv-app{display:grid;grid-template-rows:auto 1fr;grid-template-columns:280px 1fr;grid-template-areas:"top top" "side main";height:100vh}
+.dv-topbar{grid-area:top;border-bottom:1px solid var(--line);background:var(--panel)}
+.dv-topbar-inner{display:flex;align-items:center;justify-content:space-between;gap:16px;flex-wrap:wrap;padding:12px 20px}
+.dv-brand{display:flex;align-items:center;background:none;border:none;padding:0;cursor:pointer;border-radius:6px}
+.dv-brand svg{height:28px;width:auto;display:block}
+.dv-brand:focus-visible{outline:2px solid var(--accent);outline-offset:4px}
+.dv-meta{font-family:var(--mono);font-size:12px;color:var(--muted);display:flex;gap:12px;flex-wrap:wrap}
+.dv-status{display:flex;align-items:center;gap:10px}
+.dv-analyzing{font-size:12px;color:var(--accent);font-weight:600}
+.dv-conn{width:8px;height:8px;border-radius:50%;background:var(--faint);display:inline-block}
+.dv-conn-connected{background:var(--good)}
+.dv-conn-reconnecting{background:var(--warn)}
+.dv-menu-toggle{display:none;border:1px solid var(--line-strong);background:var(--panel);color:var(--ink);border-radius:8px;width:28px;height:28px;cursor:pointer}
+.dv-theme-toggle{border:1px solid var(--line-strong);background:var(--panel);color:var(--ink);border-radius:999px;width:28px;height:28px;cursor:pointer}
+.dv-theme-toggle:focus-visible,.dv-menu-toggle:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.dv-sidebar{grid-area:side;border-right:1px solid var(--line);background:var(--panel);overflow-y:auto}
+.dv-sidebar-inner{display:flex;flex-direction:column;gap:10px;padding:14px}
+.dv-search{font:inherit;font-size:13px;padding:7px 10px;border:1px solid var(--line-strong);border-radius:8px;background:var(--ground);color:var(--ink)}
+.dv-sort{font:inherit;font-size:12.5px;padding:6px 8px;border:1px solid var(--line-strong);border-radius:8px;background:var(--ground);color:var(--ink)}
+.dv-nav{display:flex;flex-direction:column;gap:2px}
+.dv-nav-item{display:flex;flex-direction:column;gap:4px;padding:8px 10px;border-radius:8px;cursor:pointer}
+.dv-nav-item:hover{background:var(--ground)}
+.dv-nav-item.active{background:var(--active-bg);color:var(--active-ink)}
+.dv-nav-item:focus-visible{outline:2px solid var(--accent);outline-offset:-2px}
+.dv-nav-label{font-family:var(--mono);font-size:13px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.dv-nav-meta{display:flex;align-items:center;gap:8px;font-size:11.5px;color:var(--muted)}
+.dv-nav-item.active .dv-nav-meta{color:inherit}
+.dv-nav-score{font-family:var(--mono);font-weight:700}
+.dv-badge{font-size:9.5px;font-weight:700;text-transform:uppercase;letter-spacing:.06em;padding:1px 6px;border-radius:999px}
+.dv-badge-measured{background:rgba(47,169,104,.16);color:var(--good)}
+.dv-badge-static{background:rgba(140,149,163,.2);color:var(--muted)}
+.dv-detail{grid-area:main;overflow-y:auto;padding:24px 28px 80px}
+.dv-gauge{position:relative;width:132px;height:132px;margin-bottom:20px}
+.dv-gauge svg{position:absolute;inset:0;transform:rotate(-90deg)}
+.dv-gauge-track{stroke:var(--line)}
+.dv-gauge-num{position:absolute;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center}
+.dv-gauge-num strong{font-family:var(--mono);font-size:36px;font-weight:600}
+.dv-gauge-num span{font-size:10px;text-transform:uppercase;letter-spacing:.14em;color:var(--muted)}
+.dv-cats{display:flex;gap:22px;flex-wrap:wrap;margin-bottom:20px}
+.dv-cat{min-width:180px;flex:1}
+.dv-cat-top{display:flex;justify-content:space-between;font-size:13px;margin-bottom:6px}
+.dv-bar{height:7px;border-radius:999px;background:var(--line);overflow:hidden}
+.dv-bar>i{display:block;height:100%;border-radius:999px}
+.dv-cat-reach{font-size:11.5px;color:var(--muted);margin-top:5px}
+.dv-filters{display:flex;gap:8px;flex-wrap:wrap;margin:16px 0}
+.dv-chip{font:inherit;font-size:12.5px;font-weight:600;cursor:pointer;background:var(--panel);border:1px solid var(--line-strong);color:var(--muted);padding:5px 12px;border-radius:999px}
+.dv-chip[aria-pressed="true"]{background:var(--active-bg);border-color:var(--active-bg);color:var(--active-ink)}
+.dv-chip:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.dv-section h2{font-size:12px;text-transform:uppercase;letter-spacing:.12em;color:var(--muted);margin:24px 0 12px}
+.dv-detail-header{display:flex;align-items:center;gap:12px;margin-bottom:14px;flex-wrap:wrap}
+.dv-route-path{font-family:var(--mono);font-size:16px;font-weight:600}
+.dv-score-chip{font-family:var(--mono);font-weight:700}
+.dv-finding{background:var(--panel);border:1px solid var(--line);border-left-width:3px;border-radius:10px;padding:16px 18px;margin:0 0 12px}
+.dv-finding-critical{border-left-color:var(--poor)}
+.dv-finding-warning{border-left-color:var(--warn)}
+.dv-finding-info{border-left-color:var(--faint)}
+.dv-f-head{display:flex;align-items:center;gap:10px;flex-wrap:wrap}
+.dv-ruleid{font-family:var(--mono);font-size:12px;font-weight:600;background:var(--ground);padding:2px 8px;border-radius:6px}
+.dv-f-title{font-weight:650;font-size:15px}
+.dv-sev-tag{margin-left:auto;font-size:11px;font-weight:700;text-transform:uppercase;letter-spacing:.08em}
+.dv-sev-critical{color:var(--poor)}
+.dv-sev-warning{color:var(--warn)}
+.dv-sev-info{color:var(--faint)}
+.dv-f-route{display:block;font:inherit;font-family:var(--mono);font-size:12.5px;font-weight:600;color:var(--accent);background:none;border:none;padding:0;margin:8px 0 0;cursor:pointer;text-align:left}
+.dv-f-route:hover{text-decoration:underline}
+.dv-f-route:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.dv-f-loc{font-family:var(--mono);font-size:12.5px;color:var(--muted);margin:8px 0 0}
+.dv-f-rec{font-size:14px;margin:10px 0 0}
+.dv-fix{margin:12px 0 0;background:var(--code-bg);border-radius:8px;overflow:hidden}
+.dv-fix-label{font-family:var(--mono);font-size:11px;letter-spacing:.1em;text-transform:uppercase;color:#8da0bd;padding:8px 14px 0}
+.dv-fix pre{margin:0;padding:8px 14px 14px;overflow-x:auto}
+.dv-fix code{font-family:var(--mono);font-size:12.5px;color:var(--code-ink);line-height:1.65;white-space:pre}
+.tok-kw{color:#ff7ab8}
+.tok-str{color:#9ece6a}
+.tok-num{color:#ff9e64}
+.tok-cm{color:#6b7280;font-style:italic}
+.tok-id{color:var(--code-ink)}
+.tok-pn{color:#8da0bd}
+.dv-f-link{display:inline-block;margin-top:12px;font-size:13px;font-weight:600;color:var(--accent);text-decoration:none}
+.dv-f-link:hover{text-decoration:underline}
+.dv-ai-prompt{margin-top:12px;border:1px solid var(--line);border-radius:8px;overflow:hidden}
+.dv-ai-prompt>summary{cursor:pointer;list-style:none;padding:8px 12px;font-size:12px;font-weight:600;color:var(--muted);display:flex;align-items:center;gap:6px;user-select:none}
+.dv-ai-prompt>summary::-webkit-details-marker{display:none}
+.dv-ai-prompt>summary::before{content:"\u25B8";display:inline-block;transition:transform .15s ease}
+.dv-ai-prompt[open]>summary::before{transform:rotate(90deg)}
+.dv-ai-prompt-body{padding:0 12px 12px;display:flex;flex-direction:column;gap:8px}
+.dv-ai-prompt-pre{margin:0;padding:10px 12px;background:var(--code-bg);color:var(--code-ink);border-radius:8px;font-family:var(--mono);font-size:12px;line-height:1.6;white-space:pre-wrap;word-break:break-word;max-height:280px;overflow-y:auto}
+.dv-ai-copy-btn{align-self:flex-start;font:inherit;font-size:12px;font-weight:600;cursor:pointer;background:var(--panel);border:1px solid var(--line-strong);color:var(--ink);padding:5px 12px;border-radius:999px}
+.dv-ai-copy-btn:hover{border-color:var(--faint)}
+.dv-ai-copy-btn:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.dv-empty{color:var(--muted);font-size:13px}
+@media (max-width:640px){.dv-app{grid-template-columns:1fr;grid-template-areas:"top" "main"}.dv-menu-toggle{display:inline-flex}.dv-sidebar{position:fixed;inset:0 20% 0 0;transform:translateX(-100%);transition:transform .2s ease;z-index:10}.dv-sidebar.open{transform:translateX(0)}}
+@media (prefers-reduced-motion:reduce){*{transition:none!important}}
+`;
+var APP_SCRIPT = `
+(function(){
+  var BAND_COLOR = { good: '#2fa968', warn: '#e8a317', poor: '#e5484d' };
+  var CATEGORY_NAMES = ${JSON.stringify(CATEGORY_LABEL)};
+  function scoreBand(score) { return score >= 90 ? 'good' : score >= 50 ? 'warn' : 'poor'; }
+
+  // Same mark as the docs site's hero wordmark (docs/public/wordmark.svg) \u2014 an inline
+  // copy, not an <img src>, since the dashboard is a single self-contained HTML response
+  // with no other static assets to serve alongside it. Fixed brand colors (not CSS custom
+  // properties), matching the docs usage: the wordmark reads the same in both themes.
+  var WORDMARK_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 380 56" role="img" aria-labelledby="dv-wordmark-title"><title id="dv-wordmark-title">svelte-vitals</title><defs><clipPath id="dv-wordmark-clip"><rect x="2" y="2" width="52" height="52" rx="14"/></clipPath></defs><rect x="2" y="2" width="52" height="52" rx="14" fill="#FF3E00"/><polyline clip-path="url(#dv-wordmark-clip)" points="4,28 15,28 17.5,23.5 20,28 23,28 26,7 29,49 32,28 35,28 37,24.5 39.5,28 52,28" fill="none" stroke="#fff" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"/><text x="70" y="38" font-family="ui-sans-serif, system-ui, -apple-system, \\'Segoe UI\\', Roboto, sans-serif" font-size="30" font-weight="700" fill="#FF3E00">svelte-vitals</text></svg>';
+
+  function h(tag, attrs, kids) {
+    var n = document.createElement(tag);
+    if (attrs) {
+      for (var k in attrs) {
+        if (!Object.prototype.hasOwnProperty.call(attrs, k)) continue;
+        var v = attrs[k];
+        if (v === undefined || v === null || v === false) continue;
+        if (k === 'class') n.className = v;
+        else if (k === 'text') n.textContent = v;
+        else if (k.indexOf('on') === 0 && typeof v === 'function') n.addEventListener(k.slice(2), v);
+        else n.setAttribute(k, v === true ? '' : String(v));
+      }
+    }
+    (kids || []).forEach(function (c) {
+      if (c === undefined || c === null || c === false) return;
+      n.appendChild(typeof c === 'string' ? document.createTextNode(c) : c);
+    });
+    return n;
+  }
+  function clear(n) { while (n.firstChild) n.removeChild(n.firstChild); }
+  function mount(id, node) { var el = document.getElementById(id); clear(el); el.appendChild(node); }
+
+  var HL_KEYWORDS = ['import','export','from','const','let','var','function','return','if','else','for','while','class','new','await','async','default','type','interface','extends','implements','this','typeof','instanceof','of','in','true','false','null','undefined'];
+  var HL_LANGS = { js: 1, javascript: 1, ts: 1, typescript: 1, svelte: 1, html: 1, css: 1 };
+
+  function highlightTokens(code) {
+    var tokens = [];
+    var i = 0;
+    var n = code.length;
+    var reIdent = /[A-Za-z_$][A-Za-z0-9_$]*/y;
+    var reNum = /\\d+(\\.\\d+)?/y;
+    while (i < n) {
+      var ch = code[i];
+      if (ch === '/' && code[i + 1] === '/') {
+        var end = code.indexOf('\\n', i);
+        if (end === -1) end = n;
+        tokens.push({ text: code.slice(i, end), cls: 'cm' });
+        i = end;
+        continue;
+      }
+      if (ch === '/' && code[i + 1] === '*') {
+        var end2 = code.indexOf('*/', i + 2);
+        end2 = end2 === -1 ? n : end2 + 2;
+        tokens.push({ text: code.slice(i, end2), cls: 'cm' });
+        i = end2;
+        continue;
+      }
+      if (ch === '"' || ch === "'" || ch === '\`') {
+        var quote = ch;
+        var j = i + 1;
+        while (j < n && code[j] !== quote) {
+          if (code[j] === '\\\\') j++;
+          j++;
+        }
+        j = Math.min(j + 1, n);
+        tokens.push({ text: code.slice(i, j), cls: 'str' });
+        i = j;
+        continue;
+      }
+      reIdent.lastIndex = i;
+      var mIdent = reIdent.exec(code);
+      if (mIdent && mIdent.index === i) {
+        var word = mIdent[0];
+        tokens.push({ text: word, cls: HL_KEYWORDS.indexOf(word) !== -1 ? 'kw' : 'id' });
+        i += word.length;
+        continue;
+      }
+      reNum.lastIndex = i;
+      var mNum = reNum.exec(code);
+      if (mNum && mNum.index === i) {
+        tokens.push({ text: mNum[0], cls: 'num' });
+        i += mNum[0].length;
+        continue;
+      }
+      tokens.push({ text: ch, cls: 'pn' });
+      i += 1;
+    }
+    return tokens;
+  }
+
+  function renderFixSnippet(fix) {
+    var pre = h('pre', null, []);
+    var code = h('code', null, []);
+    var lang = (fix.lang || 'svelte').toLowerCase();
+    if (HL_LANGS[lang]) {
+      highlightTokens(fix.snippet).forEach(function (t) {
+        code.appendChild(h('span', { class: 'tok-' + t.cls, text: t.text }, []));
+      });
+    } else {
+      code.textContent = fix.snippet;
+    }
+    pre.appendChild(code);
+    return pre;
+  }
+
+  // Plain-text, copy-pasteable prompt for a single finding \u2014 same ingredients as the
+  // agent reporter's per-finding block (rule id, location, recommendation, fix, docs),
+  // reshaped for a standalone request rather than a whole-project remediation doc.
+  function buildAiPrompt(issue, route) {
+    var lines = ['Fix this svelte-vitals finding:', ''];
+    lines.push('- Rule: ' + issue.id + ' \u2014 ' + issue.title + ' (' + issue.severity + ')');
+    if (route) lines.push('- Route: ' + route);
+    if (issue.location) {
+      lines.push('- Location: ' + issue.location + (issue.line !== undefined ? ':' + issue.line : ''));
+    }
+    if (issue.recommendation) lines.push('- Recommendation: ' + issue.recommendation);
+    if (issue.fix) {
+      lines.push('- Fix: ' + issue.fix.description);
+      if (issue.fix.snippet) {
+        lines.push('', '\`\`\`' + (issue.fix.lang || 'svelte'), issue.fix.snippet, '\`\`\`');
+      }
+    }
+    if (issue.docsUrl) lines.push('- Docs: ' + issue.docsUrl);
+    lines.push(
+      '',
+      'After fixing, re-run \`svelte-vitals --diff\` (or revisit this route) to confirm ' +
+        issue.id +
+        ' passes' +
+        (route ? ' for ' + route : '') +
+        '.'
+    );
+    return lines.join('\\n');
+  }
+
+  function copyToClipboard(text, btn) {
+    var original = 'Copy';
+    function reset(label) {
+      btn.textContent = label;
+      setTimeout(function () { btn.textContent = original; }, 1500);
+    }
+    function done() { reset('Copied!'); }
+    function fail() { reset('Copy failed'); }
+    function fallbackCopy() {
+      var ta = document.createElement('textarea');
+      ta.value = text;
+      ta.setAttribute('readonly', '');
+      ta.style.position = 'fixed';
+      ta.style.opacity = '0';
+      document.body.appendChild(ta);
+      ta.select();
+      var ok = false;
+      try { ok = document.execCommand('copy'); } catch (e) {}
+      document.body.removeChild(ta);
+      return ok;
+    }
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      navigator.clipboard.writeText(text).then(done, function () { fallbackCopy() ? done() : fail(); });
+    } else {
+      fallbackCopy() ? done() : fail();
+    }
+  }
+
+  function renderAiPrompt(issue, route) {
+    var text = buildAiPrompt(issue, route);
+    var btn = h('button', { type: 'button', class: 'dv-ai-copy-btn', text: 'Copy' }, []);
+    btn.addEventListener('click', function () { copyToClipboard(text, btn); });
+    return h('details', { class: 'dv-ai-prompt' }, [
+      h('summary', { text: 'AI Prompt' }, []),
+      h('div', { class: 'dv-ai-prompt-body' }, [
+        h('pre', { class: 'dv-ai-prompt-pre', text: text }, []),
+        btn
+      ])
+    ]);
+  }
+
+  var state = {
+    snapshot: null,
+    selected: 'overview',
+    search: '',
+    sort: 'score-asc',
+    filter: 'all',
+    theme: initialTheme(),
+    connection: 'connecting',
+    routeBySlug: {}
+  };
+
+  function initialTheme() {
+    try {
+      var stored = localStorage.getItem('svelte-vitals-theme');
+      if (stored === 'dark' || stored === 'light') return stored;
+    } catch (e) {}
+    return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+  }
+  function applyTheme() { document.documentElement.setAttribute('data-theme', state.theme); }
+  function toggleTheme() {
+    state.theme = state.theme === 'dark' ? 'light' : 'dark';
+    try { localStorage.setItem('svelte-vitals-theme', state.theme); } catch (e) {}
+    applyTheme();
+    renderTopbar();
+  }
+  function toggleSidebar() {
+    var sb = document.getElementById('dv-sidebar');
+    if (sb) sb.classList.toggle('open');
+  }
+
+  function brandEl() {
+    var el = h('button', { type: 'button', class: 'dv-brand', 'aria-label': 'Go to Overview', onclick: function () { selectItem('overview'); } }, []);
+    el.innerHTML = WORDMARK_SVG;
+    return el;
+  }
+
+  function renderTopbar() {
+    var s = state.snapshot;
+    var findings = s.report.routes.reduce(function (n, r) { return n + r.issues.length; }, 0) + s.report.siteIssues.length;
+    var kids = [
+      h('button', { type: 'button', class: 'dv-menu-toggle', 'aria-label': 'Toggle route list', onclick: toggleSidebar, text: '\u2261' }, []),
+      brandEl(),
+      h('div', { class: 'dv-meta' }, [
+        h('span', { text: 'v' + s.meta.version }, []),
+        s.meta.coreVersion ? h('span', { title: '@svelte-vitals/core version', text: 'core v' + s.meta.coreVersion }, []) : null,
+        h('span', { text: s.report.routes.length + ' routes' }, []),
+        h('span', { text: findings + ' findings' }, [])
+      ].filter(Boolean)),
+      h('div', { class: 'dv-status' }, [
+        s.live && s.analyzing ? h('span', { class: 'dv-analyzing', text: 'Analyzing\u2026' }, []) : null,
+        s.live ? h('span', { class: 'dv-conn dv-conn-' + state.connection, title: state.connection }, []) : null,
+        h('button', { type: 'button', class: 'dv-theme-toggle', 'aria-label': 'Toggle dark mode', onclick: toggleTheme, text: state.theme === 'dark' ? '\u2600' : '\u263E' }, [])
+      ].filter(Boolean))
+    ];
+    mount('dv-topbar', h('div', { class: 'dv-topbar-inner' }, kids));
+  }
+
+  function slugify(route) {
+    return 'route-' + route.replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-|-$/g, '').toLowerCase();
+  }
+
+  function matchesSearch(route, q) {
+    if (!q) return true;
+    q = q.toLowerCase();
+    if (route.route.toLowerCase().indexOf(q) !== -1) return true;
+    return route.issues.some(function (iss) {
+      return (iss.id + ' ' + iss.title + ' ' + (iss.location || '')).toLowerCase().indexOf(q) !== -1;
+    });
+  }
+
+  function sortedRoutes() {
+    var s = state.snapshot;
+    var q = state.search.trim();
+    var list = s.report.routes.filter(function (r) { return matchesSearch(r, q); }).slice();
+    var sort = state.sort;
+    if (sort === 'score-asc') list.sort(function (a, b) { return a.score - b.score; });
+    else if (sort === 'score-desc') list.sort(function (a, b) { return b.score - a.score; });
+    else if (sort === 'alpha') list.sort(function (a, b) { return a.route.localeCompare(b.route); });
+    else if (sort === 'most-findings') list.sort(function (a, b) { return b.issues.length - a.issues.length; });
+    return list;
+  }
+
+  function renderNavItem(label, key, route, active) {
+    var kids = [h('span', { class: 'dv-nav-label', text: label }, [])];
+    if (route) {
+      var band = scoreBand(route.score);
+      var crit = route.issues.filter(function (i) { return i.severity === 'critical'; }).length;
+      var warn = route.issues.filter(function (i) { return i.severity === 'warning'; }).length;
+      var info = route.issues.filter(function (i) { return i.severity === 'info'; }).length;
+      var summary = [];
+      if (crit) summary.push(crit + ' critical');
+      if (warn) summary.push(warn + ' warning' + (warn > 1 ? 's' : ''));
+      if (info) summary.push(info + ' info');
+      var badge = state.snapshot.badges[route.route];
+      kids.push(h('span', { class: 'dv-nav-meta' }, [
+        badge ? h('span', { class: 'dv-badge dv-badge-' + badge, text: badge }, []) : null,
+        h('span', { class: 'dv-nav-score', style: 'color:' + BAND_COLOR[band], text: String(route.score) }, []),
+        h('span', { class: 'dv-nav-sum', text: summary.length ? summary.join(' \xB7 ') : 'no issues' }, [])
+      ].filter(Boolean)));
+    }
+    return h('div', {
+      class: 'dv-nav-item' + (active ? ' active' : ''),
+      role: 'option',
+      'aria-selected': active ? 'true' : 'false',
+      tabindex: '0',
+      onclick: function () { selectItem(key); },
+      onkeydown: function (e) { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); selectItem(key); } }
+    }, kids);
+  }
+
+  function selectItem(key) {
+    state.selected = key;
+    location.hash = key === 'overview' ? 'overview' : 'route/' + slugify(key);
+    var sb = document.getElementById('dv-sidebar');
+    if (sb) sb.classList.remove('open');
+    renderSidebar();
+    renderDetail();
+  }
+
+  function renderSidebar() {
+    var s = state.snapshot;
+    state.routeBySlug = {};
+
+    // mount() clears and rebuilds the whole sidebar, including the <input> itself, so
+    // a naive re-render on every keystroke drops focus and cursor position \u2014 capture
+    // them before rebuilding and restore them on the freshly-created input afterward.
+    var prevSearch = document.querySelector('.dv-search');
+    var hadFocus = !!prevSearch && document.activeElement === prevSearch;
+    var selStart = hadFocus ? prevSearch.selectionStart : null;
+    var selEnd = hadFocus ? prevSearch.selectionEnd : null;
+
+    var searchInput = h('input', {
+      type: 'search',
+      class: 'dv-search',
+      placeholder: 'Search routes or rules\u2026',
+      value: state.search,
+      oninput: function (e) { state.search = e.target.value; renderSidebar(); }
+    }, []);
+
+    var sortSelect = h('select', { class: 'dv-sort', 'aria-label': 'Sort routes', onchange: function (e) { state.sort = e.target.value; renderSidebar(); } }, [
+      h('option', { value: 'score-asc', selected: state.sort === 'score-asc' || undefined, text: 'Score (worst first)' }, []),
+      h('option', { value: 'score-desc', selected: state.sort === 'score-desc' || undefined, text: 'Score (best first)' }, []),
+      h('option', { value: 'alpha', selected: state.sort === 'alpha' || undefined, text: 'Alphabetical' }, []),
+      h('option', { value: 'most-findings', selected: state.sort === 'most-findings' || undefined, text: 'Most findings' }, [])
+    ]);
+
+    var items = [renderNavItem('Overview', 'overview', null, state.selected === 'overview')];
+    sortedRoutes().forEach(function (r) {
+      var slug = slugify(r.route);
+      state.routeBySlug[slug] = r.route;
+      items.push(renderNavItem(r.route, r.route, r, state.selected === r.route));
+    });
+
+    var nav = h('div', { class: 'dv-nav', role: 'listbox', 'aria-label': 'Routes' }, items);
+    mount('dv-sidebar', h('div', { class: 'dv-sidebar-inner' }, [searchInput, sortSelect, nav]));
+
+    if (hadFocus) {
+      searchInput.focus();
+      if (selStart !== null && searchInput.setSelectionRange) {
+        searchInput.setSelectionRange(selStart, selEnd);
+      }
+    }
+  }
+
+  function renderFilterChips(categories) {
+    var chip = function (filter, label) {
+      return h('button', {
+        type: 'button', class: 'dv-chip', 'aria-pressed': state.filter === filter ? 'true' : 'false',
+        onclick: function () { state.filter = filter; renderDetail(); },
+        text: label
+      }, []);
+    };
+    var catChips = Object.keys(categories).map(function (cat) {
+      var name = CATEGORY_NAMES[cat] || cat;
+      return chip(cat, name);
+    });
+    return h('div', { class: 'dv-filters', role: 'group', 'aria-label': 'Filter findings' },
+      [chip('all', 'All'), chip('critical', 'Critical'), chip('warning', 'Warning'), chip('info', 'Info')].concat(catChips));
+  }
+
+  function passesFilter(issue) {
+    var f = state.filter;
+    return f === 'all' || issue.severity === f || issue.category === f;
+  }
+
+  var SEVERITY_ORDER = { critical: 0, warning: 1, info: 2 };
+
+  function renderFinding(issue, route, promptRoute) {
+    var kids = [
+      h('div', { class: 'dv-f-head' }, [
+        h('span', { class: 'dv-ruleid', text: issue.id }, []),
+        h('span', { class: 'dv-f-title', text: issue.title }, []),
+        h('span', { class: 'dv-sev-tag dv-sev-' + issue.severity, text: issue.severity }, [])
+      ])
+    ];
+    if (route) {
+      kids.push(h('button', { type: 'button', class: 'dv-f-route', onclick: function () { selectItem(route); }, text: route }, []));
+    }
+    if (issue.location) {
+      kids.push(h('p', { class: 'dv-f-loc', text: issue.location + (issue.line !== undefined ? ':' + issue.line : '') }, []));
+    }
+    if (issue.recommendation) {
+      kids.push(h('p', { class: 'dv-f-rec', text: issue.recommendation }, []));
+    }
+    if (issue.fix && issue.fix.snippet) {
+      kids.push(h('div', { class: 'dv-fix' }, [h('div', { class: 'dv-fix-label', text: 'fix' }, []), renderFixSnippet(issue.fix)]));
+    }
+    if (issue.docsUrl) {
+      kids.push(h('a', { class: 'dv-f-link', href: issue.docsUrl, text: 'Learn more' }, []));
+    }
+    kids.push(renderAiPrompt(issue, promptRoute !== undefined ? promptRoute : route));
+    return h('article', { class: 'dv-finding dv-finding-' + issue.severity }, kids);
+  }
+
+  function renderGauge(score) {
+    var band = scoreBand(score);
+    var svgNs = 'http://www.w3.org/2000/svg';
+    var C = 2 * Math.PI * 58;
+    var offset = (C * (1 - score / 100)).toFixed(1);
+    var svg = document.createElementNS(svgNs, 'svg');
+    svg.setAttribute('width', '132');
+    svg.setAttribute('height', '132');
+    svg.setAttribute('viewBox', '0 0 132 132');
+    var bg = document.createElementNS(svgNs, 'circle');
+    bg.setAttribute('cx', '66'); bg.setAttribute('cy', '66'); bg.setAttribute('r', '58');
+    bg.setAttribute('fill', 'none'); bg.setAttribute('class', 'dv-gauge-track'); bg.setAttribute('stroke-width', '11');
+    var arc = document.createElementNS(svgNs, 'circle');
+    arc.setAttribute('cx', '66'); arc.setAttribute('cy', '66'); arc.setAttribute('r', '58');
+    arc.setAttribute('fill', 'none'); arc.setAttribute('stroke', BAND_COLOR[band]); arc.setAttribute('stroke-width', '11');
+    arc.setAttribute('stroke-linecap', 'round');
+    arc.setAttribute('stroke-dasharray', C.toFixed(1));
+    arc.setAttribute('stroke-dashoffset', offset);
+    svg.appendChild(bg);
+    svg.appendChild(arc);
+    var wrap = h('div', { class: 'dv-gauge' }, [h('div', { class: 'dv-gauge-num' }, [h('strong', { text: String(score) }, []), h('span', { text: 'Health' }, [])])]);
+    wrap.insertBefore(svg, wrap.firstChild);
+    return wrap;
+  }
+
+  function renderOverview(s) {
+    var gauge = renderGauge(s.report.score);
+    var cats = Object.keys(s.report.categories).map(function (cat) {
+      var c = s.report.categories[cat];
+      var band = scoreBand(c.score);
+      var weight = s.report.weights[cat];
+      var name = CATEGORY_NAMES[cat] || cat;
+      // keys/affectedKeys are absent on hand-built snapshots (older fixtures, tests) \u2014
+      // render nothing rather than "undefined of undefined". 0 affected of N keys is still
+      // rendered: on a real project that's the signal a thin score can't give, that the
+      // category is clean project-wide and not just on the one key it happened to look at
+      // (design: 2026-08-05-score-floor-and-reach-design.md).
+      var reach = typeof c.keys === 'number' && c.keys > 0
+        ? h('div', { class: 'dv-cat-reach', text: c.affectedKeys + ' of ' + c.keys + ' keys affected' }, [])
+        : null;
+      return h('div', { class: 'dv-cat' }, [
+        h('div', { class: 'dv-cat-top' }, [
+          h('span', { text: name + (weight !== undefined ? ' (weight ' + weight + ')' : '') }, []),
+          h('span', { style: 'color:' + BAND_COLOR[band], text: String(c.score) }, [])
+        ]),
+        h('div', { class: 'dv-bar' }, [h('i', { style: 'width:' + c.score + '%;background:' + BAND_COLOR[band] }, [])]),
+        reach
+      ]);
+    });
+    var chips = renderFilterChips(s.report.categories);
+    var totalCount = s.report.routes.reduce(function (n, r) { return n + r.issues.length; }, 0) + s.report.siteIssues.length;
+    var entries = [];
+    s.report.routes.forEach(function (r) {
+      r.issues.forEach(function (issue) { entries.push({ issue: issue, route: r.route }); });
+    });
+    s.report.siteIssues.forEach(function (issue) { entries.push({ issue: issue, route: null }); });
+    entries = entries.filter(function (e) { return passesFilter(e.issue); });
+    entries.sort(function (a, b) {
+      var sd = SEVERITY_ORDER[a.issue.severity] - SEVERITY_ORDER[b.issue.severity];
+      if (sd !== 0) return sd;
+      return (a.route || '').localeCompare(b.route || '');
+    });
+    var body = entries.length
+      ? entries.map(function (e) { return renderFinding(e.issue, e.route); })
+      : [h('p', { class: 'dv-empty', text: totalCount ? 'No issues match the current filter.' : 'No issues found \u2014 nice work!' }, [])];
+    var findings = h('section', { class: 'dv-section' }, [h('h2', { text: 'Findings' }, [])].concat(body));
+    return h('div', { class: 'dv-overview' }, [gauge, h('div', { class: 'dv-cats' }, cats), chips, findings].filter(Boolean));
+  }
+
+  function renderRouteDetail(route) {
+    var badge = state.snapshot.badges[route.route];
+    var band = scoreBand(route.score);
+    var header = h('div', { class: 'dv-detail-header' }, [
+      h('span', { class: 'dv-route-path', text: route.route }, []),
+      badge ? h('span', { class: 'dv-badge dv-badge-' + badge, text: badge }, []) : null,
+      h('span', { class: 'dv-score-chip', style: 'color:' + BAND_COLOR[band], text: String(route.score) }, [])
+    ].filter(Boolean));
+    var chips = renderFilterChips(state.snapshot.report.categories);
+    var findings = route.issues.filter(passesFilter);
+    var body = findings.length
+      ? findings.map(function (issue) { return renderFinding(issue, undefined, route.route); })
+      : [h('p', { class: 'dv-empty', text: 'No issues match the current filter.' }, [])];
+    return h('div', { class: 'dv-route-detail' }, [header, chips].concat(body));
+  }
+
+  function renderDetail() {
+    var s = state.snapshot;
+    if (state.selected === 'overview') {
+      mount('dv-detail', renderOverview(s));
+      return;
+    }
+    var route = s.report.routes.filter(function (r) { return r.route === state.selected; })[0];
+    if (!route) {
+      state.selected = 'overview';
+      mount('dv-detail', renderOverview(s));
+      return;
+    }
+    mount('dv-detail', renderRouteDetail(route));
+  }
+
+  function renderAll() {
+    renderTopbar();
+    renderSidebar();
+    renderDetail();
+  }
+
+  function restoreSelectionFromHash() {
+    var raw = location.hash.replace(/^#/, '');
+    if (!raw || raw === 'overview') { state.selected = 'overview'; return; }
+    var m = /^route\\/(.+)$/.exec(raw);
+    if (m && state.routeBySlug[m[1]]) state.selected = state.routeBySlug[m[1]];
+  }
+
+  function fetchSnapshot() {
+    fetch('/__svelte-vitals/data.json').then(function (r) { return r.json(); }).then(function (data) {
+      if (state.snapshot && data.sequence <= state.snapshot.sequence) return;
+      state.snapshot = data;
+      renderAll();
+    }).catch(function () {});
+  }
+
+  function boot() {
+    var raw = document.getElementById('svelte-vitals-data');
+    state.snapshot = JSON.parse(raw.textContent);
+    applyTheme();
+    renderSidebar(); // populates routeBySlug before the hash can be trusted
+    restoreSelectionFromHash();
+    renderAll();
+
+    window.addEventListener('hashchange', function () {
+      restoreSelectionFromHash();
+      renderSidebar();
+      renderDetail();
+    });
+
+    // Static export (the CLI's --reporter html): no dev server behind the page, so no
+    // SSE connection, no /data.json refetch, no connection indicator.
+    if (state.snapshot.live && typeof EventSource !== 'undefined') {
+      var es = new EventSource('/__svelte-vitals/events');
+      es.addEventListener('open', function () { state.connection = 'connected'; renderTopbar(); fetchSnapshot(); });
+      es.addEventListener('update', fetchSnapshot);
+      es.addEventListener('error', function () { state.connection = 'reconnecting'; renderTopbar(); });
+    }
+  }
+
+  boot();
+})();
+`;
+function renderAppShell(snapshot) {
+  const safe = { ...snapshot, report: sanitizeReport(snapshot.report) };
+  const title = snapshot.live ? "svelte-vitals dashboard" : "svelte-vitals report";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>${title}</title><style>${APP_STYLE}</style></head><body><div class="dv-app" id="dv-app"><header class="dv-topbar" id="dv-topbar"></header><nav class="dv-sidebar" id="dv-sidebar"></nav><main class="dv-detail" id="dv-detail"></main></div><script type="application/json" id="svelte-vitals-data">${embedJson(safe)}</script><script>${APP_SCRIPT}</script></body></html>`;
+}
+function buildHtmlDocument(report, meta) {
+  return renderAppShell({
+    report,
+    badges: {},
+    analyzing: false,
+    sequence: 0,
+    live: false,
+    meta
+  });
+}
+function formatHtmlReport(results, config, meta) {
+  return buildHtmlDocument(buildJsonReport(results, config, meta), meta);
+}
+export {
+  APP_SCRIPT,
+  APP_STYLE,
+  BAND_COLOR,
+  CHILD_NODE_KEYS,
+  IDREF_ATTRS,
+  LANDMARK_ROLES,
+  READ_CONCURRENCY,
+  ROBOTS_SOURCE_PATHS,
+  SITEMAP_SOURCE_PATHS,
+  SVELTE_CONFIG_FILES,
+  VITE_CONFIG_FILES,
+  a11yAccessibleName,
+  a11yDoctype,
+  a11yDuplicateLandmark,
+  a11yIdDuplication,
+  a11yInteractiveNesting,
+  a11yInvalidAriaValue,
+  a11yInvalidRole,
+  a11yLabelHasControl,
+  a11yNoMissingIdRef,
+  a11yPlaceholderLabelOption,
+  a11yRequireDatetime,
+  a11yRequiredAriaProps,
+  a11yTopLevelLandmark,
+  a11yUnknownAriaAttribute,
+  a11yUseList,
+  allRules,
+  applyOverrides,
+  applyRuleSeverities,
+  architectureComponentSize,
+  architectureDirectoryNaming,
+  architectureDocLinkTarget,
+  architecturePrivateScopeImport,
+  architecturePropCount,
+  architectureReservedDirectoryNames,
+  architectureReservedNamePlacement,
+  architectureRouteComponentImport,
+  architectureUnitEntryFile,
+  attrText,
+  attrTextOf,
+  attrValue,
+  attrValueOf,
+  buildHtmlDocument,
+  buildJsonReport,
+  classify,
+  collectComponentFacts,
+  collectKitModuleFacts,
+  collectSourceFiles,
+  compileOverrides,
+  computeHealth,
+  computeScore,
+  correctnessBasePathNavigation,
+  correctnessCheckableBindValue,
+  correctnessEachIndexKey,
+  correctnessEachKey,
+  correctnessEffectAsDerived,
+  correctnessEffectAsOnMount,
+  correctnessInstanceBrowserGlobal,
+  correctnessNonreactiveBuiltinState,
+  correctnessOrphanEffect,
+  correctnessOrphanLifecycle,
+  correctnessPropMutation,
+  correctnessServerBrowserGlobal,
+  correctnessStalePropDerivation,
+  correctnessUnmutatedState,
+  decodeFragmentId,
+  defaultConfig,
+  defaultProject,
+  docsUrlFor,
+  effectiveSeverity,
+  emptyComponentFacts,
+  emptyKitModuleFacts,
+  escapeHtml,
+  explainRule,
+  findAttr,
+  findKitAliasesInSvelteConfig,
+  findKitPathsBaseInSvelteConfig,
+  findKitPathsBaseInViteConfig,
+  findMinifyDisabled,
+  foldOccurrences,
+  formatAgentReport,
+  formatConsoleReport,
+  formatFailedRuleWarning,
+  formatGithubReport,
+  formatHtmlReport,
+  formatJsonReport,
+  formatMarkdownReport,
+  formatSarifReport,
+  hasFailureAtOrAbove,
+  headTagRule,
+  imageRule,
+  intOption,
+  isMentionedAnywhere,
+  isPenalized,
+  isTopFragment,
+  lineOf,
+  linkRule,
+  listOption,
+  mapOption,
+  noColorPalette,
+  overrideMatches,
+  parseComponentFacts,
+  parseKitModuleFacts,
+  parseSvelte,
+  performanceFontPreloadCrossorigin,
+  performanceHeavyImport,
+  performanceImageDimensions,
+  performanceImageLoadingHint,
+  performanceLcpImage,
+  performanceLoadWaterfall,
+  performanceMinifyDisabled,
+  performanceNamespaceImport,
+  performancePreconnect,
+  performancePreloadMissingAs,
+  performanceRenderBlockingScript,
+  performanceResponsiveImage,
+  performanceSequentialAwaits,
+  performanceStateRaw,
+  renderAppShell,
+  resolveKitAliases,
+  resolveKitPathsBase,
+  resolveRepoLocalPath,
+  resolveRuleOptions,
+  resolveRunesModuleSpecifier,
+  runRules,
+  safeHref,
+  scoreBand,
+  scoreColor,
+  scoresByCategory,
+  securityHandlerStateWrite,
+  securityJavascriptUrl,
+  securityRawHtml,
+  securityServerModuleState,
+  securitySharedStateImport,
+  selectRules,
+  seoCanonicalUrl,
+  seoCharset,
+  seoDescriptionLength,
+  seoDescriptionPresence,
+  seoDuplicateDescription,
+  seoDuplicateTitle,
+  seoHeadingLevelSkip,
+  seoHreflang,
+  seoHtmlLang,
+  seoImageAlt,
+  seoIndexability,
+  seoJsonLd,
+  seoJsonLdDateFormat,
+  seoJsonLdDeprecatedType,
+  seoJsonLdPlaceholder,
+  seoJsonLdRelativeUrl,
+  seoJsonLdRequiredProps,
+  seoJsonLdValidity,
+  seoOgDescription,
+  seoOgImage,
+  seoOgTitle,
+  seoOgUrl,
+  seoRobotsTxt,
+  seoSingleH1,
+  seoSitemapInRobots,
+  seoSitemapXml,
+  seoSsrDisabled,
+  seoTitleLength,
+  seoTitlePresence,
+  seoTwitterCard,
+  seoViewport,
+  settingOptions,
+  settingSeverity,
+  shouldSkipRangeCheck,
+  skippedFileWarnings,
+  splitTokens,
+  stripTextDirective,
+  summarize,
+  terminalSafe,
+  textFromNodes,
+  validateRuleOptions,
+  validateRuleSetting,
+  valueFromNodes,
+  withFailedRulesOff,
+  withReadLimit
+};