@svelte-vitals/core 0.42.0 → 0.43.0

package/dist/index.js

@@ -4,7 +4,14 @@ var defaultProject = {
   hasSitemap: false,
   htmlLang: { presence: "none", value: "absent" }
 };
-var CATEGORIES = ["seo", "performance", "correctness", "security", "architecture"];
+var CATEGORIES = [
+  "seo",
+  "performance",
+  "correctness",
+  "security",
+  "architecture",
+  "a11y"
+];
 var defaultConfig = {
   treatDynamicAs: "pass",
   metaComponents: [],
@@ -15,6 +22,71 @@ function defineConfig(config = {}) {
   return { ...defaultConfig, ...config };
 }
 
+// src/a11y.ts
+function foldOccurrences(nodes) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.repeatable) continue;
+    const list = byKey.get(node.key);
+    if (list) list.push(node);
+    else byKey.set(node.key, [node]);
+  }
+  const folded = /* @__PURE__ */ new Map();
+  for (const [key, list] of byKey) folded.set(key, foldAt(list, 0));
+  return folded;
+}
+function foldAt(nodes, depth) {
+  const unconditional = [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const step = node.path[depth];
+    if (!step) {
+      unconditional.push(node);
+      continue;
+    }
+    let branches = groups.get(step.group);
+    if (!branches) groups.set(step.group, branches = /* @__PURE__ */ new Map());
+    const list = branches.get(step.branch);
+    if (list) list.push(node);
+    else branches.set(step.branch, [node]);
+  }
+  const representatives = [...unconditional];
+  for (const branches of groups.values()) {
+    let best = [];
+    let bestBranch = Number.POSITIVE_INFINITY;
+    for (const [branch, list] of branches) {
+      const arm = foldAt(list, depth + 1);
+      if (arm.length > best.length || arm.length === best.length && branch < bestBranch) {
+        best = arm;
+        bestBranch = branch;
+      }
+    }
+    representatives.push(...best);
+  }
+  return representatives;
+}
+function decodeFragmentId(fragment) {
+  try {
+    return decodeURIComponent(fragment);
+  } catch {
+    return fragment;
+  }
+}
+function splitTokens(value) {
+  return value ? value.trim().split(/\s+/).filter(Boolean) : [];
+}
+var LANDMARK_ROLES = /* @__PURE__ */ new Set(["main", "banner", "contentinfo", "complementary"]);
+var IDREF_ATTRS = [
+  "for",
+  "aria-labelledby",
+  "aria-describedby",
+  "aria-controls",
+  "aria-activedescendant"
+];
+function isTopFragment(id) {
+  return id.toLowerCase() === "top";
+}
+
 // src/component-parse.ts
 import { parse } from "svelte/compiler";
 
@@ -82,6 +154,57 @@ function attrTextOf(attr) {
   return Array.isArray(v) ? textFromNodes(v) : void 0;
 }
 
+// src/rules/a11y/interactive.ts
+var ALWAYS_INTERACTIVE_TAGS = /* @__PURE__ */ new Set(["button", "select", "textarea", "summary", "embed", "iframe"]);
+var INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "checkbox",
+  "radio",
+  "switch",
+  "tab",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "option",
+  "slider",
+  "spinbutton",
+  "textbox",
+  "combobox",
+  "searchbox",
+  "scrollbar",
+  "gridcell"
+]);
+function literalOf(attrs, name) {
+  return attrs.find((a) => a.name === name)?.literal;
+}
+function hasInteractiveRole(attrs) {
+  const role = splitTokens(literalOf(attrs, "role"))[0];
+  return role !== void 0 && INTERACTIVE_ROLES.has(role);
+}
+function isInteractiveElement(tag, attrs) {
+  if (ALWAYS_INTERACTIVE_TAGS.has(tag)) return true;
+  if (tag === "a" && literalOf(attrs, "href") !== void 0) return true;
+  if (tag === "input") {
+    const typeAttr = attrs.find((a) => a.name === "type");
+    if (!typeAttr) return true;
+    if (typeAttr.literal !== void 0) return typeAttr.literal.toLowerCase() !== "hidden";
+    return false;
+  }
+  if ((tag === "audio" || tag === "video") && attrs.some((a) => a.name === "controls")) return true;
+  const tabindex = literalOf(attrs, "tabindex")?.trim();
+  if (tabindex) {
+    const n = Number(tabindex);
+    if (Number.isFinite(n) && n >= 0) return true;
+  }
+  return hasInteractiveRole(attrs);
+}
+function isInteractiveContainer(tag, attrs) {
+  if (tag === "button") return true;
+  if (tag === "a") return literalOf(attrs, "href") !== void 0;
+  return hasInteractiveRole(attrs);
+}
+
 // src/component-parse.ts
 function unwrapTs(expr) {
   let cur = expr;
@@ -715,6 +838,304 @@ function collectCheckableBindValues(node, source, acc) {
     if (key in node) collectCheckableBindValues(node[key], source, acc);
   }
 }
+function classifyAttrValue(value) {
+  if (value === true) return { literal: "" };
+  if (Array.isArray(value) && value.length === 1 && value[0]?.type === "Text") {
+    return { literal: String(value[0].data ?? "") };
+  }
+  return { expression: true };
+}
+function collectAriaElements(node, source, acc) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectAriaElements(child, source, acc);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "RegularElement" && Array.isArray(node.attributes)) {
+    const roleAttr = findAttr(node.attributes, "role");
+    const ariaAttrs = node.attributes.filter(
+      (a) => a?.type === "Attribute" && typeof a.name === "string" && a.name.startsWith("aria-")
+    );
+    if (roleAttr || ariaAttrs.length > 0) {
+      const inputType = node.name === "input" ? attrText(node.attributes, "type") : void 0;
+      const hasSpread = node.attributes.some((a) => a?.type === "SpreadAttribute");
+      acc.push({
+        tag: node.name,
+        line: lineOf(source, node.start),
+        ...roleAttr ? { role: classifyAttrValue(roleAttr.value) } : {},
+        ...inputType !== void 0 ? { inputType: inputType.toLowerCase() } : {},
+        ...hasSpread ? { hasSpread: true } : {},
+        aria: ariaAttrs.map((a) => ({
+          name: a.name,
+          line: lineOf(source, a.start ?? node.start),
+          ...classifyAttrValue(a.value)
+        }))
+      });
+    }
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectAriaElements(node[key], source, acc);
+  }
+}
+function elementAttrs(attributes) {
+  return attributes.filter((a) => a?.type === "Attribute" && typeof a.name === "string").map((a) => ({ name: a.name, ...classifyAttrValue(a.value) }));
+}
+function collectInteractiveNestings(node, source, acc, stack) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectInteractiveNestings(child, source, acc, stack);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "SnippetBlock") {
+    for (const key of CHILD_NODE_KEYS) {
+      if (key in node) collectInteractiveNestings(node[key], source, acc, []);
+    }
+    return;
+  }
+  let opened = false;
+  if (node.type === "RegularElement" && Array.isArray(node.attributes)) {
+    const attrs = elementAttrs(node.attributes);
+    if (stack.length > 0 && isInteractiveElement(node.name, attrs)) {
+      acc.push({
+        containerTag: stack[stack.length - 1],
+        descendantTag: node.name,
+        line: lineOf(source, node.start)
+      });
+    }
+    if (isInteractiveContainer(node.name, attrs)) {
+      stack.push(node.name);
+      opened = true;
+    }
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectInteractiveNestings(node[key], source, acc, stack);
+  }
+  if (opened) stack.pop();
+}
+function hasNamingAttr(attributes) {
+  return ["aria-label", "aria-labelledby", "title"].some((name) => {
+    const attr = findAttr(attributes, name);
+    if (!attr) return false;
+    const v = classifyAttrValue(attr.value);
+    return "expression" in v || v.literal !== void 0 && v.literal.trim().length > 0;
+  });
+}
+function scanAccessibleNameSubtree(node) {
+  if (Array.isArray(node)) {
+    const acc2 = { named: false, unknowable: false };
+    for (const child of node) {
+      const r = scanAccessibleNameSubtree(child);
+      acc2.named ||= r.named;
+      acc2.unknowable ||= r.unknowable;
+    }
+    return acc2;
+  }
+  if (!node || typeof node !== "object") return { named: false, unknowable: false };
+  if (node.type === "SnippetBlock") return { named: false, unknowable: false };
+  if (node.type === "Text") return { named: String(node.data ?? "").trim().length > 0, unknowable: false };
+  if (node.type === "ExpressionTag" || node.type === "RenderTag" || node.type === "HtmlTag" || COMPONENT_LIKE_TYPES.has(node.type)) {
+    return { named: false, unknowable: true };
+  }
+  if (node.type === "RegularElement" && node.name === "img" && Array.isArray(node.attributes)) {
+    const alt = attrText(node.attributes, "alt");
+    if (alt !== void 0 && alt.trim().length > 0) return { named: true, unknowable: false };
+  }
+  const acc = { named: false, unknowable: false };
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) {
+      const r = scanAccessibleNameSubtree(node[key]);
+      acc.named ||= r.named;
+      acc.unknowable ||= r.unknowable;
+    }
+  }
+  return acc;
+}
+function accessibleNameTarget(node) {
+  if (node.name === "button") return "button";
+  if (node.name === "a") return attrText(node.attributes, "href") !== void 0 ? "a" : void 0;
+  if (node.name === "input") {
+    const type = attrText(node.attributes, "type");
+    return type?.toLowerCase() === "image" ? "input" : void 0;
+  }
+  return void 0;
+}
+function collectUnnamedInteractive(node, source, acc) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectUnnamedInteractive(child, source, acc);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "RegularElement" && Array.isArray(node.attributes)) {
+    const target = accessibleNameTarget(node);
+    const hasSpread = node.attributes.some((a) => a?.type === "SpreadAttribute");
+    if (target && !hasSpread) {
+      if (target === "input") {
+        const alt = attrText(node.attributes, "alt");
+        if (!hasNamingAttr(node.attributes) && !(alt !== void 0 && alt.trim().length > 0)) {
+          acc.push({ tag: node.name, line: lineOf(source, node.start) });
+        }
+      } else {
+        const scan = scanAccessibleNameSubtree(node);
+        if (!hasNamingAttr(node.attributes) && !scan.named && !scan.unknowable) {
+          acc.push({ tag: node.name, line: lineOf(source, node.start) });
+        }
+      }
+    }
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectUnnamedInteractive(node[key], source, acc);
+  }
+}
+var LABELABLE_TAGS = /* @__PURE__ */ new Set(["input", "select", "textarea", "button", "meter", "output", "progress"]);
+function isLabelableDescendant(node) {
+  if (node.type !== "RegularElement" || !LABELABLE_TAGS.has(node.name)) return false;
+  if (node.name !== "input") return true;
+  return attrText(node.attributes ?? [], "type")?.toLowerCase() !== "hidden";
+}
+function scanLabelSubtree(node) {
+  if (Array.isArray(node)) {
+    const acc2 = { hasControl: false, unknowable: false };
+    for (const child of node) {
+      const r = scanLabelSubtree(child);
+      acc2.hasControl ||= r.hasControl;
+      acc2.unknowable ||= r.unknowable;
+    }
+    return acc2;
+  }
+  if (!node || typeof node !== "object") return { hasControl: false, unknowable: false };
+  if (node.type === "SnippetBlock") return { hasControl: false, unknowable: false };
+  if (node.type === "ExpressionTag" || node.type === "RenderTag" || node.type === "HtmlTag" || COMPONENT_LIKE_TYPES.has(node.type)) {
+    return { hasControl: false, unknowable: true };
+  }
+  if (isLabelableDescendant(node)) return { hasControl: true, unknowable: false };
+  const acc = { hasControl: false, unknowable: false };
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) {
+      const r = scanLabelSubtree(node[key]);
+      acc.hasControl ||= r.hasControl;
+      acc.unknowable ||= r.unknowable;
+    }
+  }
+  return acc;
+}
+function collectUnassociatedLabels(node, source, acc) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectUnassociatedLabels(child, source, acc);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "RegularElement" && node.name === "label" && Array.isArray(node.attributes)) {
+    const hasFor = findAttr(node.attributes, "for") !== void 0;
+    const hasSpread = node.attributes.some((a) => a?.type === "SpreadAttribute");
+    if (!hasFor && !hasSpread) {
+      const scan = scanLabelSubtree(node);
+      if (!scan.hasControl && !scan.unknowable) {
+        acc.push({ line: lineOf(source, node.start) });
+      }
+    }
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectUnassociatedLabels(node[key], source, acc);
+  }
+}
+var BULLET_TEXT_RE = /^[•・·\-*]\s/;
+function collectBulletTexts(node, source, acc, insideLi) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectBulletTexts(child, source, acc, insideLi);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "Text") {
+    const trimmed = String(node.data ?? "").trim();
+    if (!insideLi && BULLET_TEXT_RE.test(trimmed)) {
+      acc.push({ line: lineOf(source, node.start), char: trimmed[0] });
+    }
+    return;
+  }
+  if (node.type === "SnippetBlock") return;
+  const nowInsideLi = insideLi || node.type === "RegularElement" && node.name === "li";
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectBulletTexts(node[key], source, acc, nowInsideLi);
+  }
+}
+function selectNeedsPlaceholder(attributes) {
+  const requiredAttr = findAttr(attributes, "required");
+  if (!requiredAttr || attrValueOf(requiredAttr) === "dynamic") return false;
+  if (findAttr(attributes, "multiple")) return false;
+  const sizeAttr = findAttr(attributes, "size");
+  if (sizeAttr) {
+    if (attrValueOf(sizeAttr) === "dynamic") return false;
+    const size = Number(attrText(attributes, "size"));
+    if (!(Number.isFinite(size) && size <= 1)) return false;
+  }
+  return true;
+}
+function firstSignificantChild(nodes) {
+  for (const child of nodes ?? []) {
+    if (!child) continue;
+    if (child.type === "Comment") continue;
+    if (child.type === "Text" && !String(child.data ?? "").trim()) continue;
+    return child;
+  }
+  return void 0;
+}
+function isPlaceholderOption(option) {
+  const attributes = option.attributes ?? [];
+  if (findAttr(attributes, "value")) {
+    const literal = attrText(attributes, "value");
+    return literal === void 0 || literal === "";
+  }
+  return textFromNodes(option.fragment?.nodes ?? []) === void 0;
+}
+function collectSelectsMissingPlaceholder(node, source, acc) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectSelectsMissingPlaceholder(child, source, acc);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "RegularElement" && node.name === "select" && Array.isArray(node.attributes)) {
+    const hasSpread = node.attributes.some((a) => a?.type === "SpreadAttribute");
+    if (!hasSpread && selectNeedsPlaceholder(node.attributes)) {
+      const first = firstSignificantChild(node.fragment?.nodes);
+      if (!first) {
+        acc.push({ line: lineOf(source, node.start) });
+      } else if (first.type === "RegularElement" && first.name === "option") {
+        const firstHasSpread = (first.attributes ?? []).some((a) => a?.type === "SpreadAttribute");
+        if (!firstHasSpread && !isPlaceholderOption(first)) acc.push({ line: lineOf(source, node.start) });
+      }
+    }
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectSelectsMissingPlaceholder(node[key], source, acc);
+  }
+}
+var MACHINE_READABLE_TIME = [
+  /^\d{4}(-\d{2}){0,2}$/,
+  /^\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/,
+  /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/,
+  /^\d{2}-\d{2}$/,
+  /^P(?=\d|T)/i
+];
+function collectTimesMissingDatetime(node, source, acc) {
+  if (Array.isArray(node)) {
+    for (const child of node) collectTimesMissingDatetime(child, source, acc);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node.type === "RegularElement" && node.name === "time" && findAttr(node.attributes ?? [], "datetime") === void 0 && !(node.attributes ?? []).some((a) => a?.type === "SpreadAttribute")) {
+    const nodes = node.fragment?.nodes ?? [];
+    if (nodes.length > 0 && nodes.every((n) => n?.type === "Text")) {
+      const text = nodes.map((n) => String(n.data ?? "")).join("");
+      const trimmed = text.trim();
+      if (trimmed.length > 0 && !MACHINE_READABLE_TIME.some((re) => re.test(trimmed))) {
+        acc.push({ line: lineOf(source, node.start), text: trimmed });
+      }
+    }
+  }
+  for (const key of CHILD_NODE_KEYS) {
+    if (key in node) collectTimesMissingDatetime(node[key], source, acc);
+  }
+}
 function collectHrefLinks(node, source, acc) {
   if (Array.isArray(node)) {
     for (const child of node) collectHrefLinks(child, source, acc);
@@ -1336,6 +1757,20 @@ function parseComponentFacts(source, filename) {
   collectSecurityFacts(ast.fragment ?? ast, source, htmlTags, javascriptUrls);
   const checkableBindValues = [];
   collectCheckableBindValues(ast.fragment ?? ast, source, checkableBindValues);
+  const ariaElements = [];
+  collectAriaElements(ast.fragment ?? ast, source, ariaElements);
+  const interactiveNestings = [];
+  collectInteractiveNestings(ast.fragment ?? ast, source, interactiveNestings, []);
+  const unnamedInteractive = [];
+  collectUnnamedInteractive(ast.fragment ?? ast, source, unnamedInteractive);
+  const unassociatedLabels = [];
+  collectUnassociatedLabels(ast.fragment ?? ast, source, unassociatedLabels);
+  const bulletTexts = [];
+  collectBulletTexts(ast.fragment ?? ast, source, bulletTexts, false);
+  const selectsMissingPlaceholder = [];
+  collectSelectsMissingPlaceholder(ast.fragment ?? ast, source, selectsMissingPlaceholder);
+  const timesMissingDatetime = [];
+  collectTimesMissingDatetime(ast.fragment ?? ast, source, timesMissingDatetime);
   const basePathLinks = [];
   collectHrefLinks(ast.fragment ?? ast, source, basePathLinks);
   const gotoPrograms = [ast.module?.content, ast.instance?.content].filter(Boolean);
@@ -1538,7 +1973,14 @@ function parseComponentFacts(source, filename) {
     browserGlobalRefs,
     moduleStateDecls: [],
     suppressions,
-    commentLinks: collectCommentLinks(source)
+    commentLinks: collectCommentLinks(source),
+    ariaElements,
+    interactiveNestings,
+    unnamedInteractive,
+    unassociatedLabels,
+    bulletTexts,
+    selectsMissingPlaceholder,
+    timesMissingDatetime
   };
 }
 
@@ -2408,10 +2850,10 @@ function findKitPathsBaseInViteConfig(source) {
 }
 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;
+    const result3 = findKitPathsBaseInViteConfig(viteConfig.source);
+    if (result3.kind === "unresolvable") return void 0;
+    if (result3.kind === "resolved") {
+      return result3.base ? { ...result3.base, file: viteConfig.file } : void 0;
     }
   }
   if (!svelteConfig) return void 0;
@@ -3047,9 +3489,9 @@ function formatFailedRuleWarning(f) {
   return `rule ${f.id} failed and was skipped: ${f.message.split("\n")[0]}`;
 }
 function applyRuleSeverities(results, config) {
-  return results.map((result) => {
-    const severity = settingSeverity(config.rules[result.id]);
-    return severity !== void 0 && severity !== "off" ? { ...result, severity } : result;
+  return results.map((result3) => {
+    const severity = settingSeverity(config.rules[result3.id]);
+    return severity !== void 0 && severity !== "off" ? { ...result3, severity } : result3;
   });
 }
 function routeGlobToRegExp(pattern) {
@@ -3076,15 +3518,15 @@ function applyOverrides(results, config) {
   const compiled = compileOverrides(config);
   if (compiled.length === 0) return results;
   const out = [];
-  for (const result of results) {
+  for (const result3 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 (!overrideMatches(o, { route: result3.route, file: result3.location })) continue;
+      const sev = settingSeverity(o.rules[result3.id]) ?? settingSeverity(o.rules[result3.category ?? "seo"]);
       if (sev !== void 0) severity = sev;
     }
-    if (severity === void 0) out.push(result);
-    else if (severity !== "off") out.push({ ...result, severity });
+    if (severity === void 0) out.push(result3);
+    else if (severity !== "off") out.push({ ...result3, severity });
   }
   return out;
 }
@@ -3922,7 +4364,7 @@ function lengthRule(opts) {
         const o = resolveRuleOptions(opts.id, spec, ctx.config, { route: head.route, file: location }, compiled);
         const min = intOption(o, "min", opts.min);
         const max = intOption(o, "max", opts.max);
-        const recommendation10 = typeof opts.recommendation === "function" ? opts.recommendation(o) : opts.recommendation;
+        const recommendation12 = typeof opts.recommendation === "function" ? opts.recommendation(o) : opts.recommendation;
         const len = visibleLength(tag.text);
         let problem;
         if (len < min) problem = `${opts.noun} is too short (${len} chars; aim for ${min}\u2013${max})`;
@@ -3936,7 +4378,7 @@ function lengthRule(opts) {
             route: head.route,
             location,
             message: problem,
-            recommendation: recommendation10,
+            recommendation: recommendation12,
             docsUrl: docsUrl12
           } : {
             id: opts.id,
@@ -3950,7 +4392,7 @@ function lengthRule(opts) {
             // it to also apply `severity: 'off'`.
             location,
             message: opts.label,
-            recommendation: recommendation10,
+            recommendation: recommendation12,
             docsUrl: docsUrl12
           }
         );
@@ -4304,7 +4746,7 @@ function fileRule(spec) {
       for (const f of spec.facts(ctx) ?? []) {
         const o = resolveRuleOptions(spec.id, spec.options, ctx.config, { route: f.file, file: f.file }, compiled);
         if (!spec.applies(f, o, ctx)) continue;
-        const recommendation10 = typeof spec.recommendation === "function" ? spec.recommendation(o) : spec.recommendation;
+        const recommendation12 = typeof spec.recommendation === "function" ? spec.recommendation(o) : spec.recommendation;
         const bad = spec.bad(f, o, ctx).filter((b) => !(b.line > 0 && isSuppressed(f.suppressions, spec.id, b.line)));
         if (bad.length === 0) {
           out.push({
@@ -4315,7 +4757,7 @@ function fileRule(spec) {
             route: f.file,
             location: f.file,
             message: spec.label,
-            recommendation: recommendation10,
+            recommendation: recommendation12,
             docsUrl: docsUrl12
           });
           continue;
@@ -4330,7 +4772,7 @@ function fileRule(spec) {
             location: f.file,
             ...b.line > 0 ? { line: b.line } : {},
             message: b.message,
-            recommendation: recommendation10,
+            recommendation: recommendation12,
             docsUrl: docsUrl12,
             ...spec.fix ? { fix: { ...spec.fix } } : {}
           });
@@ -5704,7 +6146,7 @@ var architectureReservedNamePlacement = {
       const inCapUnits = Object.hasOwn(capUnits, name);
       const inAnyUnits = Object.hasOwn(anyUnits, name);
       if (!inPlacements && !inCapUnits && !inAnyUnits) continue;
-      const emptyValue = (present3, value) => present3 && globsOf(value ?? "").length === 0;
+      const emptyValue = (present4, value) => present4 && globsOf(value ?? "").length === 0;
       if (emptyValue(inPlacements, placements[name]) || emptyValue(inCapUnits, capUnits[name]) || emptyValue(inAnyUnits, anyUnits[name])) {
         continue;
       }
@@ -5821,9 +6263,9 @@ 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;
+  const result3 = routeEntryImports(c, ctx);
+  routeEntryImportsCache.set(c, { aliases: ctx.project.kitAliases, result: result3 });
+  return result3;
 }
 var architectureRouteComponentImport = componentRule({
   id: ID8,
@@ -6052,6 +6494,386 @@ var performanceStateRaw = componentRule({
   }))
 });
 
+// src/rules/a11y/aria-data.ts
+import { roles, aria } from "aria-query";
+function isKnownRole(role) {
+  return roles.has(role);
+}
+function isAbstractRole(role) {
+  return roles.get(role)?.abstract === true;
+}
+function isKnownAriaAttribute(name) {
+  return aria.has(name);
+}
+function requiredAriaProps(role) {
+  const def = roles.get(role);
+  return def ? Object.keys(def.requiredProps) : [];
+}
+function ariaValueKind(name) {
+  const def = aria.get(name);
+  if (!def) return void 0;
+  return { type: def.type, ...def.values ? { values: def.values.map(String) } : {} };
+}
+
+// src/rules/a11y/invalid-role.ts
+var a11yInvalidRole = componentRule({
+  id: "a11y/invalid-role",
+  title: "Invalid ARIA role",
+  category: "a11y",
+  label: "ARIA roles",
+  rationale: "A role that does not exist in WAI-ARIA (or is abstract, reserved for the spec itself) is ignored or misread by assistive technology, silently breaking the element\u2019s announced semantics.",
+  recommendation: "Use a concrete WAI-ARIA role; abstract roles and typos are ignored by assistive technology.",
+  applies: (c) => (c.ariaElements ?? []).some((e) => e.role?.literal !== void 0),
+  bad: (c) => (c.ariaElements ?? []).flatMap((e) => {
+    const literal = e.role?.literal;
+    if (literal === void 0) return [];
+    const tokens = splitTokens(literal);
+    const badTokens = tokens.filter((t) => !isKnownRole(t) || isAbstractRole(t));
+    if (badTokens.length === 0) return [];
+    return [
+      {
+        line: e.line,
+        message: `role="${literal}" on <${e.tag}> is ${isAbstractRole(badTokens[0]) ? "an abstract role" : "not a WAI-ARIA role"}`
+      }
+    ];
+  })
+});
+
+// src/rules/a11y/unknown-aria-attribute.ts
+var a11yUnknownAriaAttribute = componentRule({
+  id: "a11y/unknown-aria-attribute",
+  title: "Unknown ARIA attribute",
+  category: "a11y",
+  label: "Known ARIA attributes",
+  rationale: "An `aria-*` name that does not exist in WAI-ARIA is not recognized by assistive technology, so the attribute is silently ignored instead of doing what the author intended.",
+  recommendation: "Use a spec-defined `aria-*` attribute; unknown names are ignored by assistive technology.",
+  applies: (c) => (c.ariaElements ?? []).some((e) => e.aria.length > 0),
+  bad: (c) => (c.ariaElements ?? []).flatMap(
+    (e) => e.aria.filter((a) => !isKnownAriaAttribute(a.name)).map((a) => ({ line: a.line, message: `\`${a.name}\` is not a WAI-ARIA attribute` }))
+  )
+});
+
+// src/rules/a11y/required-aria-props.ts
+var HOST_SUPPLIED = {
+  "aria-checked": (e) => e.tag === "input" && (e.inputType === "checkbox" || e.inputType === "radio"),
+  "aria-selected": (e) => e.tag === "option",
+  "aria-level": (e) => /^h[1-6]$/.test(e.tag),
+  "aria-valuenow": (e) => e.tag === "input" && e.inputType === "range" || e.tag === "progress" || e.tag === "meter"
+};
+var a11yRequiredAriaProps = componentRule({
+  id: "a11y/required-aria-props",
+  title: "Missing required ARIA props",
+  category: "a11y",
+  label: "Required ARIA props",
+  rationale: 'Some WAI-ARIA roles are unusable to assistive technology without their required state/property attributes \u2014 a role="checkbox" with no way to know checked/unchecked announces a control with no discoverable state.',
+  recommendation: "Add the role\u2019s required `aria-*` attribute(s), or rely on native host semantics that already supply them.",
+  applies: (c) => (c.ariaElements ?? []).some((e) => e.role?.literal !== void 0 && !e.role.literal.includes(" ")),
+  bad: (c) => (c.ariaElements ?? []).flatMap((e) => {
+    if (e.hasSpread) return [];
+    const literal = e.role?.literal;
+    if (literal === void 0 || literal.includes(" ")) return [];
+    const required = requiredAriaProps(literal);
+    if (required.length === 0) return [];
+    const present4 = new Set(e.aria.map((a) => a.name));
+    const missing = required.filter((p) => !present4.has(p) && !HOST_SUPPLIED[p]?.(e));
+    if (missing.length === 0) return [];
+    return [{ line: e.line, message: `role="${literal}" on <${e.tag}> is missing required ${missing.join(", ")}` }];
+  })
+});
+
+// src/rules/a11y/invalid-aria-value.ts
+function isValid(type, values, literal) {
+  switch (type) {
+    case "boolean":
+      return literal === "true" || literal === "false";
+    case "tristate":
+      return literal === "true" || literal === "false" || literal === "mixed";
+    case "token":
+      return (values ?? []).includes(literal);
+    case "tokenlist":
+      return splitTokens(literal).every((t) => (values ?? []).includes(t));
+    case "integer":
+      return /^-?\d+$/.test(literal);
+    case "number":
+      return literal.trim() !== "" && Number.isFinite(Number(literal));
+    default:
+      return true;
+  }
+}
+var a11yInvalidAriaValue = componentRule({
+  id: "a11y/invalid-aria-value",
+  title: "Invalid ARIA attribute value",
+  category: "a11y",
+  label: "ARIA attribute values",
+  rationale: "An `aria-*` attribute whose value does not match its spec-defined type (e.g. a boolean given a non-`true`/`false` literal) is misread or ignored by assistive technology.",
+  recommendation: "Use a value matching the attribute\u2019s WAI-ARIA type \u2014 see the spec for allowed values.",
+  applies: (c) => (c.ariaElements ?? []).some((e) => e.aria.some((a) => a.literal !== void 0)),
+  bad: (c) => (c.ariaElements ?? []).flatMap(
+    (e) => e.aria.flatMap((a) => {
+      if (a.literal === void 0) return [];
+      const kind = ariaValueKind(a.name);
+      if (kind === void 0) return [];
+      if (isValid(kind.type, kind.values, a.literal)) return [];
+      return [{ line: a.line, message: `\`${a.name}="${a.literal}"\` is not a valid ${kind.type} value` }];
+    })
+  )
+});
+
+// src/rules/a11y/interactive-nesting.ts
+var a11yInteractiveNesting = componentRule({
+  id: "a11y/interactive-nesting",
+  title: "Interactive element nested in an interactive element",
+  category: "a11y",
+  label: "Interactive nesting",
+  rationale: "A control nested inside another interactive element is unreachable or misannounced by keyboard and assistive technology, and violates the HTML content model.",
+  recommendation: "Restructure the markup so each interactive control is a sibling, not a descendant, of another.",
+  applies: (c) => (c.interactiveNestings ?? []).length > 0,
+  bad: (c) => (c.interactiveNestings ?? []).map((f) => ({
+    line: f.line,
+    message: `<${f.descendantTag}> is nested inside interactive <${f.containerTag}>`
+  }))
+});
+
+// src/rules/a11y/accessible-name.ts
+var a11yAccessibleName = componentRule({
+  id: "a11y/accessible-name",
+  title: "Interactive element has no accessible name",
+  category: "a11y",
+  label: "Accessible names",
+  rationale: 'A button, link, or image button with no accessible name is announced by assistive technology as its bare role ("button", "link") with nothing to distinguish it from any other control on the page.',
+  recommendation: "Give the element visible text, an aria-label/aria-labelledby/title, or an alt on its icon image.",
+  applies: (c) => (c.unnamedInteractive ?? []).length > 0,
+  bad: (c) => (c.unnamedInteractive ?? []).map((f) => ({ line: f.line, message: `<${f.tag}> has no accessible name` }))
+});
+
+// src/rules/a11y/label-has-control.ts
+var a11yLabelHasControl = componentRule({
+  id: "a11y/label-has-control",
+  title: "<label> has no associated control",
+  category: "a11y",
+  label: "Label associations",
+  rationale: "A `<label>` with no associated control is announced by assistive technology as plain text \u2014 clicking or tapping it does not focus the field, and a screen reader gives no relationship between the label and its control.",
+  recommendation: "Add a `for` attribute pointing at the control's `id`, or wrap the control inside the `<label>`.",
+  applies: (c) => (c.unassociatedLabels ?? []).length > 0,
+  bad: (c) => (c.unassociatedLabels ?? []).map((f) => ({ line: f.line, message: "<label> has no associated control" }))
+});
+
+// src/rules/a11y/use-list.ts
+var a11yUseList = componentRule({
+  id: "a11y/use-list",
+  title: "Bullet text should be a list",
+  category: "a11y",
+  severity: "info",
+  label: "List structure",
+  rationale: "A screen reader announces a real `<ul>`/`<ol>` as a list \u2014 item count, position, and boundaries. A bullet character typed into plain text carries none of that, so the visual structure is lost on assistive technology.",
+  recommendation: "Use a `<ul>`/`<ol>` with `<li>` items instead of a bullet character in plain text.",
+  applies: (c) => (c.bulletTexts ?? []).length > 0,
+  bad: (c) => (c.bulletTexts ?? []).map((b) => ({
+    line: b.line,
+    message: `Text starts with a bullet character ('${b.char}') \u2014 use a list element`
+  }))
+});
+
+// src/rules/a11y/placeholder-label-option.ts
+var a11yPlaceholderLabelOption = componentRule({
+  id: "a11y/placeholder-label-option",
+  title: "Missing placeholder label option",
+  category: "a11y",
+  label: "Select placeholder",
+  rationale: "A required, single-selection `<select>` initially shows its first option as the chosen value \u2014 if that option is not an empty placeholder, users can submit the form without ever having made a real choice, and assistive technology announces a value as already selected.",
+  recommendation: 'Make the first `<option>` a placeholder: an empty `value=""`, or no `value` attribute and no text.',
+  applies: (c) => (c.selectsMissingPlaceholder ?? []).length > 0,
+  bad: (c) => (c.selectsMissingPlaceholder ?? []).map((f) => ({
+    line: f.line,
+    message: "<select required> is missing a placeholder label option"
+  }))
+});
+
+// src/rules/a11y/require-datetime.ts
+var a11yRequireDatetime = componentRule({
+  id: "a11y/require-datetime",
+  title: "Missing datetime attribute",
+  category: "a11y",
+  label: "Time elements",
+  rationale: 'A `<time>` element with no `datetime` attribute exposes its text content as the machine-readable value \u2014 text like "last Tuesday" cannot be parsed by assistive technology or user agents into an actual date, so its meaning is lost to anything that isn\'t a sighted reader.',
+  recommendation: 'Add a `datetime` attribute with a machine-readable value, e.g. `<time datetime="2026-08-14">Aug 14</time>`.',
+  applies: (c) => (c.timesMissingDatetime ?? []).length > 0,
+  bad: (c) => (c.timesMissingDatetime ?? []).map((f) => ({
+    line: f.line,
+    message: `<time> content "${f.text}" is not machine-readable and has no datetime attribute`
+  }))
+});
+
+// src/rules/a11y/doctype.ts
+var present3 = { presence: "own", value: "static" };
+var absent3 = { presence: "none", value: "absent" };
+var FIX8 = {
+  description: "Add <!doctype html> as the first line of src/app.html.",
+  snippet: "<!doctype html>",
+  lang: "html"
+};
+var a11yDoctype = {
+  id: "a11y/doctype",
+  title: "Doctype",
+  category: "a11y",
+  severity: "warning",
+  scope: "project",
+  rationale: "Without a doctype browsers render in quirks mode, breaking CSS and accessibility tree behavior.",
+  fix: FIX8,
+  async check(ctx) {
+    const { appHtmlDoctype } = ctx.project;
+    if (appHtmlDoctype === void 0) return [];
+    return [
+      {
+        id: "a11y/doctype",
+        category: "a11y",
+        severity: "warning",
+        detection: appHtmlDoctype ? present3 : absent3,
+        location: "src/app.html",
+        message: appHtmlDoctype ? "<!doctype html>" : "src/app.html is missing <!doctype html>",
+        recommendation: "Add <!doctype html> as the first line of src/app.html.",
+        docsUrl: docsUrlFor("a11y/doctype"),
+        fix: { ...FIX8 }
+      }
+    ];
+  }
+};
+
+// src/rules/a11y/route-rule.ts
+function resultFactory(id, recommendation12) {
+  const docsUrl12 = docsUrlFor(id);
+  return (route, detection, occ, message) => ({
+    id,
+    category: "a11y",
+    severity: "warning",
+    detection,
+    route,
+    location: occ.file,
+    ...occ.line > 0 ? { line: occ.line } : {},
+    message,
+    recommendation: recommendation12,
+    docsUrl: docsUrl12
+  });
+}
+function surplusRule(spec) {
+  const result3 = resultFactory(spec.id, spec.recommendation);
+  return {
+    id: spec.id,
+    title: spec.title,
+    category: "a11y",
+    severity: "warning",
+    scope: "route",
+    rationale: spec.rationale,
+    async check(ctx) {
+      const out = [];
+      for (const route of ctx.a11y ?? []) {
+        let first;
+        let surplus = false;
+        for (const [key, reps] of spec.map(route)) {
+          first ??= reps[0];
+          for (let i = 1; i < reps.length; i++) {
+            surplus = true;
+            out.push(result3(route.route, PENALIZED, reps[i], spec.message(key, i, reps.length)));
+          }
+        }
+        if (first && !surplus) out.push(result3(route.route, PASS, { file: first.file, line: 0 }, spec.passMessage));
+      }
+      return out;
+    }
+  };
+}
+
+// src/rules/a11y/duplicate-landmark.ts
+var KINDS = ["main", "banner", "contentinfo"];
+var a11yDuplicateLandmark = surplusRule({
+  id: "a11y/duplicate-landmark",
+  title: "Duplicate landmark",
+  rationale: "Assistive tech users jump between landmarks to skip repeated content; more than one main, banner, or contentinfo per page leaves them guessing which one is the real one.",
+  recommendation: "A route should have at most one main, banner, and contentinfo landmark.",
+  map: (route) => KINDS.flatMap((kind) => {
+    const reps = route.landmarks[kind];
+    return reps?.length ? [[kind, reps]] : [];
+  }),
+  message: (kind, i, n) => `Duplicate ${kind} landmark (${i + 1} of ${n})`,
+  passMessage: "No duplicate landmarks"
+});
+
+// src/rules/a11y/top-level-landmark.ts
+var recommendation10 = "A banner, main, complementary, or contentinfo landmark should not be nested inside another landmark.";
+var result = resultFactory("a11y/top-level-landmark", recommendation10);
+var KINDS2 = ["main", "banner", "complementary", "contentinfo"];
+var a11yTopLevelLandmark = {
+  id: "a11y/top-level-landmark",
+  title: "Top-level landmark",
+  category: "a11y",
+  severity: "warning",
+  scope: "route",
+  rationale: "Assistive tech landmark navigation expects banner/main/complementary/contentinfo at the top level; nesting one inside another hides it from that navigation.",
+  async check(ctx) {
+    const out = [];
+    for (const route of ctx.a11y ?? []) {
+      for (const nested of route.nestedLandmarks) {
+        out.push(result(route.route, PENALIZED, nested, `${nested.kind} landmark is nested inside ${nested.within}`));
+      }
+      if (route.nestedLandmarks.length === 0) {
+        const first = KINDS2.map((kind) => route.landmarks[kind]?.[0]).find((rep) => rep !== void 0);
+        if (first) out.push(result(route.route, PASS, { file: first.file, line: 0 }, "No nested landmarks"));
+      }
+    }
+    return out;
+  }
+};
+
+// src/rules/a11y/id-duplication.ts
+var a11yIdDuplication = surplusRule({
+  id: "a11y/id-duplication",
+  title: "Id duplication",
+  rationale: "A duplicate id breaks label/aria-labelledby associations and in-page fragment navigation: assistive tech resolves the first match, which may not be the one the author intended.",
+  recommendation: "Every id in a route should be unique.",
+  // Entries ordered by each id's first representative (file, then line): content-derived and
+  // stable — a Record's own-key enumeration would pull integer-like ids ("1") to the front.
+  map: (route) => Object.entries(route.ids).sort(([, a], [, b]) => a[0].file.localeCompare(b[0].file) || a[0].line - b[0].line),
+  message: (id) => `Duplicate id "${id}"`,
+  passMessage: "No duplicate ids"
+});
+
+// src/rules/a11y/no-missing-id-ref.ts
+var recommendation11 = "An id reference should point to an id that exists somewhere in the composed route.";
+var result2 = resultFactory("a11y/no-missing-id-ref", recommendation11);
+var a11yNoMissingIdRef = {
+  id: "a11y/no-missing-id-ref",
+  title: "No missing id ref",
+  category: "a11y",
+  severity: "warning",
+  scope: "route",
+  rationale: 'A `for`/`aria-labelledby`/`aria-describedby`/`aria-controls`/`aria-activedescendant`/`href="#\u2026"` pointing at an id that does not exist leaves assistive tech with a broken association or the browser with a dead in-page link.',
+  async check(ctx) {
+    const out = [];
+    for (const route of ctx.a11y ?? []) {
+      if (!route.fullyResolved || route.idRefs.length === 0) continue;
+      const candidates = new Set(route.idCandidates);
+      let hasMissing = false;
+      for (const ref of route.idRefs) {
+        if (candidates.has(ref.id)) continue;
+        hasMissing = true;
+        out.push(
+          result2(
+            route.route,
+            PENALIZED,
+            ref,
+            `${ref.attr}="${ref.attr === "href" ? "#" : ""}${ref.id}" references a missing id`
+          )
+        );
+      }
+      if (!hasMissing) {
+        const first = route.idRefs[0];
+        out.push(result2(route.route, PASS, { file: first.file, line: 0 }, "No missing id references"));
+      }
+    }
+    return out;
+  }
+};
+
 // src/rules/index.ts
 var allRules = [
   seoTitlePresence,
@@ -6126,7 +6948,22 @@ var allRules = [
   performanceMinifyDisabled,
   performanceLoadWaterfall,
   performanceSequentialAwaits,
-  performanceStateRaw
+  performanceStateRaw,
+  a11yInvalidRole,
+  a11yUnknownAriaAttribute,
+  a11yRequiredAriaProps,
+  a11yInvalidAriaValue,
+  a11yInteractiveNesting,
+  a11yAccessibleName,
+  a11yLabelHasControl,
+  a11yUseList,
+  a11yPlaceholderLabelOption,
+  a11yRequireDatetime,
+  a11yDoctype,
+  a11yDuplicateLandmark,
+  a11yTopLevelLandmark,
+  a11yIdDuplication,
+  a11yNoMissingIdRef
 ];
 function optionInfos(spec) {
   return Object.entries(spec).map(([name, s]) => ({
@@ -6153,21 +6990,21 @@ function explainRule(id) {
 }
 
 // src/summary.ts
-function classify(result, config) {
-  if (isPenalized(result.detection, config.treatDynamicAs)) return "fail";
-  if (result.detection.value === "dynamic") return "dynamic";
+function classify(result3, config) {
+  if (isPenalized(result3.detection, config.treatDynamicAs)) return "fail";
+  if (result3.detection.value === "dynamic") return "dynamic";
   return "pass";
 }
-function effectiveSeverity(result, config) {
-  if (result.detection.value === "dynamic" && config.treatDynamicAs === "warn") return "warning";
-  return result.severity;
+function effectiveSeverity(result3, config) {
+  if (result3.detection.value === "dynamic" && config.treatDynamicAs === "warn") return "warning";
+  return result3.severity;
 }
 function summarize(results, config) {
   const summary = { critical: 0, warning: 0, info: 0, passed: 0, dynamic: 0 };
-  for (const result of results) {
-    const cls = classify(result, config);
+  for (const result3 of results) {
+    const cls = classify(result3, config);
     if (cls === "fail") {
-      summary[effectiveSeverity(result, config)] += 1;
+      summary[effectiveSeverity(result3, config)] += 1;
     } else {
       summary.passed += 1;
       if (cls === "dynamic") summary.dynamic += 1;
@@ -6341,7 +7178,16 @@ var SEVERITY_TITLE = {
   warning: "Warnings",
   info: "Info"
 };
-var categoryLabel = (c) => c === "seo" ? "SEO" : c.charAt(0).toUpperCase() + c.slice(1);
+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();
@@ -6396,7 +7242,7 @@ function formatConsoleReport(results, config, options = {}) {
   const p = options.palette ?? noColorPalette;
   const summary = summarize(results, config);
   const { health, categories: byCat } = computeHealth(results, config);
-  const present3 = CATEGORIES.filter((c) => byCat[c] !== void 0);
+  const present4 = CATEGORY_ORDER.filter((c) => byCat[c] !== void 0);
   const lines = [];
   if (!options.omitHeader) {
     lines.push(
@@ -6405,7 +7251,7 @@ function formatConsoleReport(results, config, options = {}) {
       `${p.bold("Health:")} ${scoreColor(p, health)(`${health}/100`)}`
     );
   }
-  for (const c of present3) {
+  for (const c of present4) {
     lines.push(scoreLine(p, categoryLabel(c), byCat[c]));
   }
   lines.push("");
@@ -6465,17 +7311,17 @@ function formatConsoleReport(results, config, options = {}) {
 }
 
 // src/reporter/json.ts
-function issueOf(result) {
+function issueOf(result3) {
   return {
-    id: result.id,
-    category: result.category ?? "seo",
-    title: result.message,
-    detection: result.detection,
-    location: result.location,
-    ...result.line !== void 0 ? { line: result.line } : {},
-    recommendation: result.recommendation,
-    ...result.docsUrl ? { docsUrl: result.docsUrl } : {},
-    ...result.fix ? { fix: result.fix } : {}
+    id: result3.id,
+    category: result3.category ?? "seo",
+    title: result3.message,
+    detection: result3.detection,
+    location: result3.location,
+    ...result3.line !== void 0 ? { line: result3.line } : {},
+    recommendation: result3.recommendation,
+    ...result3.docsUrl ? { docsUrl: result3.docsUrl } : {},
+    ...result3.fix ? { fix: result3.fix } : {}
   };
 }
 function ruleEvidence(results, config, ruleIds) {
@@ -6543,8 +7389,8 @@ function severityToSarifLevel(sev) {
 function severityToGithubLevel(sev) {
   return sev === "critical" ? "error" : sev === "warning" ? "warning" : "notice";
 }
-function messageText(result) {
-  return result.recommendation ? `${result.message} ${result.recommendation}` : result.message;
+function messageText(result3) {
+  return result3.recommendation ? `${result3.message} ${result3.recommendation}` : result3.message;
 }
 var RULE_META = new Map(
   allRules.map((r) => [r.id, { title: r.title, severity: r.severity, docsUrl: docsUrlFor(r.id) }])
@@ -6614,7 +7460,7 @@ function formatSarifReport(results, config, meta) {
         defaultConfiguration: { level: severityToSarifLevel(m?.severity ?? r.severity) }
       });
     }
-    const result = {
+    const result3 = {
       ruleId: r.id,
       ruleIndex: ruleIndex.get(r.id),
       level: severityToSarifLevel(effectiveSeverity(r, config)),
@@ -6624,7 +7470,7 @@ function formatSarifReport(results, config, meta) {
       }
     };
     if (r.location) {
-      result.locations = [
+      result3.locations = [
         {
           physicalLocation: {
             artifactLocation: { uri: r.location },
@@ -6633,7 +7479,7 @@ function formatSarifReport(results, config, meta) {
         }
       ];
     }
-    return result;
+    return result3;
   });
   const log = {
     $schema: "https://json.schemastore.org/sarif-2.1.0.json",
@@ -6899,6 +7745,7 @@ body{background:var(--ground);color:var(--ink);font-family:var(--sans);line-heig
 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
@@ -7245,7 +8092,7 @@ var APP_SCRIPT = `
       }, []);
     };
     var catChips = Object.keys(categories).map(function (cat) {
-      var name = cat === 'seo' ? 'SEO' : cat.charAt(0).toUpperCase() + cat.slice(1);
+      var name = CATEGORY_NAMES[cat] || cat;
       return chip(cat, name);
     });
     return h('div', { class: 'dv-filters', role: 'group', 'aria-label': 'Filter findings' },
@@ -7317,7 +8164,7 @@ var APP_SCRIPT = `
       var c = s.report.categories[cat];
       var band = scoreBand(c.score);
       var weight = s.report.weights[cat];
-      var name = cat === 'seo' ? 'SEO' : cat.charAt(0).toUpperCase() + cat.slice(1);
+      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
@@ -7458,10 +8305,27 @@ export {
   BAND_COLOR,
   CATEGORIES,
   CHILD_NODE_KEYS,
+  IDREF_ATTRS,
+  LANDMARK_ROLES,
   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,
@@ -7501,6 +8365,7 @@ export {
   correctnessServerBrowserGlobal,
   correctnessStalePropDerivation,
   correctnessUnmutatedState,
+  decodeFragmentId,
   defaultConfig,
   defaultProject,
   defineConfig,
@@ -7515,6 +8380,7 @@ export {
   findKitPathsBaseInSvelteConfig,
   findKitPathsBaseInViteConfig,
   findMinifyDisabled,
+  foldOccurrences,
   formatAgentReport,
   formatConsoleReport,
   formatFailedRuleWarning,
@@ -7529,6 +8395,7 @@ export {
   intOption,
   isMentionedAnywhere,
   isPenalized,
+  isTopFragment,
   lineOf,
   linkRule,
   listOption,
@@ -7602,6 +8469,7 @@ export {
   settingOptions,
   settingSeverity,
   shouldSkipRangeCheck,
+  splitTokens,
   summarize,
   terminalSafe,
   textFromNodes,